@mutmutco/cli 4.3.52 → 4.3.53

package/dist/main.cjs

@@ -15858,10 +15858,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.52",
-    tag: "v4.3.52",
-    commit: "6219f52caf87",
-    npm: "@mutmutco/cli@4.3.52"
+    version: "4.3.53",
+    tag: "v4.3.53",
+    commit: "8877c0336b18",
+    npm: "@mutmutco/cli@4.3.53"
   },
   exitCriterion: "fleet-n-of-n",
   hubOnlyShortcut: "forbidden",
@@ -15878,14 +15878,14 @@ var rollout_plan_default = {
           repo: "mutmutco/mmi-hub",
           role: "canary",
           schedule: "train",
-          v3Target: "v4.3.52"
+          v3Target: "v4.3.53"
         }
       ],
       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.52 and redeploy the Hub Lambda from tag v4.3.52 (6219f52caf87); installed clients repair via `mmi-cli doctor`. No other cohort is touched.",
-        v3Target: "v4.3.52 (@mutmutco/cli@4.3.52, tag commit 6219f52caf87 \u2014 last known-good release carrying the repo-index v4-only contract)"
+        mechanism: "npm dist-tag latest -> 4.3.53 and redeploy the Hub Lambda from tag v4.3.53 (8877c0336b18); installed clients repair via `mmi-cli doctor`. No other cohort is touched.",
+        v3Target: "v4.3.53 (@mutmutco/cli@4.3.53, tag commit 8877c0336b18 \u2014 last known-good release carrying the repo-index v4-only contract)"
       }
     },
     {
@@ -17819,6 +17819,7 @@ rollback stays available: mmi-cli devops train enforce --apply --disarm`
 
 // src/train-apply-correlation.ts
 async function verifyPublishedRelease(deps, repo, tag, expectedTarget, expectedSha) {
+  deps.warn?.("Release: Verifying the published release");
   const out = await deps.run("gh", ["release", "view", tag, "--repo", repo, "--json", "tagName,targetCommitish"]);
   let release;
   try {
@@ -17954,6 +17955,7 @@ async function currentBranch(deps) {
   return clean2(await deps.run("git", ["rev-parse", "--abbrev-ref", "HEAD"])) || "(unknown)";
 }
 async function restoreCheckoutAfterRelease(deps, startBranch) {
+  deps.warn?.("Release: Returning to the working branch");
   const status = await deps.run("git", ["status", "--porcelain"]);
   if (porcelainHasBlockingChanges(status)) {
     return {
@@ -18194,6 +18196,7 @@ async function correlateWorkflowRun(deps, args) {
 }
 async function watchTenantRun(deps, runId, repo = HUB_REPO2) {
   if (runId == null) return "pending";
+  deps.warn?.("Release: Waiting for deployment or publishing to finish");
   let watchSaidSuccess = true;
   const startedAt = Date.now();
   deps.warn?.(`watching workflow run ${runId} (${repo})`);
@@ -18304,6 +18307,7 @@ function parsePrNumber(url) {
   return Number.isFinite(n) ? n : void 0;
 }
 async function rollDevelopmentForward(deps, ctx, tag) {
+  deps.warn?.("Release: Bringing development up to date");
   await runGitRemoteRead(deps, ["fetch", "origin", "main", "development"]);
   const required = await discoverRequiredCheckContexts(deps, ctx, "development");
   if (required.length === 0) {
@@ -18368,6 +18372,7 @@ var ALIGNMENT_LAND_POLL_MS = 15e3;
 var ALIGNMENT_LAND_TIMEOUT_MS = 20 * 6e4;
 async function awaitAlignmentLanded(deps, ctx, leg, base, opts = {}) {
   if (leg.status !== "pr-pending" || !leg.autoMergeEnqueued || leg.prNumber === void 0) return leg;
+  deps.warn?.(`Release: Waiting for ${base} alignment to finish`);
   const sleep2 = resolveSleep(deps);
   const now = deps.now ?? Date.now;
   const startedAt = now();
@@ -18409,6 +18414,7 @@ async function awaitAlignmentLanded(deps, ctx, leg, base, opts = {}) {
   }
 }
 async function alignRcForward(deps, ctx, tag) {
+  deps.warn?.("Release: Bringing the release candidate up to date");
   await runGitRemoteRead(deps, ["fetch", "origin", "main", "rc"]);
   const required = await discoverRequiredCheckContexts(deps, ctx, "rc");
   if (required.length === 0) {
@@ -18471,6 +18477,7 @@ async function waitForRequiredTrainChecks(deps, ctx, sha, required, freshSince)
   if (required.length === 0) {
     return "no required status checks configured on the target branch \u2014 check wait skipped (GitHub push gate is the backstop)";
   }
+  deps.warn?.("Release: Waiting for required checks");
   let fleetNote = "";
   let fleetPosted;
   if (required.includes(FLEET_LOCKSTEP_CONTEXT)) {
@@ -18764,6 +18771,7 @@ async function reconcilePublishFailure(deps, runId) {
   return "failure";
 }
 async function dispatchTenantPublish(deps, ctx, stage, ref, watch, dispatchFailure = "throw", publishDir) {
+  deps.warn?.("Release: Starting package publishing");
   const since = (deps.now ?? Date.now)();
   const dispatchArgs = [
     "workflow",
@@ -18989,6 +18997,7 @@ async function discoverShaWorkflowRuns(deps, repo, headSha, seenRunIds) {
 }
 async function dispatchDeploy(deps, ctx, stage, ref, model, watch, autoRunSince, autoRunHeadSha, dispatchFailure = "throw", publishDir) {
   if (isCentralDispatchModel(model)) {
+    deps.warn?.("Release: Starting deployment");
     const since = (deps.now ?? Date.now)();
     try {
       await dispatchTenantDeployWithRetry(deps, { repo: ctx.repo, slug: ctx.slug, ref, stage });
@@ -19018,6 +19027,7 @@ async function dispatchDeploy(deps, ctx, stage, ref, model, watch, autoRunSince,
   if (model === "registry-publish") {
     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" };
+    deps.warn?.("Release: Checking package publishing progress");
     if (!watch) {
       const listed = await listOwnWorkflowRuns(deps, ctx.repo, prodReleaseTargets(model), autoRunHeadSha);
       return { note, workflowRuns: listed, deployStatus: aggregateWorkflowRuns(listed) };
@@ -19037,6 +19047,7 @@ async function dispatchDeploy(deps, ctx, stage, ref, model, watch, autoRunSince,
   if (model === "hub-serverless") {
     const note = ref === "rc" ? "no manual dispatch: deploy.yml auto-fires on the rc push (rc stage)" : "no manual dispatch: deploy.yml + publish.yml auto-fire on the published Release (prod)";
     if (!autoRunHeadSha) return { note, deployStatus: "pending" };
+    deps.warn?.("Release: Checking deployment and publishing progress");
     if (!watch) {
       if (ref === "rc") return { note, deployStatus: "pending" };
       const listed = await listOwnWorkflowRuns(deps, HUB_REPO2, prodReleaseTargets(model), autoRunHeadSha);
@@ -22261,6 +22272,7 @@ function enforceGateBudget(deps, repo) {
   }
 }
 async function preflight(deps, ctx, stage, meta, lane) {
+  deps.warn?.("Release: Checking release prerequisites");
   const model = requireDeployModel(meta, ctx.repo);
   if (model === "content") {
     throw new Error(`${ctx.repo} is a content repo (deployModel=content) \u2014 the release train does not apply (trunk-based; PR to main)`);
@@ -22287,6 +22299,7 @@ async function preflightMergeToMain(deps, deployModel, remoteRef, blockingPrefix
   return { foldPaths, tolerated, predicted };
 }
 async function executeMergeToMain(deps, sourceRef, mergeLabel, tolerated, predicted, preFold) {
+  deps.warn?.("Release: Preparing the release version");
   await deps.run("git", ["checkout", "main"]);
   await ffOnlyPull(deps, "main");
   preFold.mainSha = clean2(await deps.run("git", ["rev-parse", "main"]));
@@ -22808,6 +22821,7 @@ async function completeMainRelease(deps, ctx, meta, deployModel, watch, options,
   const resumeCommand = options.dev ? "mmi-cli devops release --dev --apply" : "mmi-cli devops release --apply";
   const ledgerAnchors = { repo: ctx.repo, tag, tagSha: releaseSha };
   try {
+    deps.warn?.("Release: Checking the package before publishing");
     await verifyPublishDryRun(deps, ctx, meta, deployModel);
   } catch (e) {
     throw await recoverFailedFold(deps, e, startBranch, preFold.mainSha, resumeCommand);
@@ -22849,6 +22863,7 @@ async function completeMainRelease(deps, ctx, meta, deployModel, watch, options,
       }
       tagLedgerStarted = true;
     }
+    deps.warn?.("Release: Publishing the release tag");
     tagPush = await ensureTagPushed(deps, tag, releaseSha, tagProbe, ctx.repo);
   } catch (e) {
     if (ledger && tagLedgerStarted) {
@@ -22899,12 +22914,14 @@ ${recovery.note}`), recoveryInput);
   });
   if (trueMergeGateNote) checks = `${trueMergeGateNote}; ${checks}`;
   try {
+    deps.warn?.("Release: Promoting the verified release");
     await runGitPush(deps, ["push", "origin", "main"]);
   } catch (e) {
     await recordPhase(ledger, deps, ledgerAnchors, "promotion", phaseEntry({ state: "failed", sha: releaseSha, error: `origin/main push failed after ${tag} was pushed: ${e instanceof Error ? e.message : String(e)}` }), { landed: "the immutable tag pushed at " + releaseSha.slice(0, 12) });
     throw partialTrainRecoveryError(e, recoveryInput);
   }
   await recordPhase(ledger, deps, ledgerAnchors, "promotion", phaseEntry({ state: "complete", sha: releaseSha, note: `immutable ${tag} pushed at ${releaseSha.slice(0, 12)}; origin/main fast-forwarded to it` }), { landed: "the immutable tag and the green required-check wall" });
