@deeeed/metamask-harness 0.92.21 → 0.92.23

package/dist/mm-harness-cli.js

@@ -9,22 +9,36 @@ import {
   createHarnessCli,
   handleActions,
   handleCall,
+  handleChecklist,
+  handleDoctor,
+  handleExecutionTemplate,
   handleHarness,
   handleLast,
   handleLaunch,
+  handleLogs,
+  handlePrepare,
+  handleRecipeQuality,
   handleReload,
+  handleReview,
   handleRun,
+  handleStatus,
   handleStop,
+  handleTaskInit,
   harnessHost,
   optionValues,
   parseArgs,
+  resolveAdapter,
   targetPath
 } from "@farmslot/recipe-cli/harness";
 import { handleStopViewers } from "./commands/stop.js";
-import { stopOptions } from "./provider-lifecycle.js";
+import { cliDoctorOptions, configureProviderReadiness } from "./provider-doctor.js";
+import { cliRecipeQualityOptions, cliReviewOptions, helperCommandOptions } from "./provider-helpers.js";
+import { cliStatusOptions, prepareOptions, stopOptions } from "./provider-lifecycle.js";
+import { createLogsOptions } from "./provider-logs.js";
 import { adoptPluginAdapter, afterAdapterLoad, configuredLibrarySources } from "./adapters/plugin-surface.js";
 import { withMainnetOrderAbort } from "./adapters/perps-mainnet-cleanup.js";
 import { adapterRegistry } from "./adapters/registry.js";
+import { getAdapterSurface } from "./adapters/surface.js";
 import {
   explainMissingAdapterLibrary,
   HIDDEN_COMMANDS,
@@ -34,32 +48,22 @@ import {
   withAdapterList
 } from "./command-contract.js";
 import { handleCheck } from "./commands/check.js";
-import { handleChecklist } from "./commands/checklist.js";
 import { handleCompletionCandidates, invalidateCompletionCache } from "./commands/completion-candidates.js";
 import { handleConfig } from "./commands/config.js";
 import { handleDebug } from "./commands/debug.js";
 import { applyDeviceTargeting } from "./commands/device-target.js";
-import { handleDoctor } from "./commands/doctor.js";
-import { handleDomain } from "./commands/domain.js";
 import { handleEnsureReady } from "./commands/ensure-ready.js";
-import { handleExecutionTemplate } from "./commands/execution-template.js";
 import { handleFixtures } from "./commands/fixtures.js";
 import { handleHelp } from "./commands/help.js";
-import { handleLogs } from "./commands/logs.js";
 import { overlayCommandOptions } from "./commands/overlay.js";
 import { handlePin } from "./commands/pin.js";
 import { handlePrBody } from "./commands/pr-body.js";
-import { handlePrepare } from "./commands/prepare.js";
 import { handleProvision } from "./commands/provision.js";
-import { handleRecipeQuality } from "./commands/recipe-quality.js";
 import { handleResolveExtension } from "./commands/resolve-extension.js";
-import { handleReview } from "./commands/review.js";
 import { handleRuntimeDecision } from "./commands/runtime-decision.js";
 import { handleRuntimeLaunch } from "./commands/runtime-launch.js";
 import { handleSelfTest } from "./commands/self-test.js";
 import { handleSetupBase } from "./commands/setup-base.js";
-import { handleStatus } from "./commands/status.js";
-import { handleTaskInit } from "./commands/task-init.js";
 import { handleTutorial } from "./commands/tutorial.js";
 import { handleUpdate, maybeNudge } from "./commands/update.js";
 import { metaMaskEngine } from "./engine.js";
@@ -114,6 +118,20 @@ function overlay(command) {
     return code;
   };
 }
+const LOGS_OPTIONS = PUBLIC_COMMANDS.find((command) => command.name === "logs").contract.options;
+function logsOptions(options) {
+  const surface = () => createLogsOptions(getAdapterSurface(resolveAdapter(options).adapter));
+  return {
+    compact: (request) => surface().compact(request),
+    window: (request) => surface().window(request),
+    announce: ({ source, logFile }) => process.stderr.write(
+      `${source} log: ${logFile}
+  tail it yourself: tail -f ${logFile}   \xB7   page it: less +F ${logFile}
+  following below (Ctrl-C to stop) \u2026
+`
+    )
+  };
+}
 function invocationLibraries() {
   return optionValues(process.argv.slice(2), "--library");
 }
