@mutmutco/cli 3.105.10 → 3.105.12

package/dist/main.cjs

@@ -5000,7 +5000,7 @@ var program = new Command();
 
 // src/index.ts
 var import_promises11 = require("node:fs/promises");
-var import_node_fs42 = require("node:fs");
+var import_node_fs43 = require("node:fs");
 var import_node_child_process19 = require("node:child_process");
 
 // src/cli-shared.ts
@@ -6517,12 +6517,148 @@ function localTrainSyncBannerLine(result) {
 
 // src/gc.ts
 var import_promises = require("node:fs/promises");
-var import_node_path8 = require("node:path");
+var import_node_path9 = require("node:path");
 
-// src/worktree-ownership.ts
+// src/active-workspace-root.ts
 var import_node_fs9 = require("node:fs");
 var import_node_os3 = require("node:os");
 var import_node_path7 = require("node:path");
+var ACTIVE_WORKSPACE_ROOT_ENV = "MMI_ACTIVE_WORKSPACE_ROOT";
+function normPath(p, platform2 = process.platform) {
+  const unified = p.replace(/\\/g, "/").replace(/\/+$/, "");
+  return platform2 === "win32" || platform2 === "darwin" ? unified.toLowerCase() : unified;
+}
+function isPathUnderDirectory(childPath, parentPath, platform2 = process.platform) {
+  const child2 = normPath(childPath, platform2);
+  const parent = normPath(parentPath, platform2);
+  if (!child2 || !parent) return false;
+  if (child2 === parent) return true;
+  return child2.startsWith(`${parent}/`);
+}
+function normalizeActiveWorkspaceRoot(value, opts = {}) {
+  const raw = value?.trim();
+  if (!raw) return void 0;
+  if (!(0, import_node_path7.isAbsolute)(raw)) return void 0;
+  const exists = opts.exists ?? import_node_fs9.existsSync;
+  if (!exists(raw)) return void 0;
+  return normPath(raw, opts.platform);
+}
+function removalTouchesActiveWorkspace(targetPath, activeWorkspaceRoot, platform2 = process.platform) {
+  const target = normPath(targetPath, platform2);
+  const root = normPath(activeWorkspaceRoot, platform2);
+  if (!target || !root) return false;
+  return isPathUnderDirectory(root, target, platform2);
+}
+function activeWorkspaceRefusalMessage(targetPath, activeWorkspaceRoot) {
+  return `refusing to remove active Cursor workspace ${activeWorkspaceRoot} (target ${targetPath}). Open the primary checkout in Cursor first, then retry \`mmi-cli worktree gc sweep-deferred\` / \`worktree gc --apply\`.`;
+}
+function decideActiveWorkspaceGuard(targetPath, activeWorkspaceRoot, platform2 = process.platform) {
+  if (!activeWorkspaceRoot) return { action: "proceed" };
+  if (!removalTouchesActiveWorkspace(targetPath, activeWorkspaceRoot, platform2)) {
+    return { action: "proceed" };
+  }
+  return {
+    action: "refuse",
+    reason: "active-workspace",
+    activeWorkspaceRoot,
+    message: activeWorkspaceRefusalMessage(targetPath, activeWorkspaceRoot)
+  };
+}
+function cursorProjectSlugFromAgentTranscripts(agentTranscripts) {
+  const raw = agentTranscripts?.trim();
+  if (!raw) return void 0;
+  const unified = raw.replace(/\\/g, "/").replace(/\/+$/, "");
+  const parts = unified.split("/");
+  const idx = parts.lastIndexOf("agent-transcripts");
+  if (idx <= 0) return void 0;
+  const slug = parts[idx - 1]?.trim();
+  return slug || void 0;
+}
+function cursorProjectSlugFromFolderPath(folderPath, platform2 = process.platform) {
+  let unified = folderPath.replace(/\\/g, "/").replace(/\/+$/, "");
+  if (platform2 === "win32") {
+    unified = unified.replace(/^\/+/, "");
+  } else if (unified.startsWith("/")) {
+    unified = unified.slice(1);
+  }
+  return unified.replace(/\//g, "-");
+}
+function cursorWorkspaceStorageRoot(platform2 = process.platform, home = (0, import_node_os3.homedir)()) {
+  if (platform2 === "darwin") {
+    return (0, import_node_path7.join)(home, "Library", "Application Support", "Cursor", "User", "workspaceStorage");
+  }
+  if (platform2 === "win32") {
+    return (0, import_node_path7.join)(home, "AppData", "Roaming", "Cursor", "User", "workspaceStorage");
+  }
+  return (0, import_node_path7.join)(home, ".config", "Cursor", "User", "workspaceStorage");
+}
+function folderUriToPath(uri) {
+  const trimmed = uri.trim();
+  if (!trimmed.startsWith("file://")) return void 0;
+  let rest = trimmed.slice("file://".length);
+  if (/^\/[A-Za-z]:\//.test(rest)) rest = rest.slice(1);
+  try {
+    return decodeURIComponent(rest);
+  } catch {
+    return rest;
+  }
+}
+function resolveCursorAgentWorkspaceRoot(deps = {}) {
+  const env = deps.env ?? process.env;
+  const platform2 = deps.platform ?? process.platform;
+  const exists = deps.exists ?? import_node_fs9.existsSync;
+  const readTextFile = deps.readTextFile ?? ((path2) => {
+    try {
+      return (0, import_node_fs9.readFileSync)(path2, "utf8");
+    } catch {
+      return void 0;
+    }
+  });
+  const listDir = deps.listDir ?? ((path2) => {
+    try {
+      return (0, import_node_fs9.readdirSync)(path2);
+    } catch {
+      return [];
+    }
+  });
+  const slug = cursorProjectSlugFromAgentTranscripts(env.AGENT_TRANSCRIPTS);
+  if (!slug) return void 0;
+  const storageRoot = cursorWorkspaceStorageRoot(platform2, (deps.homedir ?? import_node_os3.homedir)());
+  if (!exists(storageRoot)) return void 0;
+  const matches = /* @__PURE__ */ new Set();
+  for (const entry of listDir(storageRoot)) {
+    const text = readTextFile((0, import_node_path7.join)(storageRoot, entry, "workspace.json"));
+    if (!text) continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(text.replace(/^\uFEFF/, ""));
+    } catch {
+      continue;
+    }
+    if (typeof parsed.folder !== "string") continue;
+    const folderPath = folderUriToPath(parsed.folder);
+    if (!folderPath || !exists(folderPath)) continue;
+    if (cursorProjectSlugFromFolderPath(folderPath, platform2) !== slug) continue;
+    matches.add(normPath(folderPath, platform2));
+  }
+  if (matches.size !== 1) return void 0;
+  return [...matches][0];
+}
+function resolveActiveWorkspaceRoot(deps = {}) {
+  const env = deps.env ?? process.env;
+  const platform2 = deps.platform ?? process.platform;
+  const exists = deps.exists ?? import_node_fs9.existsSync;
+  const fromEnv = normalizeActiveWorkspaceRoot(env[ACTIVE_WORKSPACE_ROOT_ENV], { exists, platform: platform2 });
+  if (fromEnv) return fromEnv;
+  const cursorAgent = env.CURSOR_AGENT === "1" || Boolean(env.CURSOR_EXTENSION_HOST_ROLE?.trim());
+  if (!cursorAgent && !env.AGENT_TRANSCRIPTS?.trim()) return void 0;
+  return resolveCursorAgentWorkspaceRoot(deps);
+}
+
+// src/worktree-ownership.ts
+var import_node_fs10 = require("node:fs");
+var import_node_os4 = require("node:os");
+var import_node_path8 = require("node:path");
 var OWNERS_FILE = "worktree-owners.json";
 var EVENTS_FILE = "worktree-events.jsonl";
 var WORKTREE_ACTIVITY_WINDOW_MS = 30 * 6e4;
@@ -6546,7 +6682,7 @@ function describeActor(input) {
   const session = readSessionId(input.env);
   return {
     surface: input.surface,
-    host: input.host ?? (0, import_node_os3.hostname)(),
+    host: input.host ?? (0, import_node_os4.hostname)(),
     pid: input.pid ?? process.pid,
     cwd: input.cwd,
     ...session ? { session } : {}
@@ -6627,7 +6763,7 @@ function decideWorktreeRemoval(input) {
 }
 function readFreshWorktreeLease(path2, now) {
   try {
-    const candidate = JSON.parse((0, import_node_fs9.readFileSync)((0, import_node_path7.join)(path2, WORKTREE_LEASE_MARKER), "utf8"));
+    const candidate = JSON.parse((0, import_node_fs10.readFileSync)((0, import_node_path8.join)(path2, WORKTREE_LEASE_MARKER), "utf8"));
     if (!candidate || typeof candidate !== "object" || Array.isArray(candidate)) return void 0;
     const lease = candidate;
     if (lease.kind !== "worktree" || lease.state !== "active" || typeof lease.agent !== "string" || !lease.agent.trim() || typeof lease.ref !== "string" || !sameWorktreePath(lease.ref, path2) || typeof lease.createdAt !== "string" || typeof lease.ttlHours !== "number" || !Number.isFinite(lease.ttlHours) || lease.ttlHours <= 0) return void 0;
@@ -6646,7 +6782,7 @@ function describeActorShort(actor) {
 }
 function readOwners(primaryRoot) {
   try {
-    return parseWorktreeOwners((0, import_node_fs9.readFileSync)(worktreeOwnersPath(primaryRoot), "utf8"));
+    return parseWorktreeOwners((0, import_node_fs10.readFileSync)(worktreeOwnersPath(primaryRoot), "utf8"));
   } catch {
     return [];
   }
@@ -6654,8 +6790,8 @@ function readOwners(primaryRoot) {
 function writeOwners(primaryRoot, entries) {
   try {
     const path2 = worktreeOwnersPath(primaryRoot);
-    (0, import_node_fs9.mkdirSync)((0, import_node_path7.dirname)(path2), { recursive: true });
-    (0, import_node_fs9.writeFileSync)(path2, serializeWorktreeOwners(entries), "utf8");
+    (0, import_node_fs10.mkdirSync)((0, import_node_path8.dirname)(path2), { recursive: true });
+    (0, import_node_fs10.writeFileSync)(path2, serializeWorktreeOwners(entries), "utf8");
   } catch {
   }
 }
@@ -6690,8 +6826,8 @@ function dropWorktreeOwner(primaryRoot, path2, expectedCreatedAt) {
 function appendWorktreeEvent(primaryRoot, event) {
   try {
     const path2 = worktreeEventsPath(primaryRoot);
-    (0, import_node_fs9.mkdirSync)((0, import_node_path7.dirname)(path2), { recursive: true });
-    (0, import_node_fs9.appendFileSync)(path2, `${JSON.stringify({ at: event.at ?? (/* @__PURE__ */ new Date()).toISOString(), ...event })}
+    (0, import_node_fs10.mkdirSync)((0, import_node_path8.dirname)(path2), { recursive: true });
+    (0, import_node_fs10.appendFileSync)(path2, `${JSON.stringify({ at: event.at ?? (/* @__PURE__ */ new Date()).toISOString(), ...event })}
 `, "utf8");
   } catch {
   }
@@ -6708,7 +6844,7 @@ function recordWorktreeRemoval(primaryRoot, event) {
 function readWorktreeEvents(primaryRoot, limit = 50) {
   let text;
   try {
-    text = (0, import_node_fs9.readFileSync)(worktreeEventsPath(primaryRoot), "utf8");
+    text = (0, import_node_fs10.readFileSync)(worktreeEventsPath(primaryRoot), "utf8");
   } catch {
     return [];
   }
@@ -6805,7 +6941,12 @@ async function isCommitUnreferenced(oid, git2) {
   return refs !== void 0 && !refs.trim();
 }
 var DEFERRED_SWEEP_COMMAND = "mmi-cli worktree gc sweep-deferred";
-var DEFERRED_NOTE = "Worktree cleanup queued (IDE lock). Detached sweep will retry automatically \u2014 no human action required.";
+function deferredNoteFor(reason) {
+  if (reason === "active-workspace") {
+    return "Worktree cleanup queued (active Cursor workspace). Open the primary checkout in Cursor first \u2014 then detached sweep / `worktree gc sweep-deferred` can remove it.";
+  }
+  return "Worktree cleanup queued (IDE lock). Detached sweep will retry automatically \u2014 no human action required.";
+}
 var PRESERVED_WORKTREE_CONFIG = "mmi.preservedWorktreeBranch";
 var WORKTREE_LOCK_RE = /EPERM|EBUSY|EACCES|ENOTEMPTY|permission denied|access is denied|used by another process|resource busy|directory not empty/i;
 function isWorktreeLockError(error) {
@@ -6821,14 +6962,14 @@ function deferredWorktreesRegistryPath(gitDir) {
 function parseDeferredWorktreesFile(text) {
   const parsed = JSON.parse(text.replace(/^\uFEFF/, ""));
   if (!parsed || !Array.isArray(parsed.entries)) return [];
-  return parsed.entries.filter((e) => Boolean(e) && typeof e === "object" && typeof e.path === "string" && typeof e.branch === "string" && e.reason === "lock-held").map((e) => ({ ...e, registeredAt: e.registeredAt || (/* @__PURE__ */ new Date(0)).toISOString() }));
+  return parsed.entries.filter((e) => Boolean(e) && typeof e === "object" && typeof e.path === "string" && typeof e.branch === "string" && (e.reason === "lock-held" || e.reason === "active-workspace")).map((e) => ({ ...e, registeredAt: e.registeredAt || (/* @__PURE__ */ new Date(0)).toISOString() }));
 }
 function serializeDeferredWorktrees(entries) {
   return `${JSON.stringify({ entries }, null, 2)}
 `;
 }
 function deferredPathKey(path2) {
-  return normPath(path2);
+  return normPath2(path2);
 }
 function isPersistentWorktreeLockFailure(outcome) {
   return outcome.status === "failed" && isWorktreeLockError(outcome.error);
@@ -6838,7 +6979,7 @@ async function registerDeferredWorktree(store, entry) {
   const built = {
     ...entry,
     registeredAt: entry.registeredAt ?? (/* @__PURE__ */ new Date()).toISOString(),
-    reason: "lock-held"
+    reason: entry.reason ?? "lock-held"
   };
   let newlyRegistered = false;
   const mutate = (existing2) => {
@@ -6879,6 +7020,21 @@ async function sweepDeferredWorktrees(store, deps, removalContext) {
     }
     const owner = removalContext ? lookupWorktreeOwner(removalContext.primaryRoot, entry.path) : void 0;
     if (removalContext) {
+      const activeRoot = removalContext.activeWorkspaceRoot ?? resolveActiveWorkspaceRoot();
+      const activeGuard = decideActiveWorkspaceGuard(entry.path, activeRoot);
+      if (activeGuard.action === "refuse") {
+        stillDeferred.push({ ...entry, reason: "active-workspace" });
+        recordWorktreeRemoval(removalContext.primaryRoot, {
+          action: "refused",
+          command: removalContext.command,
+          target: entry.path,
+          branch: entry.branch,
+          actor: removalContext.actor,
+          owner,
+          reason: activeGuard.message
+        });
+        continue;
+      }
       const verdict = decideWorktreeRemoval({
         path: entry.path,
         owner,
@@ -7002,10 +7158,10 @@ function baseName(p) {
   return p.replace(/[/\\]+$/, "").split(/[/\\]/).pop() ?? "";
 }
 function assertSafeWorktreeTarget(worktreePath, primaryCheckout) {
-  const wt = normPath(worktreePath);
+  const wt = normPath2(worktreePath);
   if (!wt) throw new Error("worktree teardown refused: empty target path");
   if (!primaryCheckout) return;
-  const primary = normPath(primaryCheckout);
+  const primary = normPath2(primaryCheckout);
   if (wt === primary) throw new Error(`worktree teardown refused: target is the primary checkout (${worktreePath})`);
   if (primary.startsWith(`${wt}/`)) {
     throw new Error(`worktree teardown refused: target ${worktreePath} contains the primary checkout`);
@@ -7161,7 +7317,7 @@ function resolveSafeSiblingWorktreeCleanupTarget(worktreePath, siblingRoot, deps
   } catch {
     return { ok: false, reason: "sibling root could not be resolved" };
   }
-  if (!isPathUnderDirectory(rootReal, siblingRoot) || !isPathUnderDirectory(siblingRoot, rootReal)) {
+  if (!isPathUnderDirectory2(rootReal, siblingRoot) || !isPathUnderDirectory2(siblingRoot, rootReal)) {
     return { ok: false, reason: "sibling root resolves outside expected path" };
   }
   try {
@@ -7169,26 +7325,26 @@ function resolveSafeSiblingWorktreeCleanupTarget(worktreePath, siblingRoot, deps
   } catch {
     return { ok: false, reason: "worktree path could not be resolved" };
   }
-  if (!isPathUnderDirectory(worktreeReal, rootReal)) {
+  if (!isPathUnderDirectory2(worktreeReal, rootReal)) {
     return { ok: false, reason: "resolved worktree path outside sibling root" };
   }
   return { ok: true, path: worktreePath };
 }
 function siblingMmiWorktreesRoot(repoRoot2) {
-  const parent = (0, import_node_path8.dirname)(repoRoot2);
-  if ((0, import_node_path8.basename)(parent).toLowerCase() === "mmi-worktrees") return parent;
-  const grandparent = (0, import_node_path8.dirname)(parent);
-  if ((0, import_node_path8.basename)(grandparent).toLowerCase() === "mmi-worktrees") return grandparent;
-  return (0, import_node_path8.join)(parent, "mmi-worktrees");
+  const parent = (0, import_node_path9.dirname)(repoRoot2);
+  if ((0, import_node_path9.basename)(parent).toLowerCase() === "mmi-worktrees") return parent;
+  const grandparent = (0, import_node_path9.dirname)(parent);
+  if ((0, import_node_path9.basename)(grandparent).toLowerCase() === "mmi-worktrees") return grandparent;
+  return (0, import_node_path9.join)(parent, "mmi-worktrees");
 }
 function worktreeScanDirs(root, repoRoot2, listDirs, isRepoCheckout) {
-  const projectsDir = (0, import_node_path8.dirname)(root);
-  const ownName = (0, import_node_path8.basename)(repoRoot2).toLowerCase();
+  const projectsDir = (0, import_node_path9.dirname)(root);
+  const ownName = (0, import_node_path9.basename)(repoRoot2).toLowerCase();
   const flat = [];
   let ownContainer = null;
   for (const dir of listDirs(root)) {
-    const name = (0, import_node_path8.basename)(dir);
-    if (isRepoCheckout((0, import_node_path8.join)(projectsDir, name))) {
+    const name = (0, import_node_path9.basename)(dir);
+    if (isRepoCheckout((0, import_node_path9.join)(projectsDir, name))) {
       if (name.toLowerCase() === ownName) ownContainer = dir;
       continue;
     }
@@ -7197,9 +7353,9 @@ function worktreeScanDirs(root, repoRoot2, listDirs, isRepoCheckout) {
   return ownContainer ? [...flat, ...listDirs(ownContainer)] : flat;
 }
 function explicitRepoWorktreesRoot(root, repoRoot2, rootDirs) {
-  const repoName = (0, import_node_path8.basename)(repoRoot2);
+  const repoName = (0, import_node_path9.basename)(repoRoot2);
   const repoDir = rootDirs.find((name) => name.toLowerCase() === repoName.toLowerCase());
-  return repoDir ? (0, import_node_path8.join)(root, repoDir) : root;
+  return repoDir ? (0, import_node_path9.join)(root, repoDir) : root;
 }
 function classifySiblingWorktreeDir(entry) {
   if (!entry.ownedByCurrentRepo) {
@@ -7475,12 +7631,12 @@ function parseWorktreePorcelain(stdout) {
 function pathsAreCaseInsensitive(platform2 = process.platform) {
   return platform2 === "win32" || platform2 === "darwin";
 }
-function normPath(p, platform2 = process.platform) {
+function normPath2(p, platform2 = process.platform) {
   const unified = p.replace(/\\/g, "/").replace(/\/+$/, "");
   return pathsAreCaseInsensitive(platform2) ? unified.toLowerCase() : unified;
 }
 function samePath(a, b, platform2 = process.platform) {
-  return normPath(a, platform2) === normPath(b, platform2);
+  return normPath2(a, platform2) === normPath2(b, platform2);
 }
 function toNativePath(p) {
   return process.platform === "win32" ? p.replace(/\//g, "\\") : p;
@@ -7515,12 +7671,12 @@ function parseComposeLs(stdout) {
   }).filter((p) => Boolean(p));
 }
 function selectWorktreeComposeProjects(worktreePath, projects) {
-  const root = normPath(worktreePath);
+  const root = normPath2(worktreePath);
   if (!root) return [];
   const names = [];
   for (const project2 of projects) {
     const inside = project2.configFiles.some((file) => {
-      const f = normPath(file);
+      const f = normPath2(file);
       return f === root || f.startsWith(`${root}/`);
     });
     if (inside && !names.includes(project2.name)) names.push(project2.name);
@@ -7528,7 +7684,7 @@ function selectWorktreeComposeProjects(worktreePath, projects) {
   return names;
 }
 function deriveComposeProjectName(worktreePath) {
-  const norm = normPath(worktreePath).toLowerCase();
+  const norm = normPath2(worktreePath).toLowerCase();
   if (!norm) return void 0;
   const base = norm.slice(norm.lastIndexOf("/") + 1);
   const name = base.replace(/[^a-z0-9_-]+/g, "_").replace(/^[^a-z0-9]+/, "");
@@ -7589,15 +7745,15 @@ function selectSafeWorktreeCwd(worktrees, targetPath, options) {
   const exists = options?.pathExists ?? (() => true);
   return worktrees.find((w) => !samePath(w.path, targetPath) && exists(w.path))?.path;
 }
-function isPathUnderDirectory(childPath, parentPath) {
-  const child2 = normPath(childPath);
-  const parent = normPath(parentPath);
+function isPathUnderDirectory2(childPath, parentPath) {
+  const child2 = normPath2(childPath);
+  const parent = normPath2(parentPath);
   if (!child2 || !parent) return false;
   if (child2 === parent) return true;
   return child2.startsWith(`${parent}/`);
 }
 function planReleaseCwdBeforeWorktreeRemoval(targetPath, safeCwd, currentCwd) {
-  if (!safeCwd || !isPathUnderDirectory(currentCwd, targetPath)) return void 0;
+  if (!safeCwd || !isPathUnderDirectory2(currentCwd, targetPath)) return void 0;
   if (samePath(currentCwd, safeCwd)) return void 0;
   return safeCwd;
 }
@@ -7748,6 +7904,57 @@ async function cleanupPrMergeLocalBranch(branch, options) {
   if (wtPath && mainWorktreeTarget) {
     report.worktree = { path: wtPath, status: "not-attempted", reason: "main-worktree" };
   } else if (wtPath) {
+    const activeRoot = options.removalContext?.activeWorkspaceRoot ?? resolveActiveWorkspaceRoot();
+    const activeGuard = decideActiveWorkspaceGuard(wtPath, activeRoot);
+    if (activeGuard.action === "refuse") {
+      if (options.deferredStore) {
+        try {
+          const { newlyRegistered } = await registerDeferredWorktree(options.deferredStore, {
+            path: wtPath,
+            branch,
+            reason: "active-workspace"
+          });
+          report.worktree = {
+            path: wtPath,
+            status: "deferred",
+            reason: "active-workspace",
+            deferredNote: deferredNoteFor("active-workspace"),
+            deferredSweepCommand: DEFERRED_SWEEP_COMMAND,
+            ...newlyRegistered ? { safeCleanupCommand: safeWorktreeRemoveCommand(safeCwd, wtPath) } : {}
+          };
+          if (options.removalContext) {
+            recordWorktreeRemoval(options.removalContext.primaryRoot, {
+              action: "refused",
+              command: options.removalContext.command,
+              target: wtPath,
+              branch,
+              actor: options.removalContext.actor,
+              owner: lookupWorktreeOwner(options.removalContext.primaryRoot, wtPath),
+              reason: activeGuard.message
+            });
+          }
+          noteBranchBlocked("active-workspace");
+          return report;
+        } catch (e) {
+          report.worktree = {
+            path: wtPath,
+            status: "not-attempted",
+            reason: "active-workspace",
+            error: `${activeGuard.message}; deferred registry unavailable: ${errorMessage(e)}`
+          };
+          noteBranchBlocked("active-workspace");
+          return report;
+        }
+      }
+      report.worktree = {
+        path: wtPath,
+        status: "not-attempted",
+        reason: "active-workspace",
+        error: activeGuard.message
+      };
+      noteBranchBlocked("active-workspace");
+      return report;
+    }
     const dirt = await worktreeDirtyAtActTime(wtPath);
     if (dirt !== void 0 && !isRemovableDirt(dirt)) {
       const reason = dirt === "untracked-files" ? "untracked-files" : "dirty-worktree";
@@ -7813,7 +8020,7 @@ async function cleanupPrMergeLocalBranch(branch, options) {
           status: "deferred",
           reason: "lock-held",
           error: outcome.error,
-          deferredNote: DEFERRED_NOTE,
+          deferredNote: deferredNoteFor("lock-held"),
           deferredSweepCommand: DEFERRED_SWEEP_COMMAND,
           ...newlyRegistered ? { safeCleanupCommand: safeWorktreeRemoveCommand(safeCwd, wtPath) } : {},
           stageTeardown
@@ -8027,13 +8234,13 @@ async function gatherStaleWorktreeWarning(gitRun = defaultGitRun) {
 }
 
 // src/released-version-cache.ts
-var import_node_fs10 = require("node:fs");
-var import_node_path9 = require("node:path");
+var import_node_fs11 = require("node:fs");
+var import_node_path10 = require("node:path");
 var RELEASED_VERSION_CACHE_MS = 24 * 36e5;
 function releasedVersionCachePath(runtimeRoot) {
-  return (0, import_node_path9.join)(runtimeRoot, "head-ts", ".released-version");
+  return (0, import_node_path10.join)(runtimeRoot, "head-ts", ".released-version");
 }
-function readReleasedVersionCache(cachePath, now = Date.now(), read = import_node_fs10.readFileSync) {
+function readReleasedVersionCache(cachePath, now = Date.now(), read = import_node_fs11.readFileSync) {
   let parsed;
   try {
     parsed = JSON.parse(read(cachePath, "utf8"));
@@ -8050,8 +8257,8 @@ function readReleasedVersionCache(cachePath, now = Date.now(), read = import_nod
 }
 function writeReleasedVersionCache(cachePath, version, now = Date.now()) {
   try {
-    (0, import_node_fs10.mkdirSync)((0, import_node_path9.dirname)(cachePath), { recursive: true });
-    (0, import_node_fs10.writeFileSync)(cachePath, JSON.stringify({ version, at: now }), "utf8");
+    (0, import_node_fs11.mkdirSync)((0, import_node_path10.dirname)(cachePath), { recursive: true });
+    (0, import_node_fs11.writeFileSync)(cachePath, JSON.stringify({ version, at: now }), "utf8");
   } catch {
   }
 }
@@ -8268,8 +8475,8 @@ function marketplaceRows(name, known, settings, healable = false) {
 }
 
 // src/hook-activity.ts
-var import_node_fs11 = require("node:fs");
-var import_node_path10 = require("node:path");
+var import_node_fs12 = require("node:fs");
+var import_node_path11 = require("node:path");
 var DEFAULT_SURFACE = "claude";
 function activityLogPath(cwd) {
   return repoRuntimeStatePath(cwd, "hooks", "activity.jsonl");
@@ -8282,20 +8489,20 @@ function appendHookActivity(cwd, entry) {
       surface: DEFAULT_SURFACE,
       ...entry
     };
-    (0, import_node_fs11.mkdirSync)((0, import_node_path10.dirname)(path2), { recursive: true });
-    (0, import_node_fs11.appendFileSync)(path2, `${JSON.stringify(line)}
+    (0, import_node_fs12.mkdirSync)((0, import_node_path11.dirname)(path2), { recursive: true });
+    (0, import_node_fs12.appendFileSync)(path2, `${JSON.stringify(line)}
 `, "utf8");
   } catch {
   }
 }
 
 // src/worktree.ts
-var import_node_fs12 = require("node:fs");
-var import_node_path12 = require("node:path");
+var import_node_fs13 = require("node:fs");
+var import_node_path13 = require("node:path");
 
 // src/file-lock.ts
 var import_promises2 = require("node:fs/promises");
-var import_node_path11 = require("node:path");
+var import_node_path12 = require("node:path");
 var sleep = (ms) => new Promise((resolve5) => setTimeout(resolve5, ms));
 var IMMEDIATE_RETRY_BUDGET = 3;
 var FileLockBusyError = class extends Error {
@@ -8380,7 +8587,7 @@ async function releaseFileLock(lockPath, guard) {
 }
 async function withFileLock(lockPath, opts, fn) {
   const resolved = resolveFileLockOpts(opts);
-  await (0, import_promises2.mkdir)((0, import_node_path11.dirname)(lockPath), { recursive: true }).catch(() => void 0);
+  await (0, import_promises2.mkdir)((0, import_node_path12.dirname)(lockPath), { recursive: true }).catch(() => void 0);
   const guard = await acquireFileLock(lockPath, resolved, Date.now() + resolved.maxWaitMs);
   try {
     return await fn();
@@ -8407,35 +8614,35 @@ var PROVISION_ENV_MARKER = "MMI_PROVISION_RUNNING";
 var realFsProbe = {
   isDir: (p) => {
     try {
-      return (0, import_node_fs12.statSync)(p).isDirectory();
+      return (0, import_node_fs13.statSync)(p).isDirectory();
     } catch {
       return false;
     }
   },
   isFile: (p) => {
     try {
-      return (0, import_node_fs12.statSync)(p).isFile();
+      return (0, import_node_fs13.statSync)(p).isFile();
     } catch {
       return false;
     }
   },
   listDirs: (p) => {
     try {
-      return (0, import_node_fs12.readdirSync)(p, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+      return (0, import_node_fs13.readdirSync)(p, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
     } catch {
       return [];
     }
   },
   readFile: (p) => {
     try {
-      return (0, import_node_fs12.readFileSync)(p, "utf8");
+      return (0, import_node_fs13.readFileSync)(p, "utf8");
     } catch {
       return void 0;
     }
   }
 };
 function declaredProvision(fs2, abs) {
-  const raw = fs2.readFile?.((0, import_node_path12.join)(abs, PKG));
+  const raw = fs2.readFile?.((0, import_node_path13.join)(abs, PKG));
   if (raw === void 0) return void 0;
   try {
     const scripts = JSON.parse(raw).scripts;
@@ -8447,13 +8654,13 @@ function declaredProvision(fs2, abs) {
 }
 function scanInstallDirs(root, fs2 = realFsProbe) {
   const factsFor = (dir) => {
-    const abs = dir ? (0, import_node_path12.join)(root, dir) : root;
-    const match = LOCKFILE_INSTALLS.find((c) => fs2.isFile((0, import_node_path12.join)(abs, c.lockfile)));
-    const hasPackageJson = fs2.isFile((0, import_node_path12.join)(abs, PKG));
+    const abs = dir ? (0, import_node_path13.join)(root, dir) : root;
+    const match = LOCKFILE_INSTALLS.find((c) => fs2.isFile((0, import_node_path13.join)(abs, c.lockfile)));
+    const hasPackageJson = fs2.isFile((0, import_node_path13.join)(abs, PKG));
     return {
       dir,
       hasPackageJson,
-      hasNodeModules: fs2.isDir((0, import_node_path12.join)(abs, NODE_MODULES)),
+      hasNodeModules: fs2.isDir((0, import_node_path13.join)(abs, NODE_MODULES)),
       install: match?.command,
       provision: hasPackageJson ? declaredProvision(fs2, abs) : void 0
     };
@@ -8469,7 +8676,7 @@ function npmInstallTargets(dirs) {
   }));
 }
 function isLinkedWorktree(root, fs2 = realFsProbe) {
-  return fs2.isFile((0, import_node_path12.join)(root, ".git"));
+  return fs2.isFile((0, import_node_path13.join)(root, ".git"));
 }
 function worktreeAutoProvisionBanner(root, fs2 = realFsProbe) {
   if (!isLinkedWorktree(root, fs2)) return null;
@@ -8479,8 +8686,8 @@ function worktreeAutoProvisionBanner(root, fs2 = realFsProbe) {
   return `[worktree] provisioning tooling in the background (deps in ${where} + local config) \u2014 \`mmi-cli worktree setup\` to redo`;
 }
 function defaultCopyFile(from, to) {
-  (0, import_node_fs12.mkdirSync)((0, import_node_path12.dirname)(to), { recursive: true });
-  (0, import_node_fs12.copyFileSync)(from, to);
+  (0, import_node_fs13.mkdirSync)((0, import_node_path13.dirname)(to), { recursive: true });
+  (0, import_node_fs13.copyFileSync)(from, to);
 }
 async function runDeclaredProvision(target, cwd, runInstall) {
   const previous = process.env[PROVISION_ENV_MARKER];
@@ -8510,7 +8717,7 @@ async function provisionWorktree(worktreeRoot, deps) {
   const targets = npmInstallTargets(allDirs);
   if (deps.validateInstall) {
     for (const dir of allDirs.filter((d) => d.hasPackageJson && (d.provision ?? d.install) && d.hasNodeModules)) {
-      const cwd = dir.dir ? (0, import_node_path12.join)(worktreeRoot, dir.dir) : worktreeRoot;
+      const cwd = dir.dir ? (0, import_node_path13.join)(worktreeRoot, dir.dir) : worktreeRoot;
       if (!await deps.validateInstall(cwd)) {
         targets.push({
           dir: dir.dir,
@@ -8524,7 +8731,7 @@ async function provisionWorktree(worktreeRoot, deps) {
   const skippedInstall = allDirs.filter((d) => d.hasPackageJson && d.hasNodeModules && !targetDirs.has(d.dir)).map((d) => d.dir);
   const installed = [];
   for (const target of targets) {
-    const cwd = target.dir ? (0, import_node_path12.join)(worktreeRoot, target.dir) : worktreeRoot;
+    const cwd = target.dir ? (0, import_node_path13.join)(worktreeRoot, target.dir) : worktreeRoot;
     log(`installing deps: ${target.command} in ${target.dir || "."}`);
     if (target.declared) await runDeclaredProvision(target, cwd, deps.runInstall);
     else await deps.runInstall(target.command, cwd);
@@ -8534,7 +8741,7 @@ async function provisionWorktree(worktreeRoot, deps) {
   const copySkipped = [];
   const primary = await deps.primaryCheckout();
   for (const rel of LOCAL_ONLY_FILES) {
-    const dest = (0, import_node_path12.join)(worktreeRoot, rel);
+    const dest = (0, import_node_path13.join)(worktreeRoot, rel);
     if (fs2.isFile(dest)) {
       copySkipped.push({ file: rel, reason: "already-present" });
       continue;
@@ -8543,11 +8750,11 @@ async function provisionWorktree(worktreeRoot, deps) {
       copySkipped.push({ file: rel, reason: "no-primary" });
       continue;
     }
-    if (!fs2.isFile((0, import_node_path12.join)(primary, rel))) {
+    if (!fs2.isFile((0, import_node_path13.join)(primary, rel))) {
       copySkipped.push({ file: rel, reason: "absent-in-primary" });
       continue;
     }
-    copyFile((0, import_node_path12.join)(primary, rel), dest);
+    copyFile((0, import_node_path13.join)(primary, rel), dest);
     copied.push(rel);
     log(`copied local config: ${rel}`);
   }
@@ -8561,12 +8768,12 @@ function capWorktreeDirName(name, max = 40) {
 }
 function defaultWorktreePath(repoRoot2, branch) {
   const safe = capWorktreeDirName(branch.replace(/[/\\]+/g, "-"));
-  return (0, import_node_path12.join)((0, import_node_path12.dirname)(repoRoot2), "mmi-worktrees", (0, import_node_path12.basename)(repoRoot2), safe);
+  return (0, import_node_path13.join)((0, import_node_path13.dirname)(repoRoot2), "mmi-worktrees", (0, import_node_path13.basename)(repoRoot2), safe);
 }
 async function primaryCheckoutRootOf(git2) {
   try {
     const out = (await git2(["rev-parse", "--path-format=absolute", "--git-common-dir"])).trim();
-    return out ? (0, import_node_path12.dirname)(out) : void 0;
+    return out ? (0, import_node_path13.dirname)(out) : void 0;
   } catch {
     return void 0;
   }
@@ -8704,7 +8911,7 @@ function commandLadderHint() {
 }
 
 // src/index.ts
-var import_node_path40 = require("node:path");
+var import_node_path41 = require("node:path");
 
 // src/merge-ci-policy.ts
 function resolveMergeCiPolicy(input) {
@@ -9364,13 +9571,13 @@ function planManagedGitignore(current) {
 }
 
 // src/docs-index-command.ts
-var import_node_fs14 = require("node:fs");
-var import_node_path14 = require("node:path");
+var import_node_fs15 = require("node:fs");
+var import_node_path15 = require("node:path");
 
 // src/doc-refs-core.ts
 var import_node_child_process5 = require("node:child_process");
-var import_node_fs13 = require("node:fs");
-var import_node_path13 = require("node:path");
+var import_node_fs14 = require("node:fs");
+var import_node_path14 = require("node:path");
 var PIN_RE = /<!--\s*pinned by\s+([^:]+?)\s*:\s*"([^"]+)"[^"]*-->/;
 var PIN_MENTION_RE = /<!--\s*pinned by\b/;
 var FWD_RE = /<!--\s*forward-ref:\s*(\S+?)\s*-->/;
@@ -9429,7 +9636,7 @@ function checkPins(root, readFile9, docs2) {
         findings.push({ kind: "malformed-pin", doc, line: pin.line, detail: pin.text });
         continue;
       }
-      const source = readFile9((0, import_node_path13.join)(root, pin.file));
+      const source = readFile9((0, import_node_path14.join)(root, pin.file));
       if (source == null) {
         findings.push({ kind: "missing-test", doc, line: pin.line, detail: pin.file });
         continue;
@@ -9491,11 +9698,11 @@ function checkRefs(root, deps, docs2) {
     for (const { ref } of extractRefs(markdown)) allFirstSegments.add(refFirstSegment(ref));
   }
   const tracked = allFirstSegments.size ? deps.trackedFirstSegments?.([...allFirstSegments]) ?? null : null;
-  const firstVerifiable = (first) => tracked ? tracked.has(first) : exists((0, import_node_path13.join)(root, first));
+  const firstVerifiable = (first) => tracked ? tracked.has(first) : exists((0, import_node_path14.join)(root, first));
   const candidates = [];
   const direct = [];
   for (const [doc, markdown] of Object.entries(docs2)) {
-    const docDir = import_node_path13.posix.dirname(doc);
+    const docDir = import_node_path14.posix.dirname(doc);
     const base = docDir === "." ? "" : docDir;
     const covered = /* @__PURE__ */ new Set();
     const markers = [];
@@ -9504,21 +9711,21 @@ function checkRefs(root, deps, docs2) {
         direct.push({ kind: "malformed-forward-ref", doc, line: fwd.line, detail: fwd.text });
         continue;
       }
-      const docRel = import_node_path13.posix.normalize(import_node_path13.posix.join(base, fwd.target));
-      const rootRel = import_node_path13.posix.normalize(fwd.target.replace(/^\/+/, ""));
+      const docRel = import_node_path14.posix.normalize(import_node_path14.posix.join(base, fwd.target));
+      const rootRel = import_node_path14.posix.normalize(fwd.target.replace(/^\/+/, ""));
       markers.push({ target: fwd.target, line: fwd.line, docRel, rootRel });
       covered.add(docRel);
       covered.add(rootRel);
     }
     const links = extractLinks(markdown).map(({ target, line }) => {
-      const resolved = import_node_path13.posix.normalize(import_node_path13.posix.join(base, target));
-      return { target, line, resolved, missing: !exists((0, import_node_path13.join)(root, resolved)) };
+      const resolved = import_node_path14.posix.normalize(import_node_path14.posix.join(base, target));
+      return { target, line, resolved, missing: !exists((0, import_node_path14.join)(root, resolved)) };
     });
     for (const marker of markers) {
       const coversMissing = links.some(
         (l) => l.missing && (l.resolved === marker.docRel || l.resolved === marker.rootRel)
       );
-      if (!coversMissing && (exists((0, import_node_path13.join)(root, marker.docRel)) || exists((0, import_node_path13.join)(root, marker.rootRel)))) {
+      if (!coversMissing && (exists((0, import_node_path14.join)(root, marker.docRel)) || exists((0, import_node_path14.join)(root, marker.rootRel)))) {
         direct.push({
           kind: "stale-forward-ref",
           doc,
@@ -9529,7 +9736,7 @@ function checkRefs(root, deps, docs2) {
     }
     for (const { ref, line } of extractRefs(markdown)) {
       if (!firstVerifiable(refFirstSegment(ref))) continue;
-      if (!exists((0, import_node_path13.join)(root, ref))) candidates.push({ kind: "missing-path", doc, line, detail: ref });
+      if (!exists((0, import_node_path14.join)(root, ref))) candidates.push({ kind: "missing-path", doc, line, detail: ref });
     }
     for (const { target, line, resolved, missing } of links) {
       if (resolved.startsWith("..")) {
@@ -9577,22 +9784,22 @@ function checkCommands(docs2, commandPaths) {
   return { ok: findings.length === 0, findings, warnings: [] };
 }
 function readFileOrNull(path2) {
-  return (0, import_node_fs13.existsSync)(path2) ? (0, import_node_fs13.readFileSync)(path2, "utf8") : null;
+  return (0, import_node_fs14.existsSync)(path2) ? (0, import_node_fs14.readFileSync)(path2, "utf8") : null;
 }
 function walk(dir, root, out) {
-  for (const entry of (0, import_node_fs13.readdirSync)(dir)) {
-    const full = (0, import_node_path13.join)(dir, entry);
-    if ((0, import_node_fs13.statSync)(full).isDirectory()) walk(full, root, out);
+  for (const entry of (0, import_node_fs14.readdirSync)(dir)) {
+    const full = (0, import_node_path14.join)(dir, entry);
+    if ((0, import_node_fs14.statSync)(full).isDirectory()) walk(full, root, out);
     else if (entry.endsWith(".md")) out.push(full.slice(root.length + 1).replaceAll("\\", "/"));
   }
   return out;
 }
 function defaultListDocs(root) {
-  const docsDir = (0, import_node_path13.join)(root, "docs");
-  const docs2 = ((0, import_node_fs13.existsSync)(docsDir) ? walk(docsDir, root, []) : []).filter(
+  const docsDir = (0, import_node_path14.join)(root, "docs");
+  const docs2 = ((0, import_node_fs14.existsSync)(docsDir) ? walk(docsDir, root, []) : []).filter(
     (rel) => !SKIP_WALK.some((skip) => rel.startsWith(skip))
   );
-  return [...ROOT_DOCS.filter((rel) => (0, import_node_fs13.existsSync)((0, import_node_path13.join)(root, rel))), ...docs2];
+  return [...ROOT_DOCS.filter((rel) => (0, import_node_fs14.existsSync)((0, import_node_path14.join)(root, rel))), ...docs2];
 }
 var CHECK_IGNORE_MAX_BUFFER = 32 * 1024 * 1024;
 function defaultIsIgnored(root, relPaths, exec = import_node_child_process5.execFileSync) {
@@ -9644,7 +9851,7 @@ function defaultTrackedFirstSegments(root, firstSegments, exec = import_node_chi
 }
 function runDocRefs(root, deps = {}) {
   const readFile9 = deps.readFile ?? readFileOrNull;
-  const exists = deps.exists ?? import_node_fs13.existsSync;
+  const exists = deps.exists ?? import_node_fs14.existsSync;
   const listDocs = deps.listDocs ?? defaultListDocs;
   const isIgnored = deps.isIgnored ?? ((paths) => defaultIsIgnored(root, paths));
   const trackedFirstSegments = deps.trackedFirstSegments ?? ((segs) => defaultTrackedFirstSegments(root, segs));
@@ -9652,7 +9859,7 @@ function runDocRefs(root, deps = {}) {
   const walked = listDocs(root);
   const ignoredDocs = walked.length ? isIgnored(walked) : /* @__PURE__ */ new Set();
   const docs2 = Object.fromEntries(
-    walked.filter((rel) => !ignoredDocs.has(rel)).map((rel) => [rel, readFile9((0, import_node_path13.join)(root, rel))]).filter(([, body]) => body != null)
+    walked.filter((rel) => !ignoredDocs.has(rel)).map((rel) => [rel, readFile9((0, import_node_path14.join)(root, rel))]).filter(([, body]) => body != null)
   );
   const refResult = checkRefs(root, { exists, isIgnored, trackedFirstSegments }, docs2);
   const findings = [
@@ -9759,31 +9966,31 @@ function walkMarkdown(dir) {
   const stack = [dir];
   while (stack.length) {
     const current = stack.pop();
-    for (const entry of (0, import_node_fs14.readdirSync)(current, { withFileTypes: true })) {
-      const full = (0, import_node_path14.join)(current, entry.name);
+    for (const entry of (0, import_node_fs15.readdirSync)(current, { withFileTypes: true })) {
+      const full = (0, import_node_path15.join)(current, entry.name);
       if (entry.isDirectory()) {
         stack.push(full);
       } else if (entry.isFile() && entry.name.endsWith(".md")) {
-        out.push((0, import_node_path14.relative)(dir, full).split(import_node_path14.sep).join("/"));
+        out.push((0, import_node_path15.relative)(dir, full).split(import_node_path15.sep).join("/"));
       }
     }
   }
   return out;
 }
 function createDocsIndexDeps(repoRoot2) {
-  const docsDir = (0, import_node_path14.join)(repoRoot2, "docs");
-  const indexPath = (0, import_node_path14.join)(repoRoot2, DOCS_INDEX_PATH);
+  const docsDir = (0, import_node_path15.join)(repoRoot2, "docs");
+  const indexPath = (0, import_node_path15.join)(repoRoot2, DOCS_INDEX_PATH);
   return {
     listDocs: () => {
-      if (!(0, import_node_fs14.existsSync)(docsDir)) return [];
+      if (!(0, import_node_fs15.existsSync)(docsDir)) return [];
       const walked = walkMarkdown(docsDir).filter(isRoutableDocsPath);
       if (!walked.length) return [];
       const ignored = defaultIsIgnored(repoRoot2, walked.map((rel) => `docs/${rel}`));
       return walked.filter((rel) => !ignored.has(`docs/${rel}`)).sort();
     },
-    readDoc: (relPath) => (0, import_node_fs14.readFileSync)((0, import_node_path14.join)(docsDir, relPath), "utf8"),
-    readIndex: () => (0, import_node_fs14.existsSync)(indexPath) ? (0, import_node_fs14.readFileSync)(indexPath, "utf8") : null,
-    writeIndex: (content) => (0, import_node_fs14.writeFileSync)(indexPath, content, "utf8")
+    readDoc: (relPath) => (0, import_node_fs15.readFileSync)((0, import_node_path15.join)(docsDir, relPath), "utf8"),
+    readIndex: () => (0, import_node_fs15.existsSync)(indexPath) ? (0, import_node_fs15.readFileSync)(indexPath, "utf8") : null,
+    writeIndex: (content) => (0, import_node_fs15.writeFileSync)(indexPath, content, "utf8")
   };
 }
 
@@ -10430,15 +10637,15 @@ function parseVerifyBroker(stdout) {
 }
 
 // src/train-apply.ts
-var import_node_fs16 = require("node:fs");
+var import_node_fs17 = require("node:fs");
 var import_promises3 = require("node:fs/promises");
-var import_node_path16 = require("node:path");
+var import_node_path17 = require("node:path");
 
 // src/plugin-guard-io.ts
-var import_node_fs15 = require("node:fs");
+var import_node_fs16 = require("node:fs");
 var import_node_child_process6 = require("node:child_process");
-var import_node_path15 = require("node:path");
-var import_node_os4 = require("node:os");
+var import_node_path16 = require("node:path");
+var import_node_os5 = require("node:os");
 var import_proper_lockfile = __toESM(require_proper_lockfile(), 1);
 
 // src/version-lag.ts
@@ -10727,20 +10934,20 @@ function runHostBin(bin, args, opts) {
   const argv = isWin ? ["/c", bin, ...args] : args;
   return step ? execFileHard(file, argv, { ...shared, step }) : execFileP2(file, argv, shared);
 }
-function surfaceConfigRoot(surface, env = process.env, home = (0, import_node_os4.homedir)()) {
-  if (surface === "codex") return env.CODEX_HOME?.trim() || (0, import_node_path15.join)(home, ".codex");
-  if (surface === "kimi") return env.KIMI_CODE_HOME?.trim() || (0, import_node_path15.join)(home, ".kimi-code");
-  if (surface === "kilo") return env.KILO_CONFIG_DIR?.trim() || (0, import_node_path15.join)(home, ".config", "kilo");
-  if (surface === "cursor") return (0, import_node_path15.join)(home, ".cursor");
-  if (surface === "jervcode") return env.PI_CODING_AGENT_DIR?.trim() || (0, import_node_path15.join)(home, ".pi", "agent");
-  return (0, import_node_path15.join)(home, ".claude");
+function surfaceConfigRoot(surface, env = process.env, home = (0, import_node_os5.homedir)()) {
+  if (surface === "codex") return env.CODEX_HOME?.trim() || (0, import_node_path16.join)(home, ".codex");
+  if (surface === "kimi") return env.KIMI_CODE_HOME?.trim() || (0, import_node_path16.join)(home, ".kimi-code");
+  if (surface === "kilo") return env.KILO_CONFIG_DIR?.trim() || (0, import_node_path16.join)(home, ".config", "kilo");
+  if (surface === "cursor") return (0, import_node_path16.join)(home, ".cursor");
+  if (surface === "jervcode") return env.PI_CODING_AGENT_DIR?.trim() || (0, import_node_path16.join)(home, ".pi", "agent");
+  return (0, import_node_path16.join)(home, ".claude");
 }
 var installedPluginsPath = (surface = detectSurface(process.env)) => {
-  return (0, import_node_path15.join)(surfaceConfigRoot(surface), "plugins", "installed_plugins.json");
+  return (0, import_node_path16.join)(surfaceConfigRoot(surface), "plugins", "installed_plugins.json");
 };
 function readInstalledPlugins(surface = detectSurface(process.env)) {
   try {
-    return JSON.parse((0, import_node_fs15.readFileSync)(installedPluginsPath(surface), "utf8"));
+    return JSON.parse((0, import_node_fs16.readFileSync)(installedPluginsPath(surface), "utf8"));
   } catch {
     return null;
   }
@@ -10749,17 +10956,17 @@ function marketplaceCloneCandidates(surface, home, env = process.env) {
   if (surface === "codex") {
     const root = surfaceConfigRoot(surface, env, home);
     return [
-      (0, import_node_path15.join)(root, ".tmp", "marketplaces", CODEX_MARKETPLACE),
-      (0, import_node_path15.join)(root, "plugins", "marketplaces", CODEX_MARKETPLACE)
+      (0, import_node_path16.join)(root, ".tmp", "marketplaces", CODEX_MARKETPLACE),
+      (0, import_node_path16.join)(root, "plugins", "marketplaces", CODEX_MARKETPLACE)
     ];
   }
   if (surface === "kimi") return [];
   if (surface === "kilo") return [];
   if (surface === "cursor") return [];
   if (surface === "jervcode") return [];
-  return [(0, import_node_path15.join)(home, ".claude", "plugins", "marketplaces", "mutmutco")];
+  return [(0, import_node_path16.join)(home, ".claude", "plugins", "marketplaces", "mutmutco")];
 }
-function marketplaceClonePresent(surface, home, exists = import_node_fs15.existsSync, env = process.env) {
+function marketplaceClonePresent(surface, home, exists = import_node_fs16.existsSync, env = process.env) {
   return marketplaceCloneCandidates(surface, home, env).some(exists);
 }
 function runHostBinSync(bin, args) {
@@ -10791,7 +10998,7 @@ function codexPluginStatus() {
 }
 function countCodexHookCommands(path2) {
   try {
-    const parsed = JSON.parse((0, import_node_fs15.readFileSync)(path2, "utf8"));
+    const parsed = JSON.parse((0, import_node_fs16.readFileSync)(path2, "utf8"));
     let count = 0;
     for (const groups of Object.values(parsed.hooks ?? {})) {
       for (const group of groups) {
@@ -10808,11 +11015,11 @@ function codexHookTrustState(status = codexPluginStatus()) {
     return { applicable: false, trusted: false, trustedCount: 0, requiredCount: 0 };
   }
   const root = surfaceConfigRoot("codex");
-  const hooksPath = (0, import_node_path15.join)(root, "plugins", "cache", CODEX_MARKETPLACE, "mmi", status.version, "hooks", "codex-hooks.json");
+  const hooksPath = (0, import_node_path16.join)(root, "plugins", "cache", CODEX_MARKETPLACE, "mmi", status.version, "hooks", "codex-hooks.json");
   const requiredCount = countCodexHookCommands(hooksPath);
   let config = "";
   try {
-    config = (0, import_node_fs15.readFileSync)((0, import_node_path15.join)(root, "config.toml"), "utf8");
+    config = (0, import_node_fs16.readFileSync)((0, import_node_path16.join)(root, "config.toml"), "utf8");
   } catch {
     return { applicable: true, trusted: false, trustedCount: 0, requiredCount };
   }
@@ -10846,11 +11053,11 @@ async function npmSelfUpdateCli(target, onStep) {
     return { ok: false, detail: e.message.trim().slice(0, 200).replace(/\s+/g, " ") };
   }
 }
-function kiloConfigListsPlugin(configRoot, home = (0, import_node_os4.homedir)(), read = (p) => (0, import_node_fs15.readFileSync)(p, "utf8"), exists = import_node_fs15.existsSync) {
+function kiloConfigListsPlugin(configRoot, home = (0, import_node_os5.homedir)(), read = (p) => (0, import_node_fs16.readFileSync)(p, "utf8"), exists = import_node_fs16.existsSync) {
   const candidates = ["kilo.json", "kilo.jsonc", "opencode.json", "opencode.jsonc", "config.json"];
-  for (const dir of [configRoot, (0, import_node_path15.join)(home, ".kilo")]) {
+  for (const dir of [configRoot, (0, import_node_path16.join)(home, ".kilo")]) {
     for (const file of candidates) {
-      const path2 = (0, import_node_path15.join)(dir, file);
+      const path2 = (0, import_node_path16.join)(dir, file);
       if (!exists(path2)) continue;
       try {
         const stripped = read(path2).replace(/\/\*[\s\S]*?\*\//g, "").replace(/\/\/.*$/gm, "");
@@ -10866,24 +11073,24 @@ function kiloConfigListsPlugin(configRoot, home = (0, import_node_os4.homedir)()
   }
   return false;
 }
-function cursorLocalPluginRoot(env = process.env, home = (0, import_node_os4.homedir)()) {
-  return (0, import_node_path15.join)(surfaceConfigRoot("cursor", env, home), "plugins", "local", "mmi");
+function cursorLocalPluginRoot(env = process.env, home = (0, import_node_os5.homedir)()) {
+  return (0, import_node_path16.join)(surfaceConfigRoot("cursor", env, home), "plugins", "local", "mmi");
 }
-function cursorPluginTreeHealthy(root, exists = import_node_fs15.existsSync) {
+function cursorPluginTreeHealthy(root, exists = import_node_fs16.existsSync) {
   return [
     ".cursor-plugin/plugin.json",
     "skills/mmi/SKILL.md",
     "hooks/cursor-hooks.json",
     "scripts/hook-run.mjs",
     "scripts/hook-policy.mjs"
-  ].every((path2) => exists((0, import_node_path15.join)(root, ...path2.split("/"))));
+  ].every((path2) => exists((0, import_node_path16.join)(root, ...path2.split("/"))));
 }
-function kimiPluginTreeHealthy(root, exists = import_node_fs15.existsSync) {
+function kimiPluginTreeHealthy(root, exists = import_node_fs16.existsSync) {
   return [
     ".kimi-plugin/plugin.json",
     "skills/mmi/SKILL.md",
     "scripts/hook-run.mjs"
-  ].every((path2) => exists((0, import_node_path15.join)(root, ...path2.split("/"))));
+  ].every((path2) => exists((0, import_node_path16.join)(root, ...path2.split("/"))));
 }
 var JERVCODE_WRAPPER_DIR = ".pi-plugin";
 function normalizePiEntry(value) {
@@ -10906,7 +11113,7 @@ function jervcodePackageFamily(entry) {
 function isMmiOwnedPiEntry(entry) {
   if (typeof entry !== "string") return false;
   try {
-    const pkg = JSON.parse((0, import_node_fs15.readFileSync)((0, import_node_path15.join)(piEntryFsPath(entry), "package.json"), "utf8"));
+    const pkg = JSON.parse((0, import_node_fs16.readFileSync)((0, import_node_path16.join)(piEntryFsPath(entry), "package.json"), "utf8"));
     return pkg.name === "mmi";
   } catch {
     return false;
@@ -10928,17 +11135,17 @@ function mergeMmiPiPackageEntries(entries, packagePath) {
   };
 }
 function readPiSettings(path2) {
-  if (!(0, import_node_fs15.existsSync)(path2)) return void 0;
+  if (!(0, import_node_fs16.existsSync)(path2)) return void 0;
   try {
-    const parsed = JSON.parse((0, import_node_fs15.readFileSync)(path2, "utf8"));
+    const parsed = JSON.parse((0, import_node_fs16.readFileSync)(path2, "utf8"));
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
     return parsed;
   } catch {
     return null;
   }
 }
-function mmiPiWrapperEntry(env = process.env, home = (0, import_node_os4.homedir)()) {
-  const settings = readPiSettings((0, import_node_path15.join)(surfaceConfigRoot("jervcode", env, home), "settings.json"));
+function mmiPiWrapperEntry(env = process.env, home = (0, import_node_os5.homedir)()) {
+  const settings = readPiSettings((0, import_node_path16.join)(surfaceConfigRoot("jervcode", env, home), "settings.json"));
   const entries = Array.isArray(settings?.packages) ? settings.packages : [];
   for (const entry of entries) {
     if (typeof entry !== "string") continue;
@@ -10951,17 +11158,17 @@ function mmiPiWrapperEntry(env = process.env, home = (0, import_node_os4.homedir
 function mmiPiWrapperHealthy(entry) {
   if (!entry) return false;
   const wrapper = piEntryFsPath(entry);
-  return isMmiOwnedPiEntry(entry) && (0, import_node_fs15.existsSync)((0, import_node_path15.join)((0, import_node_path15.dirname)(wrapper), "skills", "mmi", "SKILL.md"));
+  return isMmiOwnedPiEntry(entry) && (0, import_node_fs16.existsSync)((0, import_node_path16.join)((0, import_node_path16.dirname)(wrapper), "skills", "mmi", "SKILL.md"));
 }
-function findMmiPiSourceClone(home = (0, import_node_os4.homedir)()) {
-  const cacheRoot = (0, import_node_path15.join)(home, ".claude", "plugins", "cache", "mutmutco", "mmi");
+function findMmiPiSourceClone(home = (0, import_node_os5.homedir)()) {
+  const cacheRoot = (0, import_node_path16.join)(home, ".claude", "plugins", "cache", "mutmutco", "mmi");
   let best = null;
   try {
-    for (const entry of (0, import_node_fs15.readdirSync)(cacheRoot, { withFileTypes: true })) {
+    for (const entry of (0, import_node_fs16.readdirSync)(cacheRoot, { withFileTypes: true })) {
       if (!entry.isDirectory() || !/^\d+\.\d+\.\d+$/.test(entry.name)) continue;
-      if (!(0, import_node_fs15.existsSync)((0, import_node_path15.join)(cacheRoot, entry.name, JERVCODE_WRAPPER_DIR, "package.json"))) continue;
+      if (!(0, import_node_fs16.existsSync)((0, import_node_path16.join)(cacheRoot, entry.name, JERVCODE_WRAPPER_DIR, "package.json"))) continue;
       if (!best || compareVersions(entry.name, best.version) > 0) {
-        best = { path: (0, import_node_path15.join)(cacheRoot, entry.name), version: entry.name };
+        best = { path: (0, import_node_path16.join)(cacheRoot, entry.name), version: entry.name };
       }
     }
   } catch {
@@ -10989,9 +11196,9 @@ function healJervCodePackageRegistration(opts = {}) {
   const env = opts.env ?? process.env;
   const inSeat = !!env.PI_SESSION_ID?.trim();
   const nextLaunch = inSeat ? " \u2014 takes effect on the next seat launch" : "";
-  const home = opts.home ?? (0, import_node_os4.homedir)();
+  const home = opts.home ?? (0, import_node_os5.homedir)();
   const agentDir = surfaceConfigRoot("jervcode", env, home);
-  if (!(0, import_node_fs15.existsSync)(agentDir)) {
+  if (!(0, import_node_fs16.existsSync)(agentDir)) {
     return { available: false, ok: true, changed: false, version: null, detail: "skipped \u2014 no Pi/JervCode install (no agent config dir)" };
   }
   const clone = opts.clone === void 0 ? findMmiPiSourceClone(home) : opts.clone;
@@ -10999,9 +11206,9 @@ function healJervCodePackageRegistration(opts = {}) {
     return { available: true, ok: true, changed: false, version: null, detail: "skipped \u2014 no installed MMI clone carries the pi wrapper (install the Claude plugin first)" };
   }
   const packagePath = `${clone.path.replace(/\\/g, "/").replace(/\/+$/, "")}/${JERVCODE_WRAPPER_DIR}`;
-  const settingsPath2 = (0, import_node_path15.join)(agentDir, "settings.json");
-  const release = (0, import_node_fs15.existsSync)(settingsPath2) ? acquirePiSettingsLock(settingsPath2) : void 0;
-  if ((0, import_node_fs15.existsSync)(settingsPath2) && !release) {
+  const settingsPath2 = (0, import_node_path16.join)(agentDir, "settings.json");
+  const release = (0, import_node_fs16.existsSync)(settingsPath2) ? acquirePiSettingsLock(settingsPath2) : void 0;
+  if ((0, import_node_fs16.existsSync)(settingsPath2) && !release) {
     return {
       available: true,
       ok: false,
@@ -11029,14 +11236,14 @@ function healJervCodePackageRegistration(opts = {}) {
     }
     current.packages = merged.next;
     try {
-      (0, import_node_fs15.mkdirSync)((0, import_node_path15.dirname)(settingsPath2), { recursive: true });
+      (0, import_node_fs16.mkdirSync)((0, import_node_path16.dirname)(settingsPath2), { recursive: true });
       const tmp = `${settingsPath2}.tmp-${process.pid}`;
-      (0, import_node_fs15.writeFileSync)(tmp, `${JSON.stringify(current, null, 2)}
+      (0, import_node_fs16.writeFileSync)(tmp, `${JSON.stringify(current, null, 2)}
 `, "utf8");
       try {
-        (0, import_node_fs15.renameSync)(tmp, settingsPath2);
+        (0, import_node_fs16.renameSync)(tmp, settingsPath2);
       } catch (renameError) {
-        (0, import_node_fs15.rmSync)(tmp, { force: true });
+        (0, import_node_fs16.rmSync)(tmp, { force: true });
         throw renameError;
       }
     } catch (error) {
@@ -11062,18 +11269,18 @@ function snapshotPluginGuardInput(surface = detectSurface(process.env), isOrgRep
   return {
     isOrgRepo,
     installRecordPresent: hasUserInstallRecord(installed, MMI_PLUGIN_ID) || hasProjectInstallRecord(installed, MMI_PLUGIN_ID, process.cwd()) || // Kimi's managed plugin directory is its native install record; it has no Claude-style ledger.
-    surface === "kimi" && (0, import_node_fs15.existsSync)((0, import_node_path15.join)(root, "plugins", "managed", "mmi")) || // kilo-p1: the install record is the config file itself.
+    surface === "kimi" && (0, import_node_fs16.existsSync)((0, import_node_path16.join)(root, "plugins", "managed", "mmi")) || // kilo-p1: the install record is the config file itself.
     surface === "kilo" && kiloConfigListsPlugin(root) || // #4188: jervcode's install record is the settings-file packages[] entry itself.
-    surface === "jervcode" && piEntry !== null || surface === "cursor" && (0, import_node_fs15.existsSync)(cursorLocalPluginRoot()),
+    surface === "jervcode" && piEntry !== null || surface === "cursor" && (0, import_node_fs16.existsSync)(cursorLocalPluginRoot()),
     // Kilo has no marketplace to clone — the config file IS the install record, so this dimension of
     // the shared guard table is vacuously satisfied. Same for jervcode's settings entry.
-    marketplaceClonePresent: surface === "kimi" || surface === "kilo" || surface === "cursor" || surface === "jervcode" ? true : marketplaceClonePresent(surface, (0, import_node_os4.homedir)()),
+    marketplaceClonePresent: surface === "kimi" || surface === "kilo" || surface === "cursor" || surface === "jervcode" ? true : marketplaceClonePresent(surface, (0, import_node_os5.homedir)()),
     // Kimi keeps no plugin cache dir — installs are copied to plugins/managed/<id> and run from there.
     // Kilo (kilo-p1) keeps no cache dir either: the plugin's server() provisions ~/.kilo behind the
     // version stamp, so the stamp's presence is the cache signal.
-    pluginCachePresent: surface === "jervcode" ? mmiPiWrapperHealthy(piEntry) : surface === "kilo" ? (0, import_node_fs15.existsSync)((0, import_node_path15.join)((0, import_node_os4.homedir)(), ".kilo", ".mmi-kilo-version")) : surface === "kimi" ? kimiPluginTreeHealthy((0, import_node_path15.join)(root, "plugins", "managed", "mmi")) : surface === "cursor" ? cursorPluginTreeHealthy(cursorLocalPluginRoot()) : surface === "codex" ? Boolean(
-      codexStatus?.installed && codexStatus.enabled && codexStatus.version && (0, import_node_fs15.existsSync)((0, import_node_path15.join)(root, "plugins", "cache", CODEX_MARKETPLACE, "mmi", codexStatus.version))
-    ) : (0, import_node_fs15.existsSync)((0, import_node_path15.join)(root, "plugins", "cache", "mutmutco", "mmi"))
+    pluginCachePresent: surface === "jervcode" ? mmiPiWrapperHealthy(piEntry) : surface === "kilo" ? (0, import_node_fs16.existsSync)((0, import_node_path16.join)((0, import_node_os5.homedir)(), ".kilo", ".mmi-kilo-version")) : surface === "kimi" ? kimiPluginTreeHealthy((0, import_node_path16.join)(root, "plugins", "managed", "mmi")) : surface === "cursor" ? cursorPluginTreeHealthy(cursorLocalPluginRoot()) : surface === "codex" ? Boolean(
+      codexStatus?.installed && codexStatus.enabled && codexStatus.version && (0, import_node_fs16.existsSync)((0, import_node_path16.join)(root, "plugins", "cache", CODEX_MARKETPLACE, "mmi", codexStatus.version))
+    ) : (0, import_node_fs16.existsSync)((0, import_node_path16.join)(root, "plugins", "cache", "mutmutco", "mmi"))
   };
 }
 async function runHostBinLogged(bin, args, opts) {
@@ -11093,11 +11300,11 @@ async function runPluginCli(bin, args, log) {
 function captureCodexHookLauncher() {
   const status = codexPluginStatus();
   if (!status.installed || !status.enabled || !status.version) return void 0;
-  const root = (0, import_node_path15.join)(surfaceConfigRoot("codex"), "plugins", "cache", CODEX_MARKETPLACE, "mmi", status.version);
+  const root = (0, import_node_path16.join)(surfaceConfigRoot("codex"), "plugins", "cache", CODEX_MARKETPLACE, "mmi", status.version);
   const files = ["mmi-hook", "mmi-hook.exe"].flatMap((name) => {
-    const path2 = (0, import_node_path15.join)(root, "bin", name);
+    const path2 = (0, import_node_path16.join)(root, "bin", name);
     try {
-      return [{ name, content: (0, import_node_fs15.readFileSync)(path2) }];
+      return [{ name, content: (0, import_node_fs16.readFileSync)(path2) }];
     } catch {
       return [];
     }
@@ -11105,13 +11312,13 @@ function captureCodexHookLauncher() {
   return files.length === 2 ? { root, files } : void 0;
 }
 function restoreCodexHookLauncher(snapshot) {
-  if (!snapshot || (0, import_node_fs15.existsSync)((0, import_node_path15.join)(snapshot.root, "scripts", "hook-run.mjs"))) return false;
-  const bin = (0, import_node_path15.join)(snapshot.root, "bin");
-  (0, import_node_fs15.mkdirSync)(bin, { recursive: true });
+  if (!snapshot || (0, import_node_fs16.existsSync)((0, import_node_path16.join)(snapshot.root, "scripts", "hook-run.mjs"))) return false;
+  const bin = (0, import_node_path16.join)(snapshot.root, "bin");
+  (0, import_node_fs16.mkdirSync)(bin, { recursive: true });
   for (const file of snapshot.files) {
-    const path2 = (0, import_node_path15.join)(bin, file.name);
-    (0, import_node_fs15.writeFileSync)(path2, file.content);
-    if (file.name === "mmi-hook") (0, import_node_fs15.chmodSync)(path2, 493);
+    const path2 = (0, import_node_path16.join)(bin, file.name);
+    (0, import_node_fs16.writeFileSync)(path2, file.content);
+    if (file.name === "mmi-hook") (0, import_node_fs16.chmodSync)(path2, 493);
   }
   return true;
 }
@@ -11120,10 +11327,10 @@ function canonicalCursorRemote(remote) {
 }
 async function installCursorPluginCheckout(env = process.env) {
   const configRoot = surfaceConfigRoot("cursor", env);
-  const pluginsRoot = (0, import_node_path15.join)(configRoot, "plugins");
-  const target = (0, import_node_path15.join)(pluginsRoot, "local", "mmi");
+  const pluginsRoot = (0, import_node_path16.join)(configRoot, "plugins");
+  const target = (0, import_node_path16.join)(pluginsRoot, "local", "mmi");
   const source = env.MMI_CURSOR_PLUGIN_SOURCE?.trim();
-  if ((0, import_node_fs15.existsSync)(target) && !source) {
+  if ((0, import_node_fs16.existsSync)(target) && !source) {
     try {
       const { stdout } = await runHostBin("git", ["-C", target, "remote", "get-url", "origin"], { timeout: 15e3 });
       if (!canonicalCursorRemote(stdout)) {
@@ -11133,15 +11340,15 @@ async function installCursorPluginCheckout(env = process.env) {
       return { ok: false, detail: `refused to replace unmanaged Cursor plugin directory at ${target}` };
     }
   }
-  (0, import_node_fs15.mkdirSync)((0, import_node_path15.join)(pluginsRoot, "local"), { recursive: true });
-  (0, import_node_fs15.mkdirSync)((0, import_node_path15.join)(pluginsRoot, "staging"), { recursive: true });
-  (0, import_node_fs15.mkdirSync)((0, import_node_path15.join)(pluginsRoot, "quarantine"), { recursive: true });
+  (0, import_node_fs16.mkdirSync)((0, import_node_path16.join)(pluginsRoot, "local"), { recursive: true });
+  (0, import_node_fs16.mkdirSync)((0, import_node_path16.join)(pluginsRoot, "staging"), { recursive: true });
+  (0, import_node_fs16.mkdirSync)((0, import_node_path16.join)(pluginsRoot, "quarantine"), { recursive: true });
   const suffix = `${Date.now()}-${process.pid}`;
-  const staged = (0, import_node_path15.join)(pluginsRoot, "staging", `mmi-${suffix}`);
-  const quarantined = (0, import_node_path15.join)(pluginsRoot, "quarantine", `mmi-${suffix}`);
+  const staged = (0, import_node_path16.join)(pluginsRoot, "staging", `mmi-${suffix}`);
+  const quarantined = (0, import_node_path16.join)(pluginsRoot, "quarantine", `mmi-${suffix}`);
   try {
     if (source) {
-      (0, import_node_fs15.cpSync)(source, staged, {
+      (0, import_node_fs16.cpSync)(source, staged, {
         recursive: true,
         filter: (path2) => !path2.split(/[\\/]/).some((part) => part === ".git" || part === "node_modules")
       });
@@ -11152,18 +11359,18 @@ async function installCursorPluginCheckout(env = process.env) {
       });
     }
     if (!cursorPluginTreeHealthy(staged)) {
-      (0, import_node_fs15.rmSync)(staged, { recursive: true, force: true });
+      (0, import_node_fs16.rmSync)(staged, { recursive: true, force: true });
       return { ok: false, detail: "downloaded Cursor plugin is incomplete; existing install was preserved" };
     }
     let movedOld = false;
-    if ((0, import_node_fs15.existsSync)(target)) {
-      (0, import_node_fs15.renameSync)(target, quarantined);
+    if ((0, import_node_fs16.existsSync)(target)) {
+      (0, import_node_fs16.renameSync)(target, quarantined);
       movedOld = true;
     }
     try {
-      (0, import_node_fs15.renameSync)(staged, target);
+      (0, import_node_fs16.renameSync)(staged, target);
     } catch (error) {
-      if (movedOld && !(0, import_node_fs15.existsSync)(target)) (0, import_node_fs15.renameSync)(quarantined, target);
+      if (movedOld && !(0, import_node_fs16.existsSync)(target)) (0, import_node_fs16.renameSync)(quarantined, target);
       throw error;
     }
     return {
@@ -11171,7 +11378,7 @@ async function installCursorPluginCheckout(env = process.env) {
       detail: movedOld ? `installed canonical Cursor plugin; previous checkout quarantined at ${quarantined}` : `installed canonical Cursor plugin at ${target}`
     };
   } catch (error) {
-    if ((0, import_node_fs15.existsSync)(staged)) (0, import_node_fs15.rmSync)(staged, { recursive: true, force: true });
+    if ((0, import_node_fs16.existsSync)(staged)) (0, import_node_fs16.rmSync)(staged, { recursive: true, force: true });
     return { ok: false, detail: error.message.trim().slice(0, 240).replace(/\s+/g, " ") };
   }
 }
@@ -11221,7 +11428,7 @@ async function applyPluginHeal(surface, log, opts) {
   const refSupported = await marketplaceAddRefSupported(bin);
   const { steps } = adaptHealStepsForRefSupport(tableSteps, refSupported);
   log(healBannerLine(bin, token, refSupported));
-  const pinsPath = (0, import_node_path15.join)((0, import_node_os4.homedir)(), ...KNOWN_MARKETPLACES_RELATIVE);
+  const pinsPath = (0, import_node_path16.join)((0, import_node_os5.homedir)(), ...KNOWN_MARKETPLACES_RELATIVE);
   const pins = token === "claude" ? captureMarketplacePins(readKnownMarketplacesFile(pinsPath), [MMI_MARKETPLACE_NAME, JERV_MARKETPLACE_NAME]) : /* @__PURE__ */ new Map();
   try {
     for (const step of steps) {
@@ -11296,7 +11503,7 @@ async function healActivePluginForDoctor(surface = detectSurface(process.env), o
 }
 function readKnownMarketplacesFile(path2) {
   try {
-    return (0, import_node_fs15.existsSync)(path2) ? (0, import_node_fs15.readFileSync)(path2, "utf8") : void 0;
+    return (0, import_node_fs16.existsSync)(path2) ? (0, import_node_fs16.readFileSync)(path2, "utf8") : void 0;
   } catch {
     return void 0;
   }
@@ -11323,7 +11530,7 @@ function writeMarketplacePinsOnDisk(path2, pins, succeeded, failedVerb, declineW
   const declined = declineWhileHostLive?.();
   if (declined) return declined;
   try {
-    (0, import_node_fs15.writeFileSync)(path2, next, "utf8");
+    (0, import_node_fs16.writeFileSync)(path2, next, "utf8");
   } catch {
     return `could NOT ${failedVerb} ${[...pins.keys()].join(", ")} \u2014 set it by hand`;
   }
@@ -11358,15 +11565,15 @@ function applyOrgMarketplacePins(path2, names, hostIsRunning = claudeCodeIsRunni
 }
 function writeMarketplacePinPending(path2, names, now = Date.now()) {
   try {
-    (0, import_node_fs15.mkdirSync)((0, import_node_path15.dirname)(path2), { recursive: true });
-    (0, import_node_fs15.writeFileSync)(path2, `${JSON.stringify({ v: 1, names: [...names], at: new Date(now).toISOString() })}
+    (0, import_node_fs16.mkdirSync)((0, import_node_path16.dirname)(path2), { recursive: true });
+    (0, import_node_fs16.writeFileSync)(path2, `${JSON.stringify({ v: 1, names: [...names], at: new Date(now).toISOString() })}
 `, "utf8");
   } catch {
   }
 }
 function readMarketplacePinPending(path2, name, now = Date.now()) {
   try {
-    const parsed = JSON.parse((0, import_node_fs15.readFileSync)(path2, "utf8"));
+    const parsed = JSON.parse((0, import_node_fs16.readFileSync)(path2, "utf8"));
     const at = typeof parsed.at === "string" ? Date.parse(parsed.at) : Number.NaN;
     if (parsed.v !== 1 || !Array.isArray(parsed.names) || !parsed.names.includes(name) || !Number.isFinite(at)) return void 0;
     if (now - at < 0 || now - at > 12 * 60 * 6e4) return void 0;
@@ -12498,17 +12705,17 @@ async function dispatchDeploy(deps, ctx, stage, ref, model, watch, autoRunSince,
   return { note: `no manual dispatch: ${model} repo deploys via its own push-triggered workflow`, deployStatus: "pending" };
 }
 function readLocalGateWorkflows() {
-  const dir = (0, import_node_path16.join)(".github", "workflows");
+  const dir = (0, import_node_path17.join)(".github", "workflows");
   let names;
   try {
-    names = (0, import_node_fs16.readdirSync)(dir);
+    names = (0, import_node_fs17.readdirSync)(dir);
   } catch {
     return null;
   }
   const files = [];
   for (const name of names.filter(isGateWorkflowPath)) {
     try {
-      files.push({ path: `${dir}/${name}`.replace(/\\/g, "/"), body: (0, import_node_fs16.readFileSync)((0, import_node_path16.join)(dir, name), "utf8") });
+      files.push({ path: `${dir}/${name}`.replace(/\\/g, "/"), body: (0, import_node_fs17.readFileSync)((0, import_node_path17.join)(dir, name), "utf8") });
     } catch {
     }
   }
@@ -14610,12 +14817,12 @@ async function runPrLand(prNumber, options, deps) {
 }
 
 // src/wave-status.ts
-var import_node_fs18 = require("node:fs");
+var import_node_fs19 = require("node:fs");
 
 // src/stage-runner.ts
 var import_node_child_process7 = require("node:child_process");
-var import_node_fs17 = require("node:fs");
-var import_node_path17 = require("node:path");
+var import_node_fs18 = require("node:fs");
+var import_node_path18 = require("node:path");
 var import_node_net = require("node:net");
 var import_node_util5 = require("node:util");
 
@@ -14730,7 +14937,7 @@ function containersPublishingPort(containers, port) {
   return containers.filter((c) => c.publishedHostPorts.includes(port));
 }
 function isOwnComposeContainer(container, cwd) {
-  if (container.composeWorkingDir && normPath2(container.composeWorkingDir) === normPath2(cwd)) return true;
+  if (container.composeWorkingDir && normPath3(container.composeWorkingDir) === normPath3(cwd)) return true;
   if (container.composeWorkingDir && pathUnder(container.composeWorkingDir, cwd)) return true;
   const derived = deriveComposeProjectName(cwd);
   return Boolean(derived && container.composeProject === derived);
@@ -14754,13 +14961,13 @@ function appendForceRecreate(up) {
   return `${up.trimEnd()} --force-recreate`;
 }
 function stageStatePath(cwd = process.cwd()) {
-  return (0, import_node_path17.join)(cwd, "tmp", "stage", "state.json");
+  return (0, import_node_path18.join)(cwd, "tmp", "stage", "state.json");
 }
 function stageGlobalStatePath(cwd = process.cwd(), gitCommonDir = ".git") {
-  const dir = (0, import_node_path17.isAbsolute)(gitCommonDir) ? gitCommonDir : (0, import_node_path17.resolve)(cwd, gitCommonDir);
-  return (0, import_node_path17.join)(dir, "mmi", "stage", "state.json");
+  const dir = (0, import_node_path18.isAbsolute)(gitCommonDir) ? gitCommonDir : (0, import_node_path18.resolve)(cwd, gitCommonDir);
+  return (0, import_node_path18.join)(dir, "mmi", "stage", "state.json");
 }
-function normPath2(path2) {
+function normPath3(path2) {
   return path2.replace(/\\/g, "/").replace(/\/+$/, "").toLowerCase();
 }
 function parseWorktreeListPaths(stdout) {
@@ -14791,8 +14998,8 @@ function parseStagePortFlag(raw) {
   return port;
 }
 function pathUnder(childPath, parentPath) {
-  const child2 = normPath2(childPath);
-  const parent = normPath2(parentPath);
+  const child2 = normPath3(childPath);
+  const parent = normPath3(parentPath);
   return Boolean(child2 && parent && (child2 === parent || child2.startsWith(`${parent}/`)));
 }
 function stageStateMatchesRequiredCwd(state, requiredCwd) {
@@ -14956,8 +15163,8 @@ async function resolveStagePort(config, guard, reservedPorts = /* @__PURE__ */ n
   return pickStagePort(config.portRange, (p) => free.has(p));
 }
 async function reservedPortsForWorktree(cwd) {
-  const self = normPath2(cwd);
-  const siblings = (await listRepoWorktreePaths(cwd)).filter((p) => normPath2(p) !== self);
+  const self = normPath3(cwd);
+  const siblings = (await listRepoWorktreePaths(cwd)).filter((p) => normPath3(p) !== self);
   return collectReservedStagePorts(siblings);
 }
 async function assertStagePortAvailable(port, cwd, guard, reserved) {
@@ -14982,14 +15189,14 @@ function stageProcessEnv(stagePort, extraEnv) {
 }
 async function ensureStageRuntimeEnv(config, opts, cwd) {
   if (!config.ensureEnv) return;
-  const target = (0, import_node_path17.join)(cwd, config.ensureEnv.target);
-  const example = (0, import_node_path17.join)(cwd, config.ensureEnv.example);
-  if (!(0, import_node_fs17.existsSync)(target) && (0, import_node_fs17.existsSync)(example)) {
-    (0, import_node_fs17.copyFileSync)(example, target);
-  } else if ((0, import_node_fs17.existsSync)(target) && (0, import_node_fs17.existsSync)(example)) {
-    const stale = detectStaleEnvFile((0, import_node_fs17.readFileSync)(example, "utf8"), (0, import_node_fs17.readFileSync)(target, "utf8"), {
-      exampleMtimeMs: (0, import_node_fs17.statSync)(example).mtimeMs,
-      targetMtimeMs: (0, import_node_fs17.statSync)(target).mtimeMs
+  const target = (0, import_node_path18.join)(cwd, config.ensureEnv.target);
+  const example = (0, import_node_path18.join)(cwd, config.ensureEnv.example);
+  if (!(0, import_node_fs18.existsSync)(target) && (0, import_node_fs18.existsSync)(example)) {
+    (0, import_node_fs18.copyFileSync)(example, target);
+  } else if ((0, import_node_fs18.existsSync)(target) && (0, import_node_fs18.existsSync)(example)) {
+    const stale = detectStaleEnvFile((0, import_node_fs18.readFileSync)(example, "utf8"), (0, import_node_fs18.readFileSync)(target, "utf8"), {
+      exampleMtimeMs: (0, import_node_fs18.statSync)(example).mtimeMs,
+      targetMtimeMs: (0, import_node_fs18.statSync)(target).mtimeMs
     });
     if (stale) {
       const msg = `stale ${config.ensureEnv.target} (${stale}) \u2014 delete it or refresh from ${config.ensureEnv.example} before re-running /stage`;
@@ -14997,8 +15204,8 @@ async function ensureStageRuntimeEnv(config, opts, cwd) {
       console.error(`mmi-cli stage: ${msg} (allowed via --allow-stale-env)`);
     }
   }
-  if (opts.vaultEnvMerge && Object.keys(opts.vaultEnvMerge).length && (0, import_node_fs17.existsSync)(target)) {
-    (0, import_node_fs17.writeFileSync)(target, mergeEnvSecretsIntoFile((0, import_node_fs17.readFileSync)(target, "utf8"), opts.vaultEnvMerge), "utf8");
+  if (opts.vaultEnvMerge && Object.keys(opts.vaultEnvMerge).length && (0, import_node_fs18.existsSync)(target)) {
+    (0, import_node_fs18.writeFileSync)(target, mergeEnvSecretsIntoFile((0, import_node_fs18.readFileSync)(target, "utf8"), opts.vaultEnvMerge), "utf8");
   }
 }
 async function gitText(cwd, args) {
@@ -15028,20 +15235,20 @@ async function resolveGlobalStatePath(cwd, explicit) {
   return void 0;
 }
 function readState(path2) {
-  if (!(0, import_node_fs17.existsSync)(path2)) return null;
+  if (!(0, import_node_fs18.existsSync)(path2)) return null;
   try {
-    return JSON.parse((0, import_node_fs17.readFileSync)(path2, "utf8"));
+    return JSON.parse((0, import_node_fs18.readFileSync)(path2, "utf8"));
   } catch {
     return null;
   }
 }
 function mkdirFor(path2) {
   const dir = path2.slice(0, Math.max(path2.lastIndexOf("/"), path2.lastIndexOf("\\")));
-  (0, import_node_fs17.mkdirSync)(dir, { recursive: true });
+  (0, import_node_fs18.mkdirSync)(dir, { recursive: true });
 }
 function writeState(path2, state) {
   mkdirFor(path2);
-  (0, import_node_fs17.writeFileSync)(path2, JSON.stringify(state, null, 2), "utf8");
+  (0, import_node_fs18.writeFileSync)(path2, JSON.stringify(state, null, 2), "utf8");
 }
 function writeStagePortReservation(port, cwd, statePath, globalStatePath, now) {
   const reservation = {
@@ -15061,7 +15268,7 @@ async function cleanupStageState(state, paths, timeoutMs, fallbackCwd) {
     await shell(state.teardown.command.trim(), state.teardown.cwd || state.cwd || fallbackCwd, Math.max(timeoutMs, 1e4));
   }
   for (const path2 of [...new Set(paths.filter((p) => Boolean(p)))]) {
-    (0, import_node_fs17.rmSync)(path2, { force: true });
+    (0, import_node_fs18.rmSync)(path2, { force: true });
   }
 }
 async function killTree(pid) {
@@ -15219,8 +15426,8 @@ async function runStage(config = {}, opts = {}) {
     await ensureStageRuntimeEnv(config, opts, cwd);
     if (build) await shell(sub(build), cwd, timeoutMs, stageProcessEnv(stagePort, extraEnv));
   } catch (e) {
-    (0, import_node_fs17.rmSync)(statePath, { force: true });
-    if (globalStatePath && globalStatePath !== statePath) (0, import_node_fs17.rmSync)(globalStatePath, { force: true });
+    (0, import_node_fs18.rmSync)(statePath, { force: true });
+    if (globalStatePath && globalStatePath !== statePath) (0, import_node_fs18.rmSync)(globalStatePath, { force: true });
     throw e;
   }
   const started = await startStage(config, {
@@ -15241,9 +15448,9 @@ function parseNextFromHead(headText) {
 }
 function readStageSummary(worktreePath) {
   const statePath = stageStatePath(worktreePath);
-  if (!(0, import_node_fs18.existsSync)(statePath)) return void 0;
+  if (!(0, import_node_fs19.existsSync)(statePath)) return void 0;
   try {
-    const state = JSON.parse((0, import_node_fs18.readFileSync)(statePath, "utf8"));
+    const state = JSON.parse((0, import_node_fs19.readFileSync)(statePath, "utf8"));
     const port = typeof state.port === "number" ? state.port : void 0;
     if (port == null || !Number.isInteger(port) || port <= 0) return void 0;
     return { port, url: typeof state.url === "string" ? state.url : void 0 };
@@ -15348,13 +15555,13 @@ async function executeWaveLand(plan, deps, opts = { preserveWorktree: true }) {
 }
 
 // src/index.ts
-var import_node_os17 = require("node:os");
+var import_node_os18 = require("node:os");
 
 // src/board.ts
 var import_node_child_process9 = require("node:child_process");
-var import_node_fs21 = require("node:fs");
-var import_node_os7 = require("node:os");
-var import_node_path20 = require("node:path");
+var import_node_fs22 = require("node:fs");
+var import_node_os8 = require("node:os");
+var import_node_path21 = require("node:path");
 var import_node_util6 = require("node:util");
 
 // src/board-priority.ts
@@ -15708,9 +15915,9 @@ function boardConfigFromProject(meta, floor = {}) {
 }
 
 // src/cli-doctor-shared.ts
-var import_node_fs19 = require("node:fs");
-var import_node_path19 = require("node:path");
 var import_node_fs20 = require("node:fs");
+var import_node_path20 = require("node:path");
+var import_node_fs21 = require("node:fs");
 
 // src/readiness-audit.ts
 var TENANT_DEPLOY_RUN_SCAN_LIMIT = 100;
@@ -15827,12 +16034,12 @@ ${lines.join("\n")}`;
 
 // src/secrets.ts
 var import_node_child_process8 = require("node:child_process");
-var import_node_os6 = require("node:os");
+var import_node_os7 = require("node:os");
 
 // src/gh-create.ts
 var import_promises4 = require("node:fs/promises");
-var import_node_os5 = require("node:os");
-var import_node_path18 = require("node:path");
+var import_node_os6 = require("node:os");
+var import_node_path19 = require("node:path");
 var import_node_crypto3 = require("node:crypto");
 var ISSUE_TYPES = ["bug", "feature", "task"];
 var GH_MUTATION_TIMEOUT_MS = 12e4;
@@ -15885,9 +16092,9 @@ async function bodyArgsViaFile(args, deps = {}) {
   const write = deps.write ?? import_promises4.writeFile;
   const remove2 = deps.remove ?? import_promises4.unlink;
   const ensureDir = deps.ensureDir ?? import_promises4.mkdir;
-  const dir = deps.dir ?? (0, import_node_os5.tmpdir)();
-  const file = (0, import_node_path18.join)(dir, `mmi-gh-body-${process.pid}-${(0, import_node_crypto3.randomBytes)(4).toString("hex")}.md`);
-  await ensureDir((0, import_node_path18.dirname)(file), { recursive: true }).catch(() => {
+  const dir = deps.dir ?? (0, import_node_os6.tmpdir)();
+  const file = (0, import_node_path19.join)(dir, `mmi-gh-body-${process.pid}-${(0, import_node_crypto3.randomBytes)(4).toString("hex")}.md`);
+  await ensureDir((0, import_node_path19.dirname)(file), { recursive: true }).catch(() => {
   });
   await write(file, args[i + 1], "utf8");
   return {
@@ -17064,7 +17271,7 @@ function resolveSpawnTarget(command, args, platform2 = process.platform) {
 }
 function spawnExitCode(status, signal) {
   if (status != null) return status;
-  const signo = signal ? import_node_os6.constants.signals[signal] : void 0;
+  const signo = signal ? import_node_os7.constants.signals[signal] : void 0;
   return signo ? 128 + signo : 1;
 }
 function defaultSpawn(command, args, env) {
@@ -17411,7 +17618,7 @@ async function localBranchHeads() {
 }
 async function currentRepoWorktreeGitRoot(repoRoot2) {
   const gitCommonDir = (await execFileP2("git", ["rev-parse", "--git-common-dir"], { timeout: GIT_TIMEOUT_MS }).catch(() => ({ stdout: "" }))).stdout.trim();
-  return gitCommonDir ? (0, import_node_path19.resolve)(repoRoot2, gitCommonDir, "worktrees") : "";
+  return gitCommonDir ? (0, import_node_path20.resolve)(repoRoot2, gitCommonDir, "worktrees") : "";
 }
 async function worktreeBranches() {
   const { stdout } = await execFileP2("git", ["worktree", "list", "--porcelain"], { timeout: GIT_TIMEOUT_MS });
@@ -17431,18 +17638,18 @@ function resolveGitdirForWorktreeFile(worktreePath, content) {
   const match = /^gitdir:\s*(.+)\s*$/im.exec(content);
   if (!match?.[1]) return void 0;
   const raw = match[1].trim();
-  return (0, import_node_path19.isAbsolute)(raw) ? raw : (0, import_node_path19.resolve)(worktreePath, raw);
+  return (0, import_node_path20.isAbsolute)(raw) ? raw : (0, import_node_path20.resolve)(worktreePath, raw);
 }
 function metadataOwnsMissingWorktreeDir(worktreePath, worktreeGitRoot) {
   if (!worktreeGitRoot) return false;
   try {
-    const entries = (0, import_node_fs20.readdirSync)(worktreeGitRoot, { withFileTypes: true });
+    const entries = (0, import_node_fs21.readdirSync)(worktreeGitRoot, { withFileTypes: true });
     for (const ent of entries) {
       if (!ent.isDirectory()) continue;
       try {
-        const gitdirPath = (0, import_node_fs19.readFileSync)((0, import_node_path19.join)(worktreeGitRoot, ent.name, "gitdir"), "utf8").trim();
-        const resolvedGitdir = (0, import_node_path19.isAbsolute)(gitdirPath) ? gitdirPath : (0, import_node_path19.resolve)(worktreeGitRoot, ent.name, gitdirPath);
-        if (sameWorktreeMetadataPath((0, import_node_path19.dirname)(resolvedGitdir), worktreePath)) return true;
+        const gitdirPath = (0, import_node_fs20.readFileSync)((0, import_node_path20.join)(worktreeGitRoot, ent.name, "gitdir"), "utf8").trim();
+        const resolvedGitdir = (0, import_node_path20.isAbsolute)(gitdirPath) ? gitdirPath : (0, import_node_path20.resolve)(worktreeGitRoot, ent.name, gitdirPath);
+        if (sameWorktreeMetadataPath((0, import_node_path20.dirname)(resolvedGitdir), worktreePath)) return true;
       } catch {
       }
     }
@@ -17452,7 +17659,7 @@ function metadataOwnsMissingWorktreeDir(worktreePath, worktreeGitRoot) {
 }
 function pathExistsKnown(path2) {
   try {
-    (0, import_node_fs20.statSync)(path2);
+    (0, import_node_fs21.statSync)(path2);
     return true;
   } catch (e) {
     const code = typeof e === "object" && e && "code" in e ? String(e.code ?? "") : "";
@@ -17461,10 +17668,10 @@ function pathExistsKnown(path2) {
   }
 }
 function inspectSiblingWorktreeDir(path2, worktreeGitRoot) {
-  const gitPath = (0, import_node_path19.join)(path2, ".git");
+  const gitPath = (0, import_node_path20.join)(path2, ".git");
   let st;
   try {
-    st = (0, import_node_fs20.lstatSync)(gitPath);
+    st = (0, import_node_fs21.lstatSync)(gitPath);
   } catch (e) {
     const code = typeof e === "object" && e && "code" in e ? String(e.code ?? "") : "";
     if (code === "ENOENT" || code === "ENOTDIR") {
@@ -17481,7 +17688,7 @@ function inspectSiblingWorktreeDir(path2, worktreeGitRoot) {
   if (st.isDirectory()) return { path: path2, gitType: "dir" };
   if (!st.isFile()) return { path: path2, gitType: "other" };
   try {
-    const gitFileContent = (0, import_node_fs19.readFileSync)(gitPath, "utf8");
+    const gitFileContent = (0, import_node_fs20.readFileSync)(gitPath, "utf8");
     const gitdir = resolveGitdirForWorktreeFile(path2, gitFileContent);
     const gitDirExists = gitdir ? pathExistsKnown(gitdir) : false;
     return {
@@ -17489,7 +17696,7 @@ function inspectSiblingWorktreeDir(path2, worktreeGitRoot) {
       gitType: "file",
       gitFileContent,
       gitDirExists,
-      ownedByCurrentRepo: Boolean(gitdir && worktreeGitRoot && isPathUnderDirectory(gitdir, worktreeGitRoot)),
+      ownedByCurrentRepo: Boolean(gitdir && worktreeGitRoot && isPathUnderDirectory2(gitdir, worktreeGitRoot)),
       detail: gitDirExists === void 0 ? "gitdir existence could not be verified" : void 0
     };
   } catch {
@@ -17498,7 +17705,7 @@ function inspectSiblingWorktreeDir(path2, worktreeGitRoot) {
 }
 function inspectDeadWorktreeDirContent(path2) {
   try {
-    return { entries: (0, import_node_fs20.readdirSync)(path2) };
+    return { entries: (0, import_node_fs21.readdirSync)(path2) };
   } catch (e) {
     const code = typeof e === "object" && e && "code" in e ? String(e.code ?? "") : "";
     return { error: code ? `unable to inspect directory contents (${code})` : "unable to inspect directory contents" };
@@ -17515,7 +17722,7 @@ async function preservedBranches() {
 async function siblingWorktreeDirs(explicitRoot) {
   const repoRoot2 = (await execFileP2("git", ["rev-parse", "--show-toplevel"], { timeout: GIT_TIMEOUT_MS }).catch(() => ({ stdout: "" }))).stdout.trim() || process.cwd();
   const worktreeGitRoot = await currentRepoWorktreeGitRoot(repoRoot2);
-  const primaryRepoRoot = worktreeGitRoot ? (0, import_node_path19.dirname)((0, import_node_path19.dirname)(worktreeGitRoot)) : repoRoot2;
+  const primaryRepoRoot = worktreeGitRoot ? (0, import_node_path20.dirname)((0, import_node_path20.dirname)(worktreeGitRoot)) : repoRoot2;
   try {
     const dirs = explicitRoot ? listDirsIn(resolveExplicitScanRoot(explicitRoot, primaryRepoRoot)) : worktreeScanDirs(siblingMmiWorktreesRoot(primaryRepoRoot), primaryRepoRoot, listDirsIn, isRepoCheckoutDir);
     return dirs.map((dir) => inspectSiblingWorktreeDir(dir, worktreeGitRoot)).filter((entry) => Boolean(entry));
@@ -17525,18 +17732,18 @@ async function siblingWorktreeDirs(explicitRoot) {
 }
 function listDirsIn(dir) {
   try {
-    return (0, import_node_fs20.readdirSync)(dir, { withFileTypes: true }).filter((ent) => ent.isDirectory()).map((ent) => (0, import_node_path19.join)(dir, ent.name));
+    return (0, import_node_fs21.readdirSync)(dir, { withFileTypes: true }).filter((ent) => ent.isDirectory()).map((ent) => (0, import_node_path20.join)(dir, ent.name));
   } catch {
     return [];
   }
 }
 function isRepoCheckoutDir(dir) {
-  return (0, import_node_fs20.existsSync)((0, import_node_path19.join)(dir, ".git"));
+  return (0, import_node_fs21.existsSync)((0, import_node_path20.join)(dir, ".git"));
 }
 function resolveExplicitScanRoot(explicitRoot, repoRoot2) {
   let rootDirs;
   try {
-    rootDirs = (0, import_node_fs20.readdirSync)(explicitRoot, { withFileTypes: true }).filter((ent) => ent.isDirectory()).map((ent) => ent.name);
+    rootDirs = (0, import_node_fs21.readdirSync)(explicitRoot, { withFileTypes: true }).filter((ent) => ent.isDirectory()).map((ent) => ent.name);
   } catch {
     return explicitRoot;
   }
@@ -18884,7 +19091,7 @@ var CLAIM_SESSION_ACTIVITY_MS = 30 * 6e4;
 var CLAIM_SESSION_PROBE_CACHE_MS = 6e4;
 var claimSessionProbeCache = /* @__PURE__ */ new Map();
 function probeLocalClaimSession(marker, now = Date.now()) {
-  if (!marker.session || !marker.host || marker.host.toLowerCase() !== (0, import_node_os7.hostname)().toLowerCase()) return void 0;
+  if (!marker.session || !marker.host || marker.host.toLowerCase() !== (0, import_node_os8.hostname)().toLowerCase()) return void 0;
   if (!marker.surface?.toLowerCase().startsWith("claude")) return void 0;
   const cacheKey = `${marker.host.toLowerCase()}/${marker.session}`;
   const cached = claimSessionProbeCache.get(cacheKey);
@@ -18893,17 +19100,17 @@ function probeLocalClaimSession(marker, now = Date.now()) {
     claimSessionProbeCache.set(cacheKey, { checkedAt: now, state });
     return state;
   };
-  const root = (0, import_node_path20.join)((0, import_node_os7.homedir)(), ".claude", "projects");
+  const root = (0, import_node_path21.join)((0, import_node_os8.homedir)(), ".claude", "projects");
   try {
     const wanted = `${marker.session}.jsonl`.toLowerCase();
     const pending = [root];
     while (pending.length) {
       const dir = pending.pop();
-      for (const entry of (0, import_node_fs21.readdirSync)(dir, { withFileTypes: true })) {
-        const path2 = (0, import_node_path20.join)(dir, entry.name);
+      for (const entry of (0, import_node_fs22.readdirSync)(dir, { withFileTypes: true })) {
+        const path2 = (0, import_node_path21.join)(dir, entry.name);
         if (entry.isDirectory()) pending.push(path2);
         else if (entry.isFile() && entry.name.toLowerCase() === wanted) {
-          return remember(now - (0, import_node_fs21.statSync)(path2).mtimeMs <= CLAIM_SESSION_ACTIVITY_MS ? "live" : "dead");
+          return remember(now - (0, import_node_fs22.statSync)(path2).mtimeMs <= CLAIM_SESSION_ACTIVITY_MS ? "live" : "dead");
         }
       }
     }
@@ -19182,7 +19389,7 @@ async function resolveAutoAddBoardAttach(client, cfg, selector, priority, warn =
 }
 
 // src/issue-body.ts
-var import_node_os8 = require("node:os");
+var import_node_os9 = require("node:os");
 var TextArgError = class extends Error {
   constructor(message, code, offendingFlag) {
     super(message);
@@ -19194,7 +19401,7 @@ var TextArgError = class extends Error {
   offendingFlag;
 };
 function emptyStdinMessage(fileFlag) {
-  if ((0, import_node_os8.platform)() === "win32") {
+  if ((0, import_node_os9.platform)() === "win32") {
     return `${fileFlag} - read empty stdin (on Windows, ${fileFlag} - is unreliable through the npm .cmd shim \u2014 use ${fileFlag} <path>, or pipe to \`node cli/dist/index.cjs\` directly)`;
   }
   return `${fileFlag} - read empty stdin (nothing piped \u2014 pass a heredoc/pipe, or ${fileFlag} <path>)`;
@@ -19299,6 +19506,102 @@ function applyChecklistCheck(body, query, checked) {
   return { ok: true, edit: setChecklistMarker(body, sel.item, checked), item: sel.item };
 }
 
+// src/house-map.ts
+var HOUSE_ROOTS = ["oracle", "harbour", "devops", "vault", "learning"];
+function isHouseRoot(token) {
+  return HOUSE_ROOTS.includes(token);
+}
+var COMPAT_SHIM_DEATH_WAVE = "Wave 3";
+var COMPAT_SHIM_NOTE = `compatibility shim \u2014 the flat Wave 0 path; use the canonical house-prefixed form; dies in ${COMPAT_SHIM_DEATH_WAVE} (#4316)`;
+var HOUSE_QUESTIONS = {
+  oracle: "Is it live?",
+  harbour: "Is it bounded?",
+  devops: "Is it legal?",
+  vault: "Is it guarded?",
+  learning: "Did it learn?",
+  core: "Is it one door?"
+};
+var HOUSE_MAP = {
+  // --- oracle — live truth ------------------------------------------------------------------------
+  board: "oracle",
+  // board management (read + the guarded mutations that keep it live)
+  issue: "oracle",
+  // issues are live org truth
+  find: "oracle",
+  // estate search door
+  "repo-index": "oracle",
+  // Hub cloud + local pointer index
+  wave: "oracle",
+  // read-side multi-worktree board visibility (`wave status`)
+  next: "oracle",
+  // read-side board: the next actionable item
+  docs: "oracle",
+  // generated docs surfaces — the live org knowledge routing index
+  org: "oracle",
+  // org projects/registry/access reads (subgroup overrides below)
+  "org project": "oracle",
+  // registry projections (declared + projected live truth)
+  "org access": "oracle",
+  // org access role/audit reads
+  "org config": "oracle",
+  // live org configuration read
+  // --- harbour — declared lanes -------------------------------------------------------------------
+  "org schedules": "harbour",
+  // register/run/park schedule rows under the one lane contract
+  // --- devops — shipping --------------------------------------------------------------------------
+  pr: "devops",
+  ci: "devops",
+  // the CI/gate audit
+  rcand: "devops",
+  release: "devops",
+  hotfix: "devops",
+  train: "devops",
+  "wave land": "devops",
+  // the write-side serial merge train is shipping, not board observation
+  bootstrap: "devops",
+  // repo provisioning + propagate
+  runtime: "devops",
+  // tenant/deploy/box/edge — shipping and central deploy
+  "org rules": "devops",
+  // org-managed repository rule delivery (.gitignore)
+  // --- vault — secrets ----------------------------------------------------------------------------
+  secrets: "vault",
+  "org oauth": "vault",
+  // OAuth credential planning/set/verify
+  // --- learning — self-improvement ----------------------------------------------------------------
+  report: "learning",
+  // friction reports
+  "skill-lesson": "learning",
+  // --- core — the front door itself ---------------------------------------------------------------
+  commands: "core",
+  whoami: "core",
+  worktree: "core",
+  spawn: "core",
+  // this repo's process-spawn contract
+  tests: "core",
+  // this repo's test-policy contract
+  doctor: "core",
+  stage: "core",
+  plugin: "core",
+  // plugin lifecycle + guards (CLI house owns plugins)
+  explain: "core",
+  // command-surface help
+  status: "core",
+  // repo-orientation snapshot (front door — torn toward oracle, kept core)
+  onboard: "core"
+  // repo-readiness orientation (front door — torn toward oracle, kept core)
+};
+function houseForPath(path2) {
+  if (path2 === "") return "core";
+  const segments = path2.split(" ");
+  for (let end = segments.length; end > 0; end -= 1) {
+    const key = segments.slice(0, end).join(" ");
+    const house = HOUSE_MAP[key];
+    if (house) return house;
+  }
+  return void 0;
+}
+
 // src/command-taxonomy.ts
 var COMMAND_METADATA = /* @__PURE__ */ Symbol.for("mmi.commandTaxonomy.metadata");
 var PRIMARY_GROUPS = [
@@ -19476,9 +19779,6 @@ function applyCommandTaxonomy(program3) {
 function commandTaxonomyRank(name) {
   return TOP_LEVEL_ORDER.get(name) ?? Number.MAX_SAFE_INTEGER;
 }
-function commandHelpGroupRank(group) {
-  return HELP_GROUP_ORDER.get(group) ?? Number.MAX_SAFE_INTEGER;
-}
 function isCanonicalSuggestion(metadata) {
   return metadata.category !== "internal";
 }
@@ -19559,9 +19859,16 @@ function buildCommand(cmd, path2) {
     module_owner: "unclassified",
     consumer: "unclassified"
   };
+  const house = houseForPath(path2);
+  if (!house) {
+    throw new Error(
+      `command-manifest: command '${path2}' has no house assignment \u2014 add it to cli/src/house-map.ts (the six-house taxonomy; every top-level command maps to exactly one house).`
+    );
+  }
   const out = {
     name: cmd.name(),
     path: path2,
+    house,
     arguments: cmd.registeredArguments.map(buildArgument),
     // A hand-parsed command registers no Commander options, so its declared set is merged in (#3682).
     options: [...cmd.options.map(buildOption), ...readDeclaredOptions(cmd)],
@@ -19571,6 +19878,7 @@ function buildCommand(cmd, path2) {
     ...metadata
   };
   if (cmd._allowUnknownOption) out.parses_own_argv = true;
+  if (path2 && house !== "core") out.shim = true;
   const description = cmd.description();
   if (description) out.description = description;
   const examples = readExamples(cmd);
@@ -19596,6 +19904,22 @@ function collectLeaves(node, acc) {
   }
   for (const child2 of node.subcommands) collectLeaves(child2, acc);
 }
+function buildHouses(tree) {
+  const collect = (node, parentHouse, root, out) => {
+    if (node.house === root && parentHouse !== root) {
+      const entry = { path: node.path };
+      if (node.description) entry.description = node.description;
+      out.push(entry);
+    }
+    for (const child2 of node.subcommands) collect(child2, node.house, root, out);
+  };
+  return HOUSE_ROOTS.map((root) => {
+    const commands = [];
+    for (const top of tree.subcommands) collect(top, void 0, root, commands);
+    commands.sort((a, b) => a.path.localeCompare(b.path));
+    return { root, question: HOUSE_QUESTIONS[root], commands };
+  });
+}
 function buildCommandManifest(program3) {
   const tree = buildCommand(program3, "");
   const index = [];
@@ -19609,6 +19933,13 @@ function buildCommandManifest(program3) {
     name: tree.name,
     tree,
     index,
+    houses: buildHouses(tree),
+    shim_contract: {
+      canonical: "mmi-cli <house> <command> \u2026",
+      shim: "mmi-cli <command> \u2026",
+      dies: COMPAT_SHIM_DEATH_WAVE,
+      note: COMPAT_SHIM_NOTE
+    },
     primary_tree: primaryTree,
     primary_index: primaryIndex,
     error_codes: ERROR_CODE_REFERENCE
@@ -19645,16 +19976,26 @@ function formatManifestHuman(manifest, options = {}) {
     }
     if (options.all) for (const child2 of node.subcommands) render(child2, depth + 1);
   };
-  let currentGroup;
-  const rootCommands = [...root.subcommands].sort((a, b) => commandHelpGroupRank(a.help_group) - commandHelpGroupRank(b.help_group) || commandTaxonomyRank(a.name) - commandTaxonomyRank(b.name));
-  for (const command of rootCommands) {
-    if (command.help_group !== currentGroup) {
-      currentGroup = command.help_group;
-      lines.push("", `${currentGroup}:`);
-    }
-    render(command, 1);
-  }
-  lines.push("", options.all ? "Use `mmi-cli explain <group|command>` for a focused map." : "Use `mmi-cli explain <group|command>` for detail or `mmi-cli commands --all` for operational depth.");
+  const forHouse = (node, house) => {
+    const subcommands = node.subcommands.map((child2) => forHouse(child2, house)).filter((child2) => Boolean(child2));
+    if (node.house === house) return { ...node, subcommands };
+    return subcommands.length ? { ...node, subcommands } : void 0;
+  };
+  const renderHouse = (house, label) => {
+    const members = root.subcommands.map((command) => forHouse(command, house)).filter((command) => Boolean(command)).sort((a, b) => commandTaxonomyRank(a.name) - commandTaxonomyRank(b.name));
+    if (!members.length) return;
+    lines.push("", `${label}:`);
+    for (const member of members) render(member, 1);
+  };
+  for (const house of HOUSE_ROOTS) renderHouse(house, `${house} \u2014 ${HOUSE_QUESTIONS[house]}`);
+  renderHouse("core", `core \u2014 ${HOUSE_QUESTIONS.core}`);
+  lines.push(
+    "",
+    `Canonical form: \`mmi-cli <house> <command> \u2026\`. The flat paths above are compatibility shims,`,
+    `kept for one window so fleet scripts keep working \u2014 they die in ${COMPAT_SHIM_DEATH_WAVE} (#4316).`,
+    "",
+    options.all ? "Use `mmi-cli explain <group|command>` for a focused map." : "Use `mmi-cli explain <group|command>` for detail or `mmi-cli commands --all` for operational depth."
+  );
   return lines.join("\n");
 }
 
@@ -19719,8 +20060,8 @@ function consolidateCommandNamespaces(program3) {
 }
 
 // src/pi-plugin-registration.ts
-var import_node_fs22 = require("node:fs");
-var import_node_path21 = require("node:path");
+var import_node_fs23 = require("node:fs");
+var import_node_path22 = require("node:path");
 
 // src/plugin-cache-prune.ts
 var PLUGIN_CACHE_KEEP = 2;
@@ -19974,37 +20315,37 @@ function newestExistingPiPlugin(home) {
   const cacheRoot = pluginCacheRoot(home);
   let names;
   try {
-    names = (0, import_node_fs22.readdirSync)(cacheRoot);
+    names = (0, import_node_fs23.readdirSync)(cacheRoot);
   } catch {
     return void 0;
   }
   for (const version of names.filter(isVersionDirName).sort((a, b) => compareVersions(b, a))) {
-    const candidate = (0, import_node_path21.join)(cacheRoot, version, ".pi-plugin");
-    if ((0, import_node_fs22.existsSync)(candidate)) return candidate;
+    const candidate = (0, import_node_path22.join)(cacheRoot, version, ".pi-plugin");
+    if ((0, import_node_fs23.existsSync)(candidate)) return candidate;
   }
   return void 0;
 }
 function expectedPiPluginPath(home, env, installedVersion) {
   const root = env.CLAUDE_PLUGIN_ROOT?.trim();
-  if (root && /[\\/]mutmutco[\\/]mmi[\\/]/.test(root)) return (0, import_node_path21.join)(root, ".pi-plugin");
+  if (root && /[\\/]mutmutco[\\/]mmi[\\/]/.test(root)) return (0, import_node_path22.join)(root, ".pi-plugin");
   const version = installedVersion ?? runningPluginVersion(env);
   if (version) {
-    const pinned = (0, import_node_path21.join)(home, ".claude", "plugins", "cache", "mutmutco", "mmi", version, ".pi-plugin");
-    if ((0, import_node_fs22.existsSync)(pinned)) return pinned;
+    const pinned = (0, import_node_path22.join)(home, ".claude", "plugins", "cache", "mutmutco", "mmi", version, ".pi-plugin");
+    if ((0, import_node_fs23.existsSync)(pinned)) return pinned;
   }
   return newestExistingPiPlugin(home);
 }
 function settingsPath(home) {
-  return (0, import_node_path21.join)(home, ".pi", "agent", "settings.json");
+  return (0, import_node_path22.join)(home, ".pi", "agent", "settings.json");
 }
 function readPiPluginState(home, env, installedVersion) {
-  if (!(0, import_node_fs22.existsSync)((0, import_node_path21.join)(home, ".pi", "agent"))) return void 0;
+  if (!(0, import_node_fs23.existsSync)((0, import_node_path22.join)(home, ".pi", "agent"))) return void 0;
   const expectedPath = expectedPiPluginPath(home, env, installedVersion);
   if (!expectedPath) return void 0;
   const file = settingsPath(home);
-  if (!(0, import_node_fs22.existsSync)(file)) return { expectedPath, settingsReadable: true };
+  if (!(0, import_node_fs23.existsSync)(file)) return { expectedPath, settingsReadable: true };
   try {
-    const parsed = JSON.parse((0, import_node_fs22.readFileSync)(file, "utf8"));
+    const parsed = JSON.parse((0, import_node_fs23.readFileSync)(file, "utf8"));
     const packages = Array.isArray(parsed.packages) ? parsed.packages : [];
     return { expectedPath, registeredPath: packages.find((p) => typeof p === "string" && isMmiPiPackage(p)), settingsReadable: true };
   } catch {
@@ -20017,11 +20358,11 @@ function healPiPluginRegistration(home, env, installedVersion) {
   if (!state.settingsReadable) return { ok: false, detail: "settings.json unreadable \u2014 nothing written (fail closed)" };
   const file = settingsPath(home);
   try {
-    const parsed = (0, import_node_fs22.existsSync)(file) ? JSON.parse((0, import_node_fs22.readFileSync)(file, "utf8")) : {};
+    const parsed = (0, import_node_fs23.existsSync)(file) ? JSON.parse((0, import_node_fs23.readFileSync)(file, "utf8")) : {};
     const packages = Array.isArray(parsed.packages) ? parsed.packages : [];
     const next = packages.filter((p) => !(typeof p === "string" && isMmiPiPackage(p)));
     next.push(state.expectedPath);
-    (0, import_node_fs22.writeFileSync)(file, `${JSON.stringify({ ...parsed, packages: next }, null, 2)}
+    (0, import_node_fs23.writeFileSync)(file, `${JSON.stringify({ ...parsed, packages: next }, null, 2)}
 `);
     return { ok: true, detail: state.registeredPath ? `replaced ${state.registeredPath}` : `registered ${state.expectedPath}` };
   } catch (e) {
@@ -21666,8 +22007,8 @@ function renderAccessReport(report) {
 // src/repo-index.ts
 var import_node_crypto4 = require("node:crypto");
 var import_node_child_process12 = require("node:child_process");
-var import_node_fs23 = require("node:fs");
-var import_node_path22 = require("node:path");
+var import_node_fs24 = require("node:fs");
+var import_node_path23 = require("node:path");
 var REPO_INDEX_SCHEMA = 1;
 var HARD_DENY = [
   /(^|\/)\.env(\.|$)/i,
@@ -21792,11 +22133,11 @@ function loadReadmeHints(cwd, candidatePaths) {
   }
   for (const rel of readmes) {
     if (isHardDeniedPath(rel)) continue;
-    const abs = (0, import_node_path22.join)(cwd, ...rel.split("/"));
-    if (!(0, import_node_fs23.existsSync)(abs)) continue;
+    const abs = (0, import_node_path23.join)(cwd, ...rel.split("/"));
+    if (!(0, import_node_fs24.existsSync)(abs)) continue;
     let text;
     try {
-      text = (0, import_node_fs23.readFileSync)(abs, "utf8");
+      text = (0, import_node_fs24.readFileSync)(abs, "utf8");
     } catch {
       continue;
     }
@@ -21809,7 +22150,7 @@ function loadReadmeHints(cwd, candidatePaths) {
   return hints;
 }
 function toPosix(p) {
-  return p.split(import_node_path22.sep).join("/");
+  return p.split(import_node_path23.sep).join("/");
 }
 function listCandidatePaths(cwd, exec = import_node_child_process12.execFileSync) {
   try {
@@ -21831,11 +22172,11 @@ function rebuildRepoIndex(cwd, repoSlug2) {
   for (const rel of candidates) {
     if (ignored.has(rel)) continue;
     if (isHardDeniedPath(rel)) continue;
-    const abs = (0, import_node_path22.join)(cwd, ...rel.split("/"));
-    if (!(0, import_node_fs23.existsSync)(abs)) continue;
+    const abs = (0, import_node_path23.join)(cwd, ...rel.split("/"));
+    if (!(0, import_node_fs24.existsSync)(abs)) continue;
     let text;
     try {
-      text = (0, import_node_fs23.readFileSync)(abs, "utf8");
+      text = (0, import_node_fs24.readFileSync)(abs, "utf8");
     } catch {
       continue;
     }
@@ -21860,16 +22201,16 @@ function rebuildRepoIndex(cwd, repoSlug2) {
     entries
   };
   const store = repoIndexStorePath(cwd);
-  (0, import_node_fs23.mkdirSync)((0, import_node_path22.dirname)(store), { recursive: true });
-  (0, import_node_fs23.writeFileSync)(store, `${JSON.stringify(projection, null, 2)}
+  (0, import_node_fs24.mkdirSync)((0, import_node_path23.dirname)(store), { recursive: true });
+  (0, import_node_fs24.writeFileSync)(store, `${JSON.stringify(projection, null, 2)}
 `, "utf8");
   return projection;
 }
 function loadRepoIndex(cwd) {
   const store = repoIndexStorePath(cwd);
-  if (!(0, import_node_fs23.existsSync)(store)) return null;
+  if (!(0, import_node_fs24.existsSync)(store)) return null;
   try {
-    const raw = JSON.parse((0, import_node_fs23.readFileSync)(store, "utf8"));
+    const raw = JSON.parse((0, import_node_fs24.readFileSync)(store, "utf8"));
     if (raw?.schema !== REPO_INDEX_SCHEMA || !Array.isArray(raw.entries)) return null;
     return raw;
   } catch {
@@ -21941,7 +22282,7 @@ function inferRepoSlug(cwd, exec = import_node_child_process12.execFileSync) {
     if (m?.[1]) return m[1].toLowerCase();
   } catch {
   }
-  return ((0, import_node_path22.basename)(cwd) || "local").toLowerCase();
+  return ((0, import_node_path23.basename)(cwd) || "local").toLowerCase();
 }
 
 // src/repo-index-cloud-client.ts
@@ -22081,9 +22422,9 @@ async function gcRepoIndexCloud(deps) {
 }
 
 // src/repo-index-sync.ts
-var import_node_fs24 = require("node:fs");
-var import_node_os9 = require("node:os");
-var import_node_path23 = require("node:path");
+var import_node_fs25 = require("node:fs");
+var import_node_os10 = require("node:os");
+var import_node_path24 = require("node:path");
 var import_node_child_process13 = require("node:child_process");
 var MAX_EMBED_BACKFILL_ROUNDS = 40;
 function normalizeRepo(raw) {
@@ -22127,7 +22468,7 @@ async function syncEstateRepoIndex(opts) {
   const failed = [];
   const skipped = [];
   for (const repo of repos) {
-    const dir = (0, import_node_fs24.mkdtempSync)((0, import_node_path23.join)((0, import_node_os9.tmpdir)(), "mmi-repo-index-"));
+    const dir = (0, import_node_fs25.mkdtempSync)((0, import_node_path24.join)((0, import_node_os10.tmpdir)(), "mmi-repo-index-"));
     try {
       shallowClone(repo, dir, opts.githubToken);
       const built = rebuildRepoIndex(dir, repo);
@@ -22177,7 +22518,7 @@ async function syncEstateRepoIndex(opts) {
       failed.push({ repo, error: e.message });
     } finally {
       try {
-        (0, import_node_fs24.rmSync)(dir, { recursive: true, force: true });
+        (0, import_node_fs25.rmSync)(dir, { recursive: true, force: true });
       } catch {
       }
     }
@@ -22186,7 +22527,7 @@ async function syncEstateRepoIndex(opts) {
 }
 
 // src/repo-index-health.ts
-var import_node_fs25 = require("node:fs");
+var import_node_fs26 = require("node:fs");
 
 // testdata/repo-index-golden-queries.json
 var repo_index_golden_queries_default = {
@@ -22228,7 +22569,7 @@ function assertGoldenSuite(raw, source) {
 function loadGoldenSuite(path2) {
   let text;
   try {
-    text = (0, import_node_fs25.readFileSync)(path2, "utf8");
+    text = (0, import_node_fs26.readFileSync)(path2, "utf8");
   } catch (e) {
     throw new Error(`golden suite unreadable at ${path2}: ${e.message}`);
   }
@@ -22372,8 +22713,8 @@ async function runRepoIndexHealth(opts) {
 
 // src/spawn-policy-core.ts
 var import_node_child_process14 = require("node:child_process");
-var import_node_fs26 = require("node:fs");
-var import_node_path24 = require("node:path");
+var import_node_fs27 = require("node:fs");
+var import_node_path25 = require("node:path");
 var SPAWNERS = ["spawn", "spawnSync", "exec", "execSync", "execFile", "execFileSync"];
 var CALL_SOURCE = String.raw`(^|[^.\w$])(${SPAWNERS.join("|")})\s*\(`;
 var SOURCE_EXT = /\.(ts|mts|cts|js|mjs|cjs)$/;
@@ -22459,7 +22800,7 @@ function runSpawnPolicy(root) {
   for (const file of files) {
     let raw;
     try {
-      raw = (0, import_node_fs26.readFileSync)((0, import_node_path24.join)(root, file), "utf8");
+      raw = (0, import_node_fs27.readFileSync)((0, import_node_path25.join)(root, file), "utf8");
     } catch {
       continue;
     }
@@ -22477,8 +22818,8 @@ function runSpawnPolicy(root) {
 
 // src/test-policy-core.ts
 var import_node_child_process15 = require("node:child_process");
-var import_node_fs27 = require("node:fs");
-var import_node_path25 = require("node:path");
+var import_node_fs28 = require("node:fs");
+var import_node_path26 = require("node:path");
 var POLICY_FILE = "test-policy.json";
 var TEST_RE = /\.(?:test|spec)\.[cm]?[jt]sx?$/;
 var PY_TEST_RE = /(?:^|\/)test_[^/]*\.py$|_test\.py$/;
@@ -22531,7 +22872,7 @@ function isTestPath(path2) {
   return TEST_RE.test(path2) || PY_TEST_RE.test(path2);
 }
 function loadPolicy(root, readFile9 = readFileOrNull2) {
-  const raw = readFile9((0, import_node_path25.join)(root, POLICY_FILE));
+  const raw = readFile9((0, import_node_path26.join)(root, POLICY_FILE));
   if (raw == null) return { mandatory: [], declared: false };
   try {
     return { ...JSON.parse(raw), declared: true };
@@ -22541,7 +22882,7 @@ function loadPolicy(root, readFile9 = readFileOrNull2) {
 }
 function readFileOrNull2(path2) {
   try {
-    return (0, import_node_fs27.readFileSync)(path2, "utf8");
+    return (0, import_node_fs28.readFileSync)(path2, "utf8");
   } catch {
     return null;
   }
@@ -22568,12 +22909,12 @@ function classify(changed, policy, present = () => false) {
   const removedProtected = [...removed].filter((p) => protectedBy.has(p)).map((p) => ({ path: p, why: protectedBy.get(p) ?? "" }));
   return { mandatoryHits, untestedHits, testChanges, addedTests, removedProtected };
 }
-function unresolvedProtectedEntries(policy, root, exists = (path2) => (0, import_node_fs27.existsSync)(path2)) {
-  return (policy.protected ?? []).map((p) => p.path).filter((p) => !exists((0, import_node_path25.join)(root, p)));
+function unresolvedProtectedEntries(policy, root, exists = (path2) => (0, import_node_fs28.existsSync)(path2)) {
+  return (policy.protected ?? []).map((p) => p.path).filter((p) => !exists((0, import_node_path26.join)(root, p)));
 }
-function unresolvedSatisfiers(policy, root, exists = (path2) => (0, import_node_fs27.existsSync)(path2)) {
+function unresolvedSatisfiers(policy, root, exists = (path2) => (0, import_node_fs28.existsSync)(path2)) {
   const declared = (policy.mandatory ?? []).flatMap((m) => m.satisfiedBy ?? []);
-  return [...new Set(declared)].filter((p) => !exists((0, import_node_path25.join)(root, p)));
+  return [...new Set(declared)].filter((p) => !exists((0, import_node_path26.join)(root, p)));
 }
 function evaluate(changed, policy, present = () => false) {
   const { mandatoryHits, untestedHits, testChanges, addedTests, removedProtected } = classify(changed, policy, present);
@@ -22755,13 +23096,13 @@ function changedFilesSince(base, cwd) {
 }
 function runTestPolicy(root, deps = {}) {
   const policy = deps.policy ?? loadPolicy(root);
-  const exists = deps.exists ?? ((path2) => (0, import_node_fs27.existsSync)(path2));
+  const exists = deps.exists ?? ((path2) => (0, import_node_fs28.existsSync)(path2));
   const counts = { mandatoryCount: (policy.mandatory ?? []).length, protectedCount: (policy.protected ?? []).length };
   const base = deps.changed ? "(injected)" : resolveBase(root, deps.base);
   const refusal = deps.changed ? null : untrustworthyRange(root, base);
   const changed = deps.changed ?? (refusal ? [] : changedFilesSince(base, root));
   const lookup = deps.override !== void 0 ? { override: deps.override, refusals: [] } : !deps.changed && !refusal ? readOverride(base, root) : { override: null, refusals: [] };
-  const present = (path2) => exists((0, import_node_path25.join)(root, path2));
+  const present = (path2) => exists((0, import_node_path26.join)(root, path2));
   const removedByThisDiff = removedPaths(changed);
   const staleFindings = [];
   const unresolved = unresolvedProtectedEntries(policy, root, exists).filter((p) => !removedByThisDiff.has(p));
@@ -22799,8 +23140,8 @@ function runTestPolicy(root, deps = {}) {
 }
 
 // src/project-info-sync.ts
-var import_node_fs28 = require("node:fs");
-var import_node_path26 = require("node:path");
+var import_node_fs29 = require("node:fs");
+var import_node_path27 = require("node:path");
 var UPDATE_PROJECT_INFO = `mutation($projectId: ID!, $shortDescription: String!, $readme: String!) {
   updateProjectV2(input: { projectId: $projectId, shortDescription: $shortDescription, readme: $readme }) {
     projectV2 { id }
@@ -22845,14 +23186,14 @@ function sharedName(entries, fallback) {
 }
 function buildProjectInfoSyncPlan(targetRepo2, project2, projects, repoRoot2) {
   if (!project2.projectId) throw new Error(`org project sync-info: ${targetRepo2} registry META has no projectId`);
-  const readmePath = (0, import_node_path26.join)(repoRoot2, "README.md");
-  if (!(0, import_node_fs28.existsSync)(readmePath)) throw new Error(`org project sync-info: ${targetRepo2} has no README.md`);
+  const readmePath = (0, import_node_path27.join)(repoRoot2, "README.md");
+  if (!(0, import_node_fs29.existsSync)(readmePath)) throw new Error(`org project sync-info: ${targetRepo2} has no README.md`);
   const entries = entriesFor(project2, projects);
   const memberRepos = [...new Set(entries.flatMap((entry) => entry.repos ?? []))].filter((repo) => /^[^/]+\/[^/]+$/.test(repo)).sort((a, b) => a.localeCompare(b));
   const projectName = sharedName(entries, project2.name?.trim() || targetRepo2.split("/").pop() || targetRepo2);
   if (!memberRepos.length) throw new Error(`org project sync-info: project ${projectName} has no registered member repos`);
   const entryNames = entries.map((entry) => entry.name?.trim()).filter((name) => Boolean(name));
-  const shortDescription = memberRepos.length === 1 ? shortDescriptionFromReadme((0, import_node_fs28.readFileSync)(readmePath, "utf8")) : `Shared work across ${new Intl.ListFormat("en", { type: "conjunction" }).format(entryNames)}.`;
+  const shortDescription = memberRepos.length === 1 ? shortDescriptionFromReadme((0, import_node_fs29.readFileSync)(readmePath, "utf8")) : `Shared work across ${new Intl.ListFormat("en", { type: "conjunction" }).format(entryNames)}.`;
   const lines = [
     `# ${projectName}`,
     "",
@@ -22871,8 +23212,8 @@ function buildProjectInfoSyncPlan(targetRepo2, project2, projects, repoRoot2) {
   const targetBase = `https://github.com/${targetRepo2}`;
   const targetBranch = branchFor(targetRepo2, projects);
   const orgDocs = [
-    (0, import_node_fs28.existsSync)((0, import_node_path26.join)(repoRoot2, "docs", "org-readme.md")) ? `- [Org identity](${targetBase}/blob/${targetBranch}/docs/org-readme.md)` : "",
-    (0, import_node_fs28.existsSync)((0, import_node_path26.join)(repoRoot2, "docs", "org-architecture.md")) ? `- [Org architecture](${targetBase}/blob/${targetBranch}/docs/org-architecture.md)` : ""
+    (0, import_node_fs29.existsSync)((0, import_node_path27.join)(repoRoot2, "docs", "org-readme.md")) ? `- [Org identity](${targetBase}/blob/${targetBranch}/docs/org-readme.md)` : "",
+    (0, import_node_fs29.existsSync)((0, import_node_path27.join)(repoRoot2, "docs", "org-architecture.md")) ? `- [Org architecture](${targetBase}/blob/${targetBranch}/docs/org-architecture.md)` : ""
   ].filter(Boolean);
   if (orgDocs.length) lines.push("", "## Organisation docs", "", ...orgDocs);
   return { projectId: project2.projectId, projectName, targetRepo: targetRepo2, memberRepos, shortDescription, readme: `${lines.join("\n")}
@@ -23749,9 +24090,9 @@ function writeError(res) {
 }
 
 // src/secrets-commands.ts
-var import_node_fs29 = require("node:fs");
-var import_node_path27 = require("node:path");
-var import_node_os10 = require("node:os");
+var import_node_fs30 = require("node:fs");
+var import_node_path28 = require("node:path");
+var import_node_os11 = require("node:os");
 
 // src/project-runtime.ts
 function hasRuntimeSecretContract(contract) {
@@ -23874,18 +24215,18 @@ function collectMap(value, previous = []) {
   return [...previous, value];
 }
 async function decryptRailsCredentials(input) {
-  const appDir = (0, import_node_path27.resolve)(input.appDir ?? process.cwd());
+  const appDir = (0, import_node_path28.resolve)(input.appDir ?? process.cwd());
   const credentialsFile = input.credentialsFile ?? DEFAULT_RAILS_CREDENTIALS_FILE;
   const masterKeyFile = input.masterKeyFile ?? DEFAULT_RAILS_MASTER_KEY_FILE;
-  const credentialsPath = (0, import_node_path27.resolve)(appDir, credentialsFile);
-  const masterKeyPath = (0, import_node_path27.resolve)(appDir, masterKeyFile);
+  const credentialsPath = (0, import_node_path28.resolve)(appDir, credentialsFile);
+  const masterKeyPath = (0, import_node_path28.resolve)(appDir, masterKeyFile);
   const env = {
     ...process.env,
     MMI_RAILS_CREDENTIALS_FILE: credentialsPath,
     MMI_RAILS_MASTER_KEY_FILE: masterKeyPath
   };
-  if ((0, import_node_fs29.existsSync)(masterKeyPath)) {
-    env.RAILS_MASTER_KEY = (0, import_node_fs29.readFileSync)(masterKeyPath, "utf8").trim();
+  if ((0, import_node_fs30.existsSync)(masterKeyPath)) {
+    env.RAILS_MASTER_KEY = (0, import_node_fs30.readFileSync)(masterKeyPath, "utf8").trim();
   }
   const script = [
     'require "json"',
@@ -23895,9 +24236,9 @@ async function decryptRailsCredentials(input) {
     'config = ActiveSupport::EncryptedConfiguration.new(config_path: config_path, key_path: key_path, env_key: "RAILS_MASTER_KEY", raise_if_missing_key: true)',
     "puts JSON.generate(config.config)"
   ].join("\n");
-  const scriptDir = (0, import_node_fs29.mkdtempSync)((0, import_node_path27.join)((0, import_node_os10.tmpdir)(), "mmi-rails-decrypt-"));
-  const scriptPath = (0, import_node_path27.join)(scriptDir, "decrypt.rb");
-  (0, import_node_fs29.writeFileSync)(scriptPath, script, "utf8");
+  const scriptDir = (0, import_node_fs30.mkdtempSync)((0, import_node_path28.join)((0, import_node_os11.tmpdir)(), "mmi-rails-decrypt-"));
+  const scriptPath = (0, import_node_path28.join)(scriptDir, "decrypt.rb");
+  (0, import_node_fs30.writeFileSync)(scriptPath, script, "utf8");
   try {
     const args = ["exec", "ruby", scriptPath];
     const cmd = process.platform === "win32" ? "cmd.exe" : "bundle";
@@ -23909,7 +24250,7 @@ async function decryptRailsCredentials(input) {
     });
     return JSON.parse(stdout);
   } finally {
-    (0, import_node_fs29.rmSync)(scriptDir, { recursive: true, force: true });
+    (0, import_node_fs30.rmSync)(scriptDir, { recursive: true, force: true });
   }
 }
 async function readSecretStdin() {
@@ -23999,7 +24340,7 @@ function registerSecretsCommands(program3) {
     let body;
     if (o.file) {
       try {
-        body = (0, import_node_fs29.readFileSync)((0, import_node_path27.resolve)(o.file), "utf8");
+        body = (0, import_node_fs30.readFileSync)((0, import_node_path28.resolve)(o.file), "utf8");
       } catch (e) {
         return fail(`secrets org-catalog: cannot read --file ${o.file}: ${e.message}`);
       }
@@ -24104,7 +24445,7 @@ function registerSecretsCommands(program3) {
       {
         ...d,
         decryptRailsCredentials,
-        removeFile: (path2) => (0, import_node_fs29.unlinkSync)((0, import_node_path27.resolve)(o.appDir ?? process.cwd(), path2))
+        removeFile: (path2) => (0, import_node_fs30.unlinkSync)((0, import_node_path28.resolve)(o.appDir ?? process.cwd(), path2))
       },
       {
         repo: o.repo,
@@ -24268,7 +24609,7 @@ async function activateAppActor(commandPath3, env, mint) {
 }
 
 // src/box-commands.ts
-var import_node_fs30 = require("node:fs");
+var import_node_fs31 = require("node:fs");
 
 // src/box.ts
 var BOX_KEYS = {
@@ -24471,7 +24812,7 @@ function registerBoxCommands(program3) {
       }
       if (o.json) console.log(JSON.stringify({ box: found, incomplete }, null, 2));
       else if (o.ssh && o.script) {
-        (0, import_node_fs30.writeFileSync)(o.script, sshRecipeScript(found), "utf8");
+        (0, import_node_fs31.writeFileSync)(o.script, sshRecipeScript(found), "utf8");
         console.log(`wrote ${o.script} \u2014 run: bash "${o.script}"`);
       } else if (o.ssh) console.log(`${formatSshRecipe(found)}
 ${SSH_RECIPE_AGENT_NOTE}`);
@@ -25237,7 +25578,7 @@ function registerSchedulesCommands(program3) {
 
 // src/schedules-lift-command.ts
 var import_promises6 = require("node:fs/promises");
-var import_node_path28 = require("node:path");
+var import_node_path29 = require("node:path");
 
 // src/schedules-lift.ts
 var SCHEDULE_HEADER_FIELDS = ["schedule", "what", "owner", "cadence", "executor", "llm", "output", "breaks", "kill"];
@@ -25343,7 +25684,7 @@ async function readWorkflowFiles(dir) {
   const files = [];
   for (const name of names.sort()) {
     if (!/\.ya?ml$/.test(name)) continue;
-    files.push({ path: `.github/workflows/${name}`, text: await (0, import_promises6.readFile)((0, import_node_path28.join)(dir, name), "utf8") });
+    files.push({ path: `.github/workflows/${name}`, text: await (0, import_promises6.readFile)((0, import_node_path29.join)(dir, name), "utf8") });
   }
   return files;
 }
@@ -26038,9 +26379,9 @@ function registerQueryCommands(program3) {
 }
 
 // src/bootstrap-commands.ts
-var import_node_fs31 = require("node:fs");
-var import_node_os11 = require("node:os");
-var import_node_path29 = require("node:path");
+var import_node_fs32 = require("node:fs");
+var import_node_os12 = require("node:os");
+var import_node_path30 = require("node:path");
 
 // src/bootstrap-drift.ts
 var import_node_crypto6 = require("node:crypto");
@@ -26944,13 +27285,13 @@ function registerBootstrapCommands(program3) {
       client: defaultGitHubClient(),
       projectMeta: meta,
       deployModel: typeof meta?.deployModel === "string" ? meta.deployModel : void 0,
-      readLocalFile: (path2) => path2 === "projects.json" && apiProjects != null ? apiProjects : (0, import_node_fs31.existsSync)(path2) ? (0, import_node_fs31.readFileSync)(path2, "utf8") : null,
+      readLocalFile: (path2) => path2 === "projects.json" && apiProjects != null ? apiProjects : (0, import_node_fs32.existsSync)(path2) ? (0, import_node_fs32.readFileSync)(path2, "utf8") : null,
       // requiredGcpApis is stored as an array by a JSON write, but `org project set --var KEY=VALUE` stores a raw
       // comma-string — accept either so the seeded value verifies regardless of how it was written.
       // #3689: the same committed map the org access audit reads (#3664), so a sanctioned admin is not a
       // permanent bootstrap failure on one surface and an intended state on the other. Absent file → no
       // sanction, which is the pre-#3664 behaviour.
-      sanctionedAdmins: (0, import_node_fs31.existsSync)("access-matrix.json") ? entriesValueByCanonicalRepo(loadSanctionedAdmins((0, import_node_fs31.readFileSync)("access-matrix.json", "utf8")), repo) : void 0,
+      sanctionedAdmins: (0, import_node_fs32.existsSync)("access-matrix.json") ? entriesValueByCanonicalRepo(loadSanctionedAdmins((0, import_node_fs32.readFileSync)("access-matrix.json", "utf8")), repo) : void 0,
       requiredGcpApis: (() => {
         const v = meta?.requiredGcpApis;
         if (Array.isArray(v)) return v;
@@ -27003,14 +27344,14 @@ function registerBootstrapCommands(program3) {
   bootstrap.command("drift").description("#3818: compare every org-owned whole-file seed against MMI-Hub's copy across the registry roster; read-only").option("--repo <owner/repo>", "audit one repo instead of the roster (never a fleet verdict)").option("--json", "machine-readable output").action(async () => {
     const o = { repo: rawValue("--repo", ""), json: rawFlag("--json") };
     const manifestPath = "skills/bootstrap/seeds/manifest.json";
-    if (!(0, import_node_fs31.existsSync)(manifestPath)) return fail(`bootstrap drift: ${manifestPath} not found; run from the MMI-Hub repo root \u2014 the Hub's copies ARE the reference this compares against`);
+    if (!(0, import_node_fs32.existsSync)(manifestPath)) return fail(`bootstrap drift: ${manifestPath} not found; run from the MMI-Hub repo root \u2014 the Hub's copies ARE the reference this compares against`);
     const seedSource = await resolveHubSeedSource(execGitForSeedSource);
     if (!seedSource.ok) return fail(`bootstrap drift: ${seedSource.reason}`);
-    const manifest = loadBootstrapSeeds((0, import_node_fs31.readFileSync)(manifestPath, "utf8"));
+    const manifest = loadBootstrapSeeds((0, import_node_fs32.readFileSync)(manifestPath, "utf8"));
     const hubContents = /* @__PURE__ */ new Map();
     for (const s of manifest.seeds) {
       if (s.ownership !== "org" || s.source !== "self") continue;
-      hubContents.set(s.target, (0, import_node_fs31.existsSync)(s.target) ? (0, import_node_fs31.readFileSync)(s.target, "utf8") : null);
+      hubContents.set(s.target, (0, import_node_fs32.existsSync)(s.target) ? (0, import_node_fs32.readFileSync)(s.target, "utf8") : null);
     }
     let targets;
     let classOf = (_repo) => "deployable";
@@ -27089,10 +27430,10 @@ function registerBootstrapCommands(program3) {
       return fail(`bootstrap apply: ${e.message}`);
     }
     const manifestPath = "skills/bootstrap/seeds/manifest.json";
-    if (!(0, import_node_fs31.existsSync)(manifestPath)) return fail(`bootstrap apply: ${manifestPath} not found; bootstrap runs from the MMI-Hub repo root by design \u2014 it stamps org-level resources (Project, Ruleset, secrets, access) through the GitHub App, which is only authorized from the Hub checkout`);
+    if (!(0, import_node_fs32.existsSync)(manifestPath)) return fail(`bootstrap apply: ${manifestPath} not found; bootstrap runs from the MMI-Hub repo root by design \u2014 it stamps org-level resources (Project, Ruleset, secrets, access) through the GitHub App, which is only authorized from the Hub checkout`);
     const seedSource = await resolveHubSeedSource(execGitForSeedSource);
     if (!seedSource.ok) return fail(`bootstrap apply: ${seedSource.reason}`);
-    const manifest = loadBootstrapSeeds((0, import_node_fs31.readFileSync)(manifestPath, "utf8"));
+    const manifest = loadBootstrapSeeds((0, import_node_fs32.readFileSync)(manifestPath, "utf8"));
     const baseBranch = o.class === "content" ? "main" : "development";
     const slug = parsedRepo.slug;
     const onlyTarget = o.only.trim();
@@ -27103,16 +27444,16 @@ function registerBootstrapCommands(program3) {
   ${known}`);
     }
     const gh = async (args) => execFileP2("gh", args, { timeout: 2e4 });
-    const readFile9 = (p) => (0, import_node_fs31.existsSync)(p) ? (0, import_node_fs31.readFileSync)(p, "utf8") : null;
+    const readFile9 = (p) => (0, import_node_fs32.existsSync)(p) ? (0, import_node_fs32.readFileSync)(p, "utf8") : null;
     const enc = (p) => p.split("/").map(encodeURIComponent).join("/");
     const putSeed = async (target, content, ref, sha) => {
-      const tmp = (0, import_node_path29.join)((0, import_node_os11.tmpdir)(), `mmi-seed-${process.pid}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}.json`);
-      (0, import_node_fs31.writeFileSync)(tmp, JSON.stringify(contentPutBody(target, content, ref, sha)), "utf8");
+      const tmp = (0, import_node_path30.join)((0, import_node_os12.tmpdir)(), `mmi-seed-${process.pid}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}.json`);
+      (0, import_node_fs32.writeFileSync)(tmp, JSON.stringify(contentPutBody(target, content, ref, sha)), "utf8");
       try {
         await gh(contentPutInputArgs(repo, target, tmp));
       } finally {
         try {
-          (0, import_node_fs31.unlinkSync)(tmp);
+          (0, import_node_fs32.unlinkSync)(tmp);
         } catch {
         }
       }
@@ -27377,10 +27718,10 @@ LIVE apply to ${repo}:
   bootstrap.command("propagate").description("#4238: re-entrant canary\u2192wave tick \u2014 plan (or, with --execute, open) per-repo PRs fanning an org-owned seed out to the fleet").option("--target <path>", "the manifest target to propagate (an ownership:org + source:self seed, e.g. .github/workflows/agent-pr.yml)").option("--execute", "LIVE tick via gh (master-gated) \u2014 opens/reuses per-repo seed-propagate PRs; dry-run prints the plan only").option("--json", "machine-readable output").action(async () => {
     const o = { target: rawValue("--target", ""), execute: rawFlag("--execute"), json: rawFlag("--json") };
     const manifestPath = "skills/bootstrap/seeds/manifest.json";
-    if (!(0, import_node_fs31.existsSync)(manifestPath)) return fail(`bootstrap propagate: ${manifestPath} not found; run from the MMI-Hub repo root \u2014 the Hub's copies ARE the desired state this tick propagates`);
+    if (!(0, import_node_fs32.existsSync)(manifestPath)) return fail(`bootstrap propagate: ${manifestPath} not found; run from the MMI-Hub repo root \u2014 the Hub's copies ARE the desired state this tick propagates`);
     const seedSource = await resolveHubSeedSource(execGitForSeedSource);
     if (!seedSource.ok) return fail(`bootstrap propagate: ${seedSource.reason}`);
-    const manifest = loadBootstrapSeeds((0, import_node_fs31.readFileSync)(manifestPath, "utf8"));
+    const manifest = loadBootstrapSeeds((0, import_node_fs32.readFileSync)(manifestPath, "utf8"));
     const propagatable = manifest.seeds.filter((s) => s.ownership === "org" && s.source === "self");
     if (!o.target) {
       return fail(`bootstrap propagate: --target <path> is required \u2014 one of:
@@ -27389,8 +27730,8 @@ LIVE apply to ${repo}:
     const seed = propagatable.find((s) => s.target === o.target);
     if (!seed) return fail(`bootstrap propagate: --target '${o.target}' names no ownership:org + source:self seed in ${manifestPath}. Propagatable targets:
   ${propagatable.map((s) => s.target).join("\n  ")}`);
-    if (!(0, import_node_fs31.existsSync)(seed.target)) return fail(`bootstrap propagate: the Hub's own copy of '${seed.target}' is missing \u2014 nothing to propagate`);
-    const hubContent = (0, import_node_fs31.readFileSync)(seed.target, "utf8");
+    if (!(0, import_node_fs32.existsSync)(seed.target)) return fail(`bootstrap propagate: the Hub's own copy of '${seed.target}' is missing \u2014 nothing to propagate`);
+    const hubContent = (0, import_node_fs32.readFileSync)(seed.target, "utf8");
     const isWorkflowSeed = seed.target.startsWith(".github/workflows/");
     const cfg = await loadConfig();
     const projects = await fetchProjectsList(registryClientDeps(cfg));
@@ -27399,9 +27740,9 @@ LIVE apply to ${repo}:
     }
     const rosterRepos2 = collectRegistryRepos(projects).filter((r) => r.toLowerCase() !== "mutmutco/mmi-hub");
     let independentCount = rosterRepos2.length;
-    if ((0, import_node_fs31.existsSync)("projects.json")) {
+    if ((0, import_node_fs32.existsSync)("projects.json")) {
       try {
-        const local = JSON.parse((0, import_node_fs31.readFileSync)("projects.json", "utf8"));
+        const local = JSON.parse((0, import_node_fs32.readFileSync)("projects.json", "utf8"));
         const localRepos = /* @__PURE__ */ new Set();
         for (const p of local.projects ?? []) for (const r of p.repos ?? []) {
           const full = (r.includes("/") ? r : `mutmutco/${r}`).toLowerCase();
@@ -27517,13 +27858,13 @@ LIVE apply to ${repo}:
         } catch {
           existingSha = void 0;
         }
-        const tmp = (0, import_node_path29.join)((0, import_node_os11.tmpdir)(), `mmi-propagate-${process.pid}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}.json`);
-        (0, import_node_fs31.writeFileSync)(tmp, JSON.stringify(contentPutBody(seed.target, hubContent, branch, existingSha)), "utf8");
+        const tmp = (0, import_node_path30.join)((0, import_node_os12.tmpdir)(), `mmi-propagate-${process.pid}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}.json`);
+        (0, import_node_fs32.writeFileSync)(tmp, JSON.stringify(contentPutBody(seed.target, hubContent, branch, existingSha)), "utf8");
         try {
           await gh(contentPutInputArgs(rec.repo, seed.target, tmp));
         } finally {
           try {
-            (0, import_node_fs31.unlinkSync)(tmp);
+            (0, import_node_fs32.unlinkSync)(tmp);
           } catch {
           }
         }
@@ -27581,10 +27922,10 @@ Rollback: \`mmi-cli bootstrap rollback ${rec.repo} --target ${seed.target} --exe
       return fail(`bootstrap rollback: ${e.message}`);
     }
     const manifestPath = "skills/bootstrap/seeds/manifest.json";
-    if (!(0, import_node_fs31.existsSync)(manifestPath)) return fail(`bootstrap rollback: ${manifestPath} not found; run from the MMI-Hub repo root \u2014 the manifest names which targets are org-owned and therefore propagated (and rollback-able)`);
+    if (!(0, import_node_fs32.existsSync)(manifestPath)) return fail(`bootstrap rollback: ${manifestPath} not found; run from the MMI-Hub repo root \u2014 the manifest names which targets are org-owned and therefore propagated (and rollback-able)`);
     const seedSource = await resolveHubSeedSource(execGitForSeedSource);
     if (!seedSource.ok) return fail(`bootstrap rollback: ${seedSource.reason}`);
-    const manifest = loadBootstrapSeeds((0, import_node_fs31.readFileSync)(manifestPath, "utf8"));
+    const manifest = loadBootstrapSeeds((0, import_node_fs32.readFileSync)(manifestPath, "utf8"));
     const propagatable = manifest.seeds.filter((s) => s.ownership === "org" && s.source === "self");
     if (!o.target) {
       return fail(`bootstrap rollback: --target <path> is required \u2014 one of:
@@ -27601,10 +27942,10 @@ Rollback: \`mmi-cli bootstrap rollback ${rec.repo} --target ${seed.target} --exe
     const enc = (p) => p.split("/").map(encodeURIComponent).join("/");
     let candidates;
     if (o.record) {
-      if (!(0, import_node_fs31.existsSync)(o.record)) return fail(`bootstrap rollback: --record '${o.record}' not found`);
+      if (!(0, import_node_fs32.existsSync)(o.record)) return fail(`bootstrap rollback: --record '${o.record}' not found`);
       let parsed;
       try {
-        parsed = JSON.parse((0, import_node_fs31.readFileSync)(o.record, "utf8"));
+        parsed = JSON.parse((0, import_node_fs32.readFileSync)(o.record, "utf8"));
       } catch (e) {
         return fail(`bootstrap rollback: --record '${o.record}' is not valid JSON: ${e.message}`);
       }
@@ -27673,13 +28014,13 @@ Rollback: \`mmi-cli bootstrap rollback ${rec.repo} --target ${seed.target} --exe
       } catch {
         existingSha = void 0;
       }
-      const tmp = (0, import_node_path29.join)((0, import_node_os11.tmpdir)(), `mmi-rollback-${process.pid}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}.json`);
-      (0, import_node_fs31.writeFileSync)(tmp, JSON.stringify(contentPutBody(seed.target, preSeedContent, plan.branch, existingSha)), "utf8");
+      const tmp = (0, import_node_path30.join)((0, import_node_os12.tmpdir)(), `mmi-rollback-${process.pid}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}.json`);
+      (0, import_node_fs32.writeFileSync)(tmp, JSON.stringify(contentPutBody(seed.target, preSeedContent, plan.branch, existingSha)), "utf8");
       try {
         await gh(contentPutInputArgs(repo, seed.target, tmp));
       } finally {
         try {
-          (0, import_node_fs31.unlinkSync)(tmp);
+          (0, import_node_fs32.unlinkSync)(tmp);
         } catch {
         }
       }
@@ -27701,12 +28042,12 @@ Rollback: \`mmi-cli bootstrap rollback ${rec.repo} --target ${seed.target} --exe
 }
 
 // src/stage-commands.ts
-var import_node_fs33 = require("node:fs");
-var import_node_path31 = require("node:path");
+var import_node_fs34 = require("node:fs");
+var import_node_path32 = require("node:path");
 
 // src/port-registry.ts
-var import_node_fs32 = require("node:fs");
-var import_node_path30 = require("node:path");
+var import_node_fs33 = require("node:fs");
+var import_node_path31 = require("node:path");
 
 // ../infra/port-geometry.mjs
 var PORT_BLOCK = 100;
@@ -27720,8 +28061,8 @@ function nextPortBlock(registry2) {
   return [base, base + PORT_SPAN];
 }
 function loadPortRegistry(path2) {
-  if (!(0, import_node_fs32.existsSync)(path2)) return {};
-  const raw = JSON.parse((0, import_node_fs32.readFileSync)(path2, "utf8"));
+  if (!(0, import_node_fs33.existsSync)(path2)) return {};
+  const raw = JSON.parse((0, import_node_fs33.readFileSync)(path2, "utf8"));
   const out = {};
   for (const [key, value] of Object.entries(raw)) {
     if (Array.isArray(value) && value.length === 2 && value.every((n) => typeof n === "number")) {
@@ -27735,9 +28076,9 @@ function ensurePortRange(repo, path2) {
   const existing = registry2[repo];
   if (existing) return existing;
   const range = nextPortBlock(registry2);
-  const raw = (0, import_node_fs32.existsSync)(path2) ? JSON.parse((0, import_node_fs32.readFileSync)(path2, "utf8")) : {};
+  const raw = (0, import_node_fs33.existsSync)(path2) ? JSON.parse((0, import_node_fs33.readFileSync)(path2, "utf8")) : {};
   raw[repo] = range;
-  (0, import_node_fs32.writeFileSync)(path2, JSON.stringify(raw, null, 2) + "\n", "utf8");
+  (0, import_node_fs33.writeFileSync)(path2, JSON.stringify(raw, null, 2) + "\n", "utf8");
   return range;
 }
 function portCursorSeed(registry2) {
@@ -27759,22 +28100,22 @@ function existingPortRange(repo, registry2) {
   return registry2[repo] ?? null;
 }
 function portRangeInfraAt(root, source) {
-  const registryPath = (0, import_node_path30.join)(root, "infra", "port-ranges.json");
-  const ddbScriptPath = (0, import_node_path30.join)(root, "infra", "port-ddb.mjs");
-  if (!(0, import_node_fs32.existsSync)(registryPath) || !(0, import_node_fs32.existsSync)(ddbScriptPath)) return null;
+  const registryPath = (0, import_node_path31.join)(root, "infra", "port-ranges.json");
+  const ddbScriptPath = (0, import_node_path31.join)(root, "infra", "port-ddb.mjs");
+  if (!(0, import_node_fs33.existsSync)(registryPath) || !(0, import_node_fs33.existsSync)(ddbScriptPath)) return null;
   return { root, source, registryPath, ddbScriptPath };
 }
 function resolvePortRangeInfra(cwd, packageDir) {
   const direct = portRangeInfraAt(cwd, "cwd");
   if (direct) return direct;
-  for (let dir = cwd; ; dir = (0, import_node_path30.dirname)(dir)) {
-    const sibling = portRangeInfraAt((0, import_node_path30.join)(dir, "MMI-Hub"), "sibling-hub");
+  for (let dir = cwd; ; dir = (0, import_node_path31.dirname)(dir)) {
+    const sibling = portRangeInfraAt((0, import_node_path31.join)(dir, "MMI-Hub"), "sibling-hub");
     if (sibling) return sibling;
-    const parent = (0, import_node_path30.dirname)(dir);
+    const parent = (0, import_node_path31.dirname)(dir);
     if (parent === dir) break;
   }
   if (packageDir) {
-    const pkgRoot = (0, import_node_path30.join)(packageDir, "..", "..");
+    const pkgRoot = (0, import_node_path31.join)(packageDir, "..", "..");
     const pkgFrom = portRangeInfraAt(pkgRoot, "pkg-root");
     if (pkgFrom) return pkgFrom;
   }
@@ -27968,8 +28309,8 @@ function registerStageCommands(program3) {
     const portRange = portRangeMeta && typeof portRangeMeta.start === "number" && typeof portRangeMeta.end === "number" ? [portRangeMeta.start, portRangeMeta.end] : void 0;
     return decideStage({
       registry: { deployModel: project2?.deployModel, portRange, error: read.ok ? void 0 : read.error },
-      hasCompose: (0, import_node_fs33.existsSync)((0, import_node_path31.join)(process.cwd(), "docker-compose.yml")),
-      hasEnvExample: (0, import_node_fs33.existsSync)((0, import_node_path31.join)(process.cwd(), ".env.example"))
+      hasCompose: (0, import_node_fs34.existsSync)((0, import_node_path32.join)(process.cwd(), "docker-compose.yml")),
+      hasEnvExample: (0, import_node_fs34.existsSync)((0, import_node_path32.join)(process.cwd(), ".env.example"))
     });
   }
   async function fetchStageVaultEnvMerge() {
@@ -28427,10 +28768,10 @@ function registerBoardCommands(program3) {
 }
 
 // src/merge-cleanup.ts
-var import_node_fs35 = require("node:fs");
+var import_node_fs36 = require("node:fs");
 var import_promises8 = require("node:fs/promises");
-var import_node_path34 = require("node:path");
-var import_node_os13 = require("node:os");
+var import_node_path35 = require("node:path");
+var import_node_os14 = require("node:os");
 var import_node_child_process17 = require("node:child_process");
 
 // src/board-advance.ts
@@ -28517,7 +28858,7 @@ function boardAdvanceFailureMessage(result) {
 
 // src/deferred-registry-store.ts
 var import_promises7 = require("node:fs/promises");
-var import_node_path32 = require("node:path");
+var import_node_path33 = require("node:path");
 var sleep2 = (ms) => new Promise((resolve5) => setTimeout(resolve5, ms));
 async function atomicWrite(target, contents) {
   const tmp = `${target}.tmp-${process.pid}-${Math.random().toString(36).slice(2)}`;
@@ -28568,12 +28909,12 @@ function makeDeferredWorktreeStore(registryPath, lockOpts = {}) {
     },
     // Standalone atomic write — THROWS on failure (no best-effort swallow, #2846).
     write: async (entries) => {
-      await (0, import_promises7.mkdir)((0, import_node_path32.dirname)(registryPath), { recursive: true });
+      await (0, import_promises7.mkdir)((0, import_node_path33.dirname)(registryPath), { recursive: true });
       await atomicWrite(registryPath, serializeDeferredWorktrees(entries));
     },
     // Serialized read-modify-write under the repo-wide lock (#2846).
     update: async (mutate) => {
-      await (0, import_promises7.mkdir)((0, import_node_path32.dirname)(registryPath), { recursive: true });
+      await (0, import_promises7.mkdir)((0, import_node_path33.dirname)(registryPath), { recursive: true });
       const deadline = Date.now() + opts.maxWaitMs;
       for (; ; ) {
         const guard = await acquireLock(lockPath, opts, deadline);
@@ -28597,15 +28938,15 @@ function makeDeferredWorktreeStore(registryPath, lockOpts = {}) {
 }
 
 // src/jerv-cli-spawn.ts
-var import_node_fs34 = require("node:fs");
-var import_node_os12 = require("node:os");
-var import_node_path33 = require("node:path");
+var import_node_fs35 = require("node:fs");
+var import_node_os13 = require("node:os");
+var import_node_path34 = require("node:path");
 var WIN_NAMES = ["jerv-cli.cmd", "jerv-cli.exe", "jerv-cli"];
 var POSIX_NAMES = ["jerv-cli"];
-var JERV_CLI_ENTRY = (0, import_node_path33.join)("node_modules", "@jervaise", "jerv-cli", "dist", "index.cjs");
+var JERV_CLI_ENTRY = (0, import_node_path34.join)("node_modules", "@jervaise", "jerv-cli", "dist", "index.cjs");
 function pathEnvEntries(pathEnv, platform2 = process.platform) {
   if (platform2 !== "win32") {
-    return pathEnv.split(import_node_path33.delimiter).map((e) => e.trim()).filter(Boolean);
+    return pathEnv.split(import_node_path34.delimiter).map((e) => e.trim()).filter(Boolean);
   }
   if (pathEnv.includes(";")) {
     return pathEnv.split(";").map((e) => e.trim()).filter(Boolean);
@@ -28624,7 +28965,7 @@ function normalizeSpawnPathEntry(entry, platform2 = process.platform) {
   if (msys) return `${msys[1].toUpperCase()}:\\${msys[2].replace(/\//g, "\\")}`;
   return trimmed;
 }
-function jervCliCandidateDirs(env = process.env, home = (0, import_node_os12.homedir)(), platform2 = process.platform) {
+function jervCliCandidateDirs(env = process.env, home = (0, import_node_os13.homedir)(), platform2 = process.platform) {
   const seen = /* @__PURE__ */ new Set();
   const out = [];
   const push = (dir) => {
@@ -28638,35 +28979,35 @@ function jervCliCandidateDirs(env = process.env, home = (0, import_node_os12.hom
     push(normalizeSpawnPathEntry(entry, platform2));
   }
   if (platform2 === "win32") {
-    if (env.APPDATA) push((0, import_node_path33.join)(env.APPDATA, "npm"));
-    if (env.LOCALAPPDATA) push((0, import_node_path33.join)(env.LOCALAPPDATA, "npm"));
+    if (env.APPDATA) push((0, import_node_path34.join)(env.APPDATA, "npm"));
+    if (env.LOCALAPPDATA) push((0, import_node_path34.join)(env.LOCALAPPDATA, "npm"));
   } else {
-    push((0, import_node_path33.join)(home, ".local", "bin"));
+    push((0, import_node_path34.join)(home, ".local", "bin"));
   }
   return out;
 }
-function jervCliCandidatePaths(env = process.env, home = (0, import_node_os12.homedir)(), platform2 = process.platform) {
+function jervCliCandidatePaths(env = process.env, home = (0, import_node_os13.homedir)(), platform2 = process.platform) {
   const names = platform2 === "win32" ? WIN_NAMES : POSIX_NAMES;
   const out = [];
   for (const dir of jervCliCandidateDirs(env, home, platform2)) {
-    for (const name of names) out.push((0, import_node_path33.join)(dir, name));
+    for (const name of names) out.push((0, import_node_path34.join)(dir, name));
   }
   return out;
 }
-function resolveJervCliPath(env = process.env, home = (0, import_node_os12.homedir)(), platform2 = process.platform, exists = import_node_fs34.existsSync) {
+function resolveJervCliPath(env = process.env, home = (0, import_node_os13.homedir)(), platform2 = process.platform, exists = import_node_fs35.existsSync) {
   for (const candidate of jervCliCandidatePaths(env, home, platform2)) {
     if (exists(candidate)) return candidate;
   }
   return void 0;
 }
-function resolveJervCliNodeEntry(shimPath, exists = import_node_fs34.existsSync) {
-  const entry = (0, import_node_path33.join)((0, import_node_path33.dirname)(shimPath), JERV_CLI_ENTRY);
+function resolveJervCliNodeEntry(shimPath, exists = import_node_fs35.existsSync) {
+  const entry = (0, import_node_path34.join)((0, import_node_path34.dirname)(shimPath), JERV_CLI_ENTRY);
   return exists(entry) ? entry : void 0;
 }
 function jervCliExecFileArgs(args, opts = {}) {
   const platform2 = opts.platform ?? process.platform;
-  const exists = opts.exists ?? import_node_fs34.existsSync;
-  const resolved = resolveJervCliPath(opts.env ?? process.env, opts.home ?? (0, import_node_os12.homedir)(), platform2, exists);
+  const exists = opts.exists ?? import_node_fs35.existsSync;
+  const resolved = resolveJervCliPath(opts.env ?? process.env, opts.home ?? (0, import_node_os13.homedir)(), platform2, exists);
   if (resolved) {
     const entry = resolveJervCliNodeEntry(resolved, exists);
     if (entry) {
@@ -28849,12 +29190,31 @@ async function applyGcPlan(plan, remote, opts = {}) {
   );
   const repoRoot2 = (await execFileP2("git", ["rev-parse", "--show-toplevel"], { timeout: GIT_TIMEOUT_MS }).catch(() => ({ stdout: "" }))).stdout.trim() || process.cwd();
   const worktreeGitRoot = await currentRepoWorktreeGitRoot(repoRoot2);
-  const primaryRepoRoot = worktreeGitRoot ? (0, import_node_path34.dirname)((0, import_node_path34.dirname)(worktreeGitRoot)) : repoRoot2;
+  const primaryRepoRoot = worktreeGitRoot ? (0, import_node_path35.dirname)((0, import_node_path35.dirname)(worktreeGitRoot)) : repoRoot2;
   const gcActor = describeActor({ env: process.env, surface: detectSurface(process.env), cwd: process.cwd() });
   const owners = readWorktreeOwners(primaryRepoRoot);
   const removalNow = Date.now();
-  const refusesRemoval = (path2) => {
+  const activeWorkspaceRoot = resolveActiveWorkspaceRoot();
+  const deferredStore = await createDeferredWorktreeStore();
+  const activeWorkspaceDeferred = [];
+  const refusesRemoval = (path2, branch) => {
     if (!path2) return false;
+    const activeGuard = decideActiveWorkspaceGuard(path2, activeWorkspaceRoot);
+    if (activeGuard.action === "refuse") {
+      result.refused.push(activeGuard.message);
+      const owner2 = findWorktreeOwner(owners, path2);
+      recordWorktreeRemoval(primaryRepoRoot, {
+        action: "refused",
+        command: "worktree gc",
+        target: path2,
+        branch: branch ?? owner2?.branch,
+        actor: gcActor,
+        owner: owner2,
+        reason: activeGuard.message
+      });
+      activeWorkspaceDeferred.push({ path: path2, branch: branch ?? owner2?.branch ?? "(unknown)" });
+      return true;
+    }
     const owner = findWorktreeOwner(owners, path2);
     const verdict = decideWorktreeRemoval({ path: path2, owner, actor: gcActor, now: removalNow, force: opts.force });
     if (verdict.action !== "refuse") return false;
@@ -28870,9 +29230,16 @@ async function applyGcPlan(plan, remote, opts = {}) {
     });
     return true;
   };
-  const branchesToClean = plan.branches.filter((b) => !refusesRemoval(b.worktreePath));
+  const branchesToClean = plan.branches.filter((b) => !refusesRemoval(b.worktreePath, b.branch));
   const worktreeDirsToRemove = plan.worktreeDirs.filter((d) => !refusesRemoval(d.path));
-  const deferredStore = await createDeferredWorktreeStore();
+  if (deferredStore) {
+    for (const entry of activeWorkspaceDeferred) {
+      try {
+        await registerDeferredWorktree(deferredStore, { ...entry, reason: "active-workspace" });
+      } catch {
+      }
+    }
+  }
   const branchTracking = await applyBranchAndTrackingCleanup({ ...plan, branches: branchesToClean }, {
     localBranchHeads,
     cleanupBranch: async (branch, expectedHeadOid) => {
@@ -28880,7 +29247,7 @@ async function applyGcPlan(plan, remote, opts = {}) {
       const cleanup = await cleanupPrMergeLocalBranch(branch.branch, {
         beforeWorktrees,
         startingPath: branch.worktreePath,
-        pathExists: (p) => (0, import_node_fs35.existsSync)(p),
+        pathExists: (p) => (0, import_node_fs36.existsSync)(p),
         execGit: async (args) => (await execFileP2("git", args, { timeout: GIT_TIMEOUT_MS })).stdout,
         teardownWorktreeStage,
         deferredStore,
@@ -28888,7 +29255,13 @@ async function applyGcPlan(plan, remote, opts = {}) {
         detachReparsePoints: wtDeps.detachReparsePoints,
         // #3064: junction-safe teardown
         removeWorktreeDir: wtDeps.removeWorktreeDir,
-        removalContext: { primaryRoot: primaryRepoRoot, actor: gcActor, command: "worktree gc", force: opts.force }
+        removalContext: {
+          primaryRoot: primaryRepoRoot,
+          actor: gcActor,
+          command: "worktree gc",
+          force: opts.force,
+          activeWorkspaceRoot
+        }
       });
       if (cleanup.worktree?.status === "removed") await bestEffortLeaseClose(cleanup.worktree.path);
       return cleanup;
@@ -28909,7 +29282,7 @@ async function applyGcPlan(plan, remote, opts = {}) {
     let removalAttempted = false;
     try {
       const cleanupTarget = resolveSafeSiblingWorktreeCleanupTarget(wt.path, siblingRoot, {
-        realpath: (path2) => (0, import_node_fs35.realpathSync)(path2)
+        realpath: (path2) => (0, import_node_fs36.realpathSync)(path2)
       });
       if (!cleanupTarget.ok) {
         result.failed.push(`${wt.path}: ${cleanupTarget.reason}`);
@@ -28996,13 +29369,13 @@ async function composeOverrideBodyFile(prNumber, repoArgs, gh) {
     const commits = JSON.parse(raw).commits ?? [];
     const body = squashBodyWithOverride(commits.map((c) => ({ headline: c.messageHeadline ?? "", body: c.messageBody ?? "" })), process.cwd());
     if (!body) return void 0;
-    const dir = (0, import_node_fs35.mkdtempSync)((0, import_node_path34.join)((0, import_node_os13.tmpdir)(), "mmi-squash-body-"));
-    const path2 = (0, import_node_path34.join)(dir, "body.txt");
-    (0, import_node_fs35.writeFileSync)(path2, `${body}
+    const dir = (0, import_node_fs36.mkdtempSync)((0, import_node_path35.join)((0, import_node_os14.tmpdir)(), "mmi-squash-body-"));
+    const path2 = (0, import_node_path35.join)(dir, "body.txt");
+    (0, import_node_fs36.writeFileSync)(path2, `${body}
 `, "utf8");
     return { path: path2, cleanup: () => {
       try {
-        (0, import_node_fs35.rmSync)(dir, { recursive: true, force: true });
+        (0, import_node_fs36.rmSync)(dir, { recursive: true, force: true });
       } catch {
       }
     } };
@@ -29124,13 +29497,13 @@ var realWorktreeDirRemover = {
   probe: (p) => {
     let st;
     try {
-      st = (0, import_node_fs35.lstatSync)(p);
+      st = (0, import_node_fs36.lstatSync)(p);
     } catch {
       return null;
     }
     if (st.isSymbolicLink()) return "link";
     try {
-      (0, import_node_fs35.readlinkSync)(p);
+      (0, import_node_fs36.readlinkSync)(p);
       return "link";
     } catch {
     }
@@ -29138,7 +29511,7 @@ var realWorktreeDirRemover = {
   },
   readdir: (p) => {
     try {
-      return (0, import_node_fs35.readdirSync)(p);
+      return (0, import_node_fs36.readdirSync)(p);
     } catch {
       return [];
     }
@@ -29147,9 +29520,9 @@ var realWorktreeDirRemover = {
   // leaving the target); a file symlink with unlink. rmdir first, fall back to unlink.
   detachLink: (p) => {
     try {
-      (0, import_node_fs35.rmdirSync)(p);
+      (0, import_node_fs36.rmdirSync)(p);
     } catch {
-      (0, import_node_fs35.unlinkSync)(p);
+      (0, import_node_fs36.unlinkSync)(p);
     }
   },
   removeTree: (p) => (0, import_promises8.rm)(p, { recursive: true, force: true, maxRetries: 5, retryDelay: 200 })
@@ -29182,11 +29555,11 @@ async function worktreeHasStageState(worktreePath) {
   }
 }
 function stageStateFileBelongsToWorktree(statePath, worktreePath) {
-  if (!(0, import_node_fs35.existsSync)(statePath)) return false;
+  if (!(0, import_node_fs36.existsSync)(statePath)) return false;
   try {
-    const state = JSON.parse((0, import_node_fs35.readFileSync)(statePath, "utf8"));
+    const state = JSON.parse((0, import_node_fs36.readFileSync)(statePath, "utf8"));
     const recordedCwd = typeof state.identity?.cwd === "string" ? state.identity.cwd : typeof state.cwd === "string" ? state.cwd : "";
-    return Boolean(recordedCwd && isPathUnderDirectory(recordedCwd, worktreePath));
+    return Boolean(recordedCwd && isPathUnderDirectory2(recordedCwd, worktreePath));
   } catch {
     return false;
   }
@@ -29566,9 +29939,9 @@ async function checkDocsIndexAtHead(opts, deps) {
 }
 
 // src/worktree-lifecycle-commands.ts
-var import_node_fs36 = require("node:fs");
+var import_node_fs37 = require("node:fs");
 var import_promises9 = require("node:fs/promises");
-var import_node_path35 = require("node:path");
+var import_node_path36 = require("node:path");
 var GH_TIMEOUT_MS = 2e4;
 var STALE_PR_LOOKUP_LIMIT = 20;
 var DEFAULT_BASE = "origin/development";
@@ -29715,7 +30088,7 @@ function classifyStaleLeaks(input) {
 var defaultOrphanDirScanDeps = {
   listDirs: (root) => {
     try {
-      return (0, import_node_fs36.readdirSync)(root, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => (0, import_node_path35.join)(root, e.name));
+      return (0, import_node_fs37.readdirSync)(root, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => (0, import_node_path36.join)(root, e.name));
     } catch {
       return [];
     }
@@ -29871,13 +30244,13 @@ function registerWorktreeCommands(program3) {
       const detached = headBorn && !symbolicBranch;
       const branch = symbolicBranch || (detached ? "HEAD" : "");
       if (!wtPath || !branch) return fail("worktree land: not inside a git worktree");
-      const gitFile = (0, import_node_path35.join)(wtPath, ".git");
-      const isLinked = (0, import_node_fs36.existsSync)(gitFile) && (0, import_node_fs36.statSync)(gitFile).isFile();
+      const gitFile = (0, import_node_path36.join)(wtPath, ".git");
+      const isLinked = (0, import_node_fs37.existsSync)(gitFile) && (0, import_node_fs37.statSync)(gitFile).isFile();
       if (apply && !isLinked) {
         return fail("worktree land: run from inside the linked worktree you want to land (this is the primary checkout)");
       }
       const commonDir = (await execFileP2("git", ["rev-parse", "--git-common-dir"], { timeout: GIT_TIMEOUT_MS }).catch(() => ({ stdout: "" }))).stdout.trim();
-      const primaryCheckout = commonDir ? (0, import_node_path35.dirname)(commonDir) : wtPath;
+      const primaryCheckout = commonDir ? (0, import_node_path36.dirname)(commonDir) : wtPath;
       const localBranchNames = await execFileP2("git", ["-C", primaryCheckout, "for-each-ref", "--format=%(refname:short)", "refs/heads"], { timeout: GIT_TIMEOUT_MS }).then(({ stdout }) => new Set((stdout || "").split("\n").map((l) => l.trim()).filter(Boolean))).catch(() => void 0);
       const orphan = classifyOrphanedWorktree({
         branch,
@@ -29940,6 +30313,47 @@ function registerWorktreeCommands(program3) {
       if (landRefs.action === "keep-remote") console.warn(`worktree land: ${landRefs.message}.`);
       const reportedMergeState = treeOnly ? "not-checked" : mergeVerdict.state;
       const landOwner = lookupWorktreeOwner(primaryCheckout, wtPath);
+      const activeWorkspaceRoot = resolveActiveWorkspaceRoot();
+      const activeGuard = decideActiveWorkspaceGuard(wtPath, activeWorkspaceRoot);
+      if (activeGuard.action === "refuse") {
+        const deferredStore = await createDeferredWorktreeStore();
+        if (deferredStore) {
+          await registerDeferredWorktree(deferredStore, {
+            path: toNativePath(wtPath),
+            branch,
+            reason: "active-workspace"
+          }).catch(() => void 0);
+        }
+        const landActor2 = describeActor({ env: process.env, surface: detectSurface(process.env), cwd: wtPath });
+        appendWorktreeEvent(primaryCheckout, {
+          action: "refused",
+          command: "worktree land",
+          target: toNativePath(wtPath),
+          branch,
+          actor: landActor2,
+          owner: landOwner ? { createdAt: landOwner.createdAt, lastSeenAt: landOwner.lastSeenAt, actor: landOwner.actor } : void 0,
+          reason: activeGuard.message
+        });
+        const result2 = {
+          dryRun: false,
+          ...plan,
+          ...o.keepRemote ? { keepRemote: true } : {},
+          mergeState: reportedMergeState,
+          prNumbers: mergeVerdict.numbers,
+          cleanupState: "deferred",
+          report: [
+            { step: "remove worktree", status: `deferred: ${activeGuard.message}` },
+            { step: "delete branch refs", status: "skipped: active Cursor workspace \u2014 open the primary checkout first" }
+          ]
+        };
+        if (o.json) console.log(JSON.stringify(result2, null, 2));
+        else {
+          console.error(`worktree land: ${activeGuard.message}`);
+          for (const row of result2.report) console.log(`  ${row.step}: ${row.status}`);
+        }
+        process.exitCode = 1;
+        return;
+      }
       const report = [];
       if (hasStage) {
         try {
@@ -30086,10 +30500,10 @@ async function gatherWorktreeContext() {
     if (s) stages.push({ path: wt.path, port: s.port });
   }
   const worktreeGitRoot = await currentRepoWorktreeGitRoot(repoRoot2);
-  const primaryRepoRoot = worktreeGitRoot ? (0, import_node_path35.dirname)((0, import_node_path35.dirname)(worktreeGitRoot)) : repoRoot2;
+  const primaryRepoRoot = worktreeGitRoot ? (0, import_node_path36.dirname)((0, import_node_path36.dirname)(worktreeGitRoot)) : repoRoot2;
   const wtRoot = siblingMmiWorktreesRoot(primaryRepoRoot);
   let orphanDirs = [];
-  if ((0, import_node_fs36.existsSync)(wtRoot)) {
+  if ((0, import_node_fs37.existsSync)(wtRoot)) {
     orphanDirs = scanOrphanDirs(wtRoot, worktreeGitRoot, {
       ...defaultOrphanDirScanDeps,
       listDirs: (root) => worktreeScanDirs(root, primaryRepoRoot, defaultOrphanDirScanDeps.listDirs, isRepoCheckoutDir)
@@ -30115,7 +30529,7 @@ ${err.stderr ?? ""}`;
 }
 
 // src/issue-commands.ts
-var import_node_fs37 = require("node:fs");
+var import_node_fs38 = require("node:fs");
 var import_node_crypto7 = require("node:crypto");
 var ghRunner = async (args, timeoutMs) => (await execFileP2("gh", args, { timeout: timeoutMs })).stdout;
 var ReparentConflictError = class extends Error {
@@ -30133,7 +30547,7 @@ async function editIssue(client, options, deps = {}) {
   const url = `https://github.com/${repo}/issues/${parsed.number}`;
   const patch = {};
   let bodyChanged = false;
-  const textDeps = () => deps.textDeps ?? { readFile: (p, e) => Promise.resolve((0, import_node_fs37.readFileSync)(p, e)), readStdin: () => Promise.resolve("") };
+  const textDeps = () => deps.textDeps ?? { readFile: (p, e) => Promise.resolve((0, import_node_fs38.readFileSync)(p, e)), readStdin: () => Promise.resolve("") };
   if (options.titleFile !== void 0) {
     patch.title = await resolveIssueTitle({ title: options.title, titleFile: options.titleFile }, textDeps());
   } else if (options.title !== void 0) {
@@ -30738,7 +31152,7 @@ function extendCreateCommand(issue2, batchAttach) {
     if (opts.batch) {
       let specs;
       try {
-        const raw = (0, import_node_fs37.readFileSync)(opts.batch, "utf8");
+        const raw = (0, import_node_fs38.readFileSync)(opts.batch, "utf8");
         specs = JSON.parse(raw);
         if (!Array.isArray(specs)) throw new Error("batch file must contain a JSON array");
       } catch (e) {
@@ -30813,8 +31227,8 @@ ${lines}`, {
 }
 
 // src/train-commands.ts
-var import_node_fs38 = require("node:fs");
-var import_node_path36 = require("node:path");
+var import_node_fs39 = require("node:fs");
+var import_node_path37 = require("node:path");
 
 // src/train-status.ts
 function buildTrainStatusReport(input) {
@@ -30854,7 +31268,7 @@ function formatTrainStatus(r) {
 // src/train-commands.ts
 function readRepoVersion() {
   try {
-    return JSON.parse((0, import_node_fs38.readFileSync)((0, import_node_path36.join)(process.cwd(), ".claude-plugin", "plugin.json"), "utf8")).version || void 0;
+    return JSON.parse((0, import_node_fs39.readFileSync)((0, import_node_path37.join)(process.cwd(), ".claude-plugin", "plugin.json"), "utf8")).version || void 0;
   } catch {
     return void 0;
   }
@@ -31000,9 +31414,9 @@ function registerDeployCommands(program3) {
 }
 
 // src/discovery-commands.ts
-var import_node_fs39 = require("node:fs");
-var import_node_os14 = require("node:os");
-var import_node_path37 = require("node:path");
+var import_node_fs40 = require("node:fs");
+var import_node_os15 = require("node:os");
+var import_node_path38 = require("node:path");
 var GC_GH_TIMEOUT_MS3 = 2e4;
 async function collectStatus() {
   const repo = await resolveRepo();
@@ -31190,10 +31604,10 @@ async function collectOnboardStatus(opts = {}) {
     else if (top) nextCommand = `mmi-cli board claim ${top.number}  # ${top.title}`;
     else nextCommand = "mmi-cli board read \u2014 no claimable items found";
   }
-  const home = (0, import_node_os14.homedir)();
+  const home = (0, import_node_os15.homedir)();
   const plugin = onboardPluginGate({
-    readKnown: () => readFileSyncSafe((0, import_node_path37.join)(home, ...KNOWN_MARKETPLACES_RELATIVE), import_node_fs39.readFileSync),
-    readSettings: () => readFileSyncSafe((0, import_node_path37.join)(home, ".claude", "settings.json"), import_node_fs39.readFileSync)
+    readKnown: () => readFileSyncSafe((0, import_node_path38.join)(home, ...KNOWN_MARKETPLACES_RELATIVE), import_node_fs40.readFileSync),
+    readSettings: () => readFileSyncSafe((0, import_node_path38.join)(home, ".claude", "settings.json"), import_node_fs40.readFileSync)
   });
   return { track, board, registry: registry2, secrets, plugin, estateCli, nextCommand };
 }
@@ -32097,19 +32511,19 @@ function registerSessionReport(program3) {
 }
 
 // src/plugin-release-catchup.ts
-var import_node_fs40 = require("node:fs");
-var import_node_path38 = require("node:path");
-var import_node_os15 = require("node:os");
+var import_node_fs41 = require("node:fs");
+var import_node_path39 = require("node:path");
+var import_node_os16 = require("node:os");
 var RELEASE_CATCHUP_TTL_MS = 24 * 60 * 60 * 1e3;
 var RELEASE_CATCHUP_DISABLE_ENV = "MMI_NO_RELEASE_CATCHUP";
 function releaseCatchupStatePath(env = process.env) {
   if (env.MMI_RELEASE_CATCHUP_STATE) return env.MMI_RELEASE_CATCHUP_STATE;
   if (process.platform === "win32") {
-    const base2 = env.LOCALAPPDATA || (0, import_node_path38.join)((0, import_node_os15.homedir)(), "AppData", "Local");
-    return (0, import_node_path38.join)(base2, "MMI Future", "mmi-cli", "release-catchup.json");
+    const base2 = env.LOCALAPPDATA || (0, import_node_path39.join)((0, import_node_os16.homedir)(), "AppData", "Local");
+    return (0, import_node_path39.join)(base2, "MMI Future", "mmi-cli", "release-catchup.json");
   }
-  const base = env.XDG_STATE_HOME || (0, import_node_path38.join)((0, import_node_os15.homedir)(), ".local", "state");
-  return (0, import_node_path38.join)(base, "mmi-cli", "release-catchup.json");
+  const base = env.XDG_STATE_HOME || (0, import_node_path39.join)((0, import_node_os16.homedir)(), ".local", "state");
+  return (0, import_node_path39.join)(base, "mmi-cli", "release-catchup.json");
 }
 function releaseCatchupDue(state, now, force = false) {
   if (force) return true;
@@ -32119,7 +32533,7 @@ function releaseCatchupDue(state, now, force = false) {
 function newestCachedPluginVersion(home) {
   let names;
   try {
-    names = (0, import_node_fs40.readdirSync)(pluginCacheRoot(home));
+    names = (0, import_node_fs41.readdirSync)(pluginCacheRoot(home));
   } catch {
     return void 0;
   }
@@ -32127,15 +32541,15 @@ function newestCachedPluginVersion(home) {
 }
 function marketplaceClonePath(home) {
   try {
-    const parsed = JSON.parse((0, import_node_fs40.readFileSync)((0, import_node_path38.join)(home, ".claude", "plugins", "known_marketplaces.json"), "utf8"));
+    const parsed = JSON.parse((0, import_node_fs41.readFileSync)((0, import_node_path39.join)(home, ".claude", "plugins", "known_marketplaces.json"), "utf8"));
     if (parsed.mutmutco?.installLocation) return parsed.mutmutco.installLocation;
   } catch {
   }
-  return (0, import_node_path38.join)(home, ".claude", "plugins", "marketplaces", "mutmutco");
+  return (0, import_node_path39.join)(home, ".claude", "plugins", "marketplaces", "mutmutco");
 }
 function readCatalogVersion(home) {
   try {
-    const parsed = JSON.parse((0, import_node_fs40.readFileSync)((0, import_node_path38.join)(marketplaceClonePath(home), ".claude-plugin", "marketplace.json"), "utf8"));
+    const parsed = JSON.parse((0, import_node_fs41.readFileSync)((0, import_node_path39.join)(marketplaceClonePath(home), ".claude-plugin", "marketplace.json"), "utf8"));
     return parsed.plugins?.find((p) => p.name === "mmi")?.version;
   } catch {
     return void 0;
@@ -32143,7 +32557,7 @@ function readCatalogVersion(home) {
 }
 function readMmiInstallRecord(home) {
   try {
-    const parsed = JSON.parse((0, import_node_fs40.readFileSync)((0, import_node_path38.join)(home, ".claude", "plugins", "installed_plugins.json"), "utf8"));
+    const parsed = JSON.parse((0, import_node_fs41.readFileSync)((0, import_node_path39.join)(home, ".claude", "plugins", "installed_plugins.json"), "utf8"));
     const record = parsed.plugins?.["mmi@mutmutco"]?.[0];
     return record?.version ? { version: record.version, gitCommitSha: record.gitCommitSha } : void 0;
   } catch {
@@ -32152,7 +32566,7 @@ function readMmiInstallRecord(home) {
 }
 async function runReleaseCatchup(home, env, deps, opts = {}) {
   if (env[RELEASE_CATCHUP_DISABLE_ENV]) return { ok: true, skipped: true, detail: `disabled via ${RELEASE_CATCHUP_DISABLE_ENV}` };
-  if (!(0, import_node_fs40.existsSync)(pluginCacheRoot(home))) return { ok: true, skipped: true, detail: "no mmi plugin cache on this machine \u2014 nothing to catch up" };
+  if (!(0, import_node_fs41.existsSync)(pluginCacheRoot(home))) return { ok: true, skipped: true, detail: "no mmi plugin cache on this machine \u2014 nothing to catch up" };
   const statePath = releaseCatchupStatePath(env);
   const state = deps.readState(statePath);
   if (!releaseCatchupDue(state, deps.now(), opts.force)) {
@@ -32177,8 +32591,8 @@ async function runReleaseCatchup(home, env, deps, opts = {}) {
     return { ok: false, detail: `released ${latest} but the install record could not be cleared \u2014 nothing changed (record still ${prior.version})` };
   }
   const installed = await deps.runClaude(["plugin", "install", "mmi@mutmutco"], "claude plugin install mmi@mutmutco");
-  const payload = (0, import_node_path38.join)(pluginCacheRoot(home), latest, ".pi-plugin");
-  if (!installed || !(0, import_node_fs40.existsSync)(payload)) {
+  const payload = (0, import_node_path39.join)(pluginCacheRoot(home), latest, ".pi-plugin");
+  if (!installed || !(0, import_node_fs41.existsSync)(payload)) {
     const why = installed ? `install of ${latest} did not produce a verifiable .pi-plugin payload` : `install of ${latest} failed`;
     if (!prior) return { ok: false, detail: `${why}; no prior record to restore` };
     const rollback = await restorePriorRecord(home, prior, deps);
@@ -32206,7 +32620,7 @@ async function restorePriorRecord(home, prior, deps) {
 }
 function shouldSpawnReleaseCatchup(home, env, readState2, now = Date.now()) {
   if (env[RELEASE_CATCHUP_DISABLE_ENV]) return false;
-  if (!(0, import_node_fs40.existsSync)(pluginCacheRoot(home))) return false;
+  if (!(0, import_node_fs41.existsSync)(pluginCacheRoot(home))) return false;
   return releaseCatchupDue(readState2(releaseCatchupStatePath(env)), now);
 }
 function defaultRegistrationHeal(home, env) {
@@ -34252,17 +34666,17 @@ function parseOriginRepo(remoteUrl) {
 }
 function ghHostsConfigPath(env, platform2) {
   const sep3 = platform2 === "win32" ? "\\" : "/";
-  const join36 = (...parts) => parts.join(sep3);
+  const join37 = (...parts) => parts.join(sep3);
   const explicit = env.GH_CONFIG_DIR?.trim();
-  if (explicit) return join36(explicit, "hosts.yml");
+  if (explicit) return join37(explicit, "hosts.yml");
   if (platform2 === "win32") {
     const appData = (env.AppData ?? env.APPDATA)?.trim();
-    return appData ? join36(appData, "GitHub CLI", "hosts.yml") : void 0;
+    return appData ? join37(appData, "GitHub CLI", "hosts.yml") : void 0;
   }
   const xdg = env.XDG_CONFIG_HOME?.trim();
-  if (xdg) return join36(xdg, "gh", "hosts.yml");
+  if (xdg) return join37(xdg, "gh", "hosts.yml");
   const home = env.HOME?.trim();
-  return home ? join36(home, ".config", "gh", "hosts.yml") : void 0;
+  return home ? join37(home, ".config", "gh", "hosts.yml") : void 0;
 }
 function parseGhHostsAccounts(yaml, host = "github.com") {
   let hostIndent = null;
@@ -34312,9 +34726,9 @@ function ghAccountCaveat(announcedLogin, accounts) {
 }
 
 // src/doctor-io.ts
-var import_node_fs41 = require("node:fs");
-var import_node_os16 = require("node:os");
-var import_node_path39 = require("node:path");
+var import_node_fs42 = require("node:fs");
+var import_node_os17 = require("node:os");
+var import_node_path40 = require("node:path");
 var import_node_child_process18 = require("node:child_process");
 var import_node_util8 = require("node:util");
 var execFileP6 = (0, import_node_util8.promisify)(import_node_child_process18.execFile);
@@ -34322,7 +34736,7 @@ var MMI_PLUGIN_ID2 = "mmi@mutmutco";
 function installedClaudePluginVersion() {
   try {
     const file = JSON.parse(
-      (0, import_node_fs41.readFileSync)((0, import_node_path39.join)((0, import_node_os16.homedir)(), ".claude", "plugins", "installed_plugins.json"), "utf8")
+      (0, import_node_fs42.readFileSync)((0, import_node_path40.join)((0, import_node_os17.homedir)(), ".claude", "plugins", "installed_plugins.json"), "utf8")
     );
     const versions = (file.plugins?.[MMI_PLUGIN_ID2] ?? []).map((r) => r.version).filter((v) => Boolean(v));
     if (versions.length === 0) return void 0;
@@ -34333,7 +34747,7 @@ function installedClaudePluginVersion() {
 }
 function manifestVersion(path2) {
   try {
-    const manifest = JSON.parse((0, import_node_fs41.readFileSync)(path2, "utf8"));
+    const manifest = JSON.parse((0, import_node_fs42.readFileSync)(path2, "utf8"));
     return typeof manifest.version === "string" && manifest.version.trim() ? manifest.version.trim() : void 0;
   } catch {
     return void 0;
@@ -34343,22 +34757,22 @@ function installedSurfacePluginVersion(surface) {
   const token = surfaceToken(surface);
   if (token === "kilo") {
     try {
-      const stamp = (0, import_node_fs41.readFileSync)((0, import_node_path39.join)((0, import_node_os16.homedir)(), ".kilo", ".mmi-kilo-version"), "utf8").trim();
+      const stamp = (0, import_node_fs42.readFileSync)((0, import_node_path40.join)((0, import_node_os17.homedir)(), ".kilo", ".mmi-kilo-version"), "utf8").trim();
       return stamp || void 0;
     } catch {
       return void 0;
     }
   }
   if (token === "cursor") {
-    return manifestVersion((0, import_node_path39.join)(cursorLocalPluginRoot(), ".cursor-plugin", "plugin.json"));
+    return manifestVersion((0, import_node_path40.join)(cursorLocalPluginRoot(), ".cursor-plugin", "plugin.json"));
   }
   if (token === "jervcode") {
     const entry = mmiPiWrapperEntry();
     if (!entry) return void 0;
-    return manifestVersion((0, import_node_path39.join)(decodeURIComponent(entry.replace(/^file:\/\/\/?/, "")), "package.json"));
+    return manifestVersion((0, import_node_path40.join)(decodeURIComponent(entry.replace(/^file:\/\/\/?/, "")), "package.json"));
   }
   if (token === "kimi") {
-    return manifestVersion((0, import_node_path39.join)(surfaceConfigRoot(surface), "plugins", "managed", "mmi", ".kimi-plugin", "plugin.json"));
+    return manifestVersion((0, import_node_path40.join)(surfaceConfigRoot(surface), "plugins", "managed", "mmi", ".kimi-plugin", "plugin.json"));
   }
   if (token === "claude") return installedClaudePluginVersion();
   if (token !== "codex") return void 0;
@@ -34396,13 +34810,13 @@ function worktreeRootSync() {
 }
 var gitignorePath = () => {
   const root = worktreeRootSync();
-  return root === null ? null : (0, import_node_path39.join)(root, ".gitignore");
+  return root === null ? null : (0, import_node_path40.join)(root, ".gitignore");
 };
 function readGitignore() {
   const path2 = gitignorePath();
   if (path2 === null) return null;
   try {
-    return (0, import_node_fs41.readFileSync)(path2, "utf8");
+    return (0, import_node_fs42.readFileSync)(path2, "utf8");
   } catch {
     return null;
   }
@@ -34411,7 +34825,7 @@ function writeGitignore(content) {
   const path2 = gitignorePath();
   if (path2 === null) return false;
   try {
-    (0, import_node_fs41.writeFileSync)(path2, content, "utf8");
+    (0, import_node_fs42.writeFileSync)(path2, content, "utf8");
     return true;
   } catch {
     return false;
@@ -34435,7 +34849,7 @@ async function repoRoot() {
 }
 function hasRepoLocalWorktrees() {
   const root = worktreeRootSync();
-  return root !== null && (0, import_node_fs41.existsSync)((0, import_node_path39.join)(root, ".worktrees"));
+  return root !== null && (0, import_node_fs42.existsSync)((0, import_node_path40.join)(root, ".worktrees"));
 }
 
 // src/index.ts
@@ -34454,8 +34868,8 @@ ${r.stderr ?? ""}`).catch(() => "");
 function ghMultiAccountCaveat(announcedLogin) {
   try {
     const hostsPath = ghHostsConfigPath(process.env, process.platform);
-    if (!hostsPath || !(0, import_node_fs42.existsSync)(hostsPath)) return void 0;
-    return ghAccountCaveat(announcedLogin, parseGhHostsAccounts((0, import_node_fs42.readFileSync)(hostsPath, "utf8")));
+    if (!hostsPath || !(0, import_node_fs43.existsSync)(hostsPath)) return void 0;
+    return ghAccountCaveat(announcedLogin, parseGhHostsAccounts((0, import_node_fs43.readFileSync)(hostsPath, "utf8")));
   } catch {
     return void 0;
   }
@@ -34463,12 +34877,12 @@ function ghMultiAccountCaveat(announcedLogin) {
 var ENV_HEAL_LOCK_STALE_MS = 10 * 6e4;
 var ENV_HEAL_LOCK_MAX_WAIT_MS = 2 * 6e4;
 function envHealLockPath(home) {
-  return (0, import_node_path40.join)(home, ".claude", "plugins", ".mmi-env-heal.lock");
+  return (0, import_node_path41.join)(home, ".claude", "plugins", ".mmi-env-heal.lock");
 }
 async function withEnvHealLock(what, run) {
   try {
     return await withFileLock(
-      envHealLockPath((0, import_node_os17.homedir)()),
+      envHealLockPath((0, import_node_os18.homedir)()),
       { staleMs: ENV_HEAL_LOCK_STALE_MS, maxWaitMs: ENV_HEAL_LOCK_MAX_WAIT_MS, label: "mmi env-heal lock" },
       run
     );
@@ -34565,7 +34979,7 @@ function mmiDoctorDeps(opts = {}) {
       const configRoot = surfaceConfigRoot(surface);
       const running = surface === "codex" ? installedActivePluginVersion(surface) : runningPluginVersion(process.env, resolveClientVersion());
       const plan = buildPluginCachePlan(
-        (0, import_node_os17.homedir)(),
+        (0, import_node_os18.homedir)(),
         running,
         pluginCacheFsDeps(configRoot, () => 0),
         { configRoot, includeStaging: surface !== "codex" }
@@ -34589,14 +35003,14 @@ function mmiDoctorDeps(opts = {}) {
       const running = surface === "codex" ? installedActivePluginVersion(surface) : runningPluginVersion(process.env, resolveClientVersion());
       const installed = installedActivePluginVersion(surface);
       const plan = buildPluginCachePlan(
-        (0, import_node_os17.homedir)(),
+        (0, import_node_os18.homedir)(),
         running,
         pluginCacheFsDeps(configRoot, () => 0),
         { configRoot, includeStaging: surface !== "codex", installedVersion: installed }
       );
       const result = applyPluginCachePlan(
         plan,
-        (p) => (0, import_node_fs42.rmSync)(p, { recursive: true }),
+        (p) => (0, import_node_fs43.rmSync)(p, { recursive: true }),
         stagingApplyFsGuard(configRoot)
       );
       return {
@@ -34624,12 +35038,12 @@ function mmiDoctorDeps(opts = {}) {
     piPluginState: () => {
       const env = { ...process.env };
       delete env.CLAUDE_PLUGIN_ROOT;
-      return readPiPluginState((0, import_node_os17.homedir)(), env);
+      return readPiPluginState((0, import_node_os18.homedir)(), env);
     },
     healPiPlugin: () => {
       const env = { ...process.env };
       delete env.CLAUDE_PLUGIN_ROOT;
-      return healPiPluginRegistration((0, import_node_os17.homedir)(), env);
+      return healPiPluginRegistration((0, import_node_os18.homedir)(), env);
     },
     // #3470: what the SessionStart hook LAST emitted, measured at emission by the session-start verb below.
     // A local record read ? cheap enough for every lane, including the banner.
@@ -34639,17 +35053,17 @@ function mmiDoctorDeps(opts = {}) {
     marketplaceRows: () => {
       try {
         if (detectSurface(process.env) === "codex") return [];
-        const home = (0, import_node_os17.homedir)();
+        const home = (0, import_node_os18.homedir)();
         const rows = marketplaceRows(
           MMI_MARKETPLACE_NAME,
-          readFileSyncSafe((0, import_node_path40.join)(home, ...KNOWN_MARKETPLACES_RELATIVE), import_node_fs42.readFileSync),
-          readFileSyncSafe((0, import_node_path40.join)(home, ".claude", "settings.json"), import_node_fs42.readFileSync),
+          readFileSyncSafe((0, import_node_path41.join)(home, ...KNOWN_MARKETPLACES_RELATIVE), import_node_fs43.readFileSync),
+          readFileSyncSafe((0, import_node_path41.join)(home, ".claude", "settings.json"), import_node_fs43.readFileSync),
           // #3974: this CLI heals these rows, so report mode names the doctor run rather than the hand
           // edit. Unconditional ? it is a fact about mmi-cli, not about the lane this run is on.
           true
         );
         const pending = readMarketplacePinPending(
-          (0, import_node_path40.join)(home, ".claude", "plugins", ".mmi-marketplace-pin-pending.json"),
+          (0, import_node_path41.join)(home, ".claude", "plugins", ".mmi-marketplace-pin-pending.json"),
           MMI_MARKETPLACE_NAME
         );
         if (!pending) return rows;
@@ -34673,11 +35087,11 @@ function mmiDoctorDeps(opts = {}) {
     healMarketplacePins: () => {
       try {
         if (detectSurface(process.env) === "codex") return void 0;
-        const home = (0, import_node_os17.homedir)();
+        const home = (0, import_node_os18.homedir)();
         const names = [MMI_MARKETPLACE_NAME];
-        const result = applyOrgMarketplacePins((0, import_node_path40.join)(home, ...KNOWN_MARKETPLACES_RELATIVE), names);
+        const result = applyOrgMarketplacePins((0, import_node_path41.join)(home, ...KNOWN_MARKETPLACES_RELATIVE), names);
         if (result?.wrote) {
-          writeMarketplacePinPending((0, import_node_path40.join)(home, ".claude", "plugins", ".mmi-marketplace-pin-pending.json"), names);
+          writeMarketplacePinPending((0, import_node_path41.join)(home, ".claude", "plugins", ".mmi-marketplace-pin-pending.json"), names);
         }
         return result;
       } catch {
@@ -34693,7 +35107,7 @@ function mmiDoctorDeps(opts = {}) {
     // adopted the generated routing index (MMG-Unlive: `docs/Archive/**` only, no index, no gate.yml) would
     // get a permanent ? demanding an artifact it never asked for.
     docsIndexState: (root) => {
-      if (!(0, import_node_fs42.existsSync)((0, import_node_path40.join)(root, DOCS_INDEX_PATH))) return void 0;
+      if (!(0, import_node_fs43.existsSync)((0, import_node_path41.join)(root, DOCS_INDEX_PATH))) return void 0;
       const real = createDocsIndexDeps(root);
       let docs2;
       const listDocs = () => docs2 ??= real.listDocs();
@@ -34702,7 +35116,7 @@ function mmiDoctorDeps(opts = {}) {
     },
     // #4168: working-tree heal — write if drifted, then re-check. Commit remains the operator's step.
     healDocsIndex: (root) => {
-      if (!(0, import_node_fs42.existsSync)((0, import_node_path40.join)(root, DOCS_INDEX_PATH))) return { drift: false, docCount: 0 };
+      if (!(0, import_node_fs43.existsSync)((0, import_node_path41.join)(root, DOCS_INDEX_PATH))) return { drift: false, docCount: 0 };
       const real = createDocsIndexDeps(root);
       let docs2;
       const listDocs = () => docs2 ??= real.listDocs();
@@ -35006,6 +35420,14 @@ function envelopeAwareWriteErr(str) {
 }
 var program2 = new Command();
 program2.name("mmi-cli").description("MMI Future Hub CLI ? the org control plane for agentic coding.").version(resolveClientVersion()).configureOutput({ writeErr: envelopeAwareWriteErr }).showHelpAfterError(PARSE_HINT_SENTINEL);
+program2.addHelpText(
+  "before",
+  `Houses (canonical roots): oracle \xB7 harbour \xB7 devops \xB7 vault \xB7 learning
+  \`mmi-cli <house> <command> \u2026\` is the canonical form; the flat \`mmi-cli <command> \u2026\` paths below
+  are compatibility shims that die in ${COMPAT_SHIM_DEATH_WAVE} (#4316). \`mmi-cli commands\` shows the
+  house-shaped tree; \`mmi-cli <house> --help\` lists one house.
+`
+);
 function appActorDeps() {
   return {
     fetchSecret: async (key) => fetchSecretValue(makeSecretsDeps(await loadConfig()), key, { repo: APP_VAULT_REPO }),
@@ -35037,19 +35459,19 @@ program2.hook("preAction", async (_thisCommand, actionCommand) => {
 });
 var rules = program2.command("rules").description("org-managed .gitignore delivery");
 rules.command("gitignore").option("--write", "upsert the managed block into .gitignore (default: check only, non-zero exit on drift)").option("--json", "machine-readable output").description("verify (or --write) this repo's org-managed .gitignore block matches the SSOT").action((opts) => {
-  const path2 = (0, import_node_path40.join)(process.cwd(), ".gitignore");
-  const current = (0, import_node_fs42.existsSync)(path2) ? (0, import_node_fs42.readFileSync)(path2, "utf8") : null;
+  const path2 = (0, import_node_path41.join)(process.cwd(), ".gitignore");
+  const current = (0, import_node_fs43.existsSync)(path2) ? (0, import_node_fs43.readFileSync)(path2, "utf8") : null;
   const plan = planManagedGitignore(current);
   const drift = [...plan.added.map((l) => `+${l}`), ...plan.removed.map((l) => `-${l}`)].join(", ") || "block normalize";
   if (opts.json) {
-    if (opts.write && plan.changed) (0, import_node_fs42.writeFileSync)(path2, plan.content, "utf8");
+    if (opts.write && plan.changed) (0, import_node_fs43.writeFileSync)(path2, plan.content, "utf8");
     console.log(JSON.stringify(plan, null, 2));
     if (!opts.write && plan.changed) process.exitCode = 1;
     return;
   }
   if (opts.write) {
     if (plan.changed) {
-      (0, import_node_fs42.writeFileSync)(path2, plan.content, "utf8");
+      (0, import_node_fs43.writeFileSync)(path2, plan.content, "utf8");
       console.log(`mmi-cli org rules gitignore: updated .gitignore (${drift})`);
     } else {
       console.log("mmi-cli org rules gitignore: up to date");
@@ -35207,10 +35629,10 @@ gcCmd.option("--dry-run", "show what would be deleted (default)").option("--appl
   if (!Number.isFinite(limit) || limit < 1) return fail("worktree gc: --limit must be a positive integer");
   let root;
   if (o.root !== void 0) {
-    root = (0, import_node_path40.resolve)(o.root);
-    if (!(0, import_node_fs42.existsSync)(root) || !(0, import_node_fs42.statSync)(root).isDirectory()) return fail(`worktree gc: --root ${o.root} is not a directory`);
+    root = (0, import_node_path41.resolve)(o.root);
+    if (!(0, import_node_fs43.existsSync)(root) || !(0, import_node_fs43.statSync)(root).isDirectory()) return fail(`worktree gc: --root ${o.root} is not a directory`);
     const gcRepoRoot = (await execFileP2("git", ["rev-parse", "--show-toplevel"], { timeout: GIT_TIMEOUT_MS }).catch(() => ({ stdout: "" }))).stdout.trim() || process.cwd();
-    if (isPathUnderDirectory(gcRepoRoot, root)) {
+    if (isPathUnderDirectory2(gcRepoRoot, root)) {
       return fail(`worktree gc: --root ${root} contains this checkout ? name a worktrees root, not the repo or an ancestor of it`);
     }
   }
@@ -35280,15 +35702,17 @@ async function primaryCheckoutRoot(from) {
 }
 async function currentWorktreeRemovalContext(command, force) {
   const cwd = process.cwd();
+  const activeWorkspaceRoot = resolveActiveWorkspaceRoot();
   return {
     primaryRoot: await primaryCheckoutRoot(cwd) ?? cwd,
     actor: describeActor({ env: process.env, surface: detectSurface(process.env), cwd }),
     command,
-    ...force ? { force: true } : {}
+    ...force ? { force: true } : {},
+    ...activeWorkspaceRoot ? { activeWorkspaceRoot } : {}
   };
 }
 async function unprovenWorktreeReason(wtPath, repoRoot2) {
-  if (!(0, import_node_fs42.existsSync)(wtPath)) return `${wtPath} does not exist on disk`;
+  if (!(0, import_node_fs43.existsSync)(wtPath)) return `${wtPath} does not exist on disk`;
   const porcelain = (await execFileP2("git", ["-C", repoRoot2, "worktree", "list", "--porcelain"], { timeout: GIT_TIMEOUT_MS }).catch(() => ({ stdout: "" }))).stdout;
   const registered = parseWorktreePorcelainEntries(porcelain);
   if (!registered.length) {
@@ -35310,26 +35734,26 @@ function makeProvisionDeps(worktreeRoot, quiet, log) {
 function acquireWorktreeSetupLock(worktreeRoot) {
   const lockPath = repoRuntimeStatePath(worktreeRoot, "worktree-setup.lock");
   const take = () => {
-    const fd = (0, import_node_fs42.openSync)(lockPath, "wx");
+    const fd = (0, import_node_fs43.openSync)(lockPath, "wx");
     try {
-      (0, import_node_fs42.writeSync)(fd, String(Date.now()));
+      (0, import_node_fs43.writeSync)(fd, String(Date.now()));
     } finally {
-      (0, import_node_fs42.closeSync)(fd);
+      (0, import_node_fs43.closeSync)(fd);
     }
     return () => {
       try {
-        (0, import_node_fs42.rmSync)(lockPath, { force: true });
+        (0, import_node_fs43.rmSync)(lockPath, { force: true });
       } catch {
       }
     };
   };
   try {
-    (0, import_node_fs42.mkdirSync)((0, import_node_path40.dirname)(lockPath), { recursive: true });
+    (0, import_node_fs43.mkdirSync)((0, import_node_path41.dirname)(lockPath), { recursive: true });
     return take();
   } catch {
     try {
-      if (Date.now() - (0, import_node_fs42.statSync)(lockPath).mtimeMs > WORKTREE_SETUP_LOCK_TTL_MS) {
-        (0, import_node_fs42.rmSync)(lockPath, { force: true });
+      if (Date.now() - (0, import_node_fs43.statSync)(lockPath).mtimeMs > WORKTREE_SETUP_LOCK_TTL_MS) {
+        (0, import_node_fs43.rmSync)(lockPath, { force: true });
         return take();
       }
     } catch {
@@ -36182,7 +36606,7 @@ project.command("set [owner/repo]").description("upsert project META (idempotent
   if (dupe) return fail(`org project set: KEY "${dupe}" was passed to both --var and --set; --set is an alias of --var, so pass each KEY once`);
   if (o.secretsFile) {
     try {
-      vars.push(`secrets=${(0, import_node_fs42.readFileSync)(o.secretsFile, "utf8")}`);
+      vars.push(`secrets=${(0, import_node_fs43.readFileSync)(o.secretsFile, "utf8")}`);
     } catch (e) {
       return fail(`org project set: cannot read --secrets-file ${o.secretsFile}: ${e.message}`);
     }
@@ -36937,11 +37361,11 @@ pr.command("view <number>").description("read a PR as structured JSON (merged st
   }
 });
 async function listCiWorkflowPaths(cwd = process.cwd()) {
-  const wfDir = (0, import_node_path40.join)(cwd, ".github", "workflows");
-  if (!(0, import_node_fs42.existsSync)(wfDir)) return [];
-  return (0, import_node_fs42.readdirSync)(wfDir).filter((name) => /\.(ya?ml)$/i.test(name)).filter((name) => {
+  const wfDir = (0, import_node_path41.join)(cwd, ".github", "workflows");
+  if (!(0, import_node_fs43.existsSync)(wfDir)) return [];
+  return (0, import_node_fs43.readdirSync)(wfDir).filter((name) => /\.(ya?ml)$/i.test(name)).filter((name) => {
     try {
-      return workflowReportsPrChecks((0, import_node_fs42.readFileSync)((0, import_node_path40.join)(wfDir, name), "utf8"));
+      return workflowReportsPrChecks((0, import_node_fs43.readFileSync)((0, import_node_path41.join)(wfDir, name), "utf8"));
     } catch {
       return true;
     }
@@ -36973,16 +37397,16 @@ function ciAuditDeps() {
     // gate re-seed step is skipped gracefully rather than failing mid-run.
     readSeedFile: (path2) => {
       if (!root) return null;
-      const fullPath = (0, import_node_path40.join)(root, path2);
-      return (0, import_node_fs42.existsSync)(fullPath) ? (0, import_node_fs42.readFileSync)(fullPath, "utf8") : null;
+      const fullPath = (0, import_node_path41.join)(root, path2);
+      return (0, import_node_fs43.existsSync)(fullPath) ? (0, import_node_fs43.readFileSync)(fullPath, "utf8") : null;
     }
   };
 }
 function hubRoot() {
-  const fromPkg = (0, import_node_path40.join)(__dirname, "..", "..");
+  const fromPkg = (0, import_node_path41.join)(__dirname, "..", "..");
   const marker = "skills/bootstrap/seeds/manifest.json";
-  if ((0, import_node_fs42.existsSync)((0, import_node_path40.join)(fromPkg, marker))) return fromPkg;
-  if ((0, import_node_fs42.existsSync)((0, import_node_path40.join)(process.cwd(), marker))) return process.cwd();
+  if ((0, import_node_fs43.existsSync)((0, import_node_path41.join)(fromPkg, marker))) return fromPkg;
+  if ((0, import_node_fs43.existsSync)((0, import_node_path41.join)(process.cwd(), marker))) return process.cwd();
   return null;
 }
 pr.command("ci-policy").description("report merge CI policy: wait-for-checks vs no-ci (for grind/build agents)").option("--json", "machine-readable output").option("--repo <owner/repo>", "target repo (defaults to the current checkout)").action(async (o) => {
@@ -37302,7 +37726,7 @@ jsonParity(pr.command("merge <number>").description("merge a PR (squash by defau
     localCleanup = await cleanupPrMergeLocalBranch(headRef, {
       beforeWorktrees,
       startingPath,
-      pathExists: (p) => (0, import_node_fs42.existsSync)(p),
+      pathExists: (p) => (0, import_node_fs43.existsSync)(p),
       execGit: async (args) => (await execFileP2("git", args, { timeout: GIT_TIMEOUT_MS })).stdout,
       teardownWorktreeStage,
       deferredStore,
@@ -37799,12 +38223,12 @@ access.command("audit").description("audit collaborator roles + train-branch pus
     targets = resolution.targets;
   }
   const derivedMatrix = registryProjects ? accessMatrixFromProjects(registryProjects) : {};
-  const fileMatrix = (0, import_node_fs42.existsSync)("access-matrix.json") ? loadAccessMatrix((0, import_node_fs42.readFileSync)("access-matrix.json", "utf8")) : {};
+  const fileMatrix = (0, import_node_fs43.existsSync)("access-matrix.json") ? loadAccessMatrix((0, import_node_fs43.readFileSync)("access-matrix.json", "utf8")) : {};
   const matrix = mergeAccessMatrix(fileMatrix, derivedMatrix);
   const derivedContracts = registryProjects ? dataAccessContractsFromProjects(registryProjects) : { consumers: {} };
-  const fileContracts = (0, import_node_fs42.existsSync)("data-access-contracts.json") ? loadDataAccessContracts((0, import_node_fs42.readFileSync)("data-access-contracts.json", "utf8")) : { consumers: {} };
+  const fileContracts = (0, import_node_fs43.existsSync)("data-access-contracts.json") ? loadDataAccessContracts((0, import_node_fs43.readFileSync)("data-access-contracts.json", "utf8")) : { consumers: {} };
   const dataAccess = mergeDataAccessContracts(fileContracts, derivedContracts);
-  const sanctioned = (0, import_node_fs42.existsSync)("access-matrix.json") ? loadSanctionedAdmins((0, import_node_fs42.readFileSync)("access-matrix.json", "utf8")) : {};
+  const sanctioned = (0, import_node_fs43.existsSync)("access-matrix.json") ? loadSanctionedAdmins((0, import_node_fs43.readFileSync)("access-matrix.json", "utf8")) : {};
   const report = await auditOrgAccess(targets, deps, matrix, dataAccess, sanctioned);
   console.log(o.json ? JSON.stringify(report, null, 2) : renderAccessReport(report));
   if (!report.ok) process.exitCode = 1;
@@ -37836,16 +38260,16 @@ function directoryBytes(path2) {
   let total = 0;
   let entries;
   try {
-    entries = (0, import_node_fs42.readdirSync)(path2, { withFileTypes: true });
+    entries = (0, import_node_fs43.readdirSync)(path2, { withFileTypes: true });
   } catch {
     return 0;
   }
   for (const entry of entries) {
-    const child2 = (0, import_node_path40.join)(path2, entry.name);
+    const child2 = (0, import_node_path41.join)(path2, entry.name);
     if (entry.isDirectory()) total += directoryBytes(child2);
     else {
       try {
-        total += (0, import_node_fs42.statSync)(child2).size;
+        total += (0, import_node_fs43.statSync)(child2).size;
       } catch {
       }
     }
@@ -37853,25 +38277,25 @@ function directoryBytes(path2) {
   return total;
 }
 function listDirEntries(dir) {
-  return (0, import_node_fs42.readdirSync)(dir, { withFileTypes: true }).map((d) => ({ name: d.name, isDirectory: d.isDirectory() }));
+  return (0, import_node_fs43.readdirSync)(dir, { withFileTypes: true }).map((d) => ({ name: d.name, isDirectory: d.isDirectory() }));
 }
 function readInstalledPluginRefs(configRoot) {
   const p = installedPluginsPathForConfig(configRoot);
-  if (!(0, import_node_fs42.existsSync)(p)) return [];
+  if (!(0, import_node_fs43.existsSync)(p)) return [];
   try {
-    return installedPluginPaths((0, import_node_fs42.readFileSync)(p, "utf8"));
+    return installedPluginPaths((0, import_node_fs43.readFileSync)(p, "utf8"));
   } catch {
     return null;
   }
 }
 function pluginCacheFsDeps(configRoot, dirBytes) {
   return {
-    exists: (p) => (0, import_node_fs42.existsSync)(p),
-    listVersionDirs: (root) => (0, import_node_fs42.readdirSync)(root, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name),
+    exists: (p) => (0, import_node_fs43.existsSync)(p),
+    listVersionDirs: (root) => (0, import_node_fs43.readdirSync)(root, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name),
     dirBytes,
-    listStagingDirs: (root) => (0, import_node_fs42.readdirSync)(root, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => {
+    listStagingDirs: (root) => (0, import_node_fs43.readdirSync)(root, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => {
       try {
-        return { name: d.name, mtimeMs: newestMtimeMs((0, import_node_path40.join)(root, d.name), listDirEntries, (p) => (0, import_node_fs42.statSync)(p).mtimeMs) };
+        return { name: d.name, mtimeMs: newestMtimeMs((0, import_node_path41.join)(root, d.name), listDirEntries, (p) => (0, import_node_fs43.statSync)(p).mtimeMs) };
       } catch {
         return { name: d.name, mtimeMs: Date.now() };
       }
@@ -37885,10 +38309,10 @@ function stagingApplyFsGuard(configRoot) {
   return {
     referencedPaths: () => readInstalledPluginRefs(configRoot),
     mtimeMs: (name) => {
-      const p = (0, import_node_path40.join)(stagingRoot, name);
-      if (!(0, import_node_fs42.existsSync)(p)) return null;
+      const p = (0, import_node_path41.join)(stagingRoot, name);
+      if (!(0, import_node_fs43.existsSync)(p)) return null;
       try {
-        return newestMtimeMs(p, listDirEntries, (q) => (0, import_node_fs42.statSync)(q).mtimeMs);
+        return newestMtimeMs(p, listDirEntries, (q) => (0, import_node_fs43.statSync)(q).mtimeMs);
       } catch {
         return null;
       }
@@ -37908,13 +38332,13 @@ program2.command("plugin-prune").description(`prune stale cached MMI plugin vers
     return;
   }
   const plan = buildPluginCachePlan(
-    (0, import_node_os17.homedir)(),
+    (0, import_node_os18.homedir)(),
     running,
     pluginCacheFsDeps(configRoot, directoryBytes),
     { withBytes: true, configRoot, includeStaging: surface !== "codex" }
   );
   const anythingToDelete = plan.prune.length > 0 || plan.staging.length > 0;
-  const result = o.apply && anythingToDelete ? applyPluginCachePlan(plan, (p) => (0, import_node_fs42.rmSync)(p, { recursive: true, force: true }), stagingApplyFsGuard(configRoot)) : void 0;
+  const result = o.apply && anythingToDelete ? applyPluginCachePlan(plan, (p) => (0, import_node_fs43.rmSync)(p, { recursive: true, force: true }), stagingApplyFsGuard(configRoot)) : void 0;
   const warnings = plan.prune.length > 0 ? [CONCURRENT_SESSION_WARNING] : [];
   if (o.json) console.log(JSON.stringify({ ...plan, warnings, applied: result ?? null }));
   else console.log(renderPluginCachePlan(plan, result));
@@ -37922,7 +38346,7 @@ program2.command("plugin-prune").description(`prune stale cached MMI plugin vers
 });
 function readReleaseCatchupState(path2) {
   try {
-    const parsed = JSON.parse((0, import_node_fs42.readFileSync)(path2, "utf8"));
+    const parsed = JSON.parse((0, import_node_fs43.readFileSync)(path2, "utf8"));
     return typeof parsed?.checkedAt === "number" ? parsed : void 0;
   } catch {
     return void 0;
@@ -37930,8 +38354,8 @@ function readReleaseCatchupState(path2) {
 }
 function writeReleaseCatchupState(path2, state) {
   try {
-    (0, import_node_fs42.mkdirSync)((0, import_node_path40.dirname)(path2), { recursive: true });
-    (0, import_node_fs42.writeFileSync)(path2, `${JSON.stringify(state)}
+    (0, import_node_fs43.mkdirSync)((0, import_node_path41.dirname)(path2), { recursive: true });
+    (0, import_node_fs43.writeFileSync)(path2, `${JSON.stringify(state)}
 `);
   } catch {
   }
@@ -37939,7 +38363,7 @@ function writeReleaseCatchupState(path2, state) {
 program2.command("plugin-release-catchup").description("install a newer released MMI plugin clone non-destructively and re-point the Pi registration (#4297); TTL-gated no-op when current").option("--force", "skip the 24h TTL (acceptance proof / manual run)").option("--quiet", "print only failures (the detached session-start lane)").option("--json", "machine-readable output").action(async (o) => {
   const outcome = await withEnvHealLock(
     "plugin release catch-up",
-    () => runReleaseCatchup((0, import_node_os17.homedir)(), process.env, {
+    () => runReleaseCatchup((0, import_node_os18.homedir)(), process.env, {
       fetchReleased: fetchNpmReleasedVersion,
       runClaude: (args, step) => runPluginCli("claude", args, (msg) => {
         if (!o.quiet && !o.json) console.log(msg);
@@ -37955,7 +38379,7 @@ program2.command("plugin-release-catchup").description("install a newer released
       },
       readState: readReleaseCatchupState,
       writeState: writeReleaseCatchupState,
-      healRegistration: defaultRegistrationHeal((0, import_node_os17.homedir)(), process.env),
+      healRegistration: defaultRegistrationHeal((0, import_node_os18.homedir)(), process.env),
       now: () => Date.now()
     }, { force: o.force })
   );
@@ -38023,7 +38447,7 @@ program2.command("session-start").description("run the SessionStart verbs (whoam
     spawnDetachedSelf(["worktree", "setup", "--quiet"], { spawn: import_node_child_process19.spawn, execPath: process.execPath, scriptPath: process.argv[1] });
     bannerIo.log(worktreeBanner);
   }
-  if (shouldSpawnReleaseCatchup((0, import_node_os17.homedir)(), process.env, readReleaseCatchupState)) {
+  if (shouldSpawnReleaseCatchup((0, import_node_os18.homedir)(), process.env, readReleaseCatchupState)) {
     spawnDetachedSelf(["plugin", "release-catchup", "--quiet"], { spawn: import_node_child_process19.spawn, execPath: process.execPath, scriptPath: process.argv[1] });
   }
   if (isLinkedWorktree(process.cwd())) {
@@ -38037,6 +38461,61 @@ program2.command("session-start").description("run the SessionStart verbs (whoam
 installProcessBackstop();
 consolidateCommandNamespaces(program2);
 applyCommandTaxonomy(program2);
+function resolveHouseShim(argv) {
+  const houseToken = argv[2];
+  if (!houseToken) return;
+  if (!isHouseRoot(houseToken)) {
+    return;
+  }
+  const remainder = argv.slice(3);
+  const first = remainder[0];
+  if (!first || first === "--help" || first === "-h") {
+    printHouseRootHelp(houseToken);
+    hardExit(0);
+  }
+  const commandTokens = remainder.slice(0, 2).filter((tok) => !tok.startsWith("-"));
+  const lookupPath = commandTokens.join(" ");
+  if (!lookupPath) {
+    printHouseRootHelp(houseToken);
+    hardExit(2);
+  }
+  const actual = houseForPath(lookupPath);
+  if (actual === houseToken) {
+    argv.splice(2, 1);
+    return;
+  }
+  const canonical = actual ? `mmi-cli ${actual === "core" ? "" : `${actual} `}${lookupPath}`.replace(/\s+/g, " ").trim() : void 0;
+  if (actual) {
+    process.stderr.write(
+      `mmi-cli ${houseToken}: '${lookupPath}' lives in house '${actual}' \u2014 run: ${canonical} \u2026
+`
+    );
+  } else {
+    process.stderr.write(
+      `mmi-cli ${houseToken}: '${first}' is not a command of house '${houseToken}' \u2014 run \`mmi-cli ${houseToken} --help\` for its commands
+`
+    );
+  }
+  hardExit(2);
+}
+function printHouseRootHelp(house) {
+  const manifest = buildCommandManifest(program2);
+  const commands = manifest.houses.find((entry) => entry.root === house)?.commands ?? [];
+  const lines = [
+    `mmi-cli ${house} \u2014 the ${house} house (${HOUSE_QUESTIONS[house]}), ${commands.length} command${commands.length === 1 ? "" : "s"}:`,
+    ""
+  ];
+  for (const cmd of commands) {
+    lines.push(cmd.description ? `  ${cmd.path} \u2014 ${cmd.description}` : `  ${cmd.path}`);
+  }
+  lines.push(
+    "",
+    `Canonical: \`mmi-cli ${house} <command> \u2026\`. The flat \`mmi-cli <command> \u2026\` form is a compatibility`,
+    `shim keeping fleet scripts working for one window \u2014 shims die in ${COMPAT_SHIM_DEATH_WAVE} (#4316).`
+  );
+  consoleIo.log(lines.join("\n"));
+}
+resolveHouseShim(process.argv);
 program2.parseAsync(process.argv).then(() => finishCliRun()).catch((e) => failGraceful(e.message));
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {