@mutmutco/cli 4.3.21 → 4.3.23

package/dist/main.cjs

@@ -12242,7 +12242,10 @@ async function claimOneBoardItem(ctx, selector, options) {
       }
       return;
     }
-    if (!options.force) throw new Error(withPowerShellChainHint(laneContestMessage(item.ref, contest, "claim")));
+    if (!options.force) {
+      const refusal = laneContestMessage(item.ref, contest, "claim");
+      throw new Error(options.bulk ? refusal : withPowerShellChainHint(refusal));
+    }
     previousHolder = displaced();
   };
   await refuseIfContested();
@@ -12313,7 +12316,7 @@ async function claimBoardIssues(options, deps = {}) {
       const selector = selectors[index];
       const ref = `${selector.repo}#${selector.number}`;
       try {
-        const result = await claimOneBoardItem(ctx, selector, options);
+        const result = await claimOneBoardItem(ctx, selector, { ...options, bulk: true });
         results[index] = { ref: result.item.ref, claimed: true, item: result.item, status: result.status, partial: result.partial, warning: result.warning, outcome: result.outcome, holder: result.holder, previousHolder: result.previousHolder, resumeEvidence: result.resumeEvidence, alreadyClaimed: result.alreadyClaimed, checked: result.checked };
       } catch (e) {
         results[index] = { ref, claimed: false, reason: e.message };
@@ -15516,10 +15519,10 @@ var rollout_plan_default = {
     note: "The v4.0.0 stamp happens at cut time (D6e #4463); until then the candidate is the origin/development head artifacts (built cli/dist + npm pack), identity proven by dist content hash (D6a)."
   },
   baseline: {
-    version: "4.3.21",
-    tag: "v4.3.21",
-    commit: "f55fc2217cd3",
-    npm: "@mutmutco/cli@4.3.21"
+    version: "4.3.23",
+    tag: "v4.3.23",
+    commit: "64b06ac32d90",
+    npm: "@mutmutco/cli@4.3.23"
   },
   exitCriterion: "fleet-n-of-n",
   hubOnlyShortcut: "forbidden",
@@ -15536,14 +15539,14 @@ var rollout_plan_default = {
           repo: "mutmutco/mmi-hub",
           role: "canary",
           schedule: "train",
-          v3Target: "v4.3.21"
+          v3Target: "v4.3.23"
         }
       ],
       rollbackTrigger: "Any red inside the post-contract soak window: `devops train gate` FAIL attributable to the v4 doors, Hub endpoint health probe failure, a pre-v4 client admitted instead of receiving actionable HTTP 426, or npm consumer install/doctor failure on the v4-only dist.",
       rollback: {
         independent: true,
-        mechanism: "npm dist-tag latest -> 4.3.21 and redeploy the Hub Lambda from tag v4.3.21 (f55fc2217cd3); installed clients repair via `mmi-cli doctor`. No other cohort is touched.",
-        v3Target: "v4.3.21 (@mutmutco/cli@4.3.21, tag commit f55fc2217cd3 \u2014 last known-good release carrying the repo-index v4-only contract)"
+        mechanism: "npm dist-tag latest -> 4.3.23 and redeploy the Hub Lambda from tag v4.3.23 (64b06ac32d90); installed clients repair via `mmi-cli doctor`. No other cohort is touched.",
+        v3Target: "v4.3.23 (@mutmutco/cli@4.3.23, tag commit 64b06ac32d90 \u2014 last known-good release carrying the repo-index v4-only contract)"
       }
     },
     {
@@ -17911,8 +17914,29 @@ async function discoverRequiredCheckContexts(deps, ctx, branch) {
   }
   return [...contexts];
 }
