@deeeed/metamask-harness 0.51.9 → 0.53.0

package/CHANGELOG.md

@@ -2,6 +2,36 @@
 
 ## Unreleased
 
+## 0.53.0 - 2026-09-17
+
+### Added
+
+- `doctor` and `status` print one checkout view, also carried under `view` in their `--json`: the runtime-context fields that keep this checkout off other slots' ports and devices (mobile adds `watcherPort`, `metroPort`, `devServerPort`, `simulator`, `simulatorUdid`; extension adds `devServerPort`), the recipe libraries this machine resolves with their revision and recipe/checklist counts, and the wallet fixture the checkout last applied. Values are an allowlist — no fixture body, key, or phrase is ever rendered.
+- `prepare --clear-metro` passes the flag to its launch step, so the stale-Metro recovery `doctor` teaches is reachable through the sanctioned prepare path. Nothing clears the transform cache on its own; the flag stays an explicit operator decision, and it is refused on extension and core.
+- `status --watch` shows a live read-only view of the task a checkout is working through: slot and device isolation, template and flow, fixture and sandbox readiness, and the checklist with the time each row took and how long the current row has been running. `--task <dir>` selects a task directory instead of the most recently marked one under `temp/tasks/`, and prints the view once without `--watch`. It reads task files only, so watching never probes a device or disturbs the run. Piped output logs one line per change; `--json` emits the view model, one object per change while watching. When nothing is in progress it says `no ongoing task detected` with the reason (finished, silent, or no task yet) and whether the checked-out branch carries the task's ticket, and it keeps waiting for a new task instead of exiting on an old finished one. Rows are grouped by checklist phase.
+
+### Changed
+
+- The base review, which every `review checklist` starts with in any repo and domain, gains a signal-over-noise rule: comments that say why and stay short, no ticket keys or tool mentions in source, no leftover scaffolding, swallowed errors, one-caller abstractions or padded tests and PR text.
+- `task init` no longer requires `--run-mode`. It defaults to `autonomous`; the distinction belongs to a control plane, and an engineer running a skill steers by hand.
+- Every library this machine resolves — engineer config, a sibling checkout, the fetch cache — now reaches recipe, action, and template discovery, not only the ones `RECIPE_LIBRARY_PATH` names. An engineer who never exported the variable sees the same recipes as an orchestrator that injects it. Entries already in the variable keep their precedence and order, the personal library still applies, and nothing is fetched.
+- A runtime-context field overridden from the environment now names the variable that actually supplied the value instead of the canonical one.
+
+### Fixed
+
+- `check diff` runs a changed `<name>.<layer>.test.*` file under `jest.config.<layer>.*` when the repo has one. MetaMask Mobile keeps view and integration tests out of its default Jest config, so a task that changed a view test got "No tests found" and a failed gate.
+- `mm-harness update` and `update --check` no longer report `REGISTRY_UNREACHABLE` inside a checkout whose `.npmrc` sets `offline = true`. The registry lookup and the global install run from a neutral directory, so a project can no longer answer for a global install.
+
+## 0.52.0 - 2026-09-17
+
+### Added
+
+- Export portable runtime proof validation so standalone QA requires executed assertions and rejects passing packages without behavioral proof.
+
+### Changed
+
+- Align tutorials with explicit workflow invocation, static review, recipe-qa scopes and caller-owned publication/cleanup; refresh shared execution-template examples.
+
 ## 0.51.9 - 2026-09-16
 
 ### Changed

package/README.md

@@ -189,6 +189,11 @@ mm-harness run --list
 Shared libraries hold durable actions and composable recipes. Task acceptance
 criteria remain task-local. See [Recipes](docs/RECIPES.md).
 
+Exporting is not required: a library registered with `mm-harness config set
+libraries.<name> <path>`, or checked out beside the product checkout, reaches
+`run`, `actions`, and template discovery too. `mm-harness status` lists what this
+machine resolves, with each location's revision and recipe count.
+
 Teams maintain their library checkouts. Update them before starting a task;
 the harness records local revisions and recipe digests but does not fetch or
 check for upstream updates. Keep the selected library unchanged during a run.
