@mutmutco/cli 4.5.35 → 4.5.37

package/dist/main.cjs

@@ -863,6 +863,9 @@ var init_house_map = __esm({
 });
 
 // src/stdin-inject.ts
+function setInjectedStdin(payload) {
+  injectedStdin = payload;
+}
 function stdinHasPipedInput(statFd = () => (0, import_node_fs4.fstatSync)(0), getIsTTY = () => process.stdin.isTTY) {
   try {
     const stat4 = statFd();
@@ -922,6 +925,34 @@ var init_stdin_inject = __esm({
 });
 
 // src/cli-shared.ts
+var cli_shared_exports = {};
+__export(cli_shared_exports, {
+  DEFAULT_EXEC_TIMEOUT_MS: () => DEFAULT_EXEC_TIMEOUT_MS,
+  ExecDeadlineError: () => ExecDeadlineError,
+  GIT_TIMEOUT_MS: () => GIT_TIMEOUT_MS,
+  consoleIo: () => consoleIo,
+  execFileHard: () => execFileHard,
+  execFileP: () => execFileP,
+  fail: () => fail,
+  failGraceful: () => failGraceful,
+  failGracefulEnvelope: () => failGracefulEnvelope,
+  gitOut: () => gitOut,
+  githubLogin: () => githubLogin,
+  hubHeaders: () => hubHeaders,
+  installBrokenPipeGuard: () => installBrokenPipeGuard,
+  installProcessBackstop: () => installProcessBackstop,
+  isOrgRepoRoot: () => isOrgRepoRoot,
+  jsonParity: () => jsonParity,
+  loadConfig: () => loadConfig,
+  mutating: () => mutating,
+  planMutation: () => planMutation,
+  printLine: () => printLine,
+  rawFlag: () => rawFlag,
+  rawValue: () => rawValue,
+  readStdin: () => readStdin,
+  repoProject: () => repoProject,
+  setInjectedStdin: () => setInjectedStdin
+});
 function killProcessTree(pid) {
   try {
     if (process.platform === "win32") {
@@ -7295,11 +7326,11 @@ function decorateAwsModel(entries, registry2, verdicts) {
   });
 }
 var DECLARED_ENTRIES = [
-  { name: "mmi-backup (mm-central, mm-work, mmi-oguz; zuber unverified)", cadence: "17 2 * * *", executor: "box cron.d", llm: "no", resolved: "declared", source: "/etc/cron.d/mmi-backup \u2192 /opt/mmi-control/nightly-backup.sh; every Docker volume is tarred and every running Postgres container is pg_dumpall'd beside it (#7147; source scripts/nightly-backup.sh); zuber (46.225.58.31) absent from box inventory and its SSH host key changed on 2026-09-24 \u2014 unverified, not dropped (verify: mmi-cli devops runtime box get <box> --ssh)" },
+  { name: "mmi-backup (mm-central, mm-work, mmi-oguz)", cadence: "17 2 * * *", executor: "box cron.d", llm: "no", resolved: "declared", source: "/etc/cron.d/mmi-backup \u2192 /opt/mmi-control/nightly-backup.sh; every Docker volume is tarred and every running Postgres container is pg_dumpall'd beside it (#7147; source scripts/nightly-backup.sh); zuber (46.225.58.31) is gone: deleted 2026-09-18 by the owner-approved ZuberShade decommission (MMC-ZuberShade#1838, snapshot kept); Hetzner has since reassigned that IP to another machine (#7351)" },
   // #7148: a backup nobody restored is a hope. Monthly, restore the latest artifact of every
   // archived stage (including a stage whose containers are down) into scratch Postgres and compare
   // row counts, and read-verify every storage archive against its listing; per-stage PASS/FAIL.
-  { name: "mmi-backup-restore-check (mm-central, mm-work, mmi-oguz; zuber unverified)", cadence: "0 3 1 * *", executor: "box cron.d", llm: "no", resolved: "declared", source: "/etc/cron.d/mmi-backup-restore-check \u2192 /opt/mmi-control/nightly-backup-restore-check.sh; monthly restore proof for every archived stage (#7148; source scripts/nightly-backup-restore-check.sh); zuber (46.225.58.31) absent from box inventory and its SSH host key changed on 2026-09-24 \u2014 unverified, not dropped (verify: mmi-cli devops runtime box get <box> --ssh)" },
+  { name: "mmi-backup-restore-check (mm-central, mm-work, mmi-oguz)", cadence: "0 3 1 * *", executor: "box cron.d", llm: "no", resolved: "declared", source: "/etc/cron.d/mmi-backup-restore-check \u2192 /opt/mmi-control/nightly-backup-restore-check.sh; monthly restore proof for every archived stage (#7148; source scripts/nightly-backup-restore-check.sh); zuber (46.225.58.31) is gone: deleted 2026-09-18 by the owner-approved ZuberShade decommission (MMC-ZuberShade#1838, snapshot kept); Hetzner has since reassigned that IP to another machine (#7351)" },
   // #3370/#6270: the one runner hygiene layer (runner-hygiene.yml was folded in and deleted). A workflow ran ON the runner and needed checkout +
   // setup-node before it can prune, so at 100% it dies at checkout and never prunes — the cleanup is
   // unavailable exactly when it is needed. This one is root cron on the box: no checkout, no node, and
@@ -11654,11 +11685,11 @@ function writeMarketplacePinsOnDisk(path2, pins, succeeded, failedVerb, declineW
         return `could NOT ${failedVerb} ${[...pins.keys()].join(", ")} \u2014 set it by hand`;
       }
       const verify = readKnownMarketplacesFile(path2);
-      const failed = [...pins].filter(([name, want]) => {
+      const failed2 = [...pins].filter(([name, want]) => {
         const got = readKnownMarketplace(verify, name);
         return typeof want.autoUpdate === "boolean" && got.declared !== want.autoUpdate || want.ref !== void 0 && got.ref !== want.ref;
       });
-      return failed.length ? `${failedVerb} did NOT take for ${failed.map(([n]) => n).join(", ")} \u2014 set it by hand` : succeeded(pins);
+      return failed2.length ? `${failedVerb} did NOT take for ${failed2.map(([n]) => n).join(", ")} \u2014 set it by hand` : succeeded(pins);
     });
   } catch (error) {
     if (error instanceof Error && error.message.startsWith("shared-document lock timeout:")) return error.message;
@@ -15715,9 +15746,9 @@ function trainFollowUpExitCode(status) {
 }
 function trainFollowUpNote(status) {
   if (status === "complete") return void 0;
-  return `follow-up ${status}: the exit code is never the verdict, read workflowRuns \u2014 see docs/Guides/train-troubleshooting.md#follow-up-pending`;
+  return `follow-up ${status}: the exit code is never the verdict, read workflowRuns \u2014 see https://github.com/mutmutco/MMI-Hub/blob/development/docs/Guides/train-troubleshooting.md#follow-up-pending`;
 }
-var TRAIN_DEPLOY_FAILED_NOTE = "promotion stands; retry the deploy, do not re-tag \u2014 see docs/Guides/train-troubleshooting.md#deploy-failed";
+var TRAIN_DEPLOY_FAILED_NOTE = "promotion stands; retry the deploy, do not re-tag \u2014 see https://github.com/mutmutco/MMI-Hub/blob/development/docs/Guides/train-troubleshooting.md#deploy-failed";
 function missingRunUrlNote(runId) {
   return runId != null ? `no run URL emitted \u2014 GitHub Actions returned run ${runId} without its URL` : "no run URL emitted \u2014 run absent or unreadable";
 }
@@ -16840,10 +16871,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.5.35",
-    tag: "v4.5.35",
-    commit: "f10f5c65382f",
-    npm: "@mutmutco/cli@4.5.35"
+    version: "4.5.37",
+    tag: "v4.5.37",
+    commit: "75086128c3ba",
+    npm: "@mutmutco/cli@4.5.37"
   },
   exitCriterion: "fleet-n-of-n",
   hubOnlyShortcut: "forbidden",
@@ -16860,14 +16891,14 @@ var rollout_plan_default = {
           repo: "mutmutco/mmi-hub",
           role: "canary",
           schedule: "train",
-          v3Target: "v4.5.35"
+          v3Target: "v4.5.37"
         }
       ],
       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.5.35 and redeploy the Hub Lambda from tag v4.5.35 (f10f5c65382f); installed clients repair via `mmi-cli doctor`. No other cohort is touched.",
-        v3Target: "v4.5.35 (@mutmutco/cli@4.5.35, tag commit f10f5c65382f \u2014 last known-good release carrying the repo-index v4-only contract)"
+        mechanism: "npm dist-tag latest -> 4.5.37 and redeploy the Hub Lambda from tag v4.5.37 (75086128c3ba); installed clients repair via `mmi-cli doctor`. No other cohort is touched.",
+        v3Target: "v4.5.37 (@mutmutco/cli@4.5.37, tag commit 75086128c3ba \u2014 last known-good release carrying the repo-index v4-only contract)"
       }
     },
     {
@@ -19633,9 +19664,9 @@ async function waitForRequiredTrainChecks(deps, ctx, sha, required, freshSince)
     });
     const satisfiedNote = autoSatisfied.size ? `, auto-satisfied (never runs on a tag, see #2404): ${[...autoSatisfied].join(", ")}` : "";
     lastStatus = `${states.map(([c, s]) => `${c}=${s}`).join(", ")}${satisfiedNote}`;
