@mutmutco/cli 4.4.8 → 4.4.9

package/dist/main.cjs

@@ -4534,7 +4534,7 @@ function useColor() {
 var program = new Command();
 
 // src/command-composition.ts
-var import_node_fs48 = require("node:fs");
+var import_node_fs49 = require("node:fs");
 init_clean_exit();
 init_cli_shared();
 
@@ -5437,7 +5437,7 @@ function resolveVerbAliasShim(argv) {
 
 // src/command-composition.ts
 var import_node_os21 = require("node:os");
-var import_node_path46 = require("node:path");
+var import_node_path47 = require("node:path");
 
 // src/board-read.ts
 var import_node_fs13 = require("node:fs");
@@ -15938,10 +15938,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.4.8",
-    tag: "v4.4.8",
-    commit: "beed56b5ec82",
-    npm: "@mutmutco/cli@4.4.8"
+    version: "4.4.9",
+    tag: "v4.4.9",
+    commit: "da79ce082e9b",
+    npm: "@mutmutco/cli@4.4.9"
   },
   exitCriterion: "fleet-n-of-n",
   hubOnlyShortcut: "forbidden",
@@ -15958,14 +15958,14 @@ var rollout_plan_default = {
           repo: "mutmutco/mmi-hub",
           role: "canary",
           schedule: "train",
-          v3Target: "v4.4.8"
+          v3Target: "v4.4.9"
         }
       ],
       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.4.8 and redeploy the Hub Lambda from tag v4.4.8 (beed56b5ec82); installed clients repair via `mmi-cli doctor`. No other cohort is touched.",