@@ -262,3 +267,17 @@ mm-harness --version
 ```
 
 Unset `MM_HARNESS_BIN` to return to the published installation.
+
+
+### Workflow entry points and completion
+
+Explicitly invoke `mms-recipe-dev`, `mms-recipe-fixbug`, `mms-recipe-qa` or the team's static review skill. `mms-recipe-cook` selects or resumes their shared Markdown checklist. Matching descriptions or changed paths never activates these workflows.
+
+Static Perps review uses a generated source checklist without installing or launching the app harness. `recipe-qa` freezes a PR, range or daily change window and requires runtime smoke plus selected recipe proof. Official release validation uses its named release profile and proof lane.
+
+TASK.md holds the request; CHECKLIST.md is the sole step list. The frozen terminal contract and task-local mark validate completion. Publication, retained sessions and workspace cleanup belong to the caller. Farmslot handles them through its control plane; direct invocation returns the outcome to the engineer. See the [task-directory guide](site/task-dir.html) and [QA tutorial](site/tutorials/v5.html).
+
+
+### Portable runtime proof
+
+`validateRuntimeProof(bundle, smokeTarget)` validates a retained Recipe v1 artifact package, requiring executed behavioral assertions for its declared targets. A passing command or end node alone is insufficient. QA skills use this exported function through their locked harness installation; no gateway, farm profile or run ID is required.

package/dist/checkout-view.js

@@ -0,0 +1,112 @@
+import fs from "node:fs";
+import path from "node:path";
+import { color } from "./cli-color.js";
+import { renderRuntimeContext, runtimeContextSummary } from "./doctor.js";
+import { recipeRuntimeDir } from "./paths.js";
+import {
+  configPath,
+  declaredLibraryPathEnv,
+  discoverLibraries,
+  readConfig
+} from "./review/knowledge.js";
+const NO_LIBRARIES = "none registered. Learn how: docs/RECIPES.md, or run: mm-harness config set libraries.<name> <path>";
+const FIXTURE_REPORT = path.join("prepare", "fixtures.json");
+function collectCheckoutView(target, adapter) {
+  const declared = declaredLibraryPathEnv();
+  const libraries = discoverLibraries({
+    target,
+    config: readConfig(configPath()),
+    ...declared ? { env: { ...process.env, RECIPE_LIBRARY_PATH: declared.value } } : {}
+  }).map((library) => ({
+    name: library.name,
+    root: library.root,
+    source: library.source,
+    revision: library.revision ?? null,
+    recipes: countFiles(library.root, "recipes", ".json"),
+    checklists: countFiles(library.root, "checklists", ".md")
+  }));
+  const fixtures = readFixtureView(target);
+  return {
+    isolation: runtimeContextSummary(target, adapter),
+    libraries,
+    ...fixtures ? { fixtures } : {}
+  };
+}
+function renderCheckoutView(view) {
+  const out = (style, text) => color(style, text, { stream: process.stdout });
+  const lines = [renderRuntimeContext(view.isolation)];
+  if (view.libraries.length === 0) {
+    lines.push(`${out("label", "libraries:")} ${out("dim", NO_LIBRARIES)}`);
+  } else {
+    lines.push(`${out("label", "libraries:")} ${view.libraries.length}`);
+    for (const library of view.libraries) {
+      const pin = library.revision ? `${library.source} ${library.revision}` : library.source;
+      lines.push(
+        `  ${library.name.padEnd(22)} ${out("ok", library.root)}  ${out("accent", `[${pin}]`)} ` + out("dim", `\u2014 ${library.recipes} recipes, ${library.checklists} checklists`)
+      );
+    }
+  }
+  if (view.fixtures) {
+    lines.push(`${out("label", "fixtures:")}`);
+    for (const [key, value] of Object.entries(view.fixtures)) {
+      const isSet = value !== null && value !== "";
+      lines.push(`  ${key.padEnd(22)} ${isSet ? out("ok", String(value)) : out("dim", "(unset)")}`);
+    }
+  }
+  return lines.join("\n");
+}
+function countFiles(root, directory, extension) {
+  const base = path.join(root, directory);
+  if (!isDirectory(base)) return 0;
+  return fs.readdirSync(base, { recursive: true, withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(extension)).length;
+}
+function readFixtureView(target) {
+  const newest = fixtureReports(target).map((file) => ({ file, modified: modifiedAt(file) })).filter((entry) => entry.modified !== void 0).sort((left, right) => right.modified - left.modified)[0];
+  if (!newest) return void 0;
+  let parsed;
+  try {
+    parsed = JSON.parse(fs.readFileSync(newest.file, "utf8"));
+  } catch {
+    return { fixture: null, canonicalFixture: null, status: "unreadable", walletReset: null };
+  }
+  const record = parsed ?? {};
+  const text = (key) => typeof record[key] === "string" ? record[key] : null;
+  return {
+    fixture: text("fixture"),
+    canonicalFixture: text("canonicalFixture"),
+    status: text("status"),
+    walletReset: typeof record.walletReset === "boolean" ? record.walletReset : null
+  };
+}
+function fixtureReports(target) {
+  const reports = [path.join(target, recipeRuntimeDir(), FIXTURE_REPORT)];
+  const tasksRoot = path.join(target, "temp", "tasks");
+  for (const flow of directoryNames(tasksRoot)) {
+    for (const task of directoryNames(path.join(tasksRoot, flow))) {
+      reports.push(path.join(tasksRoot, flow, task, "artifacts", FIXTURE_REPORT));
+    }
+  }
+  return reports;
+}
+function directoryNames(root) {
+  if (!isDirectory(root)) return [];
+  return fs.readdirSync(root, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+}
+function isDirectory(candidate) {
+  try {
+    return fs.statSync(candidate).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function modifiedAt(file) {
+  try {
+    return fs.statSync(file).mtimeMs;
+  } catch {
+    return void 0;
+  }
+}
+export {
+  collectCheckoutView,
+  renderCheckoutView
+};

package/dist/cli-commands.js

@@ -15,7 +15,7 @@ const SPEC = {
     { name: "config", desc: "Per-engineer locations: libraries.<name>, references.<adapter>", args: ["list", "path", "get", "set", "unset"], flags: ["--json"] },
     { name: "tutorial", desc: "Open the visual recipe tutorial", flags: ["--json", "--no-open"] },
     { name: "setup-base", desc: "Bootstrap numbered product checkouts", flags: ["--dir", "--counts", "--only", "--dry-run", "--force", "--json", "--show-config", "--reset-config", "--skip-harness-update"] },
-    { name: "status", aliases: ["health", "home"], desc: "Home status + next commands", flags: ["--json", "--fast"] },
+    { name: "status", aliases: ["health", "home"], desc: "Home status + next commands", flags: ["--json", "--fast", "--watch", "--task"] },
     { name: "ports", desc: "Slot ports and runtime paths", flags: ["--json"] },
     { name: "up", desc: "Decide + run minimum work to reach ready", flags: ["--json", "--dry-run"] },
     { name: "sync", desc: "Refresh harness + canonicalize wallet fixture", flags: ["--json"] },

package/dist/command-contract.js

@@ -112,7 +112,9 @@ const PUBLIC_COMMAND_CONTRACTS = {
     aliases: ["health", "home"],
     options: options(HELP, JSON, TARGET, DEVICE, {
       "--fast": bool(),
-      "--all-devices": bool()
+      "--all-devices": bool(),
+      "--watch": bool(),
+      "--task": value()
     })
   },
   checklist: {
@@ -147,10 +149,11 @@ const PUBLIC_COMMAND_CONTRACTS = {
     minimumPositionals: 2
   },
   prepare: {
-    usage: "mm-harness prepare [--target <checkout>] [--platform mobile|extension|core] [--mobile-platform ios|android] [--artifacts-dir <dir>] [--json]",
+    usage: "mm-harness prepare [--target <checkout>] [--platform mobile|extension|core] [--mobile-platform ios|android] [--clear-metro] [--artifacts-dir <dir>] [--json]",
     options: options(HELP, JSON, TARGET, {
       "--platform": value(["mobile", "extension", "core"]),
       "--mobile-platform": value(["ios", "android"]),
+      "--clear-metro": bool(),
       "--artifacts-dir": value()
     })
   },

package/dist/commands/check.js

@@ -312,17 +312,18 @@ function runToolCheck(input) {
 }
 function runJestChecks(input) {
   if (input.adapter !== "core" || input.files.length === 0) {
-    return [
-      runToolCheck({
-        id: "jest",
-        label: "Changed test files",
+    const groups2 = groupByJestConfig(input.target, input.files);
+    return groups2.map(
+      (group) => runToolCheck({
+        id: groups2.length === 1 || !group.layer ? "jest" : `jest-${safeId(group.layer)}`,
+        label: group.layer ? `Changed ${group.layer} test files` : "Changed test files",
         target: input.target,
         artifactsDir: input.artifactsDir,
-        files: input.files,
+        files: group.files,
         command: executable(input.target, "jest"),
-        args: ["--no-coverage"]
+        args: group.config ? ["--no-coverage", "-c", group.config] : ["--no-coverage"]
       })
-    ];
+    );
   }
   const groups = /* @__PURE__ */ new Map();
   const rootFiles = [];
@@ -367,6 +368,18 @@ function runJestChecks(input) {
   }
   return results;
 }
+function groupByJestConfig(target, files) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const layer = /\.([a-z][a-z0-9-]*)\.test\.[cm]?[jt]sx?$/u.exec(path.basename(file))?.[1];
+    const config = layer ? ["js", "cjs", "mjs", "ts"].map((ext) => `jest.config.${layer}.${ext}`).find((name) => fs.existsSync(path.join(target, name))) : void 0;
+    const key = config ?? "";
+    const group = groups.get(key) ?? { ...config ? { layer, config } : {}, files: [] };
+    group.files.push(file);
+    groups.set(key, group);
+  }
+  return [...groups.values()].sort((a, b) => (a.config ?? "").localeCompare(b.config ?? ""));
+}
 function resolveWorkspace(target, file) {
   const root = path.resolve(target);
   let current = path.dirname(path.resolve(root, file));
@@ -555,5 +568,6 @@ function failEnvelope(input) {
   return exitCode;
 }
 export {
+  groupByJestConfig,
   handleCheck
 };

package/dist/commands/doctor.js

@@ -3,7 +3,8 @@ import { randomUUID } from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
 import { color } from "../cli-color.js";
-import { createDoctorReport, fixtureSummary, renderRuntimeContext, requiredDoctorCheckSummary } from "../doctor.js";
+import { collectCheckoutView, renderCheckoutView } from "../checkout-view.js";
+import { createDoctorReport, fixtureSummary, requiredDoctorCheckSummary } from "../doctor.js";
 import { detectAdapter, resolveRuntimeContextPath } from "../harness.js";
 import { assertAdapter, runnerDir } from "../paths.js";
 import { getAdapterSurface } from "../adapters/surface.js";
@@ -139,6 +140,7 @@ async function handleDoctor({ options }) {
     actionManifestPath,
     mobilePlatform
   );
+  const view = collectCheckoutView(target, adapter);
   const missingRequiredTool = result.checks.find(
     (check) => check.required && check.status === "fail" && check.id.startsWith("device-tool-") && check.userAction
   );
@@ -209,7 +211,7 @@ async function handleDoctor({ options }) {
   )?.userAction ?? `mm-harness doctor --fix --adapter ${adapter} --target ${shellQuote(target)} --json`;
   const doctorError = doctorResult.status === "fail" ? { code: "DOCTOR_CHECKS_FAILED", message: "one or more required doctor checks failed", userAction: doctorUserAction } : void 0;
   const next = doctorError?.userAction ?? discovery.deviceDiscoveryErrors?.[0]?.userAction ?? (runtime?.decision === "ready" ? void 0 : runtime?.nextAction);
-  if (json) console.log(JSON.stringify({ ...doctorResult, ready: runtime?.decision === "ready", runtime, orphanMetros, capture, devices, additionalReachableDevices, ...discovery, ...next ? { next } : {}, ...doctorError ? { error: doctorError } : {} }, null, 2));
+  if (json) console.log(JSON.stringify({ ...doctorResult, ready: runtime?.decision === "ready", runtime, view, orphanMetros, capture, devices, additionalReachableDevices, ...discovery, ...next ? { next } : {}, ...doctorError ? { error: doctorError } : {} }, null, 2));
   else {
     const out = (style, text) => color(style, text, { stream: process.stdout });
     const stateStyle = (value, good) => value === good ? "ok" : "warn";
@@ -230,7 +232,7 @@ async function handleDoctor({ options }) {
     } else if (runtimeProbeError) {
       console.log(`${out("err", "runtime probe failed:")} ${out("dim", runtimeProbeError)}`);
     }
-    console.log(renderRuntimeContext(result.runtimeContext));
+    console.log(renderCheckoutView(view));
     if (adapter === "mobile") {
       const perps = mobilePerpsEnvironment(target);
       console.log(

package/dist/commands/parse-args.js

@@ -35,11 +35,13 @@ function parseArgs(argv, command) {
     "categories",
     "fix",
     "force",
+    "clearMetro",
     "resolveOnly",
     "expectLive",
     "printReady",
     "fast",
     "allDevices",
+    "watch",
     "help",
     "noOpen"
   ]);

package/dist/commands/prepare.js

@@ -9,7 +9,7 @@ import { detectAdapter } from "../harness.js";
 import { harnessExecutable, manifestPath, recipeRuntimeDir } from "../paths.js";
 import { optionFlag, optionString, parseArgs, targetPath, usageError } from "./parse-args.js";
 import { EXIT } from "./shared.js";
-const USAGE = "mm-harness prepare [--target <checkout>] [--platform mobile|extension|core] [--mobile-platform ios|android] [--artifacts-dir <dir>] [--json]";
+const USAGE = "mm-harness prepare [--target <checkout>] [--platform mobile|extension|core] [--mobile-platform ios|android] [--clear-metro] [--artifacts-dir <dir>] [--json]";
 const REPORT_DIR = "prepare";
 const SKIPPED_AFTER_FAILURE = "previous step failed";
 function reportPathFor(id) {
@@ -166,6 +166,11 @@ async function handlePrepare(argv) {
   );
   const executable = harnessExecutable();
   const targetArgs = ["--target", target];
+  const clearMetro = optionFlag(options, "clearMetro");
+  if (clearMetro && platform !== "mobile") {
+    throw usageError(`--clear-metro is mobile only; this checkout is ${platform}
+  Next: ${USAGE}`);
+  }
   let mobilePlatform = mobilePlatformOption(optionString(options, "mobilePlatform"));
   const steps = [];
   const failed = () => steps.some((step) => step.status === "fail");
@@ -189,7 +194,7 @@ async function handlePrepare(argv) {
     addStep(skippedStep("fixtures", `${executable} fixtures set`, reason));
   } else if (platform === "mobile") {
     const device = mobilePlatform ? [mobilePlatform] : [];
-    run("launch", ["launch", ...device, "--verify", "--json", ...targetArgs]);
+    run("launch", ["launch", ...device, ...clearMetro ? ["--clear-metro"] : [], "--verify", "--json", ...targetArgs]);
     run("fixtures", [
       "fixtures",
       "set",

package/dist/commands/status-watch.js

@@ -0,0 +1,216 @@
+import os from "node:os";
+import path from "node:path";
+import { color } from "../cli-color.js";
+import {
+  CHECKLIST_LABEL_LIMIT,
+  collectTaskView,
+  findTaskDir,
+  isTerminalStatus,
+  TASK_SILENT_AFTER_MS
+} from "../task-view.js";
+import { EXIT } from "./shared.js";
+const REFRESH_MS = 2e3;
+const CLEAR_SCREEN = "\x1B[2J\x1B[H";
+const HIDE_CURSOR = "\x1B[?25l";
+const SHOW_CURSOR = "\x1B[?25h";
+async function handleStatusTaskView(options) {
+  const deps = {
+    now: () => Date.now(),
+    wait: (ms) => new Promise((resolve) => {
+      setTimeout(resolve, ms);
+    }),
+    write: (text) => process.stdout.write(text),
+    isTty: Boolean(process.stdout.isTTY)
+  };
+  if (!options.watch || !deps.isTty) return runStatusWatch(options, deps);
+  const restore = () => deps.write(SHOW_CURSOR);
+  const interrupt = () => {
+    restore();
+    process.exit(EXIT.ok);
+  };
+  process.on("SIGINT", interrupt);
+  deps.write(HIDE_CURSOR);
+  try {
+    return await runStatusWatch(options, deps);
+  } finally {
+    process.off("SIGINT", interrupt);
+    restore();
+  }
+}
+async function runStatusWatch(options, deps) {
+  const title = `mm-harness status ${options.watch ? "--watch" : "--task"}`;
+  let previous;
+  let sawInProgress = false;
+  for (; ; ) {
+    const taskDir = options.taskDir ?? findTaskDir(options.target);
+    const view = collectTaskView(options.target, taskDir, deps.now());
+    const changes = changedLines(previous, view);
+    if (options.json && !options.watch) {
+      deps.write(`${JSON.stringify(view, null, 2)}
+`);
+    } else if (options.json) {
+      if (changes.length > 0) deps.write(`${JSON.stringify(view)}
+`);
+    } else if (options.watch && !deps.isTty) {
+      for (const line of changes) deps.write(`${line}
+`);
+    } else {
+      deps.write(`${deps.isTty && options.watch ? CLEAR_SCREEN : ""}${renderTaskView(view, title, options.taskDir !== void 0).join("\n")}
+`);
+    }
+    previous = view;
+    const terminal = isTerminalStatus(view.signal?.status);
+    if (view.activity.ongoing) sawInProgress = true;
+    if (!options.watch || terminal && (sawInProgress || options.taskDir !== void 0)) return EXIT.ok;
+    await deps.wait(REFRESH_MS);
+  }
+}
+function renderTaskView(view, title, explicitTask = false) {
+  const out = (style, text) => color(style, text, { stream: process.stdout });
+  const showTask = view.activity.ongoing || explicitTask;
+  const lines = [joinParts([
+    out("label", title),
+    out("bold", path.basename(view.checkout.target)),
+    view.checkout.branch && out("info", view.checkout.branch),
+    view.checkout.head && out("dim", `@${view.checkout.head}`),
+    showTask && view.elapsedMs !== void 0 && out("dim", `${formatDuration(view.elapsedMs)} elapsed`)
+  ], "  ")];
+  const isolation = view.isolation;
+  const device = isolation && joinParts([isolation.platform, isolation.simulator, shortUdid(isolation.simulatorUdid)], " ");
+  const devServer = isolation?.metroPort ?? isolation?.watcherPort ?? isolation?.devServerPort;
+  const runtimeLine = joinParts([
+    isolation?.slotId && `slot ${out("ok", isolation.slotId)}`,
+    device && out("ok", device),
+    devServer !== void 0 && `metro ${out("ok", String(devServer))}`,
+    isolation?.cdpPort !== void 0 && `cdp ${out("ok", String(isolation.cdpPort))}`,
+    isolation?.extensionId && `extension ${out("ok", isolation.extensionId)}`,
+    showTask && view.harness?.version && `harness ${out("info", view.harness.version)}${view.harness.sourceKind ? out("dim", ` (${view.harness.sourceKind})`) : ""}`
+  ]);
+  if (runtimeLine) lines.push(runtimeLine);
+  const template = showTask ? view.template : void 0;
+  const templateLine = joinParts([
+    template?.id && `template ${out("accent", template.id)}${template.sourceId ? out("dim", ` (${template.sourceId})`) : ""}`,
+    template?.flow && `flow ${out("info", template.flow)}`,
+    template?.domain && `domain ${out("info", template.domain)}`,
+    template?.surface && `via ${out("info", template.surface)}`
+  ]);
+  if (templateLine) lines.push(templateLine);
+  const taskLine = joinParts([
+    template?.ticket && out("bold", template.ticket),
+    template?.title && out("info", template.title.trim())
+  ], " ");
+  if (taskLine) lines.push(`${out("label", "task")} ${taskLine}`);
+  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")}`
+  ]);
+  if (contextLine) lines.push(contextLine);
+  lines.push("");
+  if (!view.activity.ongoing) {
+    lines.push(out("warn", "no ongoing task detected"));
+    lines.push(out("dim", idleReason(view)));
+    if (!view.taskDir || !explicitTask) return lines;
+    lines.push("");
+  }
+  let phase;
+  for (const row of view.checklist) {
+    if (row.phase && row.phase !== phase) {
+      const inPhase = view.checklist.filter((other) => other.phase === row.phase);
+      const done = inPhase.filter((other) => other.checked).length;
+      lines.push(out("dim", `  ${row.phase}  ${done}/${inPhase.length}`));
+    }
+    phase = row.phase;
+    lines.push(renderRow(row, view.currentStep, out));
+  }
+  const signal = view.signal;
+  if (signal) {
+    const age = view.checklist.find((row) => row.runningMs !== void 0)?.runningMs;
+    lines.push("");
+    lines.push(joinParts([
+      `signal ${statusWord(out, signal.status)}`,
+      // SIGNAL.json records the last row ticked, not the row in progress.
+      signal.step && `last ticked ${out("info", stepLabel(signal.step))}`,
+      // A cancelled agent leaves status "running"; the age is the only honest hint.
+      age !== void 0 && `no update for ${out(age > TASK_SILENT_AFTER_MS ? "warn" : "dim", formatDuration(age))}`
+    ]));
+  }
+  return lines;
+}
+function idleReason(view) {
+  if (!view.taskDir) return "no task directory under temp/tasks";
+  const { reason, idleMs, branchCarriesTicket } = view.activity;
+  if (reason === "no-task") return `${path.basename(view.taskDir)} holds no task files yet`;
+  const what = reason === "finished" ? view.signal?.status ?? "finished" : "silent";
+  return joinParts([
+    `last task ${path.basename(view.taskDir)}: ${what}`,
+    idleMs !== void 0 && `last update ${formatDuration(idleMs)} ago`,
+    branchCarriesTicket === false && `checkout is on ${view.checkout.branch}, which does not carry ${view.template?.ticket}`
+  ], ", ");
+}
+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"}`
+    ], " ")];
+  }
+  const lines = [];
+  const before = new Map(previous.checklist.map((row) => [row.number, row.checked]));
+  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)})` : ""}`);
+  }
+  if (previous.signal?.step !== next.signal?.step && next.signal?.step) {
+    lines.push(`step ${stepLabel(next.signal.step)}`);
+  }
+  if (previous.signal?.status !== next.signal?.status) {
+    lines.push(`status ${next.signal?.status ?? "unknown"}`);
+  }
+  return lines;
+}
+function formatDuration(ms) {
+  const total = Math.max(0, Math.round(ms / 1e3));
+  const seconds = String(total % 60).padStart(2, "0");
+  const minutes = Math.floor(total / 60) % 60;
+  const hours = Math.floor(total / 3600);
+  if (hours === 0) return `${minutes}:${seconds}`;
+  return `${hours}:${String(minutes).padStart(2, "0")}:${seconds}`;
+}
+function renderRow(row, currentStep, out) {
+  const marker = row.checked ? out("ok", "\u2713") : row.number === currentStep ? out("accent", "\u25B6") : out("dim", "\xB7");
+  const timing = row.durationMs !== void 0 ? formatDuration(row.durationMs) : row.runningMs !== void 0 ? `${formatDuration(row.runningMs)} \u2026` : "";
+  const number = String(row.number).padStart(2);
+  const label = timing ? row.label.padEnd(CHECKLIST_LABEL_LIMIT) : row.label;
+  const text = row.checked ? out("dim", label) : out("bold", label);
+  return ` ${marker} ${out("dim", number)} ${text}${timing ? ` ${out("dim", timing)}` : ""}`;
+}
+function libraryLabel(library) {
+  const home = os.homedir();
+  const location = home && library.path.startsWith(`${home}/`) ? `~${library.path.slice(home.length)}` : library.path;
+  return library.name ? `${library.name}=${location}` : location;
+}
+function statusWord(out, status) {
+  if (!status) return out("dim", "unknown");
+  const style = ["pass", "ready", "complete", "no-change"].includes(status) ? "ok" : ["running", "started"].includes(status) ? "accent" : "err";
+  return out(style, status);
+}
+function stepLabel(step) {
+  return /^\s*(\d+)\./u.exec(step)?.[1] ?? step.trim();
+}
+function shortUdid(udid) {
+  if (!udid) return void 0;
+  return `(${udid.split("-")[0]})`;
+}
+function joinParts(parts, separator = " \xB7 ") {
+  return parts.filter((part) => Boolean(part)).join(separator);
+}
+export {
+  changedLines,
+  formatDuration,
+  handleStatusTaskView,
+  renderTaskView,
+  runStatusWatch
+};

