@mutmutco/cli 3.95.0 → 3.96.0

package/dist/main.cjs

@@ -16990,7 +16990,7 @@ async function boardDoctor(options, deps = {}) {
     };
     await Promise.all(Array.from({ length: Math.min(concurrency, suspicious.length) }, () => ghostWorker()));
   }
-  const claimedItems = collected.items.filter(
+  const claimedItems = options.skipClaimLiveness ? [] : collected.items.filter(
     (item) => item.contentType === "Issue" && item.assignees.length > 0 && item.status === "In Progress"
   );
   const liveClaims = [];
@@ -19342,6 +19342,12 @@ var INDEXABLE_EXT = /* @__PURE__ */ new Set([
   ".html"
 ]);
 var SYMBOL_RE = /^(?:export\s+)?(?:async\s+)?(?:function|class|const|let|var|type|interface|enum)\s+([A-Za-z_$][\w$]*)/gm;
+function repoIndexPathTieBreak(path2) {
+  const p = path2.replace(/\\/g, "/");
+  if (/(^|\/)__tests__\//.test(p) || /(^|\/)tests?\//.test(p)) return 1;
+  if (/\.(test|spec)\.[^.]+$/i.test(p)) return 1;
+  return 0;
+}
 function repoIndexStorePath(cwd) {
   return repoRuntimeStatePath(cwd, "repo-index", "index.json");
 }
@@ -19552,7 +19558,9 @@ function searchRepoIndex(idx, query, limit = 20) {
       }
     }
   }
