@mutmutco/cli 3.0.1 → 3.2.0

package/dist/main.cjs

@@ -4789,7 +4789,7 @@ mutation($projectId: ID!, $itemId: ID!) {
 async function updateItemSingleSelect(client, projectId, itemId, fieldId, optionId) {
   await client.graphql(UPDATE_ITEM_FIELD_MUTATION, { projectId, itemId, fieldId, optionId });
 }
-function resolveBoardConfig(cfg) {
+function missingBoardConfigFields(cfg) {
   const missing = [];
   if (!cfg.projectOwner) missing.push("projectOwner");
   if (!cfg.projectNumber) missing.push("projectNumber");
@@ -4799,9 +4799,20 @@ function resolveBoardConfig(cfg) {
   for (const status of BOARD_STATUSES) {
     if (!cfg.statusOptions?.[status]) missing.push(`statusOptions.${status}`);
   }
-  if (missing.length) {
-    throw new Error(
-      `Hub registry board META missing ${missing.join(", ")}; run \`gh auth login\`, then \`mmi-cli project get <owner/repo>\`, or ask a master-admin to register/backfill board coords`
+  return missing;
+}
+function diagnoseBoardConfigGap(cfg) {
+  const missing = missingBoardConfigFields(cfg);
+  if (!missing.length) return null;
+  return cfg.projectId ? { kind: "registry-meta-missing", missing } : { kind: "no-project-detected" };
+}
+function resolveBoardConfig(cfg) {
+  const gap = diagnoseBoardConfigGap(cfg);
+  if (gap) {
+    throw gap.kind === "no-project-detected" ? new Error(
+      "no MMI project detected for this workspace (no Hub registry match for this repo, or no git origin in this folder); run `mmi-cli board read --repo <owner/repo>` to target a specific registered repo, or `mmi-cli project get <owner/repo>` to check registration"
+    ) : new Error(
+      `Hub registry board META missing ${gap.missing.join(", ")}; run \`gh auth login\`, then \`mmi-cli project get <owner/repo>\`, or ask a master-admin to register/backfill board coords`
     );
   }
   return {
@@ -4864,6 +4875,11 @@ function detailCandidates(report) {
     ...report.secondary.claimable
   ].filter((item) => item.contentType === "Issue");
 }
+function boardNotFoundError(ref, board2, opts = {}) {
+  const verb = opts.verb ?? "is not on";
+  const remedy = opts.remedy ?? "if it lives on a different board, pass --repo <owner/repo> for the repo that owns it";
+  return new Error(`${ref} ${verb} the ${board2.owner} #${board2.number} board; ${remedy}`);
+}
 function findClaimableItem(report, selector) {
   const candidates = [...report.primary.claimable, ...report.secondary.claimable];
   const found = candidates.find((item) => item.repository.toLowerCase() === selector.repo.toLowerCase() && item.number === selector.number);
@@ -4882,7 +4898,10 @@ function findClaimableItem(report, selector) {
     if (existing.assignees.length) throw new Error(`${existing.ref} is already assigned to @${existing.assignees.join(", @")}`);
     throw new Error(`${existing.ref} is not claimable`);
   }
-  throw new Error(`${selector.repo}#${selector.number} is not on this project board`);
+  throw boardNotFoundError(`${selector.repo}#${selector.number}`, report.project, {
+    verb: "is not a claimable item on",
+    remedy: "it may already be Done (excluded from claim tracking), or it lives on a different board \u2014 pass --repo <owner/repo> for the repo that owns it"
+  });
 }
 function renderBoardItem(item) {
   const assignees = item.assignees.length ? `@${item.assignees.join(", @")}` : "unassigned";
@@ -5022,11 +5041,11 @@ async function readBoard(options, deps = {}) {
   }
   return report;
 }
-function findBoardItem(items, selector) {
+function findBoardItem(items, selector, board2) {
   const found = items.find(
     (candidate) => candidate.repository.toLowerCase() === selector.repo.toLowerCase() && candidate.number === selector.number
   );
-  if (!found) throw new Error(`${selector.repo}#${selector.number} is not on this project board`);
+  if (!found) throw boardNotFoundError(`${selector.repo}#${selector.number}`, board2);
   return found;
 }
 async function resolveCurrentRepo(options, deps) {
@@ -5045,7 +5064,9 @@ async function moveBoardItem(options, deps = {}) {
   const selector = parseIssueSelector(options.selector, currentRepo);
   const lookup = await fetchIssueProjectItem(client, cfg, selector);
   const item = lookup.item;
-  if (!item) throw new Error(`${selector.repo}#${selector.number} is not on this project board`);
+  if (!item) {
+    throw boardNotFoundError(`${selector.repo}#${selector.number}`, { owner: cfg.projectOwner, number: cfg.projectNumber });
+  }
   const optionId = cfg.statusOptions[options.status];
   try {
     await updateItemSingleSelect(client, cfg.projectId, item.itemId, cfg.statusFieldId, optionId);
@@ -5091,7 +5112,7 @@ async function showBoardItem(options, deps = {}) {
   const currentRepo = await resolveCurrentRepo(options, deps);
   const selector = parseIssueSelector(options.selector, currentRepo);
   const { item } = await fetchIssueProjectItem(client, cfg, selector);
-  if (!item) throw new Error(`${selector.repo}#${selector.number} is not on this project board`);
+  if (!item) throw boardNotFoundError(`${selector.repo}#${selector.number}`, { owner: cfg.projectOwner, number: cfg.projectNumber });
   if (item.contentType === "Issue") {
     try {
       item.details = await fetchIssueDetails(client, item.repository, item.number);
@@ -5104,9 +5125,10 @@ async function showBoardItem(options, deps = {}) {
 async function prepareClaimContext(options, selectors, deps, collected) {
   const cfg = resolveBoardConfig(options.config);
   const client = deps.client ?? defaultGitHubClient();
+  const board2 = { owner: cfg.projectOwner, number: cfg.projectNumber };
   for (const selector of selectors) {
     try {
-      findBoardItem(collected.items, selector);
+      findBoardItem(collected.items, selector, board2);
     } catch {
       const fallback = (await fetchIssueProjectItem(client, cfg, selector)).item;
       if (fallback) collected.items.push(fallback);
@@ -5132,7 +5154,7 @@ async function prepareClaimContext(options, selectors, deps, collected) {
 }
 async function claimOneBoardItem(ctx, selector, options) {
   const { cfg, client, report } = ctx;
-  const flatItem = findBoardItem(ctx.items, selector);
+  const flatItem = findBoardItem(ctx.items, selector, { owner: cfg.projectOwner, number: cfg.projectNumber });
   if (flatItem.status === "Todo" && flatItem.assignees.length === 0 && !ctx.writable.has(flatItem.repository.toLowerCase())) {
     throw new Error(`${flatItem.ref} is not claimable: viewer does not have write access to ${flatItem.repository}`);
   }
@@ -6994,6 +7016,18 @@ var PR_LAND_POLL_MS = 3e4;
 var PR_LAND_ENQUEUE_TIMEOUT_MS = 10 * 6e4;
 var PR_LAND_STATE_READ_RETRIES = 3;
 var PR_LAND_STATE_READ_DELAY_MS = 2e3;
+var PR_LAND_MERGE_RETRY_DELAY_MS = 3e3;
+async function mergeAutoWithTransientRetry(prNumber, repo, deps) {
+  const first = await deps.mergeAuto(prNumber, repo);
+  if (first.mergeStatus !== "failed") return first;
+  const ready = await deps.probeMergeReady(prNumber, repo).catch(() => ({ open: false, mergeable: false, checksPassing: false }));
+  if (!ready.open || !ready.mergeable || !ready.checksPassing) return first;
+  const sleep = deps.sleep ?? ((ms) => new Promise((resolve6) => setTimeout(resolve6, ms)));
+  await sleep(PR_LAND_MERGE_RETRY_DELAY_MS);
+  const retried = await deps.mergeAuto(prNumber, repo);
+  if (retried.mergeStatus !== "failed") return retried;
+  return { mergeStatus: "failed", error: `merge retry after transient failure also failed: ${retried.error ?? first.error ?? "unknown error"}` };
+}
 async function readGhPrStateWithRetry(fetchState, options) {
   const retries = options?.retries ?? PR_LAND_STATE_READ_RETRIES;
   const delayMs = options?.delayMs ?? PR_LAND_STATE_READ_DELAY_MS;
@@ -7037,7 +7071,7 @@ async function runPrLand(prNumber, options, deps) {
       error: `checks-wait ${checksWait.status}${checksWait.detail ? `: ${checksWait.detail}` : ""}`
     };
   }
-  const merge = await deps.mergeAuto(prNumber, repo);
+  const merge = await mergeAutoWithTransientRetry(prNumber, repo, deps);
   base.mergeStatus = merge.mergeStatus;
   if (merge.mergeStatus === "failed") {
     return { ...base, error: merge.error ?? "merge failed" };
@@ -9411,7 +9445,7 @@ function trainPlan(command, options = {}) {
         { label: "merge development to main", gated: true },
         { label: "fold the version bump into the release commit (Hub: full distribution set; app repos: root package manifest) \u2014 runs inside the apply step, no separate bump PR", gated: true },
         { label: "tag release and publish GitHub Release", gated: true },
-        { label: "trigger the repo deploy path from the release event", command: "hub-serverless: deploy.yml + publish.yml auto-fire on the release; other models deploy via their own workflow", gated: true },
+        { label: "trigger the repo deploy path from the release event", command: "hub-serverless: deploy.yml + publish.yml auto-fire on the release; registry-publish: own publish.yml auto-fires, watched on that repo, never a central dispatch (#2428); other models deploy via their own workflow", gated: true },
         { label: "roll development forward", gated: true }
       ];
     }
@@ -9439,7 +9473,7 @@ function trainPlan(command, options = {}) {
       { label: "merge rc to main", gated: true },
       { label: "fold the version bump into the release commit (app repos: root package manifest) \u2014 runs inside the apply step, no separate bump PR", gated: true },
       { label: "tag release and publish GitHub Release", gated: true },
-      { label: "trigger the deploy path for this repo model, returning Hub Actions run id/url data (and, with --watch, its outcome)", command: "tenant-container: gh workflow run tenant-deploy.yml ... then gh run list/watch; hub-serverless: no manual dispatch, deploy.yml + publish.yml auto-fire on the release, correlate/watch those runs", gated: true },
+      { label: "trigger the deploy path for this repo model, returning Hub Actions run id/url data (and, with --watch, its outcome)", command: "tenant-container: gh workflow run tenant-deploy.yml ... then gh run list/watch; hub-serverless: no manual dispatch, deploy.yml + publish.yml auto-fire on the release, correlate/watch those runs; registry-publish: no manual dispatch, own publish.yml auto-fires on the release, correlate/watch that run on the product repo (#2428)", gated: true },
       { label: "roll development forward", gated: true }
     ];
   }
@@ -9943,9 +9977,12 @@ var TRAIN_PROTECTION_CONTEXTS_JQ = "[.contexts[]]";
 var TRAIN_RULES_CONTEXTS_JQ = '[.[]|select(.type=="required_status_checks")|.parameters.required_status_checks[].context]';
 var TRAIN_CHECK_ATTEMPTS = 40;
 var TRAIN_CHECK_DELAY_MS = 15e3;
+var TRAIN_PR_ONLY_AUTOMATION_CONTEXTS = /* @__PURE__ */ new Set(["add-to-project", "mark-merged-pr-done"]);
+var TRAIN_PR_AUTOMATION_GRACE_ATTEMPTS = 3;
 async function correlateRun(deps, args) {
   const sleep = resolveSleep(deps);
   const threshold = args.since - CORRELATE_SKEW_SLACK_MS;
+  const repo = args.mode === "workflow" ? args.repo ?? HUB_REPO3 : HUB_REPO3;
   let lastError;
   let parsedAnyResponse = false;
   for (let attempt = 0; attempt < CORRELATE_ATTEMPTS; attempt++) {
@@ -9954,7 +9991,7 @@ async function correlateRun(deps, args) {
       "run",
       "list",
       "--repo",
-      HUB_REPO3,
+      repo,
       "--workflow",
       args.workflow,
       ...args.mode === "workflow" ? ["--event", args.event] : [],
@@ -9997,10 +10034,10 @@ function correlateControlRun(deps, since, titleIncludes) {
 async function correlateWorkflowRun(deps, args) {
   return correlateRun(deps, { ...args, mode: "workflow" });
 }
-async function watchTenantRun(deps, runId) {
+async function watchTenantRun(deps, runId, repo = HUB_REPO3) {
   if (runId == null) return "pending";
   try {
-    await deps.run("gh", ["run", "watch", String(runId), "--repo", HUB_REPO3, "--exit-status"]);
+    await deps.run("gh", ["run", "watch", String(runId), "--repo", repo, "--exit-status"]);
     return "success";
   } catch {
     return "failure";
@@ -10013,9 +10050,9 @@ async function fetchControlRunLog(deps, runId) {
     return "";
   }
 }
-async function watchWorkflowRun(deps, workflow, run) {
+async function watchWorkflowRun(deps, workflow, run, repo = HUB_REPO3) {
   if (run.runId == null) return { workflow, conclusion: "pending" };
-  const conclusion = await watchTenantRun(deps, run.runId);
+  const conclusion = await watchTenantRun(deps, run.runId, repo);
   return { workflow, runId: run.runId, runUrl: run.runUrl, conclusion };
 }
 function aggregateWorkflowRuns(runs) {
@@ -10124,6 +10161,7 @@ async function waitForRequiredTrainChecks(deps, ctx, sha, required) {
   let lastStatus = "not checked";
   let lastError;
   const everObserved = /* @__PURE__ */ new Set();
+  const autoSatisfied = /* @__PURE__ */ new Set();
   for (let attempt = 0; attempt < TRAIN_CHECK_ATTEMPTS; attempt++) {
     if (attempt > 0) await sleep(TRAIN_CHECK_DELAY_MS);
     let checkRuns;
@@ -10145,18 +10183,25 @@ async function waitForRequiredTrainChecks(deps, ctx, sha, required) {
     for (const c of required) {
       if (checkRuns.some((r) => r.name === c) || statuses.some((s) => s.context === c)) everObserved.add(c);
     }
-    const states = required.map((c) => [c, resolveContextState(c, checkRuns, statuses)]);
-    lastStatus = states.map(([c, s]) => `${c}=${s}`).join(", ");
+    if (attempt >= TRAIN_PR_AUTOMATION_GRACE_ATTEMPTS - 1) {
+      for (const c of required) {
+        if (TRAIN_PR_ONLY_AUTOMATION_CONTEXTS.has(c) && !everObserved.has(c)) autoSatisfied.add(c);
+      }
+    }
+    const pending = required.filter((c) => !autoSatisfied.has(c));
+    const states = pending.map((c) => [c, resolveContextState(c, checkRuns, statuses)]);
+    const satisfiedNote = autoSatisfied.size ? `, auto-satisfied (never runs on a tag, see #2404): ${[...autoSatisfied].join(", ")}` : "";
+    lastStatus = `${states.map(([c, s]) => `${c}=${s}`).join(", ")}${satisfiedNote}`;
     const failed = states.filter(([, s]) => s === "failed").map(([c]) => c);
     if (failed.length > 0) {
       throw new Error(`required train check failed: ${failed.join(", ")} (${lastStatus})`);
     }
     if (states.every(([, s]) => s === "success")) {
-      return `required checks passed: ${required.join(", ")}`;
+      return `required checks passed: ${pending.join(", ") || "(none pending)"}${satisfiedNote}`;
     }
   }
   const waitedMin = Math.round((TRAIN_CHECK_ATTEMPTS - 1) * TRAIN_CHECK_DELAY_MS / 6e4);
-  const neverMaterialized = required.filter((c) => !everObserved.has(c));
+  const neverMaterialized = required.filter((c) => !everObserved.has(c) && !autoSatisfied.has(c));
   const neverNote = neverMaterialized.length ? ` Never materialized on ${sha} (no check-run or commit status ever appeared \u2014 the workflow that produces them was likely not triggered by the tag event): ${neverMaterialized.join(", ")}.` : "";
   throw new Error(
     `timed out after ~${waitedMin}m (${TRAIN_CHECK_ATTEMPTS} attempts) waiting for required train checks on ${sha}.${neverNote} Last observed: ${lastError ? `error: ${lastError}` : lastStatus}`
@@ -10246,6 +10291,19 @@ function tenantPublishRecoveryCommand(slug, repo, ref, stage2, publishDir) {
   if (publishDir && publishDir !== ".") parts.push(`-f publishDir=${publishDir}`);
   return parts.join(" ");
 }
+var PUBLISH_IDEMPOTENT_MARKER = /already on npm/i;
+var PUBLISH_LOG_RETRY_ATTEMPTS = 4;
+var PUBLISH_LOG_RETRY_DELAY_MS = 6e3;
+async function reconcilePublishFailure(deps, runId) {
+  if (runId == null) return "failure";
+  const sleep = resolveSleep(deps);
+  for (let attempt = 0; attempt < PUBLISH_LOG_RETRY_ATTEMPTS; attempt++) {
+    if (attempt > 0) await sleep(PUBLISH_LOG_RETRY_DELAY_MS);
+    const log = await fetchControlRunLog(deps, runId);
+    if (PUBLISH_IDEMPOTENT_MARKER.test(log)) return "success";
+  }
+  return "failure";
+}
 async function dispatchTenantPublish(deps, ctx, stage2, ref, watch, dispatchFailure = "throw", publishDir) {
   const since = (deps.now ?? Date.now)();
   const dispatchArgs = [
@@ -10276,8 +10334,16 @@ async function dispatchTenantPublish(deps, ctx, stage2, ref, watch, dispatchFail
     };
   }
   const { runId, runUrl } = await correlatePublishRun(deps, since, [ctx.slug, stage2]);
-  const deployStatus = watch ? await watchTenantRun(deps, runId) : "pending";
-  return { note: `dispatched tenant-publish.yml (slug=${ctx.slug}, ref=${ref}, stage=${stage2})`, runId, runUrl, deployStatus };
+  let deployStatus = watch ? await watchTenantRun(deps, runId) : "pending";
+  let note = `dispatched tenant-publish.yml (slug=${ctx.slug}, ref=${ref}, stage=${stage2})`;
+  if (deployStatus === "failure") {
+    const reconciled = await reconcilePublishFailure(deps, runId);
+    if (reconciled === "success") {
+      deployStatus = "success";
+      note = `${note}; run reported failure but its log confirms the version is already on npm (idempotent E409 \u2014 #2428)`;
+    }
+  }
+  return { note, runId, runUrl, deployStatus };
 }
 async function dispatchPublishIfRequired(deps, ctx, meta, model, stage2, publishRef, watch, dispatchFailure) {
   if (!meta.publishRequired || stage2 !== "main") return null;
@@ -10294,6 +10360,18 @@ function appendPublishDispatch(deploy, publish) {
     deployStatus: deploy.deployStatus === "failure" || publish.deployStatus === "failure" ? "failure" : deploy.deployStatus === "pending" || publish.deployStatus === "pending" ? "pending" : "success"
   };
 }
+async function watchOwnWorkflowRuns(deps, repo, targets, since, headSha) {
+  const workflowRuns = [];
+  for (const target of targets) {
+    try {
+      const run = await correlateWorkflowRun(deps, { ...target, since, headSha, repo });
+      workflowRuns.push(await watchWorkflowRun(deps, target.workflow, run, repo));
+    } catch {
+      workflowRuns.push({ workflow: target.workflow, conclusion: "failure" });
+    }
+  }
+  return workflowRuns;
+}
 async function dispatchDeploy(deps, ctx, stage2, ref, model, watch, autoRunSince, autoRunHeadSha, dispatchFailure = "throw", publishDir) {
   if (model === "tenant-container" || model === "solo-container") {
     const since = (deps.now ?? Date.now)();
@@ -10312,7 +10390,18 @@ async function dispatchDeploy(deps, ctx, stage2, ref, model, watch, autoRunSince
     return { note: `dispatched tenant-deploy.yml (slug=${ctx.slug}, ref=${ref}, stage=${stage2})`, runId, runUrl, deployStatus };
   }
   if (model === "registry-publish") {
-    return dispatchTenantPublish(deps, ctx, stage2, ref, watch, dispatchFailure, publishDir);
+    const note = ref === "rc" ? "no dispatch on rc: registry-publish repos have no rc-stage Release to publish from" : "no central dispatch: this repo's own publish.yml auto-fires on the published Release (#2428)";
+    if (ref === "rc" || !watch || !autoRunHeadSha) return { note, deployStatus: "pending" };
+    const since = autoRunSince ?? (deps.now ?? Date.now)();
+    const workflowRuns = await watchOwnWorkflowRuns(
+      deps,
+      ctx.repo,
+      [{ workflow: "publish.yml", event: "release" }],
+      since,
+      autoRunHeadSha
+    );
+    const primary = workflowRuns[0];
+    return { note, runId: primary?.runId, runUrl: primary?.runUrl, workflowRuns, deployStatus: aggregateWorkflowRuns(workflowRuns) };
   }
   if (model === "hub-serverless") {
     const note = ref === "rc" ? "no manual dispatch: deploy.yml auto-fires on the rc push (rc stage)" : "no manual dispatch: deploy.yml + publish.yml auto-fire on the published Release (prod)";
@@ -10323,15 +10412,7 @@ async function dispatchDeploy(deps, ctx, stage2, ref, model, watch, autoRunSince
       { workflow: "deploy.yml", event: "release" },
       { workflow: "publish.yml", event: "release" }
     ];
-    const workflowRuns = [];
-    for (const target of targets) {
-      try {
-        const run = await correlateWorkflowRun(deps, { ...target, since, headSha: autoRunHeadSha });
-        workflowRuns.push(await watchWorkflowRun(deps, target.workflow, run));
-      } catch {
-        workflowRuns.push({ workflow: target.workflow, conclusion: "failure" });
-      }
-    }
+    const workflowRuns = await watchOwnWorkflowRuns(deps, HUB_REPO3, targets, since, autoRunHeadSha);
     const primary = workflowRuns[0];
     return {
       note,
@@ -10364,25 +10445,113 @@ async function preflightMergeToMain(deps, deployModel, remoteRef, blockingPrefix
   }
   return { foldPaths, tolerated, predicted };
 }
-async function executeMergeToMain(deps, sourceRef, mergeLabel, tolerated, predicted) {
+async function executeMergeToMain(deps, sourceRef, mergeLabel, tolerated, predicted, preFold) {
   await deps.run("git", ["checkout", "main"]);
   await ffOnlyPull(deps, "main");
+  preFold.mainSha = clean(await deps.run("git", ["rev-parse", "main"]));
   if (predicted.length === 0) {
     await deps.run("git", ["merge", sourceRef, "--no-edit"]);
   } else {
     await mergeWithToleratedResolution(deps, sourceRef, mergeLabel, "theirs", tolerated);
   }
 }
-async function mergeSourceToMain(deps, deployModel, args) {
-  const { foldPaths, tolerated, predicted } = await preflightMergeToMain(
-    deps,
-    deployModel,
-    args.remoteRef,
-    args.blockingPrefix,
-    args.realignMessage
+async function probeFoldFailureState(deps) {
+  const branch = await currentBranch(deps);
+  const mergeInProgress = await deps.run("git", ["rev-parse", "-q", "--verify", "MERGE_HEAD"]).then(() => true).catch(() => false);
+  const dirty = porcelainHasBlockingChanges(await deps.run("git", ["status", "--porcelain"]).catch(() => ""));
+  const mainSha = await deps.run("git", ["rev-parse", "main"]).then(clean).catch(() => "");
+  const originMainSha = await deps.run("git", ["rev-parse", "origin/main"]).then(clean).catch(() => "");
+  const originIsAncestorOfMain = Boolean(mainSha) && Boolean(originMainSha) ? await deps.run("git", ["merge-base", "--is-ancestor", "origin/main", "main"]).then(() => true).catch(() => false) : false;
+  return { branch, mergeInProgress, dirty, mainSha, originMainSha, originIsAncestorOfMain };
+}
+function shaLabel(sha) {
+  return sha ? sha.slice(0, 7) : "(unknown)";
+}
+async function finishFoldAutoRestore(deps, causeMessage, startBranch, what) {
+  try {
+    await deps.run("git", ["checkout", startBranch]);
+  } catch (e) {
+    return new Error(
+      `${causeMessage}
+
+fold failed; ${what}, but returning to ${startBranch} afterwards failed: ${e instanceof Error ? e.message : String(e)}. Finish manually: git checkout ${startBranch}`
+    );
+  }
+  return new Error(
+    `${causeMessage}
+
+fold failed; ${what} and the checkout was returned to ${startBranch}. Nothing was pushed to origin and no tag was created \u2014 rerun the release once the fold issue above is fixed.`
   );
-  await executeMergeToMain(deps, args.sourceRef, args.mergeLabel, tolerated, predicted);
-  return { foldPaths };
+}
+function foldFailureGuidance(causeMessage, probe, startBranch, preFoldMainSha) {
+  const steps = preFoldMainSha ? [
+    `  1. git status                              # inspect what is actually there`,
+    `  2. git log --oneline ${preFoldMainSha}..main   # commits beyond the pre-fold main \u2014 confirm they are only this run's merge/fold attempt`,
+    `  3. git checkout main && git reset --hard ${preFoldMainSha}   # back to the exact commit the fold built on`,
+    `  4. git checkout ${startBranch}`
+  ] : [
+    `  1. git status                              # inspect what is actually there`,
+    `  2. git log --oneline origin/main..main     # this run never committed to main (it failed before the merge) \u2014 any commits here predate this run; preserve them`,
+    `  3. git checkout ${startBranch}`
+  ];
+  return new Error(
+    `${causeMessage}
+
+fold failed leaving the checkout in a state train --apply will not auto-restore (branch=${probe.branch || "(unknown)"}, dirty-working-tree=${probe.dirty}, main=${shaLabel(probe.mainSha)}, origin/main=${shaLabel(probe.originMainSha)}, pre-fold main=${preFoldMainSha ? shaLabel(preFoldMainSha) : "not captured"}, origin/main is${probe.originIsAncestorOfMain ? "" : " NOT"} an ancestor of main). Nothing was pushed to origin and no tag was created.
+Recovery sequence:
+${steps.join("\n")}`
+  );
+}
+async function recoverFailedFold(deps, cause, startBranch, preFoldMainSha) {
+  const causeMessage = cause instanceof Error ? cause.message : String(cause);
+  const probe = await probeFoldFailureState(deps);
+  if (probe.mergeInProgress) {
+    try {
+      await deps.run("git", ["merge", "--abort"]);
+    } catch (e) {
+      return new Error(
+        `${causeMessage}
+
+fold failed with an in-progress merge left on ${probe.branch || "(unknown branch)"}; automatic \`git merge --abort\` failed: ${e instanceof Error ? e.message : String(e)}. Nothing was pushed to origin and no tag was created.
+Recovery sequence:
+  1. git merge --abort
+  2. git checkout ${startBranch}`
+      );
+    }
+    return finishFoldAutoRestore(deps, causeMessage, startBranch, "the in-progress merge was aborted");
+  }
+  if (probe.branch === "main" && preFoldMainSha) {
+    const mainDescendsFromPreFold = await deps.run("git", ["merge-base", "--is-ancestor", preFoldMainSha, "main"]).then(() => true).catch(() => false);
+    if (mainDescendsFromPreFold) {
+      try {
+        await deps.run("git", ["reset", "--hard", preFoldMainSha]);
+      } catch (e) {
+        return new Error(
+          `${causeMessage}
+
+fold failed after this run's merge/fold committed locally on main (now ${shaLabel(probe.mainSha)}, unpushed, built on the pre-fold main ${shaLabel(preFoldMainSha)}); automatic \`git reset --hard ${shaLabel(preFoldMainSha)}\` failed: ${e instanceof Error ? e.message : String(e)}. Nothing was pushed to origin and no tag was created.
+Recovery sequence:
+  1. git reset --hard ${preFoldMainSha}
+  2. git checkout ${startBranch}`
+        );
+      }
+      const aheadNote = probe.originMainSha && preFoldMainSha !== probe.originMainSha ? `; local main carried commit(s) origin/main (${shaLabel(probe.originMainSha)}) does not have \u2014 they were preserved` : "";
+      return finishFoldAutoRestore(
+        deps,
+        causeMessage,
+        startBranch,
+        `local main was reset to its pre-fold state ${shaLabel(preFoldMainSha)} (discarding only this run's merge/fold commit(s) at ${shaLabel(probe.mainSha)})${aheadNote}`
+      );
+    }
+  }
+  return foldFailureGuidance(causeMessage, probe, startBranch, preFoldMainSha);
+}
+async function runFoldStage(deps, startBranch, preFold, fn) {
+  try {
+    return await fn();
+  } catch (e) {
+    throw await recoverFailedFold(deps, e, startBranch, preFold.mainSha);
+  }
 }
 async function completeMainRelease(deps, ctx, meta, deployModel, watch, options, tag, releaseSha) {
   await ensureTagPushed(deps, tag, releaseSha);
@@ -10475,15 +10644,20 @@ async function runTrainApplyPipeline(mode, input) {
     const deployModel2 = await preflight(deps, ctx, "main", meta);
     const tag2 = requireValue(clean(await deps.run("node", ["scripts/next-version.mjs", "cycle"])), "release tag");
     const rcShaAtRelease = !directTrack && hasRcBranch ? clean(await deps.run("git", ["rev-parse", "origin/rc"])) : "";
-    const { foldPaths: foldPaths2 } = await mergeSourceToMain(deps, deployModel2, {
-      sourceRef: "development",
-      remoteRef: "origin/development",
-      mergeLabel: "development -> main",
-      blockingPrefix: "development -> main merge would conflict on untolerated path(s)",
-      realignMessage: "The train is misaligned: reconcile main and development via an approved alignment PR, then rerun release."
+    const { foldPaths: foldPaths2, tolerated: tolerated2, predicted: predicted2 } = await preflightMergeToMain(
+      deps,
+      deployModel2,
+      "origin/development",
+      "development -> main merge would conflict on untolerated path(s)",
+      "The train is misaligned: reconcile main and development via an approved alignment PR, then rerun release."
+    );
+    const preFold2 = {};
+    const { versionFold: versionFold2, releaseSha: releaseSha2 } = await runFoldStage(deps, "development", preFold2, async () => {
+      await executeMergeToMain(deps, "development", "development -> main", tolerated2, predicted2, preFold2);
+      const versionFold3 = await foldReleaseVersion(deps, deployModel2, tag2, foldPaths2);
+      const releaseSha3 = requireValue(clean(await deps.run("git", ["rev-parse", "main"])), "release sha");
+      return { versionFold: versionFold3, releaseSha: releaseSha3 };
     });
-    const versionFold2 = await foldReleaseVersion(deps, deployModel2, tag2, foldPaths2);
-    const releaseSha2 = requireValue(clean(await deps.run("git", ["rev-parse", "main"])), "release sha");
     const { checks: checks2, releaseUrl: releaseUrl2, announceNote: announceNote2, dispatch: d2 } = await completeMainRelease(deps, ctx, meta, deployModel2, watch, options, tag2, releaseSha2);
     const devRollForward2 = await rollDevelopmentForward(deps, ctx, tag2);
     if (directTrack) {
@@ -10560,10 +10734,14 @@ async function runTrainApplyPipeline(mode, input) {
     );
   }
   const releasedRcSha = clean(await deps.run("git", ["rev-parse", "origin/rc"]));
-  await executeMergeToMain(deps, "rc", "rc -> main", tolerated, predicted);
-  const tag = requireValue(clean(await deps.run("node", ["scripts/next-version.mjs", "release"])), "release tag");
-  const versionFold = await foldReleaseVersion(deps, deployModel, tag, foldPaths);
-  const releaseSha = requireValue(clean(await deps.run("git", ["rev-parse", "main"])), "release sha");
+  const preFold = {};
+  const { tag, versionFold, releaseSha } = await runFoldStage(deps, "rc", preFold, async () => {
+    await executeMergeToMain(deps, "rc", "rc -> main", tolerated, predicted, preFold);
+    const tag2 = requireValue(clean(await deps.run("node", ["scripts/next-version.mjs", "release"])), "release tag");
+    const versionFold2 = await foldReleaseVersion(deps, deployModel, tag2, foldPaths);
+    const releaseSha2 = requireValue(clean(await deps.run("git", ["rev-parse", "main"])), "release sha");
+    return { tag: tag2, versionFold: versionFold2, releaseSha: releaseSha2 };
+  });
   const { checks, releaseUrl, announceNote, dispatch: d } = await completeMainRelease(deps, ctx, meta, deployModel, watch, options, tag, releaseSha);
   const retirement = await retireRcRuntime(deps, ctx, deployModel, d.deployStatus, releasedRcSha);
   const devRollForward = await rollDevelopmentForward(deps, ctx, tag);
@@ -11165,7 +11343,11 @@ async function runHotfixRelease(deps, versionInput, options = {}) {
       runs.push(await watchReleaseRun(deps, ctx, workflow, mergedSha));
     }
     deployNote = "watched release-triggered deploy.yml + publish.yml";
-  } else if (deployModel === "tenant-container" || deployModel === "solo-container" || deployModel === "registry-publish") {
+  } else if (deployModel === "registry-publish") {
+    const run = await watchReleaseRun(deps, ctx, "publish.yml", mergedSha);
+    runs.push(run);
+    deployNote = "watched this repo's own release-triggered publish.yml (#2428 \u2014 no central dispatch)";
+  } else if (deployModel === "tenant-container" || deployModel === "solo-container") {
     const meta = requireProjectMetaForTrain(await loadProjectMeta(deps, ctx), ctx.repo);
     const deploy = await dispatchDeploy(
       deps,
@@ -11181,7 +11363,7 @@ async function runHotfixRelease(deps, versionInput, options = {}) {
     );
     const publish = deploy.deployStatus === "success" ? await dispatchPublishIfRequired(deps, ctx, meta, deployModel, "main", tag, true, "report") : null;
     let dispatch = appendPublishDispatch(deploy, publish);
-    if (!publish && deploy.deployStatus !== "success" && meta.publishRequired && (deployModel === "tenant-container" || deployModel === "solo-container")) {
+    if (!publish && deploy.deployStatus !== "success" && meta.publishRequired) {
       const reason = deploy.deployStatus === "failure" ? "box deploy failed \u2014 redeploy the box before publishing" : "box deploy not confirmed (run with --watch) \u2014 publish after the box deploy lands";
       dispatch = {
         ...dispatch,
@@ -11189,25 +11371,17 @@ async function runHotfixRelease(deps, versionInput, options = {}) {
       };
     }
     deployNote = dispatch.note;
-    if (deployModel !== "registry-publish") {
-      runs.push({
-        workflow: "tenant-deploy.yml",
-        url: deploy.runUrl,
-        conclusion: deploy.deployStatus === "success" ? "success" : deploy.deployStatus === "failure" ? "failure" : deploy.deployStatus ?? "pending"
-      });
-    }
+    runs.push({
+      workflow: "tenant-deploy.yml",
+      url: deploy.runUrl,
+      conclusion: deploy.deployStatus === "success" ? "success" : deploy.deployStatus === "failure" ? "failure" : deploy.deployStatus ?? "pending"
+    });
     if (publish?.runUrl) {
       runs.push({
         workflow: "tenant-publish.yml",
         url: publish.runUrl,
         conclusion: publish.deployStatus === "success" ? "success" : publish.deployStatus === "failure" ? "failure" : publish.deployStatus ?? "pending"
       });
-    } else if (deployModel === "registry-publish") {
-      runs.push({
-        workflow: "tenant-publish.yml",
-        url: deploy.runUrl,
-        conclusion: deploy.deployStatus === "success" ? "success" : deploy.deployStatus === "failure" ? "failure" : deploy.deployStatus ?? "pending"
-      });
     }
   } else {
     deployNote = `no hotfix deploy dispatch for deployModel=${deployModel} \u2014 prod deploy is repo-specific`;
@@ -14751,16 +14925,24 @@ function cursorPluginPinsNeedingSeed(pins, releasedVersion) {
     return false;
   });
 }
+function cursorPluginCacheSeedTargets(pins, releasedVersion, cacheRoot, cacheRootExists = false) {
+  const needing = cursorPluginPinsNeedingSeed(pins, releasedVersion);
+  if (needing.length > 0) return needing.map((pin) => pin.path);
+  if (pins.length === 0 && cacheRoot && cacheRootExists && isSemverVersion(releasedVersion)) {
+    return [(0, import_node_path15.join)(cacheRoot, `v${releasedVersion.replace(/^v/, "")}`)];
+  }
+  return [];
+}
 async function applyCursorPluginCacheSeed(input) {
   if (!isSemverVersion(input.releasedVersion)) return false;
-  const pinsToSeed = cursorPluginPinsNeedingSeed(input.pins, input.releasedVersion);
-  if (pinsToSeed.length === 0) return false;
+  const targets = cursorPluginCacheSeedTargets(input.pins, input.releasedVersion, input.cacheRoot, input.cacheRootExists);
+  if (targets.length === 0) return false;
   const tmpRoot = await input.mkdtemp("mmi-cursor-seed-");
   const source = await resolvePluginMmiSource(input.releasedVersion, input.hubCheckout, tmpRoot, input.execFileP);
   if (!source) return false;
   input.log(`  \u21BB seeding Cursor MMI plugin cache \u2192 ${input.releasedVersion}\u2026`);
-  for (const pin of pinsToSeed) {
-    syncDirContents(source, pin.path);
+  for (const dest of targets) {
+    syncDirContents(source, dest);
   }
   (0, import_node_fs14.rmSync)(tmpRoot, { recursive: true, force: true });
   return true;
@@ -15040,6 +15222,33 @@ function buildMmiPluginCacheCleanupCheck(input) {
     }))
   };
 }
+var CURSOR_PLUGIN_CACHE_CLEANUP_LABEL = "leftover older MMI plugin cache pins (Cursor)";
+var CURSOR_PLUGIN_CACHE_CLEANUP_FIX = "older Cursor MMI plugin cache pins can be removed manually after confirming in Cursor Settings \u2192 Plugins \u2192 Marketplace which pin is registered";
+function buildCursorPluginCacheCleanupCheck(input) {
+  const base = {
+    ok: true,
+    label: CURSOR_PLUGIN_CACHE_CLEANUP_LABEL,
+    fix: CURSOR_PLUGIN_CACHE_CLEANUP_FIX
+  };
+  if (!input.isOrgRepo || !isSemverVersion2(input.releasedVersion)) return base;
+  const semverPins = input.pins.filter((pin) => isSemverVersion2(pin.version));
+  if (semverPins.length === 0) return base;
+  const activeVersion = semverPins.map((pin) => pin.version).reduce((a, b) => compareVersions(a, b) >= 0 ? a : b);
+  const protectedVersions = new Set(
+    [normalizeVersion(input.releasedVersion), normalizeVersion(activeVersion)].filter((v) => Boolean(v))
+  );
+  const leftoverPins = semverPins.filter((pin) => !protectedVersions.has(normalizeVersion(pin.version)));
+  if (leftoverPins.length === 0) return base;
+  const leftovers = leftoverPins.map((pin) => ({ surface: "cursor", root: input.cacheRoot, name: pin.name, path: pin.path }));
+  const listed = leftoverPins.map((pin) => `${pin.name} (${pin.version})`).join(", ");
+  return {
+    ...base,
+    ok: false,
+    severityOverride: "advisory",
+    leftovers,
+    fix: `${leftoverPins.length} older Cursor MMI plugin cache pin(s) left behind by marketplace re-clones: ${listed}. Not auto-removed: which pin Cursor's Team Marketplace registration is bound to cannot be read programmatically (no per-user CLI, #2409), and the registration may still point at an older pin \u2014 after confirming in Cursor Settings \u2192 Plugins \u2192 Marketplace that the newer pin is the registered one, the older dir(s) can be removed manually`
+  };
+}
 var NESTED_PLUGIN_TREE_LABEL = "self-nested MMI plugin cache tree (#1126)";
 var NESTED_PLUGIN_TREE_FIX = "SessionStart and mmi-cli doctor auto-clear when possible; if this persists, run the MAX_PATH-safe robocopy cleanup for a self-nested MMI plugin cache tree (#1126)";
 function nestedPluginTreeCleanupCommand(paths, isWindows) {
@@ -15062,7 +15271,21 @@ function buildNestedPluginTreeCheck(input) {
     fix: `${nested.length} self-nested MMI plugin cache tree(s) (#1126) exceed MAX_PATH and can't self-clean \u2014 run: ${nestedPluginTreeCleanupCommand(nested.map((n) => n.path), input.isWindows)}`
   };
 }
+function nestedTreeReinstallGapFix(surfaces) {
+  const recoveries = surfaces.map((s) => PLUGIN_SURFACE_HEAL[s].recovery).join("   and   ");
+  return `self-nested MMI plugin cache tree(s) cleared, but the plugin was NOT reinstalled for ${surfaces.join(" + ")} (host CLI unavailable or reinstall failed) \u2014 run: ${recoveries}`;
+}
 var CODEX_ACTIVE_CACHE_LABEL = "Codex active plugin cache (vs latest release)";
+function codexEnabledPluginVersionFromList(jsonText, pluginId = MMI_PLUGIN_ID) {
+  try {
+    const parsed = JSON.parse(jsonText);
+    const rows = Array.isArray(parsed?.installed) ? parsed.installed : [];
+    const row = rows.find((r) => r?.pluginId === pluginId && r.installed === true && r.enabled === true);
+    return isSemverVersion2(row?.version) ? row.version.trim().replace(/^v/, "") : void 0;
+  } catch {
+    return void 0;
+  }
+}
 function buildCodexActiveCacheCheck(input) {
   const base = {
     ok: true,
@@ -15070,6 +15293,18 @@ function buildCodexActiveCacheCheck(input) {
     fix: CODEX_PLUGIN_RECOVERY
   };
   if (!input.isOrgRepo || !isSemverVersion2(input.releasedVersion)) return base;
+  if (isSemverVersion2(input.codexActiveVersion)) {
+    if (compareVersions(input.codexActiveVersion, input.releasedVersion) < 0) {
+      return {
+        ...base,
+        ok: false,
+        activeCacheVersion: input.codexActiveVersion,
+        releasedVersion: input.releasedVersion,
+        fix: `\`codex plugin list\` reports mmi@mutmutco enabled at ${input.codexActiveVersion} < ${input.releasedVersion} (a newer cache dir or install record may also exist and mask it) \u2014 run \`mmi-cli doctor --apply\` (forces the Codex remove/re-add when \`codex\` is on PATH; restart Codex after), or manually: ${CODEX_PLUGIN_RECOVERY}`
+      };
+    }
+    return { ...base, activeCacheVersion: input.codexActiveVersion, releasedVersion: input.releasedVersion };
+  }
   if (isSemverVersion2(input.codexRecordVersion) && compareVersions(input.codexRecordVersion, input.releasedVersion) < 0) {
     return base;
   }
@@ -15117,6 +15352,55 @@ function reloadAction(surface) {
       return "restart Claude Code (or run /reload-plugins)";
   }
 }
+function restartAction(surface) {
+  switch (surface) {
+    case "claude-vscode":
+      return "fully restart VS Code";
+    case "codex":
+      return "fully restart Codex";
+    case "opencode":
+      return "fully restart OpenCode";
+    case "cursor":
+      return "fully restart Cursor";
+    case "claude-cli":
+    case "shell":
+    default:
+      return "fully restart Claude Code";
+  }
+}
+function parseSessionSkillRootVersion(pluginRoot) {
+  const trimmed = pluginRoot?.trim();
+  if (!trimmed) return void 0;
+  const segments = trimmed.split(/[\\/]+/).filter(Boolean);
+  const mmiIdx = segments.findIndex((seg, i) => seg === "mmi" && segments[i - 1] === "mutmutco");
+  if (mmiIdx < 0) return void 0;
+  const candidate = segments[mmiIdx + 1];
+  return candidate && /^v?\d+\.\d+\.\d+/.test(candidate) ? candidate.replace(/^v/, "") : void 0;
+}
+var SESSION_SKILL_ROOT_LABEL = "Session-loaded MMI skill roots (vs on-disk plugin cache)";
+function buildSessionSkillRootCheck(input) {
+  const base = {
+    ok: true,
+    label: SESSION_SKILL_ROOT_LABEL,
+    fix: `fully restart the host to load the current MMI skill roots \u2014 a running session does not hot-refresh them, and a plugin reload does not re-register them`
+  };
+  if (!input.isOrgRepo) return base;
+  const sessionVersion = parseSessionSkillRootVersion(input.pluginRoot);
+  if (!sessionVersion) return base;
+  const activeCacheVersion = highestSemver(input.cacheVersions ?? []);
+  if (!isSemverVersion2(activeCacheVersion)) return { ...base, sessionVersion };
+  if (compareVersions(sessionVersion, activeCacheVersion) >= 0) {
+    return { ...base, sessionVersion, activeCacheVersion };
+  }
+  return {
+    ...base,
+    ok: false,
+    severityOverride: "advisory",
+    sessionVersion,
+    activeCacheVersion,
+    fix: `This ${input.surface} session loaded MMI skill roots from ${sessionVersion} but the on-disk plugin cache is ${activeCacheVersion} \u2014 a running session does NOT hot-refresh skill roots and a plugin reload does not re-register them, so ${restartAction(input.surface)} to load ${activeCacheVersion}. Until then this session keeps executing the ${sessionVersion} skill bundle; halt autonomous /grind and /build first.`
+  };
+}
 var CLAUDE_RECOVERY = `claude plugin marketplace remove ${LEGACY_MMI_MARKETPLACE} && claude plugin marketplace remove mutmutco && claude plugin marketplace add mutmutco/MMI-Hub --ref main && claude plugin install mmi@mutmutco`;
 var CODEX_RECOVERY = `codex plugin marketplace remove ${LEGACY_MMI_MARKETPLACE} && codex plugin marketplace remove mutmutco && codex plugin marketplace add mutmutco/MMI-Hub --ref main && codex plugin add mmi@mutmutco`;
 var CURSOR_RECOVERY = "in Cursor Dashboard \u2192 Settings \u2192 Plugins, click Update next to the MMI Team Marketplace";
@@ -15329,10 +15613,12 @@ function isSemverVersion2(v) {
 function staleRecordCommand(surface) {
   return surface === "codex" ? CODEX_PLUGIN_RECOVERY : CLAUDE_PLUGIN_RECOVERY;
 }
+var CLAUDE_UPDATE_BUTTON_WARNING = "Windows: do NOT use the in-app Update button for this plugin (#2411, hits the #1126 MAX_PATH nesting bug) \u2014 run `mmi-cli doctor --apply` instead";
 function staleSurfacesFix(stale, releasedVersion) {
   const parts = stale.map((s) => {
     const at = s.recordPath ? ` (${s.recordPath})` : "";
-    return `${s.surface} record${at} is at ${s.installedVersion}${releasedVersion ? ` < ${releasedVersion}` : ""} \u2014 run: ${staleRecordCommand(s.surface)}`;
+    const warning = s.surface === "claude" ? ` \u2014 ${CLAUDE_UPDATE_BUTTON_WARNING}` : "";
+    return `${s.surface} record${at} is at ${s.installedVersion}${releasedVersion ? ` < ${releasedVersion}` : ""} \u2014 run: ${staleRecordCommand(s.surface)}${warning}`;
   });
   return `stale installed-plugin record on ${stale.map((s) => s.surface).join(" + ")}: ${parts.join("; ")}`;
 }
@@ -15374,18 +15660,71 @@ function buildInstalledPluginVersionCheck(input) {
     staleSurfaces: stale
   };
 }
+var MANAGED_PLUGINS = [
+  {
+    // Marketplace-qualified key exactly as installed_plugins.json stores it (same convention as
+    // MMI_PLUGIN_ID = 'mmi@mutmutco') — a bare 'jervaise-powertools' would never match a real record
+    // and the check would be a permanent no-op. The same `<marketplace>/<name>` segments also address its
+    // Cursor Team Marketplace cache dir (~/.cursor/plugins/cache/jervaise/jervaise-powertools/<version>/).
+    id: "jervaise-powertools@jervaise",
+    label: "jervaise-powertools",
+    healCommand: "jerv-cli doctor --apply",
+    opencodePackage: "@jervaise/opencode-jerv"
+  }
+];
+function parseManagedPluginId(id) {
+  const at = id.lastIndexOf("@");
+  if (at <= 0 || at === id.length - 1) return null;
+  return { name: id.slice(0, at), marketplace: id.slice(at + 1) };
+}
+var MANAGED_PLUGIN_DRIFT_LABEL = "managed org plugin version drift (cross-surface)";
+function managedPluginDriftFix(drifted) {
+  return drifted.map((d) => {
+    const versions = d.versions.map((v) => `${v.version} (${v.surface})`).join(" vs ");
+    return `${d.label} drift: ${versions} \u2192 run \`${d.healCommand}\``;
+  }).join(" ; ");
+}
+function buildManagedPluginDriftCheck(input) {
+  const base = { ok: true, label: MANAGED_PLUGIN_DRIFT_LABEL, fix: "" };
+  if (!input.isOrgRepo) return base;
+  const registry2 = input.plugins ?? MANAGED_PLUGINS;
+  const drifted = [];
+  const normalize = (v) => v.replace(/^v/, "");
+  for (const descriptor of registry2) {
+    const versions = [];
+    for (const source of input.sources) {
+      if (source.directVersions && descriptor.id in source.directVersions) {
+        const version2 = source.directVersions[descriptor.id];
+        if (isSemverVersion2(version2)) versions.push({ surface: source.surface, version: normalize(version2) });
+        continue;
+      }
+      const records = source.installed?.plugins?.[descriptor.id];
+      if (!Array.isArray(records) || records.length === 0) continue;
+      const recordVersion = bestRecord(records).version;
+      const version = isSemverVersion2(recordVersion) ? recordVersion : highestSemver(source.cacheVersions?.[descriptor.id] ?? []);
+      if (!isSemverVersion2(version)) continue;
+      versions.push({ surface: source.surface, version: normalize(version) });
+    }
+    if (versions.length < 2) continue;
+    const distinctVersions = new Set(versions.map((v) => v.version));
+    if (distinctVersions.size < 2) continue;
+    drifted.push({ pluginId: descriptor.id, label: descriptor.label, healCommand: descriptor.healCommand, versions });
+  }
+  if (drifted.length === 0) return base;
+  return { ...base, ok: false, fix: managedPluginDriftFix(drifted), drifted };
+}
 var OPENCODE_VERSION_LABEL = "installed OpenCode MMI adapter version (vs latest release)";
 function buildOpencodeVersionCheck(input) {
   const fix = pluginRecoveryFix("opencode");
   const base = { ok: true, label: OPENCODE_VERSION_LABEL, fix };
   if (!input.isOrgRepo || !isSemverVersion2(input.releasedVersion)) return base;
   if (!isSemverVersion2(input.installedVersion)) {
-    return { ...base, ok: false, releasedVersion: input.releasedVersion };
+    return { ...base, ok: false, severityOverride: "hard", releasedVersion: input.releasedVersion };
   }
   if (compareVersions(input.installedVersion, input.releasedVersion) >= 0) {
     return { ...base, installedVersion: input.installedVersion, releasedVersion: input.releasedVersion };
   }
-  return { ...base, ok: false, installedVersion: input.installedVersion, releasedVersion: input.releasedVersion };
+  return { ...base, ok: false, severityOverride: "hard", installedVersion: input.installedVersion, releasedVersion: input.releasedVersion };
 }
 function pickOpencodeActiveVersion(input) {
   for (const value of [input.envStamp, input.cacheVersion, input.diskVersion]) {
@@ -15593,6 +15932,9 @@ function cursorPluginInstallFix(input) {
   const localSeed = input.hubCheckout ? `temporary fallback: copy ${joinCachePath(input.hubCheckout, "plugins", "mmi")} to ${cacheDir}, then restart Cursor` : `temporary fallback: copy plugins/mmi from a local MMI-Hub checkout to ${cacheDir}, then restart Cursor`;
   return `Cursor plugin cache at ${cacheDir} is empty or missing ${CURSOR_PLUGIN_JSON_REL}, ${CURSOR_HOOKS_JSON_REL}, or the cursor-hook dispatcher script \u2014 ${autoSeed}; ${marketplaceRefresh}; ${authSteps}; ${localSeed}; ${logHint}; ${guide}`;
 }
+function cursorSeededFromNothingAdvisoryFix(releasedVersion) {
+  return `Cursor MMI plugin cache seeded from nothing${releasedVersion ? ` at ${releasedVersion}` : ""} \u2014 the cache is healthy, but the Team Marketplace pin REGISTRATION could not be verified (no per-user CLI, #2409): if MMI commands do not load after restarting Cursor, a master-admin must register/refresh the MMI Team Marketplace in Cursor Settings \u2192 Plugins \u2192 Marketplace (\xA76.8); ${CURSOR_MARKETPLACE_INSTALL_GUIDE}`;
+}
 function buildCursorPluginInstallCheck(input) {
   const base = {
     ok: true,
@@ -15634,9 +15976,10 @@ function buildCursorPluginInstallCheck(input) {
     return {
       ...base,
       ok: false,
+      severityOverride: "advisory",
       cacheRoot: input.cacheRoot,
       pins: input.pins,
-      fix: `Cursor MMI plugin cache is behind ${input.releasedVersion} (${stale}) \u2014 run \`mmi-cli doctor --apply\` to seed the cache from the latest release (effective after restart Cursor); when Dashboard \u2192 Settings \u2192 Plugins shows Update next to the MMI Team Marketplace, a master-admin can refresh the pin there instead; ${CURSOR_MARKETPLACE_INSTALL_GUIDE}`
+      fix: `Cursor MMI plugin cache is behind ${input.releasedVersion} (${stale}) \u2014 run \`mmi-cli doctor --apply\` to seed the cache from the latest release (effective after restart Cursor); cache healthy after that, but the Team Marketplace REGISTRATION may still show stale \u2014 a master-admin must manually refresh it: Cursor Settings \u2192 Plugins \u2192 Marketplace, click Update next to the MMI Team Marketplace (no per-user CLI exists to do this automatically, #2409); ${CURSOR_MARKETPLACE_INSTALL_GUIDE}`
     };
   }
   return { ...base, cacheRoot: input.cacheRoot, pins: input.pins };
@@ -15709,9 +16052,7 @@ function buildHubDeployFreshnessCheck(input) {
   };
 }
 var PLAYWRIGHT_MCP_VISION_CAP_LABEL = "Playwright MCP vision caps (--caps=vision prohibited)";
-var PLAYWRIGHT_MCP_VISION_CAP_FIX = "remove --caps=vision (and vision-first defaults) from Playwright MCP args \u2014 use DOM-first tools; see skills/browser-automation/SKILL.md and bootstrap seed mcp-playwright.template.json";
 var PLAYWRIGHT_MCP_OUTPUT_DIR_LABEL = "Playwright MCP output dir (use tmp/playwright-mcp)";
-var PLAYWRIGHT_MCP_OUTPUT_DIR_FIX = "configure Playwright MCP args with --output-dir tmp/playwright-mcp; see skills/browser-automation/SKILL.md and bootstrap seed mcp-playwright.template.json";
 function textHasPlaywrightMcp(content) {
   const normalized = content.replace(/\r\n/g, "\n");
   return /@playwright\/mcp/.test(normalized) || /mcp_servers\.playwright/.test(normalized) || /"playwright"\s*:\s*\{/.test(normalized) || /\bmcpServers\b/.test(normalized);
@@ -15726,45 +16067,10 @@ function textHasPlaywrightVisionCap(content) {
   if (/\bvision[-_]?(?:first|only|mode)\b/i.test(normalized)) return true;
   return false;
 }
-function buildPlaywrightMcpVisionCapCheck(input) {
-  const base = {
-    ok: true,
-    label: PLAYWRIGHT_MCP_VISION_CAP_LABEL,
-    fix: PLAYWRIGHT_MCP_VISION_CAP_FIX
-  };
-  if (!input.isOrgRepo) return base;
-  const offending = input.configs.filter((c) => textHasPlaywrightVisionCap(c.content)).map((c) => c.path);
-  if (offending.length === 0) return base;
-  return {
-    ...base,
-    ok: false,
-    offendingPaths: offending,
-    fix: `${PLAYWRIGHT_MCP_VISION_CAP_FIX} \u2014 found in: ${offending.join(", ")}`
-  };
-}
 function textHasCanonicalPlaywrightOutputDir(content) {
   const normalized = content.replace(/\r\n/g, "\n");
   return /--output-dir(?:\s*=\s*|["'\s,]+)tmp\/playwright-mcp\b/.test(normalized);
 }
-function textNeedsPlaywrightOutputDir(content) {
-  return textHasPlaywrightMcp(content) && !textHasCanonicalPlaywrightOutputDir(content);
-}
-function buildPlaywrightMcpOutputDirCheck(input) {
-  const base = {
-    ok: true,
-    label: PLAYWRIGHT_MCP_OUTPUT_DIR_LABEL,
-    fix: PLAYWRIGHT_MCP_OUTPUT_DIR_FIX
-  };
-  if (!input.isOrgRepo) return base;
-  const offending = input.configs.filter((c) => textNeedsPlaywrightOutputDir(c.content)).map((c) => c.path);
-  if (offending.length === 0) return base;
-  return {
-    ...base,
-    ok: false,
-    offendingPaths: offending,
-    fix: `${PLAYWRIGHT_MCP_OUTPUT_DIR_FIX} \u2014 missing in: ${offending.join(", ")}`
-  };
-}
 var STRAY_BROWSER_ARTIFACT_DIRS = [".playwright-mcp", "playwright-report", "test-results"];
 var BROWSER_ARTIFACTS_LABEL = "browser MCP artifacts outside tmp/ (use tmp/playwright-mcp)";
 var BROWSER_ARTIFACTS_FIX = "move or delete stray Playwright output at repo root; re-run MCP with --output-dir tmp/playwright-mcp \u2014 see skills/browser-automation/SKILL.md";
@@ -15804,6 +16110,12 @@ function buildSelfUpdateHaltPayload(input) {
     checks: input.checks
   };
 }
+var DOCTOR_SELF_UPDATE_HALT_EXIT_CODE = 3;
+var DOCTOR_SELF_UPDATE_HALT_SENTINEL = "MMI_DOCTOR_SELF_UPDATE_HALT";
+function selfUpdateHaltSentinelLine(input) {
+  const to = input.report.releasedVersion ?? "latest";
+  return `${DOCTOR_SELF_UPDATE_HALT_SENTINEL} rerunRequired=true updatedTo=${to} rerun="mmi-cli ${input.rerunArgs.join(" ")}"`;
+}
 var DOCTOR_POST_SELF_UPDATE_ENV = "MMI_DOCTOR_POST_SELF_UPDATE";
 function buildSelfUpdateReexecArgs(opts) {
   const args = ["doctor"];
@@ -15830,6 +16142,30 @@ function preflightOutcome(input) {
 function pluginAutonomousHaltLine(reloadHint) {
   return `\u26A0 PLUGIN RELOAD REQUIRED \u2014 mmi:* skills and agent types are unavailable until you ${reloadHint}. Halt autonomous /grind and /build until then.`;
 }
+var DOCTOR_EXTENDED_CHECK_LABELS = /* @__PURE__ */ new Set([
+  AWS_CROSS_ACCOUNT_LABEL,
+  HUB_DEPLOY_FRESHNESS_LABEL,
+  PLAYWRIGHT_MCP_VISION_CAP_LABEL,
+  PLAYWRIGHT_MCP_OUTPUT_DIR_LABEL,
+  BROWSER_ARTIFACTS_LABEL,
+  SCRATCH_GC_LABEL,
+  GIT_GC_LABEL,
+  OPENCODE_VERSION_LABEL,
+  OPENCODE_DESKTOP_BOOTSTRAP_LABEL
+]);
+function isDoctorExtendedCheck(label) {
+  if (DOCTOR_EXTENDED_CHECK_LABELS.has(label)) return true;
+  if (label.startsWith(HUB_DEPLOY_FRESHNESS_LABEL)) return true;
+  if (label.startsWith("@mutmutco design-system") || label.startsWith("@mutmutco registry components")) return true;
+  return false;
+}
+function isAdvisoryDoctorCheck(check) {
+  if (check.severityOverride) return check.severityOverride === "advisory";
+  return isDoctorExtendedCheck(check.label);
+}
+function doctorExitCode(checks) {
+  return checks.some((c) => !c.ok && !isAdvisoryDoctorCheck(c)) ? 1 : 0;
+}
 function renderPluginUpdateReportStaleOnly(report) {
   const v = report.versions;
   const released = v.released;
@@ -15844,24 +16180,97 @@ function renderPluginUpdateReportStaleOnly(report) {
   return ["Update commands (stale surfaces):", ...blocks];
 }
 var DOCTOR_VERBOSE_HINT = "Run mmi-cli doctor --verbose for the full audit checklist + version report.";
-function renderTerseDoctorReport(input) {
-  const cliVersion = input.updateReport.versions.cli;
-  const versionSuffix = cliVersion ? ` (mmi-cli ${cliVersion})` : "";
-  if (!input.gaps.length) {
-    return [`\u2713 MMI doctor: all checks passed${versionSuffix}.`, DOCTOR_VERBOSE_HINT];
+function doctorCheckGlyph(check) {
+  if (check.ok) return "\u2713";
+  return isAdvisoryDoctorCheck(check) ? "\u26A0" : "\u2717";
+}
+function doctorVerdictLine(input) {
+  const gaps = input.checks.filter((c) => !c.ok);
+  const hardGaps = gaps.filter((c) => !isAdvisoryDoctorCheck(c));
+  const softGaps = gaps.filter((c) => isAdvisoryDoctorCheck(c));
+  if (input.shouldApply) {
+    if (hardGaps.length > 0) {
+      return `\u2717 ${hardGaps.length} repair${hardGaps.length === 1 ? "" : "s"} failed \u2014 see the items above.`;
+    }
+    if (softGaps.length > 0) {
+      return `\u26A0 Healed what I could; ${softGaps.length} item${softGaps.length === 1 ? "" : "s"} still need${softGaps.length === 1 ? "s" : ""} attention (above).`;
+    }
+    const healed = input.healedCount ?? 0;
+    if (healed > 0) return `\u2713 Healed ${healed} item${healed === 1 ? "" : "s"} \u2014 everything checks out now.`;
+    return "\u2713 Everything healthy \u2014 nothing needed fixing.";
   }
-  const lines = [];
-  for (const c of input.gaps) {
-    lines.push(`\u2717 ${c.label}`);
-    lines.push(`   \u2192 ${c.fix}`);
+  const attention = gaps.length;
+  if (attention > 0) {
+    return `\u26A0 ${attention} item${attention === 1 ? " needs" : "s need"} attention \u2014 run \`mmi-cli doctor --apply\` to heal.`;
+  }
+  return "\u2713 Everything healthy.";
+}
+function doctorHumanLines(input) {
+  const gaps = input.checks.filter((c) => !c.ok);
+  const lines = [
+    doctorVerdictLine({ checks: input.checks, shouldApply: input.shouldApply, healedCount: input.healedCount }),
+    "",
+    "Checks",
+    ...input.checks.map((c) => `  ${doctorCheckGlyph(c)} ${c.label}`)
+  ];
+  if (gaps.length > 0) {
+    lines.push("", input.shouldApply ? "Repairs" : "Will fix on --apply");
+    for (const c of gaps) {
+      const mark = input.shouldApply ? isAdvisoryDoctorCheck(c) ? "\u26A0" : "\u2717" : "\u2192";
+      lines.push(`  ${mark} ${c.label} \u2014 ${c.fix}`);
+    }
+  }
+  if (input.shouldApply && input.pluginReloadRequired) {
+    lines.push("", `\u21BB ${input.reloadHint ?? "reload"} so the healed plugin/MCP installs load.`);
   }
   const stale = renderPluginUpdateReportStaleOnly(input.updateReport);
   if (stale.length) {
-    lines.push("");
-    lines.push(...stale);
+    lines.push("", ...stale);
+  } else if (!input.verbose) {
+    lines.push("", DOCTOR_VERBOSE_HINT);
+  }
+  if (!input.verbose) return lines;
+  lines.push("", ...renderPluginUpdateReport(input.updateReport));
+  lines.push(
+    "",
+    doctorSummaryLine({ checks: input.checks, updateReport: input.updateReport, shouldApply: input.shouldApply, healedCount: input.healedCount }),
+    ...doctorAuditLines({
+      checks: input.checks,
+      shouldApply: input.shouldApply,
+      healedCount: input.healedCount,
+      cliVersion: input.updateReport.versions.cli,
+      releasedVersion: input.updateReport.versions.released
+    })
+  );
+  return lines;
+}
+function doctorSummaryLine(input) {
+  const gaps = input.checks.filter((c) => !c.ok);
+  const mode = input.shouldApply ? "apply" : "plan";
+  const released = input.updateReport.versions.released ?? "unknown";
+  const failed = gaps.filter((c) => !isAdvisoryDoctorCheck(c)).length;
+  const countSummary = input.shouldApply ? `${input.healedCount ?? 0} healed` : `${gaps.length} planned`;
+  return `summary: mode ${mode} \xB7 released ${released} \xB7 ${countSummary} \xB7 ${failed} failed`;
+}
+function doctorAuditLines(input) {
+  const gaps = input.checks.filter((c) => !c.ok);
+  const failed = gaps.filter((c) => !isAdvisoryDoctorCheck(c)).length;
+  const lines = [
+    "MMI doctor audit",
+    `mode: ${input.shouldApply ? "apply" : "plan"}`,
+    `cli: ${input.cliVersion ?? "unknown"}`,
+    `released: ${input.releasedVersion ?? "unknown"}`,
+    `checks: ${input.checks.length} (${input.checks.length - gaps.length} ok, ${gaps.length} gap)`,
+    `planned actions: ${gaps.length}`,
+    `healed actions: ${input.healedCount ?? 0}`,
+    `failed actions: ${failed}`
+  ];
+  if (gaps.length) {
+    lines.push("actions:");
+    for (const c of gaps) {
+      lines.push(`[${isAdvisoryDoctorCheck(c) ? "advisory" : "auto"}] ${c.label}: ${c.fix}`);
+    }
   }
-  lines.push("");
-  lines.push(`\u26A0 ${input.gaps.length} item(s) need attention \u2014 ${DOCTOR_VERBOSE_HINT}`);
   return lines;
 }
 var PLUGIN_RESOLVABILITY_LABEL = "MMI plugin resolvability (marketplace + cache present)";
@@ -15894,6 +16303,262 @@ function buildPluginResolvabilityCheck(input) {
   }
 }
 
+// src/mcp-reconcile.ts
+var PLAYWRIGHT_MCP_SPEC = {
+  name: "playwright",
+  command: "npx",
+  args: ["-y", "@playwright/mcp@latest", "--output-dir", "tmp/playwright-mcp"],
+  legacyNames: []
+};
+var MCP_RECONCILE_LABEL = "MCP server registrations (org-managed Playwright)";
+var MCP_RECONCILE_FIX = "register/reconcile the org Playwright MCP server (npx -y @playwright/mcp@latest --output-dir tmp/playwright-mcp) \u2014 run `mmi-cli doctor --apply`; see skills/browser-automation/SKILL.md and bootstrap seed mcp-playwright.template.json";
+function extractServerBlock(content, format, spec) {
+  return format === "json" ? extractJsonServer(content, spec) : extractTomlServer(content, spec);
+}
+function extractJsonServer(content, spec) {
+  let parsed;
+  try {
+    parsed = JSON.parse(content);
+  } catch {
+    return { kind: "unparseable" };
+  }
+  if (parsed == null || typeof parsed !== "object") return { kind: "unparseable" };
+  const servers = parsed.mcpServers;
+  if (servers == null || typeof servers !== "object") return { kind: "absent" };
+  const bag = servers;
+  for (const name of [spec.name, ...spec.legacyNames]) {
+    if (Object.prototype.hasOwnProperty.call(bag, name)) {
+      return { kind: "found", matchedName: name, isLegacy: name !== spec.name, blockText: JSON.stringify(bag[name]) };
+    }
+  }
+  return { kind: "absent" };
+}
+function extractTomlServer(content, spec) {
+  const blocks = parseTomlBlocks(content.replace(/\r\n/g, "\n").split("\n"));
+  for (const name of [spec.name, ...spec.legacyNames]) {
+    const full = `mcp_servers.${name}`;
+    const block = blocks.find((b) => b.name === full && !b.isArrayTable);
+    if (block) {
+      const blockText = [block.headerRaw, ...block.body].filter((l) => l != null).join("\n");
+      return { kind: "found", matchedName: name, isLegacy: name !== spec.name, blockText };
+    }
+  }
+  return { kind: "absent" };
+}
+function detectMcpState(target, spec) {
+  if (!target.present) return { target, state: "skip", action: "skip", reasons: [] };
+  if (target.content == null) {
+    if (target.createWhenFileAbsent) return { target, state: "absent", action: "install", reasons: [] };
+    return { target, state: "skip", action: "skip", reasons: [] };
+  }
+  const extract = extractServerBlock(target.content, target.format, spec);
+  if (extract.kind === "unparseable") {
+    return { target, state: "drifted", action: "reconcile", reasons: ["unparseable"] };
+  }
+  if (extract.kind === "absent") {
+    return { target, state: "absent", action: "install", reasons: [] };
+  }
+  const reasons = [];
+  if (extract.isLegacy) reasons.push("legacy-name");
+  if (textHasPlaywrightVisionCap(extract.blockText)) reasons.push("vision-cap");
+  if (!textHasCanonicalPlaywrightOutputDir(extract.blockText)) reasons.push("output-dir");
+  if (reasons.length === 0) {
+    return { target, state: "healthy", action: "none", reasons: [], matchedName: extract.matchedName };
+  }
+  return { target, state: "drifted", action: "reconcile", reasons, matchedName: extract.matchedName };
+}
+function planMcpReconcile(targets, spec) {
+  return targets.map((t) => detectMcpState(t, spec));
+}
+function buildMcpReconcileCheck(plan) {
+  const base = {
+    ok: true,
+    label: MCP_RECONCILE_LABEL,
+    fix: MCP_RECONCILE_FIX,
+    severityOverride: "advisory"
+  };
+  const gaps = plan.filter((p) => p.action === "install" || p.action === "reconcile");
+  if (gaps.length === 0) return base;
+  const detail = gaps.map((g) => `${g.target.path} (${g.action === "install" ? "missing" : g.reasons.join("+") || "drifted"})`).join(", ");
+  return {
+    ...base,
+    ok: false,
+    fix: `${MCP_RECONCILE_FIX} \u2014 ${detail}`,
+    mcpGaps: gaps.map((g) => ({ path: g.target.path, action: g.action, reasons: g.reasons }))
+  };
+}
+function applyMcpReconcile(targets, spec, opts) {
+  const results = [];
+  for (const item of planMcpReconcile(targets, spec)) {
+    if (item.action !== "install" && item.action !== "reconcile") continue;
+    const t = item.target;
+    if (t.isRepoFile && !opts.repoWritesAllowed) {
+      results.push({ target: t, action: item.action, outcome: "skipped-repo-write" });
+      continue;
+    }
+    const next = t.format === "json" ? renderJsonMcpConfig(t.content, spec) : renderTomlMcpConfig(t.content, spec);
+    if (next == null) {
+      results.push({ target: t, action: item.action, outcome: "unparseable" });
+      continue;
+    }
+    results.push({ target: t, action: item.action, outcome: opts.write(t.path, next) ? "wrote" : "write-failed" });
+  }
+  return results;
+}
+function renderJsonMcpConfig(existing, spec) {
+  const canonicalEntry = { command: spec.command, args: [...spec.args] };
+  if (existing == null || existing.trim() === "") {
+    return `${JSON.stringify({ mcpServers: { [spec.name]: canonicalEntry } }, null, 2)}
+`;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(existing);
+  } catch {
+    return null;
+  }
+  if (parsed == null || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+  const obj = parsed;
+  const rawServers = obj.mcpServers;
+  if (rawServers != null && (typeof rawServers !== "object" || Array.isArray(rawServers))) return null;
+  const servers = rawServers ?? {};
+  const prior = servers[spec.name] ?? spec.legacyNames.map((n) => servers[n]).find((v) => v != null);
+  for (const legacy of spec.legacyNames) delete servers[legacy];
+  const priorObj = prior != null && typeof prior === "object" && !Array.isArray(prior) ? prior : {};
+  servers[spec.name] = { ...priorObj, ...canonicalEntry };
+  obj.mcpServers = servers;
+  const text = `${JSON.stringify(obj, null, 2)}
+`;
+  return existing.includes("\r\n") ? text.replace(/\n/g, "\r\n") : text;
+}
+function isTomlEscaped(line, i) {
+  let n = 0;
+  for (let j = i - 1; j >= 0 && line[j] === "\\"; j--) n += 1;
+  return n % 2 === 1;
+}
+function advanceTomlStringState(line, state) {
+  let multi = state;
+  let single = null;
+  let i = 0;
+  while (i < line.length) {
+    if (multi != null) {
+      if (line.startsWith(multi, i) && !(multi === '"""' && isTomlEscaped(line, i))) {
+        multi = null;
+        i += 3;
+      } else {
+        i += 1;
+      }
+      continue;
+    }
+    if (single != null) {
+      if (line[i] === single && !(single === '"' && isTomlEscaped(line, i))) single = null;
+      i += 1;
+      continue;
+    }
+    if (line[i] === "#") break;
+    if (line.startsWith('"""', i)) {
+      multi = '"""';
+      i += 3;
+      continue;
+    }
+    if (line.startsWith("'''", i)) {
+      multi = "'''";
+      i += 3;
+      continue;
+    }
+    if (line[i] === '"' || line[i] === "'") {
+      single = line[i];
+      i += 1;
+      continue;
+    }
+    i += 1;
+  }
+  return multi;
+}
+function parseTomlBlocks(lines) {
+  const blocks = [];
+  let current = { headerRaw: null, name: null, isArrayTable: false, body: [] };
+  let multi = null;
+  const tableRe = /^\s*\[\s*([^[\]]+?)\s*\]\s*$/;
+  const arrayTableRe = /^\s*\[\[\s*([^[\]]+?)\s*\]\]\s*$/;
+  for (const line of lines) {
+    if (multi == null) {
+      const am = arrayTableRe.exec(line);
+      const tm = am == null ? tableRe.exec(line) : null;
+      if (am != null || tm != null) {
+        blocks.push(current);
+        current = { headerRaw: line, name: (am ?? tm)[1].trim(), isArrayTable: am != null, body: [] };
+        continue;
+      }
+    }
+    multi = advanceTomlStringState(line, multi);
+    current.body.push(line);
+  }
+  blocks.push(current);
+  return blocks;
+}
+function mergeCanonicalTomlBody(body, commandLine, argsLine) {
+  const preserved = [];
+  for (let i = 0; i < body.length; i++) {
+    const line = body[i];
+    const trimmed = line.trim();
+    if (/^command\s*=/.test(trimmed)) continue;
+    if (/^args\s*=/.test(trimmed)) {
+      let open = (line.match(/\[/g) ?? []).length;
+      let close = (line.match(/\]/g) ?? []).length;
+      while (open > close && i + 1 < body.length) {
+        i += 1;
+        open += (body[i].match(/\[/g) ?? []).length;
+        close += (body[i].match(/\]/g) ?? []).length;
+      }
+      continue;
+    }
+    preserved.push(line);
+  }
+  return [commandLine, argsLine, ...preserved];
+}
+function renderTomlMcpConfig(existing, spec) {
+  const commandLine = `command = ${JSON.stringify(spec.command)}`;
+  const argsLine = `args = [${spec.args.map((a) => JSON.stringify(a)).join(", ")}]`;
+  const canonicalHeader = `[mcp_servers.${spec.name}]`;
+  const canonicalName = `mcp_servers.${spec.name}`;
+  if (existing == null || existing.trim() === "") {
+    return `${canonicalHeader}
+${commandLine}
+${argsLine}
+`;
+  }
+  const eol = existing.includes("\r\n") ? "\r\n" : "\n";
+  const lines = existing.replace(/\r\n/g, "\n").split("\n");
+  const legacyFull = new Set(spec.legacyNames.map((n) => `mcp_servers.${n}`));
+  const all = parseTomlBlocks(lines);
+  if (all.some((b) => b.isArrayTable && b.name != null && (b.name === canonicalName || legacyFull.has(b.name)))) return null;
+  const targetBlock = all.find((b) => !b.isArrayTable && b.name === canonicalName) ?? all.find((b) => !b.isArrayTable && b.name != null && legacyFull.has(b.name));
+  const out = [];
+  for (const b of all) {
+    if (b === targetBlock) {
+      out.push({ headerRaw: canonicalHeader, name: canonicalName, isArrayTable: false, body: mergeCanonicalTomlBody(b.body, commandLine, argsLine) });
+      continue;
+    }
+    if (targetBlock != null && !b.isArrayTable && b.name != null && legacyFull.has(b.name)) continue;
+    out.push(b);
+  }
+  if (targetBlock != null) {
+    const joined = out.flatMap((b) => b.headerRaw != null ? [b.headerRaw, ...b.body] : b.body).join("\n");
+    return eol === "\r\n" ? joined.replace(/\n/g, "\r\n") : joined;
+  }
+  const base = out.flatMap((b) => b.headerRaw != null ? [b.headerRaw, ...b.body] : b.body).join("\n").replace(/\n+$/, "");
+  const block = `${canonicalHeader}
+${commandLine}
+${argsLine}`;
+  const combined = base === "" ? `${block}
+` : `${base}
+
+${block}
+`;
+  return eol === "\r\n" ? combined.replace(/\n/g, "\r\n") : combined;
+}
+
 // src/cli-doctor-shared.ts
 var import_node_fs15 = require("node:fs");
 var import_node_path16 = require("node:path");
@@ -16150,7 +16815,20 @@ var CLAUDE_PLUGIN_TIMEOUT_MS = 12e4;
 function runHostBin(bin, args, opts) {
   return isWin ? execFileP2("cmd.exe", ["/c", bin, ...args], opts) : execFileP2(bin, args, opts);
 }
-function reexecMmiCli(args) {
+function reexecStrategies(input) {
+  const strategies = [
+    input.platform === "win32" ? { command: "cmd.exe", args: ["/c", "mmi-cli"], kind: "cmd-shim" } : { command: "mmi-cli", args: [], kind: "direct" }
+  ];
+  if (input.argv1) strategies.push({ command: input.execPath, args: [input.argv1], kind: "direct" });
+  return strategies;
+}
+var CMD_NOT_RECOGNIZED_EXIT_CODE = 9009;
+function reexecAttemptOutcome(strategy, code) {
+  if (code < 0) return "strategy-failed";
+  if (strategy.kind === "cmd-shim" && code === CMD_NOT_RECOGNIZED_EXIT_CODE) return "strategy-failed";
+  return "result";
+}
+function spawnReexecAttempt(command, args, env) {
   return new Promise((resolve6) => {
     let settled = false;
     const done = (code) => {
@@ -16159,12 +16837,20 @@ function reexecMmiCli(args) {
         resolve6(code);
       }
     };
-    const env = { ...process.env, [DOCTOR_POST_SELF_UPDATE_ENV]: "1" };
-    const child = isWin ? (0, import_node_child_process10.spawn)("cmd.exe", ["/c", "mmi-cli", ...args], { stdio: "inherit", env }) : (0, import_node_child_process10.spawn)("mmi-cli", args, { stdio: "inherit", env });
+    const child = (0, import_node_child_process10.spawn)(command, args, { stdio: "inherit", env });
     child.on("error", () => done(-1));
     child.on("exit", (code) => done(code ?? 0));
   });
 }
+async function reexecMmiCli(args) {
+  const strategies = reexecStrategies({ platform: process.platform, argv1: process.argv[1], execPath: process.execPath });
+  const env = { ...process.env, [DOCTOR_POST_SELF_UPDATE_ENV]: "1" };
+  for (const strategy of strategies) {
+    const code = await spawnReexecAttempt(strategy.command, [...strategy.args, ...args], env);
+    if (reexecAttemptOutcome(strategy, code) === "result") return code;
+  }
+  return -1;
+}
 function hostBinAvailable(bin) {
   return execFileP2(isWin ? "where" : "which", [bin]).then(() => true).catch(() => false);
 }
@@ -16184,6 +16870,15 @@ async function runCodexPlugin(args) {
     return false;
   }
 }
+async function codexEnabledMmiVersion() {
+  if (!await hostBinAvailable("codex")) return void 0;
+  try {
+    const { stdout } = await runHostBin("codex", ["plugin", "list", "--json"], { timeout: CLAUDE_PLUGIN_TIMEOUT_MS });
+    return codexEnabledPluginVersionFromList(stdout, MMI_PLUGIN_ID);
+  } catch {
+    return void 0;
+  }
+}
 async function marketplaceAddRefSupported(bin) {
   try {
     const { stdout, stderr } = await runHostBin(bin, ["plugin", "marketplace", "add", "--help"], {
@@ -16246,6 +16941,77 @@ function installedPluginSources() {
     }
   });
 }
+function managedPluginSurfaceSources() {
+  const claudeCodex = installedPluginSources().map(({ surface, installed }) => {
+    const cacheVersions = {};
+    for (const descriptor of MANAGED_PLUGINS) {
+      const segments = parseManagedPluginId(descriptor.id);
+      if (!segments) continue;
+      try {
+        cacheVersions[descriptor.id] = (0, import_node_fs17.readdirSync)(
+          (0, import_node_path17.join)((0, import_node_os6.homedir)(), `.${surface}`, "plugins", "cache", segments.marketplace, segments.name),
+          { withFileTypes: true }
+        ).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+      } catch {
+      }
+    }
+    return { surface, installed, cacheVersions };
+  });
+  return [
+    ...claudeCodex,
+    { surface: "cursor", directVersions: managedPluginCursorDirectVersions() },
+    { surface: "opencode", directVersions: managedPluginOpencodeDirectVersions() }
+  ];
+}
+function managedPluginCursorDirectVersions() {
+  const out = {};
+  for (const descriptor of MANAGED_PLUGINS) {
+    const segments = parseManagedPluginId(descriptor.id);
+    if (!segments) continue;
+    try {
+      const versions = (0, import_node_fs17.readdirSync)(
+        (0, import_node_path17.join)((0, import_node_os6.homedir)(), ".cursor", "plugins", "cache", segments.marketplace, segments.name),
+        { withFileTypes: true }
+      ).filter((entry) => entry.isDirectory() && !entry.name.startsWith(".")).map((entry) => entry.name);
+      out[descriptor.id] = highestSemver(versions);
+    } catch {
+    }
+  }
+  return out;
+}
+function managedPluginOpencodeDirectVersions() {
+  const out = {};
+  for (const descriptor of MANAGED_PLUGINS) {
+    if (!descriptor.opencodePackage) continue;
+    out[descriptor.id] = readOpencodePackageVersion(descriptor.opencodePackage);
+  }
+  return out;
+}
+function readOpencodePackageVersionFrom(packageJsonPath) {
+  try {
+    const parsed = JSON.parse((0, import_node_fs17.readFileSync)(packageJsonPath, "utf8"));
+    return typeof parsed.version === "string" && parsed.version.trim() ? parsed.version.trim() : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function readOpencodePackageVersion(packageName) {
+  const [scope, name] = packageName.startsWith("@") ? packageName.slice(1).split("/", 2) : [void 0, packageName];
+  if (!name) return void 0;
+  const diskCandidates = [
+    (0, import_node_path17.join)(opencodeConfigDir(), "node_modules", ...scope ? [`@${scope}`] : [], name, "package.json"),
+    (0, import_node_path17.join)((0, import_node_os6.homedir)(), ".cache", "opencode", "node_modules", ...scope ? [`@${scope}`] : [], name, "package.json")
+  ];
+  const diskVersion = diskCandidates.map(readOpencodePackageVersionFrom).find((v) => v !== void 0);
+  const packagesRoot = (0, import_node_path17.join)((0, import_node_os6.homedir)(), ".cache", "opencode", "packages", ...scope ? [`@${scope}`] : []);
+  let cacheVersion;
+  try {
+    const cacheVersions = (0, import_node_fs17.readdirSync)(packagesRoot, { withFileTypes: true }).filter((e) => e.isDirectory() && e.name.startsWith(`${name}@`) && !e.name.startsWith(".")).map((e) => readOpencodePackageVersionFrom((0, import_node_path17.join)(packagesRoot, e.name, "node_modules", ...scope ? [`@${scope}`] : [], name, "package.json"))).filter((v) => Boolean(v));
+    if (cacheVersions.length) cacheVersion = cacheVersions.reduce((lowest, v) => compareVersions(v, lowest) < 0 ? v : lowest);
+  } catch {
+  }
+  return pickOpencodeActiveVersion({ cacheVersion, diskVersion });
+}
 function readClaudeSettings() {
   try {
     return JSON.parse((0, import_node_fs17.readFileSync)((0, import_node_path17.join)(process.cwd(), ".claude", "settings.json"), "utf8"));
@@ -16460,6 +17226,12 @@ function opencodeInstalledVersionForDoctor() {
     diskVersion: readOpencodeAdapterDiskVersion()
   });
 }
+function opencodePersistedVersionForDoctor() {
+  return pickOpencodeActiveVersion({
+    cacheVersion: readOpencodeLoadedCacheVersion(),
+    diskVersion: readOpencodeAdapterDiskVersion()
+  });
+}
 function opencodePluginVersionsForReport() {
   return [process.env.MMI_OPENCODE_PLUGIN_VERSION, readOpencodeAdapterDiskVersion()].filter((v) => Boolean(v));
 }
@@ -16577,8 +17349,8 @@ function hasNestedMmiChild(versionDir) {
   }
 }
 function nestedPluginTreeSnapshot() {
-  return mmiPluginCacheRootSnapshots().filter((root) => root.surface === "claude").flatMap(
-    (root) => root.entries.filter((e) => e.isDirectory && /^v?\d+\.\d+\.\d+/.test(e.name)).map((e) => ({ surface: "claude", path: e.path, nested: hasNestedMmiChild(e.path) }))
+  return mmiPluginCacheRootSnapshots().flatMap(
+    (root) => root.entries.filter((e) => e.isDirectory && /^v?\d+\.\d+\.\d+/.test(e.name)).map((e) => ({ surface: root.surface, path: e.path, nested: hasNestedMmiChild(e.path) }))
   );
 }
 function uniqueQuarantineTarget(path2) {
@@ -16654,21 +17426,95 @@ function readTextFile(path2) {
     return null;
   }
 }
-function playwrightMcpConfigSnapshots() {
+function mcpDirExists(path2) {
+  try {
+    return (0, import_node_fs17.existsSync)(path2);
+  } catch {
+    return false;
+  }
+}
+function mcpConfigTargets() {
   const cwd = process.cwd();
   const home = (0, import_node_os6.homedir)();
-  const candidates = [
-    (0, import_node_path17.join)(cwd, ".mcp.json"),
-    (0, import_node_path17.join)(cwd, ".cursor", "mcp.json"),
-    (0, import_node_path17.join)(home, ".cursor", "mcp.json"),
-    (0, import_node_path17.join)(home, ".codex", "config.toml")
+  const cursorProjectDir = (0, import_node_path17.join)(cwd, ".cursor");
+  const cursorUserDir = (0, import_node_path17.join)(home, ".cursor");
+  const codexDir = (0, import_node_path17.join)(home, ".codex");
+  return [
+    // Claude Code project MCP — reconciled if present, never conjured (org seeds .cursor/mcp.json, not this).
+    {
+      host: "claude-code",
+      label: "Claude Code project MCP",
+      path: (0, import_node_path17.join)(cwd, ".mcp.json"),
+      format: "json",
+      present: true,
+      // parent is the repo root (cwd); the caller gates the whole reconcile on isOrgRepo
+      isRepoFile: true,
+      createWhenFileAbsent: false,
+      content: readTextFile((0, import_node_path17.join)(cwd, ".mcp.json"))
+    },
+    // Cursor project MCP — the bootstrap-seeded surface; restored if its .cursor dir exists but the file is gone.
+    {
+      host: "cursor-project",
+      label: "Cursor project MCP",
+      path: (0, import_node_path17.join)(cursorProjectDir, "mcp.json"),
+      format: "json",
+      present: mcpDirExists(cursorProjectDir),
+      isRepoFile: true,
+      createWhenFileAbsent: true,
+      content: readTextFile((0, import_node_path17.join)(cursorProjectDir, "mcp.json"))
+    },
+    // Cursor user MCP — global; written only when Cursor is installed (~/.cursor exists).
+    {
+      host: "cursor-user",
+      label: "Cursor user MCP",
+      path: (0, import_node_path17.join)(cursorUserDir, "mcp.json"),
+      format: "json",
+      present: mcpDirExists(cursorUserDir),
+      isRepoFile: false,
+      createWhenFileAbsent: true,
+      content: readTextFile((0, import_node_path17.join)(cursorUserDir, "mcp.json"))
+    },
+    // Codex user config (TOML) — global; written only when Codex is installed (~/.codex exists).
+    {
+      host: "codex",
+      label: "Codex user config",
+      path: (0, import_node_path17.join)(codexDir, "config.toml"),
+      format: "toml",
+      present: mcpDirExists(codexDir),
+      isRepoFile: false,
+      createWhenFileAbsent: true,
+      content: readTextFile((0, import_node_path17.join)(codexDir, "config.toml"))
+    }
   ];
-  const out = [];
-  for (const path2 of candidates) {
-    const content = readTextFile(path2);
-    if (content != null) out.push({ path: path2, content });
+}
+function writeMcpConfigFile(path2, content) {
+  try {
+    (0, import_node_fs17.writeFileSync)(path2, content, "utf8");
+    return true;
+  } catch {
+    return false;
   }
-  return out;
+}
+async function reconcileMcpRegistrations(input) {
+  if (!input.isOrgRepo) return buildMcpReconcileCheck([]);
+  const targets = mcpConfigTargets();
+  if (!input.apply) return buildMcpReconcileCheck(planMcpReconcile(targets, PLAYWRIGHT_MCP_SPEC));
+  const results = applyMcpReconcile(targets, PLAYWRIGHT_MCP_SPEC, {
+    repoWritesAllowed: input.repoWritesAllowed,
+    write: writeMcpConfigFile
+  });
+  for (const r of results) {
+    if (r.outcome === "wrote") {
+      input.onHealed();
+      const verb = r.action === "install" ? "registered" : "reconciled";
+      input.log(`  \u21BB ${verb} Playwright MCP in ${r.target.path} \u2014 restart the host to load it`);
+    } else if (r.outcome === "unparseable") {
+      input.log(`  \u26A0 ${r.target.label}: could not safely patch ${r.target.path} (unparseable) \u2014 fix it by hand`);
+    } else if (r.outcome === "write-failed") {
+      input.log(`  \u26A0 ${r.target.label}: failed to write ${r.target.path}`);
+    }
+  }
+  return buildMcpReconcileCheck(planMcpReconcile(mcpConfigTargets(), PLAYWRIGHT_MCP_SPEC));
 }
 function strayBrowserArtifactPaths() {
   const cwd = process.cwd();
@@ -16704,7 +17550,6 @@ async function runDoctor(opts, io = consoleIo, readOrigin) {
   const repairLocal = !opts.json || Boolean(opts.apply) || Boolean(opts.preflight);
   const repoWritesAllowed = !opts.noRepoWrites;
   const runExtended = Boolean(opts.verbose) || Boolean(opts.json);
-  const terseOutput = !opts.verbose && !opts.json && !opts.banner && !opts.preflight;
   const checks = [];
   const REWRITE_KEY = "url.https://github.com/.insteadOf";
   const CLONE_FIX = 'run: git config --global url."https://github.com/".insteadOf "git@github.com:"';
@@ -16774,6 +17619,10 @@ async function runDoctor(opts, io = consoleIo, readOrigin) {
   const markPluginReloadRequired = () => {
     pluginReloadRequired = true;
   };
+  let healedCount = 0;
+  const markHealed = () => {
+    healedCount += 1;
+  };
   let versionReport = buildVersionLagReport({
     currentVersion: resolveClientVersion(),
     repoVersion: readRepoVersion(),
@@ -16789,13 +17638,19 @@ async function runDoctor(opts, io = consoleIo, readOrigin) {
   checks.push(versionReport);
   if (selfUpdatedCli) {
     if (!opts.json) io.err(selfUpdateReexecLine(versionReport));
-    const code = await reexecMmiCli(buildSelfUpdateReexecArgs(opts));
+    const reexecArgs = buildSelfUpdateReexecArgs(opts);
+    const code = await reexecMmiCli(reexecArgs);
     if (code >= 0) {
       if (code > 0) process.exitCode = code;
       return;
     }
-    if (opts.json) io.log(JSON.stringify(buildSelfUpdateHaltPayload({ checks, updatedTo: versionReport.releasedVersion }), null, 2));
-    else io.err(selfUpdateHaltLine(versionReport));
+    process.exitCode = DOCTOR_SELF_UPDATE_HALT_EXIT_CODE;
+    if (opts.json) {
+      io.log(JSON.stringify(buildSelfUpdateHaltPayload({ checks, updatedTo: versionReport.releasedVersion }), null, 2));
+    } else {
+      io.err(selfUpdateHaltLine(versionReport));
+      io.err(selfUpdateHaltSentinelLine({ report: versionReport, rerunArgs: reexecArgs }));
+    }
     return;
   }
   checks.push({ ok: Boolean(cfg.sagaApiUrl), label: "Hub API URL configured", fix: "set MMI_HUB_URL or use a current MMI CLI/plugin build" });
@@ -16826,6 +17681,7 @@ async function runDoctor(opts, io = consoleIo, readOrigin) {
     try {
       await execFileP2("git", ["config", "--global", "--add", REWRITE_KEY, "git@github.com:"]);
       cloneOk = true;
+      markHealed();
       io.err("  \u21BB repaired: git insteadOf git@github.com \u2192 https (plugin clone over HTTPS)");
     } catch {
     }
@@ -16844,6 +17700,7 @@ async function runDoctor(opts, io = consoleIo, readOrigin) {
   if (!pluginCheck.ok && pluginCheck.recordToInsert && repairLocal) {
     if (writeProjectInstallRecord(pluginCheck.recordToInsert)) {
       pluginCheck = { ...pluginCheck, ok: true };
+      markHealed();
       io.err(`  \u21BB repaired: registered mmi@mutmutco project install record \u2014 ${reloadHint} to load MMI commands`);
     }
   }
@@ -16863,6 +17720,7 @@ async function runDoctor(opts, io = consoleIo, readOrigin) {
         surface
       });
       if (legacyPluginCheck.ok) {
+        markHealed();
         io.err(`  \u21BB migrated legacy mmi@mmi \u2192 mmi@mutmutco via claude plugin \u2014 ${reloadHint} to load MMI commands`);
       }
     }
@@ -16873,6 +17731,7 @@ async function runDoctor(opts, io = consoleIo, readOrigin) {
         surface
       });
       if (legacyPluginCheck.ok) {
+        markHealed();
         io.err(`  \u21BB migrated legacy mmi@mmi \u2192 mmi@mutmutco via codex plugin \u2014 ${reloadHint} to load MMI commands`);
       }
     }
@@ -16891,6 +17750,7 @@ async function runDoctor(opts, io = consoleIo, readOrigin) {
         gitignoreCheck.removed?.length ? `removed ${gitignoreCheck.removed.join(", ")}` : ""
       ].filter(Boolean).join("; ") || "normalized the block";
       gitignoreCheck = { ...gitignoreCheck, ok: true };
+      markHealed();
       io.err(`  \u21BB repaired: org-managed .gitignore block \u2014 ${drift}`);
       io.err("     this is an org-managed update (not unrelated churn) \u2014 stage & commit .gitignore so it stops recurring");
     }
@@ -16904,6 +17764,7 @@ async function runDoctor(opts, io = consoleIo, readOrigin) {
   if (!driftCheck.ok && driftCheck.recordsToWrite && repairLocal) {
     if (backupAndWriteInstalledPlugins(driftCheck.recordsToWrite, driftCheck.pluginId)) {
       driftCheck = { ...driftCheck, ok: true };
+      markHealed();
       io.err(`  \u21BB repaired: collapsed mmi@mutmutco to one user-scope entry (backup at installed_plugins.json.bak) \u2014 ${reloadHint} to load MMI commands`);
     }
   }
@@ -16936,6 +17797,7 @@ async function runDoctor(opts, io = consoleIo, readOrigin) {
       installedVersionCheck = healed;
       if (healed.ok) {
         markPluginReloadRequired();
+        markHealed();
         io.err(`  \u21BB updated MMI plugin \u2192 ${releasedVersion ?? "latest"} via claude plugin \u2014 ${reloadAction(surface)} to load the new commands`);
       }
     }
@@ -16945,11 +17807,13 @@ async function runDoctor(opts, io = consoleIo, readOrigin) {
       installedVersionCheck = healed;
       if (healed.ok) {
         markPluginReloadRequired();
+        markHealed();
         io.err(`  \u21BB updated MMI plugin \u2192 ${releasedVersion ?? "latest"} via codex plugin \u2014 ${reloadAction(surface)} to load the new commands`);
       }
     }
   }
   checks.push(installedVersionCheck);
+  checks.push(buildManagedPluginDriftCheck({ isOrgRepo, sources: managedPluginSurfaceSources() }));
   let openCodeConfigSnapshot = opencodeConfigSnapshot();
   const inspectOpenCode = surface === "opencode" || openCodeConfigSnapshot.hasConfig || runExtended;
   if (inspectOpenCode) {
@@ -16974,6 +17838,7 @@ async function runDoctor(opts, io = consoleIo, readOrigin) {
         });
         if (opencodeConfigCheck.ok) {
           markPluginReloadRequired();
+          markHealed();
           io.err(`  \u21BB repaired: wired ${OPENCODE_PLUGIN_PACKAGE} in OpenCode config \u2014 ${reloadAction("opencode")} to load MMI commands`);
         }
       }
@@ -16986,10 +17851,20 @@ async function runDoctor(opts, io = consoleIo, readOrigin) {
       releasedVersion
     });
     if (!opencodeVersionCheck.ok && repairFull) {
-      const refreshed = await forceInstallOpencodeMmiPlugins(openCodeConfigSnapshot, (m) => io.err(m));
-      const quarantined = quarantineStaleOpencodePluginCaches(releasedVersion, (m) => io.err(m));
-      if (refreshed || quarantined) {
-        opencodeInstalledVersion = opencodeInstalledVersionForDoctor() ?? opencodeInstalledVersion;
+      const persistedCurrent = () => buildOpencodeVersionCheck({
+        isOrgRepo,
+        installedVersion: opencodePersistedVersionForDoctor(),
+        releasedVersion
+      }).ok;
+      let refreshed = false;
+      let quarantined = false;
+      if (!persistedCurrent()) {
+        refreshed = await forceInstallOpencodeMmiPlugins(openCodeConfigSnapshot, (m) => io.err(m));
+        quarantined = quarantineStaleOpencodePluginCaches(releasedVersion, (m) => io.err(m));
+      }
+      if (persistedCurrent()) {
+        const wasReinstalled = refreshed || quarantined;
+        opencodeInstalledVersion = opencodePersistedVersionForDoctor() ?? opencodeInstalledVersion;
         opencodeVersionCheck = buildOpencodeVersionCheck({
           isOrgRepo,
           installedVersion: opencodeInstalledVersion,
@@ -16997,7 +17872,9 @@ async function runDoctor(opts, io = consoleIo, readOrigin) {
         });
         if (opencodeVersionCheck.ok) {
           markPluginReloadRequired();
-          io.err(`  \u21BB force-refreshed OpenCode MMI plugin \u2192 ${opencodeInstalledVersion ?? releasedVersion ?? "latest"} \u2014 ${reloadAction("opencode")} to load it`);
+          markHealed();
+          const version = opencodeInstalledVersion ?? releasedVersion ?? "latest";
+          io.err(wasReinstalled ? `  \u21BB force-refreshed OpenCode MMI plugin \u2192 ${version} \u2014 ${reloadAction("opencode")} to load it` : `  \u21BB OpenCode MMI plugin is current on disk (${version}); the running session is stale \u2014 ${reloadAction("opencode")} to load it`);
         }
       }
     }
@@ -17035,6 +17912,7 @@ async function runDoctor(opts, io = consoleIo, readOrigin) {
         });
         if (surfaceAssetsCheck.ok) {
           markPluginReloadRequired();
+          markHealed();
           io.err(`  \u21BB materialized OpenCode MMI commands + skills path \u2014 ${reloadAction("opencode")} to load them`);
         }
       }
@@ -17056,6 +17934,7 @@ async function runDoctor(opts, io = consoleIo, readOrigin) {
     if (!legacyOpenCodeCheck.ok && repairLocal && legacyOpenCodeConfig.legacyPath) {
       if (quarantineOpencodeLegacyConfig(legacyOpenCodeConfig.legacyPath)) {
         legacyOpenCodeCheck = buildOpencodeLegacyConfigCheck({ isOrgRepo: true });
+        markHealed();
         io.err(`  \u21BB quarantined legacy OpenCode config \u2192 ${legacyOpenCodeConfig.legacyPath}.bak \u2014 restart OpenCode`);
       }
     }
@@ -17066,6 +17945,7 @@ async function runDoctor(opts, io = consoleIo, readOrigin) {
     return versions.sort((a, b) => compareVersions(b, a))[0];
   };
   const codexCacheVersions = () => mmiPluginCacheRootSnapshots().filter((r) => r.surface === "codex").flatMap((r) => r.entries.filter((e) => e.isDirectory).map((e) => e.name));
+  const codexActiveVersion = () => isOrgRepo && releasedVersion ? codexEnabledMmiVersion() : Promise.resolve(void 0);
   let cacheCleanupCheck = buildMmiPluginCacheCleanupCheck({
     isOrgRepo,
     roots: mmiPluginCacheRootSnapshots(),
@@ -17080,6 +17960,7 @@ async function runDoctor(opts, io = consoleIo, readOrigin) {
       const surfaces = [...new Set(cacheCleanupCheck.leftovers?.map((entry) => entry.surface) ?? [])].join("/");
       const names = cacheCleanupCheck.leftovers?.map((entry) => entry.name).join(", ");
       markPluginReloadRequired();
+      markHealed();
       io.err(`  \u21BB quarantined ${moved} stale MMI plugin cache dir(s) for ${surfaces || "agent surfaces"}: ${names} \u2014 ${reloadHint} to load MMI commands`);
     }
     cacheCleanupCheck = {
@@ -17101,18 +17982,21 @@ async function runDoctor(opts, io = consoleIo, readOrigin) {
     isOrgRepo,
     releasedVersion,
     codexCacheVersions: codexCacheVersions(),
-    codexRecordVersion: codexRecordVersion()
+    codexRecordVersion: codexRecordVersion(),
+    codexActiveVersion: await codexActiveVersion()
   });
   if (!codexActiveCacheCheck.ok && repairFull) {
     const canDriveCodex = surfaceToken(surface) === "codex" || await hostBinAvailable("codex");
     if (canDriveCodex && await applyPluginHeal("codex", surface, (m) => io.err(m), { force: true })) {
       markPluginReloadRequired();
+      markHealed();
       io.err(`  \u21BB restored Codex MMI plugin cache \u2192 ${releasedVersion ?? "latest"} via codex plugin \u2014 ${reloadAction("codex")} to load the new commands`);
       codexActiveCacheCheck = buildCodexActiveCacheCheck({
         isOrgRepo,
         releasedVersion,
         codexCacheVersions: codexCacheVersions(),
-        codexRecordVersion: codexRecordVersion()
+        codexRecordVersion: codexRecordVersion(),
+        codexActiveVersion: await codexActiveVersion()
       });
     }
   }
@@ -17123,7 +18007,8 @@ async function runDoctor(opts, io = consoleIo, readOrigin) {
     entries: nestedPluginTreeSnapshot()
   });
   if (!nestedPluginTreeCheck.ok && nestedPluginTreeCheck.nested?.length && repairLocal) {
-    const nestedPaths = nestedPluginTreeCheck.nested.map((n) => n.path);
+    const nestedEntries = nestedPluginTreeCheck.nested;
+    const nestedPaths = nestedEntries.map((n) => n.path);
     if (await applyNestedPluginTreeCleanup(nestedPaths, (m) => io.err(m))) {
       nestedPluginTreeCheck = buildNestedPluginTreeCheck({
         isOrgRepo,
@@ -17131,35 +18016,62 @@ async function runDoctor(opts, io = consoleIo, readOrigin) {
         entries: nestedPluginTreeSnapshot()
       });
       if (nestedPluginTreeCheck.ok) {
-        io.err(`  \u21BB cleared self-nested MMI plugin cache tree(s) \u2014 reinstalling plugin\u2026`);
+        io.err(`  \u21BB cleared self-nested MMI plugin cache tree(s)`);
+      }
+      let reinstalledAny = false;
+      const unreinstalled = [];
+      for (const token of [...new Set(nestedEntries.map((n) => n.surface))]) {
+        const bin = token === "codex" ? "codex" : "claude";
+        const canDrive = surfaceToken(surface) === token || await hostBinAvailable(bin);
+        if (canDrive && await applyPluginHeal(token, surface, (m) => io.err(m), { force: true })) {
+          reinstalledAny = true;
+          io.err(`  \u21BB reinstalled MMI plugin (${token}) after nested-cache cleanup \u2014 ${reloadAction(surface)} to load MMI commands`);
+        } else {
+          unreinstalled.push(token);
+        }
       }
-      if (await applyPluginHeal("claude", surface, (m) => io.err(m))) {
+      if (reinstalledAny) {
         markPluginReloadRequired();
-        io.err(`  \u21BB reinstalled MMI plugin after nested-cache cleanup \u2014 ${reloadAction(surface)} to load MMI commands`);
+        markHealed();
         nestedPluginTreeCheck = buildNestedPluginTreeCheck({
           isOrgRepo,
           isWindows: isWin,
           entries: nestedPluginTreeSnapshot()
         });
       }
+      if (unreinstalled.length > 0 && nestedPluginTreeCheck.ok) {
+        nestedPluginTreeCheck = { ...nestedPluginTreeCheck, ok: false, fix: nestedTreeReinstallGapFix(unreinstalled) };
+      }
     }
   }
   checks.push(nestedPluginTreeCheck);
   const cursorCacheRoot = cursorPluginCacheRoot();
+  const cursorCacheRootExists = (0, import_node_fs17.existsSync)(cursorCacheRoot);
   let cursorPins = cursorPluginCachePinSnapshots() ?? [];
+  checks.push(
+    buildCursorPluginCacheCleanupCheck({
+      isOrgRepo,
+      cacheRoot: cursorCacheRoot,
+      pins: cursorPins,
+      releasedVersion
+    })
+  );
   let cursorPluginCheck = buildCursorPluginInstallCheck({
     isOrgRepo,
     surface,
     cacheRoot: cursorCacheRoot,
-    cacheRootExists: (0, import_node_fs17.existsSync)(cursorCacheRoot),
+    cacheRootExists: cursorCacheRootExists,
     pins: cursorPins,
     hubCheckout: hubCheckoutForCursorSeed(),
     releasedVersion
   });
   if (!cursorPluginCheck.ok && repairLocal) {
+    const seedingFromNothing = cursorPins.length === 0;
     const seeded = await applyCursorPluginCacheSeed({
       pins: cursorPins,
       releasedVersion,
+      cacheRoot: cursorCacheRoot,
+      cacheRootExists: cursorCacheRootExists,
       hubCheckout: hubCheckoutForCursorSeed(),
       execFileP: execFileP2,
       mkdtemp: (prefix) => (0, import_promises2.mkdtemp)((0, import_node_path17.join)((0, import_node_os6.tmpdir)(), prefix)),
@@ -17171,13 +18083,26 @@ async function runDoctor(opts, io = consoleIo, readOrigin) {
         isOrgRepo,
         surface,
         cacheRoot: cursorCacheRoot,
-        cacheRootExists: (0, import_node_fs17.existsSync)(cursorCacheRoot),
+        cacheRootExists: cursorCacheRootExists,
         pins: cursorPins,
         hubCheckout: hubCheckoutForCursorSeed(),
         releasedVersion
       });
       if (cursorPluginCheck.ok) {
-        io.err(`  \u21BB seeded Cursor MMI plugin cache \u2192 ${releasedVersion ?? "latest"} \u2014 ${reloadAction(surface)}`);
+        markHealed();
+        if (seedingFromNothing) {
+          io.err(
+            `  \u21BB seeded Cursor MMI plugin cache from nothing \u2192 ${releasedVersion ?? "latest"} (cache only \u2014 Team Marketplace registration not verified, #2409) \u2014 ${reloadAction(surface)}`
+          );
+          cursorPluginCheck = {
+            ...cursorPluginCheck,
+            ok: false,
+            severityOverride: "advisory",
+            fix: cursorSeededFromNothingAdvisoryFix(releasedVersion)
+          };
+        } else {
+          io.err(`  \u21BB seeded Cursor MMI plugin cache \u2192 ${releasedVersion ?? "latest"} \u2014 ${reloadAction(surface)}`);
+        }
       }
     }
   }
@@ -17198,20 +18123,29 @@ async function runDoctor(opts, io = consoleIo, readOrigin) {
       mmiCliOnPath: onPath
     })
   );
-  if (runExtended) {
-    const playwrightMcpConfigs = playwrightMcpConfigSnapshots();
-    checks.push(
-      buildPlaywrightMcpVisionCapCheck({
-        isOrgRepo,
-        configs: playwrightMcpConfigs
-      })
-    );
+  if (!opts.banner) {
     checks.push(
-      buildPlaywrightMcpOutputDirCheck({
+      await reconcileMcpRegistrations({
         isOrgRepo,
-        configs: playwrightMcpConfigs
+        apply: Boolean(opts.apply),
+        repoWritesAllowed,
+        log: (m) => io.err(m),
+        onHealed: markHealed
       })
     );
+  }
+  const sessionPluginRoot = process.env.CLAUDE_PLUGIN_ROOT;
+  const sessionCacheSurface = sessionPluginRoot?.includes(".codex") ? "codex" : sessionPluginRoot?.includes(".claude") ? "claude" : void 0;
+  const sessionCacheVersions = sessionCacheSurface ? mmiPluginCacheRootSnapshots().filter((r) => r.surface === sessionCacheSurface).flatMap((r) => r.entries.filter((e) => e.isDirectory).map((e) => e.name)) : [];
+  checks.push(
+    buildSessionSkillRootCheck({
+      isOrgRepo,
+      surface,
+      pluginRoot: sessionPluginRoot,
+      cacheVersions: sessionCacheVersions
+    })
+  );
+  if (runExtended) {
     checks.push(
       buildBrowserArtifactsCheck({
         isOrgRepo,
@@ -17248,48 +18182,66 @@ async function runDoctor(opts, io = consoleIo, readOrigin) {
     } catch {
     }
   }
+  emitDoctorReport(opts, io, {
+    checks,
+    surface,
+    needsEagerHeal: healPlan.needsEagerHeal,
+    healedCount,
+    pluginReloadRequired,
+    reloadHint,
+    // Surface-aware update report (#865): the per-surface version snapshot + copy-paste update recipes, so
+    // an agent told "make sure the CLI and plugin are up to date" can run the right command per surface and
+    // echo back an unambiguous version line (CLI / Claude plugin / Codex marketplace / Codex active cache).
+    // Passed lazily: emitDoctorReport calls it only past the --preflight/--banner early returns, keeping
+    // the SessionStart hot path free of its synchronous fs I/O.
+    buildUpdateReport: () => {
+      const cacheRoots = mmiPluginCacheRootSnapshots();
+      const cacheVersionsFor = (s) => cacheRoots.filter((r) => r.surface === s).flatMap((r) => r.entries.filter((e) => e.isDirectory).map((e) => e.name));
+      const sourceVersions = (s) => installedPluginVersions(installedPluginSources().find((src) => src.surface === s)?.installed ?? null);
+      return buildPluginUpdateReport({
+        cliVersion: resolveClientVersion(),
+        claudePluginVersions: sourceVersions("claude"),
+        codexPluginVersions: sourceVersions("codex"),
+        codexCacheVersions: cacheVersionsFor("codex"),
+        opencodePluginVersions: opencodePluginVersionsForReport(),
+        releasedVersion
+      });
+    }
+  });
+}
+function emitDoctorReport(opts, io, ctx) {
+  const { checks, surface, healedCount, pluginReloadRequired, reloadHint } = ctx;
   const gaps = checks.filter((c) => !c.ok);
   if (opts.preflight) {
-    const outcome = preflightOutcome({ gaps, needsEagerHeal: healPlan.needsEagerHeal, surface });
+    const outcome = preflightOutcome({ gaps, needsEagerHeal: ctx.needsEagerHeal, surface });
     if (outcome.line) io.err(outcome.line);
     if (pluginReloadRequired) io.err(pluginAutonomousHaltLine(reloadHint));
     return;
   }
   if (opts.banner) {
-    if (healPlan.needsEagerHeal) io.err(doctorPreflightDoneLine(surface));
+    if (ctx.needsEagerHeal) io.err(doctorPreflightDoneLine(surface));
     if (pluginReloadRequired) io.err(pluginAutonomousHaltLine(reloadHint));
     if (gaps.length) io.log(`\u26A0 MMI setup needed \u2014 ${gaps.map((g) => g.fix).join(" \xB7 ")} \xB7 guide: ${MMI_AGENTIC_ONBOARDING_GUIDE.url}`);
     return;
   }
-  const cacheRoots = mmiPluginCacheRootSnapshots();
-  const cacheVersionsFor = (s) => cacheRoots.filter((r) => r.surface === s).flatMap((r) => r.entries.filter((e) => e.isDirectory).map((e) => e.name));
-  const sourceVersions = (s) => installedPluginVersions(installedPluginSources().find((src) => src.surface === s)?.installed ?? null);
-  const updateReport = buildPluginUpdateReport({
-    cliVersion: resolveClientVersion(),
-    claudePluginVersions: sourceVersions("claude"),
-    codexPluginVersions: sourceVersions("codex"),
-    codexCacheVersions: cacheVersionsFor("codex"),
-    opencodePluginVersions: opencodePluginVersionsForReport(),
-    releasedVersion
-  });
+  const updateReport = ctx.buildUpdateReport();
   const resources = doctorResourcesForGaps(gaps);
+  process.exitCode = doctorExitCode(checks);
   if (opts.json) {
     io.log(JSON.stringify(buildDoctorJsonPayload({ checks, updateReport, resources }), null, 2));
     return;
   }
-  if (terseOutput) {
-    if (pluginReloadRequired) io.err(pluginAutonomousHaltLine(reloadHint));
-    for (const line of renderTerseDoctorReport({ gaps, updateReport })) io.log(line);
-    for (const r of resources) io.log(`Resource: ${r.label} \u2014 ${r.url}`);
-    return;
-  }
-  for (const c of checks) io.log(c.ok ? `\u2713 ${c.label}` : `\u2717 ${c.label}
-   \u2192 ${c.fix}`);
+  if (pluginReloadRequired) io.err(pluginAutonomousHaltLine(reloadHint));
+  for (const line of doctorHumanLines({
+    checks,
+    updateReport,
+    shouldApply: Boolean(opts.apply),
+    healedCount,
+    pluginReloadRequired,
+    reloadHint,
+    verbose: Boolean(opts.verbose)
+  })) io.log(line);
   for (const r of resources) io.log(`Resource: ${r.label} \u2014 ${r.url}`);
-  io.log("");
-  for (const line of renderPluginUpdateReport(updateReport)) io.log(line);
-  io.log(gaps.length ? `
-${gaps.length} item(s) need attention.` : "\nAll set \u2014 you are ready.");
 }
 var USER_SCOPE_GUARD_MARKER = "mmi-guard:v1";
 var USER_SCOPE_GUARD_COMMAND = `mmi-cli guard --session-start || true # ${USER_SCOPE_GUARD_MARKER}`;
@@ -18874,6 +19826,21 @@ pr.command("land <number>").description("agent merge path (#1440): train probe \
       pollChecks: () => pollGhPrChecks(prNumber, repo ? ["--repo", repo] : []),
       sleep: (ms) => new Promise((resolve6) => setTimeout(resolve6, ms))
     }),
+    // #2425: re-probe used ONLY to decide whether a failed `gh pr merge --auto` is worth retrying — a
+    // fresh read of state/mergeable/checks, independent of the merge call's own (possibly stale) error.
+    probeMergeReady: async (prNumber, repo) => {
+      const args = repo ? ["--repo", repo] : [];
+      const [state, checks] = await Promise.all([
+        execFileP2("gh", ["pr", "view", prNumber, ...args, "--json", "state,mergeable", "--jq", '.state + " " + .mergeable'], { timeout: GC_GH_TIMEOUT_MS2 }).then((r) => r.stdout.trim().split(/\s+/)).catch(() => ["", ""]),
+        pollGhPrChecks(prNumber, args).catch(() => "error")
+      ]);
+      const [prState, mergeable] = state;
+      return {
+        open: prState === "OPEN",
+        mergeable: mergeable === "MERGEABLE",
+        checksPassing: checks === "success" || checks === "no-checks-reported"
+      };
+    },
     mergeAuto: async (prNumber, repo) => {
       const args = repo ? ["--repo", repo] : [];
       const readMergeState = () => readGhPrStateWithRetry(async () => (await execFileP2("gh", ["pr", "view", prNumber, ...args, "--json", "state", "--jq", ".state"], { timeout: GC_GH_TIMEOUT_MS2 })).stdout);
@@ -19274,7 +20241,7 @@ board.command("prune-priority-labels").description("remove retired priority:* la
 });
 board.command("done <issue>").description("set a board item's Status to Done (does not close the GitHub issue; use `gh issue close`)").option("--json", "machine-readable output").option("--repo <owner/repo>", "current repo for local issue numbers (defaults to git origin)").option("--allow-partial", "return success JSON if the item resolves but the status move fails").action(async (issueRef, o) => {
   try {
-    const result = await moveBoardItem({ config: await loadConfigOrDiscover(), selector: issueRef, status: "Done", repo: o.repo, allowPartial: o.allowPartial });
+    const result = await moveBoardItem({ config: await loadConfigForBoardSelector(issueRef, o.repo), selector: issueRef, status: "Done", repo: o.repo, allowPartial: o.allowPartial });
     if (o.json) return console.log(JSON.stringify(result));
     console.log(result.partial ? `Partially moved ${result.item.ref}: ${result.warning}` : `Moved ${result.item.ref} -> Done`);
   } catch (e) {