+  deps.warn?.("Release: Creating the release announcement");
   const releaseUrl = clean2(await deps.run("gh", ["release", "create", tag, "--target", "main", "--generate-notes", "--latest", "--repo", ctx.repo])) || void 0;
   await verifyPublishedRelease(deps, ctx.repo, tag, "main", releaseSha);
   await recordPhase(ledger, deps, ledgerAnchors, "githubRelease", phaseEntry({ state: "complete", sha: releaseSha, runUrl: releaseUrl, note: `verified GitHub Release ${tag} against ${releaseSha.slice(0, 12)}` }), { landed: "the immutable tag, the green required-check wall, and the origin/main fast-forward" });
@@ -23239,6 +23256,7 @@ Nothing was written. Inspect ${ledger.path} (or clear it only after proving the
     steps2.push(`development alignment: ${devRollForward2.status}`);
     const rcAlignment2 = !directTrack && branchHints.hasRcBranch ? await alignRcForward(deps, ctx, tag) : void 0;
     if (rcAlignment2) steps2.push(`rc alignment: ${rcAlignment2.status}`);
+    deps.warn?.("Release: Checking deployment and publishing progress");
     const historicalTargets = prodReleaseTargets(deployModel);
     const historicalRepo = releaseRunRepoFor(deployModel, ctx.repo);
     let historicalRows = historicalTargets.length ? await listOwnWorkflowRuns(deps, historicalRepo, historicalTargets, tagSha) : [];
@@ -23341,9 +23359,11 @@ ${recovery.note}`), recoveryInput);
     }
   }
   await recordPhase(ledger, deps, anchors, "ordinaryCi", phaseEntry({ state: "complete", sha: tagSha, note: "re-verified the required-check wall live on this resume" }), { strict: ledgerMode === "strict", landed: "the immutable tag on origin at the resumed SHA" });
+  deps.warn?.("Release: Promoting the verified release");
   await runGitPush(deps, ["push", "origin", `${tagSha}:refs/heads/main`]);
   steps.push(`pushed ${tagSha.slice(0, 12)} to origin/main`);
   await recordPhase(ledger, deps, anchors, "promotion", phaseEntry({ state: "complete", sha: tagSha, note: `resumed: ${tagSha.slice(0, 12)} pushed to origin/main (tag preserved, never re-cut)` }), { strict: ledgerMode === "strict", landed: "the immutable tag and the re-proven required-check wall" });
+  deps.warn?.("Release: Creating the release announcement");
   const releaseUrl = clean2(await deps.run("gh", ["release", "create", tag, "--target", "main", "--generate-notes", "--latest", "--repo", ctx.repo])) || void 0;
   steps.push(`created the GitHub Release for ${tag}`);
   await verifyPublishedRelease(deps, ctx.repo, tag, "main", tagSha);
@@ -44049,6 +44069,36 @@ function registerTrainCommands(program3, trainDeps) {
   });
 }
 
+// src/release-progress.ts
+async function withReleaseProgress(deps, initial, action) {
+  let phase = initial;
+  let startedAt = Date.now();
+  const progressDeps = {
+    ...deps,
+    warn(message2) {
+      if (message2.startsWith("Release: ")) {
+        phase = message2.slice("Release: ".length);
+        startedAt = Date.now();
+      }
+      deps.warn?.(message2);
+    }
+  };
+  progressDeps.warn(`Release: ${initial}`);
+  const heartbeat = setInterval(() => {
+    const seconds = Math.floor((Date.now() - startedAt) / 1e3);
+    deps.warn?.(`Release: ${phase} \u2014 ${seconds}s elapsed`);
+  }, 3e4);
+  heartbeat.unref();
+  try {
+    return await action(progressDeps);
+  } finally {
+    clearInterval(heartbeat);
+  }
+}
+function releaseProgressVerdict(status) {
+  return status === "complete" ? "Release complete" : status === "failed" ? "Release failed \u2014 a follow-up needs attention" : "Release pending \u2014 waiting for unfinished follow-ups";
+}
+
 // src/command-register-train-operations.ts
 var INVOKED_ARGV2 = process.argv.slice(2);
 var isWin3 = process.platform === "win32";
@@ -44226,6 +44276,9 @@ function renderReleaseResume(r) {
   if (r.rcAlignment) lines2.push(`  rc: ${r.rcAlignment.note}`);
   if (r.checkout) lines2.push(`  checkout: ${r.checkout.note}`);
   if (r.projectInfoSync) lines2.push(`  project info: ${r.projectInfoSync.note}`);
+  if (r.releaseVerdict) {
+    lines2.push(`  release verdict: ${r.releaseVerdict.releaseStatus.toUpperCase()} (published); follow-up: ${r.releaseVerdict.followUpStatus.toUpperCase()}`);
+  }
   if (r.ledger) lines2.push(...formatReleaseLedgerReport(r.ledger).map((l, i) => i === 0 ? `  ${l}` : `  ${l}`));
   return lines2.join("\n");
 }
@@ -44268,11 +44321,11 @@ function releaseFollowUpLegs(result, projectInfoSync) {
       status: followUpLegStatus(run.conclusion),
       ...run.conclusion === "failure" ? { error: run.workflow === "jerv-gateway" ? result.dispatch : `${run.workflow} reported failure` } : {}
     })));
-  } else if (result.deployStatus !== "success") {
+  } else if (result.deployStatus && result.deployStatus !== "success") {
     legs.push({
       leg: "deploy",
       status: followUpLegStatus(result.deployStatus),
-      ...result.deployStatus === "failure" ? { error: result.dispatch } : {}
+      ...result.deployStatus === "failure" ? { error: result.dispatch ?? "deploy reported failure" } : {}
     });
   }
   if (result.rcRetirement) {
@@ -44360,6 +44413,37 @@ function buildReleaseVerdict(commandName, result, projectInfoSync) {
     } : void 0
   };
 }
+function buildResumeReleaseVerdict(result, projectInfoSync) {
+  const resumeStatus = resumeFollowUpOf(result.state);
+  const followUpStatus = deriveTrainFollowUpStatus({
+    projectInfo: projectInfoOutcome(projectInfoSync),
+    deploy: "ok",
+    rcRetirement: "ok",
+    alignment: resumeStatus === "failed" ? "failure" : resumeStatus === "pending" ? "unresolved" : "ok",
+    foldPort: "ok"
+  });
+  const legInput = {
+    ...result.dispatch ? {
+      dispatch: result.dispatch.note,
+      deployStatus: result.dispatch.deployStatus,
+      ...result.dispatch.workflowRuns ? { workflowRuns: result.dispatch.workflowRuns } : {}
+    } : {},
+    ...result.devRollForward ? { devRollForward: result.devRollForward } : {},
+    ...result.rcAlignment ? { rcAlignment: result.rcAlignment } : {}
+  };
+  return {
+    followUpStatus,
+    releaseVerdict: {
+      releaseStatus: "succeeded",
+      followUpStatus,
+      promoted: true,
+      tag: result.tag,
+      // Alignment-only carries no Release URL of its own; `null` is the honest absence.
+      releaseUrl: result.releaseUrl ?? null,
+      legs: releaseFollowUpLegs(legInput, projectInfoSync)
+    }
+  };
+}
 function renderTrainApply(commandName, r) {
   let base = `mmi-cli ${commandName}: promoted ${r.repo} \u2014 ${r.stage} at ${r.tag} [${r.deployModel}]; ${renderDeployLine(r)}`;
   if (r.versionFold) base = `${base}; ${r.versionFold}`;
@@ -44541,22 +44625,26 @@ function registerTrainOperationsCommands(program3, runProjectInfoSyncCallback) {
             }));
             return;
           }
-          const raw = await runReleaseResume(trainApplyDeps(), { watch: o.watch, announceSummaryFile: o.announceSummaryFile });
+          const raw = await withReleaseProgress(
+            trainApplyDeps(),
+            "Checking the existing release",
+            (deps) => runReleaseResume(deps, { watch: o.watch, announceSummaryFile: o.announceSummaryFile })
+          );
           const result = raw.dispatch?.workflowRuns ? { ...raw, dispatch: { ...raw.dispatch, workflowRuns: raw.dispatch.workflowRuns.map(workflowRunWithEvidence) } } : raw;
-          const projectInfoSync = await runProjectInfoSyncLeg(runProjectInfoSyncCallback, result.repo);
-          const resumed = { ...result, projectInfoSync };
+          const projectInfoSync = await withReleaseProgress(
+            trainApplyDeps(),
+            "Updating project information",
+            () => runProjectInfoSyncLeg(runProjectInfoSyncCallback, result.repo)
+          );
+          const { followUpStatus, releaseVerdict } = buildResumeReleaseVerdict(result, projectInfoSync);
+          const resumed = { ...result, projectInfoSync, releaseVerdict };
           emitTrainResult("release --resume", o.json ? JSON.stringify(resumed, null, 2) : renderReleaseResume(resumed), o.out);
-          const resumeStatus = resumeFollowUpOf(result.state);
-          applyTrainFollowUpExit(deriveTrainFollowUpStatus({
-            projectInfo: projectInfoOutcome(projectInfoSync),
-            deploy: "ok",
-            rcRetirement: "ok",
-            alignment: resumeStatus === "failed" ? "failure" : resumeStatus === "pending" ? "unresolved" : "ok",
-            foldPort: "ok"
-          }));
+          consoleIo.err(`mmi-cli: Release: ${releaseProgressVerdict(followUpStatus)}`);
+          applyTrainFollowUpExit(followUpStatus);
           return;
         } catch (e) {
           applyTrainFollowUpExit("failed");
+          if (commandName === "release") consoleIo.err("mmi-cli: Release: Release blocked \u2014 see the error below");
           return failGraceful(`${commandName} --resume: ${e.message}`);
         }
       }
@@ -44599,11 +44687,16 @@ function registerTrainOperationsCommands(program3, runProjectInfoSyncCallback) {
       if (o.apply) {
         try {
           const ack = (o.ack ?? "").split(",").map((s) => s.trim()).filter(Boolean);
-          const raw = await runTrainApply(commandName, trainApplyDeps(), { watch: o.watch, announceSummaryFile: o.announceSummaryFile, ack, dev: o.dev });
+          const apply = (deps) => runTrainApply(commandName, deps, { watch: o.watch, announceSummaryFile: o.announceSummaryFile, ack, dev: o.dev });
+          const raw = commandName === "release" ? await withReleaseProgress(trainApplyDeps(), "Preparing release", apply) : await apply(trainApplyDeps());
           const result = raw.workflowRuns ? { ...raw, workflowRuns: raw.workflowRuns.map(workflowRunWithEvidence) } : raw;
           let projectInfoSync;
           if (commandName === "release") {
-            projectInfoSync = await runProjectInfoSyncLeg(runProjectInfoSyncCallback, result.repo);
+            projectInfoSync = await withReleaseProgress(
+              trainApplyDeps(),
+              "Updating project information",
+              () => runProjectInfoSyncLeg(runProjectInfoSyncCallback, result.repo)
+            );
           }
           const { followUpStatus, releaseVerdict } = buildReleaseVerdict(commandName, result, projectInfoSync);
           const reported = {
@@ -44613,10 +44706,12 @@ function registerTrainOperationsCommands(program3, runProjectInfoSyncCallback) {
           };
           const output = o.json ? JSON.stringify(reported, null, 2) : renderTrainApply(commandName, reported);
           emitTrainResult(`${commandName} apply`, output, o.out);
+          if (commandName === "release") consoleIo.err(`mmi-cli: Release: ${releaseProgressVerdict(followUpStatus)}`);
           applyTrainFollowUpExit(followUpStatus);
           return;
         } catch (e) {
           process.exitCode = 1;
+          if (commandName === "release") consoleIo.err("mmi-cli: Release: Release blocked \u2014 see the error below");
           return await failGraceful(`${commandName}: ${e.message}`);
         }
       }

package/package.json

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