@deeeed/metamask-harness 0.67.0 → 0.68.0

package/dist/checkout-lock.js

@@ -1,3 +1,4 @@
+import { ensureRuntimeDirectory, processIdentity } from "@farmslot/recipe-harness/runtime/operation";
 import { randomUUID } from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
@@ -5,15 +6,19 @@ import { recipeRuntimeDir } from "./paths.js";
 function acquireCheckoutLock(target, operation) {
   const repoRoot = fs.realpathSync(target);
   const lockPath = path.join(repoRoot, recipeRuntimeDir(), "sandbox.lock");
-  fs.mkdirSync(path.dirname(lockPath), { recursive: true });
+  ensureRuntimeDirectory(path.dirname(lockPath));
   const inheritedToken = process.env.MM_HARNESS_CHECKOUT_LOCK_TOKEN;
   for (let attempt = 0; attempt < 4; attempt += 1) {
     try {
+      const identity = processIdentity(process.pid);
+      if (!identity) throw new Error("Cannot identify checkout lock owner process");
       const fd = fs.openSync(lockPath, "wx", 384);
-      const token = inheritedToken || randomUUID();
+      fs.fchmodSync(fd, 384);
+      const token = randomUUID();
       const owner = {
         schemaVersion: 1,
         pid: process.pid,
+        processStartedAt: identity,
         operation,
         repoRoot,
         token,
@@ -22,30 +27,38 @@ function acquireCheckoutLock(target, operation) {
       fs.writeFileSync(fd, `${JSON.stringify(owner, null, 2)}
 `);
       fs.closeSync(fd);
-      if (!inheritedToken) process.env.MM_HARNESS_CHECKOUT_LOCK_TOKEN = token;
+      process.env.MM_HARNESS_CHECKOUT_LOCK_TOKEN = token;
       return {
         path: lockPath,
         release: () => {
           const current = readOwner(lockPath);
-          if (current?.pid === process.pid && current.token === token) fs.rmSync(lockPath, { force: true });
-          if (!inheritedToken && process.env.MM_HARNESS_CHECKOUT_LOCK_TOKEN === token) {
-            delete process.env.MM_HARNESS_CHECKOUT_LOCK_TOKEN;
+          if (current?.pid === process.pid && current.token === token && !childrenAlive(current)) {
+            fs.rmSync(lockPath, { force: true });
+            fs.rmSync(path.join(path.dirname(lockPath), "lock-members", token), { recursive: true, force: true });
+          }
+          if (process.env.MM_HARNESS_CHECKOUT_LOCK_TOKEN === token) {
+            if (inheritedToken) process.env.MM_HARNESS_CHECKOUT_LOCK_TOKEN = inheritedToken;
+            else delete process.env.MM_HARNESS_CHECKOUT_LOCK_TOKEN;
           }
         }
       };
     } catch (error) {
       if (error.code !== "EEXIST") throw error;
       const owner = readOwner(lockPath);
-      if (inheritedToken && owner?.token === inheritedToken && owner.repoRoot === repoRoot && typeof owner.pid === "number" && processAlive(owner.pid)) {
+      if (inheritedToken && owner?.token === inheritedToken && owner.repoRoot === repoRoot && typeof owner.pid === "number" && ownerAlive(owner)) {
+        trackCheckoutChild(repoRoot, process.pid);
         return { path: lockPath, release: () => void 0 };
       }
-      if (owner && typeof owner.pid === "number" && processAlive(owner.pid)) {
+      if (owner && typeof owner.pid === "number" && ownerAlive(owner)) {
         return {
           path: lockPath,
           owner,
           message: `checkout sandbox is busy with ${String(owner.operation ?? "another operation")} (pid ${owner.pid}).`
         };
       }
+      if (!owner || childrenAlive(owner)) {
+        return { path: lockPath, owner, message: `checkout sandbox owner is unreadable or has surviving child processes. Inspect ${lockPath} and its lock-members directory; remove the lock only after verifying all recorded processes have exited.` };
+      }
       claimStaleLock(lockPath, owner);
     }
   }
@@ -61,12 +74,14 @@ function claimStaleLock(lockPath, expectedOwner) {
   }
   try {
     const claimedOwner = readOwner(claimedPath);
-    if (!sameOwner(claimedOwner, expectedOwner) || claimedOwner && typeof claimedOwner.pid === "number" && processAlive(claimedOwner.pid)) {
+    if (!sameOwner(claimedOwner, expectedOwner) || claimedOwner && typeof claimedOwner.pid === "number" && (ownerAlive(claimedOwner) || childrenAlive(claimedOwner))) {
       try {
         fs.linkSync(claimedPath, lockPath);
       } catch (error) {
         if (error.code !== "EEXIST") throw error;
       }
+    } else if (typeof claimedOwner?.token === "string" && /^[a-f0-9-]{36}$/.test(claimedOwner.token)) {
+      fs.rmSync(path.join(path.dirname(lockPath), "lock-members", claimedOwner.token), { recursive: true, force: true });
     }
   } finally {
     fs.rmSync(claimedPath, { force: true });
@@ -84,6 +99,42 @@ function readOwner(lockPath) {
     return null;
   }
 }
+function ownerAlive(owner) {
+  if (typeof owner.pid !== "number") return true;
+  if (typeof owner.processStartedAt === "string") return processIdentity(owner.pid) === owner.processStartedAt;
+  return processAlive(owner.pid);
+}
+function childrenAlive(owner) {
+  if (typeof owner.repoRoot !== "string" || typeof owner.token !== "string" || !/^[a-f0-9-]{36}$/.test(owner.token)) return false;
+  const directory = path.join(owner.repoRoot, recipeRuntimeDir(), "lock-members", owner.token);
+  if (!fs.existsSync(directory)) return false;
+  return fs.readdirSync(directory).filter((name) => name.endsWith(".json")).some((name) => {
+    const child = readOwner(path.join(directory, name));
+    if (child && typeof child.processGroupId === "number" && child.processGroupId > 0) return processAlive(-child.processGroupId);
+    return !child || typeof child.pid !== "number" || typeof child.processStartedAt !== "string" || child.pid !== owner.pid && processIdentity(child.pid) === child.processStartedAt;
+  });
+}
+function trackCheckoutChild(target, pid, ownsProcessGroup = false) {
+  const repoRoot = fs.realpathSync(target);
+  const lockPath = path.join(repoRoot, recipeRuntimeDir(), "sandbox.lock");
+  const owner = readOwner(lockPath);
+  if (!owner || owner.token !== process.env.MM_HARNESS_CHECKOUT_LOCK_TOKEN || typeof owner.token !== "string" || !/^[a-f0-9-]{36}$/.test(owner.token)) return () => void 0;
+  const identity = processIdentity(pid);
+  if (!identity && !ownsProcessGroup) return () => void 0;
+  const directory = path.join(repoRoot, recipeRuntimeDir(), "lock-members", owner.token);
+  ensureRuntimeDirectory(directory);
+  const file = path.join(directory, `${pid}.json`);
+  const previous = readOwner(file);
+  const group = ownsProcessGroup || previous?.processStartedAt === identity && previous?.processGroupId === pid;
+  const temporary = `${file}.${process.pid}.${randomUUID()}.tmp`;
+  fs.writeFileSync(temporary, JSON.stringify({ pid, processStartedAt: identity, ...group ? { processGroupId: pid } : {} }), { mode: 384 });
+  fs.chmodSync(temporary, 384);
+  fs.renameSync(temporary, file);
+  return () => {
+    const current = readOwner(file);
+    if (current?.pid === pid && current.processStartedAt === identity) fs.rmSync(file, { force: true });
+  };
+}
 function processAlive(pid) {
   try {
     process.kill(pid, 0);
@@ -93,5 +144,6 @@ function processAlive(pid) {
   }
 }
 export {
-  acquireCheckoutLock
+  acquireCheckoutLock,
+  trackCheckoutChild
 };

package/dist/command-contract.js

@@ -425,6 +425,7 @@ function validatePublicInvocation(argv, examples = {}) {
   }
   const { name, contract } = resolved;
   const tokens = argv.slice(1);
+  if (name === "checklist" && tokens[0] === "mark" && tokens[1] && !tokens[1].startsWith("-") && tokens[2] === "sub") return null;
   const positionals = [];
   const seenOptions = /* @__PURE__ */ new Set();
   const validOptions = Object.keys(contract.options);

package/dist/command-journal.js

@@ -1,9 +1,12 @@
 import { randomUUID } from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
+import { OperationRecord, readOperations, processIdentity, ensureRuntimeDirectory } from "@farmslot/recipe-harness/runtime/operation";
+import { latestTaskDir } from "@farmslot/agent-runtime";
 import { recipeRuntimeDir } from "./paths.js";
 const COMMAND_JOURNAL_FILE = "last-command.json";
 const JOURNALED_COMMANDS = /* @__PURE__ */ new Set([
+  "prepare",
   "call",
   "check",
   "checklist",
@@ -12,6 +15,7 @@ const JOURNALED_COMMANDS = /* @__PURE__ */ new Set([
   "fixtures",
   "install",
   "launch",
+  "runtime-launch",
   "provision",
   "recipe-quality",
   "run",
@@ -25,6 +29,8 @@ async function withCommandJournal(command, argv, execute) {
   if (!JOURNALED_COMMANDS.has(command)) return execute();
   const handle = tryBeginCommandJournal(command, argv);
   const previous = activeCommandJournal;
+  const parentId = process.env.MM_HARNESS_OPERATION_ID;
+  if (handle) process.env.MM_HARNESS_OPERATION_ID = handle.operation.value.id;
   activeCommandJournal = handle;
   try {
     const exitCode = await execute();
@@ -35,8 +41,16 @@ async function withCommandJournal(command, argv, execute) {
     throw error;
   } finally {
     activeCommandJournal = previous;
+    if (parentId) process.env.MM_HARNESS_OPERATION_ID = parentId;
+    else delete process.env.MM_HARNESS_OPERATION_ID;
   }
 }
+function recordCommandStage(stage) {
+  activeCommandJournal?.operation.stage(stage);
+}
+function recordCommandOutput(chunk) {
+  activeCommandJournal?.operation.output(chunk);
+}
 function recordCommandEvidence(...evidence) {
   const handle = activeCommandJournal;
   if (!handle || evidence.length === 0) return;
@@ -58,7 +72,12 @@ function commandJournalPath(target, runtimeDir) {
   return path.join(path.resolve(target), relative, COMMAND_JOURNAL_FILE);
 }
 function readCommandJournal(target, runtimeDir) {
-  const file = commandJournalPath(target, runtimeDir);
+  const legacyFile = commandJournalPath(target, runtimeDir);
+  const operations = readOperations(path.join(path.dirname(legacyFile), "operations"));
+  const live = operations.filter((operation) => operation.status === "running" && processIdentity(operation.pid) === operation.processStartedAt);
+  const roots = operations.filter((operation) => !operation.parentId).sort((a, b) => (a.finishedAt ?? a.startedAt).localeCompare(b.finishedAt ?? b.startedAt));
+  const selected = live.find((operation) => !operation.parentId) ?? live.at(-1) ?? roots.at(-1) ?? operations.at(-1);
+  const file = selected ? path.join(path.dirname(legacyFile), "operations", `${selected.id}.journal.json`) : legacyFile;
   let descriptor;
   try {
     const noFollow = typeof fs.constants.O_NOFOLLOW === "number" ? fs.constants.O_NOFOLLOW : 0;
@@ -113,12 +132,34 @@ function redactCommandArgs(argv) {
   }
   return redacted;
 }
+function pruneCompletedJournals(directory, operations) {
+  const completed = operations.filter((operation) => operation.status !== "running");
+  for (const operation of completed.slice(0, -100)) {
+    for (const suffix of [".json", ".journal.json", ".log"]) {
+      fs.rmSync(path.join(directory, `${operation.id}${suffix}`), { force: true });
+    }
+  }
+}
 function tryBeginCommandJournal(command, argv) {
   try {
     const target = invocationTarget(argv);
     if (!fs.existsSync(target)) return void 0;
     const runtimeDir = optionValue(argv, "--runtime-dir");
-    const file = commandJournalPath(target, runtimeDir);
+    const legacyFile = commandJournalPath(target, runtimeDir);
+    const taskDir = latestTaskDir(path.join(target, "temp", "tasks"));
+    const signalFile = taskDir && path.join(taskDir, "SIGNAL.json");
+    const liveTask = signalFile && fs.existsSync(signalFile) && JSON.parse(fs.readFileSync(signalFile, "utf8")).status === "running";
+    const directory = path.join(path.dirname(legacyFile), "operations");
+    const operations = readOperations(directory, (error) => process.stderr.write(`mm-harness: ignoring invalid prior operation: ${error.message}
+`));
+    pruneCompletedJournals(directory, operations);
+    const inherited = process.env.MM_HARNESS_OPERATION_ID;
+    const parent = inherited && operations.find((operation2) => operation2.id === inherited && operation2.target === target && operation2.status === "running" && processIdentity(operation2.pid) === operation2.processStartedAt);
+    const operation = new OperationRecord(directory, command, target, {
+      ...parent ? { parentId: parent.id } : {},
+      ...liveTask ? { mirrorDirectory: path.join(taskDir, "artifacts", "operations") } : {}
+    });
+    const file = path.join(directory, `${operation.value.id}.journal.json`);
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const record = {
       schemaVersion: 1,
@@ -132,7 +173,7 @@ function tryBeginCommandJournal(command, argv) {
       finishedAt: null
     };
     writeAtomic(file, record);
-    return { file, record };
+    return { file, record, operation };
   } catch (error) {
     process.stderr.write(
       `mm-harness: resumability journal unavailable: ${errorMessage(error)}
@@ -155,14 +196,17 @@ function tryFinishCommandJournal(handle, exitCode) {
       `mm-harness: resumability journal could not finalize: ${errorMessage(error)}
 `
     );
+  } finally {
+    handle.operation.finish(exitCode);
   }
 }
 function writeAtomic(file, record) {
-  fs.mkdirSync(path.dirname(file), { recursive: true });
+  ensureRuntimeDirectory(path.dirname(file));
   const temporary = `${file}.${process.pid}.${randomUUID()}.tmp`;
   let descriptor;
   try {
     descriptor = fs.openSync(temporary, "wx", 384);
+    fs.fchmodSync(descriptor, 384);
     fs.writeFileSync(descriptor, `${JSON.stringify(record, null, 2)}
 `);
     fs.fsyncSync(descriptor);
@@ -175,9 +219,8 @@ function writeAtomic(file, record) {
   }
 }
 function invocationTarget(argv) {
-  return path.resolve(
-    optionValue(argv, "--target") ?? process.cwd()
-  );
+  const target = path.resolve(optionValue(argv, "--target") ?? process.cwd());
+  return fs.existsSync(target) ? fs.realpathSync(target) : target;
 }
 function evidencePaths(argv) {
   const values = /* @__PURE__ */ new Set();
@@ -257,6 +300,8 @@ export {
   isSensitiveKey,
   readCommandJournal,
   recordCommandEvidence,
+  recordCommandOutput,
+  recordCommandStage,
   redactCommandArgs,
   redactStructuredValue,
   withCommandJournal

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

@@ -12,6 +12,7 @@ import { FeatureFlagSpecError, fixtureFeatureFlags, parseRemoteFlagSpec, sameFea
 import { readExtensionPinnedFlags } from "../adapters/extension/feature-flags.js";
 const FIXTURES_BOOLEANS = /* @__PURE__ */ new Set(["dev", "force", "json"]);
 const FIXTURE_STREAM_TIMEOUT_MS = 12e4;
+const FIXTURE_BRIDGE_READY_TIMEOUT_MS = 18e4;
 const MOBILE_SETUP_WALLET_TIMEOUT_MS = 36e4;
 async function handleFixtures(argv) {
   const { positional, options } = parseFlags(argv, FIXTURES_BOOLEANS);
@@ -251,9 +252,9 @@ async function handleFixturesLocked(argv) {
             const waitForBridge = path.join(runnerDir, "adapters/mobile/wait-for-bridge.sh");
             const waitResult = await spawnScriptStreaming(
               waitForBridge,
-              ["--target", target, "--port", port, "--platform", platform],
+              ["--target", target, "--port", port, "--platform", platform, "--timeout-ms", String(FIXTURE_BRIDGE_READY_TIMEOUT_MS)],
               target,
-              { timeoutMs: FIXTURE_STREAM_TIMEOUT_MS }
+              { timeoutMs: FIXTURE_BRIDGE_READY_TIMEOUT_MS + 1e4 }
             );
             if (waitResult.status !== 0) {
               resetError = new Error("Mobile bridge did not return after app data reset.");
@@ -558,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) {
@@ -577,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/launch/index.js

@@ -381,6 +381,26 @@ async function handleLaunchLocked(argv, stream) {
       originalError: attempt.output.trim() || void 0
     });
   }
+  if (adapter === "mobile" && attempt.output.includes("open-device: Android device is locked.")) {
+    return launchFail(jsonOutput, stream, adapter, mobileTarget, tier, state, target, {
+      code: "MOBILE_DEVICE_LOCKED",
+      message: "the selected Android device is locked.",
+      recoverable: false,
+      userAction: "Unlock the selected Android device, then retry the launch.",
+      exitCode: EXIT.runtime,
+      originalError: attempt.output.trim()
+    });
+  }
+  if (adapter === "mobile" && /open-device: Android (?:lock state unavailable|display preparation failed)\./u.test(attempt.output)) {
+    return launchFail(jsonOutput, stream, adapter, mobileTarget, tier, state, target, {
+      code: "MOBILE_DEVICE_UI_UNAVAILABLE",
+      message: "the selected Android display could not be prepared.",
+      recoverable: false,
+      userAction: "Check adb access and the selected device screen, then retry the launch.",
+      exitCode: EXIT.runtime,
+      originalError: attempt.output.trim()
+    });
+  }
   if (heal === "off") {
     return launchFail(jsonOutput, stream, adapter, mobileTarget, tier, state, target, {
       code: "LAUNCH_FAILED",

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