@deeeed/metamask-harness 0.67.1 → 0.68.0

package/dist/commands/checklist.js

@@ -12,6 +12,7 @@ const MARK_SCRIPT = require2.resolve(
 const { resolveChecklistPaths } = require2(
   "@farmslot/agent-runtime/scripts/checklist-target.cjs"
 );
+const { readSubtaskIndex, SubtaskRefusal } = require2("@farmslot/agent-runtime/scripts/subtask-unit.cjs");
 const USAGE = "mm-harness checklist <mark <task-dir> <step> | closeout <task-dir>> [options]";
 const CHECKLIST_VALUE_OPTIONS = /* @__PURE__ */ new Set([
   "--reason",
@@ -129,10 +130,10 @@ function checklistStepRequiresDiffPass(checklist, stepNumber) {
   const step = enumerateChecklistCheckboxes(checklist).find((item) => item.stepNumber === stepNumber);
   return step !== void 0 && /mm-harness check diff/u.test(step.rawLabel);
 }
-function checkDiffGateReady(taskDir, step) {
+function checkDiffGateReady(taskDir, step, parentChecklist) {
   const stepNumber = numericMarkStep(step);
   if (stepNumber === null) return true;
-  const { taskPath } = resolveChecklistPaths(taskDir);
+  const taskPath = parentChecklist ? path.join(taskDir, parentChecklist) : resolveChecklistPaths(taskDir).taskPath;
   let checklist = "";
   try {
     checklist = fs.readFileSync(taskPath, "utf8");
@@ -203,6 +204,16 @@ async function handleChecklist(argv) {
     return EXIT.usage;
   }
   if (preserveTerminalSignal(resolvedTaskDir, step)) return EXIT.ok;
+  if (step === "sub" && forwarded[2] === "complete") {
+    try {
+      const unit = readSubtaskIndex(resolvedTaskDir)?.units.find((unit2) => unit2.id === forwarded[1]);
+      if (unit && !checkDiffGateReady(resolvedTaskDir, String(unit.parent.stepNumber), unit.parent.checklist)) return EXIT.runtime;
+    } catch (error) {
+      if (!(error instanceof SubtaskRefusal)) throw error;
+      console.error(error.message);
+      return error.code;
+    }
+  }
   if (!checkDiffGateReady(resolvedTaskDir, step)) return EXIT.runtime;
   teachRecipeCompletion(resolvedTaskDir, step);
   const result = spawnSync(

package/dist/commands/fixtures.js

@@ -559,13 +559,12 @@ async function fixturesFinalize(adapter, target, options, json) {
   }
   return exitCode;
 }
-function fixturesSync(adapter, target, json) {
+async function fixturesSync(adapter, target, json) {
   const mmHarnessBin = path.join(runnerDir, "bin/mm-harness");
-  const installResult = spawnScript(
+  const installResult = await spawnScriptStreaming(
     mmHarnessBin,
     ["install", "--adapter", adapter, "--target", target],
-    target,
-    json
+    target
   );
   if (installResult.status !== 0) {
     if (!json) {
@@ -578,7 +577,7 @@ function fixturesSync(adapter, target, json) {
   const syncArgs = ["--target", target];
   if (process.env.CDP_PORT) syncArgs.push("--cdp-port", process.env.CDP_PORT);
   if (process.env.RECIPE_SLOT_ID) syncArgs.push("--slot-id", process.env.RECIPE_SLOT_ID);
-  const syncResult = spawnScript(syncFixtureSh, syncArgs, target, json);
+  const syncResult = await spawnScriptStreaming(syncFixtureSh, syncArgs, target);
   if (syncResult.status !== 0 || fixtureSummary(target, adapter).status !== "ready") {
     if (!json) console.error("\u2717 no usable wallet fixture source was found.\n  Next: mm-harness fixtures init --from <path>   or   mm-harness fixtures init --dev");
     return EXIT.runtime;

package/dist/commands/prepare.js

@@ -1,4 +1,7 @@
+import { acquireCheckoutLock, trackCheckoutChild } from "../checkout-lock.js";
+import { recordCommandStage } from "../command-journal.js";
 import { spawn } from "node:child_process";
+import { OperationOutputTail } from "@farmslot/recipe-harness/runtime/operation";
 import fs from "node:fs";
 import path from "node:path";
 import {
@@ -168,18 +171,19 @@ function spawnStep(executable, args, target) {
       // stream a recorded readiness step captures.
       env: { ...process.env, MM_HARNESS_NO_UPDATE_CHECK: "1" }
     });
+    if (child.pid) trackCheckoutChild(target, child.pid);
     let stdout = "";
-    let stderr = "";
+    const stderr = new OperationOutputTail();
     child.stdout?.setEncoding("utf8");
     child.stderr?.setEncoding("utf8");
     child.stdout?.on("data", (chunk) => {
       stdout += chunk;
     });
     child.stderr?.on("data", (chunk) => {
-      stderr += chunk;
+      stderr.append(chunk);
     });
-    child.on("error", (error) => resolve({ error, status: null, stdout, stderr }));
-    child.on("close", (status) => resolve({ status, stdout, stderr }));
+    child.on("error", (error) => resolve({ error, status: null, stdout, stderr: stderr.toString() }));
+    child.on("close", (status) => resolve({ status, stdout, stderr: stderr.toString() }));
   });
 }
 async function runStep(executable, target, artifactsDir, id, args, { json, onSpawn }) {
@@ -305,6 +309,22 @@ function resolvePlatform(requested, target) {
   );
 }
 async function handlePrepare(argv) {
+  const { options } = parseArgs(argv, "prepare");
+  const target = targetPath(options);
+  if (!fs.existsSync(target)) return handlePrepareLocked(argv);
+  const lock = acquireCheckoutLock(target, "prepare");
+  if ("message" in lock) {
+    if (optionFlag(options, "json")) console.log(JSON.stringify({ status: "fail", error: { code: "SANDBOX_BUSY", message: lock.message }, exitCode: EXIT.runtime }));
+    else console.error(`${lock.message} Next: inspect the owning operation with mm-harness status --watch`);
+    return EXIT.runtime;
+  }
+  try {
+    return await handlePrepareLocked(argv);
+  } finally {
+    lock.release();
+  }
+}
+async function handlePrepareLocked(argv) {
   const { options } = parseArgs(argv, "prepare");
   const json = optionFlag(options, "json");
   const target = targetPath(options);
@@ -372,6 +392,7 @@ async function handlePrepare(argv) {
     const step = await runStep(executable, target, artifactsDir, id, args, {
       json,
       onSpawn: (stepStartedAt) => {
+        recordCommandStage(id);
         activeStep = { id, startedAt: new Date(stepStartedAt).toISOString() };
         writeProgress();
         view?.start(id, stepStartedAt);

package/dist/commands/run-engine.js

@@ -20,7 +20,8 @@ import {
 import {
   importRecipeHarness,
   importRecipeProtocol,
-  runnerDir
+  runnerDir,
+  recipeRuntimePath
 } from "../paths.js";
 import { captureHelperSupportsRecordSessionSnapshots } from "../recording-target.js";
 import { startRecipeRecording, stopRecipeRecording } from "../run-recording.js";
@@ -277,7 +278,11 @@ async function resolveRecipeExecution(adapter, recipe, artifactsDir, projectRoot
     recipeDocument: recipeDocument ?? recipe,
     ...absoluteRecipePath ? { recipePath: absoluteRecipePath } : {},
     ...librarySources ? { librarySources } : {},
-    excludedProductRoots: [absoluteArtifactsDir],
+    excludedProductRoots: [
+      absoluteArtifactsDir,
+      recipeRuntimePath(projectRoot, "operations"),
+      recipeRuntimePath(projectRoot, "lock-members")
+    ],
     helperPaths: commandHelperPaths(recipeDocument ?? recipe, projectRoot)
   };
   const startProvenance = await captureExecutionProvenance(
@@ -416,6 +421,7 @@ function runtimeRecipeDocument(recipe, absoluteRecipePath) {
 function recipeProcessEnvironment() {
   const env = { ...process.env };
   delete env.MM_HARNESS_CHECKOUT_LOCK_TOKEN;
+  delete env.MM_HARNESS_OPERATION_ID;
   return env;
 }
 function executionLibrarySources(sources, invocationTrust) {

package/dist/commands/runtime-launch.js

@@ -1,4 +1,5 @@
-import { spawnSync } from "node:child_process";
+import { checkoutBusyOut, spawnScriptStreaming } from "./shared.js";
+import { acquireCheckoutLock } from "../checkout-lock.js";
 import fs from "node:fs";
 import path from "node:path";
 import {
@@ -23,7 +24,18 @@ import {
   usageError
 } from "./parse-args.js";
 import { FeatureFlagSpecError, parseRemoteFlagSpec } from "../feature-flags.js";
-async function handleRuntimeLaunch({ options }) {
+async function handleRuntimeLaunch(args) {
+  const target = targetPath(args.options);
+  if (optionFlag(args.options, "help") || !fs.existsSync(target)) return handleRuntimeLaunchLocked(args);
+  const lock = acquireCheckoutLock(target, "runtime-launch");
+  if ("message" in lock) return checkoutBusyOut(optionFlag(args.options, "json"), "runtime-launch", lock.message, lock.path);
+  try {
+    return await handleRuntimeLaunchLocked(args);
+  } finally {
+    lock.release();
+  }
+}
+async function handleRuntimeLaunchLocked({ options }) {
   if (optionFlag(options, "help")) {
     console.log(`mm-harness runtime-launch --adapter <extension|mobile> --target <checkout> [flags]
 
@@ -186,11 +198,11 @@ async function handleRuntimeLaunch({ options }) {
       cdpPort
     }));
   }
-  const result = spawnSync(command[0], command.slice(1), {
-    cwd: target,
-    encoding: "utf8",
-    maxBuffer: 5 * 1024 * 1024,
-    stdio: jsonMode ? ["ignore", "pipe", "pipe"] : "inherit"
+  const result = await spawnScriptStreaming(command[0], command.slice(1), target, {
+    forward: jsonMode ? "stderr" : "original",
+    stdin: jsonMode ? "ignore" : "inherit",
+    capture: false,
+    stage: mode
   });
   const summaryPath = path.join(artifactsDir, "summary.json");
   const summary = readJsonIfExists(summaryPath);

package/dist/commands/shared.js

@@ -1,4 +1,8 @@
+import { trackCheckoutChild } from "../checkout-lock.js";
+import { recordCommandOutput, recordCommandStage } from "../command-journal.js";
 import { spawn, spawnSync } from "node:child_process";
+import { StringDecoder } from "node:string_decoder";
+import { OperationOutputTail } from "@farmslot/recipe-harness/runtime/operation";
 import path from "node:path";
 import { detectAdapter } from "../harness.js";
 import { colorHumanMessage } from "../cli-color.js";
@@ -81,6 +85,7 @@ function spawnScript(script, args, cwd, json, env) {
     return { status: 1, output: message };
   }
   const { bin: invokeBin, args: spawnArgs } = resolveLeafInvoke(bin, directArgs);
+  recordCommandStage(path.basename(isNodeScript ? args[0] : script));
   const result = spawnSync(invokeBin, spawnArgs, {
     cwd,
     encoding: "utf8",
@@ -97,6 +102,7 @@ function spawnScript(script, args, cwd, json, env) {
     return { status: 1, output: message };
   }
   const output = `${result.stdout ?? ""}${result.stderr ?? ""}`;
+  recordCommandOutput(output);
   if (!json && output) process.stderr.write(output);
   return { status: result.status ?? 1, output };
 }
@@ -122,7 +128,7 @@ function spawnInherit(script, args, cwd) {
   return result.signal === "SIGINT" || result.signal === "SIGTERM" ? 0 : 1;
 }
 function spawnScriptStreaming(script, args, cwd, options) {
-  const spawnOptions = options && ("env" in options || "timeoutMs" in options) ? options : { env: options };
+  const spawnOptions = options && ("env" in options || "timeoutMs" in options || "forward" in options || "capture" in options || "stdin" in options || "stage" in options) ? options : { env: options };
   const isNodeScript = script === process.execPath && args.length > 0;
   const stem = isNodeScript ? path.basename(args[0]).replace(/[^A-Za-z0-9]/gu, "_").toUpperCase() : path.basename(script).replace(/[^A-Za-z0-9]/gu, "_").toUpperCase();
   const override = process.env[`MM_HARNESS_SCRIPT_BIN_${stem}`];
@@ -131,26 +137,41 @@ function spawnScriptStreaming(script, args, cwd, options) {
   if (shellLeafMissing(bin)) {
     const message = `leaf could not start: ${path.basename(bin)} (ENOENT)
   Next: reinstall mm-harness (npm i -g @deeeed/metamask-harness) \u2014 the shell leaf is missing or not executable`;
-    process.stderr.write(`${message}
+    if (spawnOptions.forward !== "none") process.stderr.write(`${message}
 `);
     return Promise.resolve({ status: 1, output: message });
   }
   const { bin: invokeBin, args: spawnArgs } = resolveLeafInvoke(bin, directArgs);
-  return new Promise((resolve) => {
-    const ownsProcessGroup = process.platform !== "win32" && Number(spawnOptions.timeoutMs) > 0;
+  recordCommandStage(spawnOptions.stage ?? path.basename(isNodeScript ? args[0] : script));
+  return new Promise((resolve, reject) => {
+    const ownsProcessGroup = process.platform !== "win32";
     const child = spawn(invokeBin, spawnArgs, {
       cwd,
       env: spawnOptions.env ? { ...process.env, ...spawnOptions.env } : process.env,
-      stdio: ["ignore", "pipe", "pipe"],
+      stdio: [spawnOptions.stdin ?? "ignore", "pipe", "pipe"],
       detached: ownsProcessGroup
     });
-    let output = "";
+    let untrack;
+    try {
+      untrack = child.pid ? trackCheckoutChild(cwd, child.pid, ownsProcessGroup) : void 0;
+    } catch (error) {
+      child.once("error", reject);
+      child.once("close", () => reject(error));
+      try {
+        if (ownsProcessGroup && child.pid) process.kill(-child.pid, "SIGKILL");
+        else child.kill("SIGKILL");
+      } catch (killError) {
+        if (killError.code !== "ESRCH") reject(killError);
+      }
+      return;
+    }
+    const captured = new OperationOutputTail();
     let settled = false;
     let didTimeout = false;
     let escalation;
     let forwardedParentSignal;
     let parentSignalFallback;
-    const parentSignals = ["SIGINT", "SIGTERM"];
+    const parentSignals = ["SIGINT", "SIGTERM", "SIGHUP", "SIGQUIT"];
     const removeParentSignalHandlers = () => {
       for (const signal of parentSignals) process.removeListener(signal, parentSignalHandlers[signal]);
     };
@@ -182,7 +203,7 @@ function spawnScriptStreaming(script, args, cwd, options) {
       forwardedParentSignal = signal;
       signalChildTree(signal);
       removeParentSignalHandlers();
-      parentSignalFallback = setTimeout(() => {
+      if (Number(spawnOptions.timeoutMs) > 0) parentSignalFallback = setTimeout(() => {
         signalChildTree("SIGKILL");
         exitFromForwardedSignal();
       }, 1e3);
@@ -194,31 +215,35 @@ function spawnScriptStreaming(script, args, cwd, options) {
     const timer = Number.isFinite(timeoutMs) && Number(timeoutMs) > 0 ? setTimeout(() => {
       didTimeout = true;
       const message = `leaf timed out after ${String(timeoutMs)}ms: ${path.basename(script)}`;
-      output += `${output.endsWith("\n") || output.length === 0 ? "" : "\n"}${message}
-`;
-      process.stderr.write(`${message}
+      captured.append(`
+${message}
+`);
+      if (spawnOptions.forward !== "none") process.stderr.write(`${message}
 `);
       signalChildTree("SIGTERM");
       escalation = setTimeout(() => {
         signalChildTree("SIGKILL");
-        finish({ status: 1, output, timedOut: true, timeoutMs: Number(timeoutMs) });
+        finish({ status: 1, output: captured.toString(), timedOut: true, timeoutMs: Number(timeoutMs) });
       }, 1e3);
     }, Number(timeoutMs)) : void 0;
-    const tee = (chunk) => {
-      const text = chunk.toString("utf8");
-      output += text;
-      process.stderr.write(text);
+    const decoders = [new StringDecoder("utf8"), new StringDecoder("utf8")];
+    const tee = (chunk, stdout = false) => {
+      if (spawnOptions.capture !== false) captured.append(decoders[stdout ? 0 : 1].write(chunk));
+      recordCommandOutput(chunk);
+      if (spawnOptions.forward !== "none") {
+        (stdout && spawnOptions.forward === "original" ? process.stdout : process.stderr).write(chunk);
+      }
     };
-    child.stdout?.on("data", tee);
+    child.stdout?.on("data", (chunk) => tee(chunk, true));
     child.stderr?.on("data", tee);
     child.on("error", (error) => {
       const leaf = isNodeScript ? path.basename(args[0]) : path.basename(script);
       const code = error.code ?? "ESPAWN";
       const message = `leaf could not start: ${leaf} (${code})
   Next: reinstall mm-harness (npm i -g @deeeed/metamask-harness) \u2014 the shell leaf is missing or not executable`;
-      process.stderr.write(`${message}
+      if (spawnOptions.forward !== "none") process.stderr.write(`${message}
 `);
-      finish({ status: 1, output: message });
+      finish({ status: 1, output: message, error });
     });
     child.on("exit", () => {
       if (forwardedParentSignal) {
@@ -227,13 +252,15 @@ function spawnScriptStreaming(script, args, cwd, options) {
       }
       if (!didTimeout) return;
       signalChildTree("SIGKILL");
-      finish({ status: 1, output, timedOut: true, timeoutMs: Number(timeoutMs) });
+      finish({ status: 1, output: captured.toString(), timedOut: true, timeoutMs: Number(timeoutMs) });
     });
     child.on("close", (status) => {
+      if (status !== null) untrack?.();
+      if (spawnOptions.capture !== false) captured.append(decoders.map((decoder) => decoder.end()).join(""));
       if (didTimeout) signalChildTree("SIGKILL");
       finish({
         status: didTimeout ? 1 : status ?? 1,
-        output,
+        output: captured.toString(),
         ...didTimeout ? { timedOut: true, timeoutMs: Number(timeoutMs) } : {}
       });
     });

package/dist/commands/status-watch.js

@@ -118,6 +118,7 @@ function renderTaskView(view, title, explicitTask = false) {
       last.ageMs !== void 0 && `${formatDuration(last.ageMs)} ago`
     ]));
   }
+  lines.push(...renderOperations(view));
   lines.push("");
   if (!view.activity.ongoing) {
     lines.push(out("warn", "no ongoing task detected"));
@@ -190,6 +191,12 @@ function changedLines(previous, next) {
     ];
   }
   const lines = [];
+  for (const operation of next.operations) {
+    const before2 = previous.operations.find((entry) => entry.id === operation.id);
+    if (!before2 || before2.status !== operation.status || before2.stage !== operation.stage || before2.ownerAlive !== operation.ownerAlive) {
+      lines.push(`operation ${operation.command} ${operation.status}${operation.stage ? ` \xB7 ${operation.stage}` : ""} \xB7 log ${operation.logPath}`);
+    }
+  }
   for (const step of next.prepare?.steps ?? []) {
     if (!previous.prepare?.steps.some((prior) => prior.id === step.id && prior.status === step.status)) {
       lines.push(`prepare ${step.id} ${step.status} (${formatDuration(step.durationMs)})`);
@@ -285,6 +292,22 @@ function shortUdid(udid) {
 function joinParts(parts, separator = " \xB7 ") {
   return parts.filter((part) => Boolean(part)).join(separator);
 }
+function renderOperations(view) {
+  const active = view.operations.filter((operation) => operation.status === "running" && operation.ownerAlive);
+  const selected = active.length ? active : view.operations.slice(-1);
+  return selected.flatMap((operation) => {
+    const elapsed = Date.parse(operation.finishedAt ?? (/* @__PURE__ */ new Date()).toISOString()) - Date.parse(operation.startedAt);
+    const state = operation.status === "running" ? operation.ownerAlive ? "owner alive" : "owner exited; outcome unknown" : operation.status;
+    const age = operation.lastOutputAt ? formatDuration(Date.now() - Date.parse(operation.lastOutputAt)) + " ago" : "none recorded";
+    const quoted = "'" + operation.logPath.replace(/'/g, "'\\''") + "'";
+    return [
+      `${operation.parentId ? "  " : ""}operation ${operation.command} \xB7 ${state} \xB7 ${formatDuration(elapsed)} elapsed`,
+      ...operation.stage ? [`  stage ${operation.stage}`] : [],
+      `  last output ${age}`,
+      `  follow: tail -n 50 -F ${quoted}`
+    ];
+  });
+}
 export {
   changedLines,
   formatDuration,

package/dist/execution-provenance.js

@@ -215,7 +215,7 @@ function gitSourceFingerprint(topLevel, pathspecs, head) {
 }
 function sourcePathspecs(git, excludedRoots, includedRoots) {
   const exclusions = excludedRoots.flatMap((root) => {
-    const relative = path.relative(git.topLevel, path.resolve(root));
+    const relative = path.relative(git.topLevel, fs.existsSync(root) ? fs.realpathSync(root) : path.resolve(root));
     return relative !== ".." && !relative.startsWith(`..${path.sep}`) ? [`:(exclude)${relative}`] : [];
   });
   const inclusions = includedRoots.length > 0 ? includedRoots.map((root) => path.join(git.pathspec === "." ? "" : git.pathspec, root)) : [git.pathspec];

package/dist/harness.js

@@ -1,7 +1,8 @@
-import { execFileSync, spawnSync } from "node:child_process";
+import { spawnScriptStreaming } from "./commands/shared.js";
+import { execFileSync } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
-import { resolveLeafInvoke, shellLeafMissing, missingShellLeafMessage } from "./leaf-invoke.js";
+import { shellLeafMissing, missingShellLeafMessage } from "./leaf-invoke.js";
 import { resolveExtensionSlotPorts } from "./adapters/slot-ports.js";
 import { recipeHarnessPath, recipeRuntimeDir, runnerDir } from "./paths.js";
 import { colorHumanMessage } from "./cli-color.js";
@@ -367,15 +368,10 @@ async function handleHarness(argv) {
     }
     return 1;
   }
-  const { bin: dispatchBin, args: dispatchArgs } = resolveLeafInvoke(dispatch.command, [
-    ...dispatch.prefixArgs,
-    ...forwardArgs
-  ]);
-  const result = spawnSync(dispatchBin, dispatchArgs, {
-    // Default: stream child output verbatim (byte-identical to the skill path).
-    // --json: route child output to our stderr so stdout carries only the summary.
-    stdio: quiet ? "ignore" : json ? ["inherit", 2, "inherit"] : "inherit",
-    env: process.env
+  const result = await spawnScriptStreaming(dispatch.command, [...dispatch.prefixArgs, ...forwardArgs], target, {
+    forward: quiet ? "none" : json ? "stderr" : "original",
+    stdin: quiet ? "ignore" : "inherit",
+    capture: false
   });
   if (result.error) {
     if (quiet) {

package/dist/json-stream.js

@@ -1,3 +1,4 @@
+import { recordCommandStage } from "./command-journal.js";
 class JsonStreamWriter {
   enabled;
   command;
@@ -32,9 +33,11 @@ class JsonStreamWriter {
     }));
   }
   phase(phase, fields = {}) {
+    recordCommandStage(phase);
     this.emit("phase", { phase, ...fields });
   }
   node(nodeId, action, status) {
+    if (status === "running") recordCommandStage(`${nodeId}: ${action}`);
     this.emit("node", { nodeId, action, status });
   }
   mutation(mutation) {

package/dist/live-adapter-contract.js

@@ -1,3 +1,5 @@
+import { recordCommandOutput } from "./command-journal.js";
+import { trackCheckoutChild } from "./checkout-lock.js";
 import { createHash } from "node:crypto";
 import { access, mkdtemp, readFile, realpath, rm, writeFile } from "node:fs/promises";
 import { existsSync, readFileSync } from "node:fs";
@@ -95,6 +97,7 @@ function runProcess(command, args, options) {
       env: options.env,
       stdio: [options.stdin == null ? "ignore" : "pipe", "pipe", "pipe"]
     });
+    if (child.pid) trackCheckoutChild(options.cwd, child.pid);
     if (options.stdin != null) {
       child.stdin.on("error", (error) => {
         if (error.code === "EPIPE" || settled) return;
@@ -107,9 +110,11 @@ function runProcess(command, args, options) {
     let stderr = "";
     child.stdout.on("data", (chunk) => {
       stdout += chunk;
+      recordCommandOutput(chunk);
     });
     child.stderr.on("data", (chunk) => {
       stderr += chunk;
+      recordCommandOutput(chunk);
     });
     const timeout = options.timeoutMs ? setTimeout(() => {
       if (settled) return;

package/dist/mm-harness-cli.js

@@ -245,6 +245,8 @@ Example:
 Example:
   mm-harness checklist mark temp/tasks/recipe-cook/<task> start
   mm-harness checklist mark temp/tasks/recipe-cook/<task> 1
+  mm-harness checklist mark temp/tasks/recipe-cook/<task> sub start qa-cases --step 2 --from inputs/qa-cases.md
+  mm-harness checklist mark temp/tasks/recipe-cook/<task> sub qa-cases 1
   mm-harness checklist mark temp/tasks/recipe-cook/<task> complete --mark-last
   mm-harness checklist closeout temp/tasks/recipe-cook/<task> --share`
   },
@@ -506,7 +508,7 @@ Example:
   replace it, and an interrupted process remains recorded as verdict=running.
 
   --target <path>                    Checkout path (default: cwd)
-  --runtime-dir <dir>                Runtime dir containing last-command.json
+  --runtime-dir <dir>                Runtime dir containing command operation records
   --json                             Machine-readable envelope
 
 Example:

package/dist/task-view.js

@@ -1,3 +1,4 @@
+import { readOperations, processIdentity } from "@farmslot/recipe-harness/runtime/operation";
 import { spawnSync } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
@@ -31,7 +32,12 @@ function findTaskDir(target) {
   return latestTaskDir(path.join(target, "temp", "tasks"));
 }
 function collectTaskView(target, taskDir, now) {
+  target = fs.existsSync(target) ? fs.realpathSync(target) : path.resolve(target);
+  taskDir = taskDir && (fs.existsSync(taskDir) ? fs.realpathSync(taskDir) : path.resolve(taskDir));
+  const taskIsRunning = taskDir && readJsonObject(path.join(taskDir, WORKER_SIGNAL_FILE))?.status === "running";
+  const operations = readOperations(path.join(target, recipeRuntimeDir(), "operations")).filter((operation) => !taskIsRunning || path.resolve(operation.logPath).startsWith(path.resolve(taskDir, "artifacts", "operations") + path.sep)).map((operation) => ({ ...operation, ownerAlive: operation.status === "running" && processIdentity(operation.pid) === operation.processStartedAt }));
   const base = {
+    operations,
     checkout: readCheckout(target),
     isolation: readIsolation(target),
     libraries: parseLibraryPathEnv(process.env.RECIPE_LIBRARY_PATH).map(
@@ -77,7 +83,8 @@ function collectTaskView(target, taskDir, now) {
       parseTime(pickString(signal, "timestamp")),
       ...readMarkEvents(signal).map((event) => Date.parse(event.checkedAt)),
       commandCounts ? commandAt : void 0,
-      prepare ? parseTime(prepare.updatedAt) : void 0
+      prepare ? parseTime(prepare.updatedAt) : void 0,
+      ...operations.flatMap((operation) => [parseTime(operation.lastOutputAt), parseTime(operation.stageStartedAt), parseTime(operation.startedAt)])
     ],
     branch: base.checkout.branch,
     ticket,

package/docs/CONTRIBUTING.md

@@ -149,6 +149,43 @@ bash tests/contract/run.sh
 Runtime changes also require real affected-platform QA and a packed installation
 test. Update `CHANGELOG.md` under `Unreleased` for user-visible behavior.
 
+When upgrading the protocol or runtime, align their transitive consumers before
+pinning them here. Farmslot's `workspace:*` dependencies become exact versions
+when packed, so `agent-runtime` and `expo-recipe` can retain older copies until
+republished. Verify the complete install with
+`bash tests/contract/packaging-dist-install.test.sh` before releasing the harness.
+
 Docs describe only current behavior. History belongs in the changelog and Git;
 do not add handovers, audits, speculative roadmaps, or duplicate command guides
 under `docs/`.
+
+## Long command observations
+
+`mm-harness status --watch` shows command ownership, stage, elapsed time, last
+output, and a `tail -n 50 -F` command for each active operation. Records and logs
+live under `temp/recipe/runtime/operations/`. During a running task, records and
+logs also appear under its `artifacts/operations/` directory for Command Center.
+
+Use `mm-harness last --json` to resolve the current journal path. Each invocation
+writes its own journal; new commands no longer write `last-command.json`. The
+reader still accepts that legacy file when no operation records exist. A running
+parent remains visible while its child or a rejected competing command finishes.
+
+An owner process being alive, recent log output, and a stage change are separate
+observations. None proves application readiness. Reading status or following logs
+does not refresh activity or take the checkout mutation lock.
+
+The checkout keeps the latest 100 completed invocation records. Task-local mirrors
+remain with their task artifacts. Streaming leaves keep full output on disk;
+commands that need captured output for classification keep a bounded tail.
+`fixtures sync --json` streams progress to stderr while reserving stdout for JSON.
+Interactive harness leaves inherit stdin; their stdout/stderr are piped for logs,
+so child TTY formatting may differ from a direct launch.
+
+Streaming leaves run in tracked process groups. Ordinary interrupt, termination,
+hangup and quit signals are forwarded. Non-timed leaves may finish their cleanup
+without a new forced-kill deadline. SIGKILL cannot be forwarded: if the caller's
+group is forcibly killed, its detached build may survive and the checkout remains
+reserved until that recorded group exits. Inspect the recorded group before
+manual cleanup. Group-ID reuse can conservatively retain an old crash lock; the
+lock's recovery hint describes what to inspect.

package/library/actions/mobile/ui/native-navigation.mjs

@@ -159,6 +159,18 @@ export async function navigateOpaqueMobile(input, destination) {
   }
 }
 
+// Release builds may omit the mode toggle when Pro is disabled. The distinct
+// visible market screen still proves its mode; a chooser or conflicting screen does not.
+export function visiblePerpsModeScreen(ids, mode) {
+  const expectedScreen = mode === 'pro' ? IDS.proMarket : IDS.market;
+  const oppositeScreen = mode === 'pro' ? IDS.market : IDS.proMarket;
+  const expectedToggle = mode === 'pro' ? IDS.modeTogglePro : IDS.modeToggleLite;
+  const oppositeToggle = mode === 'pro' ? IDS.modeToggleLite : IDS.modeTogglePro;
+  if (ids.has(IDS.modeLite) || ids.has(IDS.modePro) || ids.has(oppositeScreen) || ids.has(oppositeToggle)) return undefined;
+  if (ids.has(expectedScreen)) return expectedScreen;
+  return ids.has(expectedToggle) ? expectedToggle : undefined;
+}
+
 export async function ensureVisibleAndroidPerpsMode(input, perpsMode) {
   if (!['lite', 'pro'].includes(perpsMode)) {
     throw new Error('Opaque Mobile Perps mode must be lite or pro.');
@@ -218,7 +230,6 @@ export async function ensureVisibleAndroidPerpsMode(input, perpsMode) {
 
   try {
     const deadline = Date.now() + Number(input.node?.timeout_ms ?? 30_000);
-    const expectedToggle = perpsMode === 'pro' ? IDS.modeTogglePro : IDS.modeToggleLite;
     const currentToggle = perpsMode === 'pro' ? IDS.modeToggleLite : IDS.modeTogglePro;
     const option = perpsMode === 'pro' ? IDS.modePro : IDS.modeLite;
     let expectedStreak = 0;
@@ -240,12 +251,13 @@ export async function ensureVisibleAndroidPerpsMode(input, perpsMode) {
         await new Promise((resolve) => setTimeout(resolve, 250));
         continue;
       }
-      if (ids.has(expectedToggle)) {
+      const observedScreen = visiblePerpsModeScreen(ids, perpsMode);
+      if (observedScreen) {
         expectedStreak += 1;
         if (expectedStreak >= 2) {
           return {
             mode: perpsMode,
-            observedScreen: expectedToggle,
+            observedScreen,
             provider: 'android-native-accessibility',
             proofPath: 'visible-native-navigation',
           };
@@ -294,7 +306,6 @@ export async function ensureVisibleIosPerpsMode(input, perpsMode) {
   if (!['lite', 'pro'].includes(perpsMode)) {
     throw new Error('iOS Perps mode must be lite or pro.');
   }
-  const expectedToggle = perpsMode === 'pro' ? IDS.modeTogglePro : IDS.modeToggleLite;
   const currentToggle = perpsMode === 'pro' ? IDS.modeToggleLite : IDS.modeTogglePro;
   const option = perpsMode === 'pro' ? IDS.modePro : IDS.modeLite;
   const deadline = Date.now() + Number(input.node?.timeout_ms ?? 30_000);
@@ -324,12 +335,13 @@ export async function ensureVisibleIosPerpsMode(input, perpsMode) {
     const items = observed.observations?.['ui.visible']?.items ?? [];
     const ids = new Set(items.map((item) => String(item.test_id ?? '')));
     lastObserved = [...ids].filter(Boolean).slice(0, 20);
-    if (ids.has(expectedToggle)) {
+    const observedScreen = visiblePerpsModeScreen(ids, perpsMode);
+    if (observedScreen) {
       expectedStreak += 1;
       if (expectedStreak >= 2) {
         return {
           mode: perpsMode,
-          observedScreen: expectedToggle,
+          observedScreen,
           provider: 'ios-native-accessibility',
           proofPath: 'visible-native-navigation',
         };