@mutmutco/cli 3.84.0 → 3.86.0

package/dist/main.cjs

@@ -3415,7 +3415,7 @@ function useColor() {
 var program = new Command();
 
 // src/index.ts
-var import_promises10 = require("node:fs/promises");
+var import_promises11 = require("node:fs/promises");
 var import_node_fs36 = require("node:fs");
 var import_node_child_process16 = require("node:child_process");
 
@@ -3982,10 +3982,10 @@ var import_node_fs4 = require("node:fs");
 var injectedStdin;
 function stdinHasPipedInput(statFd = () => (0, import_node_fs4.fstatSync)(0), getIsTTY = () => process.stdin.isTTY) {
   try {
-    const stat2 = statFd();
-    if (stat2.isFIFO() || stat2.isFile()) return true;
-    if (stat2.isCharacterDevice()) return false;
-    if (stat2.isSocket()) return false;
+    const stat3 = statFd();
+    if (stat3.isFIFO() || stat3.isFile()) return true;
+    if (stat3.isCharacterDevice()) return false;
+    if (stat3.isSocket()) return false;
     if (getIsTTY() === true) return false;
     return true;
   } catch {
@@ -4502,9 +4502,9 @@ function trackedPathStatus(c, realPath, repoAnchor) {
     return null;
   }
 }
-function rootScratchDirSnapshot(root, readdir2, stat2) {
+function rootScratchDirSnapshot(root, readdir2, stat3) {
   try {
-    const rootStat = stat2(root);
+    const rootStat = stat3(root);
     let mtimeMs = rootStat.mtimeMs;
     let bytes = 0;
     const stack = [root];
@@ -4518,7 +4518,7 @@ function rootScratchDirSnapshot(root, readdir2, stat2) {
           return null;
         } catch {
         }
-        const st = stat2(child2);
+        const st = stat3(child2);
         mtimeMs = Math.max(mtimeMs, st.mtimeMs);
         if (ent.isDirectory()) stack.push(child2);
         else if (ent.isFile()) bytes += st.size;
@@ -4531,7 +4531,7 @@ function rootScratchDirSnapshot(root, readdir2, stat2) {
 }
 function collectScratchSnapshot(repoRoot2, deps = {}) {
   const readdir2 = deps.readdir ?? import_node_fs6.readdirSync;
-  const stat2 = deps.stat ?? import_node_fs6.statSync;
+  const stat3 = deps.stat ?? import_node_fs6.statSync;
   const plansRoot = (0, import_node_path4.join)(repoRoot2, "plans");
   const rootScratchFiles = [];
   try {
@@ -4544,10 +4544,10 @@ function collectScratchSnapshot(repoRoot2, deps = {}) {
       const full = (0, import_node_path4.join)(repoRoot2, ent.name);
       try {
         if (isDir) {
-          const snap = rootScratchDirSnapshot(full, readdir2, stat2);
+          const snap = rootScratchDirSnapshot(full, readdir2, stat3);
           if (snap) rootScratchFiles.push({ path: full, dir: repoRoot2, name: ent.name, mtimeMs: snap.mtimeMs, bytes: snap.bytes, kind: "dir" });
         } else {
-          const st = stat2(full);
+          const st = stat3(full);
           rootScratchFiles.push({ path: full, dir: repoRoot2, name: ent.name, mtimeMs: st.mtimeMs, bytes: st.size, kind: "file" });
         }
       } catch {
@@ -4561,7 +4561,7 @@ function collectScratchSnapshot(repoRoot2, deps = {}) {
       if (!ent.isFile() || !ent.name.endsWith(".md")) continue;
       const full = (0, import_node_path4.join)(plansRoot, ent.name);
       try {
-        const st = stat2(full);
+        const st = stat3(full);
         planMdFiles.push({ path: full, dir: plansRoot, name: ent.name, mtimeMs: st.mtimeMs, bytes: st.size, kind: "file" });
       } catch {
       }
@@ -6371,6 +6371,14 @@ var LOCAL_ONLY_FILES = [".claude/settings.local.json"];
 var PKG = "package.json";
 var LOCKFILE = "package-lock.json";
 var NODE_MODULES = "node_modules";
+var LOCKFILE_INSTALLS = [
+  { lockfile: "bun.lock", command: "bun install --frozen-lockfile" },
+  { lockfile: "bun.lockb", command: "bun install --frozen-lockfile" },
+  { lockfile: "pnpm-lock.yaml", command: "pnpm install --frozen-lockfile" },
+  { lockfile: "yarn.lock", command: "yarn install --immutable" },
+  { lockfile: LOCKFILE, command: "npm ci" }
+];
+var NO_LOCKFILE_INSTALL = "npm install --no-package-lock";
 var realFsProbe = {
   isDir: (p) => {
     try {
@@ -6397,18 +6405,19 @@ var realFsProbe = {
 function scanInstallDirs(root, fs2 = realFsProbe) {
   const factsFor = (dir) => {
     const abs = dir ? (0, import_node_path10.join)(root, dir) : root;
+    const match = LOCKFILE_INSTALLS.find((c) => fs2.isFile((0, import_node_path10.join)(abs, c.lockfile)));
     return {
       dir,
       hasPackageJson: fs2.isFile((0, import_node_path10.join)(abs, PKG)),
-      hasLockfile: fs2.isFile((0, import_node_path10.join)(abs, LOCKFILE)),
-      hasNodeModules: fs2.isDir((0, import_node_path10.join)(abs, NODE_MODULES))
+      hasNodeModules: fs2.isDir((0, import_node_path10.join)(abs, NODE_MODULES)),
+      install: match?.command
     };
   };
   const children = fs2.listDirs(root).filter((name) => name !== NODE_MODULES && name !== ".git");
   return [factsFor(""), ...children.map(factsFor).filter((f) => f.hasPackageJson)];
 }
 function npmInstallTargets(dirs) {
-  return dirs.filter((d) => d.hasPackageJson && !d.hasNodeModules).map((d) => ({ dir: d.dir, command: d.hasLockfile ? "npm ci" : "npm install --no-package-lock" }));
+  return dirs.filter((d) => d.hasPackageJson && !d.hasNodeModules).map((d) => ({ dir: d.dir, command: d.install ?? NO_LOCKFILE_INSTALL }));
 }
 function isLinkedWorktree(root, fs2 = realFsProbe) {
   return fs2.isFile((0, import_node_path10.join)(root, ".git"));
@@ -6432,9 +6441,9 @@ async function provisionWorktree(worktreeRoot, deps) {
   const allDirs = scanInstallDirs(worktreeRoot, fs2);
   const targets = npmInstallTargets(allDirs);
   if (deps.validateInstall) {
-    for (const dir of allDirs.filter((d) => d.hasPackageJson && d.hasLockfile && d.hasNodeModules)) {
+    for (const dir of allDirs.filter((d) => d.hasPackageJson && d.install && d.hasNodeModules)) {
       const cwd = dir.dir ? (0, import_node_path10.join)(worktreeRoot, dir.dir) : worktreeRoot;
-      if (!await deps.validateInstall(cwd)) targets.push({ dir: dir.dir, command: "npm ci" });
+      if (!await deps.validateInstall(cwd)) targets.push({ dir: dir.dir, command: dir.install });
     }
   }
   const targetDirs = new Set(targets.map((target) => target.dir));
@@ -7978,6 +7987,7 @@ function parseVerifyBroker(stdout) {
 
 // src/train-apply.ts
 var import_node_fs13 = require("node:fs");
+var import_promises2 = require("node:fs/promises");
 var import_node_path12 = require("node:path");
 function resolveDeployModel2(meta, repo) {
   const m = meta?.deployModel;
@@ -8484,20 +8494,30 @@ async function rollDevelopmentForward(deps, ctx, tag) {
   const number = parsePrNumber(url);
   return enqueueAlignmentAutoMerge(deps, ctx, number, url || void 0, `development requires checks (${required.join(", ")}); opened alignment PR ${url || "(url unavailable)"}`);
 }
+var ALIGNMENT_ARM_ATTEMPTS = 3;
+var ALIGNMENT_ARM_BACKOFF_MS = 2e3;
 async function enqueueAlignmentAutoMerge(deps, ctx, prNumber, prUrl, openedNote) {
   const base = { status: "pr-pending", prNumber, prUrl };
   const retryCommand = `mmi-cli pr merge ${prNumber ?? "<number>"} --auto --merge`;
   const manual = `${openedNote} \u2014 land it with \`${retryCommand}\``;
   if (deps.mergeAuto && prNumber !== void 0) {
-    try {
-      const res = await deps.mergeAuto(String(prNumber), ctx.repo);
-      if (res.mergeStatus !== "failed") {
-        return { ...base, autoMergeEnqueued: true, note: `${openedNote} \u2014 auto-merge enqueued (merges when checks pass)` };
+    const sleep3 = resolveSleep(deps);
+    let lastError;
+    for (let attempt = 1; attempt <= ALIGNMENT_ARM_ATTEMPTS; attempt += 1) {
+      try {
+        const res = await deps.mergeAuto(String(prNumber), ctx.repo);
+        if (res.mergeStatus !== "failed") {
+          return { ...base, autoMergeEnqueued: true, note: `${openedNote} \u2014 auto-merge enqueued (merges when checks pass)` };
+        }
+        lastError = res.error ?? "unknown error";
+      } catch (e) {
+        lastError = `enqueue threw (${e instanceof Error ? e.message : String(e)})`;
       }
-      deps.warn?.(`alignment PR #${prNumber} auto-merge not armed (${res.error ?? "unknown error"}) \u2014 re-run: ${retryCommand}`);
-    } catch (e) {
-      deps.warn?.(`alignment PR #${prNumber} auto-merge enqueue threw (${e instanceof Error ? e.message : String(e)}) \u2014 re-run: ${retryCommand}`);
+      if (attempt < ALIGNMENT_ARM_ATTEMPTS) await sleep3(ALIGNMENT_ARM_BACKOFF_MS * attempt);
     }
+    deps.warn?.(
+      `alignment PR #${prNumber} auto-merge not armed after ${ALIGNMENT_ARM_ATTEMPTS} attempts (${lastError ?? "unknown error"}) \u2014 re-run: ${retryCommand}`
+    );
   }
   return { ...base, note: manual };
 }
@@ -8835,6 +8855,10 @@ async function enumerateOwnWorkflowRuns(deps, repo, headSha) {
   const runs = await discoverShaWorkflowRuns(deps, repo, headSha, /* @__PURE__ */ new Set());
   return runs.length ? runs : [{ workflow: `sha-enumeration(${headSha.slice(0, 7)}) no runs yet`, conclusion: "pending" }];
 }
+function withReleaseRunObligation(runs) {
+  if (runs.some((r) => r.event === "release")) return runs;
+  return [...runs, { workflow: "release-event deploy run not created yet", conclusion: "pending" }];
+}
 var NON_DEPLOY_EVENTS = /* @__PURE__ */ new Set([
   "pull_request",
   "pull_request_target",
@@ -8884,6 +8908,7 @@ async function discoverShaWorkflowRuns(deps, repo, headSha, seenRunIds) {
       workflow: row.workflowName ?? `run:${row.databaseId}`,
       runId: row.databaseId,
       runUrl: row.url,
+      event: row.event,
       // An in-flight run is reported UNVERIFIED, never watched. Blocking on an arbitrary discovered run
       // would let one long push workflow hang the release command and mask the failed rows behind it, and
       // `gh run watch` has no timeout. The NAMED targets are the ones worth blocking on (also #3382 review).
@@ -8913,7 +8938,7 @@ async function dispatchDeploy(deps, ctx, stage, ref, model, watch, autoRunSince,
     const note = ref === "rc" ? "no dispatch on rc: registry-publish repos have no rc-stage Release to publish from" : "no central dispatch: this repo's own publish.yml auto-fires on the published Release (#2428)";
     if (ref === "rc" || !autoRunHeadSha) return { note, deployStatus: "pending" };
     if (!watch) {
-      const listed = await enumerateOwnWorkflowRuns(deps, ctx.repo, autoRunHeadSha);
+      const listed = withReleaseRunObligation(await enumerateOwnWorkflowRuns(deps, ctx.repo, autoRunHeadSha));
       return { note, workflowRuns: listed, deployStatus: aggregateWorkflowRuns(listed) };
     }
     const since = autoRunSince ?? (deps.now ?? Date.now)();
@@ -8933,7 +8958,7 @@ async function dispatchDeploy(deps, ctx, stage, ref, model, watch, autoRunSince,
     if (!autoRunHeadSha) return { note, deployStatus: "pending" };
     if (!watch) {
       if (ref === "rc") return { note, deployStatus: "pending" };
-      const listed = await enumerateOwnWorkflowRuns(deps, HUB_REPO, autoRunHeadSha);
+      const listed = withReleaseRunObligation(await enumerateOwnWorkflowRuns(deps, HUB_REPO, autoRunHeadSha));
       return { note, workflowRuns: listed, deployStatus: aggregateWorkflowRuns(listed) };
     }
     const since = autoRunSince ?? (deps.now ?? Date.now)();
@@ -9015,35 +9040,41 @@ async function executeMergeToMain(deps, sourceRef, mergeLabel, tolerated, predic
   }
 }
 async function probeFoldFailureState(deps) {
-  const branch = await currentBranch(deps);
+  const branch = await currentBranch(deps).catch(() => "");
   const mergeInProgress = await deps.run("git", ["rev-parse", "-q", "--verify", "MERGE_HEAD"]).then(() => true).catch(() => false);
-  const dirty = porcelainHasBlockingChanges(await deps.run("git", ["status", "--porcelain"]).catch(() => ""));
+  const headSha = await deps.run("git", ["rev-parse", "HEAD"]).then(clean2).catch(() => "");
+  const status = await deps.run("git", ["status", "--porcelain=v1"]).then(clean2).catch((e) => `(unavailable: ${e instanceof Error ? e.message : String(e)})`);
   const mainSha = await deps.run("git", ["rev-parse", "main"]).then(clean2).catch(() => "");
   const originMainSha = await deps.run("git", ["rev-parse", "origin/main"]).then(clean2).catch(() => "");
   const originIsAncestorOfMain = Boolean(mainSha) && Boolean(originMainSha) ? await deps.run("git", ["merge-base", "--is-ancestor", "origin/main", "main"]).then(() => true).catch(() => false) : false;
-  return { branch, mergeInProgress, dirty, mainSha, originMainSha, originIsAncestorOfMain };
+  return { branch, mergeInProgress, headSha, status, mainSha, originMainSha, originIsAncestorOfMain };
 }
 function shaLabel(sha) {
   return sha ? sha.slice(0, 7) : "(unknown)";
 }
-async function finishFoldAutoRestore(deps, causeMessage, startBranch, what) {
+async function finishFoldAutoRestore(deps, causeMessage, startBranch, preFoldMainSha, resumeCommand, what) {
   try {
     await deps.run("git", ["checkout", startBranch]);
   } catch (e) {
-    return new Error(
+    return foldFailureGuidance(
       `${causeMessage}
 
-fold failed; ${what}, but returning to ${startBranch} afterwards failed: ${e instanceof Error ? e.message : String(e)}. Finish manually: git checkout ${startBranch}`
+fold failed; ${what}, but returning to ${startBranch} afterwards failed: ${e instanceof Error ? e.message : String(e)}.`,
+      await probeFoldFailureState(deps),
+      startBranch,
+      preFoldMainSha,
+      `git checkout ${startBranch}`,
+      resumeCommand
     );
   }
   return new Error(
     `${causeMessage}
 
-fold failed; ${what} and the checkout was returned to ${startBranch}. Nothing was pushed to origin and no tag was created \u2014 rerun the release once the fold issue above is fixed.`
+fold failed; ${what} and the checkout was returned to ${startBranch}. Nothing was pushed to origin and no tag was created \u2014 rerun with \`${resumeCommand}\` once the fold issue above is fixed.`
   );
 }
-function foldFailureGuidance(causeMessage, probe, startBranch, preFoldMainSha) {
-  const steps = preFoldMainSha ? [
+function foldFailureGuidance(causeMessage, probe, startBranch, preFoldMainSha, nextCommand, resumeCommand = "mmi-cli release --apply", foldStarted = true) {
+  const steps = !foldStarted ? [`  1. Resolve or wait out the git index lock`, `  2. ${resumeCommand}`] : nextCommand === "git merge --abort" ? [`  1. git merge --abort`, `  2. git checkout ${startBranch}`, `  3. ${resumeCommand}`] : nextCommand === `git checkout ${startBranch}` ? [`  1. git checkout ${startBranch}`, `  2. ${resumeCommand}`] : preFoldMainSha ? [
     `  1. git status                              # inspect what is actually there`,
     `  2. git log --oneline ${preFoldMainSha}..main   # commits beyond the pre-fold main \u2014 confirm they are only this run's merge/fold attempt`,
     `  3. git checkout main && git reset --hard ${preFoldMainSha}   # back to the exact commit the fold built on`,
@@ -9053,14 +9084,60 @@ function foldFailureGuidance(causeMessage, probe, startBranch, preFoldMainSha) {
     `  2. git log --oneline origin/main..main     # this run never committed to main (it failed before the merge) \u2014 any commits here predate this run; preserve them`,
     `  3. git checkout ${startBranch}`
   ];
+  const exactNextCommand = nextCommand ?? "git status";
   return new Error(
     `${causeMessage}
 
-fold failed leaving the checkout in a state train --apply will not auto-restore (branch=${probe.branch || "(unknown)"}, dirty-working-tree=${probe.dirty}, main=${shaLabel(probe.mainSha)}, origin/main=${shaLabel(probe.originMainSha)}, pre-fold main=${preFoldMainSha ? shaLabel(preFoldMainSha) : "not captured"}, origin/main is${probe.originIsAncestorOfMain ? "" : " NOT"} an ancestor of main). Nothing was pushed to origin and no tag was created.
+fold failed leaving the checkout in a state train --apply will not auto-restore (branch=${probe.branch || "(unknown)"}, main=${shaLabel(probe.mainSha)}, origin/main=${shaLabel(probe.originMainSha)}, pre-fold main=${preFoldMainSha ? shaLabel(preFoldMainSha) : "not captured"}, origin/main is${probe.originIsAncestorOfMain ? "" : " NOT"} an ancestor of main). Nothing was pushed to origin and no tag was created.
+Resumable state:
+  current branch: ${probe.branch || "(unknown)"}
+  HEAD: ${probe.headSha || "(unknown)"}
+  pre-fold main: ${preFoldMainSha || "(not captured)"}
+  index/worktree status:
+    ${probe.status || "(clean)"}
+Next command: ${exactNextCommand}
+Resume command after the checkout is clean: ${resumeCommand}
 Recovery sequence:
 ${steps.join("\n")}`
   );
 }
+var GIT_INDEX_LOCK_WAIT_MS = 5e3;
+var GIT_INDEX_LOCK_POLL_MS = 100;
+async function waitForFoldIndexLock(deps, startBranch, resumeCommand) {
+  const preFoldMainSha = await deps.run("git", ["rev-parse", "main"]).then(clean2).catch(() => void 0);
+  const lockPath = requireValue(clean2(await deps.run("git", ["rev-parse", "--git-path", "index.lock"])), "git index lock path");
+  const now = deps.now ?? Date.now;
+  const sleep3 = resolveSleep(deps);
+  const deadline = now() + GIT_INDEX_LOCK_WAIT_MS;
+  for (; ; ) {
+    try {
+      await (0, import_promises2.stat)(lockPath);
+    } catch (e) {
+      if (e.code === "ENOENT") return;
+      throw foldFailureGuidance(
+        `release fold could not inspect git index lock ${lockPath}: ${e instanceof Error ? e.message : String(e)}`,
+        await probeFoldFailureState(deps),
+        startBranch,
+        preFoldMainSha,
+        resumeCommand,
+        resumeCommand,
+        false
+      );
+    }
+    if (now() >= deadline) {
+      throw foldFailureGuidance(
+        `release fold waited ${GIT_INDEX_LOCK_WAIT_MS}ms for active git index lock ${lockPath}; it is still held. The fold did not start. Do not delete the lock; let its owning git process finish.`,
+        await probeFoldFailureState(deps),
+        startBranch,
+        preFoldMainSha,
+        resumeCommand,
+        resumeCommand,
+        false
+      );
+    }
+    await sleep3(Math.min(GIT_INDEX_LOCK_POLL_MS, Math.max(1, deadline - now())));
+  }
+}
 async function recoverFailedRcand(deps, cause, preRcSha) {
   const causeMessage = cause instanceof Error ? cause.message : String(cause);
   const branch = await currentBranch(deps).catch(() => "");
@@ -9104,23 +9181,25 @@ Recovery sequence:
   3. mmi-cli rcand --apply`
   );
 }
-async function recoverFailedFold(deps, cause, startBranch, preFoldMainSha) {
+async function recoverFailedFold(deps, cause, startBranch, preFoldMainSha, resumeCommand) {
   const causeMessage = cause instanceof Error ? cause.message : String(cause);
   const probe = await probeFoldFailureState(deps);
   if (probe.mergeInProgress) {
     try {
       await deps.run("git", ["merge", "--abort"]);
     } catch (e) {
-      return new Error(
+      return foldFailureGuidance(
         `${causeMessage}
 
-fold failed with an in-progress merge left on ${probe.branch || "(unknown branch)"}; automatic \`git merge --abort\` failed: ${e instanceof Error ? e.message : String(e)}. Nothing was pushed to origin and no tag was created.
-Recovery sequence:
-  1. git merge --abort
-  2. git checkout ${startBranch}`
+fold failed with an in-progress merge; automatic \`git merge --abort\` failed: ${e instanceof Error ? e.message : String(e)}.`,
+        await probeFoldFailureState(deps),
+        startBranch,
+        preFoldMainSha,
+        "git merge --abort",
+        resumeCommand
       );
     }
-    return finishFoldAutoRestore(deps, causeMessage, startBranch, "the in-progress merge was aborted");
+    return finishFoldAutoRestore(deps, causeMessage, startBranch, preFoldMainSha, resumeCommand, "the in-progress merge was aborted");
   }
   if (probe.branch === "main" && preFoldMainSha) {
     const mainDescendsFromPreFold = await deps.run("git", ["merge-base", "--is-ancestor", preFoldMainSha, "main"]).then(() => true).catch(() => false);
@@ -9128,13 +9207,15 @@ Recovery sequence:
       try {
         await deps.run("git", ["reset", "--hard", preFoldMainSha]);
       } catch (e) {
-        return new Error(
+        return foldFailureGuidance(
           `${causeMessage}
 
-fold failed after this run's merge/fold committed locally on main (now ${shaLabel(probe.mainSha)}, unpushed, built on the pre-fold main ${shaLabel(preFoldMainSha)}); automatic \`git reset --hard ${shaLabel(preFoldMainSha)}\` failed: ${e instanceof Error ? e.message : String(e)}. Nothing was pushed to origin and no tag was created.
-Recovery sequence:
-  1. git reset --hard ${preFoldMainSha}
-  2. git checkout ${startBranch}`
+fold failed after this run's merge/fold committed locally on main; automatic \`git reset --hard ${shaLabel(preFoldMainSha)}\` failed: ${e instanceof Error ? e.message : String(e)}.`,
+          await probeFoldFailureState(deps),
+          startBranch,
+          preFoldMainSha,
+          `git reset --hard ${preFoldMainSha}`,
+          resumeCommand
         );
       }
       const aheadNote = probe.originMainSha && preFoldMainSha !== probe.originMainSha ? `; local main carried commit(s) origin/main (${shaLabel(probe.originMainSha)}) does not have \u2014 they were preserved` : "";
@@ -9142,17 +9223,20 @@ Recovery sequence:
         deps,
         causeMessage,
         startBranch,
+        preFoldMainSha,
+        resumeCommand,
         `local main was reset to its pre-fold state ${shaLabel(preFoldMainSha)} (discarding only this run's merge/fold commit(s) at ${shaLabel(probe.mainSha)})${aheadNote}`
       );
     }
   }
-  return foldFailureGuidance(causeMessage, probe, startBranch, preFoldMainSha);
+  return foldFailureGuidance(causeMessage, probe, startBranch, preFoldMainSha, void 0, resumeCommand);
 }
-async function runFoldStage(deps, startBranch, preFold, fn) {
+async function runFoldStage(deps, startBranch, preFold, resumeCommand, fn) {
+  await waitForFoldIndexLock(deps, startBranch, resumeCommand);
   try {
     return await fn();
   } catch (e) {
-    throw await recoverFailedFold(deps, e, startBranch, preFold.mainSha);
+    throw await recoverFailedFold(deps, e, startBranch, preFold.mainSha, resumeCommand);
   }
 }
 async function verifyPublishDryRun(deps, ctx, meta, deployModel) {
@@ -9211,30 +9295,31 @@ async function gateTrueMergeCommit(deps, ctx, tag, releaseSha, requiredChecks) {
   }
 }
 async function completeMainRelease(deps, ctx, meta, deployModel, watch, options, tag, releaseSha, startBranch, preFold, tagProbe) {
+  const resumeCommand = options.dev ? "mmi-cli release --dev --apply" : "mmi-cli release --apply";
   try {
     await verifyPublishDryRun(deps, ctx, meta, deployModel);
   } catch (e) {
-    throw await recoverFailedFold(deps, e, startBranch, preFold.mainSha);
+    throw await recoverFailedFold(deps, e, startBranch, preFold.mainSha, resumeCommand);
   }
   let requiredChecks;
   try {
     requiredChecks = await discoverRequiredCheckContexts(deps, ctx, "main");
   } catch (e) {
-    throw await recoverFailedFold(deps, e, startBranch, preFold.mainSha);
+    throw await recoverFailedFold(deps, e, startBranch, preFold.mainSha, resumeCommand);
   }
   let trueMergeGateNote;
   if (preFold.isTrueMerge) {
     try {
       trueMergeGateNote = await gateTrueMergeCommit(deps, ctx, tag, releaseSha, requiredChecks);
     } catch (e) {
-      throw await recoverFailedFold(deps, e, startBranch, preFold.mainSha);
+      throw await recoverFailedFold(deps, e, startBranch, preFold.mainSha, resumeCommand);
     }
   }
   let tagPush;
   try {
     tagPush = await ensureTagPushed(deps, tag, releaseSha, tagProbe, ctx.repo);
   } catch (e) {
-    throw await recoverFailedFold(deps, e, startBranch, preFold.mainSha);
+    throw await recoverFailedFold(deps, e, startBranch, preFold.mainSha, resumeCommand);
   }
   const tagPushSince = (deps.now ?? Date.now)();
   let checks;
@@ -9640,7 +9725,8 @@ async function runTrainApplyPipeline(mode, input) {
     );
     const tagProbe2 = { remoteSha: await probeRemoteTag(deps, tag2) };
     const preFold2 = {};
-    const { versionFold: versionFold2, releaseSha: releaseSha2 } = await runFoldStage(deps, "development", preFold2, async () => {
+    const resumeCommand = options.dev ? "mmi-cli release --dev --apply" : "mmi-cli release --apply";
+    const { versionFold: versionFold2, releaseSha: releaseSha2 } = await runFoldStage(deps, "development", preFold2, resumeCommand, async () => {
       await executeMergeToMain(deps, "development", "development -> main", tolerated2, predicted2, preFold2);
       const versionFold3 = await foldReleaseVersion(deps, deployModel2, tag2, foldPaths2);
       const releaseSha3 = requireValue(clean2(await deps.run("git", ["rev-parse", "main"])), "release sha");
@@ -9725,7 +9811,7 @@ async function runTrainApplyPipeline(mode, input) {
   const tag = requireValue(clean2(await deps.run("node", ["scripts/next-version.mjs", "release"])), "release tag");
   const tagProbe = { remoteSha: await probeRemoteTag(deps, tag) };
   const preFold = {};
-  const { versionFold, releaseSha } = await runFoldStage(deps, "rc", preFold, async () => {
+  const { versionFold, releaseSha } = await runFoldStage(deps, "rc", preFold, "mmi-cli release --apply", async () => {
     await executeMergeToMain(deps, "rc", "rc -> main", tolerated, predicted, preFold);
     const versionFold2 = await foldReleaseVersion(deps, deployModel, tag, foldPaths);
     const releaseSha2 = requireValue(clean2(await deps.run("git", ["rev-parse", "main"])), "release sha");
@@ -12203,7 +12289,7 @@ var import_node_child_process6 = require("node:child_process");
 var import_node_os4 = require("node:os");
 
 // src/gh-create.ts
-var import_promises2 = require("node:fs/promises");
+var import_promises3 = require("node:fs/promises");
 var import_node_os3 = require("node:os");
 var import_node_path14 = require("node:path");
 var import_node_crypto3 = require("node:crypto");
@@ -12255,9 +12341,9 @@ async function bodyArgsViaFile(args, deps = {}) {
   const i = args.indexOf("--body");
   if (i === -1 || i + 1 >= args.length) return { args, cleanup: async () => {
   } };
-  const write = deps.write ?? import_promises2.writeFile;
-  const remove2 = deps.remove ?? import_promises2.unlink;
-  const ensureDir = deps.ensureDir ?? import_promises2.mkdir;
+  const write = deps.write ?? import_promises3.writeFile;
+  const remove2 = deps.remove ?? import_promises3.unlink;
+  const ensureDir = deps.ensureDir ?? import_promises3.mkdir;
   const dir = deps.dir ?? (0, import_node_os3.tmpdir)();
   const file = (0, import_node_path14.join)(dir, `mmi-gh-body-${process.pid}-${(0, import_node_crypto3.randomBytes)(4).toString("hex")}.md`);
   await ensureDir((0, import_node_path14.dirname)(file), { recursive: true }).catch(() => {
@@ -21004,7 +21090,7 @@ function formatBoxTable(boxes) {
   const addrW = w((b) => b.address || "(no public ipv4)", "ADDRESS");
   const projW = w((b) => b.project, "PROJECT");
   const statW = w((b) => b.status, "STATUS");
-  const row = (name, addr, proj, stat2, key) => `${name.padEnd(nameW)}  ${addr.padEnd(addrW)}  ${proj.padEnd(projW)}  ${stat2.padEnd(statW)}  ${key}`;
+  const row = (name, addr, proj, stat3, key) => `${name.padEnd(nameW)}  ${addr.padEnd(addrW)}  ${proj.padEnd(projW)}  ${stat3.padEnd(statW)}  ${key}`;
   const lines = [row("BOX", "ADDRESS", "PROJECT", "STATUS", "SSH KEY (vault path)")];
   for (const b of boxes) {
     lines.push(row(b.name, b.address || "(no public ipv4)", b.project, b.status, b.sshKeyPath));
@@ -21142,7 +21228,7 @@ ${SSH_RECIPE_AGENT_NOTE}`);
 }
 
 // src/schedules-commands.ts
-var import_promises3 = require("node:fs/promises");
+var import_promises4 = require("node:fs/promises");
 var import_node_child_process13 = require("node:child_process");
 var import_node_util7 = require("node:util");
 
@@ -21752,9 +21838,9 @@ function registerSchedulesCommands(program3) {
           await failGraceful("org schedules --doc: refusing to regenerate the doc from an incomplete read (see warnings above).");
           return;
         }
-        const docText = await (0, import_promises3.readFile)(o.doc, "utf8");
+        const docText = await (0, import_promises4.readFile)(o.doc, "utf8");
         const spliced = spliceDoc(docText, renderDocSection(entries, (/* @__PURE__ */ new Date()).toISOString()));
-        await (0, import_promises3.writeFile)(o.doc, spliced, "utf8");
+        await (0, import_promises4.writeFile)(o.doc, spliced, "utf8");
         reportDrift(drift);
         console.log(`org schedules: wrote ${entries.length} entries into ${o.doc}`);
         return;
@@ -21813,7 +21899,7 @@ function registerSchedulesCommands(program3) {
 }
 
 // src/file-lock.ts
-var import_promises4 = require("node:fs/promises");
+var import_promises5 = require("node:fs/promises");
 var import_node_path24 = require("node:path");
 var sleep = (ms) => new Promise((resolve5) => setTimeout(resolve5, ms));
 var IMMEDIATE_RETRY_BUDGET = 3;
@@ -21838,7 +21924,7 @@ async function acquireFileLock(lockPath, opts, deadline) {
   for (; ; ) {
     let handle;
     try {
-      handle = await (0, import_promises4.open)(lockPath, "wx");
+      handle = await (0, import_promises5.open)(lockPath, "wx");
     } catch (e) {
       const code = e.code;
       if (code !== "EEXIST" && code !== "EPERM" && code !== "EBUSY" && code !== "EACCES") throw e;
@@ -21847,10 +21933,10 @@ async function acquireFileLock(lockPath, opts, deadline) {
         if (++immediateRetries > IMMEDIATE_RETRY_BUDGET) await sleep(opts.retryMs);
       };
       try {
-        const age = Date.now() - (await (0, import_promises4.stat)(lockPath)).mtimeMs;
+        const age = Date.now() - (await (0, import_promises5.stat)(lockPath)).mtimeMs;
         if (age > opts.staleMs) {
           try {
-            await (0, import_promises4.unlink)(lockPath);
+            await (0, import_promises5.unlink)(lockPath);
             await retryNow();
             continue;
           } catch (unlinkError) {
@@ -21886,7 +21972,7 @@ async function acquireFileLock(lockPath, opts, deadline) {
 }
 async function fileLockHeldBy(lockPath, token) {
   try {
-    return await (0, import_promises4.readFile)(lockPath, "utf8") === token;
+    return await (0, import_promises5.readFile)(lockPath, "utf8") === token;
   } catch {
     return false;
   }
@@ -21894,12 +21980,12 @@ async function fileLockHeldBy(lockPath, token) {
 async function releaseFileLock(lockPath, guard) {
   await guard.handle.close().catch(() => void 0);
   if (await fileLockHeldBy(lockPath, guard.token)) {
-    await (0, import_promises4.unlink)(lockPath).catch(() => void 0);
+    await (0, import_promises5.unlink)(lockPath).catch(() => void 0);
   }
 }
 async function withFileLock(lockPath, opts, fn) {
   const resolved = resolveFileLockOpts(opts);
-  await (0, import_promises4.mkdir)((0, import_node_path24.dirname)(lockPath), { recursive: true }).catch(() => void 0);
+  await (0, import_promises5.mkdir)((0, import_node_path24.dirname)(lockPath), { recursive: true }).catch(() => void 0);
   const guard = await acquireFileLock(lockPath, resolved, Date.now() + resolved.maxWaitMs);
   try {
     return await fn();
@@ -21909,7 +21995,7 @@ async function withFileLock(lockPath, opts, fn) {
 }
 
 // src/schedules-lift-command.ts
-var import_promises5 = require("node:fs/promises");
+var import_promises6 = require("node:fs/promises");
 var import_node_path25 = require("node:path");
 
 // src/schedules-lift.ts
@@ -22009,14 +22095,14 @@ var RegistryUnreachableError = class extends Error {
 async function readWorkflowFiles(dir) {
   let names;
   try {
-    names = await (0, import_promises5.readdir)(dir);
+    names = await (0, import_promises6.readdir)(dir);
   } catch {
     return [];
   }
   const files = [];
   for (const name of names.sort()) {
     if (!/\.ya?ml$/.test(name)) continue;
-    files.push({ path: `.github/workflows/${name}`, text: await (0, import_promises5.readFile)((0, import_node_path25.join)(dir, name), "utf8") });
+    files.push({ path: `.github/workflows/${name}`, text: await (0, import_promises6.readFile)((0, import_node_path25.join)(dir, name), "utf8") });
   }
   return files;
 }
@@ -24298,7 +24384,7 @@ function registerBoardCommands(program3) {
 
 // src/merge-cleanup.ts
 var import_node_fs30 = require("node:fs");
-var import_promises7 = require("node:fs/promises");
+var import_promises8 = require("node:fs/promises");
 var import_node_path30 = require("node:path");
 var import_node_os11 = require("node:os");
 var import_node_child_process14 = require("node:child_process");
@@ -24386,23 +24472,23 @@ function boardAdvanceFailureMessage(result) {
 }
 
 // src/deferred-registry-store.ts
-var import_promises6 = require("node:fs/promises");
+var import_promises7 = require("node:fs/promises");
 var import_node_path29 = require("node:path");
 var sleep2 = (ms) => new Promise((resolve5) => setTimeout(resolve5, ms));
 async function atomicWrite(target, contents) {
   const tmp = `${target}.tmp-${process.pid}-${Math.random().toString(36).slice(2)}`;
-  await (0, import_promises6.writeFile)(tmp, contents, "utf8");
+  await (0, import_promises7.writeFile)(tmp, contents, "utf8");
   try {
     await renameWithRetry(tmp, target);
   } catch (e) {
-    await (0, import_promises6.unlink)(tmp).catch(() => void 0);
+    await (0, import_promises7.unlink)(tmp).catch(() => void 0);
     throw e;
   }
 }
 async function renameWithRetry(from, to, attempts = 5, backoffMs = 20) {
   for (let i = 0; ; i++) {
     try {
-      await (0, import_promises6.rename)(from, to);
+      await (0, import_promises7.rename)(from, to);
       return;
     } catch (e) {
       const code = e.code;
@@ -24414,7 +24500,7 @@ async function renameWithRetry(from, to, attempts = 5, backoffMs = 20) {
 async function readStrict(registryPath) {
   let text;
   try {
-    text = await (0, import_promises6.readFile)(registryPath, "utf8");
+    text = await (0, import_promises7.readFile)(registryPath, "utf8");
   } catch (e) {
     if (e.code === "ENOENT") return [];
     throw e;
@@ -24431,19 +24517,19 @@ function makeDeferredWorktreeStore(registryPath, lockOpts = {}) {
     // Lenient read for the sweep's initial fetch: any error (missing/corrupt) yields an empty queue.
     read: async () => {
       try {
-        return parseDeferredWorktreesFile(await (0, import_promises6.readFile)(registryPath, "utf8"));
+        return parseDeferredWorktreesFile(await (0, import_promises7.readFile)(registryPath, "utf8"));
       } catch {
         return [];
       }
     },
     // Standalone atomic write — THROWS on failure (no best-effort swallow, #2846).
     write: async (entries) => {
-      await (0, import_promises6.mkdir)((0, import_node_path29.dirname)(registryPath), { recursive: true });
+      await (0, import_promises7.mkdir)((0, import_node_path29.dirname)(registryPath), { recursive: true });
       await atomicWrite(registryPath, serializeDeferredWorktrees(entries));
     },
     // Serialized read-modify-write under the repo-wide lock (#2846).
     update: async (mutate) => {
-      await (0, import_promises6.mkdir)((0, import_node_path29.dirname)(registryPath), { recursive: true });
+      await (0, import_promises7.mkdir)((0, import_node_path29.dirname)(registryPath), { recursive: true });
       const deadline = Date.now() + opts.maxWaitMs;
       for (; ; ) {
         const guard = await acquireLock(lockPath, opts, deadline);
@@ -24884,7 +24970,7 @@ var realWorktreeDirRemover = {
       (0, import_node_fs30.unlinkSync)(p);
     }
   },
-  removeTree: (p) => (0, import_promises7.rm)(p, { recursive: true, force: true, maxRetries: 5, retryDelay: 200 })
+  removeTree: (p) => (0, import_promises8.rm)(p, { recursive: true, force: true, maxRetries: 5, retryDelay: 200 })
 };
 async function resolvePrimaryCheckout(execGit) {
   try {
@@ -25141,7 +25227,7 @@ async function fetchRestCorePool(gh = defaultGhApi) {
 
 // src/worktree-lifecycle-commands.ts
 var import_node_fs31 = require("node:fs");
-var import_promises8 = require("node:fs/promises");
+var import_promises9 = require("node:fs/promises");
 var import_node_path31 = require("node:path");
 var GH_TIMEOUT_MS = 2e4;
 var DEFAULT_BASE = "origin/development";
@@ -25485,13 +25571,13 @@ function registerWorktreeCommands(program3) {
       }
       const landStatus = (await execFileP2("git", ["-C", wtPath, "status", "--porcelain"], { timeout: GIT_TIMEOUT_MS }).catch(() => ({ stdout: "unreadable" }))).stdout || "";
       const gitInWorktree = async (args) => (await execFileP2("git", ["-C", wtPath, ...args], { timeout: GIT_TIMEOUT_MS })).stdout;
-      const orphanDirt = headBorn ? void 0 : await classifyOrphanWorktreeDirt(landStatus, { git: gitInWorktree, readTextFile: (p) => (0, import_promises8.readFile)(p, "utf8") });
+      const orphanDirt = headBorn ? void 0 : await classifyOrphanWorktreeDirt(landStatus, { git: gitInWorktree, readTextFile: (p) => (0, import_promises9.readFile)(p, "utf8") });
       const landDirty = headBorn ? landStatus.trim().length > 0 : orphanDirt.dirt !== "clean";
       if (landDirty) {
         return fail(`worktree land: refusing to land '${branch}' \u2014 uncommitted changes in ${wtPath}; commit, stash, or remove the worktree manually`, { code: ERROR_CODES.ERR_BAD_ENUM });
       }
       const orphanTip = orphan.orphan ? orphanDirt?.tip ?? await readOrphanWorktreeTip(
-        { git: gitInWorktree, readTextFile: (p) => (0, import_promises8.readFile)(p, "utf8") },
+        { git: gitInWorktree, readTextFile: (p) => (0, import_promises9.readFile)(p, "utf8") },
         orphan.kind
       ) : void 0;
       const lastCommit = orphanTip ? {
@@ -26917,7 +27003,7 @@ function registerExplainCommand(program3) {
 }
 
 // src/pr-commands.ts
-var import_promises9 = require("node:fs/promises");
+var import_promises10 = require("node:fs/promises");
 var GC_GH_TIMEOUT_MS4 = 2e4;
 var CHECKS_WATCH_POLL_MS = 15e3;
 var CHECKS_WATCH_TIMEOUT_MS = 10 * 6e4;
@@ -27061,10 +27147,10 @@ function registerPrLifecycleCommands(program3) {
     let body;
     try {
       if (o.title || o.titleFile) {
-        title = await resolveIssueTitle({ title: o.title, titleFile: o.titleFile }, { readFile: import_promises9.readFile, readStdin });
+        title = await resolveIssueTitle({ title: o.title, titleFile: o.titleFile }, { readFile: import_promises10.readFile, readStdin });
       }
       if (o.body || o.bodyFile) {
-        body = await resolveIssueBody({ body: o.body, bodyFile: o.bodyFile }, { readFile: import_promises9.readFile, readStdin });
+        body = await resolveIssueBody({ body: o.body, bodyFile: o.bodyFile }, { readFile: import_promises10.readFile, readStdin });
       }
     } catch (e) {
       return fail(`pr edit: ${e.message}`);
@@ -27094,7 +27180,7 @@ function registerPrLifecycleCommands(program3) {
     }
     let body;
     try {
-      body = await resolveIssueBody({ body: o.body, bodyFile: o.bodyFile }, { readFile: import_promises9.readFile, readStdin });
+      body = await resolveIssueBody({ body: o.body, bodyFile: o.bodyFile }, { readFile: import_promises10.readFile, readStdin });
     } catch (e) {
       return fail(`pr comment: ${e.message}`);
     }
@@ -27382,9 +27468,17 @@ function findNegatedClosings(text, closingNumbers) {
     return forIssue.length > 0 && forIssue.every((m) => m.negated);
   });
 }
+function commitMessagesText(commits) {
+  if (!Array.isArray(commits)) return "";
+  return commits.map((commit) => {
+    const { messageHeadline, messageBody } = commit ?? {};
+    return `${typeof messageHeadline === "string" ? messageHeadline : ""}
+${typeof messageBody === "string" ? messageBody : ""}`;
+  }).join("\n");
+}
 function parseClosingGuardInput(raw) {
   if (!raw || typeof raw !== "object") return void 0;
-  const { title, body, state, closingIssuesReferences } = raw;
+  const { title, body, state, closingIssuesReferences, commits } = raw;
   if (typeof state !== "string" || !Array.isArray(closingIssuesReferences)) return void 0;
   const closing = [];
   for (const ref of closingIssuesReferences) {
@@ -27392,15 +27486,20 @@ function parseClosingGuardInput(raw) {
     if (typeof n !== "number" || !Number.isInteger(n) || n <= 0) return void 0;
     closing.push(n);
   }
+  const commitClosing = [...new Set(findClosingMentions(commitMessagesText(commits)).map((m) => m.issue))];
   const text = `${typeof title === "string" ? title : ""}
 ${typeof body === "string" ? body : ""}`;
-  return { state, text, closing };
+  return { state, text, closing, commitClosing };
 }
 function negatedClosingRefusalMessage(negated, context = "pr merge") {
   const named = negated.map((n) => `#${n}`).join(", ");
   const first = `#${negated[0] ?? "N"}`;
   return `${context}: REFUSED \u2014 GitHub will close ${named} on merge, but the PR body says it does not (GitHub's closing-keyword parser is negation-blind: "does not close ${first}" still closes it). Reword the body so the keyword is gone (e.g. "leaves ${first} open"), or re-run with --force to merge anyway and let ${named} close.`;
 }
+function commitClosingRefusalMessage(closing, context = "pr merge") {
+  const named = closing.map((n) => `#${n}`).join(", ");
+  return `${context}: REFUSED \u2014 commit messages will close ${named} through the squash body, but GitHub omitted ${named} from closingIssuesReferences. Remove the closing keyword from the commit message, or re-run with --force to merge anyway and let ${named} close.`;
+}
 function evaluateClosingGuard(input, opts) {
   if (!input) {
     return {
@@ -27408,7 +27507,16 @@ function evaluateClosingGuard(input, opts) {
       message: `${opts.context}: could not read the PR's closing references \u2014 proceeding WITHOUT the negated-closing check (#3718).`
     };
   }
-  if (input.state !== "OPEN" || input.closing.length === 0) return { blocked: false };
+  if (input.state !== "OPEN") return { blocked: false };
+  const commitClosing = (input.commitClosing ?? []).filter((n) => !input.closing.includes(n));
+  if (commitClosing.length) {
+    if (!opts.force) return { blocked: true, message: commitClosingRefusalMessage(commitClosing, opts.context) };
+    return {
+      blocked: false,
+      message: `${opts.context}: --force past the commit-message closing guard \u2014 the squash body will close ${commitClosing.map((n) => `#${n}`).join(", ")}.`
+    };
+  }
+  if (input.closing.length === 0) return { blocked: false };
   const negated = findNegatedClosings(input.text, input.closing);
   if (!negated.length) return { blocked: false };
   if (!opts.force) return { blocked: true, message: negatedClosingRefusalMessage(negated, opts.context) };
@@ -30669,7 +30777,7 @@ withExamples(mutating(
     try {
       title = await resolveIssueTitle(
         { title: opts.title, titleFile: opts.titleFile },
-        { readFile: import_promises10.readFile, readStdin }
+        { readFile: import_promises11.readFile, readStdin }
       );
     } catch (e) {
       return fail(
@@ -30711,8 +30819,8 @@ withExamples(mutating(
   let surfaceFlagLabel;
   try {
     issueType = resolveCreateType(o.type, "issue create", o.label);
-    title = await resolveIssueTitle({ title: o.title, titleFile: o.titleFile }, { readFile: import_promises10.readFile, readStdin });
-    body = await resolveIssueBody({ body: o.body, bodyFile: o.bodyFile }, { readFile: import_promises10.readFile, readStdin });
+    title = await resolveIssueTitle({ title: o.title, titleFile: o.titleFile }, { readFile: import_promises11.readFile, readStdin });
+    body = await resolveIssueBody({ body: o.body, bodyFile: o.bodyFile }, { readFile: import_promises11.readFile, readStdin });
     if (o.idempotencyKey) body = appendIdempotencyMarker(body, o.idempotencyKey);
     priority = resolveCreatePriority(o.priority, "issue create");
     extraLabels = [...o.label ?? []];
@@ -30892,7 +31000,7 @@ jsonParity(issue.command("comment <ref>").description("post a Markdown comment t
   }
   let body;
   try {
-    body = await resolveIssueBody({ body: o.body, bodyFile: o.bodyFile }, { readFile: import_promises10.readFile, readStdin });
+    body = await resolveIssueBody({ body: o.body, bodyFile: o.bodyFile }, { readFile: import_promises11.readFile, readStdin });
   } catch (e) {
     return fail(`issue comment: ${e.message}`);
   }
@@ -30952,8 +31060,8 @@ program2.command("report").description("file a friction report on the Hub board
   let title;
   const sourceRepo = o.repo ?? await resolveRepo(void 0);
   try {
-    title = await resolveIssueTitle({ title: o.title, titleFile: o.titleFile }, { readFile: import_promises10.readFile, readStdin });
-    body = await resolveIssueBody({ body: o.body, bodyFile: o.bodyFile }, { readFile: import_promises10.readFile, readStdin });
+    title = await resolveIssueTitle({ title: o.title, titleFile: o.titleFile }, { readFile: import_promises11.readFile, readStdin });
+    body = await resolveIssueBody({ body: o.body, bodyFile: o.bodyFile }, { readFile: import_promises11.readFile, readStdin });
     priority = resolveCreatePriority(o.priority, "report");
     if (!ISSUE_TYPES.includes(o.type)) {
       throw new Error(`unknown issue type "${o.type}" \u2014 expected one of: ${ISSUE_TYPES.join(", ")}`);
@@ -31005,8 +31113,8 @@ program2.command("skill-lesson").description("file a skill-lesson on the Hub boa
   let args;
   try {
     skill = assertSkillName(o.skill);
-    rawBody = await resolveIssueBody({ body: o.body, bodyFile: o.bodyFile }, { readFile: import_promises10.readFile, readStdin });
-    const rawTitle = await resolveIssueTitle({ title: o.title, titleFile: o.titleFile }, { readFile: import_promises10.readFile, readStdin });
+    rawBody = await resolveIssueBody({ body: o.body, bodyFile: o.bodyFile }, { readFile: import_promises11.readFile, readStdin });
+    const rawTitle = await resolveIssueTitle({ title: o.title, titleFile: o.titleFile }, { readFile: import_promises11.readFile, readStdin });
     title = buildSkillLessonTitle(skill, rawTitle);
     priority = resolveCreatePriority(o.priority, "skill-lesson");
     body = buildSkillLessonBody(rawBody, sourceRepo, pluginSha);
@@ -31065,8 +31173,8 @@ withExamples(pr.command("create").description("create a PR and print {number,url
   let body;
   let title;
   try {
-    title = await resolveIssueTitle({ title: o.title, titleFile: o.titleFile }, { readFile: import_promises10.readFile, readStdin });
-    body = await resolveIssueBody({ body: o.body, bodyFile: o.bodyFile }, { readFile: import_promises10.readFile, readStdin });
+    title = await resolveIssueTitle({ title: o.title, titleFile: o.titleFile }, { readFile: import_promises11.readFile, readStdin });
+    body = await resolveIssueBody({ body: o.body, bodyFile: o.bodyFile }, { readFile: import_promises11.readFile, readStdin });
   } catch (e) {
     return fail(`pr create: ${e.message}`, e instanceof TextArgError ? { code: e.code, offending_flag: e.offendingFlag } : void 0);
   }
@@ -31200,7 +31308,7 @@ pr.command("land <number>").description("agent merge path (#1440): train probe \
   const repoArgs = o.repo ? ["--repo", o.repo] : [];
   const startingPath = (await execFileP2("git", ["rev-parse", "--show-toplevel"], { timeout: GIT_TIMEOUT_MS }).catch(() => ({ stdout: "" }))).stdout.trim();
   assertPrMergeHousekeepingClean(startingPath || process.cwd(), "pr land", { force: o.force });
-  const landClosingGuardRaw = await execFileP2("gh", ["pr", "view", number, ...repoArgs, "--json", "title,body,state,closingIssuesReferences"], { timeout: GC_GH_TIMEOUT_MS2 }).then((r) => JSON.parse(r.stdout)).catch(() => void 0);
+  const landClosingGuardRaw = await execFileP2("gh", ["pr", "view", number, ...repoArgs, "--json", "title,body,state,closingIssuesReferences,commits"], { timeout: GC_GH_TIMEOUT_MS2 }).then((r) => JSON.parse(r.stdout)).catch(() => void 0);
   const landClosingGuardVerdict = evaluateClosingGuard(parseClosingGuardInput(landClosingGuardRaw), { force: o.force, context: "pr land" });
   if (landClosingGuardVerdict.blocked) {
     console.error(landClosingGuardVerdict.message);
@@ -31318,7 +31426,7 @@ jsonParity(pr.command("merge <number>").description("merge a PR (squash by defau
   const repoForPostCleanup = await resolveRepo(o.repo) ?? o.repo;
   const [headRef, baseRef, headRefOid] = (await execFileP2("gh", ["pr", "view", number, ...repoArgs, "--json", "headRefName,baseRefName,headRefOid", "--jq", '.headRefName + " " + .baseRefName + " " + (.headRefOid // "")'], { timeout: GC_GH_TIMEOUT_MS2 })).stdout.trim().split(/\s+/);
   const headIsProtected = isProtectedBranch(headRef);
-  const closingGuardRaw = await execFileP2("gh", ["pr", "view", number, ...repoArgs, "--json", "title,body,state,closingIssuesReferences"], { timeout: GC_GH_TIMEOUT_MS2 }).then((r) => JSON.parse(r.stdout)).catch(() => void 0);
+  const closingGuardRaw = await execFileP2("gh", ["pr", "view", number, ...repoArgs, "--json", "title,body,state,closingIssuesReferences,commits"], { timeout: GC_GH_TIMEOUT_MS2 }).then((r) => JSON.parse(r.stdout)).catch(() => void 0);
   const closingGuardVerdict = evaluateClosingGuard(parseClosingGuardInput(closingGuardRaw), { force: o.force, context: "pr merge" });
   if (closingGuardVerdict.blocked) {
     console.error(closingGuardVerdict.message);
@@ -31563,8 +31671,8 @@ function trainApplyDeps() {
     // Slack release announcement (#883): Hub-only + best-effort inside announceRelease itself.
     announce: (args) => announceRelease({
       run: async (file, cmdArgs) => (await execFileP2(file, cmdArgs, { timeout: GH_TRAIN_TIMEOUT_MS })).stdout,
-      readFile: (path2) => (0, import_promises10.readFile)(path2, "utf8"),
-      removeFile: (path2) => (0, import_promises10.unlink)(path2)
+      readFile: (path2) => (0, import_promises11.readFile)(path2, "utf8"),
+      removeFile: (path2) => (0, import_promises11.unlink)(path2)
     }, args),
     fetchEdgeDomains: async (slug) => {
       const proj = await fetchProjectBySlug(slug, registryClientDeps(await loadConfig()));
@@ -31747,7 +31855,7 @@ for (const commandName of ["rcand", "release"]) {
       }
       let summaryLines;
       try {
-        summaryLines = summaryFileLines(await (0, import_promises10.readFile)(o.announceSummaryFile, "utf8"));
+        summaryLines = summaryFileLines(await (0, import_promises11.readFile)(o.announceSummaryFile, "utf8"));
       } catch (e) {
         return fail(`release: could not read --announce-summary-file ${o.announceSummaryFile}: ${e.message}`);
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mutmutco/cli",
-  "version": "3.84.0",
+  "version": "3.86.0",
   "description": "MMI Future CLI — the org dev toolbox and shared cross-IDE engine for every registry-declared MMI coding surface.",
   "type": "module",
   "license": "UNLICENSED",