-async function findAlignmentPr(deps, ctx, target) {
-  const out = clean2(await deps.run("gh", ["pr", "list", "--repo", ctx.repo, "--base", target, "--head", "main", "--state", "all", "--json", "number,url,state"]));
+function alignmentBranchName(target, tag) {
+  return `release-align/${target}/${tag}`;
+}
+async function pushAlignmentBranch(deps, target, tag) {
+  const branch = alignmentBranchName(target, tag);
+  let tree;
+  try {
+    tree = clean2(await deps.run("git", ["merge-tree", "--write-tree", "--no-messages", `origin/${target}`, "origin/main"])).split("\n")[0] ?? "";
+  } catch {
+    const files = await runMergeTreePreflight(deps, `origin/${target}`, "origin/main");
+    throw new Error(
+      `the ${target} alignment of ${tag} could not merge origin/main${files.length ? ` \u2014 conflicts on ${files.join(", ")}` : ""} (#6288). Reconcile it on a branch cut from origin/${target} that merges origin/main, open that against ${target}, and land it with a true merge (\`mmi-cli devops pr merge <n> --auto --merge\`) \u2014 never hand-resolve on main, and never merge ${target} into main.`
+    );
+  }
+  if (!tree) throw new Error(`git merge-tree wrote no tree for the ${target} alignment of ${tag} (#6288)`);
+  const commit = clean2(await deps.run("git", ["commit-tree", tree, "-p", `origin/${target}`, "-p", "origin/main", "-m", `chore(release): align ${target} to ${tag}`]));
+  if (!commit) throw new Error(`git commit-tree wrote no commit for the ${target} alignment of ${tag} (#6288)`);
+  await deps.run("git", ["push", "origin", "--delete", branch]).catch(() => void 0);
+  await runGitPush(deps, ["push", "origin", `${commit}:refs/heads/${branch}`]);
+  return branch;
+}
+async function findAlignmentPr(deps, ctx, target, head) {
+  const out = clean2(await deps.run("gh", ["pr", "list", "--repo", ctx.repo, "--base", target, "--head", head, "--state", "all", "--json", "number,url,state"]));
   if (!out) return void 0;
   const rows = JSON.parse(out);
   const row = rows.filter((r) => typeof r.number === "number" && typeof r.url === "string" && (r.state === "OPEN" || r.state === "MERGED")).sort((a, b) => b.number - a.number)[0];
@@ -17933,23 +17957,28 @@ async function rollDevelopmentForward(deps, ctx, tag) {
     return { status: "pushed", note: "development rolled forward to the released main (development has no required checks)" };
   }
   const ahead = clean2(await deps.run("git", ["rev-list", "--count", "origin/development..origin/main"]));
-  const existing = await findAlignmentPr(deps, ctx, "development");
+  const branch = alignmentBranchName("development", tag);
+  const existing = await findAlignmentPr(deps, ctx, "development", branch);
   if (ahead === "0") {
+    const merged = existing ?? await findAlignmentPr(deps, ctx, "development", "main");
     return {
       status: "aligned",
       alignment: "already-merged",
-      note: existing?.state === "MERGED" ? `alignment: already-merged \u2014 development already contains main via alignment PR #${existing.number}` : "alignment: already-merged \u2014 development already contains the released main; nothing to roll forward"
+      note: merged?.state === "MERGED" ? `alignment: already-merged \u2014 development already contains main via alignment PR #${merged.number}` : "alignment: already-merged \u2014 development already contains the released main; nothing to roll forward"
     };
   }
   if (existing?.state === "OPEN") {
     return enqueueAlignmentAutoMerge(deps, ctx, existing.number, existing.url, `alignment PR already open: ${existing.url}`);
   }
+  const superseded = await findAlignmentPr(deps, ctx, "development", "main");
+  const supersededNote = superseded?.state === "OPEN" ? ` (supersedes the main-headed alignment PR #${superseded.number}, which GitHub closes as merged once this lands \u2014 #6288)` : "";
+  await pushAlignmentBranch(deps, "development", tag);
   const body = `Carries the ${tag} release (including the version fold) from \`main\` back to \`development\`.
 
-\`development\` requires status checks, so the release train opens this alignment PR instead of a direct push of the un-checked merge commit (#1143). Land it with a **true merge** \u2014 \`mmi-cli devops pr merge <n> --auto --merge\` (not squash) so the merge parentage survives and the misalignment guard stays satisfied. \`--auto\` waits out the checks this PR triggers, which otherwise block an immediate merge right after the release.`;
-  const url = clean2(await deps.run("gh", ["pr", "create", "--repo", ctx.repo, "--base", "development", "--head", "main", "--title", `chore(release): align development to ${tag}`, "--body", body]));
+\`development\` requires status checks, so the release train opens this alignment PR instead of a direct push of the un-checked merge commit (#1143). The head is \`development\` with \`main\` merged into it, never \`main\` itself: a strict \`require branches to be up to date\` ruleset can never be satisfied by a main-headed PR, and satisfying it literally would promote every unreleased commit to \`main\` (#6288). Land it with a **true merge** \u2014 \`mmi-cli devops pr merge <n> --auto --merge\` (not squash) so the merge parentage survives and the misalignment guard stays satisfied. \`--auto\` waits out the checks this PR triggers, which otherwise block an immediate merge right after the release.`;
+  const url = clean2(await deps.run("gh", ["pr", "create", "--repo", ctx.repo, "--base", "development", "--head", branch, "--title", `chore(release): align development to ${tag}`, "--body", body]));
   const number = parsePrNumber(url);
-  return enqueueAlignmentAutoMerge(deps, ctx, number, url || void 0, `development requires checks (${required.join(", ")}); opened alignment PR ${url || "(url unavailable)"}`);
+  return enqueueAlignmentAutoMerge(deps, ctx, number, url || void 0, `development requires checks (${required.join(", ")}); opened alignment PR ${url || "(url unavailable)"}${supersededNote}`);
 }
 var ALIGNMENT_ARM_ATTEMPTS = 3;
 var ALIGNMENT_ARM_BACKOFF_MS = 2e3;
@@ -17990,23 +18019,28 @@ async function alignRcForward(deps, ctx, tag) {
     return { status: "pushed", note: "rc aligned to the released main (rc has no required checks)" };
   }
   const ahead = clean2(await deps.run("git", ["rev-list", "--count", "origin/rc..origin/main"]));
-  const existing = await findAlignmentPr(deps, ctx, "rc");
+  const branch = alignmentBranchName("rc", tag);
+  const existing = await findAlignmentPr(deps, ctx, "rc", branch);
   if (ahead === "0") {
+    const merged = existing ?? await findAlignmentPr(deps, ctx, "rc", "main");
     return {
       status: "aligned",
       alignment: "already-merged",
-      note: existing?.state === "MERGED" ? `alignment: already-merged \u2014 rc already contains main via alignment PR #${existing.number}` : "alignment: already-merged \u2014 rc already contains the released main; nothing to align"
+      note: merged?.state === "MERGED" ? `alignment: already-merged \u2014 rc already contains main via alignment PR #${merged.number}` : "alignment: already-merged \u2014 rc already contains the released main; nothing to align"
     };
   }
   if (existing?.state === "OPEN") {
     return enqueueAlignmentAutoMerge(deps, ctx, existing.number, existing.url, `rc alignment PR already open: ${existing.url}`);
   }
+  const superseded = await findAlignmentPr(deps, ctx, "rc", "main");
+  const supersededNote = superseded?.state === "OPEN" ? ` (supersedes the main-headed alignment PR #${superseded.number}, which GitHub closes as merged once this lands \u2014 #6288)` : "";
+  await pushAlignmentBranch(deps, "rc", tag);
   const body = `Carries the ${tag} release from \`main\` back to \`rc\`.
 
-\`rc\` requires status checks, so the release train opens this alignment PR instead of bypassing branch protection with a direct push. Land it with a **true merge** \u2014 \`mmi-cli devops pr merge <n> --auto --merge\` (not squash) so the merge parentage survives.`;
-  const url = clean2(await deps.run("gh", ["pr", "create", "--repo", ctx.repo, "--base", "rc", "--head", "main", "--title", `chore(release): align rc to ${tag}`, "--body", body]));
+\`rc\` requires status checks, so the release train opens this alignment PR instead of bypassing branch protection with a direct push. The head is \`rc\` with \`main\` merged into it, never \`main\` itself \u2014 a strict \`require branches to be up to date\` ruleset can never be satisfied by a main-headed PR (#6288). Land it with a **true merge** \u2014 \`mmi-cli devops pr merge <n> --auto --merge\` (not squash) so the merge parentage survives.`;
+  const url = clean2(await deps.run("gh", ["pr", "create", "--repo", ctx.repo, "--base", "rc", "--head", branch, "--title", `chore(release): align rc to ${tag}`, "--body", body]));
   const number = parsePrNumber(url);
-  return enqueueAlignmentAutoMerge(deps, ctx, number, url || void 0, `rc requires checks (${required.join(", ")}); opened alignment PR ${url || "(url unavailable)"}`);
+  return enqueueAlignmentAutoMerge(deps, ctx, number, url || void 0, `rc requires checks (${required.join(", ")}); opened alignment PR ${url || "(url unavailable)"}${supersededNote}`);
 }
 var FLEET_FOREIGN_VERDICT_GRACE_ATTEMPTS = 3;
 function resolveContextState(context, checkRuns, statuses) {
@@ -21549,6 +21583,23 @@ async function runTrainDoctor(input) {
           derived = deriveReleasePhaseStatus(ledger);
         }
       }