@@ -137,16 +155,16 @@ function withManifestEnvelope(command, run) {
 }
 const PUBLIC_RUN = {
   help: { run: (args) => handleHelp(args, { packageRoot, harnessVersion: hostVersion() }), nudge: false },
-  review: { run: handleReview },
-  domain: { run: handleDomain },
+  review: { run: (args) => handleReview(args, cliReviewOptions) },
+  domain: { run: (args) => handleReview(["domain", ...args], cliReviewOptions) },
   "pr-body": { run: handlePrBody },
   config: { run: handleConfig },
   tutorial: { run: (args) => handleTutorial(args, { harnessVersion: hostVersion() }), exit: "now", nudge: false },
   "setup-base": { run: handleSetupBase, raw: true, exit: "now", nudge: false },
-  status: { run: (args) => handleStatus(parseArgs(args)) },
-  checklist: { run: handleChecklist },
-  prepare: { run: handlePrepare },
-  task: { run: handleTaskInit },
+  status: { run: (args) => handleStatus(parseArgs(args), cliStatusOptions) },
+  checklist: { run: (args) => handleChecklist(args, helperCommandOptions.task) },
+  prepare: { run: (args) => handlePrepare(args, prepareOptions) },
+  task: { run: (args) => handleTaskInit(args, { surface: "skill" }) },
   "execution-template": { run: handleExecutionTemplate },
   actions: { run: (args) => handleActions(parseArgs(args), { catalog: metaMaskEngine }) },
   stop: { run: (args) => handleStop(args, stopOptions) },
@@ -155,16 +173,28 @@ const PUBLIC_RUN = {
   call: { run: (args) => withMainnetOrderAbort(targetPath(parseArgs(args).options), () => handleCall(args, callOptions)) },
   run: { run: (args) => withMainnetOrderAbort(targetPath(parseArgs(args).options), () => handleRun(args, runOptions)) },
   last: { run: (args) => handleLast(parseArgs(args)) },
-  doctor: { run: (args) => handleDoctor(parseArgs(args)) },
+  doctor: {
+    run: (args) => {
+      const parsed = parseArgs(args);
+      const adapter = contextAdapter(targetPath(parsed.options));
+      if (adapter && adapterRegistry.has(adapter)) configureProviderReadiness(getAdapterSurface(adapter));
+      return handleDoctor(parsed, cliDoctorOptions);
+    }
+  },
   check: { run: handleCheck },
-  "recipe-quality": { run: handleRecipeQuality },
+  "recipe-quality": { run: (args) => handleRecipeQuality(args, cliRecipeQualityOptions) },
   provision: { run: (args) => handleProvision(parseArgs(args)) },
   install: { run: overlay("install") },
   verify: { run: overlay("verify") },
   cleanup: { run: overlay("cleanup") },
   launch: { run: handleLaunch },
   "runtime-launch": { run: (args) => handleRuntimeLaunch(parseArgs(args)) },
-  logs: { run: handleLogs },
+  logs: {
+    run: (args) => {
+      const parsed = parseArgs(args, { optionSpecs: LOGS_OPTIONS });
+      return handleLogs(parsed, logsOptions(parsed.options));
+    }
+  },
   debug: { run: handleDebug },
   reload: { run: handleReload },
   update: { run: handleUpdate, exit: "now", nudge: false },

package/dist/paths.js

@@ -4,7 +4,6 @@ import { fileURLToPath, pathToFileURL } from "node:url";
 import { recipeRuntimeDir, recipeRuntimePath } from "@farmslot/recipe-cli/harness";
 import { adapterRegistry } from "./adapters/registry.js";
 const runnerDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
-const PREPARE_PROGRESS_ARTIFACT = "prepare/progress.json";
 function walletFixturePath(projectRoot) {
   return recipeRuntimePath(projectRoot, "wallet-fixture.json");
 }
@@ -157,7 +156,6 @@ function isMissingPackageError(error, packageName) {
 }
 export {
   LIBRARY_ACTION_NAMESPACE,
-  PREPARE_PROGRESS_ARTIFACT,
   assertAdapter,
   extensionIdPath,
   harnessSlotPoolDir,

package/dist/provider-doctor.js

@@ -3,7 +3,7 @@ import { farmslotReadyIndicator } from "./commands/farmslot-ready.js";
 import { updateStatus } from "./commands/update.js";
 import { doctorReportOptions, fixtureSummary } from "./doctor.js";
 import { loadActionManifest, validateManifest } from "./manifest.js";
-import { statusOptions } from "./provider-lifecycle.js";
+import { cliDevicePreview, statusOptions } from "./provider-lifecycle.js";
 import { ensureRuntimeContext } from "./runtime-context.js";
 const doctorOptions = {
   ...statusOptions,
@@ -25,12 +25,14 @@ const doctorOptions = {
     userAction: (failed, retry) => failed.includes("wallet-fixture") ? `choose one wallet fixture source from nextActions, run it, then retry: ${retry}` : void 0
   }
 };
+const cliDoctorOptions = { ...doctorOptions, previewDevice: cliDevicePreview };
 function configureProviderReadiness(runtime) {
   Object.assign(runtime.readiness, {
     readyIndicator: (devices) => farmslotReadyIndicator(runtime.id, [...devices])
   });
 }
 export {
+  cliDoctorOptions,
   configureProviderReadiness,
   doctorOptions
 };

package/dist/provider-helpers.js

@@ -1,14 +1,118 @@
-import { checkDiffSummaryReady, runCloseout, teachRecipeCompletion } from "./commands/checklist.js";
+import { spawnSync } from "node:child_process";
+import fs from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+import {
+  usageError
+} from "@farmslot/recipe-cli/harness";
+import { adapterFromOptions, harnessVersion } from "./commands/review.js";
 import {
   BASE_REVIEW_STEPS,
   REVIEW_ADAPTERS,
+  VERDICT_STEP,
   configPath,
+  discoverLibraries,
   parityAdapter,
   parityReviewSteps,
   readConfig,
   referenceHint,
+  resolveLibrary,
   resolveReference
 } from "./review/knowledge.js";
+const require2 = createRequire(import.meta.url);
+function handoffCommand() {
+  if (process.env.HANDOFF_BIN) {
+    try {
+      fs.accessSync(process.env.HANDOFF_BIN, fs.constants.X_OK);
+      return { command: process.env.HANDOFF_BIN, prefix: [] };
+    } catch {
+      return { command: process.execPath, prefix: [process.env.HANDOFF_BIN] };
+    }
+  }
+  return {
+    command: process.execPath,
+    prefix: [require2.resolve("@farmslot/handoff/cli")]
+  };
+}
+function closeoutArgs(taskDir, args) {
+  const normalized = args.flatMap((arg) => {
+    const option = ["--config", "--destination", "--metadata"].find(
+      (name) => arg.startsWith(`${name}=`)
+    );
+    return option ? [option, arg.slice(option.length + 1)] : [arg];
+  });
+  if (process.env.METAMASK_AGENTIC_LEARNINGS_DIR && !normalized.includes("--destination")) {
+    return [
+      "closeout",
+      taskDir,
+      ...normalized,
+      "--destination",
+      process.env.METAMASK_AGENTIC_LEARNINGS_DIR
+    ];
+  }
+  return ["closeout", taskDir, ...normalized];
+}
+function runCloseout(taskDir, args, stdio) {
+  try {
+    const { command, prefix } = handoffCommand();
+    return spawnSync(command, [...prefix, ...closeoutArgs(taskDir, args)], {
+      encoding: "utf8",
+      stdio
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      status: 1,
+      stdout: "",
+      stderr: message,
+      error: new Error(message)
+    };
+  }
+}
+function checkDiffSummaryReady(taskDir, step) {
+  const summaryPath = path.join(
+    taskDir,
+    "artifacts",
+    "validation-summary.json"
+  );
+  try {
+    const summary = JSON.parse(fs.readFileSync(summaryPath, "utf8"));
+    if (summary.command === "check" && summary.action === "diff" && summary.status === "pass") {
+      return true;
+    }
+  } catch {
+  }
+  console.error(
+    `check-diff gate ${step} requires a task-local PASS at ${summaryPath}`
+  );
+  console.error(
+    `Run: mm-harness check diff [--fix] --artifacts-dir ${path.dirname(summaryPath)}`
+  );
+  console.error("Then rerun the same checklist mark command.");
+  return false;
+}
+function teachRecipeCompletion(taskDir, step) {
+  if (step !== "complete") return;
+  const artifactsDir = path.join(taskDir, "artifacts");
+  if (!fs.existsSync(path.join(artifactsDir, "recipe.json"))) return;
+  const qualityPath = path.join(artifactsDir, "recipe-quality.json");
+  const coveragePath = path.join(artifactsDir, "recipe-coverage.md");
+  const missingQuality = !fs.existsSync(qualityPath);
+  const missingCoverage = !fs.existsSync(coveragePath);
+  if (!missingQuality && !missingCoverage) return;
+  console.error("Recipe completion needs two closure artifacts; derive them from the real recipe run and evidence (do not stub them):");
+  if (missingCoverage) {
+    console.error(`  - ${coveragePath}: map each proof target to its recipe node and evidence, or record a reasoned N/A.`);
+  }
+  if (missingQuality) {
+    const compactPath = path.join(artifactsDir, "recipe-quality-input.json");
+    console.error("    First run: mm-harness help");
+    console.error(`  - ${qualityPath}: write ${compactPath} as:`);
+    console.error('    {"verdict":"pass|warn|fail","reasons":["evidence-backed reason"]}');
+    console.error(`    then run: mm-harness recipe-quality build --input ${compactPath} --output ${qualityPath}`);
+  }
+  console.error("Then rerun the same checklist complete command.");
+}
 const task = {
   stepGates: [{ label: /mm-harness check diff/u, ready: checkDiffSummaryReady }],
   closeout: runCloseout,
@@ -30,6 +134,32 @@ const review = {
     };
   }
 };
+const cliReviewOptions = {
+  ...review,
+  usage: "Usage: mm-harness review checklist [--domain <name>] [--since <sha>] [--base <ref>] [--out <file>] [--json]",
+  domainCommand: "mm-harness domain",
+  defaultDomain: { read: () => process.env.MM_HARNESS_DOMAIN || void 0, label: "MM_HARNESS_DOMAIN" },
+  runtime: ({ action, domain }) => {
+    const adapter = adapterFromOptions();
+    if (action === "domain" && !domain && adapter === "unscoped") {
+      throw usageError(`No MetaMask checkout detected: pass --adapter <${REVIEW_ADAPTERS.join("|")}> or --domain <name>.`);
+    }
+    return adapter;
+  },
+  libraries: ({ target }) => discoverLibraries({ target, config: readConfig(configPath()) }).map((library) => ({
+    name: library.name,
+    root: library.root,
+    source: library.source,
+    revision: library.revision ?? null
+  })),
+  resolveLibrary: ({ domain, target }) => resolveLibrary(domain, { target, config: readConfig(configPath()), fetch: true }),
+  header: ({ target, library, reference, referenceMissing }) => [
+    `Materialized by mm-harness ${harnessVersion()} for ${target}.`,
+    ...library ? [`Domain knowledge: ${library.name}${library.revision ? ` @ ${library.revision}` : ""} (${library.root}, via ${library.source}).`] : [],
+    ...reference ? [`Parity reference: ${reference.adapter} checkout at ${reference.root} (via ${reference.source}).`] : referenceMissing ? [`Parity reference: not checked \u2014 ${referenceMissing}.`] : []
+  ],
+  verdictRule: VERDICT_STEP
+};
 async function recipeAdvice(options, mode) {
   const { handleRecipeAdvice } = await import("./commands/recipe-advice.js");
   return handleRecipeAdvice(options, mode);
@@ -48,6 +178,18 @@ const recipeQuality = {
   missingAction: "Use build, plan, advise or advisor-status."
 };
 const helperCommandOptions = { task, review, recipeQuality };
+const cliRecipeQualityOptions = {
+  subcommands: recipeQuality.subcommands,
+  subcommandOptions: {
+    names: recipeQuality.subcommandOptions.names,
+    message: "advice options require the advise subcommand",
+    userAction: "mm-harness recipe-quality advise --recipe <recipe.json> --task <TASK.md> --adapter <adapter> --advisor <provider>"
+  },
+  missingAction: "missing action: use build, plan, or advise",
+  usageNote: "apply the quality bar from mm-harness help, then build its compact verdict here."
+};
 export {
+  cliRecipeQualityOptions,
+  cliReviewOptions,
   helperCommandOptions
 };

package/dist/provider-lifecycle.js

@@ -1,7 +1,11 @@
+import {
+  usageError
+} from "@farmslot/recipe-cli/harness";
 import { stopProjectCollector } from "../library/actions/shared/analytics/collector.mjs";
 import { collectCheckoutView, renderCheckoutView } from "./checkout-view.js";
 import { applyDeviceTargeting } from "./commands/device-target.js";
-import { featureFlagReport } from "./feature-flags.js";
+import { doctorReportOptions } from "./doctor.js";
+import { featureFlagReport, FeatureFlagSpecError, parseRemoteFlagSpec } from "./feature-flags.js";
 const statusOptions = {
   checkoutView(target, adapter) {
     const view = collectCheckoutView(target, adapter);
@@ -14,6 +18,41 @@ const statusOptions = {
     persistPin: false
   })
 };
+const cliDevicePreview = (command, adapter, options) => applyDeviceTargeting(command, adapter, options, { gate: false, rerun: "" });
+const cliStatusOptions = { ...statusOptions, previewDevice: cliDevicePreview, journal: false };
+const prepareOptions = {
+  usage: "mm-harness prepare [--target <checkout>] [--platform mobile|extension|core] [--mobile-platform ios|android] [--clear-metro] [--artifacts-dir <dir>] [--json]",
+  launchHint: "can take minutes on Mobile: Metro bundle and app start",
+  steps: [{
+    id: "fixtures",
+    command: "fixtures set",
+    hint: "under a minute",
+    argv: ({ device, forwarded, targetArgs }) => [
+      "fixtures",
+      "set",
+      ...device.flatMap((platform) => ["--platform", platform]),
+      ...forwarded,
+      "--json",
+      ...targetArgs
+    ]
+  }],
+  deviceTarget: { option: "mobilePlatform", flag: "--mobile-platform", choices: ["ios", "android"] },
+  clearMetroOnly: "mobile only",
+  forward: {
+    option: "remoteFlag",
+    flag: "--remote-flag",
+    validate(value) {
+      try {
+        parseRemoteFlagSpec(value);
+      } catch (error) {
+        if (!(error instanceof FeatureFlagSpecError)) throw error;
+        throw usageError(`${error.message}
+  Next: ${error.userAction}`);
+      }
+    }
+  },
+  provenance: doctorReportOptions.provenance
+};
 const stopOptions = {
   companions: async (target) => {
     const collector = await stopProjectCollector(target);
@@ -21,6 +60,9 @@ const stopOptions = {
   }
 };
 export {
+  cliDevicePreview,
+  cliStatusOptions,
+  prepareOptions,
   statusOptions,
   stopOptions
 };

package/dist/review/knowledge.js

@@ -274,74 +274,6 @@ function loadOwnedPaths(root) {
   }
   return { domain: record.domain, repos };
 }
-function globToRegExp(glob) {
-  let out = "^";
-  for (let i = 0; i < glob.length; i += 1) {
-    const char = glob[i];
-    if (char === "*") {
-      if (glob[i + 1] === "*") {
-        const slashAfter = glob[i + 2] === "/";
-        out += slashAfter ? "(?:.*/)?" : ".*";
-        i += slashAfter ? 2 : 1;
-      } else {
-        out += "[^/]*";
-      }
-    } else if (char === "?") {
-      out += "[^/]";
-    } else if (char === "[") {
-      const negated = glob[i + 1] === "!";
-      const bodyStart = i + 1 + (negated ? 1 : 0);
-      const close = glob.indexOf("]", glob[bodyStart] === "]" ? bodyStart + 1 : bodyStart);
-      if (close === -1) {
-        out += "\\[";
-      } else {
-        out += `[${negated ? "^" : ""}${glob.slice(bodyStart, close).replace(/[\\\]]/g, "\\$&")}]`;
-        i = close;
-      }
-    } else {
-      out += char.replace(/[.+^${}()|\\]/g, "\\$&");
-    }
-  }
-  return new RegExp(`${out}$`);
-}
-function matchOwnedFiles(files, globs) {
-  const patterns = globs.map(globToRegExp);
-  return files.filter((file) => patterns.some((pattern) => pattern.test(file)));
-}
-function classifyDomain(files, adapter, libraries) {
-  const matches = [];
-  for (const library of libraries) {
-    const owned = loadOwnedPaths(library.root);
-    if (!owned) continue;
-    const matched = matchOwnedFiles(files, owned.repos[adapter] ?? []);
-    if (matched.length > 0) matches.push({ domain: owned.domain, library, matched });
-  }
-  return matches.sort((a, b) => b.matched.length - a.matched.length);
-}
-function git(target, args) {
-  return execFileSync("git", ["-C", target, ...args], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
-}
-function defaultBaseRef(target) {
-  for (const candidate of ["origin/main", "main", "origin/develop", "develop"]) {
-    try {
-      git(target, ["rev-parse", "--verify", "--quiet", `${candidate}^{commit}`]);
-      return candidate;
-    } catch {
-    }
-  }
-  return "HEAD";
-}
-function changedFiles(target, base) {
-  const ref = base ?? defaultBaseRef(target);
-  const lists = [
-    ref === "HEAD" ? "" : git(target, ["diff", "--name-only", `${ref}...HEAD`]),
-    git(target, ["diff", "--name-only", "HEAD"]),
-    git(target, ["ls-files", "--others", "--exclude-standard"])
-  ];
-  const files = /* @__PURE__ */ new Set();
-  for (const list of lists) for (const line of list.split("\n")) if (line.trim()) files.add(line.trim());
-  return { base: ref, files: [...files].sort() };
-}
 function parseSections(markdown) {
   const lines = markdown.split("\n");
   const introLines = [];
@@ -457,51 +389,6 @@ function parityReviewSteps(input) {
   }
   return ["Parity: core changes are consumed by both mobile and extension; confirm both consumers still compile against the public surface."];
 }
-function renderReviewChecklist(input) {
-  const diffRange = input.since ? `${input.since}..HEAD` : `${input.base}...HEAD`;
-  const lines = [];
-  const scope = input.domain ? `${input.domain} (${input.adapter})` : input.adapter;
-  lines.push(`# Review checklist \u2014 ${scope}`, "");
-  lines.push(`Materialized by mm-harness ${input.harnessVersion} for ${input.target}.`);
-  if (input.knowledge) {
-    const { library } = input.knowledge;
-    lines.push(`Domain knowledge: ${library.name}${library.revision ? ` @ ${library.revision}` : ""} (${library.root}, via ${library.source}).`);
-  }
-  if (input.reference) {
-    lines.push(`Parity reference: ${input.reference.adapter} checkout at ${input.reference.root} (via ${input.reference.source}).`);
-  } else if (input.referenceMissing) {
-    lines.push(`Parity reference: not checked \u2014 ${input.referenceMissing}.`);
-  }
-  lines.push(`Scope: \`git diff ${diffRange}\`${input.since ? " (incremental re-review since the last verdict)" : ""}.`, "");
-  let step = 0;
-  const item = (text) => {
-    step += 1;
-    lines.push(`- [ ] ${step}. ${text}`);
-  };
-  lines.push("## Setup");
-  if (input.since) {
-    item(`Re-read the previous findings, then list only the files changed in \`git diff --name-only ${diffRange}\`; confirm each earlier finding is addressed or explicitly declined.`);
-  } else {
-    item(`Read the task or PR description and the linked ticket, then list the changed files with \`git diff --name-only ${diffRange}\`.`);
-  }
-  item(
-    input.domain ? `Confirm the domain is ${input.domain} (\`mm-harness domain\`) and open ${input.knowledge?.antipatterns ? "review/antipatterns.md" : "the domain library"} once before reading the diff.` : "Run `mm-harness domain` to check whether a team library owns the changed files; if one does, re-run with --domain."
-  );
-  lines.push("", "## Base review");
-  for (const text of BASE_REVIEW_STEPS) item(text);
-  if (input.knowledge?.antipatterns) {
-    lines.push("", `## Domain patterns (${input.domain})`);
-    for (const section of input.knowledge.antipatterns.sections) {
-      item(`${section.title}: ${section.summary}`);
-    }
-  }
-  lines.push("", "## Parity");
-  for (const step2 of parityReviewSteps({ ...input, hasParityGuide: Boolean(input.knowledge?.parity) })) item(step2);
-  lines.push("", "## Verdict");
-  item(VERDICT_STEP);
-  return `${lines.join("\n")}
-`;
-}
 function renderReviewHelp(input) {
   const lines = [];
   lines.push(`mm-harness ${input.harnessVersion} review guide${input.domain ? ` \u2014 ${input.domain}` : ""}`, "");
@@ -542,21 +429,16 @@ export {
   REVIEW_ADAPTERS,
   SKILLS_CACHE_DIR,
   VERDICT_STEP,
-  changedFiles,
-  classifyDomain,
   configPath,
   declaredLibraryPathEnv,
-  defaultBaseRef,
   discoverLibraries,
   excludeCacheDir,
   fetchLibrary,
   gitExcludeFile,
-  globToRegExp,
   hydrateLibraryPathEnv,
   libraryCachePath,
   loadDomainKnowledge,
   loadOwnedPaths,
-  matchOwnedFiles,
   parityAdapter,
   parityReviewSteps,
   parseAdvisorSettings,
@@ -565,7 +447,6 @@ export {
   readConfig,
   referenceEnvName,
   referenceHint,
-  renderReviewChecklist,
   renderReviewHelp,
   resolveLibrary,
   resolveReference,

package/docs/CONTRIBUTING.md

@@ -88,8 +88,9 @@ command-local platform ladders for surface-owned behavior:
 - the runner reads `actions` (manifest, bundled semantic actions, live adapter
   scripts, `cdp.target`, the `ui.*` transport, adapter wrappers, input checks);
 - `install`/`verify`/`cleanup` read `harness`, `agentic-runtime.json` reads
-  `runtimeContext`, `doctor`/`status` read `readiness`, and `fixtures`,
-  `prepare`, `debug`, `reload` and `runtime-decision` read their own members.
+  `runtimeContext`, `doctor`/`status` read `readiness`, `prepare` reads
+  `readiness.prepare`, and `fixtures`, `debug`, `reload` and
+  `runtime-decision` read their own members.
 
 A few comparisons remain where a command exists for one platform
 (`resolve-extension`, `ensure-ready`, `runtime-launch`) or

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deeeed/metamask-harness",
-  "version": "0.92.21",
+  "version": "0.92.23",
   "type": "module",
   "bin": {
     "mm-harness": "bin/mm-harness"
@@ -24,11 +24,11 @@
     "@farmslot/adapter-node": "0.1.34",
     "@farmslot/adapter-rn": "0.22.23",
     "@farmslot/adapter-sdk": "0.18.0",
-    "@farmslot/adapter-web": "0.10.14",
+    "@farmslot/adapter-web": "0.10.15",
     "@farmslot/agent-runtime": "0.29.0",
     "@farmslot/handoff": "^0.3.1",
     "@farmslot/protocol": "0.54.0",
-    "@farmslot/recipe-cli": "0.23.0",
+    "@farmslot/recipe-cli": "0.23.1",
     "@farmslot/recipe-runner": "0.39.0",
     "agent-device": "0.19.3",
     "commander": "^12.0.0",