@mutmutco/cli 3.15.0 → 3.16.1

package/README.md

@@ -2,7 +2,7 @@
 
 The command-line engine for MMI Future org tooling. It delivers the org-managed `.gitignore` block, reads and claims GitHub Project work, and exposes the model-agnostic commands used by the MMI plugin and non-Claude agents. (Personal agent guides — `AGENTS.md` / `CLAUDE.md` — are developer-owned and gitignored; the CLI does not deliver, overwrite, or fan them out — the whole-spine fanout is retired.)
 
-This package is published from [mutmutco/MMI-Hub](https://github.com/mutmutco/MMI-Hub) and its version matches the MMI Hub Claude Code, Codex, Cursor, and OpenCode distribution versions (the release train bumps all of them in lockstep).
+This package is published from [mutmutco/MMI-Hub](https://github.com/mutmutco/MMI-Hub) and its version matches the MMI Hub Claude Code plugin distribution version (Claude-only since #2741; the release train bumps both in lockstep).
 
 The CLI carries the org **Hub endpoint** intrinsically (override with the `MMI_HUB_URL` env var), so a product repo needs **no committed control-plane config** to reach the Hub — board coords, deploy coordinates, OAuth, and the secrets layout are all discovered from the Hub registry at runtime.
 

package/dist/main.cjs

@@ -6299,30 +6299,54 @@ async function registerDeferredWorktree(store, entry) {
   return { entries, newlyRegistered: true };
 }
 async function sweepDeferredWorktrees(store, deps) {
-  if (!store) return { removed: [], stillDeferred: [] };
+  if (!store) return { removed: [], stillDeferred: [], skipped: [] };
   const entries = await store.read();
-  if (!entries.length) return { removed: [], stillDeferred: [] };
+  if (!entries.length) return { removed: [], stillDeferred: [], skipped: [] };
+  let live;
+  try {
+    live = parseWorktreePorcelain(await deps.git(["worktree", "list", "--porcelain"]));
+  } catch {
+    live = [];
+  }
   const removed = [];
   const stillDeferred = [];
+  const skipped = [];
   for (const entry of entries) {
+    const current = live.find((w) => samePath(w.path, entry.path));
+    if (current && current.branch !== entry.branch) {
+      skipped.push(entry);
+      continue;
+    }
+    if (current) {
+      const dirty = (await deps.git(["-C", entry.path, "status", "--porcelain"]).catch(() => "dirty") || "").trim().length > 0;
+      if (dirty) {
+        stillDeferred.push(entry);
+        continue;
+      }
+    }
     const outcome = await removeWorktreeWithRecovery(entry.path, deps);
     if (outcome.status === "removed") removed.push(entry.path);
     else stillDeferred.push(entry);
   }
   await store.write(stillDeferred);
-  return { removed, stillDeferred };
+  return { removed, stillDeferred, skipped };
 }
 async function sweepDeferredWorktreesWithRetry(store, deps, opts = {}) {
   const attempts = opts.attempts ?? 4;
   const backoff = opts.backoffMs ?? [500, 2e3, 5e3, 1e4];
   const sleep = opts.sleep ?? defaultSleep;
-  let last = { removed: [], stillDeferred: [] };
+  const removed = [];
+  const skipped = [];
+  let stillDeferred = [];
   for (let i = 0; i < attempts; i++) {
-    last = await sweepDeferredWorktrees(store, deps);
-    if (!last.stillDeferred.length) return last;
+    const result = await sweepDeferredWorktrees(store, deps);
+    removed.push(...result.removed);
+    skipped.push(...result.skipped);
+    stillDeferred = result.stillDeferred;
+    if (!stillDeferred.length) break;
     if (i < attempts - 1) await sleep(backoff[Math.min(i, backoff.length - 1)]);
   }
-  return last;
+  return { removed, stillDeferred, skipped };
 }
 var defaultSleep = (ms) => new Promise((resolve5) => setTimeout(resolve5, ms));
 async function removeWorktreeWithRecovery(wtPath, deps) {
@@ -19137,6 +19161,18 @@ function checkClaudePlugin(probe) {
   }
   return { ok: true, label: installed ? `Claude plugin ${installed}` : "Claude plugin" };
 }
+function checkTrainSync(result) {
+  const problems = result.branches.filter((b) => b.status === "skipped" && (b.reason === "diverged" || b.reason === "ff-failed"));
+  if (problems.length) {
+    return { ok: false, label: "train branches", fix: problems.map((b) => b.note).join("; ") };
+  }
+  const moved = result.branches.filter((b) => b.status === "synced");
+  return {
+    ok: true,
+    label: "train branches",
+    detail: moved.length ? `fast-forwarded ${moved.map((b) => b.branch).join(", ")}` : void 0
+  };
+}
 function planGitignore(current) {
   const { content, changed } = upsertManagedGitignoreBlock(current);
   return changed ? { ok: false, content } : { ok: true };
@@ -19175,6 +19211,11 @@ async function runDoctorClean(opts, io, deps) {
   checks.push(plugin);
   if (!plugin.ok) restartPending = true;
   if (isOrgRepo && !opts.fast && !opts.banner) {
+    try {
+      checks.push(checkTrainSync(await deps.syncTrain()));
+    } catch (e) {
+      checks.push({ ok: false, label: "train branches", fix: `sync failed \u2014 ${e instanceof Error ? e.message : String(e)}` });
+    }
     const repoRoot2 = await deps.repoRoot();
     try {
       const plan = await deps.gcPlan("origin", 200);
@@ -19438,6 +19479,7 @@ async function applyGcPlan(plan, remote) {
   }
   return result;
 }
+var execFileGitRun = async (file, args) => (await execFileP2(file, args, { timeout: GIT_TIMEOUT_MS })).stdout;
 function mmiDoctorDeps() {
   return {
     githubLogin,
@@ -19452,7 +19494,10 @@ function mmiDoctorDeps() {
     repoRoot,
     gcPlan,
     applyGcPlan,
-    executeScratchGc: (root, o) => executeScratchGc(root, { apply: o.apply })
+    executeScratchGc: (root, o) => executeScratchGc(root, { apply: o.apply }),
+    // #2759: same fetch+ff-only sync SessionStart runs, wired here too so an on-demand `mmi-cli doctor`
+    // self-heals a checkout a long-running session left stale.
+    syncTrain: () => syncLocalTrainBranches(execFileGitRun)
   };
 }
 async function requireFreshTrainCli(commandName) {
@@ -19611,10 +19656,11 @@ gcCmd.command("sweep-deferred").description("retry IDE-locked deferred worktree
       worktreeRemoveDeps(async (args) => (await execFileP2("git", args, { timeout: GIT_TIMEOUT_MS })).stdout)
     );
     if (o.json) return console.log(JSON.stringify(result));
-    if (!o.quiet || result.removed.length || result.stillDeferred.length) {
+    if (!o.quiet || result.removed.length || result.stillDeferred.length || result.skipped.length) {
       if (result.removed.length) console.log(`gc sweep-deferred: removed ${result.removed.length} worktree(s)`);
       if (result.stillDeferred.length) console.log(`gc sweep-deferred: ${result.stillDeferred.length} still queued (will retry on next session)`);
-      if (!result.removed.length && !result.stillDeferred.length) console.log("gc sweep-deferred: nothing queued");
+      if (result.skipped.length) console.log(`gc sweep-deferred: ${result.skipped.length} dropped (repurposed for different work since queued, left untouched)`);
+      if (!result.removed.length && !result.stillDeferred.length && !result.skipped.length) console.log("gc sweep-deferred: nothing queued");
     }
   } catch (e) {
     fail(`gc sweep-deferred: ${e.message}`);
@@ -22567,8 +22613,7 @@ program2.command("session-start").description("run the SessionStart verbs (whoam
     // release pushed to origin (incl. the deferred main -> development alignment merge). Bounded git,
     // fail-soft, silent unless a branch moved.
     syncTrain: async (io) => {
-      const gitRun = async (file, args) => (await execFileP2(file, args, { timeout: GIT_TIMEOUT_MS })).stdout;
-      const result = await syncLocalTrainBranches(gitRun, { warn: (m) => io.err(`[mmi-hook] train sync: ${m}`) });
+      const result = await syncLocalTrainBranches(execFileGitRun, { warn: (m) => io.err(`[mmi-hook] train sync: ${m}`) });
       const line = localTrainSyncBannerLine(result);
       if (line) io.log(line);
     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mutmutco/cli",
-  "version": "3.15.0",
+  "version": "3.16.1",
   "description": "MMI Future CLI — the org dev toolbox (board, registry, keyless secrets, release train, bootstrap, doctor) and the cross-IDE engine the plugin's session-start hook drives.",
   "type": "module",
   "license": "UNLICENSED",