@deeeed/metamask-harness 0.92.22 → 0.92.23

package/CHANGELOG.md

@@ -2,6 +2,43 @@
 
 ## Unreleased
 
+## 0.92.23 - 2026-10-18
+
+### Changed
+
+- Pin `@farmslot/recipe-cli` 0.23.1 and `@farmslot/adapter-web` 0.10.15. A browser-extension launch no longer fails with `spawnSync ps ENOBUFS` on a host whose process list is over 1 MB.
+- `task init` and `execution-template` now run through the shared Farmslot handlers. Their output is unchanged.
+- `logs` now runs through the shared Farmslot handler:
+  - `--events` reaches the compact viewer as its argument; `logs` no longer sets `RECIPE_LOG_EVENTS` in its own environment.
+  - `--window` needs the dev-server log itself: when it is missing, `logs --window` exits 2 with `The primary log window is unavailable.` instead of opening a window on the missing file.
+  - `--full` runs `tail` as its own child, so stopping `mm-harness logs` also stops `tail`.
+  - A headless platform that declares logs is tailed; only one without logs is refused, naming that platform instead of always `core`.
+  - The "nothing running" error names the requested log only (on Extension it listed every log file).
+  - `--json` results include `target`.
+- `recipe-quality` now runs through the shared Farmslot handler: `plan` and `advise` use the detected platform when `--adapter` is absent, instead of exiting 2.
+- `checklist` now runs through the shared Farmslot handler:
+  - `mark` with `--checklist` or `--signal` checks the terminal signal and the check-diff gate against those files, not the defaults.
+  - `mark <task-dir> start` resumes a task whose signal is `blocked`.
+  - An explicit `--checklist` is used even when `checklist-target.json` is invalid.
+- `status` now runs through the shared Farmslot handler. The dashboard is unchanged: it still saves an explicit `--device` choice and shows no command journal.
+  - `status --task` and `status --watch` JSON, and each line under `--watch --json`, end with a `context` field (target and slot).
+  - The task view no longer reports another checkout's runtime context (an inherited `RECIPE_RUNTIME_CONTEXT`, or one whose `repoRoot` is elsewhere) as this checkout's slot, device and ports.
+- `doctor` now runs through the shared Farmslot handler. It still saves an explicit `--device` choice, and `--print-ready` still prints the Farmslot ready indicator.
+  - `--fix` prints one stderr progress line per repair stage, such as `[1/3] runtime-context: done, created, 0s` or `[3/3] host repair: failed, wallet-fixture, 0s`, with a heartbeat on a long stage. Stdout and the JSON are unchanged.
+  - A failing recorder without a next step no longer prints `Next: undefined`.
+  - Under `--expect-live --json`, a `RECORDER_UNAVAILABLE` error whose recorder gives no next step takes the runtime's next step as its `userAction`.
+  - `--fix` waits for a platform repair that returns a promise, and reports a rejected repair as failed instead of fixed.
+  - On a platform with both a recorder and live checks, the recorder check comes before the live checks in `checks` and `requiredChecks.failed`.
+- `review` and `domain` now run through the shared Farmslot handler. They keep every library this machine resolves (`RECIPE_LIBRARY_PATH`, `mm-harness config`, sibling checkouts, the fetch cache), `MM_HARNESS_DOMAIN`, and the checklist header, steps and verdict. `help review` is unchanged.
+  - `domain` names where a declared domain came from: `domain: declared via --domain` or `domain: declared via MM_HARNESS_DOMAIN` (it printed `declared via --domain or MM_HARNESS_DOMAIN`).
+  - `domain --domain <name> --json` outside a review checkout reports `"adapter": "unscoped"`, as `review --json` does (it reported `null`).
+  - When `domain` classifies against an `owned-paths.json` with an empty `domain` or invalid globs for the reviewed platform, it exits 2 with `Invalid owned-paths.json: <file>` or `Invalid owned paths for <platform>: <file>` (it exited 1 with a different message). `review checklist --domain` no longer reads the library's `owned-paths.json`.
+  - Setup step 2 names `review/antipatterns.<platform>.md` when the library has only that file (it named `review/antipatterns.md`).
+- `prepare` now runs through the shared Farmslot handler. Its steps, readiness record, refusals, Mobile device choice and exit codes are unchanged.
+  - Under `--json`, or when stdout or stderr is not a terminal, stderr gets a stage line per step (`[1/3] doctor --fix: started`, then `done` or `failed, <reason>`, with a heartbeat on a long step) and each step's own stage lines, prefixed with the step (`[1/3] doctor --fix › [1/3] runtime-context: done, created`). Stdout is unchanged.
+  - In a terminal, the running step's row shows its latest stage line instead of its hint.
+  - A platform plugin that declares `readiness.prepare` can be prepared.
+
 ## 0.92.22 - 2026-10-18
 
 ### Fixed