-        v3Target: "v4.4.8 (@mutmutco/cli@4.4.8, tag commit beed56b5ec82 \u2014 last known-good release carrying the repo-index v4-only contract)"
+        mechanism: "npm dist-tag latest -> 4.4.9 and redeploy the Hub Lambda from tag v4.4.9 (da79ce082e9b); installed clients repair via `mmi-cli doctor`. No other cohort is touched.",
+        v3Target: "v4.4.9 (@mutmutco/cli@4.4.9, tag commit da79ce082e9b \u2014 last known-good release carrying the repo-index v4-only contract)"
       }
     },
     {
@@ -18259,6 +18259,9 @@ function correlateTenantRun(deps, since, titleIncludes) {
 function correlatePublishRun(deps, since, titleIncludes) {
   return correlateRun(deps, { workflow: "tenant-publish.yml", since, mode: "dispatch", titleIncludes });
 }
+function correlateGetPublishRun(deps, since, product) {
+  return correlateRun(deps, { workflow: "get-publish.yml", since, mode: "dispatch", titleIncludes: [product] });
+}
 function correlateControlRun(deps, since, titleIncludes) {
   return correlateRun(deps, { workflow: "tenant-control.yml", since, mode: "dispatch", titleIncludes });
 }
@@ -18801,6 +18804,10 @@ function isReleaseShaDeployEnumerationCandidate(row, nonDeployEvents) {
   return true;
 }
 
+// src/train-apply-deploy.ts
+var import_node_fs19 = require("node:fs");
+var import_node_path17 = require("node:path");
+
 // src/vercel-deployments.ts
 var TERMINAL = /* @__PURE__ */ new Set(["success", "failure", "error", "inactive"]);
 function isTerminalVercelState(state) {
@@ -19009,6 +19016,114 @@ function appendPublishDispatch(deploy, publish) {
     deployStatus: deploy.deployStatus === "failure" || publish.deployStatus === "failure" ? "failure" : deploy.deployStatus === "pending" || publish.deployStatus === "pending" ? "pending" : "success"
   };
 }
+var HUB_SERVED_PRODUCT = "mmi";
+function getPublishDispatchCommand(repo, product = HUB_SERVED_PRODUCT) {
+  return `gh workflow run get-publish.yml --repo ${repo} --ref main -f product=${product}`;
+}
+function readLocalLauncherVersion(root = process.cwd()) {
+  try {
+    const raw = (0, import_node_fs19.readFileSync)((0, import_node_path17.join)(root, "installer", "launcher", "package.json"), "utf8");
+    const version = JSON.parse(raw).version;
+    return typeof version === "string" && version.trim() ? version.trim() : null;
+  } catch {
+    return null;
+  }
+}
+function readServedChannelUrl(product = HUB_SERVED_PRODUCT, root = process.cwd()) {
+  try {
+    const raw = (0, import_node_fs19.readFileSync)((0, import_node_path17.join)(root, "config", `product.${product}.json`), "utf8");
+    const host = JSON.parse(raw).host;
+    if (typeof host !== "string" || !host.trim()) return null;
+    return `${host.trim().replace(/\/+$/, "")}/release/version`;
+  } catch {
+    return null;
+  }
+}
+async function fetchServedChannelVersion(url, fetchImpl = fetch) {
+  try {
+    const res = await fetchImpl(url, { method: "GET", redirect: "follow", signal: AbortSignal.timeout(15e3) });
+    if (res.status !== 200) return { ok: false, status: res.status };
+    const body = (await res.text()).slice(0, 4096);
+    const version = JSON.parse(body).version;
+    if (typeof version !== "string" || !version.trim()) return { ok: false, status: res.status, error: "pointer carried no version" };
+    return { ok: true, version: version.trim(), status: res.status };
+  } catch (e) {
+    return { ok: false, error: e instanceof Error ? e.message : String(e) };
+  }
+}
+async function appendServedChannelPublish(deps, input, dispatch) {
+  if (!isHubControlRepo(input.repo)) return dispatch;
+  const channelUrl = input.channelUrl ?? readServedChannelUrl();
+  const remedy = getPublishDispatchCommand(input.repo);
+  const withNote = (note, deployStatus) => ({
+    ...dispatch,
+    note: `${dispatch.note}; ${note}`,
+    ...deployStatus ? { deployStatus } : {}
+  });
+  if (input.publishStatus !== "success") {
+    return withNote(`served channel NOT moved (publish did not succeed) \u2014 after the publish is green, run \`${remedy}\``);
+  }
+  const since = (deps.now ?? Date.now)();
+  try {
+    await deps.run("gh", ["workflow", "run", "get-publish.yml", "--repo", input.repo, "--ref", "main", "-f", `product=${HUB_SERVED_PRODUCT}`]);
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    return withNote(`get-publish dispatch FAILED: ${msg}. The release itself landed, but the SERVED CHANNEL IS UNCHANGED \u2014 recover with \`${remedy}\``, "failure");
+  }
+  const correlated = await correlateGetPublishRun(deps, since, HUB_SERVED_PRODUCT);
+  if (correlated.read === "failed") {
+    return withNote(`get-publish dispatched but its run could not be READ: ${correlated.error}. Check the Actions tab; if it never ran, recover with \`${remedy}\``, "failure");
+  }
+  const { runId, runUrl } = correlated;
+  const runRow = { workflow: "get-publish.yml", ...runId ? { runId } : {}, ...runUrl ? { runUrl } : {} };
+  if (!input.watch) {
+    return {
+      ...dispatch,
+      note: `${dispatch.note}; dispatched get-publish.yml (product=${HUB_SERVED_PRODUCT}) \u2014 NOT watched, so the served channel is not yet proven moved`,
+      workflowRuns: [...dispatch.workflowRuns ?? [], { ...runRow, conclusion: "pending" }]
+    };
+  }
+  const runStatus = await watchTenantRun(deps, runId, input.repo);
+  if (runStatus !== "success") {
+    return {
+      ...dispatch,
+      note: `${dispatch.note}; get-publish.yml ${runStatus} \u2014 the SERVED CHANNEL IS UNCHANGED; recover with \`${remedy}\``,
+      workflowRuns: [...dispatch.workflowRuns ?? [], { ...runRow, conclusion: runStatus }],
+      deployStatus: "failure"
+    };
+  }
+  const expected = (deps.readLauncherVersion ?? readLocalLauncherVersion)();
+  const runs = [...dispatch.workflowRuns ?? [], { ...runRow, conclusion: "success" }];
+  if (!channelUrl) {
+    return {
+      ...dispatch,
+      note: `${dispatch.note}; get-publish.yml succeeded but the channel URL could not be read from the product config \u2014 the move is unverified`,
+      workflowRuns: runs
+    };
+  }
+  const probe = await (deps.readServedChannelVersion ?? fetchServedChannelVersion)(channelUrl);
+  if (!probe.ok) {
+    const why = probe.error ?? `HTTP ${probe.status ?? "unknown"}`;
+    return {
+      ...dispatch,
+      note: `${dispatch.note}; get-publish.yml succeeded but the served channel version could NOT be read at ${channelUrl} (${why}) \u2014 the move is unverified`,
+      workflowRuns: runs
+    };
+  }
+  if (expected && probe.version !== expected) {
+    return {
+      ...dispatch,
+      note: `${dispatch.note}; get-publish.yml succeeded but the served channel still reports ${probe.version} (expected launcher ${expected}) \u2014 THE CHANNEL DID NOT MOVE; recover with \`${remedy}\``,
+      workflowRuns: runs,
+      deployStatus: "failure"
+    };
+  }
+  return {
+    ...dispatch,
+    note: `${dispatch.note}; served channel moved \u2014 ${channelUrl} now reports ${probe.version}${expected ? "" : " (no local launcher version to compare against)"}`,
+    workflowRuns: runs
+  };
+}
 var JERV_GATEWAY_RUN_URL_NOTE = "no run URL emitted \u2014 host health leg runs outside GitHub Actions";
 async function appendJervGatewayReleaseDeploy(deps, repo, tag, tagSha, dispatch) {
   if (!isJervHubRepo(repo)) return dispatch;
@@ -19523,9 +19638,9 @@ function renderTenantControl(r) {
 }
 
 // src/train-apply-phases.ts
-var import_node_fs23 = require("node:fs");
+var import_node_fs24 = require("node:fs");
 var import_promises3 = require("node:fs/promises");
-var import_node_path23 = require("node:path");
+var import_node_path24 = require("node:path");
 
 // src/actions-billing-preflight.ts
 var CANARY_WORKFLOW = "actions-job-start-canary.yml";
@@ -19778,14 +19893,14 @@ Resume it:  ${resumeCommand}
 
 // src/train-doctor.ts
 var import_node_child_process9 = require("node:child_process");
-var import_node_fs22 = require("node:fs");
+var import_node_fs23 = require("node:fs");
 var import_node_os13 = require("node:os");
-var import_node_path22 = require("node:path");
+var import_node_path23 = require("node:path");
 
 // src/doctor-io.ts
-var import_node_fs19 = require("node:fs");
+var import_node_fs20 = require("node:fs");
 var import_node_os10 = require("node:os");
-var import_node_path17 = require("node:path");
+var import_node_path18 = require("node:path");
 var import_node_child_process7 = require("node:child_process");
 var import_node_util4 = require("node:util");
 
@@ -19798,8 +19913,8 @@ function nodeDiscardSinkPath(platform2 = process.platform) {
 var execFileP2 = (0, import_node_util4.promisify)(import_node_child_process7.execFile);
 function execFileCapture(file, args, opts = {}) {
   const sink = nodeDiscardSinkPath();
-  const inFd = (0, import_node_fs19.openSync)(sink, "r");
-  const errFd = (0, import_node_fs19.openSync)(sink, "w");
+  const inFd = (0, import_node_fs20.openSync)(sink, "r");
+  const errFd = (0, import_node_fs20.openSync)(sink, "w");
   try {
     return (0, import_node_child_process7.execFileSync)(file, args, {
       ...opts,
@@ -19807,17 +19922,17 @@ function execFileCapture(file, args, opts = {}) {
       stdio: [inFd, "pipe", errFd]
     });
   } finally {
-    (0, import_node_fs19.closeSync)(inFd);
-    (0, import_node_fs19.closeSync)(errFd);
+    (0, import_node_fs20.closeSync)(inFd);
+    (0, import_node_fs20.closeSync)(errFd);
   }
 }
 var MMI_PLUGIN_ID2 = "mmi@mutmutco";
 function stagedClaudePluginVersion() {
   try {
-    const stagingRoot = (0, import_node_path17.join)((0, import_node_os10.homedir)(), ".claude", "plugins", "staging");
-    const record = JSON.parse((0, import_node_fs19.readFileSync)((0, import_node_path17.join)(stagingRoot, "launch-target.json"), "utf8"));
+    const stagingRoot = (0, import_node_path18.join)((0, import_node_os10.homedir)(), ".claude", "plugins", "staging");
+    const record = JSON.parse((0, import_node_fs20.readFileSync)((0, import_node_path18.join)(stagingRoot, "launch-target.json"), "utf8"));
     if (typeof record.target !== "string" || typeof record.incoming !== "string") return void 0;
-    const manifest = JSON.parse((0, import_node_fs19.readFileSync)((0, import_node_path17.join)(record.incoming, ".claude-plugin", "plugin.json"), "utf8"));
+    const manifest = JSON.parse((0, import_node_fs20.readFileSync)((0, import_node_path18.join)(record.incoming, ".claude-plugin", "plugin.json"), "utf8"));
     if (typeof manifest.version !== "string") return void 0;
     return manifest.version === record.target ? record.target : void 0;
   } catch {
@@ -19827,7 +19942,7 @@ function stagedClaudePluginVersion() {
 function installedClaudePluginVersion() {
   try {
     const file = JSON.parse(
-      (0, import_node_fs19.readFileSync)((0, import_node_path17.join)((0, import_node_os10.homedir)(), ".claude", "plugins", "installed_plugins.json"), "utf8")
+      (0, import_node_fs20.readFileSync)((0, import_node_path18.join)((0, import_node_os10.homedir)(), ".claude", "plugins", "installed_plugins.json"), "utf8")
     );
     const versions = (file.plugins?.[MMI_PLUGIN_ID2] ?? []).map((r) => r.version).filter((v) => Boolean(v));
     if (versions.length === 0) return void 0;
@@ -19838,7 +19953,7 @@ function installedClaudePluginVersion() {
 }
 function manifestVersion(path2) {
   try {
-    const manifest = JSON.parse((0, import_node_fs19.readFileSync)(path2, "utf8"));
+    const manifest = JSON.parse((0, import_node_fs20.readFileSync)(path2, "utf8"));
     return typeof manifest.version === "string" && manifest.version.trim() ? manifest.version.trim() : void 0;
   } catch {
     return void 0;
@@ -19847,12 +19962,12 @@ function manifestVersion(path2) {
 function readHermesPluginEvidence(env = process.env) {
   const host = hermesConfigRoot(env);
   const root = hermesPluginRoot(env);
-  const installRecordPresent = (0, import_node_fs19.existsSync)(root);
-  const manifestPath = (0, import_node_path17.join)(root, "plugin.yaml");
+  const installRecordPresent = (0, import_node_fs20.existsSync)(root);
+  const manifestPath = (0, import_node_path18.join)(root, "plugin.yaml");
   let installedVersion;
   let manifest = "missing";
   try {
-    const text = (0, import_node_fs19.readFileSync)(manifestPath, "utf8");
+    const text = (0, import_node_fs20.readFileSync)(manifestPath, "utf8");
     let version;
     try {
       const parsed = JSON.parse(text).version;
@@ -19866,25 +19981,25 @@ function readHermesPluginEvidence(env = process.env) {
     if (version) {
       installedVersion = version;
       manifest = "valid";
-    } else if ((0, import_node_fs19.existsSync)(manifestPath)) manifest = "invalid";
+    } else if ((0, import_node_fs20.existsSync)(manifestPath)) manifest = "invalid";
   } catch {
-    if ((0, import_node_fs19.existsSync)(manifestPath)) manifest = "invalid";
+    if ((0, import_node_fs20.existsSync)(manifestPath)) manifest = "invalid";
   }
   let skills = false;
   try {
-    skills = (0, import_node_fs19.existsSync)((0, import_node_path17.join)(root, "skills")) && (0, import_node_fs19.statSync)((0, import_node_path17.join)(root, "skills")).isDirectory();
+    skills = (0, import_node_fs20.existsSync)((0, import_node_path18.join)(root, "skills")) && (0, import_node_fs20.statSync)((0, import_node_path18.join)(root, "skills")).isDirectory();
   } catch {
   }
   let provisioned = false;
-  const provisionedRoot = (0, import_node_path17.join)(host, "skills", "mmi");
+  const provisionedRoot = (0, import_node_path18.join)(host, "skills", "mmi");
   try {
-    provisioned = (0, import_node_fs19.existsSync)(provisionedRoot) && (0, import_node_fs19.statSync)(provisionedRoot).isDirectory();
+    provisioned = (0, import_node_fs20.existsSync)(provisionedRoot) && (0, import_node_fs20.statSync)(provisionedRoot).isDirectory();
   } catch {
   }
-  const treeOk = (0, import_node_fs19.existsSync)((0, import_node_path17.join)(root, "__init__.py")) && skills && manifest === "valid";
+  const treeOk = (0, import_node_fs20.existsSync)((0, import_node_path18.join)(root, "__init__.py")) && skills && manifest === "valid";
   const receipt = treeOk && !provisioned ? `hermes-skills-unprovisioned:${provisionedRoot}` : void 0;
   return {
-    hostPresent: (0, import_node_fs19.existsSync)(host),
+    hostPresent: (0, import_node_fs20.existsSync)(host),
     installRecordPresent,
     manifest,
     payloadPresent: treeOk && provisioned,
@@ -19896,7 +20011,7 @@ function installedSurfacePluginVersion(surface) {
   const token = surfaceToken(surface);
   if (token === "hermes") return readHermesPluginEvidence().installedVersion;
   if (token === "cursor") {
-    return manifestVersion((0, import_node_path17.join)(cursorLocalPluginRoot(), ".cursor-plugin", "plugin.json"));
+    return manifestVersion((0, import_node_path18.join)(cursorLocalPluginRoot(), ".cursor-plugin", "plugin.json"));
   }
   if (token === "jervcode") {
     return installedJervCodePackageVersion();
@@ -19933,13 +20048,13 @@ function worktreeRootSync() {
 }
 var gitignorePath = () => {
   const root = worktreeRootSync();
-  return root === null ? null : (0, import_node_path17.join)(root, ".gitignore");
+  return root === null ? null : (0, import_node_path18.join)(root, ".gitignore");
 };
 function readGitignore() {
   const path2 = gitignorePath();
   if (path2 === null) return null;
   try {
-    return (0, import_node_fs19.readFileSync)(path2, "utf8");
+    return (0, import_node_fs20.readFileSync)(path2, "utf8");
   } catch {
     return null;
   }
@@ -19948,14 +20063,14 @@ function writeGitignore(content) {
   const path2 = gitignorePath();
   if (path2 === null) return false;
   try {
-    (0, import_node_fs19.writeFileSync)(path2, content, "utf8");
+    (0, import_node_fs20.writeFileSync)(path2, content, "utf8");
     return true;
   } catch {
     return false;
   }
 }
 function lineEndingState(root) {
-  const attributesPresent = (0, import_node_fs19.existsSync)((0, import_node_path17.join)(root, ".gitattributes"));
+  const attributesPresent = (0, import_node_fs20.existsSync)((0, import_node_path18.join)(root, ".gitattributes"));
   try {
     const output = execFileCapture("git", ["-C", root, "ls-files", "--eol", "--", ":(glob)**/*.sh"], {
       windowsHide: true
@@ -19998,18 +20113,18 @@ function compatHolds(range, version) {
 }
 
 // src/claude-binary-doctor.ts
-var import_node_fs20 = require("node:fs");
+var import_node_fs21 = require("node:fs");
 var import_node_os12 = require("node:os");
-var import_node_path19 = require("node:path");
+var import_node_path20 = require("node:path");
 
 // src/jerv-cli-spawn.ts
 var import_node_os11 = require("node:os");
-var import_node_path18 = require("node:path");
+var import_node_path19 = require("node:path");
 init_cli_shared();
-var JERV_CLI_ENTRY = (0, import_node_path18.join)("node_modules", "@jervaise", "jerv-cli", "dist", "index.cjs");
+var JERV_CLI_ENTRY = (0, import_node_path19.join)("node_modules", "@jervaise", "jerv-cli", "dist", "index.cjs");
 function pathEnvEntries(pathEnv, platform2 = process.platform) {
   if (platform2 !== "win32") {
-    return pathEnv.split(import_node_path18.delimiter).map((e) => e.trim()).filter(Boolean);
+    return pathEnv.split(import_node_path19.delimiter).map((e) => e.trim()).filter(Boolean);
   }
   if (pathEnv.includes(";")) {
     return pathEnv.split(";").map((e) => e.trim()).filter(Boolean);
@@ -20042,10 +20157,10 @@ function jervCliCandidateDirs(env = process.env, home = (0, import_node_os11.hom
     push(normalizeSpawnPathEntry(entry, platform2));
   }
   if (platform2 === "win32") {
-    if (env.APPDATA) push((0, import_node_path18.join)(env.APPDATA, "npm"));
-    if (env.LOCALAPPDATA) push((0, import_node_path18.join)(env.LOCALAPPDATA, "npm"));
+    if (env.APPDATA) push((0, import_node_path19.join)(env.APPDATA, "npm"));
+    if (env.LOCALAPPDATA) push((0, import_node_path19.join)(env.LOCALAPPDATA, "npm"));
   } else {
-    push((0, import_node_path18.join)(home, ".local", "bin"));
+    push((0, import_node_path19.join)(home, ".local", "bin"));
   }
   return out;
 }
@@ -20098,26 +20213,26 @@ function globalNodeModulesRoots(host) {
     out.push(dir);
   };
   const prefix = env.npm_config_prefix?.trim();
-  if (prefix) push(platform2 === "win32" ? (0, import_node_path19.join)(prefix, "node_modules") : (0, import_node_path19.join)(prefix, "lib", "node_modules"));
+  if (prefix) push(platform2 === "win32" ? (0, import_node_path20.join)(prefix, "node_modules") : (0, import_node_path20.join)(prefix, "lib", "node_modules"));
   for (const dir of jervCliCandidateDirs(env, host.home ?? (0, import_node_os12.homedir)(), platform2)) {
-    push((0, import_node_path19.join)(dir, "node_modules"));
-    push((0, import_node_path19.join)((0, import_node_path19.dirname)(dir), "lib", "node_modules"));
+    push((0, import_node_path20.join)(dir, "node_modules"));
+    push((0, import_node_path20.join)((0, import_node_path20.dirname)(dir), "lib", "node_modules"));
   }
   return out;
 }
 function readHead(path2) {
   let fd;
   try {
-    fd = (0, import_node_fs20.openSync)(path2, "r");
+    fd = (0, import_node_fs21.openSync)(path2, "r");
     const buffer = new Uint8Array(MAGIC_HEAD_BYTES);
-    const read = (0, import_node_fs20.readSync)(fd, buffer, 0, MAGIC_HEAD_BYTES, 0);
+    const read = (0, import_node_fs21.readSync)(fd, buffer, 0, MAGIC_HEAD_BYTES, 0);
     return buffer.subarray(0, read);
   } catch {
     return void 0;
   } finally {
     if (fd !== void 0) {
       try {
-        (0, import_node_fs20.closeSync)(fd);
+        (0, import_node_fs21.closeSync)(fd);
       } catch {
       }
     }
@@ -20125,7 +20240,7 @@ function readHead(path2) {
 }
 function fileBytes(path2) {
   try {
-    return (0, import_node_fs20.statSync)(path2).size;
+    return (0, import_node_fs21.statSync)(path2).size;
   } catch {
     return void 0;
   }
@@ -20139,17 +20254,17 @@ function readClaudeBinaryState(host = {}) {
   const arch = host.arch ?? process.arch;
   const magic = EXECUTABLE_MAGIC[platform2];
   if (!magic) return void 0;
-  const packageRoot = globalNodeModulesRoots(host).map((root) => (0, import_node_path19.join)(root, ...PACKAGE.split("/"))).find((dir) => (0, import_node_fs20.existsSync)((0, import_node_path19.join)(dir, "package.json")));
+  const packageRoot = globalNodeModulesRoots(host).map((root) => (0, import_node_path20.join)(root, ...PACKAGE.split("/"))).find((dir) => (0, import_node_fs21.existsSync)((0, import_node_path20.join)(dir, "package.json")));
   if (!packageRoot) return void 0;
   const keys = platformPackageKeys(platform2, arch);
   const fallbackPackage = `${PACKAGE}-${keys[0]}`;
   let manifest;
   try {
-    manifest = JSON.parse((0, import_node_fs20.readFileSync)((0, import_node_path19.join)(packageRoot, "package.json"), "utf8"));
+    manifest = JSON.parse((0, import_node_fs21.readFileSync)((0, import_node_path20.join)(packageRoot, "package.json"), "utf8"));
   } catch (e) {
     return {
       state: "unreadable",
-      binPath: (0, import_node_path19.join)(packageRoot, "package.json"),
+      binPath: (0, import_node_path20.join)(packageRoot, "package.json"),
       expectedMagic: magic.name,
       platformPackage: fallbackPackage,
       error: `package.json could not be read \u2014 ${e.message}`
@@ -20166,17 +20281,17 @@ function readClaudeBinaryState(host = {}) {
       error: "package.json declares no `bin` entry \u2014 the executed file cannot be resolved"
     };
   }
-  const binPath = (0, import_node_path19.join)(packageRoot, binRelative);
-  const binName = (0, import_node_path19.basename)(binRelative);
+  const binPath = (0, import_node_path20.join)(packageRoot, binRelative);
+  const binName = (0, import_node_path20.basename)(binRelative);
   const optional = manifest.optionalDependencies;
   const publishes = (name) => typeof optional === "object" && optional !== null && Object.prototype.hasOwnProperty.call(optional, name);
   const published = keys.map((key) => `${PACKAGE}-${key}`).filter(publishes);
   if (published.length === 0) return void 0;
   const binIn = (name) => [
-    (0, import_node_path19.join)(packageRoot, "node_modules", ...name.split("/"), binName),
-    (0, import_node_path19.join)((0, import_node_path19.dirname)((0, import_node_path19.dirname)(packageRoot)), ...name.split("/"), binName)
+    (0, import_node_path20.join)(packageRoot, "node_modules", ...name.split("/"), binName),
+    (0, import_node_path20.join)((0, import_node_path20.dirname)((0, import_node_path20.dirname)(packageRoot)), ...name.split("/"), binName)
   ];
-  const found = published.map((name) => ({ name, path: binIn(name).find((file) => (0, import_node_fs20.existsSync)(file)) })).find((c) => c.path);
+  const found = published.map((name) => ({ name, path: binIn(name).find((file) => (0, import_node_fs21.existsSync)(file)) })).find((c) => c.path);
   const platformPackage = found?.name ?? published[0];
   let source;
   let sourceProblem;
@@ -20187,7 +20302,7 @@ function readClaudeBinaryState(host = {}) {
   } else {
     source = { path: found.path, bytes: fileBytes(found.path) ?? 0 };
   }
-  if (!(0, import_node_fs20.existsSync)(binPath)) {
+  if (!(0, import_node_fs21.existsSync)(binPath)) {
     return { state: "missing", binPath, expectedMagic: magic.name, platformPackage, ...source ? { source } : {}, ...sourceProblem ? { sourceProblem } : {} };
   }
   const head = readHead(binPath);
@@ -20230,9 +20345,9 @@ function healClaudeBinary(host = {}, onStep) {
   const platform2 = host.platform ?? process.platform;
   const aside = `${probe.binPath}.stub-${Date.now()}`;
   let renamed = false;
-  if ((0, import_node_fs20.existsSync)(probe.binPath)) {
+  if ((0, import_node_fs21.existsSync)(probe.binPath)) {
     try {
-      (0, import_node_fs20.renameSync)(probe.binPath, aside);
+      (0, import_node_fs21.renameSync)(probe.binPath, aside);
       renamed = true;
       onStep?.(`renamed the stub aside: ${aside}`);
     } catch (e) {
@@ -20241,12 +20356,12 @@ function healClaudeBinary(host = {}, onStep) {
   }
   try {
     onStep?.(`copying ${probe.source.path} \u2192 ${probe.binPath} (${(probe.source.bytes / 1e6).toFixed(0)} MB)`);
-    (0, import_node_fs20.copyFileSync)(probe.source.path, probe.binPath);
-    if (platform2 !== "win32") (0, import_node_fs20.chmodSync)(probe.binPath, 493);
+    (0, import_node_fs21.copyFileSync)(probe.source.path, probe.binPath);
+    if (platform2 !== "win32") (0, import_node_fs21.chmodSync)(probe.binPath, 493);
   } catch (e) {
     if (renamed) {
       try {
-        (0, import_node_fs20.renameSync)(aside, probe.binPath);
+        (0, import_node_fs21.renameSync)(aside, probe.binPath);
       } catch {
         return { ok: false, detail: `copy failed (${e.message}) and the stub could not be restored \u2014 the original is at ${aside}` };
       }
@@ -20260,7 +20375,7 @@ function healClaudeBinary(host = {}, onStep) {
   let kept = false;
   if (renamed) {
     try {
-      (0, import_node_fs20.rmSync)(aside);
+      (0, import_node_fs21.rmSync)(aside);
     } catch {
       kept = true;
     }
@@ -20619,13 +20734,13 @@ function checkLineEndings(probe) {
 }
 
 // src/release-ledger.ts
-var import_node_fs21 = require("node:fs");
-var import_node_path21 = require("node:path");
+var import_node_fs22 = require("node:fs");
+var import_node_path22 = require("node:path");
 var import_node_crypto5 = require("node:crypto");
 
 // src/file-lock.ts
 var import_promises2 = require("node:fs/promises");
-var import_node_path20 = require("node:path");
+var import_node_path21 = require("node:path");
 var sleep = (ms) => new Promise((resolve7) => setTimeout(resolve7, ms));
 var IMMEDIATE_RETRY_BUDGET = 3;
 var FileLockBusyError = class extends Error {
@@ -20710,7 +20825,7 @@ async function releaseFileLock(lockPath, guard) {
 }
 async function withFileLock(lockPath, opts, fn) {
   const resolved = resolveFileLockOpts(opts);
-  await (0, import_promises2.mkdir)((0, import_node_path20.dirname)(lockPath), { recursive: true }).catch(() => void 0);
+  await (0, import_promises2.mkdir)((0, import_node_path21.dirname)(lockPath), { recursive: true }).catch(() => void 0);
   const guard = await acquireFileLock(lockPath, resolved, Date.now() + resolved.maxWaitMs);
   try {
     return await fn();
@@ -20879,37 +20994,37 @@ function resolvePrimaryGitDir(cwd) {
   }
   let common;
   try {
-    common = (0, import_node_fs21.readFileSync)((0, import_node_path21.join)(gitDir, "commondir"), "utf8").trim();
+    common = (0, import_node_fs22.readFileSync)((0, import_node_path22.join)(gitDir, "commondir"), "utf8").trim();
   } catch (e) {
     if (e.code !== "ENOENT") {
       throw new ReleaseLedgerError("unreadable", `release ledger: the worktree gitdir's commondir pointer could not be READ (${e instanceof Error ? e.message : String(e)}) \u2014 a failed read is unverified, not primary (#5987/#4713)`);
     }
   }
   if (!common) return gitDir;
-  const commonDir = (0, import_node_path21.isAbsolute)(common) ? common : (0, import_node_path21.resolve)(gitDir, common);
+  const commonDir = (0, import_node_path22.isAbsolute)(common) ? common : (0, import_node_path22.resolve)(gitDir, common);
   try {
-    (0, import_node_fs21.readFileSync)((0, import_node_path21.join)(commonDir, "HEAD"), "utf8");
+    (0, import_node_fs22.readFileSync)((0, import_node_path22.join)(commonDir, "HEAD"), "utf8");
   } catch (e) {
     throw new ReleaseLedgerError("no-checkout", `release ledger: the worktree's commondir pointer names ${commonDir}, which has no readable HEAD (${e instanceof Error ? e.message : String(e)}) \u2014 the primary checkout may have been removed; refusing to write the ledger into a doomed location`);
   }
   return commonDir;
 }
 function releaseLedgerPath(cwd) {
-  return (0, import_node_path21.join)(resolvePrimaryGitDir(cwd), "mmi-runtime", "release", "phases.json");
+  return (0, import_node_path22.join)(resolvePrimaryGitDir(cwd), "mmi-runtime", "release", "phases.json");
 }
 function atomicWriteJson(path2, ledger) {
-  (0, import_node_fs21.mkdirSync)((0, import_node_path21.dirname)(path2), { recursive: true });
+  (0, import_node_fs22.mkdirSync)((0, import_node_path22.dirname)(path2), { recursive: true });
   const tmp = `${path2}.tmp-${process.pid}-${(0, import_node_crypto5.randomBytes)(4).toString("hex")}`;
-  (0, import_node_fs21.writeFileSync)(tmp, `${JSON.stringify(ledger, null, 2)}
+  (0, import_node_fs22.writeFileSync)(tmp, `${JSON.stringify(ledger, null, 2)}
 `, "utf8");
-  (0, import_node_fs21.renameSync)(tmp, path2);
+  (0, import_node_fs22.renameSync)(tmp, path2);
 }
 async function withReleaseLedger(path2, expected, fn, opts = {}) {
   return withFileLock(`${path2}.lock`, { label: "release ledger", maxWaitMs: opts.maxWaitMs ?? 5e3 }, async () => {
     let current;
     let raw;
     try {
-      raw = (0, import_node_fs21.readFileSync)(path2, "utf8");
+      raw = (0, import_node_fs22.readFileSync)(path2, "utf8");
     } catch (e) {
       if (e.code !== "ENOENT") {
         throw new ReleaseLedgerError("unreadable", `release ledger at ${path2} could not be READ (${e instanceof Error ? e.message : String(e)}) \u2014 a failed read is unverified, not absent (#5987)`);
@@ -21543,7 +21658,7 @@ async function clearLedgerFile(path2, anchors, maxWaitMs) {
   return withFileLock(`${path2}.lock`, { label: "release ledger", maxWaitMs }, async () => {
     let raw;
     try {
-      raw = (0, import_node_fs21.readFileSync)(path2, "utf8");
+      raw = (0, import_node_fs22.readFileSync)(path2, "utf8");
     } catch (e) {
       if (e.code === "ENOENT") return { cleared: false };
       return { cleared: false, note: `release ledger at ${path2} could not be read for clearing (${e instanceof Error ? e.message : String(e)}) \u2014 left in place` };
@@ -21559,7 +21674,7 @@ async function clearLedgerFile(path2, anchors, maxWaitMs) {
     } catch (e) {
       return { cleared: false, note: `release ledger at ${path2} belongs to ${ledger.tag} @ ${ledger.tagSha.slice(0, 12)} \u2014 not this release; left in place (${e instanceof Error ? e.message : String(e)})` };
     }
-    (0, import_node_fs21.unlinkSync)(path2);
+    (0, import_node_fs22.unlinkSync)(path2);
     return { cleared: true, note: `cleared the release ledger at ${path2} for the live-proven aborted ${anchors.tag}` };
   });
 }
@@ -21662,7 +21777,7 @@ async function healStaleAlignmentLeg(deps, cwd, expected) {
   return withFileLock(`${path2}.lock`, { label: "release ledger" }, async () => {
     let prior;
     try {
-      prior = parseReleaseLedger((0, import_node_fs21.readFileSync)(path2, "utf8"));
+      prior = parseReleaseLedger((0, import_node_fs22.readFileSync)(path2, "utf8"));
     } catch {
       return void 0;
     }
@@ -21687,7 +21802,7 @@ async function supersedeContentCausedDeployLeg(deps, cwd) {
   return withFileLock(`${path2}.lock`, { label: "release ledger" }, async () => {
     let prior;
     try {
-      prior = parseReleaseLedger((0, import_node_fs21.readFileSync)(path2, "utf8"));
+      prior = parseReleaseLedger((0, import_node_fs22.readFileSync)(path2, "utf8"));
     } catch (e) {
       throw new ReleaseLedgerError(
         "unreadable",
@@ -21783,11 +21898,11 @@ async function proveOriginPromotionOrArchived(deps, prior, path2, label, ref) {
   if (!releaseAbsent) {
     throw new Error(`${label}: origin no longer has ${prior.tag} but its GitHub Release still exists \u2014 resolve the mixed external state before closing the ledger; nothing was written (${ref})`);
   }
-  const archivePath = (0, import_node_path21.join)((0, import_node_path21.dirname)(path2), `phases.archive-${prior.tag}.json`);
-  if ((0, import_node_fs21.existsSync)(archivePath)) {
+  const archivePath = (0, import_node_path22.join)((0, import_node_path22.dirname)(path2), `phases.archive-${prior.tag}.json`);
+  if ((0, import_node_fs22.existsSync)(archivePath)) {
     throw new Error(`${label}: archive already exists at ${archivePath} \u2014 preserving both ledger records; resolve the collision by hand; nothing was written (${ref})`);
   }
-  (0, import_node_fs21.renameSync)(path2, archivePath);
+  (0, import_node_fs22.renameSync)(path2, archivePath);
   return "deleted";
 }
 async function supersedeContentCausedPublishLeg(deps, cwd) {
@@ -21795,7 +21910,7 @@ async function supersedeContentCausedPublishLeg(deps, cwd) {
   return withFileLock(`${path2}.lock`, { label: "release ledger" }, async () => {
     let prior;
     try {
-      prior = parseReleaseLedger((0, import_node_fs21.readFileSync)(path2, "utf8"));
+      prior = parseReleaseLedger((0, import_node_fs22.readFileSync)(path2, "utf8"));
     } catch (e) {
       throw new ReleaseLedgerError(
         "unreadable",
@@ -21877,7 +21992,7 @@ async function supersedeContentCausedDeployAndPublishLegs(deps, cwd) {
   return withFileLock(`${path2}.lock`, { label: "release ledger" }, async () => {
     let prior;
     try {
-      prior = parseReleaseLedger((0, import_node_fs21.readFileSync)(path2, "utf8"));
+      prior = parseReleaseLedger((0, import_node_fs22.readFileSync)(path2, "utf8"));
     } catch (e) {
       throw new ReleaseLedgerError(
         "unreadable",
@@ -21982,7 +22097,7 @@ async function supersedeContentCausedDeployAndPublishLegs(deps, cwd) {
 async function reverifyPriorRunLegs(deps, path2, targetTag) {
   let prior;
   try {
-    prior = parseReleaseLedger((0, import_node_fs21.readFileSync)(path2, "utf8"));
+    prior = parseReleaseLedger((0, import_node_fs22.readFileSync)(path2, "utf8"));
   } catch {
     return;
   }
@@ -22002,7 +22117,7 @@ async function beginReleaseLedger(deps, cwd, targetTag) {
   return withFileLock(`${path2}.lock`, { label: "release ledger" }, async () => {
     let raw;
     try {
-      raw = (0, import_node_fs21.readFileSync)(path2, "utf8");
+      raw = (0, import_node_fs22.readFileSync)(path2, "utf8");
     } catch (e) {
       if (e.code === "ENOENT") return { ok: true };
       return { ok: false, error: `the release ledger at ${path2} could not be READ (${e instanceof Error ? e.message : String(e)}) \u2014 a failed read is unverified, not absent (#5987/#4713)` };
@@ -22039,15 +22154,15 @@ async function beginReleaseLedger(deps, cwd, targetTag) {
     if (liveSha.toLowerCase() !== prior.tagSha.toLowerCase()) {
       return { ok: false, error: `the completed ${prior.tag} ledger says phases-green but origin reports ${liveSha.slice(0, 12) || "no tag"} \u2260 ${prior.tagSha.slice(0, 12)} \u2014 refusing to archive on unproven state; resolve by hand (#5987)` };
     }
-    const archivePath = (0, import_node_path21.join)((0, import_node_path21.dirname)(path2), `phases.archive-${prior.tag}.json`);
+    const archivePath = (0, import_node_path22.join)((0, import_node_path22.dirname)(path2), `phases.archive-${prior.tag}.json`);
     try {
-      (0, import_node_fs21.unlinkSync)(archivePath);
+      (0, import_node_fs22.unlinkSync)(archivePath);
     } catch (e) {
       if (e.code !== "ENOENT") {
         return { ok: false, error: `could not clear the stale archive at ${archivePath} (${e instanceof Error ? e.message : String(e)}) \u2014 the ledger for ${prior.tag} stays active (#5987)` };
       }
     }
-    (0, import_node_fs21.renameSync)(path2, archivePath);
+    (0, import_node_fs22.renameSync)(path2, archivePath);
     return { ok: true, note: `archived the completed release ledger ${prior.tag} to ${archivePath} (live-proven at ${prior.tagSha.slice(0, 12)})` };
   });
 }
@@ -22148,10 +22263,10 @@ function readOriginWorkflowsDefault(root, ref) {
 }
 var NPM_REGISTRY = "https://registry.npmjs.org";
 async function probeRegistryWhoami(train) {
-  const dir = (0, import_node_fs22.mkdtempSync)((0, import_node_path22.join)((0, import_node_os13.tmpdir)(), "mmi-npmrc-"));
-  const rc = (0, import_node_path22.join)(dir, "npmrc");
+  const dir = (0, import_node_fs23.mkdtempSync)((0, import_node_path23.join)((0, import_node_os13.tmpdir)(), "mmi-npmrc-"));
+  const rc = (0, import_node_path23.join)(dir, "npmrc");
   try {
-    (0, import_node_fs22.writeFileSync)(rc, "//registry.npmjs.org/:_authToken=${NPM_TOKEN}\n");
+    (0, import_node_fs23.writeFileSync)(rc, "//registry.npmjs.org/:_authToken=${NPM_TOKEN}\n");
     await train.runSelf(["secrets", "use", "npm/NPM_TOKEN", "--slug", "_org", "--", "npm", "whoami", "--registry", NPM_REGISTRY, "--userconfig", rc]);
     return { kind: "ok", detail: "the registry answered a login" };
   } catch (e) {
@@ -22162,7 +22277,7 @@ async function probeRegistryWhoami(train) {
     if (/\bE401\b|401 Unauthorized/.test(stderr)) return { kind: "rejected", detail: "npm whoami answered 401 Unauthorized" };
     return { kind: "unverified", detail: first };
   } finally {
-    (0, import_node_fs22.rmSync)(dir, { recursive: true, force: true });
+    (0, import_node_fs23.rmSync)(dir, { recursive: true, force: true });
   }
 }
 var REGISTRY_TOKEN_ENV = /\b(NODE_AUTH_TOKEN|NPM_TOKEN)\b/;
@@ -22180,7 +22295,7 @@ var defaultDeps2 = {
   ledgerPath: releaseLedgerPath,
   readLedgerRaw: (path2) => {
     try {
-      return (0, import_node_fs22.readFileSync)(path2, "utf8");
+      return (0, import_node_fs23.readFileSync)(path2, "utf8");
     } catch (e) {
       if (e.code === "ENOENT") return void 0;
       throw e;
@@ -22189,7 +22304,7 @@ var defaultDeps2 = {
   healAlignmentLeg: healStaleAlignmentLeg,
   readSurfacesRaw: (cwd) => {
     try {
-      return (0, import_node_fs22.readFileSync)((0, import_node_path22.join)(cwd, "surfaces.json"), "utf8");
+      return (0, import_node_fs23.readFileSync)((0, import_node_path23.join)(cwd, "surfaces.json"), "utf8");
     } catch {
       return void 0;
     }
@@ -22594,6 +22709,53 @@ async function runTrainDoctor(input) {
 regenerate the projections (\`node scripts/check-skill-payload.mjs\`) and commit the canonical fix; never hand-edit a projection` });
     }
   }
+  if (isHubControlRepo(repo)) {
+    const verifyDeps = async () => {
+      try {
+        await train.run("node", [`${cwd}/scripts/release-distribution.mjs`, "verify-deps"]);
+        return null;
+      } catch (e) {
+        return message(e);
+      }
+    };
+    const failure = await verifyDeps();
+    if (failure) {
+      const firstDir = /in (cli|updater)\/node_modules/u.exec(failure)?.[1] ?? null;
+      if (!heal || !firstDir) {
+        add({
+          code: "hub-build-deps",
+          severity: "blocker",
+          source: "local",
+          title: `the Hub distribution build dependencies do not resolve${firstDir ? ` in ${firstDir}/node_modules` : ""} \u2014 the release refuses at preflight`,
+          remedy: firstDir ? `run \`mmi-cli devops train doctor --heal\` (installs ${firstDir} from its lockfile), or \`npm --prefix ${firstDir} ci\`` : "run `npm --prefix cli ci` and `npm --prefix updater ci`, then rerun"
+        });
+      } else {
+        const installed = [];
+        let pending = firstDir;
+        let outstanding = failure;
+        let failed = 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)}` };
+            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` });
+        } 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 {
+          add({ code: "hub-build-deps", severity: "healed", source: "local", title: `installed ${installed.join(", ")} from ${installed.length === 1 ? "its lockfile" : "their lockfiles"} \u2014 the Hub distribution build dependencies resolve`, remedy: "nothing \u2014 the release preflight passes" });
+        }
+      }
+    }
+  }
   const branches = TRAIN_BRANCHES.filter((b) => b !== "rc" || track === "full");
   if (heal) {
     const sync = await syncLocalTrainBranches(train.run, { branches, fetch: false });
@@ -22689,34 +22851,34 @@ function formatTrainDoctor(v) {
 // src/train-apply-phases.ts
 var TRAIN_BUMP_INTENTS = ["major", "minor", "patch"];
 function readLocalGateWorkflows() {
-  const dir = (0, import_node_path23.join)(".github", "workflows");
+  const dir = (0, import_node_path24.join)(".github", "workflows");
   let names;
   try {
-    names = (0, import_node_fs23.readdirSync)(dir);
+    names = (0, import_node_fs24.readdirSync)(dir);
   } catch {
     return null;
   }
   const files = [];
   for (const name of names.filter(isGateWorkflowPath)) {
     try {
-      files.push({ path: `${dir}/${name}`.replace(/\\/g, "/"), body: (0, import_node_fs23.readFileSync)((0, import_node_path23.join)(dir, name), "utf8") });
+      files.push({ path: `${dir}/${name}`.replace(/\\/g, "/"), body: (0, import_node_fs24.readFileSync)((0, import_node_path24.join)(dir, name), "utf8") });
     } catch {
     }
   }
   return files;
 }
 function readLocalWorkflows() {
-  const dir = (0, import_node_path23.join)(".github", "workflows");
+  const dir = (0, import_node_path24.join)(".github", "workflows");
   let names;
   try {
-    names = (0, import_node_fs23.readdirSync)(dir);
+    names = (0, import_node_fs24.readdirSync)(dir);
   } catch {
     return null;
   }
   const files = [];
   for (const name of names.filter((n) => /\.ya?ml$/i.test(n))) {
     try {
-      files.push({ path: `${dir}/${name}`.replace(/\\/g, "/"), body: (0, import_node_fs23.readFileSync)((0, import_node_path23.join)(dir, name), "utf8") });
+      files.push({ path: `${dir}/${name}`.replace(/\\/g, "/"), body: (0, import_node_fs24.readFileSync)((0, import_node_path24.join)(dir, name), "utf8") });
     } catch {
     }
   }
@@ -23506,6 +23668,11 @@ ${recovery.note}`), recoveryInput);
   });
   let dispatch = appendPublishDispatch(deployDispatch, publishDispatch);
   if (publishSkipNote) dispatch = { ...dispatch, note: `${dispatch.note}; tenant-publish.yml skipped (${publishSkipNote})` };
+  dispatch = await appendServedChannelPublish(
+    deps,
+    { repo: ctx.repo, publishStatus: publishLeg.state === "complete" ? "success" : "failure", watch },
+    dispatch
+  );
   const announcing = announceShippedRelease(
     deps,
     { repo: ctx.repo, tag, summaryFile: options.announceSummaryFile },
@@ -23562,7 +23729,7 @@ async function activeRcandLedgerCandidate(deps, cwd) {
   }
   let prior;
   try {
-    prior = parseReleaseLedger((0, import_node_fs23.readFileSync)(path2, "utf8"));
+    prior = parseReleaseLedger((0, import_node_fs24.readFileSync)(path2, "utf8"));
   } catch {
     return void 0;
   }
@@ -26988,9 +27155,9 @@ function registerBoardCommands(program3) {
 }
 
 // src/bootstrap-commands.ts
-var import_node_fs25 = require("node:fs");
+var import_node_fs26 = require("node:fs");
 var import_node_os14 = require("node:os");
-var import_node_path25 = require("node:path");
+var import_node_path26 = require("node:path");
 init_cli_shared();
 init_clean_exit();
 
@@ -27170,8 +27337,8 @@ init_github_client();
 init_cli_shared();
 
 // src/port-registry.ts
-var import_node_fs24 = require("node:fs");
-var import_node_path24 = require("node:path");
+var import_node_fs25 = require("node:fs");
+var import_node_path25 = require("node:path");
 
 // ../infra/port-geometry.mjs
 var PORT_BLOCK = 100;
@@ -27185,8 +27352,8 @@ function nextPortBlock(registry2) {
   return [base, base + PORT_SPAN];
 }
 function loadPortRegistry(path2) {
-  if (!(0, import_node_fs24.existsSync)(path2)) return {};
-  const raw = JSON.parse((0, import_node_fs24.readFileSync)(path2, "utf8"));
+  if (!(0, import_node_fs25.existsSync)(path2)) return {};
+  const raw = JSON.parse((0, import_node_fs25.readFileSync)(path2, "utf8"));
   const out = {};
   for (const [key, value] of Object.entries(raw)) {
     if (Array.isArray(value) && value.length === 2 && value.every((n) => typeof n === "number")) {
@@ -27200,9 +27367,9 @@ function ensurePortRange(repo, path2) {
   const existing = registry2[repo];
   if (existing) return existing;
   const range = nextPortBlock(registry2);
-  const raw = (0, import_node_fs24.existsSync)(path2) ? JSON.parse((0, import_node_fs24.readFileSync)(path2, "utf8")) : {};
+  const raw = (0, import_node_fs25.existsSync)(path2) ? JSON.parse((0, import_node_fs25.readFileSync)(path2, "utf8")) : {};
   raw[repo] = range;
-  (0, import_node_fs24.writeFileSync)(path2, JSON.stringify(raw, null, 2) + "\n", "utf8");
+  (0, import_node_fs25.writeFileSync)(path2, JSON.stringify(raw, null, 2) + "\n", "utf8");
   return range;
 }
 function portCursorSeed(registry2) {
@@ -27224,22 +27391,22 @@ function existingPortRange(repo, registry2) {
   return registry2[repo] ?? null;
 }
 function portRangeInfraAt(root, source) {
-  const registryPath = (0, import_node_path24.join)(root, "infra", "port-ranges.json");
-  const ddbScriptPath = (0, import_node_path24.join)(root, "infra", "port-ddb.mjs");
-  if (!(0, import_node_fs24.existsSync)(registryPath) || !(0, import_node_fs24.existsSync)(ddbScriptPath)) return null;
+  const registryPath = (0, import_node_path25.join)(root, "infra", "port-ranges.json");
+  const ddbScriptPath = (0, import_node_path25.join)(root, "infra", "port-ddb.mjs");
+  if (!(0, import_node_fs25.existsSync)(registryPath) || !(0, import_node_fs25.existsSync)(ddbScriptPath)) return null;
   return { root, source, registryPath, ddbScriptPath };
 }
 function resolvePortRangeInfra(cwd, packageDir) {
   const direct = portRangeInfraAt(cwd, "cwd");
   if (direct) return direct;
-  for (let dir = cwd; ; dir = (0, import_node_path24.dirname)(dir)) {
-    const sibling = portRangeInfraAt((0, import_node_path24.join)(dir, "MMI-Hub"), "sibling-hub");
+  for (let dir = cwd; ; dir = (0, import_node_path25.dirname)(dir)) {
+    const sibling = portRangeInfraAt((0, import_node_path25.join)(dir, "MMI-Hub"), "sibling-hub");
     if (sibling) return sibling;
-    const parent = (0, import_node_path24.dirname)(dir);
+    const parent = (0, import_node_path25.dirname)(dir);
     if (parent === dir) break;
   }
   if (packageDir) {
-    const pkgRoot = (0, import_node_path24.join)(packageDir, "..", "..");
+    const pkgRoot = (0, import_node_path25.join)(packageDir, "..", "..");
     const pkgFrom = portRangeInfraAt(pkgRoot, "pkg-root");
     if (pkgFrom) return pkgFrom;
   }
@@ -28725,13 +28892,13 @@ function registerBootstrapCommands(program3) {
       deployFactsRead: deployFacts !== null,
       pushAllowlistOwners: verifyOwners,
       pushAllowlistOwnersRead: verifyOwnersRead,
-      readLocalFile: (path2) => path2 === "projects.json" && apiProjects != null ? apiProjects : (0, import_node_fs25.existsSync)(path2) ? (0, import_node_fs25.readFileSync)(path2, "utf8") : null,
+      readLocalFile: (path2) => path2 === "projects.json" && apiProjects != null ? apiProjects : (0, import_node_fs26.existsSync)(path2) ? (0, import_node_fs26.readFileSync)(path2, "utf8") : null,
       // requiredGcpApis is stored as an array by a JSON write, but `org project set --var KEY=VALUE` stores a raw
       // comma-string — accept either so the seeded value verifies regardless of how it was written.
       // #3689: the same committed map the org access audit reads (#3664), so a sanctioned admin is not a
       // permanent bootstrap failure on one surface and an intended state on the other. Absent file → no
       // sanction, which is the pre-#3664 behaviour.
-      sanctionedAdmins: (0, import_node_fs25.existsSync)("access-matrix.json") ? entriesValueByCanonicalRepo(loadSanctionedAdmins((0, import_node_fs25.readFileSync)("access-matrix.json", "utf8")), repo) : void 0,
+      sanctionedAdmins: (0, import_node_fs26.existsSync)("access-matrix.json") ? entriesValueByCanonicalRepo(loadSanctionedAdmins((0, import_node_fs26.readFileSync)("access-matrix.json", "utf8")), repo) : void 0,
       requiredGcpApis: (() => {
         const v = meta?.requiredGcpApis;
         if (Array.isArray(v)) return v;
@@ -28809,14 +28976,14 @@ function registerBootstrapCommands(program3) {
   bootstrap.command("drift").description("#3818: compare every org-owned whole-file seed against MMI-Hub's copy across the registry roster; read-only").option("--repo <owner/repo>", "audit one repo instead of the roster (never a fleet verdict)").option("--json", "machine-readable output").action(async () => {
     const o = { repo: rawValue("--repo", ""), json: rawFlag("--json") };
     const manifestPath = "skills/bootstrap/seeds/manifest.json";
-    if (!(0, import_node_fs25.existsSync)(manifestPath)) return fail(`bootstrap drift: ${manifestPath} not found; run from the MMI-Hub repo root \u2014 the Hub's copies ARE the reference this compares against`);
+    if (!(0, import_node_fs26.existsSync)(manifestPath)) return fail(`bootstrap drift: ${manifestPath} not found; run from the MMI-Hub repo root \u2014 the Hub's copies ARE the reference this compares against`);
     const seedSource = await resolveHubSeedSource(execGitForSeedSource);
     if (!seedSource.ok) return fail(`bootstrap drift: ${seedSource.reason}`);
-    const manifest = loadBootstrapSeeds((0, import_node_fs25.readFileSync)(manifestPath, "utf8"));
+    const manifest = loadBootstrapSeeds((0, import_node_fs26.readFileSync)(manifestPath, "utf8"));
     const hubContents = /* @__PURE__ */ new Map();
     for (const s of manifest.seeds) {
       if (s.ownership !== "org" || s.source !== "self") continue;
-      hubContents.set(s.target, (0, import_node_fs25.existsSync)(s.target) ? (0, import_node_fs25.readFileSync)(s.target, "utf8") : null);
+      hubContents.set(s.target, (0, import_node_fs26.existsSync)(s.target) ? (0, import_node_fs26.readFileSync)(s.target, "utf8") : null);
     }
     let targets;
     let classOf = (_repo) => "deployable";
@@ -28979,10 +29146,10 @@ function registerBootstrapCommands(program3) {
       return;
     }
     const manifestPath = "skills/bootstrap/seeds/manifest.json";
-    if (!(0, import_node_fs25.existsSync)(manifestPath)) return fail(`bootstrap apply: ${manifestPath} not found; bootstrap runs from the MMI-Hub repo root by design \u2014 it stamps org-level resources (Project, Ruleset, secrets, access) through the GitHub App, which is only authorized from the Hub checkout`);
+    if (!(0, import_node_fs26.existsSync)(manifestPath)) return fail(`bootstrap apply: ${manifestPath} not found; bootstrap runs from the MMI-Hub repo root by design \u2014 it stamps org-level resources (Project, Ruleset, secrets, access) through the GitHub App, which is only authorized from the Hub checkout`);
     const seedSource = await resolveHubSeedSource(execGitForSeedSource);
     if (!seedSource.ok) return fail(`bootstrap apply: ${seedSource.reason}`);
-    const manifest = loadBootstrapSeeds((0, import_node_fs25.readFileSync)(manifestPath, "utf8"));
+    const manifest = loadBootstrapSeeds((0, import_node_fs26.readFileSync)(manifestPath, "utf8"));
     const baseBranch = o.class === "content" ? "main" : "development";
     const slug = parsedRepo.slug;
     const onlyTarget = o.only.trim();
@@ -28994,16 +29161,16 @@ function registerBootstrapCommands(program3) {
     }
     const onlyManagedBlock = onlyTarget ? seedsToApply[0]?.managedBlock != null : false;
     const gh = async (args) => execFileP("gh", args, { timeout: 2e4 });
-    const readFile9 = (p) => (0, import_node_fs25.existsSync)(p) ? (0, import_node_fs25.readFileSync)(p, "utf8") : null;
+    const readFile9 = (p) => (0, import_node_fs26.existsSync)(p) ? (0, import_node_fs26.readFileSync)(p, "utf8") : null;
     const enc = (p) => p.split("/").map(encodeURIComponent).join("/");
     const putSeed = async (target, content, ref, sha) => {
-      const tmp = (0, import_node_path25.join)((0, import_node_os14.tmpdir)(), `mmi-seed-${process.pid}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}.json`);
-      (0, import_node_fs25.writeFileSync)(tmp, JSON.stringify(contentPutBody(target, content, ref, sha)), "utf8");
+      const tmp = (0, import_node_path26.join)((0, import_node_os14.tmpdir)(), `mmi-seed-${process.pid}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}.json`);
+      (0, import_node_fs26.writeFileSync)(tmp, JSON.stringify(contentPutBody(target, content, ref, sha)), "utf8");
       try {
         await gh(contentPutInputArgs(repo, target, tmp));
       } finally {
         try {
-          (0, import_node_fs25.unlinkSync)(tmp);
+          (0, import_node_fs26.unlinkSync)(tmp);
         } catch {
         }
       }
@@ -29452,10 +29619,10 @@ LIVE apply to ${repo}:
   bootstrap.command("propagate").description("#4238: re-entrant canary\u2192wave tick \u2014 plan (or, with --execute, open) per-repo PRs fanning an org-owned seed out to the fleet").option("--target <path>", "the manifest target to propagate (an org-owned whole file or declared Hub-managed block)").option("--execute", "LIVE tick via gh (master-gated) \u2014 opens/reuses per-repo seed-propagate PRs; dry-run prints the plan only").option("--json", "machine-readable output").action(async () => {
     const o = { target: rawValue("--target", ""), execute: rawFlag("--execute"), json: rawFlag("--json") };
     const manifestPath = "skills/bootstrap/seeds/manifest.json";
-    if (!(0, import_node_fs25.existsSync)(manifestPath)) return fail(`bootstrap propagate: ${manifestPath} not found; run from the MMI-Hub repo root \u2014 the Hub's copies ARE the desired state this tick propagates`);
+    if (!(0, import_node_fs26.existsSync)(manifestPath)) return fail(`bootstrap propagate: ${manifestPath} not found; run from the MMI-Hub repo root \u2014 the Hub's copies ARE the desired state this tick propagates`);
     const seedSource = await resolveHubSeedSource(execGitForSeedSource);
     if (!seedSource.ok) return fail(`bootstrap propagate: ${seedSource.reason}`);
-    const manifest = loadBootstrapSeeds((0, import_node_fs25.readFileSync)(manifestPath, "utf8"));
+    const manifest = loadBootstrapSeeds((0, import_node_fs26.readFileSync)(manifestPath, "utf8"));
     const propagatable = manifest.seeds.filter(isPropagatableSeed);
     if (!o.target) {
       return fail(`bootstrap propagate: --target <path> is required \u2014 one of:
@@ -29464,9 +29631,9 @@ LIVE apply to ${repo}:
     const seed = propagatable.find((s) => s.target === o.target);
     if (!seed) return fail(`bootstrap propagate: --target '${o.target}' names no centrally propagatable seed in ${manifestPath}. Propagatable targets:
   ${propagatable.map((s) => s.target).join("\n  ")}`);
-    if (!seed.managedBlock && !(0, import_node_fs25.existsSync)(seed.target)) return fail(`bootstrap propagate: the Hub's own copy of '${seed.target}' is missing \u2014 nothing to propagate`);
-    const hubContent = seed.managedBlock ? null : (0, import_node_fs25.readFileSync)(seed.target, "utf8");
-    const readSeedFile2 = (path2) => (0, import_node_fs25.existsSync)(path2) ? (0, import_node_fs25.readFileSync)(path2, "utf8") : null;
+    if (!seed.managedBlock && !(0, import_node_fs26.existsSync)(seed.target)) return fail(`bootstrap propagate: the Hub's own copy of '${seed.target}' is missing \u2014 nothing to propagate`);
+    const hubContent = seed.managedBlock ? null : (0, import_node_fs26.readFileSync)(seed.target, "utf8");
+    const readSeedFile2 = (path2) => (0, import_node_fs26.existsSync)(path2) ? (0, import_node_fs26.readFileSync)(path2, "utf8") : null;
     const isWorkflowSeed = seed.target.startsWith(".github/workflows/");
     const cfg = await loadConfig();
     const projects = await fetchProjectsList(registryClientDeps(cfg));
@@ -29475,9 +29642,9 @@ LIVE apply to ${repo}:
     }
     const rosterRepos = collectRegistryRepos(projects).filter((r) => r.toLowerCase() !== "mutmutco/mmi-hub");
     let independentCount = rosterRepos.length;
-    if ((0, import_node_fs25.existsSync)("projects.json")) {
+    if ((0, import_node_fs26.existsSync)("projects.json")) {
       try {
-        const local = JSON.parse((0, import_node_fs25.readFileSync)("projects.json", "utf8"));
+        const local = JSON.parse((0, import_node_fs26.readFileSync)("projects.json", "utf8"));
         const localRepos = /* @__PURE__ */ new Set();
         for (const p of local.projects ?? []) for (const r of p.repos ?? []) {
           const full = (r.includes("/") ? r : `mutmutco/${r}`).toLowerCase();
@@ -29638,15 +29805,15 @@ LIVE apply to ${repo}:
         } catch {
           existingSha = void 0;
         }
-        const tmp = (0, import_node_path25.join)((0, import_node_os14.tmpdir)(), `mmi-propagate-${process.pid}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}.json`);
+        const tmp = (0, import_node_path26.join)((0, import_node_os14.tmpdir)(), `mmi-propagate-${process.pid}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}.json`);
         const desiredContent = desiredByRepo.get(rec.repo);
         if (desiredContent == null) return fail(`bootstrap propagate: no resolved content for ${rec.repo} ${seed.target} \u2014 refusing to write`);
-        (0, import_node_fs25.writeFileSync)(tmp, JSON.stringify(contentPutBody(seed.target, desiredContent, branch, existingSha)), "utf8");
+        (0, import_node_fs26.writeFileSync)(tmp, JSON.stringify(contentPutBody(seed.target, desiredContent, branch, existingSha)), "utf8");
         try {
           await gh(contentPutInputArgs(rec.repo, seed.target, tmp));
         } finally {
           try {
-            (0, import_node_fs25.unlinkSync)(tmp);
+            (0, import_node_fs26.unlinkSync)(tmp);
           } catch {
           }
         }
@@ -29713,10 +29880,10 @@ Rollback: \`mmi-cli devops bootstrap rollback ${rec.repo} --target ${seed.target
       return fail(`bootstrap rollback: ${e.message}`);
     }
     const manifestPath = "skills/bootstrap/seeds/manifest.json";
-    if (!(0, import_node_fs25.existsSync)(manifestPath)) return fail(`bootstrap rollback: ${manifestPath} not found; run from the MMI-Hub repo root \u2014 the manifest names which targets are org-owned and therefore propagated (and rollback-able)`);
+    if (!(0, import_node_fs26.existsSync)(manifestPath)) return fail(`bootstrap rollback: ${manifestPath} not found; run from the MMI-Hub repo root \u2014 the manifest names which targets are org-owned and therefore propagated (and rollback-able)`);
     const seedSource = await resolveHubSeedSource(execGitForSeedSource);
     if (!seedSource.ok) return fail(`bootstrap rollback: ${seedSource.reason}`);
-    const manifest = loadBootstrapSeeds((0, import_node_fs25.readFileSync)(manifestPath, "utf8"));
+    const manifest = loadBootstrapSeeds((0, import_node_fs26.readFileSync)(manifestPath, "utf8"));
     const propagatable = manifest.seeds.filter(isPropagatableSeed);
     if (!o.target) {
       return fail(`bootstrap rollback: --target <path> is required \u2014 one of:
@@ -29733,10 +29900,10 @@ Rollback: \`mmi-cli devops bootstrap rollback ${rec.repo} --target ${seed.target
     const enc = (p) => p.split("/").map(encodeURIComponent).join("/");
     let candidates;
     if (o.record) {
-      if (!(0, import_node_fs25.existsSync)(o.record)) return fail(`bootstrap rollback: --record '${o.record}' not found`);
+      if (!(0, import_node_fs26.existsSync)(o.record)) return fail(`bootstrap rollback: --record '${o.record}' not found`);
       let parsed;
       try {
-        parsed = JSON.parse((0, import_node_fs25.readFileSync)(o.record, "utf8"));
+        parsed = JSON.parse((0, import_node_fs26.readFileSync)(o.record, "utf8"));
       } catch (e) {
         return fail(`bootstrap rollback: --record '${o.record}' is not valid JSON: ${e.message}`);
       }
@@ -29813,13 +29980,13 @@ Rollback: \`mmi-cli devops bootstrap rollback ${rec.repo} --target ${seed.target
       } catch {
         existingSha = void 0;
       }
-      const tmp = (0, import_node_path25.join)((0, import_node_os14.tmpdir)(), `mmi-rollback-${process.pid}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}.json`);
-      (0, import_node_fs25.writeFileSync)(tmp, JSON.stringify(contentPutBody(seed.target, preSeedContent, plan.branch, existingSha)), "utf8");
+      const tmp = (0, import_node_path26.join)((0, import_node_os14.tmpdir)(), `mmi-rollback-${process.pid}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}.json`);
+      (0, import_node_fs26.writeFileSync)(tmp, JSON.stringify(contentPutBody(seed.target, preSeedContent, plan.branch, existingSha)), "utf8");
       try {
         await gh(contentPutInputArgs(repo, seed.target, tmp));
       } finally {
         try {
-          (0, import_node_fs25.unlinkSync)(tmp);
+          (0, import_node_fs26.unlinkSync)(tmp);
         } catch {
         }
       }
@@ -30886,7 +31053,7 @@ function renderDeployPortDoctor(report) {
 init_cli_shared();
 
 // src/wave-status.ts
-var import_node_fs28 = require("node:fs");
+var import_node_fs29 = require("node:fs");
 
 // src/git-worktree-observation.ts
 function parseGitWorktreePorcelain(text) {
@@ -30917,8 +31084,8 @@ function deriveComposeProjectName(worktreePath) {
 
 // src/stage-runner.ts
 var import_node_child_process10 = require("node:child_process");
-var import_node_fs27 = require("node:fs");
-var import_node_path27 = require("node:path");
+var import_node_fs28 = require("node:fs");
+var import_node_path28 = require("node:path");
 var import_node_net = require("node:net");
 var import_node_util5 = require("node:util");
 
@@ -30928,8 +31095,8 @@ function normalizeEol2(s) {
 }
 
 // src/env-detection.ts
-var import_node_fs26 = require("node:fs");
-var import_node_path26 = require("node:path");
+var import_node_fs27 = require("node:fs");
+var import_node_path27 = require("node:path");
 var SKIPPED_DIRS = /* @__PURE__ */ new Set([".git", "node_modules", "dist", ".jerv", ".pi", ".venv", "venv"]);
 function isEnvBaseName(name) {
   return name.toLowerCase() === ".env";
@@ -30939,7 +31106,7 @@ function findEnvFiles(root) {
   const walk2 = (dir, rel) => {
     let entries;
     try {
-      entries = (0, import_node_fs26.readdirSync)(dir, { withFileTypes: true });
+      entries = (0, import_node_fs27.readdirSync)(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -30947,13 +31114,13 @@ function findEnvFiles(root) {
       const relPath = rel ? `${rel}/${entry.name}` : entry.name;
       if (entry.isDirectory()) {
         if (SKIPPED_DIRS.has(entry.name)) continue;
-        walk2((0, import_node_path26.join)(dir, entry.name), relPath);
+        walk2((0, import_node_path27.join)(dir, entry.name), relPath);
         continue;
       }
       if (isEnvBaseName(entry.name)) {
         let isDir = false;
         try {
-          isDir = (0, import_node_fs26.lstatSync)((0, import_node_path26.join)(dir, entry.name)).isDirectory();
+          isDir = (0, import_node_fs27.lstatSync)((0, import_node_path27.join)(dir, entry.name)).isDirectory();
         } catch {
         }
         if (!isDir) found.push(relPath);
@@ -31015,12 +31182,12 @@ var DOCKER_TIMEOUT_MS = 15e3;
 function stageBash() {
   if (process.platform !== "win32") return "bash";
   const configured = process.env.SHELL;
-  if (configured && (0, import_node_path27.isAbsolute)(configured) && /[/\\]bash(?:\.exe)?$/i.test(configured) && !/[/\\](?:System32|Sysnative)[/\\]bash(?:\.exe)?$/i.test(configured) && (0, import_node_fs27.existsSync)(configured)) return configured;
+  if (configured && (0, import_node_path28.isAbsolute)(configured) && /[/\\]bash(?:\.exe)?$/i.test(configured) && !/[/\\](?:System32|Sysnative)[/\\]bash(?:\.exe)?$/i.test(configured) && (0, import_node_fs28.existsSync)(configured)) return configured;
   const candidates = [
-    (0, import_node_path27.join)(process.env.ProgramFiles || "C:\\Program Files", "Git", "bin", "bash.exe"),
-    ...process.env.LOCALAPPDATA ? [(0, import_node_path27.join)(process.env.LOCALAPPDATA, "Programs", "Git", "bin", "bash.exe")] : []
+    (0, import_node_path28.join)(process.env.ProgramFiles || "C:\\Program Files", "Git", "bin", "bash.exe"),
+    ...process.env.LOCALAPPDATA ? [(0, import_node_path28.join)(process.env.LOCALAPPDATA, "Programs", "Git", "bin", "bash.exe")] : []
   ];
-  const bash = candidates.find((path2) => (0, import_node_fs27.existsSync)(path2));
+  const bash = candidates.find((path2) => (0, import_node_fs28.existsSync)(path2));
   if (!bash) throw new Error("Local stages require Git Bash on Windows. Install Git for Windows or set SHELL to its absolute bash.exe path.");
   return bash;
 }
@@ -31151,7 +31318,7 @@ function appendForceRecreate(up) {
   return `${up.trimEnd()} --force-recreate`;
 }
 function stageStatePath(cwd = process.cwd()) {
-  return (0, import_node_path27.join)(cwd, "tmp", "stage", "state.json");
+  return (0, import_node_path28.join)(cwd, "tmp", "stage", "state.json");
 }
 function normPath(path2) {
   return path2.replace(/\\/g, "/").replace(/\/+$/, "").toLowerCase();
@@ -31368,8 +31535,8 @@ function stageProcessEnv(stagePort, extraEnv) {
 }
 function composeResolvesPort(cwd) {
   if (process.env.PORT) return true;
-  const envFile = (0, import_node_path27.join)(cwd, ".env");
-  return (0, import_node_fs27.existsSync)(envFile) && envFileKeys((0, import_node_fs27.readFileSync)(envFile, "utf8")).has("PORT");
+  const envFile = (0, import_node_path28.join)(cwd, ".env");
+  return (0, import_node_fs28.existsSync)(envFile) && envFileKeys((0, import_node_fs28.readFileSync)(envFile, "utf8")).has("PORT");
 }
 function stageComposeEnv(config, stagePort, vaultEnvMerge, cwd) {
   return {
@@ -31382,13 +31549,13 @@ function stageComposeEnv(config, stagePort, vaultEnvMerge, cwd) {
 function stageComposeFiles(cwd) {
   const files = ["docker-compose.yml"];
   for (const conventional of ["docker-compose.override.yml", "docker-compose.override.yaml"]) {
-    if ((0, import_node_fs27.existsSync)((0, import_node_path27.join)(cwd, conventional))) files.push(conventional);
+    if ((0, import_node_fs28.existsSync)((0, import_node_path28.join)(cwd, conventional))) files.push(conventional);
   }
   return [...files, RUNTIME_ENV_OVERRIDE_RELPATH];
 }
 async function prepareRuntimeEnvPassthrough(cwd, composeEnv, vaultEnvMerge) {
   const keys = Object.keys(vaultEnvMerge ?? {});
-  if (!keys.length || !(0, import_node_fs27.existsSync)((0, import_node_path27.join)(cwd, "docker-compose.yml"))) return {};
+  if (!keys.length || !(0, import_node_fs28.existsSync)((0, import_node_path28.join)(cwd, "docker-compose.yml"))) return {};
   let configJson;
   try {
     const { stdout } = await execFileP3("docker", ["compose", "config", "--format", "json"], {
@@ -31404,21 +31571,21 @@ async function prepareRuntimeEnvPassthrough(cwd, composeEnv, vaultEnvMerge) {
   }
   const body = renderRuntimeEnvOverride(runtimeEnvMarkedServices(configJson), keys);
   if (!body) return {};
-  const overridePath = (0, import_node_path27.join)(cwd, RUNTIME_ENV_OVERRIDE_RELPATH);
-  (0, import_node_fs27.mkdirSync)((0, import_node_path27.join)(cwd, "tmp", "stage"), { recursive: true });
-  (0, import_node_fs27.writeFileSync)(overridePath, body, "utf8");
+  const overridePath = (0, import_node_path28.join)(cwd, RUNTIME_ENV_OVERRIDE_RELPATH);
+  (0, import_node_fs28.mkdirSync)((0, import_node_path28.join)(cwd, "tmp", "stage"), { recursive: true });
+  (0, import_node_fs28.writeFileSync)(overridePath, body, "utf8");
   return stageComposeFileEnv(stageComposeFiles(cwd));
 }
 async function ensureStageRuntimeEnv(config, opts, cwd) {
   if (!config.ensureEnv) return;
-  const target = (0, import_node_path27.join)(cwd, config.ensureEnv.target);
-  const example = (0, import_node_path27.join)(cwd, config.ensureEnv.example);
-  if (!(0, import_node_fs27.existsSync)(target) && (0, import_node_fs27.existsSync)(example)) {
-    (0, import_node_fs27.copyFileSync)(example, target);
-  } else if ((0, import_node_fs27.existsSync)(target) && (0, import_node_fs27.existsSync)(example)) {
-    const stale = detectStaleEnvFile((0, import_node_fs27.readFileSync)(example, "utf8"), (0, import_node_fs27.readFileSync)(target, "utf8"), {
-      exampleMtimeMs: (0, import_node_fs27.statSync)(example).mtimeMs,
-      targetMtimeMs: (0, import_node_fs27.statSync)(target).mtimeMs
+  const target = (0, import_node_path28.join)(cwd, config.ensureEnv.target);
+  const example = (0, import_node_path28.join)(cwd, config.ensureEnv.example);
+  if (!(0, import_node_fs28.existsSync)(target) && (0, import_node_fs28.existsSync)(example)) {
+    (0, import_node_fs28.copyFileSync)(example, target);
+  } else if ((0, import_node_fs28.existsSync)(target) && (0, import_node_fs28.existsSync)(example)) {
+    const stale = detectStaleEnvFile((0, import_node_fs28.readFileSync)(example, "utf8"), (0, import_node_fs28.readFileSync)(target, "utf8"), {
+      exampleMtimeMs: (0, import_node_fs28.statSync)(example).mtimeMs,
+      targetMtimeMs: (0, import_node_fs28.statSync)(target).mtimeMs
     });
     if (stale) {
       const msg = `stale ${config.ensureEnv.target} (${stale}) \u2014 delete it or refresh from ${config.ensureEnv.example} before re-running /stage`;
@@ -31426,8 +31593,8 @@ async function ensureStageRuntimeEnv(config, opts, cwd) {
       console.error(`mmi-cli stage: ${msg} (allowed via --allow-stale-env)`);
     }
   }
-  if (opts.vaultEnvMerge && Object.keys(opts.vaultEnvMerge).length && (0, import_node_fs27.existsSync)(target)) {
-    (0, import_node_fs27.writeFileSync)(target, mergeEnvSecretsIntoFile((0, import_node_fs27.readFileSync)(target, "utf8"), opts.vaultEnvMerge), "utf8");
+  if (opts.vaultEnvMerge && Object.keys(opts.vaultEnvMerge).length && (0, import_node_fs28.existsSync)(target)) {
+    (0, import_node_fs28.writeFileSync)(target, mergeEnvSecretsIntoFile((0, import_node_fs28.readFileSync)(target, "utf8"), opts.vaultEnvMerge), "utf8");
   }
 }
 async function gitText(cwd, args) {
@@ -31457,20 +31624,20 @@ async function resolveGlobalStatePath(cwd, explicit) {
   return void 0;
 }
 function readState(path2) {
-  if (!(0, import_node_fs27.existsSync)(path2)) return null;
+  if (!(0, import_node_fs28.existsSync)(path2)) return null;
   try {
-    return JSON.parse((0, import_node_fs27.readFileSync)(path2, "utf8"));
+    return JSON.parse((0, import_node_fs28.readFileSync)(path2, "utf8"));
   } catch {
     return null;
   }
 }
 function mkdirFor(path2) {
   const dir = path2.slice(0, Math.max(path2.lastIndexOf("/"), path2.lastIndexOf("\\")));
-  (0, import_node_fs27.mkdirSync)(dir, { recursive: true });
+  (0, import_node_fs28.mkdirSync)(dir, { recursive: true });
 }
 function writeState(path2, state) {
   mkdirFor(path2);
-  (0, import_node_fs27.writeFileSync)(path2, JSON.stringify(state, null, 2), "utf8");
+  (0, import_node_fs28.writeFileSync)(path2, JSON.stringify(state, null, 2), "utf8");
 }
 function writeStagePortReservation(port, cwd, statePath, globalStatePath, now) {
   const reservation = {
@@ -31499,7 +31666,7 @@ async function cleanupStageState(state, paths, timeoutMs, fallbackCwd, currentEn
     );
   }
   for (const path2 of [...new Set(paths.filter((p) => Boolean(p)))]) {
-    (0, import_node_fs27.rmSync)(path2, { force: true });
+    (0, import_node_fs28.rmSync)(path2, { force: true });
   }
 }
 async function killTree(pid) {
@@ -31686,8 +31853,8 @@ async function runStage(config = {}, opts = {}) {
       });
     }
   } catch (e) {
-    (0, import_node_fs27.rmSync)(statePath, { force: true });
-    if (globalStatePath && globalStatePath !== statePath) (0, import_node_fs27.rmSync)(globalStatePath, { force: true });
+    (0, import_node_fs28.rmSync)(statePath, { force: true });
+    if (globalStatePath && globalStatePath !== statePath) (0, import_node_fs28.rmSync)(globalStatePath, { force: true });
     throw e;
   }
   const started = await startStage(config, {
@@ -31704,9 +31871,9 @@ async function runStage(config = {}, opts = {}) {
 // src/wave-status.ts
 function readStageSummary(worktreePath) {
   const statePath = stageStatePath(worktreePath);
-  if (!(0, import_node_fs28.existsSync)(statePath)) return void 0;
+  if (!(0, import_node_fs29.existsSync)(statePath)) return void 0;
   try {
-    const state = JSON.parse((0, import_node_fs28.readFileSync)(statePath, "utf8"));
+    const state = JSON.parse((0, import_node_fs29.readFileSync)(statePath, "utf8"));
     const port = typeof state.port === "number" ? state.port : void 0;
     if (port == null || !Number.isInteger(port) || port <= 0) return void 0;
     return { port, url: typeof state.url === "string" ? state.url : void 0 };
@@ -31763,9 +31930,9 @@ async function collectWaveStatus(deps) {
 // src/discovery-commands.ts
 init_github_client();
 init_cli_shared();
-var import_node_fs29 = require("node:fs");
+var import_node_fs30 = require("node:fs");
 var import_node_os15 = require("node:os");
-var import_node_path28 = require("node:path");
+var import_node_path29 = require("node:path");
 var GC_GH_TIMEOUT_MS = 2e4;
 async function collectStatus() {
   const repo = await resolveRepo();
@@ -31955,8 +32122,8 @@ async function collectOnboardStatus(opts = {}) {
   }
   const home = (0, import_node_os15.homedir)();
   const plugin = onboardPluginGate({
-    readKnown: () => readFileSyncSafe((0, import_node_path28.join)(home, ...KNOWN_MARKETPLACES_RELATIVE), import_node_fs29.readFileSync),
-    readSettings: () => readFileSyncSafe((0, import_node_path28.join)(home, ".claude", "settings.json"), import_node_fs29.readFileSync)
+    readKnown: () => readFileSyncSafe((0, import_node_path29.join)(home, ...KNOWN_MARKETPLACES_RELATIVE), import_node_fs30.readFileSync),
+    readSettings: () => readFileSyncSafe((0, import_node_path29.join)(home, ".claude", "settings.json"), import_node_fs30.readFileSync)
   });
   return {
     guide: "Read the MMI org-guide skill before project work; load only the relevant topic. Use mmi-help for a short introduction.",
@@ -33973,7 +34140,7 @@ function parseOriginRepo(remoteUrl) {
 init_github_client();
 
 // src/issue-commands.ts
-var import_node_fs30 = require("node:fs");
+var import_node_fs31 = require("node:fs");
 var import_node_crypto10 = require("node:crypto");
 init_cli_shared();
 init_clean_exit();
@@ -34230,7 +34397,7 @@ async function editIssue(client, options, deps = {}) {
   const url = `https://github.com/${repo}/issues/${parsed.number}`;
   const patch = {};
   let bodyChanged = false;
-  const textDeps = () => deps.textDeps ?? { readFile: (p, e) => Promise.resolve((0, import_node_fs30.readFileSync)(p, e)), readStdin: () => Promise.resolve("") };
+  const textDeps = () => deps.textDeps ?? { readFile: (p, e) => Promise.resolve((0, import_node_fs31.readFileSync)(p, e)), readStdin: () => Promise.resolve("") };
   if (options.titleFile !== void 0) {
     patch.title = await resolveIssueTitle({ title: options.title, titleFile: options.titleFile }, textDeps());
   } else if (options.title !== void 0) {
@@ -34886,7 +35053,7 @@ function extendCreateCommand(issue, batchAttach) {
     if (opts.batch) {
       let specs;
       try {
-        const raw = (0, import_node_fs30.readFileSync)(opts.batch, "utf8");
+        const raw = (0, import_node_fs31.readFileSync)(opts.batch, "utf8");
         specs = JSON.parse(raw);
         if (!Array.isArray(specs)) {
           const top = specs === null ? "null" : typeof specs === "object" ? `an object with keys: ${Object.keys(specs).join(", ") || "(none)"}` : `a ${typeof specs}`;
@@ -36050,8 +36217,8 @@ function registerPrLifecycleCommands(program3) {
 }
 
 // src/project-info-sync.ts
-var import_node_fs31 = require("node:fs");
-var import_node_path29 = require("node:path");
+var import_node_fs32 = require("node:fs");
+var import_node_path30 = require("node:path");
 var UPDATE_PROJECT_INFO = `mutation($projectId: ID!, $shortDescription: String!, $readme: String!) {
   updateProjectV2(input: { projectId: $projectId, shortDescription: $shortDescription, readme: $readme }) {
     projectV2 { id }
@@ -36098,14 +36265,14 @@ function sharedName(entries, fallback) {
 }
 function buildProjectInfoSyncPlan(targetRepo2, project2, projects, repoRoot2) {
   if (!project2.projectId) throw new Error(`org project sync-info: ${targetRepo2} registry META has no projectId`);
-  const readmePath = (0, import_node_path29.join)(repoRoot2, "README.md");
-  if (!(0, import_node_fs31.existsSync)(readmePath)) throw new Error(`org project sync-info: ${targetRepo2} has no README.md`);
+  const readmePath = (0, import_node_path30.join)(repoRoot2, "README.md");
+  if (!(0, import_node_fs32.existsSync)(readmePath)) throw new Error(`org project sync-info: ${targetRepo2} has no README.md`);
   const entries = entriesFor(project2, projects);
   const memberRepos = [...new Set(entries.flatMap((entry) => entry.repos ?? []))].filter((repo) => /^[^/]+\/[^/]+$/.test(repo)).sort((a, b) => a.localeCompare(b));
   const projectName = sharedName(entries, project2.name?.trim() || targetRepo2.split("/").pop() || targetRepo2);
   if (!memberRepos.length) throw new Error(`org project sync-info: project ${projectName} has no registered member repos`);
   const entryNames = entries.map((entry) => entry.name?.trim()).filter((name) => Boolean(name));
-  const shortDescription = memberRepos.length === 1 ? shortDescriptionFromReadme((0, import_node_fs31.readFileSync)(readmePath, "utf8")) : `Shared work across ${new Intl.ListFormat("en", { type: "conjunction" }).format(entryNames)}.`;
+  const shortDescription = memberRepos.length === 1 ? shortDescriptionFromReadme((0, import_node_fs32.readFileSync)(readmePath, "utf8")) : `Shared work across ${new Intl.ListFormat("en", { type: "conjunction" }).format(entryNames)}.`;
   const lines2 = [
     `# ${projectName}`,
     "",
@@ -36124,8 +36291,8 @@ function buildProjectInfoSyncPlan(targetRepo2, project2, projects, repoRoot2) {
   const targetBase = `https://github.com/${targetRepo2}`;
   const targetBranch = branchFor(targetRepo2, projects);
   const orgDocs = [
-    (0, import_node_fs31.existsSync)((0, import_node_path29.join)(repoRoot2, "architecture.md")) ? `- [Hub architecture](${targetBase}/blob/${targetBranch}/architecture.md)` : "",
-    (0, import_node_fs31.existsSync)((0, import_node_path29.join)(repoRoot2, "docs", "Architecture", "agentic-dev-environment.md")) ? `- [Agentic development environment](${targetBase}/blob/${targetBranch}/docs/Architecture/agentic-dev-environment.md)` : ""
+    (0, import_node_fs32.existsSync)((0, import_node_path30.join)(repoRoot2, "architecture.md")) ? `- [Hub architecture](${targetBase}/blob/${targetBranch}/architecture.md)` : "",
+    (0, import_node_fs32.existsSync)((0, import_node_path30.join)(repoRoot2, "docs", "Architecture", "agentic-dev-environment.md")) ? `- [Agentic development environment](${targetBase}/blob/${targetBranch}/docs/Architecture/agentic-dev-environment.md)` : ""
   ].filter(Boolean);
   if (orgDocs.length) lines2.push("", "## Organisation docs", "", ...orgDocs);
   return { projectId: project2.projectId, projectName, targetRepo: targetRepo2, memberRepos, shortDescription, readme: `${lines2.join("\n")}
@@ -36507,8 +36674,8 @@ function registerSchedulesCommands(program3) {
 }
 
 // src/secrets-commands.ts
-var import_node_fs32 = require("node:fs");
-var import_node_path30 = require("node:path");
+var import_node_fs33 = require("node:fs");
+var import_node_path31 = require("node:path");
 var import_node_os17 = require("node:os");
 init_cli_shared();
 init_hub_auth();
@@ -36614,18 +36781,18 @@ function collectMap(value, previous = []) {
   return [...previous, value];
 }
 async function decryptRailsCredentials(input) {
-  const appDir = (0, import_node_path30.resolve)(input.appDir ?? process.cwd());
+  const appDir = (0, import_node_path31.resolve)(input.appDir ?? process.cwd());
   const credentialsFile = input.credentialsFile ?? DEFAULT_RAILS_CREDENTIALS_FILE;
   const masterKeyFile = input.masterKeyFile ?? DEFAULT_RAILS_MASTER_KEY_FILE;
-  const credentialsPath = (0, import_node_path30.resolve)(appDir, credentialsFile);
-  const masterKeyPath = (0, import_node_path30.resolve)(appDir, masterKeyFile);
+  const credentialsPath = (0, import_node_path31.resolve)(appDir, credentialsFile);
+  const masterKeyPath = (0, import_node_path31.resolve)(appDir, masterKeyFile);
   const env = {
     ...process.env,
     MMI_RAILS_CREDENTIALS_FILE: credentialsPath,
     MMI_RAILS_MASTER_KEY_FILE: masterKeyPath
   };
-  if ((0, import_node_fs32.existsSync)(masterKeyPath)) {
-    env.RAILS_MASTER_KEY = (0, import_node_fs32.readFileSync)(masterKeyPath, "utf8").trim();
+  if ((0, import_node_fs33.existsSync)(masterKeyPath)) {
+    env.RAILS_MASTER_KEY = (0, import_node_fs33.readFileSync)(masterKeyPath, "utf8").trim();
   }
   const script = [
     'require "json"',
@@ -36635,9 +36802,9 @@ async function decryptRailsCredentials(input) {
     'config = ActiveSupport::EncryptedConfiguration.new(config_path: config_path, key_path: key_path, env_key: "RAILS_MASTER_KEY", raise_if_missing_key: true)',
     "puts JSON.generate(config.config)"
   ].join("\n");
-  const scriptDir = (0, import_node_fs32.mkdtempSync)((0, import_node_path30.join)((0, import_node_os17.tmpdir)(), "mmi-rails-decrypt-"));
-  const scriptPath = (0, import_node_path30.join)(scriptDir, "decrypt.rb");
-  (0, import_node_fs32.writeFileSync)(scriptPath, script, "utf8");
+  const scriptDir = (0, import_node_fs33.mkdtempSync)((0, import_node_path31.join)((0, import_node_os17.tmpdir)(), "mmi-rails-decrypt-"));
+  const scriptPath = (0, import_node_path31.join)(scriptDir, "decrypt.rb");
+  (0, import_node_fs33.writeFileSync)(scriptPath, script, "utf8");
   try {
     const args = ["exec", "ruby", scriptPath];
     const cmd = process.platform === "win32" ? "cmd.exe" : "bundle";
@@ -36649,7 +36816,7 @@ async function decryptRailsCredentials(input) {
     });
     return JSON.parse(stdout);
   } finally {
-    (0, import_node_fs32.rmSync)(scriptDir, { recursive: true, force: true });
+    (0, import_node_fs33.rmSync)(scriptDir, { recursive: true, force: true });
   }
 }
 async function readSecretStdin() {
@@ -36739,7 +36906,7 @@ function registerSecretsCommands(program3) {
     let body;
     if (o.file) {
       try {
-        body = (0, import_node_fs32.readFileSync)((0, import_node_path30.resolve)(o.file), "utf8");
+        body = (0, import_node_fs33.readFileSync)((0, import_node_path31.resolve)(o.file), "utf8");
       } catch (e) {
         return fail(`secrets org-catalog: cannot read --file ${o.file}: ${e.message}`);
       }
@@ -36871,7 +37038,7 @@ function registerSecretsCommands(program3) {
       {
         ...d,
         decryptRailsCredentials,
-        removeFile: (path2) => (0, import_node_fs32.unlinkSync)((0, import_node_path30.resolve)(o.appDir ?? process.cwd(), path2))
+        removeFile: (path2) => (0, import_node_fs33.unlinkSync)((0, import_node_path31.resolve)(o.appDir ?? process.cwd(), path2))
       },
       {
         repo: o.repo,
@@ -37034,8 +37201,8 @@ function registerSessionReport(program3) {
 }
 
 // src/stage-commands.ts
-var import_node_fs33 = require("node:fs");
-var import_node_path31 = require("node:path");
+var import_node_fs34 = require("node:fs");
+var import_node_path32 = require("node:path");
 init_cli_shared();
 init_clean_exit();
 
@@ -37281,8 +37448,8 @@ function registerStageCommands(program3) {
     return {
       resolution: decideStage({
         registry: { deployModel: project2?.deployModel, portRange, error: read.ok ? void 0 : read.error },
-        hasCompose: (0, import_node_fs33.existsSync)((0, import_node_path31.join)(process.cwd(), "docker-compose.yml")),
-        hasEnvExample: (0, import_node_fs33.existsSync)((0, import_node_path31.join)(process.cwd(), ".env.example")),
+        hasCompose: (0, import_node_fs34.existsSync)((0, import_node_path32.join)(process.cwd(), "docker-compose.yml")),
+        hasEnvExample: (0, import_node_fs34.existsSync)((0, import_node_path32.join)(process.cwd(), ".env.example")),
         repo
       }),
       project: project2,
@@ -37566,19 +37733,19 @@ vercel preview (${preview.branch}): ${d.state}${d.url ? ` \u2014 ${d.url}` : ""}
 
 // src/tenant-artifact.ts
 var import_node_crypto11 = require("node:crypto");
-var import_node_fs34 = require("node:fs");
+var import_node_fs35 = require("node:fs");
 var import_promises6 = require("node:fs/promises");
-var import_node_path32 = require("node:path");
+var import_node_path33 = require("node:path");
 var ARTIFACT_ID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
 var MAX_BYTES = 5 * 1024 * 1024 * 1024;
 async function sha256File(path2) {
   const hash = (0, import_node_crypto11.createHash)("sha256");
-  for await (const chunk of (0, import_node_fs34.createReadStream)(path2)) hash.update(chunk);
+  for await (const chunk of (0, import_node_fs35.createReadStream)(path2)) hash.update(chunk);
   return hash.digest("hex");
 }
 async function putTenantArtifact(repo, stage, inputPath, deps) {
   if (!["dev", "rc", "main"].includes(stage)) throw new Error("tenant artifact put: <stage> must be dev, rc, or main");
-  const path2 = (0, import_node_path32.resolve)(inputPath);
+  const path2 = (0, import_node_path33.resolve)(inputPath);
   const info = await (0, import_promises6.stat)(path2);
   if (!info.isFile()) throw new Error("tenant artifact put: input path must be a file");
   if (!Number.isSafeInteger(info.size) || info.size < 1 || info.size > MAX_BYTES) throw new Error(`tenant artifact put: file must be 1..${MAX_BYTES} bytes`);
@@ -37596,7 +37763,7 @@ async function putTenantArtifact(repo, stage, inputPath, deps) {
     return [key, value];
   }));
   headers["content-length"] = String(info.size);
-  const stream = (0, import_node_fs34.createReadStream)(path2);
+  const stream = (0, import_node_fs35.createReadStream)(path2);
   let uploaded;
   try {
     uploaded = await fetch(body.uploadUrl, {
@@ -37736,7 +37903,7 @@ function renderVerifySecrets(body) {
 
 // src/command-register-collaboration.ts
 var import_node_child_process15 = require("node:child_process");
-var import_node_fs41 = require("node:fs");
+var import_node_fs42 = require("node:fs");
 var import_promises7 = require("node:fs/promises");
 init_clean_exit();
 init_cli_shared();
@@ -37760,7 +37927,7 @@ function spawnDetachedSelf(args, deps, opts = {}) {
 }
 
 // src/command-register-collaboration.ts
-var import_node_path39 = require("node:path");
+var import_node_path40 = require("node:path");
 
 // src/attach-to-project.ts
 async function attachViaHubApp(cfg, contentNodeId) {
@@ -37851,6 +38018,9 @@ function prHeadBehindBase(input) {
 function prHeadUpdateRemedy(head, base) {
   return `git fetch origin ${base} && git merge origin/${base} (on ${head}), resolve the conflicts, push, then rerun \u2014 docs/Guides/train-troubleshooting.md#head-behind-base`;
 }
+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`;
+}
 var PROTECTED_PR_HEAD_BRANCHES = ["main", "master", "development", "rc"];
 function isProtectedPrHead(head) {
   return PROTECTED_PR_HEAD_BRANCHES.includes(head);
@@ -37946,8 +38116,9 @@ async function readGhPrStateWithRetry(fetchState, options) {
   return { ok: false, error: lastError };
 }
 async function runPrLand(prNumber, options, deps) {
-  const repo = await deps.resolveRepo(prNumber, options.repo);
-  const base = { status: "failed", repo, pr: prNumber };
+  const resolved = await deps.resolveRepo(prNumber, options.repo);
+  const { repo } = resolved;
+  const base = { status: "failed", repo, pr: prNumber, base: resolved.base };
   if (options.requireTrain !== false) {
     const verdict = await deps.fetchTrainAuthority(repo);
     if (!verdict.ok) {
@@ -37999,12 +38170,21 @@ async function runPrLand(prNumber, options, deps) {
     return { ...base, error: merge.error ?? "merge failed" };
   }
   if (merge.mergeStatus === "merged") {
-    return { ...base, status: "merged" };
+    return {
+      ...base,
+      status: "merged",
+      branchFinality: prLandedBranchFinality(prNumber, resolved.base)
+    };
   }
   const now = deps.now ?? (() => Date.now());
   const merged = await deps.pollMerged(prNumber, repo, now() + PR_LAND_ENQUEUE_TIMEOUT_MS);
   if (merged) {
-    return { ...base, status: "auto-merge-enqueued-then-merged", mergeStatus: "merged" };
+    return {
+      ...base,
+      status: "auto-merge-enqueued-then-merged",
+      mergeStatus: "merged",
+      branchFinality: prLandedBranchFinality(prNumber, resolved.base)
+    };
   }
   return {
     ...base,
@@ -38016,8 +38196,8 @@ async function runPrLand(prNumber, options, deps) {
 init_github_client();
 
 // src/merge-cleanup.ts
-var import_node_fs36 = require("node:fs");
-var import_node_path34 = require("node:path");
+var import_node_fs37 = require("node:fs");
+var import_node_path35 = require("node:path");
 var import_node_os18 = require("node:os");
 init_cli_shared();
 init_github_client();
@@ -38126,8 +38306,8 @@ function boardAdvanceFailureMessage(result) {
 
 // src/test-policy-core.ts
 var import_node_child_process12 = require("node:child_process");
-var import_node_fs35 = require("node:fs");
-var import_node_path33 = require("node:path");
+var import_node_fs36 = require("node:fs");
+var import_node_path34 = require("node:path");
 
 // src/test-command-policy-shared.mjs
 var import_node_child_process11 = require("node:child_process");
@@ -38603,7 +38783,7 @@ function isMeaningfulRow(file) {
   return file.meaningful !== false;
 }
 function loadPolicy(root, readFile9 = readFileOrNull2) {
-  const raw = readFile9((0, import_node_path33.join)(root, POLICY_FILE));
+  const raw = readFile9((0, import_node_path34.join)(root, POLICY_FILE));
   if (raw == null) return { mandatory: [], declared: false };
   return parsePolicy(raw, POLICY_FILE);
 }
@@ -38680,7 +38860,7 @@ function loadPolicySource(root, explicitRef, diffBase) {
 }
 function readFileOrNull2(path2) {
   try {
-    return (0, import_node_fs35.readFileSync)(path2, "utf8");
+    return (0, import_node_fs36.readFileSync)(path2, "utf8");
   } catch {
     return null;
   }
@@ -38708,12 +38888,12 @@ function classify(changed, policy, present = () => false) {
   const removedProtected = [...removed].filter((p) => protectedBy.has(p)).map((p) => ({ path: p, why: protectedBy.get(p) ?? "" }));
   return { mandatoryHits, untestedHits, testChanges, meaningfulTestChanges, addedTests, removedProtected };
 }
-function unresolvedProtectedEntries(policy, root, exists = (path2) => (0, import_node_fs35.existsSync)(path2)) {
-  return (policy.protected ?? []).map((p) => p.path).filter((p) => !exists((0, import_node_path33.join)(root, p)));
+function unresolvedProtectedEntries(policy, root, exists = (path2) => (0, import_node_fs36.existsSync)(path2)) {
+  return (policy.protected ?? []).map((p) => p.path).filter((p) => !exists((0, import_node_path34.join)(root, p)));
 }
-function unresolvedSatisfiers(policy, root, exists = (path2) => (0, import_node_fs35.existsSync)(path2)) {
+function unresolvedSatisfiers(policy, root, exists = (path2) => (0, import_node_fs36.existsSync)(path2)) {
   const declared = (policy.mandatory ?? []).flatMap((m) => m.satisfiedBy ?? []);
-  return [...new Set(declared)].filter((p) => !exists((0, import_node_path33.join)(root, p)));
+  return [...new Set(declared)].filter((p) => !exists((0, import_node_path34.join)(root, p)));
 }
 function evaluate(changed, policy, present = () => false) {
   const { mandatoryHits, untestedHits, meaningfulTestChanges, addedTests, removedProtected } = classify(changed, policy, present);
@@ -38852,14 +39032,14 @@ function runTestPolicy(root, deps = {}) {
   }
   const loaded = deps.policy ? { policy: deps.policy, source: { ref: null, sha: null, path: POLICY_FILE } } : loadPolicySource(root, deps.policyRef, deps.base);
   const { policy, source: policySource } = loaded;
-  const exists = deps.exists ?? ((path2) => (0, import_node_fs35.existsSync)(path2));
+  const exists = deps.exists ?? ((path2) => (0, import_node_fs36.existsSync)(path2));
   const counts = { mandatoryCount: (policy.mandatory ?? []).length, protectedCount: (policy.protected ?? []).length };
   const base = deps.changed ? "(injected)" : deps.policyRef ? resolveHotfixBase(root) : resolveBase(root, deps.base);
   const refusal = deps.changed ? null : untrustworthyRange(root, base);
   const raw = deps.changed ?? (refusal ? [] : changedFilesSince(base, root));
   const changed = deps.changed ? raw : annotateChangeMeaning(raw, policy, (path2) => ({
     before: blobAt(base, path2, root),
-    after: readFileOrNull2((0, import_node_path33.join)(root, path2))
+    after: readFileOrNull2((0, import_node_path34.join)(root, path2))
   }));
   const lookup = deps.override !== void 0 ? { override: deps.override, refusals: [] } : !deps.changed && !refusal ? readOverride2(base, root) : { override: null, refusals: [] };
   const policyRefusals = policy.declared === false ? [{
@@ -38869,8 +39049,8 @@ function runTestPolicy(root, deps = {}) {
   A gate with no policy cannot decide which test commands are required or permitted.
 ` + (deps.base === HOTFIX_DIFF_BASE ? `  Hotfix lane (--base ${HOTFIX_DIFF_BASE}): pass --policy-ref <exact-${HOTFIX_POLICY_REF}-commit> so the current policy is read from ${HOTFIX_POLICY_REF}.` : `  Restore ${POLICY_FILE} on this branch; the policy file belongs on every non-hotfix lane.`)
   }] : [];
-  const present = (path2) => exists((0, import_node_path33.join)(root, path2));
-  const policyTree = policySource.sha ? new Set(git2(["ls-tree", "-r", "-z", "--name-only", policySource.sha], root).split("\0").filter(Boolean).map((p) => (0, import_node_path33.join)(root, p))) : null;
+  const present = (path2) => exists((0, import_node_path34.join)(root, path2));
+  const policyTree = policySource.sha ? new Set(git2(["ls-tree", "-r", "-z", "--name-only", policySource.sha], root).split("\0").filter(Boolean).map((p) => (0, import_node_path34.join)(root, p))) : null;
   const policyTreeExists = policyTree ? (abs) => policyTree.has(abs) : exists;
   const where = policySource.sha ? `${policySource.ref}@${policySource.sha}` : "this worktree";
   const removedByThisDiff = removedPaths(changed);
@@ -39088,13 +39268,13 @@ function resolveSquashMergeBodyText(commits, allowedClosing, cwd) {
   return rewritten === base ? null : rewritten;
 }
 function writeSquashBodyFile(body) {
-  const dir = (0, import_node_fs36.mkdtempSync)((0, import_node_path34.join)((0, import_node_os18.tmpdir)(), "mmi-squash-body-"));
-  const path2 = (0, import_node_path34.join)(dir, "body.txt");
-  (0, import_node_fs36.writeFileSync)(path2, body.endsWith("\n") ? body : `${body}
+  const dir = (0, import_node_fs37.mkdtempSync)((0, import_node_path35.join)((0, import_node_os18.tmpdir)(), "mmi-squash-body-"));
+  const path2 = (0, import_node_path35.join)(dir, "body.txt");
+  (0, import_node_fs37.writeFileSync)(path2, body.endsWith("\n") ? body : `${body}
 `, "utf8");
   return { path: path2, cleanup: () => {
     try {
-      (0, import_node_fs36.rmSync)(dir, { recursive: true, force: true });
+      (0, import_node_fs37.rmSync)(dir, { recursive: true, force: true });
     } catch {
     }
   } };
@@ -39301,8 +39481,8 @@ async function deleteMergedRemoteBranch(options) {
 }
 
 // src/post-merge-recon.ts
-var import_node_fs37 = require("node:fs");
-var import_node_path35 = require("node:path");
+var import_node_fs38 = require("node:fs");
+var import_node_path36 = require("node:path");
 
 // src/cross-repo-filing-issue.ts
 init_github_client();
@@ -39469,16 +39649,16 @@ function buildPostMergeReconRecovery(input) {
 }
 function writePostMergeReconRecovery(cwd, recovery) {
   const path2 = postMergeReconStatePath(cwd, recovery.repo, recovery.pr);
-  (0, import_node_fs37.mkdirSync)((0, import_node_path35.dirname)(path2), { recursive: true });
-  (0, import_node_fs37.writeFileSync)(path2, `${JSON.stringify(recovery, null, 2)}
+  (0, import_node_fs38.mkdirSync)((0, import_node_path36.dirname)(path2), { recursive: true });
+  (0, import_node_fs38.writeFileSync)(path2, `${JSON.stringify(recovery, null, 2)}
 `, "utf8");
   return path2;
 }
 function clearPostMergeReconRecovery(cwd, repo, pr) {
   const path2 = postMergeReconStatePath(cwd, repo, pr);
-  if (!(0, import_node_fs37.existsSync)(path2)) return;
+  if (!(0, import_node_fs38.existsSync)(path2)) return;
   try {
-    (0, import_node_fs37.unlinkSync)(path2);
+    (0, import_node_fs38.unlinkSync)(path2);
   } catch {
   }
 }
@@ -39510,9 +39690,9 @@ function postMergeReconWarnings(input) {
 
 // src/review-verdict.ts
 var import_node_child_process13 = require("node:child_process");
-var import_node_fs38 = require("node:fs");
+var import_node_fs39 = require("node:fs");
 var import_node_os19 = require("node:os");
-var import_node_path36 = require("node:path");
+var import_node_path37 = require("node:path");
 init_cli_shared();
 var REVIEW_VERDICT_MARKER = "<!-- zeroci-review v1 -->";
 var REVIEW_VERDICTS = ["PROCEED", "CORRECT", "ESCALATE"];
@@ -39677,15 +39857,15 @@ async function readPrIssueComments(number, repo) {
   return comments;
 }
 async function postPrCommentFromFile(number, repo, body) {
-  const dir = (0, import_node_fs38.mkdtempSync)((0, import_node_path36.join)((0, import_node_os19.tmpdir)(), "mmi-review-verdict-"));
-  const path2 = (0, import_node_path36.join)(dir, "body.md");
+  const dir = (0, import_node_fs39.mkdtempSync)((0, import_node_path37.join)((0, import_node_os19.tmpdir)(), "mmi-review-verdict-"));
+  const path2 = (0, import_node_path37.join)(dir, "body.md");
   try {
-    (0, import_node_fs38.writeFileSync)(path2, body, "utf8");
+    (0, import_node_fs39.writeFileSync)(path2, body, "utf8");
     const { stdout } = await execFileP("gh", ["pr", "comment", number, "--repo", repo, "--body-file", path2], { timeout: GH_MUTATION_TIMEOUT_MS });
     return stdout.trim();
   } finally {
     try {
-      (0, import_node_fs38.rmSync)(dir, { recursive: true, force: true });
+      (0, import_node_fs39.rmSync)(dir, { recursive: true, force: true });
     } catch {
     }
   }
@@ -39839,6 +40019,32 @@ function withRateLimitRetry(client, seams = {}) {
     throttledPaths
   };
 }
+async function prCreateMergedHeadWarning(input, deps = {}) {
+  const guide = "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}`;
+  }
+  try {
+    const repo = await requireRepo(input.repo);
+    const owner = repo.split("/")[0];
+    if (!owner) throw new Error(`invalid repository '${repo}'`);
+    const qualifiedHead = input.head.includes(":") ? input.head : `${owner}:${input.head}`;
+    const query = new URLSearchParams({ state: "closed", head: qualifiedHead, sort: "updated", direction: "desc" });
+    const pulls = await (deps.client ?? defaultGitHubClient()).restPaginate(
+      `repos/${repo}/pulls?${query.toString()}`
+    );
+    const merged = pulls.find((pull) => typeof pull.merged_at === "string" && pull.merged_at.length > 0);
+    if (!merged) return void 0;
+    if (typeof merged.number !== "number" || typeof merged.base?.ref !== "string" || !merged.base.ref) {
+      throw new Error("GitHub returned a merged PR without its number or base branch");
+    }
+    const base = merged.base.ref;
+    return `pr create: WARNING \u2014 head branch '${input.head}' already landed in merged PR #${merged.number}. If you meant to continue that landed work, cut a fresh branch from origin/${base}: \`git fetch origin ${base} && git switch -c <new-branch> origin/${base}\`, then cherry-pick anything already committed. Creating another PR from a deliberately reused branch name remains allowed \u2014 ${guide}`;
+  } catch (e) {
+    const detail = String(e.message || e).replace(/\s+/g, " ").slice(0, 240);
+    return `pr create: WARNING \u2014 could not check whether head branch '${input.head}' already landed (${detail}); continuing with PR creation \u2014 ${guide}`;
+  }
+}
 async function prCreateClaimRefusal(body, repoOption, deps = {}) {
   const issues = [...new Set(findClosingMentions(body).map((mention) => mention.issue))];
   if (!issues.length) return void 0;
@@ -39871,13 +40077,13 @@ async function prCreateClaimRefusal(body, repoOption, deps = {}) {
 }
 
 // src/worktree-merge-cleanup.ts
-var import_node_fs40 = require("node:fs");
-var import_node_path38 = require("node:path");
+var import_node_fs41 = require("node:fs");
+var import_node_path39 = require("node:path");
 init_cli_shared();
 
 // src/worktree-evidence-archive.ts
-var import_node_fs39 = require("node:fs");
-var import_node_path37 = require("node:path");
+var import_node_fs40 = require("node:fs");
+var import_node_path38 = require("node:path");
 var JERV_ARTIFACT_RUN_SCOPE_ENV_VARS = ["JERV_RUN_ID", ...SESSION_ID_ENV_VARS];
 function sanitizeArchiveSegment(value, max = 80) {
   const scrubbed = value.replace(/[^A-Za-z0-9._@+-]+/g, "-").replace(/^-+|-+$/g, "");
@@ -39892,24 +40098,24 @@ function resolveArtifactRunScope(env = process.env) {
 }
 function defaultIsDirectory(path2) {
   try {
-    return (0, import_node_fs39.lstatSync)(path2).isDirectory();
+    return (0, import_node_fs40.lstatSync)(path2).isDirectory();
   } catch {
     return false;
   }
 }
 function archiveWorktreeJervArtifacts(args, deps = {}) {
-  const exists = deps.exists ?? import_node_fs39.existsSync;
+  const exists = deps.exists ?? import_node_fs40.existsSync;
   const isDirectory = deps.isDirectory ?? defaultIsDirectory;
-  const copyDir = deps.copyDir ?? ((from, to) => (0, import_node_fs39.cpSync)(from, to, { recursive: true, force: true }));
+  const copyDir = deps.copyDir ?? ((from, to) => (0, import_node_fs40.cpSync)(from, to, { recursive: true, force: true }));
   const mkdirp = deps.mkdirp ?? ((path2) => {
-    (0, import_node_fs39.mkdirSync)(path2, { recursive: true });
+    (0, import_node_fs40.mkdirSync)(path2, { recursive: true });
   });
   const env = deps.env ?? process.env;
   const now = deps.now ?? (() => /* @__PURE__ */ new Date());
   const resolveRoot = deps.resolveArchiveRoot ?? repoRuntimeStatePath;
   if (!args.primaryRoot?.trim()) return { status: "skipped", reason: "missing-primary-root" };
   if (!args.worktreePath?.trim()) return { status: "skipped", reason: "missing-worktree-path" };
-  const source = (0, import_node_path37.join)(args.worktreePath, ".jerv");
+  const source = (0, import_node_path38.join)(args.worktreePath, ".jerv");
   if (!exists(source)) return { status: "absent" };
   if (!isDirectory(source)) return { status: "skipped", reason: "jerv-not-a-directory" };
   const runScope = resolveArtifactRunScope(env);
@@ -39917,7 +40123,7 @@ function archiveWorktreeJervArtifacts(args, deps = {}) {
   const stamp = now().toISOString().replace(/[:.]/g, "-");
   const dest = resolveRoot(args.primaryRoot, "jerv-artifacts", runScope, branchSlug, stamp, ".jerv");
   try {
-    mkdirp((0, import_node_path37.dirname)(dest));
+    mkdirp((0, import_node_path38.dirname)(dest));
     copyDir(source, dest);
     if (!exists(dest)) return { status: "failed", error: `archive write left no directory at ${dest}` };
     return { status: "archived", path: dest, runScope };
@@ -39926,14 +40132,14 @@ function archiveWorktreeJervArtifacts(args, deps = {}) {
   }
 }
 function defaultStat(path2) {
-  const st = (0, import_node_fs39.statSync)(path2);
+  const st = (0, import_node_fs40.statSync)(path2);
   return { mtimeMs: st.mtimeMs, size: st.size, isDirectory: () => st.isDirectory() };
 }
 function scanWorktreeTmpEvidence(worktreePath, newerThanMs, deps = {}) {
-  const exists = deps.exists ?? import_node_fs39.existsSync;
+  const exists = deps.exists ?? import_node_fs40.existsSync;
   const stat4 = deps.stat ?? defaultStat;
-  const readdir2 = deps.readdir ?? import_node_fs39.readdirSync;
-  const tmpRoot = (0, import_node_path37.join)(worktreePath, "tmp");
+  const readdir2 = deps.readdir ?? import_node_fs40.readdirSync;
+  const tmpRoot = (0, import_node_path38.join)(worktreePath, "tmp");
   if (!exists(tmpRoot)) return [];
   const entries = [];
   const walk2 = (dir) => {
@@ -39944,14 +40150,14 @@ function scanWorktreeTmpEvidence(worktreePath, newerThanMs, deps = {}) {
       return;
     }
     for (const name of names) {
-      const full = (0, import_node_path37.join)(dir, name);
+      const full = (0, import_node_path38.join)(dir, name);
       let st;
       try {
         st = stat4(full);
       } catch {
         continue;
       }
-      const relPath = (0, import_node_path37.relative)(worktreePath, full).replace(/\\/g, "/");
+      const relPath = (0, import_node_path38.relative)(worktreePath, full).replace(/\\/g, "/");
       if (st.isDirectory()) {
         if (st.mtimeMs > newerThanMs) entries.push({ relPath, bytes: 0, mtimeMs: st.mtimeMs });
         walk2(full);
@@ -39965,10 +40171,10 @@ function scanWorktreeTmpEvidence(worktreePath, newerThanMs, deps = {}) {
   return entries;
 }
 function archiveWorktreeTmpArtifacts(args, deps = {}) {
-  const exists = deps.exists ?? import_node_fs39.existsSync;
-  const copyDir = deps.copyDir ?? ((from, to) => (0, import_node_fs39.cpSync)(from, to, { recursive: true, force: true }));
+  const exists = deps.exists ?? import_node_fs40.existsSync;
+  const copyDir = deps.copyDir ?? ((from, to) => (0, import_node_fs40.cpSync)(from, to, { recursive: true, force: true }));
   const mkdirp = deps.mkdirp ?? ((path2) => {
-    (0, import_node_fs39.mkdirSync)(path2, { recursive: true });
+    (0, import_node_fs40.mkdirSync)(path2, { recursive: true });
   });
   const env = deps.env ?? process.env;
   const now = deps.now ?? (() => /* @__PURE__ */ new Date());
@@ -39976,7 +40182,7 @@ function archiveWorktreeTmpArtifacts(args, deps = {}) {
   if (!args.primaryRoot?.trim()) return { status: "skipped", reason: "missing-primary-root" };
   if (!args.worktreePath?.trim()) return { status: "skipped", reason: "missing-worktree-path" };
   const scanned = scanWorktreeTmpEvidence(args.worktreePath, args.newerThanMs, deps);
-  const source = (0, import_node_path37.join)(args.worktreePath, "tmp");
+  const source = (0, import_node_path38.join)(args.worktreePath, "tmp");
   if (!scanned.length) return { status: "absent" };
   if (!exists(source)) return { status: "absent" };
   const runScope = resolveArtifactRunScope(env);
@@ -39984,7 +40190,7 @@ function archiveWorktreeTmpArtifacts(args, deps = {}) {
   const stamp = now().toISOString().replace(/[:.]/g, "-");
   const dest = resolveRoot(args.primaryRoot, "worktree-artifacts", runScope, branchSlug, stamp, "tmp");
   try {
-    mkdirp((0, import_node_path37.dirname)(dest));
+    mkdirp((0, import_node_path38.dirname)(dest));
     copyDir(source, dest);
     if (!exists(dest)) return { status: "failed", error: `archive write left no directory at ${dest}` };
     const bytes = scanned.reduce((sum, e) => sum + e.bytes, 0);
@@ -40053,9 +40259,9 @@ function normPath2(p) {
   return p.replace(/\\/g, "/").replace(/\/+$/, "");
 }
 function unlinkNodeModulesJunction(wtPath) {
-  const nm = (0, import_node_path38.join)(wtPath, "node_modules");
+  const nm = (0, import_node_path39.join)(wtPath, "node_modules");
   try {
-    if ((0, import_node_fs40.lstatSync)(nm).isSymbolicLink()) (0, import_node_fs40.rmdirSync)(nm);
+    if ((0, import_node_fs41.lstatSync)(nm).isSymbolicLink()) (0, import_node_fs41.rmdirSync)(nm);
     return { ok: true };
   } catch (e) {
     if (e.code === "ENOENT") return { ok: true };
@@ -40066,8 +40272,8 @@ function defaultSleep2(ms) {
   return new Promise((resolve7) => setTimeout(resolve7, ms));
 }
 async function removeResidueDirectory(wtPath, options = {}) {
-  const { sleep: sleep2 = defaultSleep2, removeEmptyDir = import_node_fs40.rmdirSync, exists = import_node_fs40.existsSync } = options;
-  const removeRecursive = options.removeRecursive ?? ((path2) => (0, import_node_fs40.rmSync)(path2, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 }));
+  const { sleep: sleep2 = defaultSleep2, removeEmptyDir = import_node_fs41.rmdirSync, exists = import_node_fs41.existsSync } = options;
+  const removeRecursive = options.removeRecursive ?? ((path2) => (0, import_node_fs41.rmSync)(path2, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 }));
   const junction = unlinkNodeModulesJunction(wtPath);
   if (!junction.ok) return junction;
   try {
@@ -40190,28 +40396,28 @@ async function preCleanWorktreeForRemoval(wtPath, execGit) {
 }
 async function listNestedIgnoredNodeModules(wtPath, execGit) {
   const out = await execGit(["-C", wtPath, "ls-files", "--others", "--ignored", "--exclude-standard", "--directory"]).catch(() => "");
-  return out.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.endsWith("node_modules/") && line !== "node_modules/").map((line) => (0, import_node_path38.join)(wtPath, line.slice(0, -1)));
+  return out.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.endsWith("node_modules/") && line !== "node_modules/").map((line) => (0, import_node_path39.join)(wtPath, line.slice(0, -1)));
 }
 function safeRemoveTree(path2) {
-  const stat4 = (0, import_node_fs40.lstatSync)(path2);
+  const stat4 = (0, import_node_fs41.lstatSync)(path2);
   if (stat4.isSymbolicLink()) {
     try {
-      (0, import_node_fs40.rmdirSync)(path2);
+      (0, import_node_fs41.rmdirSync)(path2);
     } catch {
-      (0, import_node_fs40.unlinkSync)(path2);
+      (0, import_node_fs41.unlinkSync)(path2);
     }
     return;
   }
   if (stat4.isDirectory()) {
-    for (const entry of (0, import_node_fs40.readdirSync)(path2)) safeRemoveTree((0, import_node_path38.join)(path2, entry));
-    (0, import_node_fs40.rmdirSync)(path2);
+    for (const entry of (0, import_node_fs41.readdirSync)(path2)) safeRemoveTree((0, import_node_path39.join)(path2, entry));
+    (0, import_node_fs41.rmdirSync)(path2);
     return;
   }
-  (0, import_node_fs40.unlinkSync)(path2);
+  (0, import_node_fs41.unlinkSync)(path2);
 }
 async function removeWorktreeNodeModules(wtPath) {
   try {
-    safeRemoveTree((0, import_node_path38.join)(wtPath, "node_modules"));
+    safeRemoveTree((0, import_node_path39.join)(wtPath, "node_modules"));
     return { ok: true };
   } catch (e) {
     if (e.code === "ENOENT") return { ok: true };
@@ -40223,7 +40429,7 @@ function errorMessage(e) {
 }
 function resolvedOrRaw(path2) {
   try {
-    return normPath2((0, import_node_fs40.realpathSync)(path2));
+    return normPath2((0, import_node_fs41.realpathSync)(path2));
   } catch {
     return normPath2(path2);
   }
@@ -40231,10 +40437,10 @@ function resolvedOrRaw(path2) {
 function unlinkEscapingReparsePoints(root, primaryRoot) {
   let realRoot;
   try {
-    if ((0, import_node_fs40.lstatSync)(root).isSymbolicLink()) {
+    if ((0, import_node_fs41.lstatSync)(root).isSymbolicLink()) {
       return { ok: false, error: `delete root ${normPath2(root)} is a reparse point resolving to ${resolvedOrRaw(root)}` };
     }
-    realRoot = normPath2((0, import_node_fs40.realpathSync)(root));
+    realRoot = normPath2((0, import_node_fs41.realpathSync)(root));
   } catch (e) {
     if (e.code === "ENOENT") return { ok: true, unlinked: [] };
     return { ok: false, error: `cannot resolve delete root ${normPath2(root)}: ${errorMessage(e)}` };
@@ -40250,16 +40456,16 @@ function unlinkEscapingReparsePoints(root, primaryRoot) {
     const dir = stack.pop();
     let entries;
     try {
-      entries = (0, import_node_fs40.readdirSync)(dir, { withFileTypes: true });
+      entries = (0, import_node_fs41.readdirSync)(dir, { withFileTypes: true });
     } catch (e) {
       return { ok: false, error: `cannot scan ${normPath2(dir)} for reparse points: ${errorMessage(e)}` };
     }
     for (const entry of entries) {
-      const child2 = (0, import_node_path38.join)(dir, entry.name);
+      const child2 = (0, import_node_path39.join)(dir, entry.name);
       if (entry.isSymbolicLink()) {
         let target = "";
         try {
-          target = normPath2((0, import_node_fs40.realpathSync)(child2));
+          target = normPath2((0, import_node_fs41.realpathSync)(child2));
         } catch {
           target = "";
         }
@@ -40442,7 +40648,7 @@ async function cleanupPrMergeLocalBranch(branch, options) {
     return report;
   }
   const execGit = options.execGit ?? (async (args) => (await execFileP("git", args, { timeout: GIT_TIMEOUT_MS })).stdout);
-  const pathExists = options.pathExists ?? import_node_fs40.existsSync;
+  const pathExists = options.pathExists ?? import_node_fs41.existsSync;
   let afterWorktrees = [];
   try {
     afterWorktrees = parseGitWorktreePorcelain(await execGit(["worktree", "list", "--porcelain"]));
@@ -40582,7 +40788,7 @@ async function cleanupPrMergeLocalBranch(branch, options) {
   const preHelperGuard = unlinkEscapingReparsePoints(wtPath, options.primaryRoot);
   if (!preHelperGuard.ok) return refuseReparseEscape(preHelperGuard.error);
   unlinkedReparsePoints.push(...preHelperGuard.unlinked);
-  if (pathExists((0, import_node_path38.join)(wtPath, "node_modules"))) {
+  if (pathExists((0, import_node_path39.join)(wtPath, "node_modules"))) {
     const nmRemoved = await (options.removeRealNodeModules ?? removeWorktreeNodeModules)(wtPath);
     if (!nmRemoved.ok) {
       report.worktree = {
@@ -40749,10 +40955,10 @@ function argvWantsJson2() {
   return process.argv.some((a) => a === "--json" || a.startsWith("--json="));
 }
 function hubRoot() {
-  const fromPkg = (0, import_node_path39.join)(__dirname, "..", "..");
+  const fromPkg = (0, import_node_path40.join)(__dirname, "..", "..");
   const marker = "skills/bootstrap/seeds/manifest.json";
-  if ((0, import_node_fs41.existsSync)((0, import_node_path39.join)(fromPkg, marker))) return fromPkg;
-  if ((0, import_node_fs41.existsSync)((0, import_node_path39.join)(process.cwd(), marker))) return process.cwd();
+  if ((0, import_node_fs42.existsSync)((0, import_node_path40.join)(fromPkg, marker))) return fromPkg;
+  if ((0, import_node_fs42.existsSync)((0, import_node_path40.join)(process.cwd(), marker))) return process.cwd();
   return null;
 }
 function ciAuditDeps() {
@@ -40764,8 +40970,8 @@ function ciAuditDeps() {
     getProjectMeta: async (slug) => fetchProjectBySlug(slug, registryClientDeps(await cfgPromise)),
     readSeedFile: (path2) => {
       if (!root) return null;
-      const fullPath = (0, import_node_path39.join)(root, path2);
-      return (0, import_node_fs41.existsSync)(fullPath) ? (0, import_node_fs41.readFileSync)(fullPath, "utf8") : null;
+      const fullPath = (0, import_node_path40.join)(root, path2);
+      return (0, import_node_fs42.existsSync)(fullPath) ? (0, import_node_fs42.readFileSync)(fullPath, "utf8") : null;
     }
   };
 }
@@ -41443,6 +41649,10 @@ ${list}`);
     }
     const claimRefusal = await prCreateClaimRefusal(body, o.repo);
     if (claimRefusal) return fail(claimRefusal);
+    const createHead = o.head ?? await gitOut(["symbolic-ref", "--quiet", "--short", "HEAD"]).catch(() => "");
+    const mergedHeadWarning = await prCreateMergedHeadWarning({ head: createHead || void 0, repo: o.repo });
+    if (mergedHeadWarning) process.stderr.write(`${mergedHeadWarning}
+`);
     const created = await ghCreate(buildPrArgs({ title, body, base: o.base, head: o.head, repo: o.repo, draft: o.draft }));
     if (isGhCreateRateLimited(created)) {
       console.log(JSON.stringify(created));
@@ -41486,11 +41696,11 @@ ${list}`);
     }
   });
   async function listCiWorkflowPaths(cwd = process.cwd()) {
-    const wfDir = (0, import_node_path39.join)(cwd, ".github", "workflows");
-    if (!(0, import_node_fs41.existsSync)(wfDir)) return [];
-    return (0, import_node_fs41.readdirSync)(wfDir).filter((name) => /\.(ya?ml)$/i.test(name)).filter((name) => {
+    const wfDir = (0, import_node_path40.join)(cwd, ".github", "workflows");
+    if (!(0, import_node_fs42.existsSync)(wfDir)) return [];
+    return (0, import_node_fs42.readdirSync)(wfDir).filter((name) => /\.(ya?ml)$/i.test(name)).filter((name) => {
       try {
-        return workflowReportsPrChecks((0, import_node_fs41.readFileSync)((0, import_node_path39.join)(wfDir, name), "utf8"));
+        return workflowReportsPrChecks((0, import_node_fs42.readFileSync)((0, import_node_path40.join)(wfDir, name), "utf8"));
       } catch {
         return true;
       }
@@ -41686,7 +41896,7 @@ ${list}`);
   jsonParity(pr.command("review-verdict <number>").description("post an explicit review verdict comment: computes the PR diff patch-id and head sha, renders the v1 contract body, and posts it as a PR comment").requiredOption("--repo <owner/repo>", "target repo").requiredOption("--verdict <verdict>", `one of ${REVIEW_VERDICTS.join("|")}`).requiredOption("--scope <text>", "one line: what was reviewed").requiredOption("--risk <text>", "one line: the residual risk").option("--unverified <text>", "a claim the reviewer could not verify (repeatable)", (v, acc) => [...acc, v], []).requiredOption("--reviewer <id>", "reviewer seat or model id").option("--findings-file <path>", "Markdown findings appended after the JSON block")).action(async (number, o) => {
     if (!isReviewVerdict(o.verdict)) return fail(`pr review-verdict: --verdict must be one of ${REVIEW_VERDICTS.join("|")} (got ${o.verdict})`);
     const verdict = o.verdict;
-    const findings = o.findingsFile ? (0, import_node_fs41.readFileSync)(o.findingsFile, "utf8") : void 0;
+    const findings = o.findingsFile ? (0, import_node_fs42.readFileSync)(o.findingsFile, "utf8") : void 0;
     let patch;
     let head;
     try {
@@ -41801,7 +42011,7 @@ ${list}`);
           const shape = track ? `${track} track` : "unresolved track \u2014 strict reading";
           throw new Error(`pr land: base branch ${base} is a promotion target (${shape}) \u2014 promotion merges stay human-only`);
         }
-        return repo;
+        return { repo, base };
       },
       fetchTrainAuthority: async (repo) => fetchTrainAuthority(repo, registryClientDeps(await loadConfig())),
       resolveCiPolicy: (repo) => resolveRepoMergeCiPolicy(repo, ciAuditDeps()),
@@ -41916,7 +42126,9 @@ ${list}`);
     }
     const credential = await pollToken().catch(() => void 0) ? "app_installation" : "user";
     if (o.json) printLine(JSON.stringify({ ...result, credential }));
-    else printLine(`pr land: ${result.status}${result.error ? ` \u2014 ${result.error}` : ""} (credential: ${credential})`);
+    else printLine(
+      `pr land: ${result.status}${result.error ? ` \u2014 ${result.error}` : ""} (credential: ${credential})` + (result.branchFinality ? ` \u2014 ${result.branchFinality}` : "")
+    );
     if (result.status === "failed") process.exitCode = 1;
   });
   jsonParity(pr.command("merge <number>").description("merge a PR (squash by default); archives gitignored tmp/** before worktree teardown; on no-ci repos run pr ci-policy / checks-wait first (#1432, #5679)").option("--squash", "squash merge (default)").option("--merge", "create a merge commit").option("--rebase", "rebase merge").option("--repo <owner/repo>", "target repo (defaults to the current repo); from a foreign checkout the remote probe/delete address this repo and local cleanup runs only in the verified sibling checkout ../<repo>, else localBranch reports skipped-foreign-cwd and the receipt carries foreignCwd: true (#6148)").option("--auto", "enable auto-merge \u2014 merge once the base-branch policy is satisfied (use for policy-gated repos)").addOption(new Option("--disable-auto", "disable a queued auto-merge without merging").conflicts(["auto", "wait", "squash", "merge", "rebase", "preserveWorktree", "gc", "squashBodyFile", "force"])).option("--wait", `wait for checks to reach a terminal passing verdict before merging (default budget ${PR_CHECKS_TIMEOUT_MS / 6e4}m) \u2014 run as a background/monitor task or under a shell timeout above that budget; a short foreground timeout (e.g. 120s) kills it after checks pass and leaves the PR open (#6027)`).option("--preserve-worktree", "after merge, keep the local PR worktree/branch for an active batch (#1888); also the merge settings-proof bypass when delete_branch_on_merge cannot be proven (#6210)").option("--gc", "acknowledge deleting unarchived gitignored tmp/** evidence newer than the branch base (#5679)").option("--squash-body-file <path>", "squash commit body (overrides GitHub COMMIT_MESSAGES); use when a pushed commit mentions close/fix/resolve + #N that must not close (#5723)").option("--force", "acknowledge and merge past a remaining prunable/severe scratch housekeeping block (advisory kept plans/ never blocks, #3012) or a negated-closing-keyword (#3718) or ambiguous-cross-repo-closing (#4279) refusal").option("--without-review <reason>", "compatibility option; shared merge helpers do not require a review verdict")).action(async (number, o) => {
@@ -41958,7 +42170,7 @@ ${list}`);
     const mergeSquashBody = squashBodyTextForMerge(
       closingGuardInput,
       method === "--squash",
-      o.squashBodyFile ? (0, import_node_fs41.readFileSync)(o.squashBodyFile, "utf8") : void 0
+      o.squashBodyFile ? (0, import_node_fs42.readFileSync)(o.squashBodyFile, "utf8") : void 0
     );
     if (!o.squashBodyFile) warnSquashBodyClosingStrip("pr merge", closingGuardInput, mergeSquashBody);
     const closingGuardVerdict = evaluateClosingGuard(closingGuardInput, {
@@ -41990,7 +42202,7 @@ ${list}`);
     const remote = foreignCwd ? `https://github.com/${targetRepo2}.git` : "origin";
     let foreignCheckout;
     if (foreignCwd) {
-      const sibling = (0, import_node_path39.join)((0, import_node_path39.dirname)(beforeWorktrees[0]?.path || startingPath || process.cwd()), targetRepo2.split("/")[1]);
+      const sibling = (0, import_node_path40.join)((0, import_node_path40.dirname)(beforeWorktrees[0]?.path || startingPath || process.cwd()), targetRepo2.split("/")[1]);
       const siblingRepo = repoFromRemoteUrl(await gitOut(["-C", sibling, "remote", "get-url", "origin"]).catch(() => ""));
       if (siblingRepo?.toLowerCase() === targetRepo2.toLowerCase()) {
         const siblingWorktrees = await execFileP("git", ["-C", sibling, "worktree", "list", "--porcelain"], { timeout: GIT_TIMEOUT_MS }).then((r) => parseGitWorktreePorcelain(r.stdout)).catch(() => void 0);
@@ -42088,7 +42300,7 @@ ${list}`);
         }
         if (!repoForPostCleanup) throw e;
         console.warn(`pr merge: gh GraphQL rate-limited \u2014 merging PR #${number} via REST PUT instead (#4588).`);
-        const commitMessage = bodyFile ? (0, import_node_fs41.readFileSync)(bodyFile, "utf8") : void 0;
+        const commitMessage = bodyFile ? (0, import_node_fs42.readFileSync)(bodyFile, "utf8") : void 0;
         await defaultGitHubClient().rest("PUT", `repos/${repoForPostCleanup}/pulls/${number}/merge`, {
           body: { merge_method: method.slice(2), ...commitMessage ? { commit_message: commitMessage } : {} },
           timeoutMs: GH_MUTATION_TIMEOUT_MS
@@ -42208,7 +42420,7 @@ ${list}`);
           preserveWorktree: o.preserveWorktree,
           gcAcknowledged: o.gc,
           expectedHeadOid: headRefOid,
-          pathExists: (p) => (0, import_node_fs41.existsSync)(p),
+          pathExists: (p) => (0, import_node_fs42.existsSync)(p),
           // #5899: pin cleanup git calls to the main checkout — the task worktree this process may be
           // standing in is removed mid-cleanup, so a cwd-relative invocation fails with
           // 'fatal: not a git repository' and leaves a spurious partial-cleanup exit.
@@ -42329,7 +42541,7 @@ ${list}`);
 }
 
 // src/command-register-developer.ts
-var import_node_fs46 = require("node:fs");
+var import_node_fs47 = require("node:fs");
 init_clean_exit();
 init_cli_shared();
 init_error_codes();
@@ -42362,7 +42574,7 @@ async function resolveWhoami(deps) {
 }
 
 // src/command-register-developer.ts
-var import_node_path44 = require("node:path");
+var import_node_path45 = require("node:path");
 init_house_map();
 init_hub_url();
 
@@ -42395,7 +42607,7 @@ async function executeWaveLand(plan, deps) {
 }
 
 // src/box-commands.ts
-var import_node_fs42 = require("node:fs");
+var import_node_fs43 = require("node:fs");
 init_clean_exit();
 
 // src/box.ts
@@ -42607,7 +42819,7 @@ function registerBoxCommands(program3) {
       }
       const remote = command && command.length ? command.join(" ") : void 0;
       const wroteScript = o.ssh && o.script ? o.script : null;
-      if (wroteScript) (0, import_node_fs42.writeFileSync)(wroteScript, sshRecipeScript(found, remote), "utf8");
+      if (wroteScript) (0, import_node_fs43.writeFileSync)(wroteScript, sshRecipeScript(found, remote), "utf8");
       if (o.json) {
         console.log(JSON.stringify({
           box: found,
@@ -42629,19 +42841,19 @@ ${SSH_RECIPE_AGENT_NOTE}`);
 // src/dist-drift.ts
 var import_node_child_process16 = require("node:child_process");
 var import_node_crypto13 = require("node:crypto");
-var import_node_fs44 = require("node:fs");
+var import_node_fs45 = require("node:fs");
 var import_node_os20 = require("node:os");
-var import_node_path41 = require("node:path");
+var import_node_path42 = require("node:path");
 
 // ../scripts/distribution-digest.mjs
 var import_node_crypto12 = require("node:crypto");
-var import_node_fs43 = require("node:fs");
-var import_node_path40 = require("node:path");
+var import_node_fs44 = require("node:fs");
+var import_node_path41 = require("node:path");
 var slash = (value) => value.replaceAll("\\", "/");
 function repoPath(root, declaredPath, label) {
-  const absoluteRoot = (0, import_node_path40.resolve)(root);
-  const target = (0, import_node_path40.resolve)(root, declaredPath);
-  if (target !== absoluteRoot && !target.startsWith(`${absoluteRoot}${import_node_path40.sep}`)) {
+  const absoluteRoot = (0, import_node_path41.resolve)(root);
+  const target = (0, import_node_path41.resolve)(root, declaredPath);
+  if (target !== absoluteRoot && !target.startsWith(`${absoluteRoot}${import_node_path41.sep}`)) {
     throw new Error(`${label} ${declaredPath} escapes the repository root`);
   }
   return target;
@@ -42649,7 +42861,7 @@ function repoPath(root, declaredPath, label) {
 function digestFiles(files) {
   const hash = (0, import_node_crypto12.createHash)("sha256");
   for (const file of [...files].sort((a, b) => a.relative.localeCompare(b.relative))) {
-    const content = file.stat.isSymbolicLink() ? Buffer.from((0, import_node_fs43.readlinkSync)(file.absolute), "utf8") : (0, import_node_fs43.readFileSync)(file.absolute);
+    const content = file.stat.isSymbolicLink() ? Buffer.from((0, import_node_fs44.readlinkSync)(file.absolute), "utf8") : (0, import_node_fs44.readFileSync)(file.absolute);
     hash.update(file.relative, "utf8");
     hash.update("\0");
     hash.update(file.stat.isSymbolicLink() ? "symlink" : "file", "utf8");
@@ -42664,8 +42876,8 @@ function digestFiles(files) {
 function digestPackedFiles(packageRoot, packedFiles) {
   return digestFiles(packedFiles.map((path2) => {
     const absolute = repoPath(packageRoot, path2, "packed artifact identity path");
-    if (!(0, import_node_fs43.existsSync)(absolute)) throw new Error(`packed artifact identity path ${path2} does not exist`);
-    return { absolute, relative: slash(path2), stat: (0, import_node_fs43.lstatSync)(absolute) };
+    if (!(0, import_node_fs44.existsSync)(absolute)) throw new Error(`packed artifact identity path ${path2} does not exist`);
+    return { absolute, relative: slash(path2), stat: (0, import_node_fs44.lstatSync)(absolute) };
   }));
 }
 
@@ -42749,13 +42961,13 @@ function renderDistDriftReceipt(receipt) {
   return lines2;
 }
 function readOrNull(path2) {
-  return (0, import_node_fs44.existsSync)(path2) ? (0, import_node_fs44.readFileSync)(path2) : null;
+  return (0, import_node_fs45.existsSync)(path2) ? (0, import_node_fs45.readFileSync)(path2) : null;
 }
 function walkFiles(root) {
   const files = [];
   const walk2 = (directory) => {
-    for (const entry of (0, import_node_fs44.readdirSync)(directory, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
-      const child2 = (0, import_node_path41.join)(directory, entry.name);
+    for (const entry of (0, import_node_fs45.readdirSync)(directory, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+      const child2 = (0, import_node_path42.join)(directory, entry.name);
       if (entry.isDirectory()) walk2(child2);
       else files.push(child2);
     }
@@ -42765,10 +42977,10 @@ function walkFiles(root) {
 }
 function bomPathFor(root) {
   try {
-    const registry2 = JSON.parse((0, import_node_fs44.readFileSync)((0, import_node_path41.join)(root, "surfaces.json"), "utf8"));
-    return (0, import_node_path41.join)(root, registry2?.sharedAgentCore?.releaseMetadata?.bomPath ?? "distribution-bom.json");
+    const registry2 = JSON.parse((0, import_node_fs45.readFileSync)((0, import_node_path42.join)(root, "surfaces.json"), "utf8"));
+    return (0, import_node_path42.join)(root, registry2?.sharedAgentCore?.releaseMetadata?.bomPath ?? "distribution-bom.json");
   } catch {
-    return (0, import_node_path41.join)(root, "distribution-bom.json");
+    return (0, import_node_path42.join)(root, "distribution-bom.json");
   }
 }
 function rebuildTo(packageRoot, outDir) {
@@ -42781,35 +42993,35 @@ function rebuildTo(packageRoot, outDir) {
   });
 }
 function runDistStatus(root) {
-  const stage = (0, import_node_fs44.mkdtempSync)((0, import_node_path41.join)((0, import_node_os20.tmpdir)(), "mmi-dist-drift-"));
+  const stage = (0, import_node_fs45.mkdtempSync)((0, import_node_path42.join)((0, import_node_os20.tmpdir)(), "mmi-dist-drift-"));
   let overlayCount = 0;
   try {
-    const cliOut = (0, import_node_path41.join)(stage, "cli-dist");
-    const hubOut = (0, import_node_path41.join)(stage, "hub-dist");
-    rebuildTo((0, import_node_path41.join)(root, "cli"), cliOut);
-    rebuildTo((0, import_node_path41.join)(root, "updater"), hubOut);
+    const cliOut = (0, import_node_path42.join)(stage, "cli-dist");
+    const hubOut = (0, import_node_path42.join)(stage, "hub-dist");
+    rebuildTo((0, import_node_path42.join)(root, "cli"), cliOut);
+    rebuildTo((0, import_node_path42.join)(root, "updater"), hubOut);
     const outDirFor = (packageDir) => packageDir === "cli" ? cliOut : hubOut;
     const rebuilt = (path2) => {
       const spec = DIST_ARTIFACTS.find((entry) => entry.path === path2);
-      return spec ? readOrNull((0, import_node_path41.join)(outDirFor(spec.packageDir), spec.output)) : null;
+      return spec ? readOrNull((0, import_node_path42.join)(outDirFor(spec.packageDir), spec.output)) : null;
     };
-    const committed = (path2) => readOrNull((0, import_node_path41.join)(root, path2));
-    const tree = (path2) => readOrNull((0, import_node_path41.join)(root, path2));
-    const distRoot = (0, import_node_path41.join)(root, "cli", "dist");
-    const distTree = () => walkFiles(distRoot).map((absolute) => `cli/dist/${(0, import_node_path41.relative)(distRoot, absolute).replaceAll("\\", "/")}`);
-    const bom = JSON.parse((0, import_node_fs44.readFileSync)(bomPathFor(root), "utf8"));
+    const committed = (path2) => readOrNull((0, import_node_path42.join)(root, path2));
+    const tree = (path2) => readOrNull((0, import_node_path42.join)(root, path2));
+    const distRoot = (0, import_node_path42.join)(root, "cli", "dist");
+    const distTree = () => walkFiles(distRoot).map((absolute) => `cli/dist/${(0, import_node_path42.relative)(distRoot, absolute).replaceAll("\\", "/")}`);
+    const bom = JSON.parse((0, import_node_fs45.readFileSync)(bomPathFor(root), "utf8"));
     const digest = (entries) => {
-      const overlay = (0, import_node_path41.join)(stage, `overlay-${overlayCount++}`);
+      const overlay = (0, import_node_path42.join)(stage, `overlay-${overlayCount++}`);
       for (const entry of entries) {
-        const target = (0, import_node_path41.join)(overlay, entry.path);
-        (0, import_node_fs44.mkdirSync)((0, import_node_path41.dirname)(target), { recursive: true });
-        (0, import_node_fs44.writeFileSync)(target, entry.bytes);
+        const target = (0, import_node_path42.join)(overlay, entry.path);
+        (0, import_node_fs45.mkdirSync)((0, import_node_path42.dirname)(target), { recursive: true });
+        (0, import_node_fs45.writeFileSync)(target, entry.bytes);
       }
       return digestPackedFiles(overlay, entries.map((entry) => entry.path));
     };
     return computeDistDriftReceipt({ committed, tree, rebuilt, distTree, bom, digest });
   } finally {
-    (0, import_node_fs44.rmSync)(stage, { recursive: true, force: true });
+    (0, import_node_fs45.rmSync)(stage, { recursive: true, force: true });
   }
 }
 
@@ -42888,7 +43100,7 @@ init_hub_auth();
 
 // src/schedules-lift-command.ts
 var import_promises8 = require("node:fs/promises");
-var import_node_path42 = require("node:path");
+var import_node_path43 = require("node:path");
 init_clean_exit();
 init_cli_shared();
 var DEFAULT_WORKFLOWS_DIR = ".github/workflows";
@@ -42917,7 +43129,7 @@ async function readWorkflowFiles(dir) {
   const files = [];
   for (const name of names.sort()) {
     if (!/\.ya?ml$/.test(name)) continue;
-    files.push({ path: `.github/workflows/${name}`, text: await (0, import_promises8.readFile)((0, import_node_path42.join)(dir, name), "utf8") });
+    files.push({ path: `.github/workflows/${name}`, text: await (0, import_promises8.readFile)((0, import_node_path43.join)(dir, name), "utf8") });
   }
   return files;
 }
@@ -43000,8 +43212,8 @@ function registerSchedulesLiftCommand(program3, deps = {}) {
 
 // src/spawn-policy-core.ts
 var import_node_child_process17 = require("node:child_process");
-var import_node_fs45 = require("node:fs");
-var import_node_path43 = require("node:path");
+var import_node_fs46 = require("node:fs");
+var import_node_path44 = require("node:path");
 var SPAWNERS = ["spawn", "spawnSync", "exec", "execSync", "execFile", "execFileSync"];
 var CALL_SOURCE = String.raw`(^|[^.\w$])(${SPAWNERS.join("|")})\s*\(`;
 var SOURCE_EXT = /\.(ts|mts|cts|js|mjs|cjs)$/;
@@ -43087,7 +43299,7 @@ function runSpawnPolicy(root) {
   for (const file of files) {
     let raw;
     try {
-      raw = (0, import_node_fs45.readFileSync)((0, import_node_path43.join)(root, file), "utf8");
+      raw = (0, import_node_fs46.readFileSync)((0, import_node_path44.join)(root, file), "utf8");
     } catch {
       continue;
     }
@@ -43107,19 +43319,19 @@ function runSpawnPolicy(root) {
 function registerDeveloperCommands(program3) {
   const rules = program3.command("rules").description("org-managed .gitignore delivery");
   rules.command("gitignore").option("--write", "upsert the managed block into .gitignore (default: check only, non-zero exit on drift)").option("--json", "machine-readable output").description("verify (or --write) this repo's org-managed .gitignore block matches the SSOT").action((opts) => {
-    const path2 = (0, import_node_path44.join)(process.cwd(), ".gitignore");
-    const current = (0, import_node_fs46.existsSync)(path2) ? (0, import_node_fs46.readFileSync)(path2, "utf8") : null;
+    const path2 = (0, import_node_path45.join)(process.cwd(), ".gitignore");
+    const current = (0, import_node_fs47.existsSync)(path2) ? (0, import_node_fs47.readFileSync)(path2, "utf8") : null;
     const plan = planManagedGitignore(current);
     const drift = [...plan.added.map((l) => `+${l}`), ...plan.removed.map((l) => `-${l}`)].join(", ") || "block normalize";
     if (opts.json) {
-      if (opts.write && plan.changed) (0, import_node_fs46.writeFileSync)(path2, plan.content, "utf8");
+      if (opts.write && plan.changed) (0, import_node_fs47.writeFileSync)(path2, plan.content, "utf8");
       console.log(JSON.stringify(plan, null, 2));
       if (!opts.write && plan.changed) process.exitCode = 1;
       return;
     }
     if (opts.write) {
       if (plan.changed) {
-        (0, import_node_fs46.writeFileSync)(path2, plan.content, "utf8");
+        (0, import_node_fs47.writeFileSync)(path2, plan.content, "utf8");
         console.log(`mmi-cli devops org rules gitignore: updated .gitignore (${drift})`);
       } else {
         console.log("mmi-cli devops org rules gitignore: up to date");
@@ -44753,8 +44965,8 @@ function checkHotfixCarries(options) {
 }
 
 // src/train-commands.ts
-var import_node_fs47 = require("node:fs");
-var import_node_path45 = require("node:path");
+var import_node_fs48 = require("node:fs");
+var import_node_path46 = require("node:path");
 init_cli_shared();
 init_clean_exit();
 init_client_version();
@@ -44769,7 +44981,7 @@ function resolveReleaseBumpIntent(raw) {
 }
 function readRepoVersion() {
   try {
-    return JSON.parse((0, import_node_fs47.readFileSync)((0, import_node_path45.join)(process.cwd(), ".claude-plugin", "plugin.json"), "utf8")).version || void 0;
+    return JSON.parse((0, import_node_fs48.readFileSync)((0, import_node_path46.join)(process.cwd(), ".claude-plugin", "plugin.json"), "utf8")).version || void 0;
   } catch {
     return void 0;
   }
@@ -45735,7 +45947,7 @@ ${r.stderr ?? ""}`).catch(() => "");
 var ENV_HEAL_LOCK_STALE_MS = 10 * 6e4;
 var ENV_HEAL_LOCK_MAX_WAIT_MS = 2 * 6e4;
 function envHealLockPath(home) {
-  return (0, import_node_path46.join)(home, ".claude", "plugins", ".mmi-env-heal.lock");
+  return (0, import_node_path47.join)(home, ".claude", "plugins", ".mmi-env-heal.lock");
 }
 async function withEnvHealLock(what, run) {
   try {
@@ -45872,7 +46084,7 @@ function mmiDoctorDeps(opts = {}) {
       );
       const result = applyPluginCachePlan(
         plan,
-        (p) => (0, import_node_fs48.rmSync)(p, { recursive: true }),
+        (p) => (0, import_node_fs49.rmSync)(p, { recursive: true }),
         stagingApplyFsGuard(configRoot)
       );
       return {
@@ -45907,7 +46119,7 @@ function mmiDoctorDeps(opts = {}) {
     // has no generated routing index would
     // get a permanent — demanding an artifact it never asked for.
     docsIndexState: (root) => {
-      if (!(0, import_node_fs48.existsSync)((0, import_node_path46.join)(root, DOCS_INDEX_PATH))) return void 0;
+      if (!(0, import_node_fs49.existsSync)((0, import_node_path47.join)(root, DOCS_INDEX_PATH))) return void 0;
       const real = createDocsIndexDeps(root);
       let docs;
       const listDocs = () => docs ??= real.listDocs();
@@ -45916,7 +46128,7 @@ function mmiDoctorDeps(opts = {}) {
     },
     // #4168: working-tree heal — write if drifted, then re-check. Commit remains the operator's step.
     healDocsIndex: (root) => {
-      if (!(0, import_node_fs48.existsSync)((0, import_node_path46.join)(root, DOCS_INDEX_PATH))) return { drift: false, docCount: 0 };
+      if (!(0, import_node_fs49.existsSync)((0, import_node_path47.join)(root, DOCS_INDEX_PATH))) return { drift: false, docCount: 0 };
       const real = createDocsIndexDeps(root);
       let docs;
       const listDocs = () => docs ??= real.listDocs();
@@ -46542,7 +46754,7 @@ project.command("set [owner/repo]").description("upsert project META (idempotent
   if (dupe) return fail(`org project set: KEY "${dupe}" was passed to both --var and --set; --set is an alias of --var, so pass each KEY once`);
   if (o.secretsFile) {
     try {
-      vars.push(`secrets=${(0, import_node_fs48.readFileSync)(o.secretsFile, "utf8")}`);
+      vars.push(`secrets=${(0, import_node_fs49.readFileSync)(o.secretsFile, "utf8")}`);
     } catch (e) {
       return fail(`org project set: cannot read --secrets-file ${o.secretsFile}: ${e.message}`);
     }
@@ -46875,16 +47087,16 @@ function ciAuditDeps2() {
     // gate re-seed step is skipped gracefully rather than failing mid-run.
     readSeedFile: (path2) => {
       if (!root) return null;
-      const fullPath = (0, import_node_path46.join)(root, path2);
-      return (0, import_node_fs48.existsSync)(fullPath) ? (0, import_node_fs48.readFileSync)(fullPath, "utf8") : null;
+      const fullPath = (0, import_node_path47.join)(root, path2);
+      return (0, import_node_fs49.existsSync)(fullPath) ? (0, import_node_fs49.readFileSync)(fullPath, "utf8") : null;
     }
   };
 }
 function hubRoot2() {
-  const fromPkg = (0, import_node_path46.join)(__dirname, "..", "..");
+  const fromPkg = (0, import_node_path47.join)(__dirname, "..", "..");
   const marker = "skills/bootstrap/seeds/manifest.json";
-  if ((0, import_node_fs48.existsSync)((0, import_node_path46.join)(fromPkg, marker))) return fromPkg;
-  if ((0, import_node_fs48.existsSync)((0, import_node_path46.join)(process.cwd(), marker))) return process.cwd();
+  if ((0, import_node_fs49.existsSync)((0, import_node_path47.join)(fromPkg, marker))) return fromPkg;
+  if ((0, import_node_fs49.existsSync)((0, import_node_path47.join)(process.cwd(), marker))) return process.cwd();
   return null;
 }
 registerQueryCommands(program2);
@@ -46984,10 +47196,10 @@ access.command("audit").description("audit collaborator roles + train-branch pus
     targets = resolution.targets;
   }
   const derivedMatrix = registryProjects ? accessMatrixFromProjects(registryProjects) : {};
-  const fileMatrix = (0, import_node_fs48.existsSync)("access-matrix.json") ? loadAccessMatrix((0, import_node_fs48.readFileSync)("access-matrix.json", "utf8")) : {};
+  const fileMatrix = (0, import_node_fs49.existsSync)("access-matrix.json") ? loadAccessMatrix((0, import_node_fs49.readFileSync)("access-matrix.json", "utf8")) : {};
   const matrix = mergeAccessMatrix(fileMatrix, derivedMatrix);
   const dataAccess = registryProjects ? dataAccessContractsFromProjects(registryProjects) : { consumers: {} };
-  const sanctioned = (0, import_node_fs48.existsSync)("access-matrix.json") ? loadSanctionedAdmins((0, import_node_fs48.readFileSync)("access-matrix.json", "utf8")) : {};
+  const sanctioned = (0, import_node_fs49.existsSync)("access-matrix.json") ? loadSanctionedAdmins((0, import_node_fs49.readFileSync)("access-matrix.json", "utf8")) : {};
   const report = await auditOrgAccess(targets, deps, matrix, dataAccess, sanctioned);
   console.log(o.json ? JSON.stringify(report, null, 2) : renderAccessReport(report));
   if (!report.ok) process.exitCode = 1;
@@ -47018,16 +47230,16 @@ function directoryBytes(path2) {
   let total = 0;
   let entries;
   try {
-    entries = (0, import_node_fs48.readdirSync)(path2, { withFileTypes: true });
+    entries = (0, import_node_fs49.readdirSync)(path2, { withFileTypes: true });
   } catch {
     return 0;
   }
   for (const entry of entries) {
-    const child2 = (0, import_node_path46.join)(path2, entry.name);
+    const child2 = (0, import_node_path47.join)(path2, entry.name);
     if (entry.isDirectory()) total += directoryBytes(child2);
     else {
       try {
-        total += (0, import_node_fs48.statSync)(child2).size;
+        total += (0, import_node_fs49.statSync)(child2).size;
       } catch {
       }
     }
@@ -47035,25 +47247,25 @@ function directoryBytes(path2) {
   return total;
 }
 function listDirEntries(dir) {
-  return (0, import_node_fs48.readdirSync)(dir, { withFileTypes: true }).map((d) => ({ name: d.name, isDirectory: d.isDirectory() }));
+  return (0, import_node_fs49.readdirSync)(dir, { withFileTypes: true }).map((d) => ({ name: d.name, isDirectory: d.isDirectory() }));
 }
 function readInstalledPluginRefs(configRoot) {
   const p = installedPluginsPathForConfig(configRoot);
-  if (!(0, import_node_fs48.existsSync)(p)) return [];
+  if (!(0, import_node_fs49.existsSync)(p)) return [];
   try {
-    return installedPluginPaths((0, import_node_fs48.readFileSync)(p, "utf8"));
+    return installedPluginPaths((0, import_node_fs49.readFileSync)(p, "utf8"));
   } catch {
     return null;
   }
 }
 function pluginCacheFsDeps(configRoot, dirBytes) {
   return {
-    exists: (p) => (0, import_node_fs48.existsSync)(p),
-    listVersionDirs: (root) => (0, import_node_fs48.readdirSync)(root, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name),
+    exists: (p) => (0, import_node_fs49.existsSync)(p),
+    listVersionDirs: (root) => (0, import_node_fs49.readdirSync)(root, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name),
     dirBytes,
-    listStagingDirs: (root) => (0, import_node_fs48.readdirSync)(root, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => {
+    listStagingDirs: (root) => (0, import_node_fs49.readdirSync)(root, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => {
       try {
-        return { name: d.name, mtimeMs: newestMtimeMs((0, import_node_path46.join)(root, d.name), listDirEntries, (p) => (0, import_node_fs48.statSync)(p).mtimeMs) };
+        return { name: d.name, mtimeMs: newestMtimeMs((0, import_node_path47.join)(root, d.name), listDirEntries, (p) => (0, import_node_fs49.statSync)(p).mtimeMs) };
       } catch {
         return { name: d.name, mtimeMs: Date.now() };
       }
@@ -47067,10 +47279,10 @@ function stagingApplyFsGuard(configRoot) {
   return {
     referencedPaths: () => readInstalledPluginRefs(configRoot),
     mtimeMs: (name) => {
-      const p = (0, import_node_path46.join)(stagingRoot, name);
-      if (!(0, import_node_fs48.existsSync)(p)) return null;
+      const p = (0, import_node_path47.join)(stagingRoot, name);
+      if (!(0, import_node_fs49.existsSync)(p)) return null;
       try {
-        return newestMtimeMs(p, listDirEntries, (q) => (0, import_node_fs48.statSync)(q).mtimeMs);
+        return newestMtimeMs(p, listDirEntries, (q) => (0, import_node_fs49.statSync)(q).mtimeMs);
       } catch {
         return null;
       }
@@ -47096,7 +47308,7 @@ program2.command("plugin-prune").description(`prune stale cached MMI plugin vers
     { withBytes: true, configRoot, includeStaging: surface !== "codex" }
   );
   const anythingToDelete = plan.prune.length > 0 || plan.staging.length > 0;
-  const result = o.apply && anythingToDelete ? applyPluginCachePlan(plan, (p) => (0, import_node_fs48.rmSync)(p, { recursive: true, force: true }), stagingApplyFsGuard(configRoot)) : void 0;
+  const result = o.apply && anythingToDelete ? applyPluginCachePlan(plan, (p) => (0, import_node_fs49.rmSync)(p, { recursive: true, force: true }), stagingApplyFsGuard(configRoot)) : void 0;
   const warnings = plan.prune.length > 0 ? [CONCURRENT_SESSION_WARNING] : [];
   if (o.json) console.log(JSON.stringify({ ...plan, warnings, applied: result ?? null }));
   else console.log(renderPluginCachePlan(plan, result));