@deeeed/metamask-harness 0.92.22 → 0.92.24

package/dist/commands/review.js

@@ -9,11 +9,9 @@ import {
   readConfig,
   referenceHint,
   REVIEW_ADAPTERS,
-  renderReviewChecklist,
   renderReviewHelp,
   resolveLibrary,
-  resolveReference,
-  defaultBaseRef
+  resolveReference
 } from "../review/knowledge.js";
 const EXIT_OK = 0;
 let cachedHarnessVersion;
@@ -32,16 +30,15 @@ function adapterFromOptions() {
   }
   return scope ?? "unscoped";
 }
-function resolveReviewContext(options, { fetch = true } = {}) {
+function resolveReviewContext(options) {
   const target = targetPath(options);
   const adapter = adapterFromOptions();
   const domain = optionString(options, "domain") ?? process.env.MM_HARNESS_DOMAIN;
   const config = readConfig(configPath());
   const context = { target, adapter, ...domain ? { domain } : {} };
   if (domain) {
-    const library = resolveLibrary(domain, { target, config, fetch });
+    const library = resolveLibrary(domain, { target, config });
     if (library) context.knowledge = loadDomainKnowledge(library, adapter === "unscoped" ? void 0 : adapter);
-    else if (fetch) throw usageError(`No library found for domain "${domain}". Set RECIPE_LIBRARY_PATH="${domain}=<path>" or run: mm-harness config set libraries.${domain} <path>`);
   }
   const parity = parityAdapter(adapter);
   if (parity) {
@@ -53,7 +50,7 @@ function resolveReviewContext(options, { fetch = true } = {}) {
 }
 function handleHelpReview(argv, harnessVersion2) {
   const parsed = parseArgs(argv);
-  const context = resolveReviewContext(parsed.options, { fetch: false });
+  const context = resolveReviewContext(parsed.options);
   const input = {
     adapter: context.adapter,
     harnessVersion: harnessVersion2,
@@ -70,66 +67,8 @@ function handleHelpReview(argv, harnessVersion2) {
   }
   return EXIT_OK;
 }
-async function handleReview(argv, version = harnessVersion()) {
-  const parsed = parseArgs(argv);
-  const subcommand = parsed.positional[0];
-  if (subcommand !== "checklist") {
-    throw usageError("Usage: mm-harness review checklist [--domain <name>] [--since <sha>] [--base <ref>] [--out <file>] [--json]");
-  }
-  const context = resolveReviewContext(parsed.options);
-  const since = optionString(parsed.options, "since");
-  const base = optionString(parsed.options, "base") ?? defaultBaseRef(context.target);
-  const checklist = renderReviewChecklist({
-    adapter: context.adapter,
-    target: context.target,
-    base,
-    harnessVersion: version,
-    ...since ? { since } : {},
-    ...context.domain ? { domain: context.domain } : {},
-    ...context.knowledge ? { knowledge: context.knowledge } : {},
-    ...context.reference ? { reference: context.reference } : {},
-    ...context.referenceMissing ? { referenceMissing: context.referenceMissing } : {}
-  });
-  const out = optionString(parsed.options, "out");
-  if (out) {
-    const file = path.resolve(out);
-    fs.mkdirSync(path.dirname(file), { recursive: true });
-    fs.writeFileSync(file, checklist);
-  }
-  if (optionFlag(parsed.options, "json")) {
-    process.stdout.write(
-      `${JSON.stringify(
-        {
-          command: "review",
-          subcommand: "checklist",
-          target: context.target,
-          adapter: context.adapter,
-          domain: context.domain ?? null,
-          library: context.knowledge?.library ?? null,
-          reference: context.reference ?? null,
-          referenceMissing: context.referenceMissing ?? null,
-          base,
-          since: since ?? null,
-          out: out ? path.resolve(out) : null,
-          checklist
-        },
-        null,
-        2
-      )}
-`
-    );
-  } else if (out) {
-    process.stdout.write(`review checklist: ${path.resolve(out)}
-`);
-  } else {
-    process.stdout.write(checklist);
-  }
-  return EXIT_OK;
-}
 export {
   adapterFromOptions,
   handleHelpReview,
-  handleReview,
-  harnessVersion,
-  resolveReviewContext
+  harnessVersion
 };

package/dist/doctor.js

@@ -5,16 +5,6 @@ import { normalizeFeatureFlagRecord } from "./feature-flags.js";
 import { getAdapterSurface } from "./adapters/surface.js";
 import { isPin } from "./harness-pin.js";
 import { readJson } from "./paths.js";
-function requiredDoctorCheckSummary(checks) {
-  const required = checks.filter((check) => check.required);
-  const failed = required.filter((check) => check.status === "fail").map((check) => check.id);
-  return {
-    status: failed.length === 0 ? "pass" : "fail",
-    total: required.length,
-    passed: required.length - failed.length,
-    failed
-  };
-}
 function repoShape(target) {
   const exists = (rel) => fs.existsSync(path.join(target, rel));
   const packageInfo = readPackageInfo(target);
@@ -188,7 +178,6 @@ export {
   fixtureSummary,
   renderRuntimeContext,
   repoShape,
-  requiredDoctorCheckSummary,
   runnerInstallKind,
   runnerProvenance,
   runtimeContextSummary

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
 };