package/dist/commands/status.js

@@ -1,4 +1,7 @@
+import fs from "node:fs";
+import path from "node:path";
 import { color } from "../cli-color.js";
+import { collectCheckoutView, renderCheckoutView } from "../checkout-view.js";
 import { detectAdapter } from "../harness.js";
 import { assertAdapter } from "../paths.js";
 import { getAdapterSurface } from "../adapters/surface.js";
@@ -15,10 +18,20 @@ import {
   renderMobileLiveBlock
 } from "./mobile-device-view.js";
 import { ADAPTER_DETECT_NEXT, EXIT, usageOut } from "./shared.js";
-import { optionFlag, targetPath } from "./parse-args.js";
+import { handleStatusTaskView } from "./status-watch.js";
+import { optionFlag, optionString, targetPath } from "./parse-args.js";
 async function handleStatus({ options }) {
   const target = targetPath(options);
   const json = optionFlag(options, "json");
+  const watch = optionFlag(options, "watch");
+  const taskDir = optionString(options, "task");
+  if (watch || taskDir) {
+    const resolvedTask = taskDir ? path.resolve(taskDir) : void 0;
+    if (resolvedTask && !(fs.existsSync(resolvedTask) && fs.statSync(resolvedTask).isDirectory())) {
+      return usageOut(json, "status", `--task is not a directory: ${resolvedTask}`, "Pass a task directory under temp/tasks, or omit --task to follow the newest one.");
+    }
+    return handleStatusTaskView({ target, taskDir: resolvedTask, json, watch });
+  }
   const fast = optionFlag(options, "fast");
   const allDevices = optionFlag(options, "allDevices");
   const adapter = detectAdapter(target);
@@ -26,6 +39,7 @@ async function handleStatus({ options }) {
     return usageOut(json, "status", `could not detect the MetaMask repo type for ${target}`, ADAPTER_DETECT_NEXT);
   }
   assertAdapter(adapter);
+  const view = collectCheckoutView(target, adapter);
   const surface = getAdapterSurface(adapter);
   surface.resolveSlotPorts(target);
   if (adapter === "mobile") {
@@ -50,6 +64,7 @@ async function handleStatus({ options }) {
             command: "status",
             adapter,
             target,
+            view,
             devices: liveView.devicesWithLive,
             ...discovery,
             ...liveView.additionalReachableDevices.length > 0 ? { additionalReachableDevices: liveView.additionalReachableDevices } : {},
@@ -69,6 +84,7 @@ async function handleStatus({ options }) {
             command: "status",
             adapter,
             target,
+            view,
             devices,
             ...discovery,
             ...runtime ? { runtime } : {},
@@ -83,6 +99,7 @@ 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 (deviceView) renderMobileDeviceList(deviceView, out);
   if (!fast && adapter === "mobile" && deviceView !== null && deviceView.allConnectedDevices.length > 0) {
     const liveView = await mobileDeviceLiveView(target, deviceView);

package/dist/commands/task-init.js

@@ -4,13 +4,14 @@ import { detectAdapter } from "../harness.js";
 import { harnessExecutable } from "../paths.js";
 import { EXIT } from "./shared.js";
 const require2 = createRequire(import.meta.url);
-const USAGE = "mm-harness task init <task-dir> --flow f --run-mode m --template id --title t [options]";
+const USAGE = "mm-harness task init <task-dir> --flow f --template id --title t [options]";
 function hasOption(argv, name) {
   return argv.some((arg) => arg === name || arg.startsWith(`${name}=`));
 }
 function metamaskDefaults(argv) {
   const defaults = [];
   if (!hasOption(argv, "--surface")) defaults.push("--surface", "skill");
+  if (!hasOption(argv, "--run-mode")) defaults.push("--run-mode", "autonomous");
   if (!hasOption(argv, "--mark-command")) {
     defaults.push("--mark-command", `${harnessExecutable()} checklist mark`);
   }

package/dist/commands/update.js

@@ -8,6 +8,9 @@ const PACKAGE_NAME = "@deeeed/metamask-harness";
 const NUDGE_INTERVAL_MS = 24 * 60 * 60 * 1e3;
 const NUDGE_FETCH_TIMEOUT_MS = 2e3;
 const REGISTRY_DIST_TAGS_ENDPOINT = `https://registry.npmjs.org/-/package/${encodeURIComponent(PACKAGE_NAME)}/dist-tags`;
+function registryCwd() {
+  return os.homedir();
+}
 function currentVersion() {
   try {
     const pkg = JSON.parse(fs.readFileSync(path.join(runnerDir, "package.json"), "utf8"));
@@ -38,6 +41,7 @@ function isNewer(candidate, base) {
 }
 function fetchLatest(timeoutMs) {
   const result = spawnSync("npm", ["view", PACKAGE_NAME, "dist-tags.latest"], {
+    cwd: registryCwd(),
     encoding: "utf8",
     timeout: timeoutMs,
     stdio: ["ignore", "pipe", "pipe"]
@@ -119,6 +123,7 @@ async function handleUpdate(argv) {
   }
   const INSTALL_TIMEOUT_MS = 5 * 60 * 1e3;
   const install = spawnSync("npm", ["i", "-g", `${PACKAGE_NAME}@latest`], {
+    cwd: registryCwd(),
     encoding: "utf8",
     timeout: INSTALL_TIMEOUT_MS,
     stdio: ["ignore", "pipe", "pipe"]
@@ -227,5 +232,6 @@ export {
   isNewer,
   maybeNudge,
   nudgeDisabled,
-  nudgeLine
+  nudgeLine,
+  registryCwd
 };

package/dist/doctor.js

@@ -95,8 +95,14 @@ function fixtureFileSummary(file, adapter, reportedPath = file) {
     return { status: "invalid", path: reportedPath, error: error instanceof Error ? error.message : String(error) };
   }
 }
+const DEV_SERVER_PORT_ENV = ["WATCHER_PORT", "METRO_PORT", "RECIPE_WATCHER_PORT"];
 const RUNTIME_CONTEXT_FIELDS = [
   { key: "slotId", envVars: ["RECIPE_SLOT_ID"], envVar: "RECIPE_SLOT_ID", customize: "doctor --fix creates local identity; Farmslot may override", adapters: ["mobile", "extension", "core"] },
+  { key: "watcherPort", envVars: DEV_SERVER_PORT_ENV, envVar: "WATCHER_PORT", customize: "doctor --fix claims one; --watcher-port overrides", adapters: ["mobile"] },
+  { key: "metroPort", envVars: DEV_SERVER_PORT_ENV, envVar: "WATCHER_PORT", customize: "mirrors watcherPort; --metro-port is its alias", adapters: ["mobile"] },
+  { key: "devServerPort", envVars: DEV_SERVER_PORT_ENV, envVar: "WATCHER_PORT", customize: "mirrors watcherPort for the adapter dev server", adapters: ["mobile", "extension"] },
+  { key: "simulator", envVars: ["IOS_SIMULATOR"], envVar: "IOS_SIMULATOR", customize: "--device pins the matched simulator into the context", adapters: ["mobile"] },
+  { key: "simulatorUdid", envVars: ["SIM_UDID"], envVar: "SIM_UDID", customize: "--device pins the matched udid into the context", adapters: ["mobile"] },
   { key: "extensionId", envVars: ["RECIPE_HARNESS_EXTENSION_ID"], envVar: "RECIPE_HARNESS_EXTENSION_ID", customize: "resolved from the built extension", adapters: ["extension"] },
   { key: "cdpPort", envVars: ["RECIPE_CDP_PORT", "CDP_PORT"], envVar: "CDP_PORT", customize: "doctor --fix claims one; --cdp-port overrides", adapters: ["extension"] }
 ];
@@ -108,9 +114,12 @@ function runtimeContextSummary(target, adapter) {
   const fields = {};
   const specs = adapter ? RUNTIME_CONTEXT_FIELDS.filter((spec) => spec.adapters.includes(adapter)) : RUNTIME_CONTEXT_FIELDS;
   for (const spec of specs) {
-    const envValue = spec.envVars.map((name) => process.env[name]).find((value) => value !== void 0 && value !== "");
-    if (envValue !== void 0) {
-      fields[spec.key] = { value: envValue, source: "env", envVar: spec.envVar, customize: spec.customize };
+    const envName = spec.envVars.find((name) => {
+      const value = process.env[name];
+      return value !== void 0 && value !== "";
+    });
+    if (envName !== void 0) {
+      fields[spec.key] = { value: process.env[envName], source: "env", envVar: envName, customize: spec.customize };
       continue;
     }
     const fileValue = fileExists ? readRuntimeContextField(contextPath, spec.key) : void 0;

package/dist/index.js

@@ -9,6 +9,7 @@ import {
   walletFixturePath
 } from "./paths.js";
 import { captureActiveRecipeRecordingSnapshot } from "./run-recording.js";
+import { validateRuntimeProof } from "./runtime-proof.js";
 export {
   captureActiveRecipeRecordingSnapshot,
   createDoctorReport,
@@ -21,5 +22,6 @@ export {
   loadActionManifest,
   recipeHarnessPath,
   validateManifest,
+  validateRuntimeProof,
   walletFixturePath
 };

package/dist/mm-harness-cli.js

@@ -13,6 +13,7 @@ import { handleTutorial } from "./commands/tutorial.js";
 import { handleSetupBase } from "./commands/setup-base.js";
 import { getAdapterSurface } from "./adapters/surface.js";
 import { detectAdapter } from "./harness.js";
+import { configPath, hydrateLibraryPathEnv, readConfig } from "./review/knowledge.js";
 import {
   PUBLIC_COMMAND_CONTRACTS,
   publicCommandNames,
@@ -177,9 +178,23 @@ Example:
   to run, and (mobile only) the connected devices with live app state. Aliases: health, home.
 
   --target <path>                    Checkout path (default: cwd)
-  --json                             Machine-readable envelope { adapter, target, devices[], next }
+  --json                             Machine-readable envelope { adapter, target, view, devices[], next }
   --fast                             Skip all live-state probes (instant output, safe for scripts)
   --all-devices                      Mobile only: show every connected device instead of the slot-scoped target
+  --watch                            Live read-only view of the task this checkout is working through (refreshes every 2s, Ctrl-C to leave)
+  --task <dir>                       Task directory for the view (default: the most recently marked one under temp/tasks/)
+
+  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
+  object per change (newline-delimited) instead of redrawing.
+
+  The checkout view (also under "view" in --json, and printed by doctor) is what
+  this checkout is bound to: the runtime-context fields that keep it off other
+  slots' ports and devices, the recipe libraries this machine resolves, and the
+  wallet fixture it last applied.
 
   Human output: static device list prints immediately; live-state lines append
   after the ~2s probe window (screen, wallet, account, fixture per device).
@@ -202,7 +217,8 @@ Example:
 Example:
   mm-harness status
   mm-harness status --json
-  mm-harness status --fast`
+  mm-harness status --fast
+  mm-harness status --watch`
   },
   {
     name: "checklist",
@@ -244,6 +260,7 @@ Example:
   --target <path>                    Checkout path (default: cwd)
   --platform <mobile|extension|core> Force the platform (auto-detected inside a checkout)
   --mobile-platform <ios|android>    Mobile target when status cannot decide it
+  --clear-metro                      Mobile only: clear Metro's transform cache in the launch step
   --artifacts-dir <dir>              Where sandbox.json and the per-step reports land
                                      (default: <target>/temp/recipe/runtime)
   --json                             Print the readiness record
@@ -266,8 +283,8 @@ Example:
   mm-harness checklist mark, and inputs/ (handoff.json, worker-terminal-contract.json).
   checklist-target.json is NOT written \u2014 absent means CHECKLIST.md + SIGNAL.json.
 
-  Applied when you do not pass them: --surface skill, --mark-command for this
-  executable, and --platform from the detected checkout.
+  Applied when you do not pass them: --surface skill, --run-mode autonomous,
+  --mark-command for this executable, and --platform from the detected checkout.
 
 Task:
   --title <t>                        Task title (required)
@@ -277,7 +294,7 @@ Task:
 
 Selection (same catalog as execution-template):
   --flow <flow>                      Exact flow (required)
-  --run-mode <mode>                  autonomous|interactive|validation (required)
+  --run-mode <mode>                  autonomous|interactive|validation (default autonomous; set by a control plane)
   --platform <platform>              Exact platform
   --template <id>                    Exact template id (required)
   --domain <domain>                  Exact domain
@@ -483,8 +500,9 @@ Example:
     example: "mm-harness doctor",
     helpText: `mm-harness doctor [flags]
 
-  Readiness check for a checkout \u2014 no app launch. Reports the fixture and runtime-context
-  sections so there is no hunting for files.
+  Readiness check for a checkout \u2014 no app launch. Reports the same checkout view
+  status does \u2014 runtime-context isolation, resolved recipe libraries, and the last
+  applied wallet fixture \u2014 so there is no hunting for files.
 
   --fix                              Repair the overlay/runtime-context WITHOUT launching (no fixture reseed); --json adds fixed[]/failed[]
   --expect-live                      Exit-coded liveness gate only (human verdict on stderr). Use without --print-ready when callers need pass/fail without a Farmslot indicator line
@@ -1027,6 +1045,12 @@ const NUDGE_SKIP = ["help", "tutorial", "setup-base", "update", "completions", "
 if (rawArgv.length > 0 && !NUDGE_SKIP.includes(rawArgv[0])) {
   maybeNudge();
 }
+function targetFromArgv(argv) {
+  const index = argv.indexOf("--target");
+  const separate = index !== -1 ? argv[index + 1] : void 0;
+  const inline = argv.find((argument) => argument.startsWith("--target="))?.slice("--target=".length);
+  return path.resolve(separate ?? inline ?? process.cwd());
+}
 function hasPassthroughHelp(argv) {
   const divider = argv.indexOf("--");
   if (divider === -1) return false;
@@ -1102,6 +1126,7 @@ if (!preflightBypass.has(rawArgv[0] ?? "")) {
     );
   }
 }
+await hydrateLibraryPathEnv({ target: targetFromArgv(rawArgv), config: readConfig(configPath()) });
 if (hasPassthroughHelp(rawArgv)) {
   process.exit(await delegate(rawArgv));
 }

package/dist/review/knowledge.js

@@ -140,9 +140,13 @@ function fetchLibrary(name, target) {
   excludeCacheDir(path.resolve(target));
   return withRevision({ name, root, source: "cache" });
 }
+let declaredLibraryPath;
+function declaredLibraryPathFor(env) {
+  return env === process.env && declaredLibraryPath ? declaredLibraryPath.value : env.RECIPE_LIBRARY_PATH;
+}
 function resolveLibrary(name, options) {
   const env = options.env ?? process.env;
-  const fromEnv = parseLibraryPathEnv(env.RECIPE_LIBRARY_PATH).find(
+  const fromEnv = parseLibraryPathEnv(declaredLibraryPathFor(env)).find(
     (entry) => isDir(entry.root) && (entry.name === name || entry.name === void 0 && loadOwnedPaths(entry.root)?.domain === name)
   );
   if (fromEnv) return withRevision({ name, root: fromEnv.root, source: "env" });
@@ -171,7 +175,7 @@ function discoverLibraries(context) {
     seenNames.add(libraryName);
     found.push(withRevision({ name: libraryName, root: resolved, source }));
   };
-  for (const entry of parseLibraryPathEnv(env.RECIPE_LIBRARY_PATH)) add(entry.name, entry.root, "env");
+  for (const entry of parseLibraryPathEnv(declaredLibraryPathFor(env))) add(entry.name, entry.root, "env");
   for (const [name, root] of Object.entries(context.config?.libraries ?? {})) add(name, root, "config");
   const siblingNames = /* @__PURE__ */ new Set();
   for (const root of siblingRoots(context)) {
@@ -188,6 +192,30 @@ function discoverLibraries(context) {
   }
   return found;
 }
+function declaredLibraryPathEnv() {
+  return declaredLibraryPath;
+}
+async function hydrateLibraryPathEnv(context) {
+  const env = context.env ?? process.env;
+  const existing = env.RECIPE_LIBRARY_PATH ?? "";
+  if (env === process.env) declaredLibraryPath = { value: existing || void 0 };
+  const declared = new Set(
+    parseLibraryPathEnv(existing).map(
+      (entry) => entry.name ?? loadOwnedPaths(entry.root)?.domain ?? path.basename(entry.root)
+    )
+  );
+  const discovered = discoverLibraries(context).filter(
+    (library) => library.source !== "env" && !declared.has(library.name)
+  );
+  if (discovered.length === 0) return;
+  const entries = discovered.map((library) => `${library.name}=${library.root}`);
+  if (!existing) {
+    const { personalRecipeLibraryRoot } = await import("@farmslot/recipe-harness");
+    const personal = personalRecipeLibraryRoot(env);
+    if (isDir(personal)) entries.push(`personal=${personal}`);
+  }
+  env.RECIPE_LIBRARY_PATH = existing ? `${existing}:${entries.join(":")}` : entries.join(":");
+}
 function resolveReference(adapter, context) {
   const env = context.env ?? process.env;
   const fromEnv = env[referenceEnvName(adapter)];
@@ -385,7 +413,8 @@ const BASE_REVIEW_STEPS = [
   "Tests: each behavior change has a test at its best-fit layer (view, integration, unit); no mocked-away logic that hides the change under test.",
   "Safety: no secrets, no widened permissions or network surface, no logging of user data; new dependencies justified.",
   "Product wiring: i18n keys, telemetry events, feature flags, and error messages follow the repo conventions for the touched area.",
-  "Scope and hygiene: diff is minimal for the ask, no unrelated refactors or reformatting, commit and PR title follow conventional commits."
+  "Scope and hygiene: diff is minimal for the ask, no unrelated refactors or reformatting, commit and PR title follow conventional commits.",
+  "Signal over noise: comments say why in a line or two and never restate the code; no ticket keys, PR numbers or tool mentions in source; no leftover TODOs, debug logs, commented-out code or unused helpers; no catch that swallows, no abstraction with one caller, no padded tests or PR text. Prefer deleting to rewording."
 ];
 const VERDICT_STEP = "Post the verdict: APPROVE or REQUEST CHANGES, findings ordered by severity with file:line, nits listed separately; state what was not checked and why.";
 function parityAdapter(adapter) {
@@ -489,12 +518,14 @@ export {
   changedFiles,
   classifyDomain,
   configPath,
+  declaredLibraryPathEnv,
   defaultBaseRef,
   discoverLibraries,
   excludeCacheDir,
   fetchLibrary,
   gitExcludeFile,
   globToRegExp,
+  hydrateLibraryPathEnv,
   libraryCachePath,
   loadDomainKnowledge,
   loadOwnedPaths,

package/dist/runtime-proof.js

@@ -0,0 +1,54 @@
+import assert from "node:assert/strict";
+import { normalizeRecipeRef, validateRecipeArtifactPackage } from "@farmslot/protocol";
+function validateRuntimeProof(bundle, smokeTarget) {
+  const checked = validateRecipeArtifactPackage(bundle);
+  assert.equal(checked.status, "valid", JSON.stringify(checked.findings));
+  const { recipe, summary, trace, manifest, recipeResolution, resolvedRecipes } = bundle;
+  assert.equal(summary.status, "pass", "Runtime recipe did not pass");
+  const entries = Array.isArray(trace) ? trace : trace.entries;
+  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 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);
+    if (!current || current.entry.action !== node.action) return false;
+    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 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));
+    }
+    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));
+    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");
+  for (const target of recipe.proofTargets) {
+    const linked = [...nodes].filter(([, node]) => node.proves?.includes(target.id));
+    assert(linked.some(([id]) => proves(id)), `Proof target ${target.id} has no executed runtime assertion`);
+  }
+  if (smokeTarget) assert(recipe.proofTargets.some((target) => target.id === smokeTarget), "Smoke target is absent from recipe");
+}
+export {
+  validateRuntimeProof
+};

package/dist/task-view.js

@@ -0,0 +1,247 @@
+import { spawnSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { resolveRuntimeContextPath } from "./harness.js";
+import { parseLibraryPathEnv } from "./review/knowledge.js";
+const TASK_SEARCH_DEPTH = 3;
+const CHECKLIST_LABEL_LIMIT = 70;
+const CHECKLIST_ROW = /^\s*-\s\[([ xX])\]\s*(\d+)\.\s*(.*)$/u;
+const CHECKLIST_PHASE = /^##\s+(.+?)\s*$/u;
+const TASK_SILENT_AFTER_MS = 10 * 60 * 1e3;
+function findTaskDir(target) {
+  const root = path.join(target, "temp", "tasks");
+  let bySignal;
+  let byChecklist;
+  const consider = (best, dir, file) => {
+    const stat = fs.statSync(path.join(dir, file), { throwIfNoEntry: false });
+    if (!stat?.isFile()) return best;
+    return best && best.mtimeMs >= stat.mtimeMs ? best : { dir, mtimeMs: stat.mtimeMs };
+  };
+  const visit = (dir, depth) => {
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue;
+      const child = path.join(dir, entry.name);
+      bySignal = consider(bySignal, child, "SIGNAL.json");
+      byChecklist = consider(byChecklist, child, "CHECKLIST.md");
+      if (depth < TASK_SEARCH_DEPTH) visit(child, depth + 1);
+    }
+  };
+  if (!fs.statSync(root, { throwIfNoEntry: false })?.isDirectory()) return void 0;
+  visit(root, 1);
+  return (bySignal ?? byChecklist)?.dir;
+}
+function collectTaskView(target, taskDir, now) {
+  const base = {
+    checkout: readCheckout(target),
+    isolation: readIsolation(target),
+    libraries: parseLibraryPathEnv(process.env.RECIPE_LIBRARY_PATH).map(
+      ({ name, root }) => ({ ...name ? { name } : {}, path: root })
+    )
+  };
+  if (!taskDir) return { ...base, checklist: [], activity: { ongoing: false, reason: "no-task" } };
+  const handoff = readJsonObject(path.join(taskDir, "inputs", "handoff.json"));
+  const provenance = readJsonObject(path.join(taskDir, "artifacts", "harness-provenance.json"));
+  const fixtures = readJsonObject(path.join(taskDir, "artifacts", "prepare", "fixtures.json"));
+  const sandbox = readJsonObject(path.join(taskDir, "artifacts", "sandbox.json"));
+  const signal = readJsonObject(path.join(taskDir, "SIGNAL.json"));
+  const checklist = readChecklistRows(path.join(taskDir, "CHECKLIST.md"));
+  const template = asObject(handoff?.executionTemplate);
+  const task = asObject(handoff?.task);
+  const startedAt = parseTime(pickString(handoff, "startedAt"));
+  const timing = applyTiming(checklist, signal, startedAt, now);
+  const ticket = pickString(task, "ticket");
+  const activity = taskActivity({
+    status: pickString(signal, "status"),
+    lastWrites: [startedAt, parseTime(pickString(signal, "timestamp")), ...readMarkTimes(signal).values()],
+    branch: base.checkout.branch,
+    ticket,
+    now
+  });
+  return {
+    ...base,
+    taskDir,
+    harness: section({
+      version: pickString(asObject(provenance?.package), "version"),
+      sourceKind: pickString(asObject(provenance?.source), "kind")
+    }),
+    template: section({
+      id: pickString(template, "id"),
+      sourceId: pickString(template, "sourceId"),
+      flow: pickString(handoff, "flow"),
+      domain: pickString(handoff, "domain"),
+      surface: pickString(handoff, "surface"),
+      title: pickString(task, "title"),
+      ticket
+    }),
+    fixture: section({
+      fixture: pickString(fixtures, "fixture"),
+      canonicalFixture: pickString(fixtures, "canonicalFixture"),
+      status: pickString(fixtures, "status"),
+      walletReset: pickBoolean(fixtures, "walletReset")
+    }),
+    sandbox: section({ ready: pickBoolean(sandbox, "ready") }),
+    checklist,
+    signal: section({
+      status: pickString(signal, "status"),
+      step: pickString(signal, "step"),
+      timestamp: pickString(signal, "timestamp"),
+      attemptId: pickString(signal, "attemptId")
+    }),
+    ...timing,
+    activity
+  };
+}
+function taskActivity(input) {
+  const writes = input.lastWrites.filter((value) => value !== void 0);
+  const idleMs = writes.length > 0 ? input.now - Math.max(...writes) : void 0;
+  const branchCarriesTicket = input.ticket && input.branch ? input.branch.includes(input.ticket) : void 0;
+  const extra = {
+    ...idleMs !== void 0 ? { idleMs } : {},
+    ...branchCarriesTicket !== void 0 ? { branchCarriesTicket } : {}
+  };
+  if (input.status === void 0 && writes.length === 0) return { ongoing: false, reason: "no-task", ...extra };
+  if (isTerminalStatus(input.status)) return { ongoing: false, reason: "finished", ...extra };
+  if (idleMs !== void 0 && idleMs > TASK_SILENT_AFTER_MS) return { ongoing: false, reason: "silent", ...extra };
+  return { ongoing: true, ...extra };
+}
+function isTerminalStatus(status) {
+  return status !== void 0 && status !== "running" && status !== "started";
+}
+function applyTiming(rows, signal, startedAt, now) {
+  const marks = readMarkTimes(signal);
+  let previousAt = startedAt;
+  let lastAt;
+  let firstAt;
+  for (const row of rows) {
+    const checkedAt = marks.get(row.number);
+    if (checkedAt === void 0) continue;
+    if (previousAt !== void 0) row.durationMs = checkedAt - previousAt;
+    if (firstAt === void 0) firstAt = checkedAt;
+    previousAt = checkedAt;
+    lastAt = checkedAt;
+  }
+  const current = rows.find((row) => !row.checked);
+  if (current && lastAt !== void 0) current.runningMs = now - lastAt;
+  const origin = startedAt ?? firstAt;
+  return {
+    ...current ? { currentStep: current.number } : {},
+    ...origin !== void 0 ? { elapsedMs: now - origin } : {}
+  };
+}
+function readMarkTimes(signal) {
+  const marks = /* @__PURE__ */ new Map();
+  const events = asObject(signal?.checklistTiming)?.events;
+  if (!Array.isArray(events)) return marks;
+  for (const entry of events) {
+    const event = asObject(entry);
+    const stepNumber = pickNumber(event, "stepNumber");
+    const checkedAt = parseTime(pickString(event, "checkedAt"));
+    if (stepNumber === void 0 || checkedAt === void 0) continue;
+    marks.set(stepNumber, checkedAt);
+  }
+  return marks;
+}
+function readChecklistRows(file) {
+  const text = readTextFile(file);
+  if (text === void 0) return [];
+  const rows = [];
+  let phase;
+  for (const line of text.split("\n")) {
+    const heading = CHECKLIST_PHASE.exec(line);
+    if (heading) {
+      phase = heading[1];
+      continue;
+    }
+    const match = CHECKLIST_ROW.exec(line);
+    if (!match) continue;
+    rows.push({
+      ...phase ? { phase } : {},
+      number: Number(match[2]),
+      label: trimLabel(match[3]),
+      checked: match[1].toLowerCase() === "x"
+    });
+  }
+  return rows;
+}
+function trimLabel(text) {
+  const plain = text.replace(/\*\*/gu, "").replace(/\s+/gu, " ").trim();
+  if (plain.length <= CHECKLIST_LABEL_LIMIT) return plain;
+  return `${plain.slice(0, CHECKLIST_LABEL_LIMIT).trimEnd()}\u2026`;
+}
+function readCheckout(target) {
+  const branch = gitRef(target, "--abbrev-ref");
+  const head = gitRef(target, "--short");
+  return { target, ...branch ? { branch } : {}, ...head ? { head } : {} };
+}
+function gitRef(target, mode) {
+  const result = spawnSync("git", ["-C", target, "rev-parse", mode, "HEAD"], { encoding: "utf8" });
+  if (result.status !== 0) return void 0;
+  return result.stdout.trim() || void 0;
+}
+function readIsolation(target) {
+  const context = readJsonObject(resolveRuntimeContextPath(target));
+  if (!context) return void 0;
+  return section({
+    slotId: pickString(context, "slotId"),
+    platform: pickString(context, "platform"),
+    metroPort: pickNumber(context, "metroPort"),
+    watcherPort: pickNumber(context, "watcherPort"),
+    devServerPort: pickNumber(context, "devServerPort"),
+    simulator: pickString(context, "simulator"),
+    simulatorUdid: pickString(context, "simulatorUdid"),
+    cdpPort: pickNumber(context, "cdpPort"),
+    extensionId: pickString(context, "extensionId")
+  });
+}
+function readTextFile(file) {
+  try {
+    return fs.readFileSync(file, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") return void 0;
+    throw error;
+  }
+}
+function readJsonObject(file) {
+  const raw = readTextFile(file);
+  if (raw === void 0) return void 0;
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    throw new Error(`${file} is not valid JSON: ${error.message}`);
+  }
+  const object = asObject(parsed);
+  if (!object) throw new Error(`${file} must contain a JSON object.`);
+  return object;
+}
+function asObject(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  return value;
+}
+function pickString(source, key) {
+  const value = source?.[key];
+  return typeof value === "string" && value !== "" ? value : void 0;
+}
+function pickNumber(source, key) {
+  const value = source?.[key];
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function pickBoolean(source, key) {
+  const value = source?.[key];
+  return typeof value === "boolean" ? value : void 0;
+}
+function parseTime(value) {
+  if (value === void 0) return void 0;
+  const parsed = Date.parse(value);
+  return Number.isFinite(parsed) ? parsed : void 0;
+}
+function section(value) {
+  return Object.values(value).some((entry) => entry !== void 0) ? value : void 0;
+}
+export {
+  CHECKLIST_LABEL_LIMIT,
+  TASK_SILENT_AFTER_MS,
+  collectTaskView,
+  findTaskDir,
+  isTerminalStatus
+};

package/docs/RECIPES.md

@@ -450,6 +450,12 @@ mm-harness run onboarding.smoke --describe
 mm-harness run onboarding.smoke --plan
 ```
 
+A library registered once with `mm-harness config set libraries.wallet <path>`,
+or checked out beside the product checkout, is reachable without exporting
+anything: every location the harness resolves reaches `run`, `actions`, and
+template discovery, and `mm-harness status` lists them. Exported entries keep
+their precedence and order in front of those.
+
 Use `--library wallet=/path/to/library` for one command. The alias is the
 source name; without one, the directory name is used. Resolution follows the
 explicit library order, then bundled MetaMask. Adapter-specific variants are

package/package.json

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

package/scripts/site-contrast.mjs

@@ -391,7 +391,7 @@ async function checkBehavior(browserEndpoint, port, pages) {
     const expected = [
       ['npm i -g @deeeed/metamask-harness@latest', copied.setup],
       ['yarn skills', copied.setup],
-      ['/mms-recipe-pr-qa-review', copied.work.join('\n')],
+      ['/mms-recipe-qa', copied.work.join('\n')],
       ['/mms-recipe-cook', copied.work.join('\n')],
       ['/mms-recipe-performance', copied.work.join('\n')],
       ['/mms-recipe-evidence', copied.work.join('\n')],
@@ -425,6 +425,32 @@ async function checkBehavior(browserEndpoint, port, pages) {
 
   // The walkthrough and its saved progress live one click deeper.
   await withPage(browserEndpoint, `${base}how-it-works.html`, async (page) => {
+    const previews = await page.evaluate(String.raw`
+      (async () => {
+        document.querySelector('[data-map-key="template"]').click();
+        const checked = [];
+        for (const button of document.querySelectorAll('[data-template-example]')) {
+          button.click();
+          const dialog = document.querySelector('#template-preview');
+          for (let attempt = 0; attempt < 100; attempt++) {
+            if (!dialog.querySelector('.template-preview-controls').hidden) break;
+            await new Promise(resolve => setTimeout(resolve, 20));
+          }
+          const meta = dialog.querySelector('#template-preview-meta').textContent;
+          const raw = dialog.querySelector('#template-preview-raw').textContent;
+          const source = dialog.querySelector('#template-preview-source');
+          if (!dialog.open || !meta.includes(button.dataset.templateExample) || !raw.includes('- [ ]') || source.hidden || !/\/blob\/[a-f0-9]{40}\//.test(source.href)) {
+            throw new Error('Invalid canonical template preview: ' + button.dataset.templateExample);
+          }
+          checked.push(button.dataset.templateExample);
+          dialog.querySelector('[data-template-close]').click();
+        }
+        return checked;
+      })()
+    `);
+    if (!previews.includes('review-pr/static-perps') || !previews.includes('qa/pr.extension')) {
+      throw new Error('Static review and QA previews must both be available');
+    }
     const progress = await page.evaluate(String.raw`
       (() => {
         const box = document.querySelector('.step-check');