-    const failed = states.filter(([, s]) => s === "failed").map(([c]) => c);
-    if (failed.length > 0) {
-      throw new Error(`required train check failed: ${failed.join(", ")} (${lastStatus}${fleetNote})`);
+    const failed2 = states.filter(([, s]) => s === "failed").map(([c]) => c);
+    if (failed2.length > 0) {
+      throw new Error(`required train check failed: ${failed2.join(", ")} (${lastStatus}${fleetNote})`);
     }
     if (states.every(([, s]) => s === "success")) {
       return `required checks passed: ${pending.join(", ") || "(none pending)"}${satisfiedNote}${fleetNote}`;
@@ -19826,7 +19857,7 @@ function installerDeclarationError(value, division) {
 
 // src/train-suite.ts
 var SUITE_GUARD_CODE = "suite-member-solo";
-var SUITE_GUARD_ANCHOR = `docs/Guides/train-troubleshooting.md#${SUITE_GUARD_CODE}`;
+var SUITE_GUARD_ANCHOR = `https://github.com/mutmutco/MMI-Hub/blob/development/docs/Guides/train-troubleshooting.md#${SUITE_GUARD_CODE}`;
 function suiteLeadRepo(repo, suite) {
   const owner = repo.split("/")[0];
   return `${owner}/${suite === "mm-work" ? "MM-Work" : suite}`;
@@ -19937,9 +19968,9 @@ async function readVercelDeployment(api, repo, sha, target, since) {
   }
   if (newest.size === 0) return void 0;
   const reads = await Promise.all([...newest].map(async ([env, id]) => ({ env, id, ...await readOne(api, repo, id, since) })));
-  const failed = reads.find((r) => FAILED.has(r.state));
+  const failed2 = reads.find((r) => FAILED.has(r.state));
   const unfinished = reads.find((r) => !isTerminalVercelState(r.state));
-  const pick = failed ?? unfinished ?? reads[0];
+  const pick = failed2 ?? unfinished ?? reads[0];
   return {
     id: pick.id,
     environment: reads.map((r) => r.env).join(", "),
@@ -20332,11 +20363,11 @@ async function appendServedChannelProof(deps, input, dispatch) {
   const channel = servedChannelFor(input.repo, input.installer);
   if (!channel) return dispatch;
   const expected = input.tag.replace(/^v/, "");
-  const withProof = (conclusion, evidence, note, failed = false) => ({
+  const withProof = (conclusion, evidence, note, failed2 = false) => ({
     ...dispatch,
     note: `${dispatch.note}; ${note}`,
     workflowRuns: [...dispatch.workflowRuns ?? [], servedChannelRow(channel.product, conclusion, evidence)],
-    ...failed ? { deployStatus: "failure" } : {}
+    ...failed2 ? { deployStatus: "failure" } : {}
   });
   if (!input.shipped) {
     return withProof("pending", `${channel.url} not probed`, `served channel ${channel.url} not probed \u2014 deploy/publish are not proven green, so it is not expected to have moved`);
@@ -20521,7 +20552,7 @@ async function appendJervGatewayReleaseDeploy(deps, repo, tag, tagSha, dispatch)
       ...dispatch,
       // #6095: the helper's receipt, health or rollback failed after a proven publish — the release resumes, never re-tags.
       // #6985: keep the FULL failing output in the note so the ledger can persist its tail (the first-line 240-char clip hid the real cause).
-      note: `${dispatch.note}; Jerv Gateway deploy FAILED (${full}) \u2014 see docs/Guides/train-troubleshooting.md#jerv-gateway-deploy`,
+      note: `${dispatch.note}; Jerv Gateway deploy FAILED (${full}) \u2014 see https://github.com/mutmutco/MMI-Hub/blob/development/docs/Guides/train-troubleshooting.md#jerv-gateway-deploy`,
       workflowRuns: [...dispatch.workflowRuns ?? [], { workflow: "jerv-gateway", runUrlNote: JERV_GATEWAY_RUN_URL_NOTE, conclusion: "failure" }],
       deployStatus: "failure"
     };
@@ -20611,8 +20642,8 @@ function shipLegsGreen(deploy, publish) {
 async function announceShippedRelease(deps, args, model, legs, deferred) {
   if (!deps.announce) return void 0;
   if (trainObservesShipment(model) && !shipLegsGreen(legs.deploy, legs.publish)) {
-    const failed = legs.deploy.state === "failed" || legs.publish.state === "failed";
-    return `not announced: deploy/publish ${failed ? "FAILED" : "not proven green"} \u2014 ${deferred}`;
+    const failed2 = legs.deploy.state === "failed" || legs.publish.state === "failed";
+    return `not announced: deploy/publish ${failed2 ? "FAILED" : "not proven green"} \u2014 ${deferred}`;
   }
   return (await deps.announce(args)).note;
 }
@@ -20742,7 +20773,7 @@ async function dispatchDeploy(deps, ctx, stage, ref, model, watch, autoRunSince,
     const deployStatus = watch ? await watchTenantRun(deps, runId) : "pending";
     let note = `dispatched tenant-deploy.yml (slug=${ctx.slug}, ref=${ref}, stage=${stage})`;
     if (deployStatus === "failure") {
-      note = `${note}; run FAILED \u2014 if its log shows exit 78 \`compose is fileless but DEPLOY#${stage}.noEnvFile is not true\`, set-deploy + reconcile before the redeploy \u2014 see docs/Guides/train-troubleshooting.md#deploy-exit-78-fileless`;
+      note = `${note}; run FAILED \u2014 if its log shows exit 78 \`compose is fileless but DEPLOY#${stage}.noEnvFile is not true\`, set-deploy + reconcile before the redeploy \u2014 see https://github.com/mutmutco/MMI-Hub/blob/development/docs/Guides/train-troubleshooting.md#deploy-exit-78-fileless`;
     }
     return { note, runId, runUrl, deployStatus };
   }
@@ -21057,7 +21088,7 @@ function isCanaryAccessBlockText(text) {
 }
 function actionsCanaryUndispatchedRefusal(detail) {
   return new Error(
-    `release refused: the hosted-job canary (#5604) was not dispatched, so a hosted job start is UNPROVEN \u2014 this is NOT a billing verdict. ${detail} The Hub dispatches ${CANARY_WORKFLOW} with its App token for a train-authorized caller (#6319): refresh the Hub session (\`gh auth login\`) and retry, and confirm \`mmi-cli oracle org access role <owner/repo>\` reports train authority. Nothing was tagged or pushed \u2014 see docs/Guides/train-troubleshooting.md#actions-job-start-canary`
+    `release refused: the hosted-job canary (#5604) was not dispatched, so a hosted job start is UNPROVEN \u2014 this is NOT a billing verdict. ${detail} The Hub dispatches ${CANARY_WORKFLOW} with its App token for a train-authorized caller (#6319): refresh the Hub session (\`gh auth login\`) and retry, and confirm \`mmi-cli oracle org access role <owner/repo>\` reports train authority. Nothing was tagged or pushed \u2014 see https://github.com/mutmutco/MMI-Hub/blob/development/docs/Guides/train-troubleshooting.md#actions-job-start-canary`
   );
 }
 function actionsBillingRefusal(detail) {
@@ -21221,11 +21252,11 @@ async function assertActionsJobsCanStart(deps, targetRepo2) {
       return;
     }
     if (last === "billing-blocked" || last === "never-started") {
-      throw actionsBillingRefusal(`${url}: hosted canary ${last} \u2014 see docs/Guides/train-troubleshooting.md#actions-job-start-canary`);
+      throw actionsBillingRefusal(`${url}: hosted canary ${last} \u2014 see https://github.com/mutmutco/MMI-Hub/blob/development/docs/Guides/train-troubleshooting.md#actions-job-start-canary`);
     }
   }
   throw actionsBillingRefusal(
-    `${url}: hosted canary stayed ${last} after ${CANARY_POLLS} polls \u2014 cannot prove a hosted job can start \u2014 see docs/Guides/train-troubleshooting.md#actions-job-start-canary`
+    `${url}: hosted canary stayed ${last} after ${CANARY_POLLS} polls \u2014 cannot prove a hosted job can start \u2014 see https://github.com/mutmutco/MMI-Hub/blob/development/docs/Guides/train-troubleshooting.md#actions-job-start-canary`
   );
 }
 
@@ -23378,8 +23409,8 @@ function ledgerFailedRemedy(ledger) {
   const openLegs = derived.legs.filter((l) => l.state === "pending" || l.state === "failed");
   const tails = formatFailedLegTails(ledger);
   if (hotfixRetryDeployShape(ledger)) {
-    const failed = openLegs.filter((l) => l.state === "failed").map((l) => l.phase);
-    return `the published ${ledger.tag} hotfix can retry the failed ${joinLegNames(failed)} of the same tag: \`mmi-cli devops hotfix release ${ledger.tag} --retry-deploy\` (the deploy helper is idempotent; alignment re-attempts the fold-port PR) (#6985)${tails}`;
+    const failed2 = openLegs.filter((l) => l.state === "failed").map((l) => l.phase);
+    return `the published ${ledger.tag} hotfix can retry the failed ${joinLegNames(failed2)} of the same tag: \`mmi-cli devops hotfix release ${ledger.tag} --retry-deploy\` (the deploy helper is idempotent; alignment re-attempts the fold-port PR) (#6985)${tails}`;
   }
   if (rcandRetryDeployShape(ledger)) {
     return `fix the rc deploy failure, then retry the failed deploy of the promoted ${ledger.tag} candidate (same tag and SHA, never re-cut): \`mmi-cli devops rcand --retry-deploy --watch\` (#7053)${tails}`;
@@ -23547,8 +23578,8 @@ async function supersedeContentCausedDeployLeg(deps, cwd) {
         `release --supersede-deploy: origin reports ${prior.tag} at ${liveSha.slice(0, 12) || "no tag"} but the ledger anchors ${prior.tagSha.slice(0, 12)} \u2014 an absent or divergent release is NOT supersedeable (release --abort --apply is the unpublished candidate's own exit); nothing was written (#6553)`
       );
     }
-    const failed = prior.phases.deploy.state === "failed";
-    const note = failed ? `superseded: content-caused deploy failure on the immutable promoted ${prior.tag} \u2014 the cause fix rides the next patch train (master-approved closure, #6553)` : `superseded: ${prior.tag} deploy outcome uncorrelatable from the release SHA (no failure recorded) \u2014 closed on the owner's evidence (master-approved closure, #6553, #7327)`;
+    const failed2 = prior.phases.deploy.state === "failed";
+    const note = failed2 ? `superseded: content-caused deploy failure on the immutable promoted ${prior.tag} \u2014 the cause fix rides the next patch train (master-approved closure, #6553)` : `superseded: ${prior.tag} deploy outcome uncorrelatable from the release SHA (no failure recorded) \u2014 closed on the owner's evidence (master-approved closure, #6553, #7327)`;
     await fence(() => atomicWriteJson(path2, {
       ...prior,
       phases: {
@@ -23562,7 +23593,7 @@ async function supersedeContentCausedDeployLeg(deps, cwd) {
       repo: prior.repo,
       tag: prior.tag,
       tagSha: prior.tagSha,
-      note: failed ? `closed the ${prior.tag} deploy leg as superseded (skipped) \u2014 the ledger is phases-green; rerun the train doctor to confirm, then run the next patch train (hotfix or release) to carry the cause fix` : `closed the ${prior.tag} uncorrelatable deploy leg as superseded (skipped) \u2014 the ledger is phases-green; rerun the train doctor to confirm`
+      note: failed2 ? `closed the ${prior.tag} deploy leg as superseded (skipped) \u2014 the ledger is phases-green; rerun the train doctor to confirm, then run the next patch train (hotfix or release) to carry the cause fix` : `closed the ${prior.tag} uncorrelatable deploy leg as superseded (skipped) \u2014 the ledger is phases-green; rerun the train doctor to confirm`
     };
   });
 }
@@ -23641,7 +23672,7 @@ async function supersedeContentCausedPublishLeg(deps, cwd) {
     }
     let gatewayDeploy;
     const deferredGateway = isJervHubRepo(prior.repo) && deferredGatewayDeployLegShape(phases.deploy);
-    const unresolved = ["promotion", "ordinaryCi", "githubRelease", "deploy", "alignment"].filter((phase) => !(phase === "deploy" && deferredGateway)).filter((phase) => phases[phase].state === "pending" || phases[phase].state === "failed");
+    const unresolved = ["promotion", "ordinaryCi", "githubRelease", "deploy", "alignment"].filter((phase) => !(phase === "deploy" && deferredGateway)).filter((phase) => !(phase === "alignment" && phases.alignment.state === "pending")).filter((phase) => phases[phase].state === "pending" || phases[phase].state === "failed");
     if (unresolved.length > 0) {
       throw new Error(
         `release --supersede-publish: ${prior.tag} has unresolved legs besides publish (${unresolved.map((p) => `${p}=${phases[p].state}`).join(", ")}) \u2014 the supersession closes only the publish leg of an otherwise-complete release; resolve those first, nothing was written (#6638)`
@@ -23689,7 +23720,7 @@ async function supersedeContentCausedPublishLeg(deps, cwd) {
       repo: prior.repo,
       tag: prior.tag,
       tagSha: prior.tagSha,
-      note: `closed the ${prior.tag} publish leg as superseded (skipped) \u2014 the ledger is phases-green; rerun the train doctor to confirm, then run the next patch train (hotfix or release) to carry the cause fix`,
+      note: `closed the ${prior.tag} publish leg as superseded (skipped) \u2014 the ledger is phases-green; rerun the train doctor to confirm, then run the next patch train (hotfix or release) to carry the cause fix${phases.alignment.state === "pending" ? "; alignment still pending (fold-port PR open \u2014 closes live at the next pre-flight, #6061)" : ""}`,
       ...gatewayDeploy ? { gatewayDeploy } : {}
     };
   });
@@ -24537,17 +24568,17 @@ async function runTrainDoctor(input) {
       if (derived.phaseStatus !== "phases-green") {
         const openLegs = derived.legs.filter((l) => l.state === "pending" || l.state === "failed");
         const open2 = openLegs.map((l) => `${l.phase}=${l.state}`).join(", ");
-        const failed = derived.phaseStatus === "phases-failed";
+        const failed2 = derived.phaseStatus === "phases-failed";
         const deployOnlyDeadlock = openLegs.length > 0 && openLegs.every((l) => l.phase === "deploy" && supersedeableDeployLegShape(l));
         const supersession = deployOnlyDeadlock ? `; when the deploy failure is content-caused on the already-published ${ledger.tag} (the immutable tag can never deploy green), the sanctioned exit is \`mmi-cli devops release --supersede-deploy --apply\` after explicit master approval \u2014 the next patch train carries the cause fix (#6553)` : "";
         add({
-          code: failed ? "ledger-failed" : "ledger-pending",
+          code: failed2 ? "ledger-failed" : "ledger-pending",
           severity: "blocker",
           source: "local",
           // #6429: each lane finishes its own run (#6068) — an rcand-lane ledger named as a release
           // ledger, with `release --resume` as its remedy, sends the operator to a verb that refuses it.
           title: `a prior ${ledger.lane ?? "release"} ledger for ${ledger.tag} is ${derived.phaseStatus} (${open2}) \u2014 a new train must not stack on it (#5987)`,
-          remedy: failed ? ledgerFailedRemedy(ledger) : `finish it first: ${ledgerLaneResumeCommand(ledger)} (alignment-only pending legs close themselves with \`train doctor --heal\` once the PR merges, and a deploy/publish leg whose run already concluded folds under the same heal)${supersession}`
+          remedy: failed2 ? ledgerFailedRemedy(ledger) : `finish it first: ${ledgerLaneResumeCommand(ledger)} (alignment-only pending legs close themselves with \`train doctor --heal\` once the PR merges, and a deploy/publish leg whose run already concluded folds under the same heal)${supersession}`
         });
       } else if (newestRemoteReleaseTag && newestRemoteReleaseTag !== ledger.tag) {
         add({
@@ -24594,21 +24625,21 @@ regenerate the projections (\`node scripts/check-skill-payload.mjs\`) and commit
         const installed = [];
         let pending = firstDir;
         let outstanding = failure;
-        let failed = null;
+        let failed2 = null;
         while (pending && !installed.includes(pending)) {
           const dir = pending;
           try {
             await train.run("npm", ["--prefix", dir, "ci"]);
           } catch (e) {
-            failed = { dir, detail: `\`npm --prefix ${dir} ci\` failed: ${message(e)}` };
+            failed2 = { dir, detail: `\`npm --prefix ${dir} ci\` failed: ${message(e)}` };
             break;
           }
           installed.push(dir);
           outstanding = await verifyDeps();
           pending = outstanding ? /in (cli|updater)\/node_modules/u.exec(outstanding)?.[1] ?? null : null;
         }
-        if (failed) {
-          add({ code: "hub-build-deps", severity: "blocker", source: "local", title: failed.detail, remedy: `repair ${failed.dir}/node_modules by hand, then rerun` });
+        if (failed2) {
+          add({ code: "hub-build-deps", severity: "blocker", source: "local", title: failed2.detail, remedy: `repair ${failed2.dir}/node_modules by hand, then rerun` });
         } else if (outstanding) {
           add({ code: "hub-build-deps", severity: "blocker", source: "local", title: `installing ${installed.join(", ")} from ${installed.length === 1 ? "its lockfile" : "their lockfiles"} did not resolve the build dependencies`, remedy: outstanding });
         } else {
@@ -24709,6 +24740,133 @@ function formatTrainDoctor(v) {
   return lines2.join("\n");
 }
 
+// src/vercel-version-env.ts
+var SKIPPED = { status: "skipped", note: "" };
+function vercelVersionEnvAheadNote(key) {
+  return `a failed branch push can leave ${key} ahead of what is live`;
+}
+function safeReason(reason, token) {
+  const compact = reason.replace(/\s+/g, " ").trim().slice(0, 180);
+  const scrubbed = token && compact.includes(token) ? compact.split(token).join("[redacted]") : compact;
+  return scrubbed || "unknown error";
+}
+function failed(deps, key, tag, reason) {
+  const note = `vercel version env: FAILED to set ${key}=${tag} (${reason}) \u2014 /healthz will show the commit, not the tag; fix: set it and redeploy once`;
+  deps.warn?.(note);
+  return { status: "failed", note };
+}
+function targetLabel(stage) {
+  return stage === "main" ? "production" : "preview";
+}
+function envCollectionUrl(project2, team, extra) {
+  const url = new URL(`https://api.vercel.com/v10/projects/${encodeURIComponent(project2)}/env`);
+  if (team) url.searchParams.set("teamId", team);
+  for (const [key, value] of Object.entries(extra ?? {})) url.searchParams.set(key, value);
+  return url.toString();
+}
+function envItemUrl(project2, id, team) {
+  const url = new URL(`https://api.vercel.com/v9/projects/${encodeURIComponent(project2)}/env/${encodeURIComponent(id)}`);
+  if (team) url.searchParams.set("teamId", team);
+  return url.toString();
+}
+function isStageEnv(row, stage, key) {
+  if (row.key !== key) return false;
+  const target = Array.isArray(row.target) ? row.target.filter((item) => typeof item === "string") : [];
+  if (stage === "main") return target.length === 1 && target[0] === "production";
+  return target.length === 1 && target[0] === "preview" && row.gitBranch === "rc";
+}
+function envsOf(body) {
+  if (Array.isArray(body)) return body;
+  if (body && typeof body === "object" && Array.isArray(body.envs)) {
+    return body.envs;
+  }
+  return null;
+}
+async function readBody(res, token) {
+  let raw = "";
+  try {
+    raw = await res.text();
+  } catch (e) {
+    return { ok: false, reason: safeReason(e instanceof Error ? e.message : String(e), token) };
+  }
+  if (!res.ok) return { ok: false, reason: `HTTP ${res.status}${raw ? `: ${safeReason(raw, token)}` : ""}` };
+  if (!raw.trim()) return { ok: true, body: {} };
+  try {
+    return { ok: true, body: JSON.parse(raw) };
+  } catch {
+    return { ok: false, reason: "response was not JSON" };
+  }
+}
+async function setVercelVersionEnv(deps, meta, stage, tag) {
+  if (meta?.deployModel !== "vercel" || !meta.vercelVersionEnv) return SKIPPED;
+  const { project: project2, key, team } = meta.vercelVersionEnv;
+  if (!project2 || !key) return failed(deps, key || "(missing key)", tag, "vercelVersionEnv is missing project or key");
+  let token;
+  try {
+    token = await deps.readToken();
+  } catch (e) {
+    return failed(deps, key, tag, safeReason(e instanceof Error ? e.message : String(e), null));
+  }
+  if (!token) return failed(deps, key, tag, "no _org/vercel/API_TOKEN");
+  const headers = { Authorization: `Bearer ${token}`, "Content-Type": "application/json" };
+  let listed;
+  try {
+    const res = await deps.fetch(envCollectionUrl(project2, team, stage === "rc" ? { gitBranch: "rc" } : void 0), { method: "GET", headers });
+    listed = await readBody(res, token);
+  } catch (e) {
+    return failed(deps, key, tag, safeReason(e instanceof Error ? e.message : String(e), token));
+  }
+  if (!listed.ok) return failed(deps, key, tag, listed.reason);
+  const rows = envsOf(listed.body);
+  if (!rows) return failed(deps, key, tag, "env list returned an unexpected shape");
+  const existing = rows.find((row) => isStageEnv(row, stage, key) && typeof row.id === "string" && row.id.length > 0);
+  const createBody = stage === "main" ? { key, value: tag, type: "plain", target: ["production"] } : { key, value: tag, type: "plain", target: ["preview"], gitBranch: "rc" };
+  try {
+    const res = existing ? await deps.fetch(envItemUrl(project2, existing.id, team), {
+      method: "PATCH",
+      headers,
+      body: JSON.stringify({ value: tag })
+    }) : await deps.fetch(envCollectionUrl(project2, team), {
+      method: "POST",
+      headers,
+      body: JSON.stringify(createBody)
+    });
+    const written = await readBody(res, token);
+    if (!written.ok) return failed(deps, key, tag, written.reason);
+  } catch (e) {
+    return failed(deps, key, tag, safeReason(e instanceof Error ? e.message : String(e), token));
+  }
+  const note = `vercel version env: ${key}=${tag} set on ${targetLabel(stage)}`;
+  deps.warn?.(note);
+  return { status: "set", note };
+}
+async function defaultVercelFetch(url, init) {
+  const res = await fetch(url, { ...init, signal: AbortSignal.timeout(15e3) });
+  return { ok: res.ok, status: res.status, text: () => res.text() };
+}
+async function readOrgVercelApiToken() {
+  const { loadConfig: loadConfig2, hubHeaders: hubHeaders2, repoProject: repoProject2 } = await Promise.resolve().then(() => (init_cli_shared(), cli_shared_exports));
+  const cfg = await loadConfig2();
+  if (!cfg.sagaApiUrl) return null;
+  const repo = `mutmutco/${(await repoProject2(cfg)).toLowerCase()}`;
+  const res = await fetch(`${cfg.sagaApiUrl}/secrets/get`, {
+    method: "POST",
+    headers: await hubHeaders2({ "content-type": "application/json" }),
+    body: JSON.stringify({ repo, key: "vercel/API_TOKEN", use: true, slug: "_org" }),
+    signal: AbortSignal.timeout(8e3)
+  });
+  if (!res.ok) return null;
+  const body = await res.json();
+  return typeof body.value === "string" ? body.value : null;
+}
+function vercelVersionEnvDeps(deps) {
+  return {
+    fetch: deps.vercelFetch ?? defaultVercelFetch,
+    readToken: deps.readVercelApiToken ?? readOrgVercelApiToken,
+    warn: (message2) => deps.warn?.(message2)
+  };
+}
+
 // src/train-apply-phases.ts
 var TRAIN_BUMP_INTENTS = ["major", "minor", "patch"];
 function readLocalGateWorkflows() {
@@ -24793,7 +24951,7 @@ async function preflightMergeToMain(deps, deployModel, remoteRef, blockingPrefix
   const predicted = await predictMergeConflicts(deps, ours, remoteRef);
   const predictedBlocking = predicted.filter((f) => !pathIsTolerated(f, tolerated));
   if (predictedBlocking.length > 0) {
-    throw new Error(`${blockingPrefix}: ${predictedBlocking.join(", ")} \u2014 no merge was started. ${realignMessage} \u2014 see docs/Guides/train-troubleshooting.md#merge-conflict`);
+    throw new Error(`${blockingPrefix}: ${predictedBlocking.join(", ")} \u2014 no merge was started. ${realignMessage} \u2014 see https://github.com/mutmutco/MMI-Hub/blob/development/docs/Guides/train-troubleshooting.md#merge-conflict`);
   }
   return { foldPaths, tolerated, predicted };
 }
@@ -25022,7 +25180,7 @@ async function recoverFailedFold(deps, cause, startBranch, preFoldMainSha, resum
   const causeMessage = anchor ? `${rawCause} \u2014 see ${anchor}` : rawCause;
   const probe = await probeFoldFailureState(deps);
   if (probe.mergeInProgress) {
-    const conflictCause = `${rawCause} \u2014 see docs/Guides/train-troubleshooting.md#merge-conflict`;
+    const conflictCause = `${rawCause} \u2014 see https://github.com/mutmutco/MMI-Hub/blob/development/docs/Guides/train-troubleshooting.md#merge-conflict`;
     try {
       await deps.run("git", ["merge", "--abort"]);
     } catch (e) {
@@ -25313,14 +25471,14 @@ async function recoverFailedDispatchPhase(deps, ledger, anchors, phase, dispatch
   let fallbackRecovered = false;
   const failedRows = workflowRuns?.filter((run) => run.conclusion === "failure") ?? [];
   if (failedRows.length > 0) {
-    for (const failed of failedRows) {
-      const rowPhase = failed.workflow.includes("publish") ? "publish" : phase;
+    for (const failed2 of failedRows) {
+      const rowPhase = failed2.workflow.includes("publish") ? "publish" : phase;
       if (persisted?.phases[rowPhase]?.superseded === true) continue;
       const recovery = await recover(deps, ledger, anchors, rowPhase, {
         repo: input.repo,
         sha: input.sha,
-        failure: `watched ${rowPhase} run failed: ${failed.workflow} (${dispatch.note})`,
-        runs: [{ ...failed, repo: input.repo }],
+        failure: `watched ${rowPhase} run failed: ${failed2.workflow} (${dispatch.note})`,
+        runs: [{ ...failed2, repo: input.repo }],
         watched: input.watched
       });
       if (recovery.note) notes.push(recovery.note);
@@ -25386,6 +25544,27 @@ async function recordRcandDeployLegs(ledger, deps, anchors, deployModel, d, opts
 function releaseAnnounceDeferral(model, summaryFile) {
   return prodReleaseTargets(model).length > 0 || model === "vercel" ? `\`mmi-cli devops release --resume --watch${summaryFile ? ` --announce-summary-file ${summaryFile}` : ""}\` announces it once they are green` : "a central deploy is proven only under --watch, so this release stays unannounced";
 }
+function annotateVersionEnvDispatch(dispatch, result) {
+  if (!result.note) return dispatch;
+  return { ...dispatch, note: `${dispatch.note}; ${result.note}` };
+}
+function annotateVersionEnvAnnounce(note, result) {
+  if (!result.note) return note;
+  return note ? `${note}; ${result.note}` : result.note;
+}
+async function pushAfterVercelVersionEnv(deps, meta, stage, tag, pushArgs) {
+  const result = await setVercelVersionEnv(vercelVersionEnvDeps(deps), meta, stage, tag);
+  try {
+    await runGitPush(deps, pushArgs);
+  } catch (e) {
+    const base = e instanceof Error ? e.message : String(e);
+    const parts = [base];
+    if (result.note) parts.push(result.note);
+    if (result.status === "set" && meta.vercelVersionEnv?.key) parts.push(vercelVersionEnvAheadNote(meta.vercelVersionEnv.key));
+    throw new Error(parts.join(" \u2014 "));
+  }
+  return result;
+}
 async function completeMainRelease(deps, ctx, meta, deployModel, watch, options, tag, releaseSha, startBranch, preFold, tagProbe, branchHints, ledger, alignEarly) {
   const resumeCommand = options.dev ? "mmi-cli devops release --dev --apply" : "mmi-cli devops release --apply";
   const ledgerAnchors = { repo: ctx.repo, tag, tagSha: releaseSha };
@@ -25482,9 +25661,10 @@ ${recovery.note}`), recoveryInput);
     landed: "the immutable tag pushed at " + releaseSha.slice(0, 12)
   });
   if (trueMergeGateNote) checks = `${trueMergeGateNote}; ${checks}`;
+  let versionEnv = { status: "skipped", note: "" };
   try {
     deps.warn?.("Release: Promoting the verified release");
-    await runGitPush(deps, ["push", "origin", "main"]);
+    versionEnv = await pushAfterVercelVersionEnv(deps, meta, "main", tag, ["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);
@@ -25517,7 +25697,7 @@ ${recovery.note}`), recoveryInput);
       workflow: failedReleaseRun?.workflow ?? (isCentralDispatchModel(deployModel) ? "tenant-deploy.yml" : "deploy workflow")
     }
   );
-  const deployDispatch = await appendJervGatewayReleaseDeploy(deps, ctx.repo, tag, releaseSha, recoveredDeployDispatch);
+  const deployDispatch = annotateVersionEnvDispatch(await appendJervGatewayReleaseDeploy(deps, ctx.repo, tag, releaseSha, recoveredDeployDispatch), versionEnv);
   const deployLeg = phaseEntry(validSuiteCutContext(ctx.repo, deps.suiteCut) && ctx.slug !== "mmi-katip" ? { state: "skipped", sha: releaseSha, note: "suite bundle-only: live backend not deployed (#7263)" } : deployPhaseInput(deployModel, deployDispatch, { releaseSha }));
   await recordPhase(ledger, deps, ledgerAnchors, "deploy", deployLeg, {
     landed: "the immutable tag, the green required-check wall, the origin/main fast-forward, and the verified GitHub Release"
@@ -25551,7 +25731,7 @@ ${recovery.note}`), recoveryInput);
     appendPublishDispatch(deployDispatch, publishDispatch)
   );
   alignment = await aligning;
-  const announceNote = await announcing;
+  const announceNote = annotateVersionEnvAnnounce(await announcing, versionEnv);
   return { checks, releaseUrl, announceNote, dispatch, ledgerAnchors, ...alignment ? { alignment } : {} };
 }
 function resumeStateOf(status) {
@@ -25754,10 +25934,10 @@ ${spent.note}`);
   await recordPhase(ledger, deps, anchors, "ordinaryCi", phaseEntry({ state: "complete", sha: tagSha, note: "re-verified the required-check wall live on this resume" }), { strict, landed: "the immutable rc tag on origin at the resumed SHA" });
   const autoRunSince = (deps.now ?? Date.now)();
   deps.warn?.("Release: Promoting the verified release candidate");
-  await runGitPush(deps, ["push", "origin", `${tagSha}:refs/heads/rc`]);
+  const versionEnv = await pushAfterVercelVersionEnv(deps, meta, "rc", tag, ["push", "origin", `${tagSha}:refs/heads/rc`]);
   await recordPhase(ledger, deps, anchors, "promotion", phaseEntry({ state: "complete", sha: tagSha, note: `resumed: ${tagSha.slice(0, 12)} pushed to origin/rc (tag preserved, never re-cut)` }), { strict, landed: "the immutable rc tag and the re-proven required-check wall" });
   await recordPhase(ledger, deps, anchors, "githubRelease", phaseEntry({ state: "skipped", sha: tagSha, note: "rcand mints no GitHub Release \u2014 the rc tag is the candidate" }), { strict, landed: "the immutable rc tag, the green wall, and origin/rc" });
-  const dispatch0 = await dispatchDeploy(deps, ctx, "rc", "rc", deployModel, watch, autoRunSince, tagSha, "report");
+  const dispatch0 = annotateVersionEnvDispatch(await dispatchDeploy(deps, ctx, "rc", "rc", deployModel, watch, autoRunSince, tagSha, "report"), versionEnv);
   const dispatch = await recordRcandDeployLegs(ledger, deps, anchors, deployModel, dispatch0, { strict });
   const ledgerReport = releaseLedgerReport(await ledger.load(anchors).catch(() => void 0), ledger.path);
   return {
@@ -26037,7 +26217,7 @@ ${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`]);
+  const versionEnv = await pushAfterVercelVersionEnv(deps, meta, "main", tag, ["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 GitHub Release");
@@ -26067,7 +26247,7 @@ ${recovery.note}`), recoveryInput);
       workflow: isCentralDispatchModel(deployModel) ? "tenant-deploy.yml" : "deploy workflow"
     }
   );
-  const deployDispatch = await appendJervGatewayReleaseDeploy(deps, ctx.repo, tag, tagSha, recoveredDeployDispatch);
+  const deployDispatch = annotateVersionEnvDispatch(await appendJervGatewayReleaseDeploy(deps, ctx.repo, tag, tagSha, recoveredDeployDispatch), versionEnv);
   steps.push(`dispatched the ${deployModel} deploy path`);
   const deployLeg = persisted?.phases.deploy.superseded === true ? persisted.phases.deploy : phaseEntry(validSuiteCutContext(ctx.repo, deps.suiteCut) && ctx.slug !== "mmi-katip" ? { state: "skipped", sha: tagSha, note: "suite bundle-only: live backend not deployed (#7263)" } : deployPhaseInput(deployModel, deployDispatch, { releaseSha: tagSha }));
   if (persisted?.phases.deploy.superseded !== true) {
@@ -26108,7 +26288,7 @@ ${recovery.note}`), recoveryInput);
     devRollForward = landed.dev;
     rcAlignment = landed.rc;
   }
-  const announceNote = await announcing;
+  const announceNote = annotateVersionEnvAnnounce(await announcing, versionEnv);
   steps.push(`development roll-forward: ${devRollForward.status}`);
   if (rcAlignment) steps.push(`rc alignment: ${rcAlignment.status}`);
   const followUp = deriveTrainFollowUpStatus({
@@ -26448,15 +26628,16 @@ ${spent.note}`), rcandRecovery(tag2));
     await recordPhase(ledger, deps, anchors, "ordinaryCi", phaseEntry({ state: "complete", sha: rcSha, note: checks2 }), { landed: "the immutable rc tag pushed at " + rcSha.slice(0, 12) });
     const autoRunSince = (deps.now ?? Date.now)();
     deps.warn?.("Release: Promoting the verified release candidate");
+    let versionEnv = { status: "skipped", note: "" };
     try {
-      await runGitPush(deps, ["push", "origin", "rc"]);
+      versionEnv = await pushAfterVercelVersionEnv(deps, meta, "rc", tag2, ["push", "origin", "rc"]);
     } catch (e) {
       await recordPhase(ledger, deps, anchors, "promotion", phaseEntry({ state: "failed", sha: rcSha, error: `origin/rc push failed after ${tag2} was pushed: ${e instanceof Error ? e.message : String(e)}` }), { landed: "the immutable rc tag pushed at " + rcSha.slice(0, 12) });
       throw partialTrainRecoveryError(e, rcandRecovery(tag2));
     }
     await recordPhase(ledger, deps, anchors, "promotion", phaseEntry({ state: "complete", sha: rcSha, note: `immutable ${tag2} pushed at ${rcSha.slice(0, 12)}; origin/rc fast-forwarded to it` }), { landed: "the immutable rc tag and the green required-check wall" });
     await recordPhase(ledger, deps, anchors, "githubRelease", phaseEntry({ state: "skipped", sha: rcSha, note: "rcand mints no GitHub Release \u2014 the rc tag is the candidate" }), { landed: "the immutable rc tag, the green wall, and origin/rc" });
-    const d0 = await dispatchDeploy(deps, ctx, "rc", "rc", deployModel2, watch, autoRunSince, rcSha, "report");
+    const d0 = annotateVersionEnvDispatch(await dispatchDeploy(deps, ctx, "rc", "rc", deployModel2, watch, autoRunSince, rcSha, "report"), versionEnv);
     const d2 = await recordRcandDeployLegs(ledger, deps, anchors, deployModel2, d0);
     const rcLedgerReport = releaseLedgerReport(await ledger?.load(anchors).catch(() => void 0), ledger?.path ?? "(no ledger)");
     return { ...ctx, command, stage: "rc", ref: "rc", tag: tag2, bumpIntent, deployModel: deployModel2, promoted: true, checks: checks2, resumeNote, dispatch: d2.note, runId: d2.runId, runUrl: d2.runUrl, workflowRuns: d2.workflowRuns, deployStatus: d2.deployStatus, ...rcLedgerReport ? { ledger: rcLedgerReport } : {} };
@@ -26593,7 +26774,7 @@ ${spent.note}`), rcandRecovery(tag2));
   if (!coverage.ok) {
     const list = coverage.uncovered.map((c) => `${c.sha.slice(0, 8)} ${c.subject}`).join("; ");
     throw new Error(
-      `hotfix-coverage: ${coverage.uncovered.length} main-only commit(s) not proven in origin/rc \u2014 the candidate would revert a prod hotfix: ${list}. Re-cut /rcand from development, or have the authorized human verify the content is in the candidate and rerun release with --ack <sha>[,<sha>\u2026] \u2014 see docs/Guides/train-troubleshooting.md#hotfix-coverage`
+      `hotfix-coverage: ${coverage.uncovered.length} main-only commit(s) not proven in origin/rc \u2014 the candidate would revert a prod hotfix: ${list}. Re-cut /rcand from development, or have the authorized human verify the content is in the candidate and rerun release with --ack <sha>[,<sha>\u2026] \u2014 see https://github.com/mutmutco/MMI-Hub/blob/development/docs/Guides/train-troubleshooting.md#hotfix-coverage`
       // #6095: the guard names its lesson
     );
   }
@@ -26673,7 +26854,7 @@ async function resolveTrainBumpIntent(deps, env = process.env, latestRelease) {
   const explicitIntent = (env.MMI_BUMP_INTENT ?? "").trim();
   if (explicitIntent) {
     if (!TRAIN_BUMP_INTENTS.includes(explicitIntent)) {
-      throw new Error("MMI_BUMP_INTENT must be one of major|minor|patch \u2014 see docs/Guides/train-troubleshooting.md#bump-intent-invalid");
+      throw new Error("MMI_BUMP_INTENT must be one of major|minor|patch \u2014 see https://github.com/mutmutco/MMI-Hub/blob/development/docs/Guides/train-troubleshooting.md#bump-intent-invalid");
     }
     return explicitIntent;
   }
@@ -26718,12 +26899,12 @@ async function resolveHotfixVersion(deps, env = process.env) {
   }
   const nonPatch = declared.find((d) => d.intent !== "patch");
   if (nonPatch) {
-    throw new Error(`hotfix is PATCH-only \u2014 ${nonPatch.name}=${nonPatch.value} declares a ${nonPatch.intent} bump over ${baseTag}; unset it (or run the release train for a ${nonPatch.intent} release) \u2014 see docs/Guides/train-troubleshooting.md#bump-intent-invalid`);
+    throw new Error(`hotfix is PATCH-only \u2014 ${nonPatch.name}=${nonPatch.value} declares a ${nonPatch.intent} bump over ${baseTag}; unset it (or run the release train for a ${nonPatch.intent} release) \u2014 see https://github.com/mutmutco/MMI-Hub/blob/development/docs/Guides/train-troubleshooting.md#bump-intent-invalid`);
   }
   const explicit = explicitVersion.replace(/^v/, "");
   const nextPatch = `${latest.major}.${latest.minor}.${latest.patch + 1}`;
   if (explicitIntent && explicit && explicit !== nextPatch) {
-    throw new Error(`hotfix version declarations conflict \u2014 MMI_BUMP_INTENT=patch targets ${nextPatch} from ${baseTag}, but MMI_RELEASE_VERSION=${explicitVersion} targets ${explicit}; set one declaration or make both target ${nextPatch} \u2014 see docs/Guides/train-troubleshooting.md#bump-intent-invalid`);
+    throw new Error(`hotfix version declarations conflict \u2014 MMI_BUMP_INTENT=patch targets ${nextPatch} from ${baseTag}, but MMI_RELEASE_VERSION=${explicitVersion} targets ${explicit}; set one declaration or make both target ${nextPatch} \u2014 see https://github.com/mutmutco/MMI-Hub/blob/development/docs/Guides/train-troubleshooting.md#bump-intent-invalid`);
   }
   const version = explicit || nextPatch;
   return { tag: `v${version}`, version, baseTag };
@@ -28643,13 +28824,13 @@ function buildPluginCachePlan(home, running, deps, opts = {}) {
 }
 function applyPluginCachePlan(plan, remove2, stagingGuard) {
   const removed = [];
-  const failed = [];
+  const failed2 = [];
   for (const version of plan.prune) {
     try {
       remove2(`${plan.cacheRoot}/${version}`);
       removed.push(version);
     } catch (e) {
-      failed.push({ version, error: e.message });
+      failed2.push({ version, error: e.message });
     }
   }
   const removedStaging = [];
@@ -28682,7 +28863,7 @@ function applyPluginCachePlan(plan, remove2, stagingGuard) {
   }
   return {
     removed,
-    failed,
+    failed: failed2,
     bytes: plan.bytes,
     removedStaging,
     failedStaging,
@@ -29694,7 +29875,7 @@ init_hub_auth();
 init_github_client();
 
 // src/project-set.ts
-var UNSET_KEYS = ["projectAdmins", "installer", "oauth", "requiredRuntimeSecrets", "requiredBuildSecrets", "tenantTasks", "secrets", "edgeDomains", "requiredGcpApis", "publishRequired", "publishDir", "releaseChannel", "releaseLanguage", "dsManifestPath", "consumesDesignSystem", "ci", "requiredChecks", "requiredCheckBranches", "ciExemptReason", "gate", "seedCanary"];
+var UNSET_KEYS = ["projectAdmins", "installer", "oauth", "requiredRuntimeSecrets", "requiredBuildSecrets", "tenantTasks", "secrets", "edgeDomains", "requiredGcpApis", "publishRequired", "publishDir", "releaseChannel", "releaseLanguage", "dsManifestPath", "consumesDesignSystem", "ci", "requiredChecks", "requiredCheckBranches", "ciExemptReason", "gate", "seedCanary", "notifyOnDeploy", "vercelVersionEnv"];
 var UNSET_KEY_SET = new Set(UNSET_KEYS);
 var RUNTIME_SECRET_STAGES = ["dev", "rc", "main"];
 var SECRET_CONSUMERS = ["runtime", "build", "lambda", "actions", "agent", "box"];
@@ -30033,6 +30214,47 @@ function parseRequiredCheckBranchesVar(raw) {
   }
   return REQUIRED_CHECK_BRANCHES.filter((branch) => parsed.includes(branch));
 }
+function parseNotifyOnDeployVar(raw) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new Error('org project set: notifyOnDeploy must be a JSON array, e.g. ["dev"]');
+  }
+  if (!Array.isArray(parsed) || parsed.some((s) => s !== "dev" && s !== "rc" && s !== "main")) {
+    throw new Error('org project set: notifyOnDeploy must be a JSON array of stages: dev, rc, main (e.g. ["dev"])');
+  }
+  if (new Set(parsed).size !== parsed.length) {
+    throw new Error("org project set: notifyOnDeploy must not contain duplicate stages");
+  }
+  return parsed;
+}
+var VERCEL_VERSION_ENV_NAME_RE = /^[A-Za-z][A-Za-z0-9_]*$/;
+var VERCEL_VERSION_ENV_ID_RE = /^[A-Za-z0-9][A-Za-z0-9._-]{0,99}$/;
+function parseVercelVersionEnvVar(raw) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new Error('org project set: vercelVersionEnv must be JSON, e.g. {"project":"mm-work","key":"MMW_VERSION","team":"team_xxx"}');
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error("org project set: vercelVersionEnv must be a JSON object { project, key, team? }");
+  }
+  const row = parsed;
+  const unknown = Object.keys(row).filter((key) => key !== "project" && key !== "key" && key !== "team");
+  if (unknown.length > 0) throw new Error(`org project set: vercelVersionEnv has unknown field(s): ${unknown.join(", ")}`);
+  if (typeof row.project !== "string" || !VERCEL_VERSION_ENV_ID_RE.test(row.project)) {
+    throw new Error("org project set: vercelVersionEnv.project must be a Vercel project id or name");
+  }
+  if (typeof row.key !== "string" || !VERCEL_VERSION_ENV_NAME_RE.test(row.key)) {
+    throw new Error("org project set: vercelVersionEnv.key must be an env name (e.g. MMW_VERSION)");
+  }
+  if (row.team !== void 0 && (typeof row.team !== "string" || !VERCEL_VERSION_ENV_ID_RE.test(row.team))) {
+    throw new Error("org project set: vercelVersionEnv.team must be a Vercel team id or slug");
+  }
+  return { project: row.project, key: row.key, ...typeof row.team === "string" ? { team: row.team } : {} };
+}
 function parseCiExemptReasonVar(raw) {
   const trimmed = raw.trim();
   if (!trimmed) throw new Error("org project set: ciExemptReason must be a non-empty reason (or use --unset ciExemptReason to clear it)");
@@ -30173,7 +30395,9 @@ var SETTABLE_VAR_KEYS = [
   "gate",
   "secrets",
   "seedCanary",
-  "installer"
+  "installer",
+  "notifyOnDeploy",
+  "vercelVersionEnv"
 ];
 var SETTABLE_VAR_KEY_SET = new Set(SETTABLE_VAR_KEYS);
 var SETTABLE_VAR_HINTS = {
@@ -30202,6 +30426,8 @@ var SETTABLE_VAR_HINTS = {
   ci: "none \u2014 declare intentional no-ci",
   requiredChecks: 'JSON array, e.g. ["gate"] or [] for no-ci',
   requiredCheckBranches: "non-empty JSON branch-name array; exact product-ruleset scope (#5210)",
+  notifyOnDeploy: 'JSON stage array, e.g. ["dev"] \u2014 successful tenant-deploy sends <stage>-deployed to the project repo (#7358)',
+  vercelVersionEnv: "JSON {project,key,team?} \u2014 train sets this Vercel env to the release tag before the main/rc push (#7362)",
   ciExemptReason: "non-empty string \u2014 declares this deployable repo has no CI surface (#4265)",
   gate: "JSON {runtime,cmd,affectedCmd,workdir,cacheDepPath,pyVersion}"
 };
@@ -30345,6 +30571,10 @@ function buildProjectSetPatch(input) {
       patch[key] = parseRequiredChecksVar(raw);
     } else if (key === "requiredCheckBranches") {
       patch[key] = parseRequiredCheckBranchesVar(raw);
+    } else if (key === "notifyOnDeploy") {
+      patch[key] = parseNotifyOnDeployVar(raw);
+    } else if (key === "vercelVersionEnv") {
+      patch[key] = parseVercelVersionEnvVar(raw);
     } else if (key === "ciExemptReason") {
       patch[key] = parseCiExemptReasonVar(raw);
     } else if (key === "gate") {
@@ -30389,6 +30619,8 @@ var DEPLOY_SHELL_SAFE_RE = /^[A-Za-z0-9./:_?&=%-]*$/;
 var DEPLOY_ROLE_ARN_RE = /^arn:aws:iam::\d{12}:role\/[A-Za-z0-9+=,.@_/-]{1,128}$/;
 var DEPLOY_BUCKET_RE = /^[a-z0-9][a-z0-9.-]{1,61}[a-z0-9]$/;
 var DEPLOY_DISTRIBUTION_ID_RE = /^[A-Z0-9]{5,32}$/;
+var COMPOSE_PROFILE_RE = /^[a-z0-9][a-z0-9_-]{0,62}$/;
+var MAX_COMPOSE_PROFILES = 8;
 function buildSetDeployPatch(_slug, input) {
   const clean4 = (v) => typeof v === "string" && v.trim() !== "" ? v.trim() : void 0;
   const stage = clean4(input.stage);
@@ -30432,6 +30664,23 @@ function buildSetDeployPatch(_slug, input) {
   if (input.noEnvFile !== void 0 && typeof input.noEnvFile !== "boolean") {
     throw new Error("org project set-deploy: --no-env-file must be true or false");
   }
+  if (input.clearComposeProfiles && (input.composeProfiles?.length ?? 0) > 0) {
+    throw new Error("org project set-deploy: --clear-compose-profiles cannot be combined with --compose-profiles (they contradict)");
+  }
+  let composeProfiles;
+  if (input.clearComposeProfiles) {
+    composeProfiles = [];
+  } else if (input.composeProfiles !== void 0) {
+    const names = input.composeProfiles.map((p) => typeof p === "string" ? p.trim() : "");
+    if (names.length > MAX_COMPOSE_PROFILES) throw new Error(`org project set-deploy: --compose-profiles carries at most ${MAX_COMPOSE_PROFILES} profiles`);
+    const seen = /* @__PURE__ */ new Set();
+    for (const name of names) {
+      if (!COMPOSE_PROFILE_RE.test(name)) throw new Error(`org project set-deploy: --compose-profiles must be comma-separated profile names ([a-z0-9_-], up to 63 chars), got ${JSON.stringify(name)}`);
+      if (seen.has(name)) throw new Error(`org project set-deploy: --compose-profiles carries a duplicate profile ${JSON.stringify(name)}`);
+      seen.add(name);
+    }
+    composeProfiles = [...seen];
+  }
   return {
     stage,
     ...substrate !== void 0 ? { substrate } : {},
@@ -30448,7 +30697,10 @@ function buildSetDeployPatch(_slug, input) {
     // #2986: an explicit `[]` is what the route reads as "clear them"; omitting the key is what it reads as
     // "keep them". Those are different instructions and they now have different flags.
     ...input.clearAliases ? { aliases: [] } : uniqueAliases.length ? { aliases: uniqueAliases } : {},
-    ...input.noEnvFile !== void 0 ? { noEnvFile: input.noEnvFile } : {}
+    ...input.noEnvFile !== void 0 ? { noEnvFile: input.noEnvFile } : {},
+    // #7353: an explicit `[]` is what the route reads as "clear them"; omitting the key is what it reads as
+    // "keep them" — same patch contract as aliases (#2986/#2984).
+    ...composeProfiles !== void 0 ? { composeProfiles } : {}
   };
 }
 var DEPLOY_STAGE_BRANCH = { dev: "development", rc: "rc", main: "main" };
@@ -34422,6 +34674,22 @@ async function suiteRcand(deps, opts) {
     Object.assign(member, { carried: true }, await carriedPins(deps, member, modules.find((m) => m.repo === member.repo).bundles));
     writeSuiteCut(deps.recordPath, record);
   }
+  const refusals = [];
+  for (const member of record.members) {
+    if (member.carried || member.published || member.id === "katip") continue;
+    try {
+      await deps.preflight(member.repo);
+    } catch (e) {
+      refusals.push(`${member.repo}: ${e.message}`);
+    }
+  }
+  if (refusals.length) {
+    const untouched = record.members.every((m) => !m.tag) && !record.pinPr;
+    if (untouched) (0, import_node_fs29.rmSync)(deps.recordPath, { force: true });
+    throw new Error(`module rc serving is not ready; ${untouched ? "no suite cut started" : "no new tag was cut"}:
+${refusals.join("\n")}
+Each module must ship a live release that bind-mounts <deployPath>/data read-only and serves <data>/rc/module.js at /rc/module.js (docs/Guides/suite-trains.md).`);
+  }
   for (const member of record.members) {
     if ((await deps.head(member.repo, "development"))?.toLowerCase() !== member.development.toLowerCase())
       throw new Error(`${member.repo}: development moved after the cut snapshot; refuse to add untested code`);
@@ -34631,7 +34899,7 @@ function announceSummaryFidelity(lines2, rangeLog) {
   if (shipped.size === 0) return null;
   const invented = [...new Set(lines2.flatMap((l) => l.match(/#\d+/g) ?? []))].filter((ref) => !shipped.has(ref));
   if (invented.length === 0) return null;
-  return `--announce-summary-file cites ${invented.join(", ")}, which ship in no commit of this release range \u2014 a summary line must describe work that actually shipped. Rebuild the summary from \`git log origin/main..HEAD\` (read commit BODIES too: a bundled PR closes issues its subject never names), then rerun the same release command \u2014 see docs/Guides/train-troubleshooting.md#announce-summary-missing`;
+  return `--announce-summary-file cites ${invented.join(", ")}, which ship in no commit of this release range \u2014 a summary line must describe work that actually shipped. Rebuild the summary from \`git log origin/main..HEAD\` (read commit BODIES too: a bundled PR closes issues its subject never names), then rerun the same release command \u2014 see https://github.com/mutmutco/MMI-Hub/blob/development/docs/Guides/train-troubleshooting.md#announce-summary-missing`;
 }
 async function resolveAnnounceTarget(deps, repo) {
   if (repo.toLowerCase() === ANNOUNCE_REPO.toLowerCase()) return { kind: "alerts" };
@@ -34709,6 +34977,12 @@ function normalizeHotfixVersion(input) {
   return { tag: `v${m[1]}`, version: m[1] };
 }
 var deriveHotfixVersion = resolveHotfixVersion;
+function bumpHotfixPatchVersion(version) {
+  const m = /^(\d+)\.(\d+)\.(\d+)$/.exec(version.trim());
+  if (!m) throw new Error(`cannot bump non-X.Y.Z hotfix version "${version}"`);
+  const next = `${m[1]}.${m[2]}.${Number(m[3]) + 1}`;
+  return { tag: `v${next}`, version: next };
+}
 function hotfixBranch(tag) {
   return `hotfix/${tag}`;
 }
@@ -34762,7 +35036,7 @@ function formatHotfixBatchPreflightRefusal(failures, fromSpecs) {
   const batchFrom = fromSpecs.join(",");
   return `hotfix start batch preflight refused: ${failures.length} pick(s) would hard-stop on origin/main:
 ${lines2.join("\n")}
-Land ONE development-based cite-only synthesis PR for the whole batch (#4643 supersedes the old cut-from-origin/main wording, which produced main-lineage PRs into development \u2014 the shape portFoldToDevelopment forbids, #4365/#4371): cut the branch FROM origin/development, regenerate the listed conflict content so it cherry-picks cleanly onto current origin/main, and land that development-parented PR with the cite-only marker (the proven #5096 flow), then rerun \`mmi-cli devops hotfix start --from ${batchFrom}\` with the port merge SHA(s) \u2014 never hand-resolve onto main; never a main-parented branch into development; never N serial ports (#3167) \u2014 see docs/Guides/train-troubleshooting.md#hotfix-pick-refused`;
+Land ONE development-based cite-only synthesis PR for the whole batch (#4643 supersedes the old cut-from-origin/main wording, which produced main-lineage PRs into development \u2014 the shape portFoldToDevelopment forbids, #4365/#4371): cut the branch FROM origin/development, regenerate the listed conflict content so it cherry-picks cleanly onto current origin/main, and land that development-parented PR with the cite-only marker (the proven #5096 flow), then rerun \`mmi-cli devops hotfix start --from ${batchFrom}\` with the port merge SHA(s) \u2014 never hand-resolve onto main; never a main-parented branch into development; never N serial ports (#3167) \u2014 see https://github.com/mutmutco/MMI-Hub/blob/development/docs/Guides/train-troubleshooting.md#hotfix-pick-refused`;
 }
 var CHERRY_PICKED_FROM = /\(cherry picked from commit ([0-9a-f]{7,40})\)/g;
 async function findHotfixPickGaps(deps, sources, tolerated) {
@@ -34791,32 +35065,44 @@ ${lines2.join("\n")}
 A hotfix branch is cut from origin/main and carries ONLY the fixes --from names, in order (#4411) \u2014 every other merged development fix stays unshipped while the channel reports healthy (#6994). Add each omitted fix to the pick list and rerun \`mmi-cli devops hotfix start --from ${[...fromSpecs, ...gaps.map((g) => g.sha.slice(0, 7))].join(",")}\`, or, when a listed fix is provably not needed on main (a development-only change, already superseded), rerun with \`--ack ${gaps.map((g) => g.sha.slice(0, 7)).join(",")}\` naming exactly the sha(s) a human excluded \u2014 the ack is recorded in the PR body, never silent.`;
 }
 async function preflightHotfixBatchPicks(deps, sources, pickTolerated) {
-  if (sources.length === 0) return [];
-  const startBranch = clean3(await deps.run("git", ["rev-parse", "--abbrev-ref", "HEAD"]));
-  const preflightBranch = `__mmi_hotfix_preflight_${Date.now()}`;
+  if (sources.length === 0) return { failures: [], skipped: [] };
+  const { mkdtemp: mkdtemp2, rm: rm2 } = await import("node:fs/promises");
+  const { tmpdir: tmpdir10 } = await import("node:os");
+  const { join: join44 } = await import("node:path");
+  const dir = await mkdtemp2(join44(tmpdir10(), "mmi-hotfix-preflight-"));
+  const wt = { run: (file, args) => deps.run(file, file === "git" ? ["-C", dir, ...args] : args) };
   const failures = [];
+  const skipped = [];
   try {
-    await deps.run("git", ["checkout", "-B", preflightBranch, "origin/main"]);
-    for (const source of sources) {
-      try {
-        await cherryPickWithToleratedPaths(deps, source.sha, pickTolerated);
-      } catch (e) {
-        const message2 = e.message ?? String(e);
-        const blocking = parseCherryPickBlockingPaths(message2);
-        failures.push({
-          label: source.label,
-          sha: source.sha,
-          blocking: blocking.length > 0 ? blocking : [message2.split("\n")[0] ?? message2]
-        });
+    await deps.run("git", ["worktree", "add", "--detach", dir, "origin/main"]);
+    try {
+      for (const source of sources) {
+        const before = await wt.run("git", ["status", "--porcelain"]);
+        try {
+          await cherryPickWithToleratedPaths(wt, source.sha, pickTolerated);
+        } catch (e) {
+          const message2 = e.message ?? String(e);
+          const after = await wt.run("git", ["status", "--porcelain"]).catch(() => null);
+          if (after !== null && after === before && /empty|nothing to commit/i.test(message2)) {
+            await wt.run("git", ["cherry-pick", "--quit"]).catch(() => void 0);
+            skipped.push({ sha: source.sha, label: source.label });
+            continue;
+          }
+          const blocking = parseCherryPickBlockingPaths(message2);
+          failures.push({
+            label: source.label,
+            sha: source.sha,
+            blocking: blocking.length > 0 ? blocking : [message2.split("\n")[0] ?? message2]
+          });
+        }
       }
+    } finally {
+      await deps.run("git", ["worktree", "remove", "--force", dir]).catch(() => void 0);
     }
   } finally {
-    if (startBranch && startBranch !== "HEAD") {
-      await deps.run("git", ["checkout", startBranch]).catch(() => void 0);
-    }
-    await deps.run("git", ["branch", "-D", preflightBranch]).catch(() => void 0);
+    await rm2(dir, { recursive: true, force: true }).catch(() => void 0);
   }
-  return failures;
+  return { failures, skipped };
 }
 async function restoreAfterFailedPort(deps, opts) {
   const { startBranch, branch, created } = opts;
@@ -34939,10 +35225,20 @@ async function runHotfixStartLocked(deps, options, doctor) {
     throw new Error(`working tree must be clean before hotfix start${describeBlockingPaths(status)}`);
   }
   await deps.run("git", ["fetch", "origin", "--tags"]);
-  const { deployModel } = await hotfixPreflight(deps, ctx, "start");
-  const { tag, version } = await resolveHotfixVersion(deps);
+  const { deployModel, meta } = await hotfixPreflight(deps, ctx, "start");
+  const bumpNotes = [];
+  let resolved = await resolveHotfixVersion(deps);
+  for (; ; ) {
+    const priorPr = await findHotfixPr(deps, ctx, resolved.tag);
+    if ((priorPr?.state ?? "").toUpperCase() !== "MERGED") break;
+    const priorReleased = await hotfixReleaseExists(deps, ctx, resolved.tag);
+    const next = bumpHotfixPatchVersion(resolved.version);
+    bumpNotes.push(`hotfix ${resolved.tag} is already merged on origin/main (PR #${priorPr?.number}, ${priorReleased ? "released" : "unreleased"}) \u2014 origin/main already carries its fold, so this cycle mints ${next.tag} instead of reusing an already-bumped version (#7338)`);
+    resolved = next;
+  }
+  const { tag, version } = resolved;
   const branch = hotfixBranch(tag);
-  const notes = [];
+  const notes = [...bumpNotes];
   const existingPr = await findHotfixPr(deps, ctx, tag);
   const existingState = (existingPr?.state ?? "").toUpperCase();
   const releaseExists = existingState === "MERGED" ? await hotfixReleaseExists(deps, ctx, tag) : false;
@@ -34974,8 +35270,8 @@ async function runHotfixStartLocked(deps, options, doctor) {
   if (specs.length === 0) throw new Error("hotfix start: --from named no PR or SHA");
   const sources = [];
   for (const spec of specs) {
-    const resolved = await resolveHotfixSource(deps, ctx, spec);
-    if (!sources.some((s) => s.sha === resolved.sha)) sources.push(resolved);
+    const resolved2 = await resolveHotfixSource(deps, ctx, spec);
+    if (!sources.some((s) => s.sha === resolved2.sha)) sources.push(resolved2);
   }
   const label = sources.map((s) => s.label).join(", ");
   const { foldPaths, pickTolerated } = await resolveHotfixPickTolerated(deps, deployModel);
@@ -34991,21 +35287,33 @@ async function runHotfixStartLocked(deps, options, doctor) {
   if (pickGaps.length > 0) {
     notes.push(`pick-completeness ack: excluded ${pickGaps.map((g) => `${g.sha.slice(0, 7)} ${g.subject}`).join("; ")} by --ack (#6994)`);
   }
+  let activeSources = sources;
+  let activeLabel = label;
   const remoteBranch = clean3(await deps.run("git", ["ls-remote", "origin", `refs/heads/${branch}`]));
   if (remoteBranch) {
     await deps.run("git", ["checkout", branch]);
     await deps.run("git", ["pull", "--ff-only", "origin", branch]);
     notes.push(`branch ${branch} already on origin \u2014 reused (cherry-pick/bump assumed present; PR step resumes)`);
   } else {
-    const preflightFailures = await preflightHotfixBatchPicks(deps, sources, pickTolerated);
-    if (preflightFailures.length > 0) {
-      throw new Error(formatHotfixBatchPreflightRefusal(preflightFailures, specs));
+    const preflight2 = await preflightHotfixBatchPicks(deps, sources, pickTolerated);
+    if (preflight2.failures.length > 0) {
+      throw new Error(formatHotfixBatchPreflightRefusal(preflight2.failures, specs));
+    }
+    if (preflight2.skipped.length > 0) {
+      const skippedShas = new Set(preflight2.skipped.map((s) => s.sha));
+      const remaining = sources.filter((s) => !skippedShas.has(s.sha));
+      notes.push(`auto-skipped ${preflight2.skipped.length} pick(s) already present on origin/main (empty cherry-pick \u2014 content already shipped there, #7338): ${preflight2.skipped.map((s) => s.label).join(", ")}`);
+      if (remaining.length === 0) {
+        throw new Error(`hotfix start: every named pick is already present on origin/main (${preflight2.skipped.map((s) => s.label).join(", ")}) \u2014 nothing to carry, so no ${branch} branch was cut`);
+      }
+      activeSources = remaining;
+      activeLabel = remaining.map((s) => s.label).join(", ");
     }
     const startBranch = clean3(await deps.run("git", ["rev-parse", "--abbrev-ref", "HEAD"]));
     const preexistingLocal = clean3(await deps.run("git", ["branch", "--list", branch]));
     await deps.run("git", ["checkout", "-B", branch, "origin/main"]);
     try {
-      for (const source of sources) {
+      for (const source of activeSources) {
         const autoResolved = await cherryPickWithToleratedPaths(deps, source.sha, pickTolerated);
         if (autoResolved.length > 0) {
           notes.push(`auto-resolved regenerable cherry-pick conflict(s) for ${source.label}: ${autoResolved.join(", ")} (regenerated in bump step)`);
@@ -35014,12 +35322,12 @@ async function runHotfixStartLocked(deps, options, doctor) {
     } catch (e) {
       const recovery = await restoreAfterFailedPort(deps, { startBranch, branch, created: !preexistingLocal });
       throw new Error(
-        `cherry-pick of ${label} onto ${branch} conflicted \u2014 aborted; nothing was pushed. Land the conflict resolution on development through a normal PR, then rerun \`mmi-cli devops hotfix start --from <that PR's merge sha>\` \u2014 never hand-resolve the port onto main. ${recovery} (${e.message ?? e})`
+        `cherry-pick of ${activeLabel} onto ${branch} conflicted \u2014 aborted; nothing was pushed. Land the conflict resolution on development through a normal PR, then rerun \`mmi-cli devops hotfix start --from <that PR's merge sha>\` \u2014 never hand-resolve the port onto main. ${recovery} (${e.message ?? e})`
       );
     }
-    notes.push(`cherry-picked ${label} onto ${branch} (from origin/main, -x trailer recorded)`);
+    notes.push(`cherry-picked ${activeLabel} onto ${branch} (from origin/main, -x trailer recorded)`);
+    const durableSource = clean3(await deps.run("git", ["merge-base", "HEAD", "origin/main"]));
     if (deployModel === "hub-serverless") {
-      const durableSource = clean3(await deps.run("git", ["merge-base", "HEAD", "origin/main"]));
       await deps.run("node", ["scripts/release-distribution.mjs", "prepare", version, "--source-commit", durableSource]);
       const changedFiles = (await deps.run("node", ["scripts/release-distribution.mjs", "changed-files"])).split("\n").map((s) => s.trim()).filter(Boolean);
       await deps.run("git", ["add", "-f", "--", ...changedFiles]);
@@ -35031,13 +35339,16 @@ async function runHotfixStartLocked(deps, options, doctor) {
         notes.push("distribution prepare produced no changes \u2014 nothing extra committed");
       }
     } else if (foldPaths.length > 0) {
-      const foldNote = await foldReleaseVersion(deps, deployModel, tag, foldPaths);
+      const foldNote = await withFoldSourceCommit(durableSource, () => foldReleaseVersion(deps, deployModel, tag, foldPaths));
       notes.push(foldNote);
     } else {
       notes.push(`version fold skipped (deployModel=${deployModel} carries no version manifest \u2014 the tag is the version)`);
     }
+    await assertHotfixFoldBomStamp(deps, tag);
     await deps.run("git", ["push", "-u", "origin", branch]);
   }
+  const versionEnv = await setVercelVersionEnv(vercelVersionEnvDeps(deps), meta, "main", tag);
+  if (versionEnv.note) notes.push(versionEnv.note);
   const bumpNote = deployModel === "hub-serverless" ? " with the locked distribution bump" : foldPaths.length > 0 ? " with the package version bump" : "";
   const prUrl = clean3(await deps.run("gh", [
     "pr",
@@ -35053,16 +35364,16 @@ async function runHotfixStartLocked(deps, options, doctor) {
     // Every picked sha goes in the marker (#4411) — `hotfix release` reads it when --carries is omitted,
     // so a multi-fix cycle proves ALL of its targets present before tagging, not just the first.
     "--body",
-    `Hotfix ${tag}: cherry-pick of ${label} onto origin/main${bumpNote}.
+    `Hotfix ${tag}: cherry-pick of ${activeLabel} onto origin/main${bumpNote}.
 
-<!-- mmi-hotfix-carries: ${sources.map((s) => s.sha).join(",")} -->${pickGaps.length > 0 ? `
+<!-- mmi-hotfix-carries: ${activeSources.map((s) => s.sha).join(",")} -->${pickGaps.length > 0 ? `
 
 <!-- mmi-hotfix-acked-excluded: ${pickGaps.map((g) => g.sha).join(",")} (#6994 pick-completeness) -->` : ""}
 
 Merge this PR (human-initiated), then run \`mmi-cli devops hotfix release ${tag}\`.`
   ]));
   notes.push(`opened hotfix PR ${prUrl} \u2014 merge it (human-initiated), then: mmi-cli devops hotfix release ${tag}`);
-  return { ...ctx, command: "hotfix-start", tag, version, branch, source: label, prUrl, reused: Boolean(remoteBranch), notes };
+  return { ...ctx, command: "hotfix-start", tag, version, branch, source: activeLabel, prUrl, reused: Boolean(remoteBranch), notes };
 }
 function hotfixWorkflowRunFromDispatch(workflow, dispatch) {
   return {
@@ -35099,6 +35410,13 @@ async function watchReleaseRun(deps, ctx, workflow, sha) {
     const run = rows.find((r) => r.headSha === sha && typeof r.databaseId === "number");
     if (!run) continue;
     if (run.status === "completed") return { workflow, runId: run.databaseId, url: run.url, conclusion: run.conclusion ?? "unknown" };
+    try {
+      const viewed = JSON.parse(await deps.run("gh", ["run", "view", String(run.databaseId), "--repo", ctx.repo, "--json", "status,conclusion"]));
+      if (viewed.status === "completed") {
+        return { workflow, runId: run.databaseId, url: run.url, conclusion: typeof viewed.conclusion === "string" ? viewed.conclusion : "unknown" };
+      }
+    } catch {
+    }
     try {
       await deps.run("gh", ghRunWatchArgs(run.databaseId, ctx.repo));
       return { workflow, runId: run.databaseId, url: run.url, conclusion: "success" };
@@ -35126,9 +35444,9 @@ async function portFoldToDevelopment(deps, ctx, deployModel, tag) {
   const branch = devFoldBranch(tag);
   const existing = await findFoldPr(deps, ctx, tag);
   if (existing?.state === "OPEN") {
-    return (await enqueueAlignmentAutoMerge(deps, ctx, existing.number, existing.url, `development fold PR #${existing.number} for ${tag} is OPEN \u2014 reused${existing.url ? ` (${existing.url})` : ""} \u2014 see docs/Guides/train-troubleshooting.md#hotfix-fold-port`)).note;
+    return (await enqueueAlignmentAutoMerge(deps, ctx, existing.number, existing.url, `development fold PR #${existing.number} for ${tag} is OPEN \u2014 reused${existing.url ? ` (${existing.url})` : ""} \u2014 see https://github.com/mutmutco/MMI-Hub/blob/development/docs/Guides/train-troubleshooting.md#hotfix-fold-port`)).note;
   }
-  if (existing) return `development fold PR #${existing.number} for ${tag} is ${existing.state} \u2014 reused${existing.url ? ` (${existing.url})` : ""} \u2014 see docs/Guides/train-troubleshooting.md#hotfix-fold-port`;
+  if (existing) return `development fold PR #${existing.number} for ${tag} is ${existing.state} \u2014 reused${existing.url ? ` (${existing.url})` : ""} \u2014 see https://github.com/mutmutco/MMI-Hub/blob/development/docs/Guides/train-troubleshooting.md#hotfix-fold-port`;
   const previousRef = clean3(await deps.run("git", ["rev-parse", "--abbrev-ref", "HEAD"]));
   await reapFoldScratchBranches(deps);
   const scratch = devFoldScratchBranch(tag, deps);
@@ -35156,7 +35474,7 @@ async function portFoldToDevelopment(deps, ctx, deployModel, tag) {
 
 Generated by \`mmi-cli devops hotfix release\` \u2014 no main-parented commit is merged in, so the squash parents stay clean (#4365/#4371). Auto-merge is enqueued through the same path as the release alignment PR (#6068); it lands once the checks it triggers pass.`
     ]));
-    return (await enqueueAlignmentAutoMerge(deps, ctx, parsePrNumber(prUrl), prUrl || void 0, `opened development fold PR ${prUrl} (${foldNote}) \u2014 see docs/Guides/train-troubleshooting.md#hotfix-fold-port`)).note;
+    return (await enqueueAlignmentAutoMerge(deps, ctx, parsePrNumber(prUrl), prUrl || void 0, `opened development fold PR ${prUrl} (${foldNote}) \u2014 see https://github.com/mutmutco/MMI-Hub/blob/development/docs/Guides/train-troubleshooting.md#hotfix-fold-port`)).note;
   } finally {
     if (previousRef && previousRef !== "HEAD") await deps.run("git", ["checkout", previousRef]).catch(() => void 0);
     await deps.run("git", ["branch", "-D", scratch]).catch(() => void 0);
@@ -35344,6 +35662,41 @@ ${recovery.note}; the full required-check wall did not revalidate`);
   }, `the immutable ${anchors.tag} pushed at ${mergedSha.slice(0, 12)}`);
   return checks;
 }
+var FOLD_SOURCE_COMMIT_ENV = "MMI_FOLD_SOURCE_COMMIT";
+async function withFoldSourceCommit(durableSource, fn) {
+  const prev = process.env[FOLD_SOURCE_COMMIT_ENV];
+  process.env[FOLD_SOURCE_COMMIT_ENV] = durableSource;
+  try {
+    return await fn();
+  } finally {
+    if (prev === void 0) delete process.env[FOLD_SOURCE_COMMIT_ENV];
+    else process.env[FOLD_SOURCE_COMMIT_ENV] = prev;
+  }
+}
+async function assertHotfixFoldBomStamp(deps, tag) {
+  let bomText;
+  try {
+    bomText = await deps.run("git", ["show", "HEAD:distribution-bom.json"]);
+  } catch {
+    return;
+  }
+  let stamp;
+  try {
+    stamp = JSON.parse(bomText).sourceCommit;
+  } catch (e) {
+    throw new Error(`hotfix ${tag}: distribution-bom.json at the fold commit is unparseable (${e.message}) \u2014 fix the BOM before the hotfix PR is opened, then rerun hotfix start`);
+  }
+  if (typeof stamp !== "string" || !/^[0-9a-f]{40}$/.test(stamp)) {
+    throw new Error(`hotfix ${tag}: distribution-bom.json at the fold commit carries no 40-hex sourceCommit \u2014 the updater would refuse this release; fix the BOM before the hotfix PR is opened, then rerun hotfix start`);
+  }
+  try {
+    await deps.run("git", ["merge-base", "--is-ancestor", stamp, "origin/main"]);
+  } catch {
+    throw new Error(
+      `hotfix ${tag}: distribution-bom.json at the fold commit stamps sourceCommit ${stamp.slice(0, 12)}, which is NOT on origin/main \u2014 the squash merge of the hotfix PR would orphan it and hotfix release would refuse (hotfix-bom-lineage). Make the consumer stamp ${FOLD_SOURCE_COMMIT_ENV} when set (the train exports the durable merge-base during the fold, Jerv-Hub#1084), land that on development, and rerun hotfix start \u2014 see https://github.com/mutmutco/MMI-Hub/blob/development/docs/Guides/train-troubleshooting.md#hotfix-bom-lineage`
+    );
+  }
+}
 async function assertConsumerBomLineage(deps, mergedSha, tag) {
   let bomText;
   try {
@@ -35364,7 +35717,7 @@ async function assertConsumerBomLineage(deps, mergedSha, tag) {
     await deps.run("git", ["merge-base", "--is-ancestor", stamp, mergedSha]);
   } catch {
     throw new Error(
-      `hotfix ${tag}: distribution-bom.json at ${mergedSha.slice(0, 12)} stamps sourceCommit ${stamp.slice(0, 12)}, which the merged main commit does not contain \u2014 every updater would reject ${tag} (gateCandidate ancestry). The fold was stamped on the hotfix branch and squash-merged away: make the consumer stamp a durable merge-base (Jerv-Hub#1084), land that on development, and port it with the fix \u2014 see docs/Guides/train-troubleshooting.md#hotfix-bom-lineage`
+      `hotfix ${tag}: distribution-bom.json at ${mergedSha.slice(0, 12)} stamps sourceCommit ${stamp.slice(0, 12)}, which the merged main commit does not contain \u2014 every updater would reject ${tag} (gateCandidate ancestry). The fold was stamped on the hotfix branch and squash-merged away: make the consumer stamp a durable merge-base (Jerv-Hub#1084), land that on development, and port it with the fix \u2014 see https://github.com/mutmutco/MMI-Hub/blob/development/docs/Guides/train-troubleshooting.md#hotfix-bom-lineage`
     );
   }
 }
@@ -35410,16 +35763,16 @@ async function runHotfixReleaseLocked(deps, versionInput, options, doctor) {
   const releaseExists = await hotfixReleaseExists(deps, ctx, tag);
   if (!releaseExists && isHubControlRepo(ctx.repo)) {
     if (!options.announceSummaryFile) {
-      throw new Error("a new MMI-Hub hotfix Release requires --announce-summary-file <path> with 3-6 short LLM-curated lines; create the summary file, then rerun the same hotfix release command \u2014 see docs/Guides/train-troubleshooting.md#announce-summary-missing");
+      throw new Error("a new MMI-Hub hotfix Release requires --announce-summary-file <path> with 3-6 short LLM-curated lines; create the summary file, then rerun the same hotfix release command \u2014 see https://github.com/mutmutco/MMI-Hub/blob/development/docs/Guides/train-troubleshooting.md#announce-summary-missing");
     }
     let lines2;
     try {
       lines2 = summaryFileLines(await (deps.readFile ?? ((p) => (0, import_promises4.readFile)(p, "utf8")))(options.announceSummaryFile));
     } catch (e) {
-      throw new Error(`could not read --announce-summary-file ${options.announceSummaryFile}: ${e.message} \u2014 see docs/Guides/train-troubleshooting.md#announce-summary-missing`);
+      throw new Error(`could not read --announce-summary-file ${options.announceSummaryFile}: ${e.message} \u2014 see https://github.com/mutmutco/MMI-Hub/blob/development/docs/Guides/train-troubleshooting.md#announce-summary-missing`);
     }
     if (lines2.length < 3 || lines2.length > 6) {
-      throw new Error(`--announce-summary-file must contain 3-6 non-empty LLM-curated lines (found ${lines2.length}) \u2014 see docs/Guides/train-troubleshooting.md#announce-summary-missing`);
+      throw new Error(`--announce-summary-file must contain 3-6 non-empty LLM-curated lines (found ${lines2.length}) \u2014 see https://github.com/mutmutco/MMI-Hub/blob/development/docs/Guides/train-troubleshooting.md#announce-summary-missing`);
     }
     const jerv = hubSummaryJervRefusal(lines2);
     if (jerv) throw new Error(jerv);
@@ -35566,7 +35919,7 @@ ${decision.note}`);
     foldNote = await portFoldToDevelopment(deps, ctx, deployModel, tag);
   } catch (e) {
     foldStatus = "failure";
-    foldNote = `development fold port FAILED: ${e.message ?? e} \u2014 the release stands; port it by hand on a fresh branch: git checkout -B ${devFoldBranch(tag)}-manual origin/development && ${foldPortManualCommand(deployModel, version)}, then push it as the canonical head (git push origin ${devFoldBranch(tag)}-manual:refs/heads/${devFoldBranch(tag)}) and open a development-base PR \u2014 see docs/Guides/train-troubleshooting.md#hotfix-fold-port`;
+    foldNote = `development fold port FAILED: ${e.message ?? e} \u2014 the release stands; port it by hand on a fresh branch: git checkout -B ${devFoldBranch(tag)}-manual origin/development && ${foldPortManualCommand(deployModel, version)}, then push it as the canonical head (git push origin ${devFoldBranch(tag)}-manual:refs/heads/${devFoldBranch(tag)}) and open a development-base PR \u2014 see https://github.com/mutmutco/MMI-Hub/blob/development/docs/Guides/train-troubleshooting.md#hotfix-fold-port`;
   }
   await recordHotfixPhase(ledger, anchors, "alignment", hotfixFoldAlignmentEntry(foldStatus, foldNote, mergedSha), "the tagged, released, deployed hotfix");
   const ledgerReport = releaseLedgerReport(await ledger.load(anchors).catch(() => void 0), ledger.path);
@@ -35615,7 +35968,7 @@ async function runHotfixRetryDeployLocked(deps, versionInput) {
         foldNote2 = await portFoldToDevelopment(deps, ctx, deployModel, prior.tag);
       } catch (e) {
         foldStatus2 = "failure";
-        foldNote2 = `development fold port FAILED: ${e.message ?? e} \u2014 the release stands; port it by hand on a fresh branch: git checkout -B ${devFoldBranch(prior.tag)}-manual origin/development && ${foldPortManualCommand(deployModel, prior.tag.replace(/^v/, ""))}, then push it as the canonical head (git push origin ${devFoldBranch(prior.tag)}-manual:refs/heads/${devFoldBranch(prior.tag)}) and open a development-base PR \u2014 see docs/Guides/train-troubleshooting.md#hotfix-fold-port`;
+        foldNote2 = `development fold port FAILED: ${e.message ?? e} \u2014 the release stands; port it by hand on a fresh branch: git checkout -B ${devFoldBranch(prior.tag)}-manual origin/development && ${foldPortManualCommand(deployModel, prior.tag.replace(/^v/, ""))}, then push it as the canonical head (git push origin ${devFoldBranch(prior.tag)}-manual:refs/heads/${devFoldBranch(prior.tag)}) and open a development-base PR \u2014 see https://github.com/mutmutco/MMI-Hub/blob/development/docs/Guides/train-troubleshooting.md#hotfix-fold-port`;
       }
       return hotfixFoldAlignmentEntry(foldStatus2, foldNote2, prior.tagSha);
     }
@@ -36135,17 +36488,17 @@ function prHeadBehindBase(input) {
   return /out[- ]of[- ]date|not up to date|up to date with the base|update (?:the|your) branch/i.test(input.message ?? "");
 }
 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`;
+  return `git fetch origin ${base} && git merge origin/${base} (on ${head}), resolve the conflicts, push, then rerun \u2014 https://github.com/mutmutco/MMI-Hub/blob/development/docs/Guides/train-troubleshooting.md#head-behind-base`;
 }
 function prLandedBranchFinality(prNumber, base) {
-  return `PR #${prNumber} is merged, and that is final \u2014 stopping a local waiter or monitor does not unmerge it. The head branch is now landed; further commits pushed to it reach nothing. If more work is needed, run \`git fetch origin ${base} && git switch -c <new-branch> origin/${base}\`, then cherry-pick anything already committed \u2014 docs/Guides/train-troubleshooting.md#merged-pr-head-reuse`;
+  return `PR #${prNumber} is merged, and that is final \u2014 stopping a local waiter or monitor does not unmerge it. The head branch is now landed; further commits pushed to it reach nothing. If more work is needed, run \`git fetch origin ${base} && git switch -c <new-branch> origin/${base}\`, then cherry-pick anything already committed \u2014 https://github.com/mutmutco/MMI-Hub/blob/development/docs/Guides/train-troubleshooting.md#merged-pr-head-reuse`;
 }
 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`;
+  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 https://github.com/mutmutco/MMI-Hub/blob/development/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;
@@ -37247,12 +37600,12 @@ async function resolveBoardAdvanceForPr(prNumber, repoOption) {
 }
 function evaluatePrMergeHousekeeping(report, context, force = false) {
   const scratch = report.scratch;
-  const failed = scratch?.status === "failed";
+  const failed2 = scratch?.status === "failed";
   const prunable = scratch?.safeAuto ?? 0;
   const unprunable = scratch?.skipped ?? 0;
-  if (!(failed || prunable > 0 || unprunable > 0)) return { blocked: false };
+  if (!(failed2 || prunable > 0 || unprunable > 0)) return { blocked: false };
   if (force) return { blocked: false };
-  const detail = failed ? `scratch housekeeping failed${scratch?.error ? `: ${scratch.error}` : ""}` : `${prunable} prunable + ${unprunable} un-prunable scratch item(s) remain after cleanup`;
+  const detail = failed2 ? `scratch housekeeping failed${scratch?.error ? `: ${scratch.error}` : ""}` : `${prunable} prunable + ${unprunable} un-prunable scratch item(s) remain after cleanup`;
   return {
     blocked: true,
     reason: `${context} housekeeping blocked merge: ${detail}. Run host-owned scratch cleanup, then retry \u2014 or re-run \`mmi-cli ${context} --force\` to acknowledge and land anyway. (Kept advisory plans/ scratch never blocks: it is gitignored and can never reach origin.)`
@@ -37635,7 +37988,7 @@ function readRepoVersion() {
 }
 function registerTrainCommands(program3, trainDeps) {
   const train = program3.command("train").description("release-train observability \u2014 track position, version lag, and the shared preflight-and-heal doctor (#2688, #6067)");
-  train.command("doctor").description("one shared preflight-and-heal verdict for the release, rcand and hotfix lanes; read-only unless --heal (#6067)").addOption(new Option("--lane <lane>", "train lane to check (defaults from the release track: direct \u2192 release)").choices([...TRAIN_LANES])).option("--dev", "judge the `release --dev` lane (development -> main, skipping rc): the lane starts from development and is read on development's workflows (#6318)").option("--heal", "repair safe local reconstructible state (scratch gitignore, churn, stray local tags, ff-only branch lag, finished scratch branches, stale alignment ledger leg); it never clears a ledger-pending, ledger-failed or branch-mismatch blocker (#6404, #6401, #6399) \u2014 those need `mmi-cli devops release --resume` (or, with fresh approval, `--abort --apply`) and `git checkout <start branch>`, so exit 1 after --heal is the gate working, not a failed heal").option("--repo <owner/repo>", "target repo (defaults to the current checkout)").option("--suite-solo", "judge an owner-approved solo release of one suite module, as `release --suite-solo --owner-go` does (requires --owner-go; never on rcand, #7327)").option("--owner-go", "explicit owner approval for the suite-solo lane (requires --suite-solo)").option("--json", "machine-readable output").option("--out <path>", "write the verdict to this file as UTF-8 (no BOM) instead of stdout \u2014 the shell-free receipt path (#5802/#6563); pair with --json for a machine-readable file (e.g. `--json --out .jerv/tmp/train-doctor.json`); the file is written even when the verdict is NOT READY").addHelpText("after", "\nExit codes:\n  0  ready \u2014 no blocker and origin verified\n  1  a blocker remains, or origin could not be verified (never green on an unread origin)\n\nEvery finding carries code, severity (blocker|warning|healed|info), source (local|origin), remedy and a\ndocs/Guides/train-troubleshooting.md#<code> anchor. `release --apply` and `rcand --apply` run this at step 0 with --heal.\n").action(async (o) => {
+  train.command("doctor").description("one shared preflight-and-heal verdict for the release, rcand and hotfix lanes; read-only unless --heal (#6067)").addOption(new Option("--lane <lane>", "train lane to check (defaults from the release track: direct \u2192 release)").choices([...TRAIN_LANES])).option("--dev", "judge the `release --dev` lane (development -> main, skipping rc): the lane starts from development and is read on development's workflows (#6318)").option("--heal", "repair safe local reconstructible state (scratch gitignore, churn, stray local tags, ff-only branch lag, finished scratch branches, stale alignment ledger leg); it never clears a ledger-pending, ledger-failed or branch-mismatch blocker (#6404, #6401, #6399) \u2014 those need `mmi-cli devops release --resume` (or, with fresh approval, `--abort --apply`) and `git checkout <start branch>`, so exit 1 after --heal is the gate working, not a failed heal").option("--repo <owner/repo>", "target repo (defaults to the current checkout)").option("--suite-solo", "judge an owner-approved solo release of one suite module, as `release --suite-solo --owner-go` does (requires --owner-go; never on rcand, #7327)").option("--owner-go", "explicit owner approval for the suite-solo lane (requires --suite-solo)").option("--json", "machine-readable output").option("--out <path>", "write the verdict to this file as UTF-8 (no BOM) instead of stdout \u2014 the shell-free receipt path (#5802/#6563); pair with --json for a machine-readable file (e.g. `--json --out .jerv/tmp/train-doctor.json`); the file is written even when the verdict is NOT READY").addHelpText("after", "\nExit codes:\n  0  ready \u2014 no blocker and origin verified\n  1  a blocker remains, or origin could not be verified (never green on an unread origin)\n\nEvery finding carries code, severity (blocker|warning|healed|info), source (local|origin), remedy and a\nhttps://github.com/mutmutco/MMI-Hub/blob/development/docs/Guides/train-troubleshooting.md#<code> anchor. `release --apply` and `rcand --apply` run this at step 0 with --heal.\n").action(async (o) => {
     try {
       if (o.suiteSolo !== o.ownerGo || o.lane === "rcand" && o.suiteSolo) {
         return failGraceful("train doctor: a suite-solo verdict needs BOTH --suite-solo --owner-go, and never on the rcand lane");
@@ -37815,7 +38168,7 @@ async function openSuiteCutPinPr(deps, input) {
 }
 async function openSuitePinPr(deps, input) {
   const { repo, tag, stage } = input;
-  const remedy = `open/merge the ${SUITE_REPO} development pin PR for ${repo} ${tag}, then rerun the same train command; do not recut the tag \u2014 see docs/Guides/train-troubleshooting.md#suite-pin-pr`;
+  const remedy = `open/merge the ${SUITE_REPO} development pin PR for ${repo} ${tag}, then rerun the same train command; do not recut the tag \u2014 see https://github.com/mutmutco/MMI-Hub/blob/development/docs/Guides/train-troubleshooting.md#suite-pin-pr`;
   let scratch = "";
   try {
     const get = JSON.parse(await deps.run("gh", ["api", `repos/${SUITE_REPO}/contents/seed/modules.json?ref=development`]));
@@ -39874,7 +40227,7 @@ function withRateLimitRetry(client, seams = {}) {
   };
 }
 async function prCreateMergedHeadWarning(input, deps = {}) {
-  const guide = "docs/Guides/train-troubleshooting.md#merged-pr-head-reuse";
+  const guide = "https://github.com/mutmutco/MMI-Hub/blob/development/docs/Guides/train-troubleshooting.md#merged-pr-head-reuse";
   if (!input.head) {
     return `pr create: WARNING \u2014 could not check whether the current head branch already landed (the current branch could not be resolved); continuing with PR creation \u2014 ${guide}`;
   }
@@ -39899,6 +40252,11 @@ async function prCreateMergedHeadWarning(input, deps = {}) {
     return `pr create: WARNING \u2014 could not check whether head branch '${input.head}' already landed (${detail}); continuing with PR creation \u2014 ${guide}`;
   }
 }
+function isIssueMissingError(e) {
+  if (typeof e.status === "number") return e.status === 404;
+  const msg = e instanceof Error ? e.message : String(e);
+  return /HTTP 404|Not Found|\(404\)/i.test(msg);
+}
 async function prCreateClaimRefusal(body, repoOption, deps = {}) {
   const issues = [...new Set(findClosingMentions(body).map((mention) => mention.issue))];
   if (!issues.length) return void 0;
@@ -39909,7 +40267,14 @@ async function prCreateClaimRefusal(body, repoOption, deps = {}) {
   const requester = `requesting lane: ${actor.surface}/${actor.session}@${actor.host} (session id from ${source})`;
   const checkContest = deps.checkContest ?? checkLaneContest;
   for (const number of issues) {
-    const state = await client.rest("GET", `repos/${repo}/issues/${number}`).then((issue) => issue?.state, () => void 0);
+    let state;
+    try {
+      state = (await client.rest("GET", `repos/${repo}/issues/${number}`))?.state;
+    } catch (e) {
+      if (isIssueMissingError(e)) {
+        return `pr create: REFUSED \u2014 ${repo}#${number} does not exist \u2014 the PR body closes an issue that was never filed; file the issue first, or drop the closing line before creating this PR. There is no lane to claim, so claiming cannot create it; ${requester}`;
+      }
+    }
     if (state?.toLowerCase() === "closed") continue;
     const contest = await checkContest(client, { repository: repo, number }, actor);
     if (!contest.contested) continue;
@@ -43402,10 +43767,10 @@ async function announceSummaryRefusal(path2, isHub = false) {
   try {
     lines2 = summaryFileLines(await (0, import_promises8.readFile)(path2, "utf8"));
   } catch (e) {
-    return `release: could not read --announce-summary-file ${path2}: ${e.message} \u2014 see docs/Guides/train-troubleshooting.md#announce-summary-missing`;
+    return `release: could not read --announce-summary-file ${path2}: ${e.message} \u2014 see https://github.com/mutmutco/MMI-Hub/blob/development/docs/Guides/train-troubleshooting.md#announce-summary-missing`;
   }
   if (lines2.length < 3 || lines2.length > 6) {
-    return `release: --announce-summary-file must contain 3-6 non-empty LLM-curated lines (found ${lines2.length}) \u2014 see docs/Guides/train-troubleshooting.md#announce-summary-missing`;
+    return `release: --announce-summary-file must contain 3-6 non-empty LLM-curated lines (found ${lines2.length}) \u2014 see https://github.com/mutmutco/MMI-Hub/blob/development/docs/Guides/train-troubleshooting.md#announce-summary-missing`;
   }
   if (isHub) {
     const jerv = hubSummaryJervRefusal(lines2);
@@ -43824,7 +44189,7 @@ function registerTrainCommandsAndInventory(program3) {
 function registerTrainOperationsCommands(program3, runProjectInfoSyncCallback) {
   async function pinSoloMember(repo, tag) {
     const read = await fetchProjectBySlugChecked(slugOf(repo), registryClientDeps(await loadConfig()));
-    if (!read.ok || !read.project) throw new Error(`suite pin PR FAILED: registry META unreadable for ${repo} (${read.ok ? "missing" : read.error}); rerun the same train command after restoring registry access \u2014 see docs/Guides/train-troubleshooting.md#suite-pin-pr`);
+    if (!read.ok || !read.project) throw new Error(`suite pin PR FAILED: registry META unreadable for ${repo} (${read.ok ? "missing" : read.error}); rerun the same train command after restoring registry access \u2014 see https://github.com/mutmutco/MMI-Hub/blob/development/docs/Guides/train-troubleshooting.md#suite-pin-pr`);
     if (!suiteMemberRefusal(repo, read.project, "release")) return void 0;
     const root = (await execFileP("git", ["rev-parse", "--show-toplevel"])).stdout.trim();
     return openSuitePinPr({ root, run: async (file, args, cwd) => (await execFileP(file, args, { cwd, timeout: GIT_TIMEOUT_MS })).stdout }, { repo, tag, stage: "main" });
@@ -44069,7 +44434,7 @@ function registerTrainOperationsCommands(program3, runProjectInfoSyncCallback) {
         if (announcesToChannel) {
           if (!o.announceSummaryFile) {
             return fail(
-              isHub ? "release: a new MMI-Hub release requires --announce-summary-file <path> with 3-6 short LLM-curated lines; create the summary file, then rerun the same release command \u2014 see docs/Guides/train-troubleshooting.md#announce-summary-missing" : `release: ${slug} announces to its project release channel, so a new release requires --announce-summary-file <path> with 3-6 short plain-language lines in the project's releaseLanguage (${releaseLanguage2}); create the summary file, then rerun the same release command \u2014 see docs/Guides/train-troubleshooting.md#announce-summary-missing`
+              isHub ? "release: a new MMI-Hub release requires --announce-summary-file <path> with 3-6 short LLM-curated lines; create the summary file, then rerun the same release command \u2014 see https://github.com/mutmutco/MMI-Hub/blob/development/docs/Guides/train-troubleshooting.md#announce-summary-missing" : `release: ${slug} announces to its project release channel, so a new release requires --announce-summary-file <path> with 3-6 short plain-language lines in the project's releaseLanguage (${releaseLanguage2}); create the summary file, then rerun the same release command \u2014 see https://github.com/mutmutco/MMI-Hub/blob/development/docs/Guides/train-troubleshooting.md#announce-summary-missing`
             );
           }
           const refusal = await announceSummaryRefusal(o.announceSummaryFile, isHub);
@@ -44252,7 +44617,7 @@ function registerTrainOperationsCommands(program3, runProjectInfoSyncCallback) {
     if (o.suiteSolo !== o.ownerGo) return fail("hotfix start: solo suite hotfix requires BOTH --suite-solo --owner-go");
     return runHotfixSub("start", () => runHotfixStart(trainApplyDeps(), { from: o.from, suiteSolo: o.suiteSolo, ack: o.ack ? o.ack.split(",").map((s) => s.trim()).filter(Boolean) : void 0 }), o, renderHotfixStart);
   });
-  hotfixCmd.command("release <version>").description("after the hotfix PR is merged + checks green: tag, GitHub Release, watch deploy/publish, verify distribution (idempotent)").option("--json", "machine-readable output").option("--announce-summary-file <path>", "agent-curated 3-6 line release Slack summary; required for a NEW MMI-Hub hotfix Release (#883/#3901/#6068), optional for a product repo announcing to its project release channel (#6517)").option("--carries <pr#|sha[,pr#|sha...]>", "declared fix target(s) this hotfix must carry; each must be proven present before tagging (#3056)").option("--retry-deploy", "re-run only the failed deploy and/or fold-port alignment legs of a published hotfix of this same tag (#6985)").option("--suite-solo", "release one suite module alone (requires --owner-go)").option("--owner-go", "explicit owner approval for a solo backend hotfix").option("--out <path>", "write the result to this file as UTF-8 (no BOM) instead of stdout \u2014 the shell-free receipt path (#5983/#6068)").action(async (version, o) => {
+  hotfixCmd.command("release <version>").description("after the hotfix PR is merged + checks green: tag, GitHub Release, watch deploy/publish, verify distribution (idempotent)").option("--json", "machine-readable output").option("--announce-summary-file <path>", "agent-curated 3-6 line release Slack summary; required for a NEW MMI-Hub hotfix Release (#883/#3901/#6068), optional for a product repo announcing to its project release channel (#6517)").option("--carries <pr#|sha[,pr#|sha...]>", "declared fix target(s) this hotfix must carry; each must be proven present before tagging (#3056)").option("--ack <shas>", "accepted for flag symmetry with hotfix start; hotfix release proves every carry by ancestry, so it is ignored here, never an error (#7338)").option("--retry-deploy", "re-run only the failed deploy and/or fold-port alignment legs of a published hotfix of this same tag (#6985)").option("--suite-solo", "release one suite module alone (requires --owner-go)").option("--owner-go", "explicit owner approval for a solo backend hotfix").option("--out <path>", "write the result to this file as UTF-8 (no BOM) instead of stdout \u2014 the shell-free receipt path (#5983/#6068)").action(async (version, o) => {
     if (o.suiteSolo !== o.ownerGo) return fail("hotfix release: solo suite release requires BOTH --suite-solo --owner-go");
     if (o.retryDeploy) {
       if (o.announceSummaryFile || o.carries) {
@@ -44261,7 +44626,7 @@ function registerTrainOperationsCommands(program3, runProjectInfoSyncCallback) {
       return runHotfixSub("retry-deploy", () => runHotfixRetryDeploy(trainApplyDeps(), version), o, renderHotfixRetryDeploy);
     }
     return runHotfixSub("release", async () => {
-      const result = await runHotfixRelease(trainApplyDeps(), version, { announceSummaryFile: o.announceSummaryFile, carries: o.carries ? [o.carries] : [], suiteSolo: o.suiteSolo });
+      const result = await runHotfixRelease(trainApplyDeps(), version, { announceSummaryFile: o.announceSummaryFile, carries: o.carries ? [o.carries] : [], suiteSolo: o.suiteSolo, ...o.ack ? { ack: o.ack.split(",").map((s) => s.trim()).filter(Boolean) } : {} });
       const suitePin = o.suiteSolo ? await pinSoloMember(result.repo, result.tag) : void 0;
       const projectInfoSync = await runProjectInfoSyncLeg(runProjectInfoSyncCallback, result.repo);
       return { ...result, projectInfoSync, ...o.suiteSolo ? { suiteSolo: true, suitePin } : {} };
@@ -44297,6 +44662,10 @@ async function exec(file, args, cwd, timeout = GH_TIMEOUT) {
 async function gh(args) {
   return exec("gh", args);
 }
+function rcRunCauseFromLog(log) {
+  const causes = [...new Set([...log.matchAll(/##\[error\](?!Process completed with exit code)([^\r\n]+)/g)].map((m) => m[1].trim()).filter(Boolean))];
+  return causes.length ? `: ${causes.join("; ")}` : "";
+}
 function suiteTrainIo(root, summaryFile) {
   const recordPath = repoRuntimeStatePath(root, "suite", "cut.json");
   const base = (0, import_node_path42.join)(repoRuntimeStatePath(root, "suite"), "checkouts");
@@ -44410,23 +44779,41 @@ function suiteTrainIo(root, summaryFile) {
       if (result.tag !== expected || result.deployStatus !== "success") throw new Error(`${repo}: release is not green at expected ${expected} (${result.tag}/${result.deployStatus})`);
     }
   });
-  const publish = async (repo, tag) => {
-    const title = `module-rc-publish ${repo} @ ${tag}`;
-    const rows = async () => JSON.parse(await gh(["run", "list", "--repo", "mutmutco/MMI-Hub", "--workflow", "module-rc-publish.yml", "--event", "workflow_dispatch", "--limit", "100", "--json", "databaseId,displayTitle,conclusion,status,createdAt"]));
-    const existing = (await rows()).filter((r) => r.displayTitle === title).sort((a, b) => Date.parse(b.createdAt) - Date.parse(a.createdAt));
-    if (existing[0]?.conclusion === "success") return;
-    if (existing[0]?.conclusion === "failure") throw new Error(`${repo}: prior module-rc-publish ${tag} failed; inspect the run and retry it explicitly before continuing`);
+  const rcRuns = async () => JSON.parse(await gh(["run", "list", "--repo", "mutmutco/MMI-Hub", "--workflow", "module-rc-publish.yml", "--event", "workflow_dispatch", "--limit", "100", "--json", "databaseId,displayTitle,conclusion,status,createdAt"]));
+  const watchRcRun = async (title, fields, reuse) => {
     const since = Date.now() - 1e4;
-    if (!existing.length) await gh(["workflow", "run", "module-rc-publish.yml", "--repo", "mutmutco/MMI-Hub", "--field", `repo=${repo}`, "--field", `tag=${tag}`]);
-    let candidate = existing[0];
+    if (!reuse) await gh(["workflow", "run", "module-rc-publish.yml", "--repo", "mutmutco/MMI-Hub", ...fields.flatMap((f) => ["--field", f])]);
+    let candidate = reuse;
     for (let i = 0; !candidate && i < 25; i++) {
       await new Promise((resolve7) => setTimeout(resolve7, 1e3));
-      candidate = (await rows()).find((r) => r.displayTitle === title && Date.parse(r.createdAt) >= since);
+      candidate = (await rcRuns()).find((r) => r.displayTitle === title && Date.parse(r.createdAt) >= since);
+    }
+    if (!candidate) throw new Error(`workflow dispatch outcome ambiguous for "${title}"; inspect Actions before retrying`);
+    try {
+      await exec("gh", ["run", "watch", String(candidate.databaseId), "--repo", "mutmutco/MMI-Hub", "--exit-status"], void 0, WATCH_TIMEOUT);
+    } catch {
     }
-    if (!candidate) throw new Error(`${repo}: workflow dispatch outcome ambiguous for ${tag}; inspect Actions before retrying`);
-    await exec("gh", ["run", "watch", String(candidate.databaseId), "--repo", "mutmutco/MMI-Hub", "--exit-status"], void 0, WATCH_TIMEOUT);
     const verdict = JSON.parse(await gh(["run", "view", String(candidate.databaseId), "--repo", "mutmutco/MMI-Hub", "--json", "conclusion"]));
-    if (verdict.conclusion !== "success") throw new Error(`${repo}: module rc publish run ${candidate.databaseId} not green`);
+    return { id: candidate.databaseId, conclusion: verdict.conclusion };
+  };
+  const publish = async (repo, tag) => {
+    const title = `module-rc-publish ${repo} @ ${tag}`;
+    const existing = (await rcRuns()).filter((r) => r.displayTitle === title).sort((a, b) => Date.parse(b.createdAt) - Date.parse(a.createdAt));
+    if (existing[0]?.conclusion === "success") return;
+    if (existing[0]?.conclusion === "failure") throw new Error(`${repo}: prior module-rc-publish ${tag} failed; inspect the run and retry it explicitly before continuing`);
+    const run = await watchRcRun(title, [`repo=${repo}`, `tag=${tag}`], existing[0]);
+    if (run.conclusion !== "success") throw new Error(`${repo}: module rc publish run ${run.id} not green${await rcRunCause(run.id)}`);
+  };
+  const preflight2 = async (repo) => {
+    const run = await watchRcRun(`module-rc-preflight ${repo}`, [`repo=${repo}`, "preflight=true"], void 0);
+    if (run.conclusion !== "success") throw new Error(`rc serving preflight run ${run.id} failed${await rcRunCause(run.id)}`);
+  };
+  const rcRunCause = async (id) => {
+    try {
+      return rcRunCauseFromLog(await exec("gh", ["run", "view", String(id), "--repo", "mutmutco/MMI-Hub", "--log-failed"]));
+    } catch {
+      return "";
+    }
   };
   const registry2 = async () => {
     const file = await defaultGitHubClient().rest("GET", `repos/${SUITE_REPO}/contents/seed/modules.json?ref=development`);
@@ -44460,6 +44847,7 @@ function suiteTrainIo(root, summaryFile) {
     },
     rcand: runRcand,
     publish,
+    preflight: preflight2,
     pin: (input) => openSuiteCutPinPr({ root, run: (file, args, cwd) => exec(file, args, cwd, GIT_TIMEOUT_MS) }, input),
     verifyLeadCut: async (sha) => {
       const current = await gh(["api", `repos/${SUITE_REPO}/git/ref/heads/development`, "--jq", ".object.sha"]);
@@ -44962,15 +45350,15 @@ function renderReport(checks, opts) {
 }
 function renderTally(checks) {
   const total = checks.length;
-  const failed = checks.filter((c) => !c.ok).length;
+  const failed2 = checks.filter((c) => !c.ok).length;
   const unverified = checks.filter((c) => c.ok && c.verified === false).length;
   const warned = checks.filter((c) => c.ok && c.verified !== false && c.warn).length;
-  const healthy = total - failed - unverified - warned;
-  if (failed === 0 && unverified === 0 && warned === 0) return `\u2713 all ${total} checks healthy`;
+  const healthy = total - failed2 - unverified - warned;
+  if (failed2 === 0 && unverified === 0 && warned === 0) return `\u2713 all ${total} checks healthy`;
   const parts = [`\u2713 ${healthy} verified healthy`];
   if (warned > 0) parts.push(`\u26A0 ${warned} warn`);
   if (unverified > 0) parts.push(`? ${unverified} unverified`);
-  if (failed > 0) parts.push(`\u2717 ${failed} failed`);
+  if (failed2 > 0) parts.push(`\u2717 ${failed2} failed`);
   return `${parts.join(" \xB7 ")} \u2014 ${total} checks`;
 }
 function doctorReportExitCode(checks) {
@@ -50522,7 +50910,7 @@ fullTrack.command("readiness <owner/repo>").description("aggregate branch topolo
   console.log(JSON.stringify(report, null, 2));
   if (!report.rcand.canApply) process.exitCode = 1;
 });
-project.command("set-deploy [owner/repo]").description("patch a tenant DEPLOY row \u2014 project-admin may set only --no-env-file on their own existing dev/rc row; master may seed/change all coords and main; defaults to the current repo").addOption(new Option("--stage <stage>", "dev | rc | main").makeOptionMandatory().choices(["dev", "rc", "main"])).option("--ssh-host <host>", "the box address the deploy ssh-es into; omit to keep the stored value (required only for a NEW hetzner-ssh row \u2014 `mmi-cli devops runtime box list` finds it)").option("--ssh-user <user>", "ssh user; omit to leave the row unchanged (default root on a new row)").option("--port <port>", "loopback port the container binds / Caddy upstream (1..65535); omit to leave the row unchanged").addOption(new Option("--substrate <substrate>", "hetzner-ssh | s3-cloudfront; omit to leave the row unchanged").choices([...DEPLOY_SUBSTRATES])).option("--deploy-role-arn <arn>", "s3-cloudfront: the scoped OIDC deployer role tenant-deploy.yml assumes for this stage").option("--app-bucket <bucket>", "s3-cloudfront: the S3 bucket the built dist/ is synced into").option("--distribution-id <id>", "s3-cloudfront: the CloudFront distribution invalidated after the sync").option("--distribution-domain <domain>", "s3-cloudfront: the host the post-deploy security-header proof is measured against").option("--deploy-path <path>", "on-box per-stage release root; omit to leave the row unchanged (default /opt/mmi/<slug>/<stage> on a new row)").option("--service <name>", "systemd/compose service name; omit to leave the row unchanged (default the slug on a new row)").option("--domain <domain>", "canonical serving host; omit to leave the row unchanged").option("--alias <domain...>", "extra serving hostname the box Caddy answers (repeatable); omit to leave the stored aliases unchanged").option("--clear-aliases", "remove EVERY serving alias from the row (#2986) \u2014 omitting --alias preserves them, so clearing needs saying out loud").option("--no-env-file <bool>", "set the DEPLOY# fileless flag (true|false) \u2014 own-repo project-admin dev/rc; master main; true = env passthrough with no .env symlink").option("--force", "explicit recovery override: skip fileless-compose verification only after independent proof").option("--json", "machine-readable output").action(async (repoOrSlug, o) => {
+project.command("set-deploy [owner/repo]").description("patch a tenant DEPLOY row \u2014 project-admin may set only --no-env-file/--compose-profiles on their own existing dev/rc row; master may seed/change all coords and main; defaults to the current repo").addOption(new Option("--stage <stage>", "dev | rc | main").makeOptionMandatory().choices(["dev", "rc", "main"])).option("--ssh-host <host>", "the box address the deploy ssh-es into; omit to keep the stored value (required only for a NEW hetzner-ssh row \u2014 `mmi-cli devops runtime box list` finds it)").option("--ssh-user <user>", "ssh user; omit to leave the row unchanged (default root on a new row)").option("--port <port>", "loopback port the container binds / Caddy upstream (1..65535); omit to leave the row unchanged").addOption(new Option("--substrate <substrate>", "hetzner-ssh | s3-cloudfront; omit to leave the row unchanged").choices([...DEPLOY_SUBSTRATES])).option("--deploy-role-arn <arn>", "s3-cloudfront: the scoped OIDC deployer role tenant-deploy.yml assumes for this stage").option("--app-bucket <bucket>", "s3-cloudfront: the S3 bucket the built dist/ is synced into").option("--distribution-id <id>", "s3-cloudfront: the CloudFront distribution invalidated after the sync").option("--distribution-domain <domain>", "s3-cloudfront: the host the post-deploy security-header proof is measured against").option("--deploy-path <path>", "on-box per-stage release root; omit to leave the row unchanged (default /opt/mmi/<slug>/<stage> on a new row)").option("--service <name>", "systemd/compose service name; omit to leave the row unchanged (default the slug on a new row)").option("--domain <domain>", "canonical serving host; omit to leave the row unchanged").option("--alias <domain...>", "extra serving hostname the box Caddy answers (repeatable); omit to leave the stored aliases unchanged").option("--clear-aliases", "remove EVERY serving alias from the row (#2986) \u2014 omitting --alias preserves them, so clearing needs saying out loud").option("--no-env-file <bool>", "set the DEPLOY# fileless flag (true|false) \u2014 own-repo project-admin dev/rc; master main; true = env passthrough with no .env symlink").option("--compose-profiles <profiles>", "comma-separated compose profiles to enable for this stage (e.g. huddles,slack-bridge); omit to leave unchanged").option("--clear-compose-profiles", "remove EVERY compose profile from the row \u2014 omitting --compose-profiles preserves them, so clearing needs saying out loud").option("--force", "explicit recovery override: skip fileless-compose verification only after independent proof").option("--json", "machine-readable output").action(async (repoOrSlug, o) => {
   const cfg = await loadConfig();
   let target;
   try {
@@ -50536,6 +50924,10 @@ project.command("set-deploy [owner/repo]").description("patch a tenant DEPLOY ro
     if (v !== "true" && v !== "false") return fail("org project set-deploy: --no-env-file must be true or false");
     noEnvFile = v === "true";
   }
+  let composeProfiles;
+  if (typeof o.composeProfiles === "string") {
+    composeProfiles = o.composeProfiles.split(",").map((p) => p.trim()).filter((p) => p.length > 0);
+  }
   if (noEnvFile !== void 0) {
     const branch = DEPLOY_STAGE_BRANCH[o.stage.trim().toLowerCase()];
     if (branch) {
@@ -50574,7 +50966,9 @@ ${filelessTransitionGuide(target, o.stage)}`
       distributionDomain: o.distributionDomain,
       aliases: o.alias,
       clearAliases: o.clearAliases,
-      noEnvFile
+      noEnvFile,
+      composeProfiles,
+      clearComposeProfiles: o.clearComposeProfiles
     });
     if (target.includes("/")) body.repo = target;
   } catch (e) {