+      if (derived.legs.some((l) => l.phase === "alignment" && l.state === "pending")) {
+        for (const target of ["development", "rc"].filter((t) => t !== "rc" || track === "full")) {
+          try {
+            const stale = await findAlignmentPr(train, ctx, target, "main");
+            if (stale?.state !== "OPEN") continue;
+            add({
+              code: "alignment-pr-main-headed",
+              severity: "blocker",
+              source: "origin",
+              title: `alignment PR #${stale.number} (\`main\` -> ${target}) is headed by \`main\` \u2014 under a strict "branches must be up to date" ruleset it can never merge (#6288)`,
+              remedy: `rerun \`mmi-cli devops release --resume\`: the train rebuilds the alignment as \`release-align/${target}/<tag>\` (${target} with \`main\` merged into it), which is up to date by construction; GitHub closes #${stale.number} as merged once that lands. Never merge ${target} into \`main\`, never hand-merge on \`main\`, and never add a bypass actor to the strict rule`
+            });
+          } catch (e) {
+            unverified(`the ${target} alignment PR head`, e);
+          }
+        }
+      }
       if (derived.phaseStatus !== "phases-green") {
         const open2 = derived.legs.filter((l) => l.state === "pending" || l.state === "failed").map((l) => `${l.phase}=${l.state}`).join(", ");
         const failed = derived.phaseStatus === "phases-failed";
@@ -33227,7 +33278,10 @@ function extendCreateCommand(issue, batchAttach) {
       try {
         const raw = (0, import_node_fs31.readFileSync)(opts.batch, "utf8");
         specs = JSON.parse(raw);
-        if (!Array.isArray(specs)) throw new Error("batch file must contain a JSON array");
+        if (!Array.isArray(specs)) {
+          const top = specs === null ? "null" : typeof specs === "object" ? `an object with keys: ${Object.keys(specs).join(", ") || "(none)"}` : `a ${typeof specs}`;
+          throw new Error(`batch file must contain a JSON array, but its top level is ${top}`);
+        }
       } catch (e) {
         return fail(`issue create --batch: cannot read/parse ${opts.batch}: ${e.message}`);
       }
@@ -36185,10 +36239,18 @@ function prHeadBehindBase(input) {
 function prHeadUpdateRemedy(head, base) {
   return `git fetch origin ${base} && git merge origin/${base} (on ${head}), resolve the conflicts, push, then rerun \u2014 docs/Guides/train-troubleshooting.md#head-behind-base`;
 }
+var PROTECTED_PR_HEAD_BRANCHES = ["main", "master", "development", "rc"];
+function isProtectedPrHead(head) {
+  return PROTECTED_PR_HEAD_BRANCHES.includes(head);
+}
+function protectedPrHeadRemedy(head, base) {
+  return `PR head \`${head}\` is a train branch \u2014 updating it from \`${base}\` would merge \`${base}\` into \`${head}\`, promoting every unreleased commit. Never do that and never hand-merge on \`${head}\`. This is the pre-#6288 alignment shape: close this PR and let the train rebuild the alignment on a \`${base}\`-based branch that merges \`${head}\` into it (\`mmi-cli devops release --resume\`), then land THAT with a true merge \u2014 docs/Guides/train-troubleshooting.md#head-behind-base`;
+}
 var PR_HEAD_UPDATE_API_READ_RETRIES = 5;
 var PR_HEAD_UPDATE_API_READ_DELAY_MS = 2e3;
 async function updatePrHeadFromBase(input) {
   const remedy = prHeadUpdateRemedy(input.head, input.base);
+  if (isProtectedPrHead(input.head)) throw new Error(protectedPrHeadRemedy(input.head, input.base));
   if (input.localCheckedOut) {
     const from2 = (await input.git(["rev-parse", "HEAD"])).trim();
     await input.git(["fetch", "origin", input.base]);
@@ -36475,8 +36537,9 @@ var WAIVABLE_KINDS = [
 var TEST_WORK_KIND = "unrequested-test-file";
 var TEST_FILE_RE = /\.(?:test|spec)\.[cm]?[jt]sx?$/;
 var PY_TEST_FILE_RE = /(?:^|\/)test_[^/]*\.py$|_test\.py$/;
+var GO_TEST_FILE_RE = /_test\.go$/;
 function isTestPath(path2) {
-  return typeof path2 === "string" && (TEST_FILE_RE.test(path2) || PY_TEST_FILE_RE.test(path2));
+  return typeof path2 === "string" && (TEST_FILE_RE.test(path2) || PY_TEST_FILE_RE.test(path2) || GO_TEST_FILE_RE.test(path2));
 }
 function editsExistingTest(paths, addedPaths = []) {
   const added = new Set(Array.isArray(addedPaths) ? addedPaths : []);
@@ -36631,6 +36694,7 @@ var HOTFIX_POLICY_REF = "origin/development";
 var HOTFIX_DIFF_BASE = "origin/main";
 var TEST_RE = TEST_FILE_RE;
 var PY_TEST_RE = PY_TEST_FILE_RE;
+var GO_TEST_RE = GO_TEST_FILE_RE;
 function translate(glob) {
   let out = "";
   for (let i = 0; i < glob.length; i++) {
@@ -36666,7 +36730,7 @@ function globToRegExp2(glob) {
   return new RegExp(`^${translate(glob)}$`);
 }
 function isTestPath2(path2) {
-  return TEST_RE.test(path2) || PY_TEST_RE.test(path2);
+  return TEST_RE.test(path2) || PY_TEST_RE.test(path2) || GO_TEST_RE.test(path2);
 }
 var SUPPORTED_SOURCE = /\.[cm]?[jt]s$/;
 var MAX_ANALYZED_BYTES = 512 * 1024;

package/package.json

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