-  hits.sort((a, b) => b.score - a.score || a.path.localeCompare(b.path));
+  hits.sort(
+    (a, b) => b.score - a.score || repoIndexPathTieBreak(a.path) - repoIndexPathTieBreak(b.path) || a.path.localeCompare(b.path)
+  );
   const seen = /* @__PURE__ */ new Set();
   const out = [];
   for (const h of hits) {
@@ -19568,10 +19576,10 @@ function inferRepoSlug(cwd, exec = import_node_child_process11.execFileSync) {
   try {
     const url = String(exec("git", ["remote", "get-url", "origin"], { cwd, encoding: "utf8" })).trim();
     const m = /[:/]([^/]+\/[^/]+?)(?:\.git)?$/.exec(url);
-    if (m?.[1]) return m[1];
+    if (m?.[1]) return m[1].toLowerCase();
   } catch {
   }
-  return (0, import_node_path20.basename)(cwd) || "local";
+  return ((0, import_node_path20.basename)(cwd) || "local").toLowerCase();
 }
 
 // src/repo-index-cloud-client.ts
@@ -19718,8 +19726,11 @@ var import_node_child_process12 = require("node:child_process");
 var MAX_EMBED_BACKFILL_ROUNDS = 40;
 function normalizeRepo(raw) {
   const t = raw.trim().replace(/\.git$/, "");
-  if (t.includes("/")) return t;
-  return `mutmutco/${t}`;
+  if (t.includes("/")) {
+    const [owner, name] = t.split("/");
+    return `${(owner || "").toLowerCase()}/${(name || "").toLowerCase()}`;
+  }
+  return `mutmutco/${t.toLowerCase()}`;
 }
 function rosterRepos(projects) {
   const set = /* @__PURE__ */ new Set();
@@ -19730,10 +19741,11 @@ function rosterRepos(projects) {
   return [...set].sort((a, b) => a.localeCompare(b));
 }
 function shallowClone(repo, dest, token) {
+  const basic = Buffer.from(`x-access-token:${token}`, "utf8").toString("base64");
   (0, import_node_child_process12.execFileSync)(
     "git",
-    ["-c", `http.extraHeader=Authorization: Bearer ${token}`, "clone", "--depth", "1", "--single-branch", `https://github.com/${repo}.git`, dest],
-    { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }
+    ["-c", `http.extraHeader=Authorization: Basic ${basic}`, "clone", "--depth", "1", "--single-branch", `https://github.com/${repo}.git`, dest],
+    { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], windowsHide: true }
   );
 }
 async function syncEstateRepoIndex(opts) {
@@ -27866,6 +27878,11 @@ async function recommendNext(repo, deps) {
   const top = sorted[0];
   return { number: top.number, title: top.title, url: top.url, priority: top.priority, repo: top.repository };
 }
+function requiredEstateCommandsPresent(commandNames) {
+  const required = ["repo-index"];
+  const present = new Set(commandNames);
+  return required.filter((name) => !present.has(name));
+}
 function onboardPluginGate(deps) {
   const { registered, declared, ref } = readKnownMarketplace(deps.readKnown(), MMI_MARKETPLACE_NAME);
   if (!registered) {
@@ -27883,8 +27900,13 @@ function onboardPluginGate(deps) {
   if (catalog && !catalog.agrees) gaps.push(`the catalog is ${catalog.unpinned ? "unpinned" : `pinned to ${catalog.ref}`} \u2014 ${CATALOG_REF_PIN_STEPS}`);
   return gaps.length === 0 ? { ok: true, detail: `auto-update on, catalog pinned to ${catalog?.ref}` } : { ok: false, detail: gaps.join("; ") };
 }
-async function collectOnboardStatus() {
+async function collectOnboardStatus(opts = {}) {
   const cfg = await loadConfig();
+  const missingEstate = requiredEstateCommandsPresent(opts.commandNames ?? []);
+  const estateCli = missingEstate.length === 0 ? { ok: true, detail: "estate commands present (repo-index)" } : {
+    ok: false,
+    detail: `global CLI missing ${missingEstate.join(", ")} \u2014 run mmi-cli doctor to heal`
+  };
   let track = "unknown";
   try {
     const revParse2 = (await execFileP2("git", ["rev-parse", "--abbrev-ref", "HEAD"], { timeout: GIT_TIMEOUT_MS }).catch(() => ({ stdout: "" }))).stdout.trim();
@@ -27938,7 +27960,9 @@ async function collectOnboardStatus() {
     }
   }
   let nextCommand = "mmi-cli doctor";
-  if (!cfg.sagaApiUrl) {
+  if (!estateCli.ok) {
+    nextCommand = "mmi-cli doctor \u2014 heal global CLI (missing repo-index)";
+  } else if (!cfg.sagaApiUrl) {
     nextCommand = "mmi-cli doctor \u2014 fix Hub API URL configuration first";
   } else if (!registry2.ok) {
     nextCommand = "mmi-cli org project set <owner/repo>";
@@ -27961,7 +27985,7 @@ async function collectOnboardStatus() {
     readKnown: () => readFileSyncSafe((0, import_node_path36.join)(home, ...KNOWN_MARKETPLACES_RELATIVE), import_node_fs37.readFileSync),
     readSettings: () => readFileSyncSafe((0, import_node_path36.join)(home, ".claude", "settings.json"), import_node_fs37.readFileSync)
   });
-  return { track, board, registry: registry2, secrets, plugin, nextCommand };
+  return { track, board, registry: registry2, secrets, plugin, estateCli, nextCommand };
 }
 function registerDiscoveryCommands(program3) {
   program3.command("status").description("unified repo snapshot: branch, worktrees, open PRs (yours), claimed board items, stage state").option("--json", "machine-readable output").action(async (o) => {
@@ -27998,7 +28022,8 @@ function registerDiscoveryCommands(program3) {
   });
   program3.command("onboard").description("report repo track/board/secrets/registry readiness and the concrete next command").option("--json", "machine-readable output").action(async (o) => {
     try {
-      const report = await collectOnboardStatus();
+      const commandNames = program3.commands.map((c) => c.name());
+      const report = await collectOnboardStatus({ commandNames });
       if (o.json) {
         console.log(JSON.stringify(report, null, 2));
       } else {
@@ -28007,6 +28032,7 @@ function registerDiscoveryCommands(program3) {
         console.log(`Registry: ${report.registry.ok ? "\u2713" : "\u2717"} ${report.registry.detail}`);
         console.log(`Secrets: ${report.secrets.ok ? "\u2713" : "\u2717"} ${report.secrets.detail}`);
         console.log(`Plugin:   ${report.plugin.ok ? "\u2713" : "\u2717"} ${report.plugin.detail}`);
+        console.log(`Estate CLI: ${report.estateCli.ok ? "\u2713" : "\u2717"} ${report.estateCli.detail}`);
         console.log(`
 Next command: ${report.nextCommand}`);
       }
@@ -30056,7 +30082,7 @@ async function runDoctorClean(opts, io, deps) {
     if (!opts.json) io.log(`\u21BB ${line}`);
   };
   const healStep = (message) => {
-    if (!opts.json) io.log(`${VERBOSE_INDENT}${message.trim()}`);
+    if (!opts.json && opts.verbose) io.log(`${VERBOSE_INDENT}${message.trim()}`);
   };
   const releasedNote = deps.releasedVersionNote?.();
   let pluginHealed = false;
@@ -30091,30 +30117,63 @@ async function runDoctorClean(opts, io, deps) {
     }
   }
   async function runCliRow() {
+    const missing = deps.missingCliCommands?.() ?? [];
     const cliInput = { currentVersion: deps.currentCliVersion(), releasedVersion: released };
     const cliReport = buildVersionLagReport(cliInput);
-    if (!(applyEnv && deps.updateCli && versionAutoUpdateAction(cliReport) === "npm")) {
+    const capabilityGap = missing.length > 0 && Boolean(cliReport.releasedVersion);
+    const shouldUpdate = Boolean(
+      applyEnv && deps.updateCli && (versionAutoUpdateAction(cliReport) === "npm" || capabilityGap)
+    );
+    if (!shouldUpdate) {
       const cli = checkCliVersion(cliInput, releasedNote);
-      if (cli) emitNow(cli);
+      if (cli) {
+        if (missing.length) {
+          emitNow({
+            ...cli,
+            ok: false,
+            detail: cli.ok ? `missing commands: ${missing.join(", ")}` : `${cli.detail ?? ""}`.trim() || `missing commands: ${missing.join(", ")}`,
+            fix: `run \`mmi-cli doctor\` to heal the global CLI (missing: ${missing.join(", ")}), or \`${cliUpdateCommand(cliReport.releasedVersion)}\``,
+            verbose: [...cli.verbose ?? [], `missing commands: ${missing.join(", ")}`]
+          });
+        } else {
+          emitNow(cli);
+        }
+      } else if (missing.length) {
+        emitNow({
+          id: "cli-version",
+          ok: false,
+          label: "mmi-cli",
+          detail: `missing commands: ${missing.join(", ")}`,
+          fix: `run \`mmi-cli doctor\` to heal the global CLI, or \`${cliUpdateCommand(cliReport.releasedVersion)}\``,
+          verbose: [`missing commands: ${missing.join(", ")}`]
+        });
+      }
       return;
     }
-    healIntent(`mmi-cli \u2014 self-updating ${cliReport.currentVersion} \u2192 ${cliReport.releasedVersion} via npm install -g`);
-    const heal = await deps.updateCli(cliReport.releasedVersion, healStep);
-    const healEvidence = [`running:  ${cliReport.currentVersion}`, `published: ${cliReport.releasedVersion}`, `heal: ${heal.detail}`];
+    const target = cliReport.releasedVersion;
+    const intent = capabilityGap && cliReport.ok ? `mmi-cli \u2014 self-updating to ${target} via npm install -g (missing commands: ${missing.join(", ")})` : `mmi-cli \u2014 self-updating ${cliReport.currentVersion} \u2192 ${target} via npm install -g`;
+    healIntent(intent);
+    const heal = await deps.updateCli(target, healStep);
+    const healEvidence = [
+      `running:  ${cliReport.currentVersion}`,
+      `published: ${target ?? "(unknown)"}`,
+      `heal: ${heal.detail}`,
+      ...missing.length ? [`missing commands before heal: ${missing.join(", ")}`] : []
+    ];
     emitNow(heal.ok ? {
       id: "cli-version",
       ok: true,
       label: "mmi-cli",
-      detail: `${cliReport.currentVersion} \u2192 ${cliReport.releasedVersion} \u2014 self-updated via npm install -g; the next mmi-cli invocation runs the new version`,
+      detail: capabilityGap && cliReport.ok ? `${cliReport.currentVersion} \u2192 ${target} \u2014 self-updated via npm install -g (was missing: ${missing.join(", ")}); the next mmi-cli invocation runs the new version` : `${cliReport.currentVersion} \u2192 ${target} \u2014 self-updated via npm install -g; the next mmi-cli invocation runs the new version`,
       verbose: healEvidence
     } : {
       id: "cli-version",
       ok: false,
       label: "mmi-cli",
-      detail: `${cliReport.currentVersion} \u2192 ${cliReport.releasedVersion}`,
+      detail: capabilityGap && cliReport.ok ? `missing commands: ${missing.join(", ")}` : `${cliReport.currentVersion} \u2192 ${target}`,
       // #3489: same split as the plugin heal above — a lock-contention skip is not this run's gap.
       ...heal.skipped ? { reportOnly: true } : {},
-      fix: heal.skipped ? `${heal.detail} \u2014 another doctor on this machine is updating it now; re-run once it finishes` : `self-update failed (${heal.detail}) \u2014 run \`${cliUpdateCommand(cliReport.releasedVersion)}\``,
+      fix: heal.skipped ? `${heal.detail} \u2014 another doctor on this machine is updating it now; re-run once it finishes` : `self-update failed (${heal.detail}) \u2014 run \`${cliUpdateCommand(target)}\``,
       verbose: healEvidence
     });
   }
@@ -30177,8 +30236,10 @@ async function runDoctorClean(opts, io, deps) {
   }
   async function runDocsIndexRow() {
     let probe;
+    let root;
     try {
-      probe = deps.docsIndexState(await deps.repoRoot());
+      root = await deps.repoRoot();
+      probe = deps.docsIndexState(root);
     } catch (e) {
       const message = e instanceof Error ? e.message : String(e);
       emitNow({
@@ -30194,10 +30255,44 @@ async function runDoctorClean(opts, io, deps) {
       });
       return;
     }
+    let healedWrite = false;
+    if (applyRepo && probe?.drift && deps.healDocsIndex) {
+      healIntent("docs index \u2014 regenerating docs/index.md");
+      try {
+        probe = deps.healDocsIndex(root);
+        healedWrite = !probe.drift;
+      } catch (e) {
+        const message = e instanceof Error ? e.message : String(e);
+        emitNow({
+          ok: false,
+          id: "docs-index",
+          label: "docs index",
+          detail: `heal failed \u2014 ${message}`,
+          fix: "run `mmi-cli docs index --write` and commit docs/index.md",
+          verbose: [`healDocsIndex threw: ${message}`]
+        });
+        return;
+      }
+    }
     const docs2 = checkDocsIndex(probe);
-    if (docs2) emitNow(docs2);
+    if (!docs2) return;
+    if (healedWrite) {
+      emitNow({
+        ...docs2,
+        detail: "rewrote docs/index.md (working-tree heal \u2014 commit still needed)"
+      });
+      restartPending = true;
+      return;
+    }
+    emitNow(docs2);
   }
   async function runRepoIndexRow() {
+    const missing = deps.missingCliCommands?.() ?? [];
+    if (missing.includes("repo-index")) {
+      const row2 = checkRepoIndexCloud({ kind: "command-absent" });
+      if (row2) emitNow(row2);
+      return;
+    }
     if (lane.preflight && !opts.self && !lane.full) {
       emitNow({
         ok: true,
@@ -30227,8 +30322,176 @@ async function runDoctorClean(opts, io, deps) {
     const row = checkRepoIndexCloud(probe);
     if (row) emitNow(row);
   }
+  async function runBoardDoctorRow() {
+    if (!deps.boardDoctorFix) return;
+    try {
+      const result = await deps.boardDoctorFix({ fix: applyRepo });
+      if (!result) {
+        emitNow({
+          ok: true,
+          warn: true,
+          reportOnly: true,
+          id: "board-doctor",
+          label: "board doctor",
+          detail: "skipped",
+          verbose: ["boardDoctorFix returned undefined"]
+        });
+        return;
+      }
+      if (result.timedOut) {
+        emitNow({
+          ok: false,
+          warn: true,
+          reportOnly: true,
+          id: "board-doctor",
+          label: "board doctor",
+          detail: "timed out",
+          fix: "run `mmi-cli board doctor --fix`",
+          verbose: [`scanned before timeout: ${result.scanned}`, `findings: ${result.findings}`]
+        });
+        return;
+      }
+      const allFixed = applyRepo && result.findings > 0 && result.failed === 0 && result.fixed >= result.findings;
+      const ok = result.findings === 0 || Boolean(allFixed);
+      emitNow(ok ? {
+        ok: true,
+        id: "board-doctor",
+        label: "board doctor",
+        detail: `scanned ${result.scanned}; fixed ${result.fixed}`,
+        verbose: [`findings: ${result.findings}`, `fixed: ${result.fixed}`, `failed: ${result.failed}`]
+      } : {
+        ok: false,
+        // Gate when fix was attempted and mechanical findings remain; detect-only stays visible but
+        // report-only would hide a red that `board doctor --fix` clears — prefer gate after a failed fix.
+        reportOnly: !applyRepo,
+        id: "board-doctor",
+        label: "board doctor",
+        detail: `scanned ${result.scanned}; ${result.findings} findings; fixed ${result.fixed}; failed ${result.failed}`,
+        fix: "run `mmi-cli board doctor --fix`",
+        verbose: [`findings: ${result.findings}`, `fixed: ${result.fixed}`, `failed: ${result.failed}`]
+      });
+    } catch (e) {
+      const message = e instanceof Error ? e.message : String(e);
+      emitNow({
+        ok: true,
+        warn: true,
+        reportOnly: true,
+        id: "board-doctor",
+        label: "board doctor",
+        detail: `skipped \u2014 ${message}`,
+        verbose: [`boardDoctorFix threw: ${message}`]
+      });
+    }
+  }
+  async function runSchedulesDriftRow() {
+    if (!deps.schedulesDriftState) return;
+    try {
+      const state = await deps.schedulesDriftState();
+      if (!state) {
+        emitNow({
+          ok: true,
+          warn: true,
+          reportOnly: true,
+          id: "schedules-drift",
+          label: "schedules drift",
+          detail: "skipped",
+          verbose: ["schedulesDriftState returned undefined"]
+        });
+        return;
+      }
+      if (state.timedOut) {
+        emitNow({
+          ok: false,
+          warn: true,
+          reportOnly: true,
+          id: "schedules-drift",
+          label: "schedules drift",
+          detail: "timed out",
+          fix: "run `mmi-cli org schedules` / `org schedules register`",
+          verbose: ["schedulesDriftState timed out"]
+        });
+        return;
+      }
+      if (state.incomplete.length) {
+        emitNow({
+          ok: true,
+          warn: true,
+          reportOnly: true,
+          id: "schedules-drift",
+          label: "schedules drift",
+          detail: `incomplete \u2014 ${state.incomplete.join("; ")}`,
+          fix: "run `mmi-cli org schedules` / `org schedules register`",
+          verbose: state.incomplete
+        });
+        return;
+      }
+      if (state.driftLines.length === 0) {
+        emitNow({
+          ok: true,
+          reportOnly: true,
+          id: "schedules-drift",
+          label: "schedules drift",
+          detail: "no drift",
+          verbose: ["no drift lines"]
+        });
+        return;
+      }
+      emitNow({
+        ok: false,
+        reportOnly: true,
+        id: "schedules-drift",
+        label: "schedules drift",
+        detail: `${state.driftLines.length} drift line(s)`,
+        fix: "run `mmi-cli org schedules` / `org schedules register`",
+        verbose: state.driftLines
+      });
+    } catch (e) {
+      const message = e instanceof Error ? e.message : String(e);
+      emitNow({
+        ok: true,
+        warn: true,
+        reportOnly: true,
+        id: "schedules-drift",
+        label: "schedules drift",
+        detail: `skipped \u2014 ${message}`,
+        verbose: [`schedulesDriftState threw: ${message}`]
+      });
+    }
+  }
   async function runHousekeeperRows() {
     const repoRoot2 = await deps.repoRoot();
+    if (applyRepo && deps.sweepDeferred) {
+      try {
+        const sweep = await deps.sweepDeferred();
+        const detailParts = [];
+        if (sweep.removed.length) detailParts.push(`removed ${sweep.removed.length}`);
+        if (sweep.stillQueued) detailParts.push(`${sweep.stillQueued} still queued`);
+        if (sweep.skipped) detailParts.push(`${sweep.skipped} skipped`);
+        emitNow({
+          id: "deferred-worktrees",
+          ok: true,
+          label: "deferred worktrees",
+          detail: detailParts.length ? detailParts.join("; ") : "nothing queued",
+          verbose: [
+            ...sweep.removed.map((p) => `removed: ${p}`),
+            `stillQueued: ${sweep.stillQueued}`,
+            `skipped: ${sweep.skipped}`
+          ]
+        });
+        if (sweep.removed.length) restartPending = true;
+      } catch (e) {
+        const message = e instanceof Error ? e.message : String(e);
+        emitNow({
+          id: "deferred-worktrees",
+          ok: true,
+          warn: true,
+          reportOnly: true,
+          label: "deferred worktrees",
+          detail: `sweep failed (fail-soft) \u2014 ${message}`,
+          verbose: [`sweepDeferred threw: ${message}`]
+        });
+      }
+    }
     try {
       const plan = await deps.gcPlan("origin", 200);
       if (applyRepo) {
@@ -30285,9 +30548,7 @@ async function runDoctorClean(opts, io, deps) {
       emitNow(scratch.plan.safeAuto.length === 0 ? { id: "scratch", ok: true, label: "scratch", verbose: scratchEvidence } : { id: "scratch", ok: false, label: "scratch", detail: `${scratch.plan.safeAuto.length} aged item(s)`, fix: "run `mmi-cli doctor` (without --no-repo-writes)", verbose: scratchEvidence });
     }
   }
-  const table = [
-    // Heals first: the slowest work starts at second zero, and a stale mmi-cli is the binary every row
-    // below is being measured with (#3954).
+  const prefix = [
     { id: "plugin", when: true, run: runPluginRow },
     { id: "cli-version", when: true, run: runCliRow },
     { id: "github-auth", when: true, run: runGithubAuthRow },
@@ -30296,18 +30557,22 @@ async function runDoctorClean(opts, io, deps) {
     { id: "gitignore-block", when: isOrgRepo, run: runGitignoreRow },
     { id: "plugin-cache", when: true, run: runPluginCacheRow },
     { id: "sessionstart-payload", when: true, run: runSessionPayloadRow },
-    { id: "marketplace", when: true, run: runMarketplaceRows },
-    // A `docs/` tree walk plus one batched `git check-ignore` — cheap next to the two rows below it, but a
-    // disk walk and a subprocess all the same, so full lane only (#4091).
+    { id: "marketplace", when: true, run: runMarketplaceRows }
+  ];
+  for (const entry of prefix) if (entry.when) await entry.run();
+  const parallel = [
     { id: "docs-index", when: isOrgRepo && lane.full, run: runDocsIndexRow },
     // Hub cloud probe (short timeout). Full lane + `--self`; `--preflight` may emit command-absent only (#4156).
     { id: "repo-index", when: isOrgRepo && (lane.full || Boolean(opts.self) || lane.preflight), run: runRepoIndexRow },
-    // The two most expensive things in this file — a real `git fetch` plus train-branch fast-forward,
-    // and a `gh`-backed gc sweep with a 20s timeout — so org repos on the full lane only (#3485).
+    { id: "board-doctor", when: isOrgRepo && lane.full, run: runBoardDoctorRow },
+    { id: "schedules-drift", when: isOrgRepo && lane.full, run: runSchedulesDriftRow }
+  ];
+  await Promise.all(parallel.filter((entry) => entry.when).map((entry) => entry.run()));
+  const suffix = [
     { id: "train-branches", when: isOrgRepo && lane.full, run: runTrainSyncRow },
     { id: "housekeeper", when: isOrgRepo && lane.full, run: runHousekeeperRows }
   ];
-  for (const entry of table) if (entry.when) await entry.run();
+  for (const entry of suffix) if (entry.when) await entry.run();
   const exitCode = doctorReportExitCode(checks);
   if (opts.json) {
     const payload = opts.verbose ? checks : checks.map(({ verbose: _evidence, ...check }) => check);
@@ -30767,6 +31032,84 @@ function mmiDoctorDeps(opts = {}) {
       const drift = docsIndex({ ...real, listDocs }, { check: true }).drift;
       return { drift, docCount: listDocs().length };
     },
+    // #4168: working-tree heal — write if drifted, then re-check. Commit remains the operator's step.
+    healDocsIndex: (root) => {
+      if (!(0, import_node_fs39.existsSync)((0, import_node_path38.join)(root, DOCS_INDEX_PATH))) return { drift: false, docCount: 0 };
+      const real = createDocsIndexDeps(root);
+      let docs2;
+      const listDocs = () => docs2 ??= real.listDocs();
+      docsIndex({ ...real, listDocs }, { check: false });
+      const drift = docsIndex({ ...real, listDocs }, { check: true }).drift;
+      return { drift, docCount: listDocs().length };
+    },
+    // #4169: mirror `worktree gc --apply` — sweep deferred removals before applyGcPlan.
+    sweepDeferred: async () => {
+      const deferredStore = await createDeferredWorktreeStore();
+      const removalContext = await currentWorktreeRemovalContext("doctor deferred sweep");
+      const result = await sweepDeferredWorktrees(
+        deferredStore,
+        // #2841: same `-c core.fsmonitor=false` guard as `worktree gc --apply` / sweep-deferred.
+        worktreeRemoveDeps(async (args) => (await execFileP2("git", ["-c", "core.fsmonitor=false", ...args], { timeout: GIT_TIMEOUT_MS })).stdout),
+        removalContext
+      );
+      return {
+        removed: result.removed,
+        stillQueued: result.stillDeferred.length,
+        skipped: result.skipped.length
+      };
+    },
+    // #4170: light board doctor with 15s ceiling. skipClaimLiveness keeps Phase 3 off.
+    boardDoctorFix: async ({ fix } = {}) => {
+      const BOARD_DOCTOR_TIMEOUT_MS = 15e3;
+      try {
+        const cfg = await loadConfigForRepo();
+        const work = boardDoctor({
+          config: cfg,
+          fix: Boolean(fix),
+          skipClaimLiveness: true
+        });
+        const raced = await Promise.race([
+          work.then((r) => ({ ...r, timedOut: false })),
+          new Promise((resolve5) => {
+            setTimeout(() => resolve5({ timedOut: true, scanned: 0, findings: 0, fixed: 0, failed: 0 }), BOARD_DOCTOR_TIMEOUT_MS);
+          })
+        ]);
+        if (raced.timedOut) return { scanned: 0, findings: 0, fixed: 0, failed: 0, timedOut: true };
+        return {
+          scanned: raced.scanned,
+          findings: raced.findings,
+          fixed: raced.fixed,
+          failed: raced.failed
+        };
+      } catch {
+        return void 0;
+      }
+    },
+    // #4171: schedules drift notebook — report-only, ~20s ceiling.
+    schedulesDriftState: async () => {
+      const SCHEDULES_DRIFT_TIMEOUT_MS = 2e4;
+      try {
+        const raced = await Promise.race([
+          fetchNotebook().then((nb) => ({
+            driftLines: nb.drift,
+            incomplete: nb.incomplete,
+            timedOut: false
+          })),
+          new Promise((resolve5) => {
+            setTimeout(() => resolve5({ driftLines: [], incomplete: [], timedOut: true }), SCHEDULES_DRIFT_TIMEOUT_MS);
+          })
+        ]);
+        return raced;
+      } catch {
+        return void 0;
+      }
+    },
+    // #4173: estate commands absent from the running Commander program (stale global CLI).
+    missingCliCommands: () => {
+      const required = ["repo-index"];
+      const names = new Set((opts.program?.commands ?? []).map((c) => c.name()));
+      return required.filter((n) => !names.has(n));
+    },
     // #4156: short-timeout Hub status for the current repo. Fail-soft ? never throws to doctor.
     repoIndexCloudState: async (root) => {
       const local = repoIndexStatus(root);
@@ -33801,7 +34144,7 @@ program2.command("doctor").description("heal CLI/plugin wiring and clean up repo
       verbose: opts.verbose
     },
     consoleIo,
-    mmiDoctorDeps()
+    mmiDoctorDeps({ program: program2 })
   );
 });
 program2.command("guard").description("detect a pruned/unresolved MMI plugin on disk").action(() => runGuard());
@@ -33944,7 +34287,7 @@ program2.command("session-start").description("run the SessionStart verbs (whoam
     // #3485 item 7: the ONLY lane that throttles the npm read ? it runs on every session start, on a
     // blocking hook. Every interactive lane still reads live.
     doctor: async (io) => {
-      await runDoctorClean({ banner: true }, io, mmiDoctorDeps({ throttleReleasedRead: true }));
+      await runDoctorClean({ banner: true }, io, mmiDoctorDeps({ throttleReleasedRead: true, program: program2 }));
     }
   });
   await runSessionStart(parallel, sequential, bannerIo);

package/package.json

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