package/dist/adapters/core/surface.js

@@ -93,9 +93,8 @@ const coreSurface = defineAdapter({
       };
     }
   },
-  readiness: coreReadiness,
-  fixtures: { operations: ["init", "sync", "set"] },
-  prepare: corePrepare
+  readiness: { ...coreReadiness, prepare: corePrepare },
+  fixtures: { operations: ["init", "sync", "set"] }
 });
 adapterRegistry.register(coreSurface);
 export {

package/dist/adapters/extension/surface.js

@@ -148,12 +148,11 @@ const extensionSurface = defineAdapter({
   actions: extensionActions,
   harness: extensionHarness,
   runtimeContext: extensionRuntimeContext,
-  readiness: extensionReadiness,
+  readiness: { ...extensionReadiness, prepare: extensionPrepare },
   fixtures: {
     operations: ["init", "sync", "set", "reset", "generate", "finalize"],
     apply: async (context) => (await import("./fixtures.js")).applyExtensionFixture(context)
   },
-  prepare: extensionPrepare,
   debug: {
     refuse: ({ devMenu }) => devMenu ? { message: "--dev-menu is mobile-only (RN developer menu). Use --worker on the extension.", userAction: "mm-harness debug --worker" } : void 0,
     args: ({ worker }) => [

package/dist/adapters/mobile/devices.js

@@ -17,7 +17,6 @@ const mobileDevices = {
   renderList: renderMobileDeviceList,
   renderAdditional: renderAdditionalReachableDevices,
   renderLive: renderMobileLiveBlock,
-  renderPortHints: renderAndroidPortHints,
   renderHints: (live, paint) => renderAndroidPortHints(live.androidPortHints, paint),
   nextForLive
 };

package/dist/adapters/mobile/overlay.js

@@ -1,4 +1,4 @@
-import { mobilePlatformFromConfiguredTarget, mobilePlatformFromDevices, readRuntimeContextTarget } from "./prepare-target.js";
+import { mobilePlatformFromConfiguredTarget, mobilePlatformFromDevices, mobileTargetAmbiguityError, readRuntimeContextTarget } from "./prepare-target.js";
 const mobileHarness = {
   install: { entry: "adapters/mobile/inject.sh", fallback: "scripts/inject-mobile-harness.sh" },
   cleanup: { entry: "adapters/mobile/cleanup.sh", fallback: "scripts/cleanup-mobile-harness.sh", fromInstalledRunner: true },
@@ -18,7 +18,8 @@ const mobileRuntimeContext = {
 };
 const mobilePrepare = {
   clearMetro: true,
-  devicePlatform: (target, devices) => mobilePlatformFromConfiguredTarget(process.env, readRuntimeContextTarget(target)) ?? mobilePlatformFromDevices(devices)
+  devicePlatform: (target, devices) => mobilePlatformFromConfiguredTarget(process.env, readRuntimeContextTarget(target)) ?? mobilePlatformFromDevices(devices),
+  ambiguousTarget: mobileTargetAmbiguityError
 };
 export {
   mobileHarness,

package/dist/adapters/mobile/prepare-target.js

@@ -31,8 +31,21 @@ function mobilePlatformFromDevices(devices) {
   ];
   return platforms.length === 1 ? platforms[0] : void 0;
 }
+function mobileTargetAmbiguityError() {
+  const choices = [
+    "1. iOS     mm-harness prepare --platform mobile --mobile-platform ios",
+    "2. Android mm-harness prepare --platform mobile --mobile-platform android"
+  ];
+  return {
+    code: "PREPARE_MOBILE_TARGET_AMBIGUOUS",
+    message: "could not infer the mobile target from the connected devices",
+    userAction: `choose the mobile target, then rerun this command:
+${choices.join("\n")}`
+  };
+}
 export {
   mobilePlatformFromConfiguredTarget,
   mobilePlatformFromDevices,
+  mobileTargetAmbiguityError,
   readRuntimeContextTarget
 };

package/dist/adapters/mobile/surface.js

@@ -107,12 +107,11 @@ const mobileSurface = defineAdapter({
   actions: mobileActions,
   harness: mobileHarness,
   runtimeContext: mobileRuntimeContext,
-  readiness: mobileReadiness,
+  readiness: { ...mobileReadiness, prepare: mobilePrepare },
   fixtures: {
     operations: ["init", "sync", "set", "reset"],
     apply: async (context) => (await import("./fixtures.js")).applyMobileFixture(context)
   },
-  prepare: mobilePrepare,
   debug: {
     refuse: ({ worker }) => worker ? { message: "--worker is extension-only (service-worker DevTools). Use --dev-menu on mobile.", userAction: "mm-harness debug --dev-menu" } : void 0,
     args: ({ devMenu }) => [

package/dist/commands/doctor.js

@@ -1,308 +1,8 @@
-import { execFileSync } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
-import { featureFlagReport } from "../feature-flags.js";
-import { adapterPluginChecks, color, acquireCheckoutLock, contextAdapter, resolveRuntimeContextPath, ensureOverlay, newHealState, recipeRunning, adapterDetectNext, checkoutBusyOut, EXIT, usageOut, actionManifestPathOption, applyRuntimeDirOption, optionFlag, optionString, shellQuote, spawnScriptStreaming, doctorReady, renderDoctorRecorder, targetPath } from "@farmslot/recipe-cli/harness";
-import { collectCheckoutView, renderCheckoutView } from "../checkout-view.js";
-import { createDoctorReport, fixtureSummary, requiredDoctorCheckSummary } from "../doctor.js";
-import { assertAdapter, runnerDir } from "../paths.js";
-import { getAdapterSurface } from "../adapters/surface.js";
-import { loadActionManifest, validateManifest } from "../manifest.js";
-import { applyDeviceTargeting } from "./device-target.js";
-import { farmslotReadyIndicator } from "./farmslot-ready.js";
-import { updateStatus } from "./update.js";
-import { ensureRuntimeContext } from "../runtime-context.js";
-function applyDoctorRuntimePorts(options) {
-  const cdpPort = optionString(options, "cdpPort");
-  if (cdpPort) {
-    process.env.CDP_PORT = cdpPort;
-    process.env.RECIPE_CDP_PORT = cdpPort;
-  }
-  const watcherPort = optionString(options, "watcherPort") ?? optionString(options, "port");
-  if (watcherPort) {
-    process.env.WATCHER_PORT = watcherPort;
-    process.env.METRO_PORT = watcherPort;
-    process.env.RECIPE_WATCHER_PORT = watcherPort;
-  }
-}
-async function handleDoctor({ options }) {
-  applyRuntimeDirOption(options);
-  const target = targetPath(options);
-  const json = optionFlag(options, "json");
-  const printReady = optionFlag(options, "printReady");
-  const expectLive = optionFlag(options, "expectLive") || printReady;
-  const allDevices = optionFlag(options, "allDevices");
-  const platformOption = optionString(options, "platform");
-  const adapter = contextAdapter(target);
-  if (!adapter) {
-    return usageOut(json, "doctor", `could not detect the MetaMask repo type for ${target}`, adapterDetectNext());
-  }
-  assertAdapter(adapter);
-  const { readiness } = getAdapterSurface(adapter);
-  if (!fs.existsSync(target)) {
-    return usageOut(
-      json,
-      "doctor",
-      `target does not exist: ${target}`,
-      "pass --target <metamask-checkout> pointing to an existing checkout"
-    );
-  }
-  if (printReady && json) {
-    return usageOut(
-      json,
-      "doctor",
-      "--print-ready owns stdout for Farmslot health_check; drop --json (use --expect-live --json for the doctor envelope)",
-      "mm-harness doctor --print-ready --adapter <adapter> --target <path>"
-    );
-  }
-  const actionManifestPath = actionManifestPathOption(options, adapter);
-  const manifest = loadActionManifest(adapter, optionString(options, "actionManifest"));
-  const manifestValidation = await validateManifest(manifest);
-  if (optionFlag(options, "fix")) {
-    const surface = getAdapterSurface(adapter);
-    surface.resolveSlotPorts(target);
-    const dtResult = applyDeviceTargeting("doctor", adapter, options, { gate: false, rerun: "" });
-    if ("code" in dtResult) {
-      return usageOut(json, "doctor", dtResult.message, dtResult.userAction);
-    }
-    applyDoctorRuntimePorts(options);
-    const lock = acquireCheckoutLock(target, "doctor-fix");
-    if ("message" in lock) {
-      return checkoutBusyOut(json, "doctor", lock.message, lock.path);
-    }
-    let fixed;
-    let failed;
-    try {
-      ({ fixed, failed } = await runDoctorFix(adapter, target, manifestValidation, json));
-    } finally {
-      lock.release();
-    }
-    const result2 = createDoctorReport(adapter, target, manifestValidation, actionManifestPath);
-    let runtime2;
-    let runtimeProbeError2;
-    try {
-      runtime2 = await surface.runtimeStatus(target);
-    } catch (error2) {
-      runtimeProbeError2 = error2 instanceof Error ? error2.message : String(error2);
-    }
-    const recorder2 = runtime2?.decision === "ready" ? await readiness.recorder?.() : void 0;
-    const ready2 = doctorReady(runtime2, recorder2);
-    const block = readiness.runtimeBlock?.(target, runtime2);
-    if (block) failed.push(block.id);
-    if (recorder2?.status === "fail") failed.push(recorder2.id);
-    const nextActions = doctorFixNextActions(failed, result2.fixture, adapter, target, block);
-    if (recorder2?.status === "fail" && recorder2.userAction) nextActions.push(recorder2.userAction);
-    if (failed.length === 0 && runtime2?.decision !== "ready" && runtime2?.nextAction) nextActions.push(runtime2.nextAction);
-    const status = result2.status === "pass" && failed.length === 0 ? "pass" : "fail";
-    const retryDoctor = `mm-harness doctor --fix --adapter ${adapter} --target ${shellQuote(target)} --json`;
-    const fixUserAction = failed.includes("wallet-fixture") ? `choose one wallet fixture source from nextActions, run it, then retry: ${retryDoctor}` : nextActions[0] ?? retryDoctor;
-    const error = status === "fail" ? {
-      code: "DOCTOR_FIX_INCOMPLETE",
-      message: "doctor --fix could not make every required check pass",
-      userAction: fixUserAction
-    } : void 0;
-    if (json) console.log(JSON.stringify({ ...result2, status, fixed, failed, ready: ready2, runtime: runtime2, ...recorder2 ? { recorder: recorder2 } : {}, ...runtimeProbeError2 ? { runtimeProbeError: runtimeProbeError2 } : {}, nextActions, ...error ? { error } : {} }, null, 2));
-    else {
-      console.log(`${status} ${adapter} ${result2.compatibilityMode} ready=${ready2} manifest=${actionManifestPath} fixed=[${fixed.join(",")}] failed=[${failed.join(",")}]`);
-      if (runtime2) {
-        console.log(`runtime: decision=${runtime2.decision}${runtime2.reasonCode ? ` (${runtime2.reasonCode})` : ""}`);
-        for (const reason of runtime2.reasons) console.log(`  ${reason}`);
-      } else if (runtimeProbeError2) {
-        console.log(`runtime probe failed: ${runtimeProbeError2}`);
-      }
-      renderDoctorRecorder(recorder2);
-      for (const action of nextActions) console.error(`  Next: ${action}`);
-    }
-    return status === "pass" ? 0 : 1;
-  }
-  const result = createDoctorReport(
-    adapter,
-    target,
-    manifestValidation,
-    actionManifestPath,
-    platformOption
-  );
-  const view = collectCheckoutView(target, adapter);
-  const missingRequiredTool = result.checks.find(
-    (check) => check.required && check.status === "fail" && check.id.startsWith("device-tool-") && check.userAction
-  );
-  if (missingRequiredTool) {
-    const error = {
-      code: "DOCTOR_CHECKS_FAILED",
-      message: missingRequiredTool.message,
-      userAction: missingRequiredTool.userAction
-    };
-    if (json) {
-      console.log(JSON.stringify({ ...result, ready: false, error }, null, 2));
-    } else {
-      console.error(`\u2717 doctor: ${error.message}
-  Next: ${error.userAction}`);
-    }
-    return EXIT.runtime;
-  }
-  let runtime;
-  let runtimeProbeError;
-  try {
-    const surface = getAdapterSurface(adapter);
-    surface.resolveSlotPorts(target);
-    const dtResult = applyDeviceTargeting("doctor", adapter, options, { gate: false, rerun: "" });
-    if ("code" in dtResult) {
-      if (json) console.log(JSON.stringify({ schemaVersion: 1, command: "doctor", adapter, target, error: { code: dtResult.code, message: dtResult.message, userAction: dtResult.userAction } }, null, 2));
-      else console.error(`\u2717 doctor: ${dtResult.message}
-  Next: ${dtResult.userAction}`);
-      return EXIT.usage;
-    }
-    applyDoctorRuntimePorts(options);
-    runtime = await surface.runtimeStatus(target);
-  } catch (error) {
-    runtimeProbeError = error instanceof Error ? error.message : String(error);
-  }
-  const runtimeCheck = doctorRuntimeCheck(runtime, runtimeProbeError, expectLive);
-  const recorder = runtime?.decision === "ready" ? await readiness.recorder?.() : void 0;
-  const checks = [
-    ...result.checks,
-    runtimeCheck,
-    ...await readiness.liveChecks?.(target) ?? [],
-    ...recorder ? [recorder] : [],
-    ...await platformDoctorChecks(adapter, target),
-    // Which library plugin code this process loaded: library, module and digest.
-    ...adapterPluginChecks()
-  ];
-  const requiredChecks = requiredDoctorCheckSummary(checks);
-  const doctorResult = {
-    ...result,
-    status: requiredChecks.status,
-    checks,
-    requiredChecks
-  };
-  const orphanMetros = readiness.orphanDevServers?.(target, process.env.WATCHER_PORT) ?? [];
-  const capture = captureHealth(readiness.captureProviders);
-  const deviceSource = await readiness.devices?.();
-  const deviceView = deviceSource ? deviceSource.view(allDevices) : null;
-  const liveView = deviceSource && deviceView ? await deviceSource.live(target, deviceView) : null;
-  const devices = liveView?.devicesWithLive ?? deviceView?.devices ?? [];
-  const additionalReachableDevices = liveView?.additionalReachableDevices ?? [];
-  const discovery = deviceView?.deviceDiscoveryErrors.length ? { deviceDiscoveryErrors: deviceView.deviceDiscoveryErrors } : {};
-  if (expectLive) {
-    return emitExpectLive(
-      adapter,
-      target,
-      runtime,
-      recorder,
-      doctorResult,
-      orphanMetros,
-      capture,
-      devices,
-      additionalReachableDevices,
-      json,
-      printReady,
-      discovery
-    );
-  }
-  const skills = skillsView(target);
-  const update = updateStatus();
-  const pinnedFlags = readiness.pinnedFlags?.(target) ?? null;
-  const featureFlags = pinnedFlags ? featureFlagReport(pinnedFlags.overrides, pinnedFlags) : featureFlagReport(liveView?.featureFlagOverrides ?? null);
-  const doctorUserAction = doctorResult.checks.find(
-    (check) => check.required && check.status === "fail" && check.userAction
-  )?.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);
-  const ready = doctorReady(runtime, recorder);
-  if (json) console.log(JSON.stringify({ ...doctorResult, ready, runtime, ...recorder ? { recorder } : {}, view, orphanMetros, capture, skills, update, featureFlags, 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";
-    console.log(`${out(doctorResult.status === "pass" ? "ok" : "err", doctorResult.status)} ${out("bold", adapter)} ${doctorResult.compatibilityMode} ${out("dim", `manifest=${actionManifestPath}`)}`);
-    console.log(
-      `${out("label", "harness:")} ${doctorResult.runner.packageName}@${doctorResult.runner.version} ${out("accent", doctorResult.runner.installKind)} ${out("dim", `executable=${doctorResult.runner.executablePath}`)}`
-    );
-    if (runtime) {
-      const provisionedDepsPending = runtime.reasonCode === "app-installed-deps-pending";
-      const decisionStyle = provisionedDepsPending ? "info" : runtime.decision === "ready" ? "ok" : runtime.decision === "blocked" ? "err" : "warn";
-      const depsStyle = provisionedDepsPending ? "info" : stateStyle(runtime.deps, "current");
-      const devServerStyle = provisionedDepsPending ? "info" : void 0;
-      const devServer = runtime.devServer ? ` ${runtime.devServer.label}=${out(devServerStyle ?? stateStyle(runtime.devServer.status, "up"), runtime.devServer.status)}` : "";
-      console.log(
-        `${out("label", "runtime:")} decision=${out(decisionStyle, runtime.decision)}${runtime.reasonCode ? ` ${out("dim", `(${runtime.reasonCode})`)}` : ""} deps=${out(depsStyle, runtime.deps ?? "unknown")}${devServer}`
-      );
-      for (const reason of runtime.reasons) console.log(`  ${out("dim", reason)}`);
-    } else if (runtimeProbeError) {
-      console.log(`${out("err", "runtime probe failed:")} ${out("dim", runtimeProbeError)}`);
-    }
-    renderDoctorRecorder(recorder, out);
-    console.log(renderCheckoutView(view));
-    console.log(`${out("label", "feature flags:")} ${out(
-      featureFlags.error || (featureFlags.overrideCount ?? 0) > 0 ? "warn" : "dim",
-      featureFlags.summary.replace(/^feature flags: /u, "")
-    )}`);
-    for (const line of readiness.lines?.(target) ?? []) console.log(line);
-    if (orphanMetros.length > 0) {
-      console.log(
-        `${out("warn", "orphan Metro:")} ${orphanMetros.length} leaked bundler(s) for this checkout (pids ${orphanMetros.join(", ")})`
-      );
-      console.log(`  ${out("dim", "Next: mm-harness stop   # reaps every bundler this checkout leaked")}`);
-    }
-    if (capture) renderCaptureHealth(capture, out);
-    renderSkillsView(skills, out);
-    renderUpdateStatus(update, out);
-    if (deviceSource) {
-      if (deviceView) deviceSource.renderList(deviceView, out);
-      if (additionalReachableDevices.length > 0) deviceSource.renderAdditional(additionalReachableDevices, out);
-      if (liveView) deviceSource.renderLive(deviceView?.devices ?? [], liveView.liveMap, out);
-    }
-    if (next) console.log(`  ${out("dim", `Next: ${next}`)}`);
-  }
-  return doctorResult.status === "pass" ? 0 : 1;
-}
-import { doctorReady as doctorReady2 } from "@farmslot/recipe-cli/harness";
-async function platformDoctorChecks(adapter, target) {
-  try {
-    return await getAdapterSurface(adapter).doctor?.(target) ?? [];
-  } catch (error) {
-    return [{
-      id: `adapter-plugin:${adapter}:doctor`,
-      status: "fail",
-      required: true,
-      message: `${adapter}'s doctor checks failed to run.`,
-      detail: error instanceof Error ? error.message : String(error),
-      userAction: `fix the doctor() of the ${adapter} adapter, then rerun mm-harness doctor --adapter ${adapter}`
-    }];
-  }
-}
-function doctorRuntimeCheck(runtime, error, expectLive) {
-  if (error) {
-    return {
-      id: "runtime",
-      status: "fail",
-      required: true,
-      message: "Runtime readiness probe failed.",
-      detail: error
-    };
-  }
-  const ready = runtime?.decision === "ready";
-  return {
-    id: "runtime",
-    status: ready ? "pass" : "fail",
-    required: expectLive,
-    message: ready ? "Runtime is ready." : `Runtime is not ready${runtime?.reasonCode ? ` (${runtime.reasonCode})` : "."}`,
-    detail: runtime?.reasons.join(" | ") || "Runtime readiness probe returned no result."
-  };
-}
-function doctorFixNextActions(failed, fixture, adapter, target, block) {
-  const actions = [];
-  const executable = process.env.MM_HARNESS_EXECUTABLE ? shellQuote(process.env.MM_HARNESS_EXECUTABLE) : "mm-harness";
-  const scope = `--adapter ${adapter} --target ${shellQuote(target)}`;
-  actions.push(...doctorFixtureNextActions(failed, fixture, scope, executable));
-  if (failed.includes("runtime-context")) {
-    actions.push(
-      `inspect ${shellQuote(resolveRuntimeContextPath(target))}, then retry ${executable} doctor --fix ${scope}`
-    );
-  }
-  if (failed.includes("overlay")) actions.push(`${executable} install ${scope}`);
-  if (block?.userAction && failed.includes(block.id)) actions.push(block.userAction);
-  return actions;
-}
+import { shellQuote, spawnScriptStreaming } from "@farmslot/recipe-cli/harness";
+import { fixtureSummary } from "../doctor.js";
+import { runnerDir } from "../paths.js";
 function doctorFixtureNextActions(failed, fixture, scope, executable = process.env.MM_HARNESS_EXECUTABLE ? shellQuote(process.env.MM_HARNESS_EXECUTABLE) : "mm-harness") {
   const actions = [];
   if (failed.includes("wallet-fixture")) {
@@ -312,91 +12,6 @@ function doctorFixtureNextActions(failed, fixture, scope, executable = process.e
   }
   return actions;
 }
-function emitExpectLiveVerdict(adapter, target, runtime, verdict, recorder) {
-  const out = (style, text) => color(style, text, { stream: process.stderr });
-  const detail = runtime ? `${runtime.decision}${runtime.reasonCode ? ` (${runtime.reasonCode})` : ""}` : "runtime probe unavailable";
-  console.error(`${out("err", verdict)} ${out("bold", adapter)} ${detail} ${out("dim", target)}`);
-  for (const reason of runtime?.reasons ?? []) console.error(`  ${out("dim", reason)}`);
-  if (recorder?.status === "fail") {
-    console.error(`  ${out("err", "recorder:")} ${recorder.message}${recorder.detail ? ` ${out("dim", recorder.detail)}` : ""}`);
-    console.error(`  Next: ${recorder.userAction}`);
-    return;
-  }
-  console.error(`  Next: ${runtime?.nextAction ?? getAdapterSurface(adapter).hints.runtimeProbeRecovery(target)}`);
-}
-function emitExpectLive(adapter, target, runtime, recorder, result, orphanMetros, capture, devices, additionalReachableDevices, json, printReady, discovery) {
-  const live = runtime?.decision === "ready";
-  const ready = doctorReady(runtime, recorder);
-  if (printReady) {
-    if (ready) {
-      const indicator = farmslotReadyIndicator(adapter, devices);
-      if (indicator) {
-        console.log(indicator);
-        return EXIT.ok;
-      }
-      emitExpectLiveVerdict(adapter, target, runtime, "not-ready");
-      return EXIT.runtime;
-    }
-    emitExpectLiveVerdict(adapter, target, runtime, live ? "not-ready" : "not-live", recorder);
-    return EXIT.runtime;
-  }
-  if (json) {
-    const userAction = runtime?.nextAction ?? getAdapterSurface(adapter).hints.runtimeProbeRecovery(target);
-    const error = !live ? { code: "RUNTIME_NOT_LIVE", message: `${adapter} runtime is not live`, userAction } : !ready ? { code: "RECORDER_UNAVAILABLE", message: recorder.message, userAction: recorder.userAction } : void 0;
-    console.log(JSON.stringify({ ...result, ready, runtime, ...recorder ? { recorder } : {}, orphanMetros, capture, devices, additionalReachableDevices, ...discovery, ...error ? { error } : {} }, null, 2));
-    return ready ? EXIT.ok : EXIT.runtime;
-  }
-  const out = (style, text) => color(style, text, { stream: process.stdout });
-  if (ready) {
-    console.log(`${out("ok", "live")} ${out("bold", adapter)} runtime ready`);
-    return EXIT.ok;
-  }
-  emitExpectLiveVerdict(adapter, target, runtime, live ? "not-ready" : "not-live", recorder);
-  return EXIT.runtime;
-}
-function captureHealth(providers) {
-  if (!providers) return null;
-  const fallback = [...providers];
-  const helper = captureHelperHealth();
-  if (!helper) {
-    return {
-      status: "fallback",
-      failing: [],
-      screenshots: { available: true, providers: fallback },
-      recording: { available: false, provider: null }
-    };
-  }
-  return {
-    status: helper.status,
-    failing: helper.failing,
-    screenshots: { available: true, providers: ["capture-helper", ...fallback] },
-    recording: { available: helper.status === "pass", provider: helper.status === "pass" ? "capture-helper" : null }
-  };
-}
-function captureHelperHealth() {
-  if (process.platform !== "darwin") return null;
-  const bin = process.env.CAPTURE_HELPER_PATH || "capture-helper";
-  try {
-    const out = execFileSync(bin, ["doctor", "--json"], { encoding: "utf8", timeout: 1e4, stdio: ["ignore", "pipe", "ignore"] });
-    const parsed = JSON.parse(out);
-    const failing = (parsed.checks ?? []).filter((c) => c.required === true && c.ok === false).map((c) => c.name ?? c.id ?? "check");
-    return { status: parsed.ok === true && failing.length === 0 ? "pass" : "warn", failing };
-  } catch {
-    return null;
-  }
-}
-function renderCaptureHealth(capture, out) {
-  const video = capture.recording.available ? "capture-helper" : "unavailable";
-  console.log(
-    `${out("label", "capture:")} ${out(capture.status === "pass" ? "ok" : "warn", capture.status)} ${out("dim", `(screenshots: ${capture.screenshots.providers.join(" \u2192 ")}; video: ${video})`)}`
-  );
-  if (capture.status === "warn") {
-    if (capture.failing.length > 0) console.log(`  ${out("dim", `failing: ${capture.failing.join(", ")}`)}`);
-    console.log(`  ${out("dim", "Next: grant Screen Recording (System Settings \u2192 Privacy & Security \u2192 Screen Recording), or run: capture-helper doctor --open-permissions")}`);
-  } else if (capture.status === "fallback") {
-    console.log(`  ${out("dim", "Next: screenshots work without capture-helper; install/configure capture-helper only when recipe video is required")}`);
-  }
-}
 const SKILL_ROOTS = [path.join(".claude", "skills"), path.join(".agents", "skills")];
 function skillsView(target) {
   const names = /* @__PURE__ */ new Set();
@@ -432,38 +47,6 @@ function renderUpdateStatus(status, out) {
     status.updateAvailable ? `${out("label", "update:")} ${out("warn", `${status.current} \u2192 ${status.latest} available`)} ${out("dim", "(mm-harness update)")}` : status.latest && status.latest !== status.current ? `${out("label", "update:")} ${out("ok", status.current)} ${out("dim", `ahead of registry ${status.latest}`)}` : `${out("label", "update:")} ${out("ok", `${status.current} is latest`)}`
   );
 }
-async function runDoctorFix(adapter, target, manifestValidation, json) {
-  const fixed = [];
-  const failed = [];
-  if (recipeRunning(target)) {
-    failed.push("recipe-running");
-    return { fixed, failed };
-  }
-  if (Number(manifestValidation.summary?.errors ?? 0) > 0) failed.push("manifest");
-  try {
-    const surface = getAdapterSurface(adapter);
-    surface.resolveSlotPorts(target);
-    const runtimeContext = ensureRuntimeContext(target, adapter);
-    if (runtimeContext.created) fixed.push("runtime-context");
-  } catch {
-    failed.push("runtime-context");
-  }
-  for (const fix of getAdapterSurface(adapter).readiness.fixes ?? []) {
-    try {
-      if (fix.apply(target)) fixed.push(fix.id);
-    } catch {
-      failed.push(fix.id);
-    }
-  }
-  const state = newHealState();
-  const ensured = await ensureOverlay(adapter, target, "infra-only", state, json);
-  if (!ensured.ok) failed.push("overlay");
-  else if (state.mutations.length > 0) fixed.push("overlay");
-  const fixture = await repairDoctorFixture(target, adapter, json);
-  fixed.push(...fixture.fixed);
-  failed.push(...fixture.failed);
-  return { fixed, failed };
-}
 async function repairDoctorFixture(target, adapter, json) {
   if (fixtureSummary(target, adapter).status === "ready") return { fixed: [], failed: [] };
   const syncFixture = path.join(runnerDir, "adapters/shared/sync-wallet-fixture.sh");
@@ -474,10 +57,7 @@ async function repairDoctorFixture(target, adapter, json) {
   return fixtureSummary(target, adapter).status === "ready" ? { fixed: ["wallet-fixture"], failed: [] } : { fixed: [], failed: ["wallet-fixture"] };
 }
 export {
-  doctorFixNextActions,
   doctorFixtureNextActions,
-  doctorReady2 as doctorReady,
-  handleDoctor,
   renderSkillsView,
   renderUpdateStatus,
   repairDoctorFixture,