@mutmutco/cli 3.58.0 → 3.59.0

package/dist/main.cjs

@@ -3411,7 +3411,7 @@ var program = new Command();
 
 // src/index.ts
 var import_promises8 = require("node:fs/promises");
-var import_node_fs32 = require("node:fs");
+var import_node_fs33 = require("node:fs");
 var import_node_child_process13 = require("node:child_process");
 
 // src/cli-shared.ts
@@ -9679,7 +9679,7 @@ function commandLadderHint() {
 }
 
 // src/index.ts
-var import_node_path30 = require("node:path");
+var import_node_path31 = require("node:path");
 
 // src/merge-ci-policy.ts
 function resolveMergeCiPolicy(input) {
@@ -12163,7 +12163,7 @@ async function executeWaveLand(plan, deps, opts = { preserveWorktree: true }) {
 }
 
 // src/index.ts
-var import_node_os9 = require("node:os");
+var import_node_os10 = require("node:os");
 
 // src/attach-to-project.ts
 async function resolveAutoAddBoardAttach(client, cfg, selector, priority, warn = (m) => process.stderr.write(m), retry = {}) {
@@ -19221,13 +19221,13 @@ function registerSchedulesLiftCommand(program3, deps = {}) {
 // src/edge-tunnel.ts
 var HOSTNAME_RE = /^(?=.{1,253}$)([a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)(\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)+$/;
 var UPSTREAM_RE = /^https?:\/\/[^/\s]+(?::\d+)?(?:\/.*)?$/;
-function tunnelNameFromHostname(hostname) {
-  return hostname.replace(/\./g, "-").slice(0, 63);
+function tunnelNameFromHostname(hostname2) {
+  return hostname2.replace(/\./g, "-").slice(0, 63);
 }
-function planInfraTunnel(hostname, upstream) {
-  const host = hostname.trim().toLowerCase();
+function planInfraTunnel(hostname2, upstream) {
+  const host = hostname2.trim().toLowerCase();
   const origin = upstream.trim();
-  if (!HOSTNAME_RE.test(host)) throw new Error(`invalid hostname ${JSON.stringify(hostname)}`);
+  if (!HOSTNAME_RE.test(host)) throw new Error(`invalid hostname ${JSON.stringify(hostname2)}`);
   if (!UPSTREAM_RE.test(origin)) throw new Error(`invalid upstream ${JSON.stringify(upstream)} \u2014 expected http(s)://host:port`);
   const tunnelName = tunnelNameFromHostname(host);
   const configYaml = [
@@ -21201,9 +21201,9 @@ function registerBoardCommands(program3) {
 }
 
 // src/merge-cleanup.ts
-var import_node_fs25 = require("node:fs");
+var import_node_fs27 = require("node:fs");
 var import_promises6 = require("node:fs/promises");
-var import_node_path24 = require("node:path");
+var import_node_path26 = require("node:path");
 var import_node_child_process11 = require("node:child_process");
 
 // src/board-advance.ts
@@ -21369,1870 +21369,2097 @@ function makeDeferredWorktreeStore(registryPath, lockOpts = {}) {
   };
 }
 
-// src/merge-cleanup.ts
-var GC_GH_TIMEOUT_MS2 = 2e4;
-async function advanceClosedIssuesToDone2(prNumber, repoOption) {
-  try {
-    return await resolveBoardAdvanceForPr(prNumber, repoOption);
-  } catch (e) {
-    return { status: "fetch-failed", entries: [], error: e.message };
+// src/plugin-guard-io.ts
+var import_node_fs25 = require("node:fs");
+var import_node_path24 = require("node:path");
+var import_node_os6 = require("node:os");
+
+// src/plugin-guard.ts
+function buildPluginGuardDecision(i) {
+  if (!i.isOrgRepo) return { state: "not-org" };
+  if (!i.installRecordPresent) return { state: "no-install" };
+  if (!i.marketplaceClonePresent || !i.pluginCachePresent) return { state: "unresolved" };
+  return { state: "healthy" };
+}
+function buildPluginGuardLine(state, opts = {}) {
+  if (state === "healthy" || state === "not-org") return { exitCode: 0 };
+  const recovery = opts.recovery ?? "mmi-cli plugin heal";
+  const restartHint = opts.restartHint ?? "restart your agent host / reload plugins";
+  const reason = state === "no-install" ? "MMI plugin is not installed for this user/session" : "MMI plugin is installed but its marketplace/cache is unresolved";
+  return {
+    line: `[mmi-guard] ${reason}; run ${recovery} and ${restartHint}.`,
+    exitCode: 1
+  };
+}
+
+// src/plugin-guard-io.ts
+var isWin = process.platform === "win32";
+var MMI_PLUGIN_ID = "mmi@mutmutco";
+var LEGACY_MMI_MARKETPLACE = "mmi";
+function detectSurface(env) {
+  const has = (k) => Boolean(env[k]?.trim());
+  if (env.MMI_AGENT_SURFACE === "codex" || has("CODEX_HOME") || (env.CLAUDE_PLUGIN_ROOT ?? "").includes(".codex")) {
+    return "codex";
+  }
+  if (env.MMI_AGENT_SURFACE === "cursor" || has("CURSOR_TRACE_ID") || has("CURSOR_USER") || has("CURSOR_SESSION_ID") || env.CURSOR_AGENT === "1" || has("CURSOR_EXTENSION_HOST_ROLE")) {
+    return "cursor";
   }
+  if (env.MMI_AGENT_SURFACE === "opencode" || has("OPENCODE_CLIENT") || has("OPENCODE_SERVER_USERNAME")) return "opencode";
+  const isClaude = has("CLAUDECODE") || has("CLAUDE_CODE_ENTRYPOINT") || has("CLAUDE_PLUGIN_ROOT") || env.MMI_AGENT_SURFACE === "claude";
+  const isVscode = env.TERM_PROGRAM === "vscode" || has("VSCODE_PID") || has("VSCODE_GIT_ASKPASS_NODE");
+  if (isClaude && isVscode) return "claude-vscode";
+  if (isClaude) return "claude-cli";
+  return "shell";
 }
-async function resolveBoardAdvanceForPr(prNumber, repoOption) {
-  const repoArgs = repoOption ? ["--repo", repoOption] : [];
-  const repo = await resolveRepo(repoOption);
-  if (!repo) {
-    return {
-      status: "fetch-failed",
-      entries: [],
-      error: "could not resolve the PR's repo, so a closing reference cannot be proven to belong to this board"
-    };
+function surfaceToken(surface) {
+  switch (surface) {
+    case "claude-cli":
+    case "claude-vscode":
+      return "claude";
+    case "codex":
+      return "codex";
+    case "cursor":
+      return "cursor";
+    case "opencode":
+      return "opencode";
+    case "shell":
+    default:
+      return null;
   }
-  return advanceClosedIssuesToDone({
-    repo,
-    fetchClosingIssues: async () => {
-      const { stdout } = await execFileP2("gh", ["pr", "view", prNumber, ...repoArgs, "--json", "closingIssuesReferences"], { timeout: GC_GH_TIMEOUT_MS2 });
-      const parsed = JSON.parse(stdout || "null");
-      if (!parsed || typeof parsed !== "object" || !("closingIssuesReferences" in parsed)) {
-        throw new Error("gh returned no closingIssuesReferences field for this PR");
-      }
-      return parsed.closingIssuesReferences;
-    },
-    moveIssueToDone: async (ref) => {
-      const moved = await moveBoardItem({ config: await loadConfigForBoardSelector2(ref, repoOption), selector: ref, status: "Done", repo: repoOption, allowPartial: true });
-      return moved.partial ? { moved: false, error: moved.warning } : { moved: true };
-    }
+}
+function reloadAction(surface) {
+  switch (surface) {
+    case "claude-vscode":
+      return "restart VS Code";
+    case "codex":
+      return "restart Codex";
+    case "opencode":
+      return "restart OpenCode";
+    case "cursor":
+      return "restart Cursor (or refresh the Team Marketplace from Dashboard \u2192 Settings \u2192 Plugins)";
+    case "claude-cli":
+    case "shell":
+    default:
+      return "restart Claude Code (or run /reload-plugins)";
+  }
+}
+var CLAUDE_RECOVERY = `claude plugin marketplace remove ${LEGACY_MMI_MARKETPLACE} && claude plugin marketplace remove mutmutco && claude plugin marketplace add mutmutco/MMI-Hub --ref main && claude plugin install mmi@mutmutco`;
+var PLUGIN_SURFACE_HEAL = {
+  claude: {
+    delivery: "plugin-cli",
+    recovery: CLAUDE_RECOVERY,
+    healSteps: [
+      { args: ["plugin", "marketplace", "remove", LEGACY_MMI_MARKETPLACE], gated: false },
+      { args: ["plugin", "marketplace", "remove", "mutmutco"], gated: false },
+      { args: ["plugin", "marketplace", "add", "mutmutco/MMI-Hub", "--ref", "main"], gated: true },
+      { args: ["plugin", "install", "mmi@mutmutco"], gated: true },
+      { args: ["plugin", "enable", "mmi@mutmutco"], gated: false }
+    ],
+    fix: (surface) => `${CLAUDE_RECOVERY}   # then ${reloadAction(surface)} to reload MMI commands`,
+    updateRecipe: [CLAUDE_RECOVERY]
+  }
+};
+function nonClaudeSurfaceHealMessage(surface) {
+  if (surface === "codex") {
+    return "Codex ships an MMI plugin (#3563). Install or repair it with:\n  codex plugin marketplace add mutmutco/MMI-Hub && codex plugin add mmi@mutmutco\n  Then run /hooks and TRUST the MMI hooks \u2014 bundled hooks are skipped until reviewed.\n  Update the CLI too: npm i -g @mutmutco/cli";
+  }
+  return "No Hub-shipped MMI plugin on this host \u2014 the Hub ships plugins for Claude and Codex only.\n  Update the CLI instead: npm i -g @mutmutco/cli   (org rules ride an AGENTS.md authored outside the Hub)";
+}
+function healStepAborts(step, ok) {
+  return !ok && step.gated;
+}
+function marketplaceAddSupportsRef(helpText) {
+  if (!helpText) return false;
+  return /(^|\s)--ref(\b|=)/.test(helpText);
+}
+function adaptHealStepsForRefSupport(steps, refSupported) {
+  if (refSupported) return { steps: [...steps], strippedRef: false };
+  let strippedRef = false;
+  const adapted = steps.map((step) => {
+    const refIdx = step.args.indexOf("--ref");
+    const isAdd = step.args.includes("marketplace") && step.args.includes("add");
+    if (!isAdd || refIdx === -1) return step;
+    strippedRef = true;
+    return { ...step, args: [...step.args.slice(0, refIdx), ...step.args.slice(refIdx + 2)] };
   });
+  return { steps: adapted, strippedRef };
 }
-function renderGcApplyResult(result) {
-  const lines = ["worktree gc apply result:"];
-  lines.push(`  branches removed: ${result.removedBranches.length ? result.removedBranches.join(", ") : "none"}`);
-  lines.push(`  remote branches removed: ${result.removedRemoteBranches.length ? result.removedRemoteBranches.join(", ") : "none"}`);
-  lines.push(`  tracking refs removed: ${result.removedTrackingRefs.length ? result.removedTrackingRefs.join(", ") : "none"}`);
-  lines.push(`  dead sibling dirs removed: ${result.removedWorktreeDirs.length ? result.removedWorktreeDirs.join(", ") : "none"}`);
-  lines.push(`  stale registrations pruned: ${result.pruned ? "yes" : "no"} (clears registrations only \u2014 never deletes a directory)`);
-  if (result.failed.length) {
-    lines.push(`  failed (${result.failed.length}):`);
-    for (const f of result.failed) lines.push(`    - ${f}`);
+function recoveryWithoutRef(recovery) {
+  return recovery.replace(/ --ref \S+/g, "");
+}
+function hasProjectInstallRecord(file, pluginId, projectPath) {
+  const records = file?.plugins?.[pluginId];
+  if (!Array.isArray(records)) return false;
+  return records.some((r) => r.scope === "project" && r.projectPath === projectPath);
+}
+function hasUserInstallRecord(file, pluginId) {
+  const records = file?.plugins?.[pluginId];
+  if (!Array.isArray(records)) return false;
+  return records.some((r) => r.scope === "user");
+}
+var CLAUDE_PLUGIN_TIMEOUT_MS = 12e4;
+var NPM_VIEW_TIMEOUT_MS = 15e3;
+function runHostBin(bin, args, opts) {
+  return isWin ? execFileP2("cmd.exe", ["/c", bin, ...args], opts) : execFileP2(bin, args, opts);
+}
+var installedPluginsPath2 = (surface = detectSurface(process.env)) => {
+  const homeDir = surface === "codex" ? ".codex" : ".claude";
+  return (0, import_node_path24.join)((0, import_node_os6.homedir)(), homeDir, "plugins", "installed_plugins.json");
+};
+function readInstalledPlugins(surface = detectSurface(process.env)) {
+  try {
+    return JSON.parse((0, import_node_fs25.readFileSync)(installedPluginsPath2(surface), "utf8"));
+  } catch {
+    return null;
   }
-  const removedNothing = result.removedBranches.length === 0 && result.removedRemoteBranches.length === 0 && result.removedTrackingRefs.length === 0 && result.removedWorktreeDirs.length === 0;
-  if (removedNothing) {
-    lines.push("  NOTHING WAS REMOVED. A stale worktree whose directory still exists is not reachable by");
-    lines.push("  this verb \u2014 remove it from inside it with `mmi-cli worktree land --apply`, or delete the");
-    lines.push("  directory and re-run to clear its registration.");
+}
+function marketplaceCloneCandidates(surface, home) {
+  if (surface === "codex") {
+    return [
+      (0, import_node_path24.join)(home, ".codex", ".tmp", "marketplaces", "mutmutco"),
+      (0, import_node_path24.join)(home, ".codex", "plugins", "marketplaces", "mutmutco")
+    ];
   }
-  return lines.join("\n");
+  return [(0, import_node_path24.join)(home, ".claude", "plugins", "marketplaces", "mutmutco")];
 }
-async function deleteReviewedRemoteBranch(remote, branch, expectedHeadOid) {
-  if (!isSafeGitRemoteName(remote)) throw new Error(`unsafe remote name ${remote}`);
-  const { stdout } = await execFileP2("git", ["ls-remote", "--heads", remote, branch], { timeout: GIT_TIMEOUT_MS });
-  const line = stdout.trim().split(/\r?\n/).find(Boolean);
-  if (!line) return "already-gone";
-  const remoteHead = line.split(/\s+/)[0]?.trim();
-  if (!remoteHead || remoteHead !== expectedHeadOid) {
-    throw new Error(`${remoteHead || "unknown"} != ${expectedHeadOid}`);
+function marketplaceClonePresent(surface, home, exists = import_node_fs25.existsSync) {
+  return marketplaceCloneCandidates(surface, home).some(exists);
+}
+async function fetchNpmReleasedVersion() {
+  try {
+    const { stdout } = await runHostBin("npm", npmReleasedVersionArgs(), { timeout: NPM_VIEW_TIMEOUT_MS });
+    return parseNpmVersion(stdout);
+  } catch {
+    return void 0;
   }
+}
+var NPM_INSTALL_TIMEOUT_MS = 12e4;
+async function npmSelfUpdateCli(target) {
+  const command = cliUpdateCommand(target);
   try {
-    await execFileP2("git", [
-      "push",
-      remote,
-      `--force-with-lease=refs/heads/${branch}:${expectedHeadOid}`,
-      `:refs/heads/${branch}`
-    ], { timeout: GH_MUTATION_TIMEOUT_MS });
+    await runHostBin("npm", ["install", "-g", `@mutmutco/cli@${target ?? "latest"}`], { timeout: NPM_INSTALL_TIMEOUT_MS });
+    return { ok: true, detail: `${command} exited 0` };
   } catch (e) {
-    const after = await execFileP2("git", ["ls-remote", "--heads", remote, branch], { timeout: GIT_TIMEOUT_MS }).catch(() => void 0);
-    if (after && !after.stdout.trim().split(/\r?\n/).find(Boolean)) return "already-gone";
-    throw e;
+    return { ok: false, detail: e.message.trim().slice(0, 200).replace(/\s+/g, " ") };
   }
-  return "deleted";
 }
-function evaluatePrMergeHousekeeping(report, context, force = false) {
-  const scratch = report.scratch;
-  const failed = scratch?.status === "failed";
-  const prunable = scratch?.safeAuto ?? 0;
-  const unprunable = scratch?.skipped ?? 0;
-  if (!(failed || prunable > 0 || unprunable > 0)) return { blocked: false };
-  if (force) return { blocked: false };
-  const detail = failed ? `scratch housekeeping failed${scratch?.error ? `: ${scratch.error}` : ""}` : `${prunable} prunable + ${unprunable} un-prunable scratch item(s) remain after cleanup`;
+function snapshotPluginGuardInput(surface = detectSurface(process.env), isOrgRepo = false) {
+  const homeDir = surface === "codex" ? ".codex" : ".claude";
+  const installed = readInstalledPlugins(surface);
   return {
-    blocked: true,
-    reason: `${context} housekeeping blocked merge: ${detail}. Run \`mmi-cli worktree gc --scratch --apply\` to clear it, then retry \u2014 or re-run \`mmi-cli ${context} --force\` to acknowledge and land anyway. (Kept advisory plans/ scratch never blocks: it is gitignored and can never reach origin.)`
+    isOrgRepo,
+    installRecordPresent: hasUserInstallRecord(installed, MMI_PLUGIN_ID) || hasProjectInstallRecord(installed, MMI_PLUGIN_ID, process.cwd()),
+    marketplaceClonePresent: marketplaceClonePresent(surface, (0, import_node_os6.homedir)()),
+    pluginCachePresent: (0, import_node_fs25.existsSync)((0, import_node_path24.join)((0, import_node_os6.homedir)(), homeDir, "plugins", "cache", "mutmutco", "mmi"))
   };
 }
-function assertPrMergeHousekeepingClean(startingPath, context, options = {}) {
-  const build = options.buildHousekeeping ?? ((repoRoot2) => buildPrMergeScratchHousekeeping(repoRoot2));
-  const housekeeping = build(startingPath || process.cwd());
-  const verdict = evaluatePrMergeHousekeeping(housekeeping, context, options.force);
-  if (verdict.blocked) throw new Error(verdict.reason);
-  return housekeeping;
+function claudePluginGuardState(isOrgRepo) {
+  return buildPluginGuardDecision(snapshotPluginGuardInput(detectSurface(process.env), isOrgRepo)).state;
 }
-async function applyGcPlan(plan, remote, opts = {}) {
-  const result = { removedBranches: [], removedRemoteBranches: [], removedTrackingRefs: [], removedWorktreeDirs: [], failed: [], pruned: false };
-  const beforeWorktrees = parseWorktreePorcelain(
-    (await execFileP2("git", ["worktree", "list", "--porcelain"], { timeout: GIT_TIMEOUT_MS }).catch(() => ({ stdout: "" }))).stdout
-  );
-  const deferredStore = await createDeferredWorktreeStore();
-  const branchTracking = await applyBranchAndTrackingCleanup(plan, {
-    localBranchHeads,
-    cleanupBranch: (branch, expectedHeadOid) => {
-      const wtDeps = worktreeRemoveDeps(async (args) => (await execFileP2("git", args, { timeout: GIT_TIMEOUT_MS })).stdout);
-      return cleanupPrMergeLocalBranch(branch.branch, {
-        beforeWorktrees,
-        startingPath: branch.worktreePath,
-        pathExists: (p) => (0, import_node_fs25.existsSync)(p),
-        execGit: async (args) => (await execFileP2("git", args, { timeout: GIT_TIMEOUT_MS })).stdout,
-        teardownWorktreeStage,
-        deferredStore,
-        expectedHeadOid,
-        detachReparsePoints: wtDeps.detachReparsePoints,
-        // #3064: junction-safe teardown
-        removeWorktreeDir: wtDeps.removeWorktreeDir
-      });
-    },
-    cleanupRemoteBranch: (branch, expectedHeadOid) => deleteReviewedRemoteBranch(remote, branch.branch, expectedHeadOid),
-    cleanupTrackingRefs: (trackingRefs, unsafeBranches) => applyTrackingRefCleanup(trackingRefs, remote, unsafeBranches, {
-      execGit: async (args) => (await execFileP2("git", args, { timeout: GIT_TIMEOUT_MS })).stdout
-    })
-  });
-  result.removedBranches.push(...branchTracking.removedBranches);
-  result.removedRemoteBranches.push(...branchTracking.removedRemoteBranches);
-  result.removedTrackingRefs.push(...branchTracking.removedTrackingRefs);
-  result.failed.push(...branchTracking.failed);
-  const removeDeps = worktreeRemoveDeps(async (args) => (await execFileP2("git", args, { timeout: GIT_TIMEOUT_MS })).stdout);
-  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_path24.dirname)((0, import_node_path24.dirname)(worktreeGitRoot)) : repoRoot2;
-  const siblingRoot = opts.root ? resolveExplicitScanRoot(opts.root, primaryRepoRoot) : siblingMmiWorktreesRoot(primaryRepoRoot);
-  for (const wt of plan.worktreeDirs) {
-    try {
-      const cleanupTarget = resolveSafeSiblingWorktreeCleanupTarget(wt.path, siblingRoot, {
-        realpath: (path2) => (0, import_node_fs25.realpathSync)(path2)
-      });
-      if (!cleanupTarget.ok) {
-        result.failed.push(`${wt.path}: ${cleanupTarget.reason}`);
-        continue;
-      }
-      const stillValid = validateDeadWorktreeDirCleanup(wt, inspectSiblingWorktreeDir(wt.path, worktreeGitRoot));
-      if (!stillValid.ok) {
-        result.failed.push(`${wt.path}: skipped dead-dir removal (${stillValid.reason})`);
-        continue;
-      }
-      const contentSafe = validateDeadWorktreeDirContent(wt, inspectDeadWorktreeDirContent(wt.path));
-      if (!contentSafe.ok) {
-        result.failed.push(`${wt.path}: skipped dead-dir removal (${contentSafe.reason})`);
-        continue;
-      }
-      await removeDeps.removeWorktreeDir(cleanupTarget.path);
-      result.removedWorktreeDirs.push(wt.path);
-    } catch (e) {
-      result.failed.push(`${wt.path}: ${e.message.split("\n")[0]}`);
-    }
-  }
+async function runClaudePlugin(args) {
   try {
-    await execFileP2("git", ["worktree", "prune"], { timeout: GIT_TIMEOUT_MS });
-    result.pruned = true;
-  } catch (e) {
-    result.failed.push(`worktree prune: ${e.message.split("\n")[0]}`);
+    await runHostBin("claude", args, { timeout: CLAUDE_PLUGIN_TIMEOUT_MS });
+    return true;
+  } catch {
+    return false;
   }
-  return result;
 }
-async function pollGhPrChecks(prNumber, repoArgs) {
-  let stdout = "";
-  let stderr = "";
+async function marketplaceAddRefSupported(bin) {
   try {
-    ({ stdout, stderr } = await execFileP2("gh", ["pr", "checks", prNumber, ...repoArgs], { timeout: GC_GH_TIMEOUT_MS2 }));
-  } catch (e) {
-    const err = e;
-    if (err.killed || err.stdout == null && err.stderr == null) throw e;
-    stdout = err.stdout ?? "";
-    stderr = err.stderr ?? "";
-  }
-  const state = parseGhPrChecksResult(stdout, stderr);
-  if (state === "error") {
-    throw new Error(`gh pr checks ${prNumber}: ${(stderr || stdout).trim() || "unknown error"}`);
+    const { stdout, stderr } = await runHostBin(bin, ["plugin", "marketplace", "add", "--help"], {
+      timeout: CLAUDE_PLUGIN_TIMEOUT_MS
+    });
+    return marketplaceAddSupportsRef(`${stdout}
+${stderr}`);
+  } catch {
+    return false;
   }
-  return state;
 }
-function ghFailureReason(e) {
-  const err = e;
-  const head = String(err?.message ?? "").split("\n")[0]?.trim() ?? "";
-  const detail = `${err?.stderr ?? ""}
-${err?.stdout ?? ""}`.split("\n").map((line) => line.trim()).find((line) => line.length > 0);
-  if (detail && head) return `${head} \u2014 ${detail}`;
-  return detail || head || "unknown error";
+function healBannerLine(bin, token, refSupported) {
+  const installVerb = token === "codex" ? "add" : "install";
+  return refSupported ? `  \u21BB reinstalling the MMI plugin via \`${bin} plugin\` (marketplace remove \u2192 add --ref main \u2192 ${installVerb})\u2026` : `  \u21BB reinstalling the MMI plugin via \`${bin} plugin\` (marketplace remove \u2192 add \u2192 ${installVerb}; release ref pinned by the marketplace manifest)\u2026`;
 }
-var defaultGhMergeAutoIo = {
-  gh: async (args, timeoutMs) => (await execFileP2("gh", args, { timeout: timeoutMs })).stdout
-};
-async function ghMergeAutoEnqueue(prNumber, repo, method, io = defaultGhMergeAutoIo) {
-  const args = repo ? ["--repo", repo] : [];
-  const headRef = (await io.gh(["pr", "view", prNumber, ...args, "--json", "headRefName", "--jq", ".headRefName"], GC_GH_TIMEOUT_MS2).catch(() => "")).trim();
-  const deleteBranch = !isProtectedBranch(headRef);
-  const readMergeState = () => readGhPrStateWithRetry(
-    () => io.gh(["pr", "view", prNumber, ...args, "--json", "state", "--jq", ".state"], GC_GH_TIMEOUT_MS2)
-  );
-  const confirmEnqueueOutcome = async () => {
-    const stateRead = await readMergeState();
-    if (!stateRead.ok) {
-      return { mergeStatus: "failed", error: `could not read PR state after merge: ${stateRead.error}` };
-    }
-    if (stateRead.state === "MERGED") return { mergeStatus: "merged" };
-    const confirmation = await confirmAutoMergeEnqueued({
-      readAutoMergeRequest: async () => io.gh(["pr", "view", prNumber, ...args, "--json", "autoMergeRequest", "--jq", '.autoMergeRequest // ""'], GC_GH_TIMEOUT_MS2),
-      readMerged: async () => {
-        const s = await readMergeState();
-        return s.ok && s.state === "MERGED";
-      },
-      reEnqueue: async () => {
-        await io.gh(buildPrMergeArgs({ number: prNumber, repoArgs: args, method, auto: true, deleteBranch }), GH_MUTATION_TIMEOUT_MS);
-      }
-    });
-    if (confirmation === "merged") return { mergeStatus: "merged" };
-    if (confirmation === "enqueued") return { mergeStatus: "auto-merge-enqueued" };
-    return { mergeStatus: "failed", error: "auto-merge did not stick \u2014 GitHub reported no autoMergeRequest after enqueue; retry once the PR has a pending check" };
-  };
-  try {
-    await io.gh(buildPrMergeArgs({ number: prNumber, repoArgs: args, method, auto: true, deleteBranch }), GH_MUTATION_TIMEOUT_MS);
-  } catch (e) {
-    const message = String(e.message || "");
-    if (/already been merged/i.test(message)) return { mergeStatus: "merged" };
-    const note = timeoutKillNote(e, GH_MUTATION_TIMEOUT_MS);
-    if (note) return { mergeStatus: "failed", error: note };
-    if (mergeAutoRejectedPrAlreadyClean(message)) {
-      try {
-        await io.gh(buildPrMergeArgs({ number: prNumber, repoArgs: args, method, auto: false, deleteBranch }), GH_MUTATION_TIMEOUT_MS);
-      } catch (e2) {
-        const m2 = String(e2.message || "");
-        if (/already been merged/i.test(m2)) return { mergeStatus: "merged" };
-        if (!ghPrMergeLocalBranchDeleteWarning(m2)) {
-          const afterDirect = await readMergeState();
-          if (afterDirect.ok && afterDirect.state === "MERGED") return { mergeStatus: "merged" };
-          if (!afterDirect.ok) {
-            return { mergeStatus: "failed", error: `could not confirm PR state after clean-status fallback: ${afterDirect.error}` };
-          }
-          try {
-            await io.gh(buildPrMergeArgs({ number: prNumber, repoArgs: args, method, auto: true, deleteBranch }), GH_MUTATION_TIMEOUT_MS);
-          } catch (e3) {
-            const m3 = String(e3.message || "");
-            if (/already been merged/i.test(m3)) return { mergeStatus: "merged" };
-            const afterRetry = await readMergeState();
-            if (afterRetry.ok && afterRetry.state === "MERGED") return { mergeStatus: "merged" };
-            const stuck = (await io.gh(["pr", "view", prNumber, ...args, "--json", "autoMergeRequest", "--jq", '.autoMergeRequest // ""'], GC_GH_TIMEOUT_MS2).catch(() => "")).trim();
-            if (stuck) return { mergeStatus: "auto-merge-enqueued" };
-            return { mergeStatus: "failed", error: `${ghFailureReason(e2)} (re-enqueue also failed: ${ghFailureReason(e3)})` };
-          }
-          return confirmEnqueueOutcome();
-        }
-      }
-      const stateRead = await readMergeState();
-      if (stateRead.ok && stateRead.state === "MERGED") return { mergeStatus: "merged" };
-      return {
-        mergeStatus: "failed",
-        error: stateRead.ok ? "direct merge did not land after clean-status fallback" : `could not confirm PR state after clean-status fallback: ${stateRead.error}`
-      };
-    }
-    if (ghPrMergeLocalBranchDeleteWarning(message)) {
-      const stateRead = await readMergeState();
-      if (stateRead.ok && stateRead.state === "MERGED") return { mergeStatus: "merged" };
-      return {
-        mergeStatus: "failed",
-        error: stateRead.ok ? message.split("\n")[0] : `could not confirm PR state after local branch cleanup warning: ${stateRead.error}`
-      };
-    }
-    if (!basePolicyBlocksImmediateMerge(message)) {
-      return { mergeStatus: "failed", error: ghFailureReason(e) };
-    }
-    return { mergeStatus: "failed", error: `merge blocked: ${ghFailureReason(e)} \u2014 ensure checks are green` };
-  }
-  return confirmEnqueueOutcome();
+function refAbsenceNote(bin, refSupported) {
+  return refSupported ? "" : `
+  Note: \`${bin}\` has no \`--ref\` option; the marketplace manifest pins the released branch, so none is needed (#2516).`;
 }
-async function remoteBranchExists2(branch, options = {}) {
-  return checkRemoteBranchExists(branch, {
-    execGit: async (args) => (await execFileP2("git", args, { timeout: GIT_TIMEOUT_MS })).stdout
-  }, options);
+var PLUGIN_READ_REPO2 = "mutmutco/MMI-Hub";
+function pluginReadGrantNote(login = "<your-github-login>") {
+  return `
+  If the reinstall 404s on ${PLUGIN_READ_REPO2}, you lack read on it. An org owner must grant it (idempotent):
+  gh api -X PUT repos/${PLUGIN_READ_REPO2}/collaborators/${login} -f permission=pull`;
 }
-var COMPOSE_TIMEOUT_MS = 12e4;
-function spawnDeferredGcSweep() {
-  spawnDetachedSelf(["worktree", "gc", "sweep-deferred", "--quiet"], { spawn: import_node_child_process11.spawn, execPath: process.execPath, scriptPath: process.argv[1] });
+async function applyPluginHeal(surface, log, opts) {
+  if (!opts?.force && surfaceToken(surface) !== "claude") return false;
+  const tableSteps = PLUGIN_SURFACE_HEAL.claude.healSteps;
+  if (!tableSteps) return false;
+  const refSupported = await marketplaceAddRefSupported("claude");
+  const { steps } = adaptHealStepsForRefSupport(tableSteps, refSupported);
+  log(healBannerLine("claude", "claude", refSupported));
+  const pinsPath = (0, import_node_path24.join)((0, import_node_os6.homedir)(), ...KNOWN_MARKETPLACES_RELATIVE);
+  const pins = captureMarketplacePins(readKnownMarketplacesFile(pinsPath), [MMI_MARKETPLACE_NAME, JERV_MARKETPLACE_NAME]);
+  for (const step of steps) {
+    if (healStepAborts(step, await runClaudePlugin([...step.args]))) return false;
+  }
+  const restored = restoreMarketplacePinsOnDisk(pinsPath, pins);
+  if (restored) log(`  ${restored}`);
+  return true;
 }
-async function createDeferredWorktreeStore() {
+async function healClaudePluginForDoctor(surface = detectSurface(process.env)) {
+  if (surfaceToken(surface) !== "claude") {
+    return { ok: false, detail: `not a Claude surface (${surface}) \u2014 no Hub-shipped plugin to reinstall` };
+  }
+  const steps = [];
+  const ok = await applyPluginHeal(surface, (msg) => steps.push(msg.trim()));
+  const pinNote = steps.find((s) => s.startsWith("re-pinned ") || s.includes("re-pin by hand"));
+  return {
+    ok,
+    detail: ok ? `marketplace remove \u2192 add \u2192 install succeeded${pinNote ? `; ${pinNote}` : ""}` : `\`claude plugin\` reinstall failed or was skipped${steps.length ? ` (${steps[steps.length - 1]})` : ""}`
+  };
+}
+function readKnownMarketplacesFile(path2) {
   try {
-    const { stdout } = await execFileP2("git", ["rev-parse", "--git-common-dir"], { timeout: GIT_TIMEOUT_MS });
-    return makeDeferredWorktreeStore(deferredWorktreesRegistryPath(stdout.trim()));
+    return (0, import_node_fs25.existsSync)(path2) ? (0, import_node_fs25.readFileSync)(path2, "utf8") : void 0;
   } catch {
     return void 0;
   }
 }
-var realWorktreeDirRemover = {
-  probe: (p) => {
-    let st;
-    try {
-      st = (0, import_node_fs25.lstatSync)(p);
-    } catch {
-      return null;
-    }
-    if (st.isSymbolicLink()) return "link";
-    try {
-      (0, import_node_fs25.readlinkSync)(p);
-      return "link";
-    } catch {
-    }
-    return st.isDirectory() ? "dir" : "file";
-  },
-  readdir: (p) => {
-    try {
-      return (0, import_node_fs25.readdirSync)(p);
-    } catch {
-      return [];
-    }
-  },
-  // A directory reparse point (junction / dir-symlink) is detached with rmdir (unlinks the mount point,
-  // leaving the target); a file symlink with unlink. rmdir first, fall back to unlink.
-  detachLink: (p) => {
-    try {
-      (0, import_node_fs25.rmdirSync)(p);
-    } catch {
-      (0, import_node_fs25.unlinkSync)(p);
-    }
-  },
-  removeTree: (p) => (0, import_promises6.rm)(p, { recursive: true, force: true, maxRetries: 5, retryDelay: 200 })
-};
-async function resolvePrimaryCheckout(execGit) {
+function restoreMarketplacePinsOnDisk(path2, pins) {
+  if (pins.size === 0) return void 0;
+  const after = readKnownMarketplacesFile(path2);
+  const next = restoreMarketplacePins(after, pins);
+  if (next === null) return void 0;
   try {
-    return parseWorktreePorcelain(await execGit(["worktree", "list", "--porcelain"]))[0]?.path;
+    (0, import_node_fs25.writeFileSync)(path2, next, "utf8");
   } catch {
-    return void 0;
+    return `could NOT restore ${[...pins.keys()].join(", ")} \u2014 re-pin by hand`;
   }
+  const verify = readKnownMarketplacesFile(path2);
+  const failed = [...pins].filter(([name, want]) => {
+    const got = readKnownMarketplace(verify, name);
+    return typeof want.autoUpdate === "boolean" && got.declared !== want.autoUpdate || want.ref !== void 0 && got.ref !== want.ref;
+  });
+  return failed.length ? `restore did NOT take for ${failed.map(([n]) => n).join(", ")} \u2014 re-pin by hand` : `re-pinned ${[...pins.keys()].join(", ")} (auto-update + catalog ref survive the reinstall)`;
 }
-function worktreeRemoveDeps(execGit) {
-  return {
-    git: execGit,
-    sleep: (ms) => new Promise((resolve5) => setTimeout(resolve5, ms)),
-    // #3064: unlink any reparse point (esp. a `node_modules` junction to base) before the git-native
-    // `worktree remove --force`, which would otherwise recurse through it and empty the base checkout.
-    detachReparsePoints: (worktreePath) => detachReparsePoints(worktreePath, realWorktreeDirRemover),
-    removeWorktreeDir: async (worktreePath) => removeWorktreeTree(worktreePath, await resolvePrimaryCheckout(execGit), realWorktreeDirRemover)
-  };
-}
-async function worktreeHasStageState(worktreePath) {
-  if (stageStateFileBelongsToWorktree(stageStatePath(worktreePath), worktreePath)) return true;
+async function runGuard(readOrigin) {
   try {
-    const { stdout } = await execFileP2("git", ["-C", worktreePath, "rev-parse", "--path-format=absolute", "--git-common-dir"], { timeout: GIT_TIMEOUT_MS });
-    const globalPath = stageGlobalStatePath(worktreePath, stdout.trim());
-    return stageStateFileBelongsToWorktree(globalPath, worktreePath);
+    const surface = detectSurface(process.env);
+    if (surfaceToken(surface) !== "claude") {
+      process.exitCode = 0;
+      return;
+    }
+    const isOrgRepo = readOrigin ? await isOrgRepoRoot(readOrigin) : await isOrgRepoRoot();
+    const input = snapshotPluginGuardInput(surface, isOrgRepo);
+    const { state } = buildPluginGuardDecision(input);
+    const { line, exitCode } = buildPluginGuardLine(state);
+    if (line) console.error(line);
+    process.exitCode = exitCode;
   } catch {
-    return false;
+    process.exitCode = 0;
   }
 }
-function stageStateFileBelongsToWorktree(statePath, worktreePath) {
-  if (!(0, import_node_fs25.existsSync)(statePath)) return false;
-  try {
-    const state = JSON.parse((0, import_node_fs25.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));
-  } catch {
-    return false;
+async function runPluginHeal(surface = detectSurface(process.env)) {
+  if (surfaceToken(surface) !== "claude") {
+    console.log(nonClaudeSurfaceHealMessage(surfaceToken(surface) ?? void 0));
+    return;
+  }
+  const descriptor = PLUGIN_SURFACE_HEAL.claude;
+  const healed = await applyPluginHeal(surface, console.log, { force: true });
+  if (healed) {
+    console.log(`  \u2713 MMI plugin reinstalled \u2014 ${reloadAction(surface)} to load MMI commands`);
+  } else {
+    const refSupported = await marketplaceAddRefSupported("claude");
+    const recovery = refSupported ? descriptor.recovery : recoveryWithoutRef(descriptor.recovery);
+    const note = refAbsenceNote("claude", refSupported);
+    console.log(`  \u2717 Auto-heal failed or was skipped. Run manually:
+  ${recovery}${note}${pluginReadGrantNote()}`);
   }
-}
-function teardownWorktreeStage(worktreePath) {
-  return runWorktreeStageTeardown(worktreePath, {
-    hasStageState: worktreeHasStageState,
-    stopRecordedStage: async (wt) => (await stopStage({ cwd: wt, requiredIdentityCwd: wt })).pid,
-    listComposeProjects: async () => {
-      const { stdout } = await execFileP2("docker", ["compose", "ls", "--all", "--format", "json"], { timeout: GC_GH_TIMEOUT_MS2 });
-      return parseComposeLs(stdout);
-    },
-    composeDown: async (project2) => {
-      await execFileP2("docker", ["compose", "-p", project2, "down", "-v"], { timeout: COMPOSE_TIMEOUT_MS });
-    }
-  });
 }
 
-// src/pr-checks-rest.ts
-var REST_GH_TIMEOUT_MS = 2e4;
-async function defaultGhApi(args) {
-  const { stdout } = await execFileP2("gh", ["api", ...args], { timeout: REST_GH_TIMEOUT_MS });
-  return stdout;
-}
-function classifyCheckRun(run) {
-  if (run.status !== "completed") return "pending";
-  switch (run.conclusion) {
-    case "success":
-    case "neutral":
-    case "skipped":
-      return "pass";
-    case "failure":
-    case "timed_out":
-    case "cancelled":
-    case "action_required":
-    case "startup_failure":
-    case "stale":
-      return "fail";
-    default:
-      return "pending";
+// src/worktree-ownership.ts
+var import_node_fs26 = require("node:fs");
+var import_node_os7 = require("node:os");
+var import_node_path25 = require("node:path");
+var OWNERS_FILE = "worktree-owners.json";
+var EVENTS_FILE = "worktree-events.jsonl";
+var WORKTREE_ACTIVITY_WINDOW_MS = 30 * 6e4;
+var SESSION_ID_ENV_VARS = ["MMI_SESSION_ID", "CLAUDE_SESSION_ID", "CODEX_SESSION_ID", "CURSOR_SESSION_ID"];
+function readSessionId(env) {
+  for (const key of SESSION_ID_ENV_VARS) {
+    const value = env[key]?.trim();
+    if (value) return value;
   }
+  return void 0;
 }
-function classifyCommitStatus(state) {
-  if (state === "success") return "pass";
-  if (state === "failure" || state === "error") return "fail";
-  return "pending";
+function describeActor(input) {
+  const session = readSessionId(input.env);
+  return {
+    surface: input.surface,
+    host: input.host ?? (0, import_node_os7.hostname)(),
+    pid: input.pid ?? process.pid,
+    cwd: input.cwd,
+    ...session ? { session } : {}
+  };
 }
-function dedupeLatestCheckRuns(runs) {
-  const byIdentity = /* @__PURE__ */ new Map();
-  const unkeyed = [];
-  for (const run of runs) {
-    if (!run.name || typeof run.id !== "number") {
-      unkeyed.push(run);
-      continue;
-    }
-    const key = `${run.app_id ?? "unknown-app"}:${run.name}`;
-    const prior = byIdentity.get(key);
-    if (!prior || run.id >= (prior.id ?? 0)) byIdentity.set(key, run);
-  }
-  return [...byIdentity.values(), ...unkeyed];
+function sameSession(a, b) {
+  return Boolean(a?.session && b?.session && a.session === b.session);
 }
-function derivePollState(buckets) {
-  if (!buckets.length) return "no-checks-reported";
-  const anyFailure = buckets.includes("fail");
-  const anyPending = buckets.includes("pending");
-  if (anyFailure) return anyPending ? "failing" : "failure";
-  return anyPending ? "pending" : "success";
+function worktreeOwnersPath(primaryRoot) {
+  return repoRuntimeStatePath(primaryRoot, OWNERS_FILE);
 }
-function parseNdjsonLines(stdout) {
-  return stdout.split(/\r?\n/).filter((line) => line.trim()).map((line) => JSON.parse(line));
+function worktreeEventsPath(primaryRoot) {
+  return repoRuntimeStatePath(primaryRoot, EVENTS_FILE);
 }
-function parseRestPrSnapshot(json) {
-  const pr2 = json ?? {};
-  const headSha = pr2.head?.sha ?? "";
-  if (!headSha) throw new Error("pulls endpoint returned no head SHA");
-  const headRepo = pr2.head?.repo?.full_name;
-  const baseRepo = pr2.base?.repo?.full_name;
-  return {
-    headSha,
-    headRef: pr2.head?.ref ?? "",
-    // Only call it a fork when BOTH names are known and differ — an absent name (private/deleted fork)
-    // must not read as same-repo and send a git-ref probe at a branch the base repo does not have.
-    headIsFork: Boolean(headRepo && baseRepo && headRepo !== baseRepo),
-    mergeable: pr2.mergeable === true ? "MERGEABLE" : pr2.mergeable === false ? "CONFLICTING" : "UNKNOWN",
-    baseRef: pr2.base?.ref ?? "development",
-    merged: pr2.merged === true,
-    state: pr2.state ?? ""
+function sameWorktreePath(a, b, platform2 = process.platform) {
+  const norm = (p) => {
+    const unified = p.replace(/\\/g, "/").replace(/\/+$/, "");
+    return platform2 === "win32" || platform2 === "darwin" ? unified.toLowerCase() : unified;
   };
+  return norm(a) === norm(b);
 }
-async function fetchBranchTipSha(repo, ref, gh = defaultGhApi) {
-  if (!ref) return null;
+function isActor(value) {
+  if (!value || typeof value !== "object") return false;
+  const a = value;
+  return typeof a.surface === "string" && typeof a.host === "string" && typeof a.pid === "number" && typeof a.cwd === "string";
+}
+function parseWorktreeOwners(text) {
+  let parsed;
   try {
-    const parsed = JSON.parse(await gh([`repos/${repo}/git/ref/heads/${ref}`]));
-    const sha = parsed.object?.sha;
-    return typeof sha === "string" && sha ? sha : null;
+    parsed = JSON.parse(text);
   } catch {
-    return null;
+    return [];
   }
+  if (!parsed || !Array.isArray(parsed.entries)) return [];
+  return parsed.entries.filter((e) => {
+    if (!e || typeof e !== "object") return false;
+    const entry = e;
+    return typeof entry.path === "string" && entry.path.length > 0 && typeof entry.branch === "string" && typeof entry.createdAt === "string" && typeof entry.lastSeenAt === "string" && isActor(entry.actor);
+  });
 }
-async function fetchRestPrSnapshot(prNumber, repo, gh = defaultGhApi) {
-  return parseRestPrSnapshot(JSON.parse(await gh([`repos/${repo}/pulls/${prNumber}`])));
-}
-async function fetchHeadCheckRuns(headSha, repo, gh) {
-  const runsOut = await gh(["--paginate", `repos/${repo}/commits/${headSha}/check-runs?per_page=100`, "--jq", ".check_runs[] | {id, name, status, conclusion, app_id: .app.id}"]);
-  return dedupeLatestCheckRuns(parseNdjsonLines(runsOut));
+function serializeWorktreeOwners(entries) {
+  return `${JSON.stringify({ entries }, null, 2)}
+`;
 }
-async function fetchHeadCheckBuckets(headSha, repo, gh) {
-  const [runs, statusesOut] = await Promise.all([
-    fetchHeadCheckRuns(headSha, repo, gh),
-    gh(["--paginate", `repos/${repo}/commits/${headSha}/status?per_page=100`, "--jq", ".statuses[] | {context, state}"])
-  ]);
-  const statuses = parseNdjsonLines(statusesOut);
-  return [...runs.map(classifyCheckRun), ...statuses.map((s) => classifyCommitStatus(s.state))];
+function upsertWorktreeOwner(entries, entry) {
+  return [...entries.filter((e) => !sameWorktreePath(e.path, entry.path)), entry];
+}
+function withoutWorktreeOwner(entries, path2) {
+  return entries.filter((e) => !sameWorktreePath(e.path, path2));
+}
+function findWorktreeOwner(entries, path2) {
+  return entries.find((e) => sameWorktreePath(e.path, path2));
+}
+function decideWorktreeRemoval(input) {
+  if (input.force) return { action: "proceed", reason: "forced" };
+  const owner = input.owner;
+  if (!owner) return { action: "proceed", reason: "no-owner" };
+  if (sameSession(owner.actor, input.actor)) return { action: "proceed", reason: "self-directed" };
+  const windowMs = input.windowMs ?? WORKTREE_ACTIVITY_WINDOW_MS;
+  const lastSeen = Date.parse(owner.lastSeenAt) || Date.parse(owner.createdAt);
+  const idleMs = Number.isFinite(lastSeen) ? input.now - lastSeen : 0;
+  if (idleMs >= windowMs) return { action: "proceed", reason: "inactive" };
+  const minutes = Math.max(1, Math.round(idleMs / 6e4));
+  return {
+    action: "refuse",
+    reason: "recently-active",
+    message: `${input.path} was created by another session (${describeActorShort(owner.actor)}) and last active ${minutes} minute(s) ago. A worktree this fresh is not abandoned \u2014 it is a session's working tree before its first commit, which is exactly the window work has been lost in (MMI-Hub#3580). Leave it, or pass --force to remove it anyway.`
+  };
 }
-async function pollRestPrChecks(prNumber, repo, gh = defaultGhApi) {
-  const snapshot = await fetchRestPrSnapshot(prNumber, repo, gh);
-  return derivePollState(await fetchHeadCheckBuckets(snapshot.headSha, repo, gh));
+function describeActorShort(actor) {
+  return `${actor.surface} pid ${actor.pid} on ${actor.host}${actor.session ? ` session ${actor.session}` : ""}`;
 }
-async function pollRestPrMergeable(prNumber, repo, gh = defaultGhApi) {
+function readOwners(primaryRoot) {
   try {
-    return (await fetchRestPrSnapshot(prNumber, repo, gh)).mergeable;
+    return parseWorktreeOwners((0, import_node_fs26.readFileSync)(worktreeOwnersPath(primaryRoot), "utf8"));
   } catch {
-    return "UNKNOWN";
+    return [];
   }
 }
-async function pollRestPrMerged(prNumber, repo, gh = defaultGhApi) {
+function writeOwners(primaryRoot, entries) {
   try {
-    return (await fetchRestPrSnapshot(prNumber, repo, gh)).merged;
+    const path2 = worktreeOwnersPath(primaryRoot);
+    (0, import_node_fs26.mkdirSync)((0, import_node_path25.dirname)(path2), { recursive: true });
+    (0, import_node_fs26.writeFileSync)(path2, serializeWorktreeOwners(entries), "utf8");
   } catch {
-    return false;
   }
 }
-var CI_BUDGET_ANNOTATION_TITLE = "CI budget exceeded";
-var CI_DISK_ANNOTATION_TITLE = "CI runner disk";
-var CI_TOOLCHAIN_ANNOTATION_TITLE = "CI runner toolchain";
-var RUNNER_INFRA_ANNOTATION_TITLES = /* @__PURE__ */ new Set([
-  CI_BUDGET_ANNOTATION_TITLE,
-  CI_DISK_ANNOTATION_TITLE,
-  CI_TOOLCHAIN_ANNOTATION_TITLE
-]);
-function isErrorAnnotation(a) {
-  const level = a.annotation_level?.toLowerCase();
-  return level === "failure" || level === "error";
+function readWorktreeOwners(primaryRoot) {
+  return readOwners(primaryRoot);
 }
-function classifyFailedChecks(failing) {
-  const infraFailures = [];
-  const otherFailures = [];
-  for (const check of failing) {
-    const errors = check.annotations.filter(isErrorAnnotation);
-    const allInfra = errors.length > 0 && errors.every((a) => RUNNER_INFRA_ANNOTATION_TITLES.has(a.title?.trim() ?? ""));
-    (allInfra ? infraFailures : otherFailures).push(check.name);
-  }
-  if (infraFailures.length && !otherFailures.length) {
-    return {
-      cause: "runner-infra",
-      infraFailures,
-      otherFailures,
-      reason: `${infraFailures.length} check(s) failed on RUNNER INFRASTRUCTURE, not your diff: ${infraFailures.join(", ")}. No test failed \u2014 the shared runner hit a wall-clock budget kill, ran out of disk, or was missing a toolchain (the check annotation names which). Re-run once the runner drains/heals (gh run rerun --failed); do not debug the diff.`
-    };
-  }
-  return {
-    cause: "checks-failure",
-    infraFailures,
-    otherFailures,
-    reason: infraFailures.length ? `checks failed: ${otherFailures.join(", ")}; separately, ${infraFailures.join(", ")} failed on runner infrastructure, not a test.` : `checks failed: ${otherFailures.join(", ") || "unknown"}.`
-  };
+function lookupWorktreeOwner(primaryRoot, path2) {
+  return findWorktreeOwner(readOwners(primaryRoot), path2);
 }
-async function diagnoseFailedRestChecks(prNumber, repo, gh = defaultGhApi) {
+function recordWorktreeOwner(primaryRoot, entry) {
+  writeOwners(primaryRoot, upsertWorktreeOwner(readOwners(primaryRoot), entry));
+}
+function touchWorktreeOwner(primaryRoot, path2, at = /* @__PURE__ */ new Date()) {
+  const entries = readOwners(primaryRoot);
+  const owner = findWorktreeOwner(entries, path2);
+  if (!owner) return;
+  writeOwners(primaryRoot, upsertWorktreeOwner(entries, { ...owner, lastSeenAt: at.toISOString() }));
+}
+function dropWorktreeOwner(primaryRoot, path2) {
+  const entries = readOwners(primaryRoot);
+  if (!findWorktreeOwner(entries, path2)) return;
+  writeOwners(primaryRoot, withoutWorktreeOwner(entries, path2));
+}
+function appendWorktreeEvent(primaryRoot, event) {
   try {
-    const snapshot = await fetchRestPrSnapshot(prNumber, repo, gh);
-    if (!snapshot.headIsFork) {
-      const branchTip = await fetchBranchTipSha(repo, snapshot.headRef, gh);
-      if (branchTip && branchTip !== snapshot.headSha) {
-        return {
-          cause: "stale-head",
-          infraFailures: [],
-          otherFailures: [],
-          reason: `the PR head (${snapshot.headSha.slice(0, 7)}) is BEHIND the branch tip (${branchTip.slice(0, 7)}) \u2014 GitHub likely dropped a \`synchronize\` event, so the reported red is a superseded commit and NO run exists for your current push. This is not your diff failing. Re-push (an empty commit is enough) or close and reopen the PR to re-sync the head and trigger a fresh run.`
-        };
-      }
-    }
-    const failing = (await fetchHeadCheckRuns(snapshot.headSha, repo, gh)).filter((run) => classifyCheckRun(run) === "fail" && typeof run.id === "number");
-    if (!failing.length) return null;
-    const annotated = await Promise.all(failing.map(async (run) => ({
-      name: run.name ?? `check-run ${run.id}`,
-      annotations: JSON.parse(await gh([`repos/${repo}/check-runs/${run.id}/annotations`]))
-    })));
-    return classifyFailedChecks(annotated);
+    const path2 = worktreeEventsPath(primaryRoot);
+    (0, import_node_fs26.mkdirSync)((0, import_node_path25.dirname)(path2), { recursive: true });
+    (0, import_node_fs26.appendFileSync)(path2, `${JSON.stringify({ at: event.at ?? (/* @__PURE__ */ new Date()).toISOString(), ...event })}
+`, "utf8");
   } catch {
-    return null;
   }
 }
-async function fetchRestCorePool(gh = defaultGhApi) {
+function readWorktreeEvents(primaryRoot, limit = 50) {
+  let text;
   try {
-    const parsed = JSON.parse(await gh(["rate_limit"]));
-    const core = parsed.resources?.core;
-    if (typeof core?.remaining !== "number" || typeof core?.reset !== "number") return null;
-    return { remaining: core.remaining, reset: core.reset };
+    text = (0, import_node_fs26.readFileSync)(worktreeEventsPath(primaryRoot), "utf8");
   } catch {
-    return null;
+    return [];
+  }
+  const events = [];
+  for (const line of text.split(/\r?\n/)) {
+    if (!line.trim()) continue;
+    try {
+      const parsed = JSON.parse(line);
+      if (parsed && typeof parsed.target === "string" && typeof parsed.action === "string") events.push(parsed);
+    } catch {
+    }
   }
+  return limit > 0 ? events.slice(-limit) : events;
+}
+function formatWorktreeEvents(events) {
+  if (!events.length) {
+    return "worktree events: none recorded yet (this log starts at the first `worktree create` after #3580 landed)";
+  }
+  const lines = [`worktree events: ${events.length} (newest first)`];
+  for (const e of [...events].reverse()) {
+    lines.push(`  ${e.at} ${e.action.toUpperCase()} ${e.target}${e.branch ? ` (branch ${e.branch})` : ""}`);
+    lines.push(`      by: ${e.command} \u2014 ${describeActorShort(e.actor)}`);
+    if (e.owner) lines.push(`      owner: ${describeActorShort(e.owner.actor)}, created ${e.owner.createdAt}, last active ${e.owner.lastSeenAt}`);
+    if (e.reason) lines.push(`      reason: ${e.reason}`);
+  }
+  return lines.join("\n");
 }
 
-// src/worktree-lifecycle-commands.ts
-var import_node_fs26 = require("node:fs");
-var import_node_path25 = require("node:path");
-var GH_TIMEOUT_MS = 2e4;
-var DEFAULT_BASE = "origin/development";
-var DEFAULT_REMOTE = "origin";
-var PROTECTED_BRANCHES2 = /* @__PURE__ */ new Set(["development", "main", "master", "rc"]);
-function slugifyIssueTitle(title) {
-  const slug = title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
-  return slug.slice(0, 50);
+// src/merge-cleanup.ts
+var GC_GH_TIMEOUT_MS2 = 2e4;
+async function advanceClosedIssuesToDone2(prNumber, repoOption) {
+  try {
+    return await resolveBoardAdvanceForPr(prNumber, repoOption);
+  } catch (e) {
+    return { status: "fetch-failed", entries: [], error: e.message };
+  }
 }
-function buildNewBranchName(issueNumber, slug) {
-  const clean4 = slug.replace(/^[-]+|[-]+$/g, "");
-  return clean4 ? `${issueNumber}-${clean4}` : String(issueNumber);
+async function resolveBoardAdvanceForPr(prNumber, repoOption) {
+  const repoArgs = repoOption ? ["--repo", repoOption] : [];
+  const repo = await resolveRepo(repoOption);
+  if (!repo) {
+    return {
+      status: "fetch-failed",
+      entries: [],
+      error: "could not resolve the PR's repo, so a closing reference cannot be proven to belong to this board"
+    };
+  }
+  return advanceClosedIssuesToDone({
+    repo,
+    fetchClosingIssues: async () => {
+      const { stdout } = await execFileP2("gh", ["pr", "view", prNumber, ...repoArgs, "--json", "closingIssuesReferences"], { timeout: GC_GH_TIMEOUT_MS2 });
+      const parsed = JSON.parse(stdout || "null");
+      if (!parsed || typeof parsed !== "object" || !("closingIssuesReferences" in parsed)) {
+        throw new Error("gh returned no closingIssuesReferences field for this PR");
+      }
+      return parsed.closingIssuesReferences;
+    },
+    moveIssueToDone: async (ref) => {
+      const moved = await moveBoardItem({ config: await loadConfigForBoardSelector2(ref, repoOption), selector: ref, status: "Done", repo: repoOption, allowPartial: true });
+      return moved.partial ? { moved: false, error: moved.warning } : { moved: true };
+    }
+  });
 }
-function isIssueRef(target) {
-  return /^#?\d+$/.test(target) || /^[\w.-]+\/[\w.-]+#\d+$/.test(target);
+function recordGcWorktreeRemoval(primaryRoot, actor, owners, path2, branch) {
+  const owner = findWorktreeOwner(owners, path2);
+  appendWorktreeEvent(primaryRoot, {
+    action: "removed",
+    command: "worktree gc",
+    target: path2,
+    branch: branch ?? owner?.branch,
+    actor,
+    owner: owner ? { createdAt: owner.createdAt, lastSeenAt: owner.lastSeenAt, actor: owner.actor } : void 0,
+    reason: owner ? "branch merged/closed or directory dead; owner registration was stale" : "branch merged/closed or directory dead; no owner registered"
+  });
+  dropWorktreeOwner(primaryRoot, path2);
 }
-function worktreeCreatePlan(opts, args) {
-  const target = String(args[0] ?? "");
+function renderGcApplyResult(result) {
+  const lines = ["worktree gc apply result:"];
+  lines.push(`  branches removed: ${result.removedBranches.length ? result.removedBranches.join(", ") : "none"}`);
+  lines.push(`  remote branches removed: ${result.removedRemoteBranches.length ? result.removedRemoteBranches.join(", ") : "none"}`);
+  lines.push(`  tracking refs removed: ${result.removedTrackingRefs.length ? result.removedTrackingRefs.join(", ") : "none"}`);
+  lines.push(`  dead sibling dirs removed: ${result.removedWorktreeDirs.length ? result.removedWorktreeDirs.join(", ") : "none"}`);
+  lines.push(`  stale registrations pruned: ${result.pruned ? "yes" : "no"} (clears registrations only \u2014 never deletes a directory)`);
+  if (result.refused.length) {
+    lines.push(`  refused \u2014 owned by another session (${result.refused.length}):`);
+    for (const r of result.refused) lines.push(`    - ${r}`);
+  }
+  if (result.failed.length) {
+    lines.push(`  failed (${result.failed.length}):`);
+    for (const f of result.failed) lines.push(`    - ${f}`);
+  }
+  const removedNothing = result.removedBranches.length === 0 && result.removedRemoteBranches.length === 0 && result.removedTrackingRefs.length === 0 && result.removedWorktreeDirs.length === 0;
+  if (removedNothing && !result.refused.length) {
+    lines.push("  NOTHING WAS REMOVED. A stale worktree whose directory still exists is not reachable by");
+    lines.push("  this verb \u2014 remove it from inside it with `mmi-cli worktree land --apply`, or delete the");
+    lines.push("  directory and re-run to clear its registration.");
+  }
+  return lines.join("\n");
+}
+async function deleteReviewedRemoteBranch(remote, branch, expectedHeadOid) {
+  if (!isSafeGitRemoteName(remote)) throw new Error(`unsafe remote name ${remote}`);
+  const { stdout } = await execFileP2("git", ["ls-remote", "--heads", remote, branch], { timeout: GIT_TIMEOUT_MS });
+  const line = stdout.trim().split(/\r?\n/).find(Boolean);
+  if (!line) return "already-gone";
+  const remoteHead = line.split(/\s+/)[0]?.trim();
+  if (!remoteHead || remoteHead !== expectedHeadOid) {
+    throw new Error(`${remoteHead || "unknown"} != ${expectedHeadOid}`);
+  }
+  try {
+    await execFileP2("git", [
+      "push",
+      remote,
+      `--force-with-lease=refs/heads/${branch}:${expectedHeadOid}`,
+      `:refs/heads/${branch}`
+    ], { timeout: GH_MUTATION_TIMEOUT_MS });
+  } catch (e) {
+    const after = await execFileP2("git", ["ls-remote", "--heads", remote, branch], { timeout: GIT_TIMEOUT_MS }).catch(() => void 0);
+    if (after && !after.stdout.trim().split(/\r?\n/).find(Boolean)) return "already-gone";
+    throw e;
+  }
+  return "deleted";
+}
+function evaluatePrMergeHousekeeping(report, context, force = false) {
+  const scratch = report.scratch;
+  const failed = scratch?.status === "failed";
+  const prunable = scratch?.safeAuto ?? 0;
+  const unprunable = scratch?.skipped ?? 0;
+  if (!(failed || prunable > 0 || unprunable > 0)) return { blocked: false };
+  if (force) return { blocked: false };
+  const detail = failed ? `scratch housekeeping failed${scratch?.error ? `: ${scratch.error}` : ""}` : `${prunable} prunable + ${unprunable} un-prunable scratch item(s) remain after cleanup`;
   return {
-    command: "worktree create",
-    target,
-    issueForm: isIssueRef(target),
-    claim: Boolean(opts.claim),
-    slug: opts.slug || void 0,
-    from: opts.base || opts.from || DEFAULT_BASE,
-    remote: opts.remote || DEFAULT_REMOTE,
-    repo: opts.repo || void 0,
-    assignee: opts.for || void 0
+    blocked: true,
+    reason: `${context} housekeeping blocked merge: ${detail}. Run \`mmi-cli worktree gc --scratch --apply\` to clear it, then retry \u2014 or re-run \`mmi-cli ${context} --force\` to acknowledge and land anyway. (Kept advisory plans/ scratch never blocks: it is gitignored and can never reach origin.)`
   };
 }
-function landSteps(branch, hasWorktree, hasStage) {
-  const steps = [];
-  if (hasStage) steps.push("stop spawned dev stage");
-  if (hasWorktree) steps.push(`remove worktree (branch ${branch})`);
-  steps.push(`delete local branch ${branch}`);
-  steps.push(`delete remote branch ${branch}`);
-  steps.push("prune worktree metadata");
-  return steps;
+function assertPrMergeHousekeepingClean(startingPath, context, options = {}) {
+  const build = options.buildHousekeeping ?? ((repoRoot2) => buildPrMergeScratchHousekeeping(repoRoot2));
+  const housekeeping = build(startingPath || process.cwd());
+  const verdict = evaluatePrMergeHousekeeping(housekeeping, context, options.force);
+  if (verdict.blocked) throw new Error(verdict.reason);
+  return housekeeping;
 }
-function classifyStaleLeaks(input) {
-  const protectedBranches = input.protectedBranches ?? PROTECTED_BRANCHES2;
-  const leaks = [];
-  const worktreeBranches2 = new Set(input.worktrees.filter((w) => !w.primary).map((w) => w.branch));
-  const stageByPath = new Map(input.stages.map((s) => [s.path, s.port]));
-  for (const wt of input.worktrees) {
-    if (wt.primary) continue;
-    if (protectedBranches.has(wt.branch)) continue;
-    if (input.openPrBranches.has(wt.branch)) continue;
-    if (!input.closedBranches.has(wt.branch)) continue;
-    leaks.push({
-      kind: "stale-worktree",
-      ref: wt.branch,
-      detail: `merged/closed branch ${wt.branch} still checked out at ${wt.path}`,
-      remediation: `cd "${wt.path}" && mmi-cli worktree land --apply  (or: mmi-cli worktree gc --apply)`
+async function applyGcPlan(plan, remote, opts = {}) {
+  const result = { removedBranches: [], removedRemoteBranches: [], removedTrackingRefs: [], removedWorktreeDirs: [], refused: [], failed: [], pruned: false };
+  const beforeWorktrees = parseWorktreePorcelain(
+    (await execFileP2("git", ["worktree", "list", "--porcelain"], { timeout: GIT_TIMEOUT_MS }).catch(() => ({ stdout: "" }))).stdout
+  );
+  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_path26.dirname)((0, import_node_path26.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) => {
+    if (!path2) return false;
+    const owner = findWorktreeOwner(owners, path2);
+    const verdict = decideWorktreeRemoval({ path: path2, owner, actor: gcActor, now: removalNow, force: opts.force });
+    if (verdict.action !== "refuse") return false;
+    result.refused.push(verdict.message);
+    appendWorktreeEvent(primaryRepoRoot, {
+      action: "refused",
+      command: "worktree gc",
+      target: path2,
+      branch: owner?.branch,
+      actor: gcActor,
+      owner: owner ? { createdAt: owner.createdAt, lastSeenAt: owner.lastSeenAt, actor: owner.actor } : void 0,
+      reason: verdict.message
     });
+    return true;
+  };
+  const branchesToClean = plan.branches.filter((b) => !refusesRemoval(b.worktreePath));
+  const worktreeDirsToRemove = plan.worktreeDirs.filter((d) => !refusesRemoval(d.path));
+  const deferredStore = await createDeferredWorktreeStore();
+  const branchTracking = await applyBranchAndTrackingCleanup({ ...plan, branches: branchesToClean }, {
+    localBranchHeads,
+    cleanupBranch: async (branch, expectedHeadOid) => {
+      const wtDeps = worktreeRemoveDeps(async (args) => (await execFileP2("git", args, { timeout: GIT_TIMEOUT_MS })).stdout);
+      const cleanup = await cleanupPrMergeLocalBranch(branch.branch, {
+        beforeWorktrees,
+        startingPath: branch.worktreePath,
+        pathExists: (p) => (0, import_node_fs27.existsSync)(p),
+        execGit: async (args) => (await execFileP2("git", args, { timeout: GIT_TIMEOUT_MS })).stdout,
+        teardownWorktreeStage,
+        deferredStore,
+        expectedHeadOid,
+        detachReparsePoints: wtDeps.detachReparsePoints,
+        // #3064: junction-safe teardown
+        removeWorktreeDir: wtDeps.removeWorktreeDir
+      });
+      if (cleanup.worktree?.status === "removed") {
+        recordGcWorktreeRemoval(primaryRepoRoot, gcActor, owners, cleanup.worktree.path, branch.branch);
+      }
+      return cleanup;
+    },
+    cleanupRemoteBranch: (branch, expectedHeadOid) => deleteReviewedRemoteBranch(remote, branch.branch, expectedHeadOid),
+    cleanupTrackingRefs: (trackingRefs, unsafeBranches) => applyTrackingRefCleanup(trackingRefs, remote, unsafeBranches, {
+      execGit: async (args) => (await execFileP2("git", args, { timeout: GIT_TIMEOUT_MS })).stdout
+    })
+  });
+  result.removedBranches.push(...branchTracking.removedBranches);
+  result.removedRemoteBranches.push(...branchTracking.removedRemoteBranches);
+  result.removedTrackingRefs.push(...branchTracking.removedTrackingRefs);
+  result.failed.push(...branchTracking.failed);
+  const removeDeps = worktreeRemoveDeps(async (args) => (await execFileP2("git", args, { timeout: GIT_TIMEOUT_MS })).stdout);
+  const siblingRoot = opts.root ? resolveExplicitScanRoot(opts.root, primaryRepoRoot) : siblingMmiWorktreesRoot(primaryRepoRoot);
+  for (const wt of worktreeDirsToRemove) {
+    try {
+      const cleanupTarget = resolveSafeSiblingWorktreeCleanupTarget(wt.path, siblingRoot, {
+        realpath: (path2) => (0, import_node_fs27.realpathSync)(path2)
+      });
+      if (!cleanupTarget.ok) {
+        result.failed.push(`${wt.path}: ${cleanupTarget.reason}`);
+        continue;
+      }
+      const stillValid = validateDeadWorktreeDirCleanup(wt, inspectSiblingWorktreeDir(wt.path, worktreeGitRoot));
+      if (!stillValid.ok) {
+        result.failed.push(`${wt.path}: skipped dead-dir removal (${stillValid.reason})`);
+        continue;
+      }
+      const contentSafe = validateDeadWorktreeDirContent(wt, inspectDeadWorktreeDirContent(wt.path));
+      if (!contentSafe.ok) {
+        result.failed.push(`${wt.path}: skipped dead-dir removal (${contentSafe.reason})`);
+        continue;
+      }
+      await removeDeps.removeWorktreeDir(cleanupTarget.path);
+      result.removedWorktreeDirs.push(wt.path);
+      recordGcWorktreeRemoval(primaryRepoRoot, gcActor, owners, wt.path, findWorktreeOwner(owners, wt.path)?.branch);
+    } catch (e) {
+      result.failed.push(`${wt.path}: ${e.message.split("\n")[0]}`);
+    }
   }
-  for (const branch of input.localBranches) {
-    if (protectedBranches.has(branch)) continue;
-    if (branch === input.currentBranch) continue;
-    if (input.openPrBranches.has(branch)) continue;
-    if (!input.closedBranches.has(branch)) continue;
-    if (worktreeBranches2.has(branch)) continue;
-    leaks.push({
-      kind: "stale-branch",
-      ref: branch,
-      detail: `merged/closed branch ${branch} has no worktree`,
-      remediation: "mmi-cli worktree gc --apply"
-    });
+  try {
+    await execFileP2("git", ["worktree", "prune"], { timeout: GIT_TIMEOUT_MS });
+    result.pruned = true;
+  } catch (e) {
+    result.failed.push(`worktree prune: ${e.message.split("\n")[0]}`);
   }
-  for (const wt of input.worktrees) {
-    if (wt.primary) continue;
-    const port = stageByPath.get(wt.path);
-    if (port == null) continue;
-    if (input.openPrBranches.has(wt.branch)) continue;
-    if (protectedBranches.has(wt.branch) && !input.closedBranches.has(wt.branch)) continue;
-    if (!input.closedBranches.has(wt.branch)) continue;
-    leaks.push({
-      kind: "stale-stage",
-      ref: wt.branch,
-      detail: `dev stage on port ${port} still running in ${wt.path} (branch ${wt.branch} merged/closed)`,
-      remediation: `cd "${wt.path}" && mmi-cli stage stop --apply`
-    });
+  return result;
+}
+async function pollGhPrChecks(prNumber, repoArgs) {
+  let stdout = "";
+  let stderr = "";
+  try {
+    ({ stdout, stderr } = await execFileP2("gh", ["pr", "checks", prNumber, ...repoArgs], { timeout: GC_GH_TIMEOUT_MS2 }));
+  } catch (e) {
+    const err = e;
+    if (err.killed || err.stdout == null && err.stderr == null) throw e;
+    stdout = err.stdout ?? "";
+    stderr = err.stderr ?? "";
   }
-  const knownPaths = new Set(input.worktrees.map((w) => w.path));
-  for (const dir of input.orphanDirs) {
-    if (knownPaths.has(dir.path)) continue;
-    leaks.push({
-      kind: "orphan-dir",
-      ref: dir.path,
-      // Say only what the inspection proved. `orphaned-folder` proves the `.git` entry is gone while this
-      // repo's worktree metadata still points at the directory — NOT that the directory is empty; gc
-      // checks contents separately, at apply time.
-      detail: dir.reason === "dangling-gitdir" ? "this repo's worktree directory whose git metadata is gone" : "this repo's worktree metadata points here, but the .git entry is gone",
-      // gc --apply re-proves ownership before deleting anything; a raw `rm -rf` does not, so it is never
-      // offered here — following it on a mis-classified dir would destroy another repo's live worktree.
-      remediation: "mmi-cli worktree gc --apply"
-    });
+  const state = parseGhPrChecksResult(stdout, stderr);
+  if (state === "error") {
+    throw new Error(`gh pr checks ${prNumber}: ${(stderr || stdout).trim() || "unknown error"}`);
   }
-  return leaks;
+  return state;
 }
-var defaultOrphanDirScanDeps = {
-  listDirs: (root) => {
-    try {
-      return (0, import_node_fs26.readdirSync)(root, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => (0, import_node_path25.join)(root, e.name));
-    } catch {
-      return [];
-    }
-  },
-  inspect: inspectSiblingWorktreeDir
-};
-function scanOrphanDirs(worktreesRoot, worktreeGitRoot, deps = defaultOrphanDirScanDeps) {
-  const candidates = [];
-  for (const dir of deps.listDirs(worktreesRoot)) {
-    const { cleanup } = classifySiblingWorktreeDir(deps.inspect(dir, worktreeGitRoot));
-    if (cleanup) candidates.push({ path: dir, reason: cleanup.reason });
-  }
-  return candidates;
+function ghFailureReason(e) {
+  const err = e;
+  const head = String(err?.message ?? "").split("\n")[0]?.trim() ?? "";
+  const detail = `${err?.stderr ?? ""}
+${err?.stdout ?? ""}`.split("\n").map((line) => line.trim()).find((line) => line.length > 0);
+  if (detail && head) return `${head} \u2014 ${detail}`;
+  return detail || head || "unknown error";
 }
-function formatStaleLeaks(leaks) {
-  if (!leaks.length) return "worktree list --stale: no leaks found";
-  const lines = [`worktree list --stale: ${leaks.length} leak(s)`];
-  for (const leak of leaks) {
-    lines.push(`  [${leak.kind}] ${leak.ref} \u2014 ${leak.detail}`);
-    lines.push(`      fix: ${leak.remediation}`);
+var defaultGhMergeAutoIo = {
+  gh: async (args, timeoutMs) => (await execFileP2("gh", args, { timeout: timeoutMs })).stdout
+};
+async function ghMergeAutoEnqueue(prNumber, repo, method, io = defaultGhMergeAutoIo) {
+  const args = repo ? ["--repo", repo] : [];
+  const headRef = (await io.gh(["pr", "view", prNumber, ...args, "--json", "headRefName", "--jq", ".headRefName"], GC_GH_TIMEOUT_MS2).catch(() => "")).trim();
+  const deleteBranch = !isProtectedBranch(headRef);
+  const readMergeState = () => readGhPrStateWithRetry(
+    () => io.gh(["pr", "view", prNumber, ...args, "--json", "state", "--jq", ".state"], GC_GH_TIMEOUT_MS2)
+  );
+  const confirmEnqueueOutcome = async () => {
+    const stateRead = await readMergeState();
+    if (!stateRead.ok) {
+      return { mergeStatus: "failed", error: `could not read PR state after merge: ${stateRead.error}` };
+    }
+    if (stateRead.state === "MERGED") return { mergeStatus: "merged" };
+    const confirmation = await confirmAutoMergeEnqueued({
+      readAutoMergeRequest: async () => io.gh(["pr", "view", prNumber, ...args, "--json", "autoMergeRequest", "--jq", '.autoMergeRequest // ""'], GC_GH_TIMEOUT_MS2),
+      readMerged: async () => {
+        const s = await readMergeState();
+        return s.ok && s.state === "MERGED";
+      },
+      reEnqueue: async () => {
+        await io.gh(buildPrMergeArgs({ number: prNumber, repoArgs: args, method, auto: true, deleteBranch }), GH_MUTATION_TIMEOUT_MS);
+      }
+    });
+    if (confirmation === "merged") return { mergeStatus: "merged" };
+    if (confirmation === "enqueued") return { mergeStatus: "auto-merge-enqueued" };
+    return { mergeStatus: "failed", error: "auto-merge did not stick \u2014 GitHub reported no autoMergeRequest after enqueue; retry once the PR has a pending check" };
+  };
+  try {
+    await io.gh(buildPrMergeArgs({ number: prNumber, repoArgs: args, method, auto: true, deleteBranch }), GH_MUTATION_TIMEOUT_MS);
+  } catch (e) {
+    const message = String(e.message || "");
+    if (/already been merged/i.test(message)) return { mergeStatus: "merged" };
+    const note = timeoutKillNote(e, GH_MUTATION_TIMEOUT_MS);
+    if (note) return { mergeStatus: "failed", error: note };
+    if (mergeAutoRejectedPrAlreadyClean(message)) {
+      try {
+        await io.gh(buildPrMergeArgs({ number: prNumber, repoArgs: args, method, auto: false, deleteBranch }), GH_MUTATION_TIMEOUT_MS);
+      } catch (e2) {
+        const m2 = String(e2.message || "");
+        if (/already been merged/i.test(m2)) return { mergeStatus: "merged" };
+        if (!ghPrMergeLocalBranchDeleteWarning(m2)) {
+          const afterDirect = await readMergeState();
+          if (afterDirect.ok && afterDirect.state === "MERGED") return { mergeStatus: "merged" };
+          if (!afterDirect.ok) {
+            return { mergeStatus: "failed", error: `could not confirm PR state after clean-status fallback: ${afterDirect.error}` };
+          }
+          try {
+            await io.gh(buildPrMergeArgs({ number: prNumber, repoArgs: args, method, auto: true, deleteBranch }), GH_MUTATION_TIMEOUT_MS);
+          } catch (e3) {
+            const m3 = String(e3.message || "");
+            if (/already been merged/i.test(m3)) return { mergeStatus: "merged" };
+            const afterRetry = await readMergeState();
+            if (afterRetry.ok && afterRetry.state === "MERGED") return { mergeStatus: "merged" };
+            const stuck = (await io.gh(["pr", "view", prNumber, ...args, "--json", "autoMergeRequest", "--jq", '.autoMergeRequest // ""'], GC_GH_TIMEOUT_MS2).catch(() => "")).trim();
+            if (stuck) return { mergeStatus: "auto-merge-enqueued" };
+            return { mergeStatus: "failed", error: `${ghFailureReason(e2)} (re-enqueue also failed: ${ghFailureReason(e3)})` };
+          }
+          return confirmEnqueueOutcome();
+        }
+      }
+      const stateRead = await readMergeState();
+      if (stateRead.ok && stateRead.state === "MERGED") return { mergeStatus: "merged" };
+      return {
+        mergeStatus: "failed",
+        error: stateRead.ok ? "direct merge did not land after clean-status fallback" : `could not confirm PR state after clean-status fallback: ${stateRead.error}`
+      };
+    }
+    if (ghPrMergeLocalBranchDeleteWarning(message)) {
+      const stateRead = await readMergeState();
+      if (stateRead.ok && stateRead.state === "MERGED") return { mergeStatus: "merged" };
+      return {
+        mergeStatus: "failed",
+        error: stateRead.ok ? message.split("\n")[0] : `could not confirm PR state after local branch cleanup warning: ${stateRead.error}`
+      };
+    }
+    if (!basePolicyBlocksImmediateMerge(message)) {
+      return { mergeStatus: "failed", error: ghFailureReason(e) };
+    }
+    return { mergeStatus: "failed", error: `merge blocked: ${ghFailureReason(e)} \u2014 ensure checks are green` };
   }
-  return lines.join("\n");
-}
-async function repoRootOf() {
-  return (await execFileP2("git", ["rev-parse", "--show-toplevel"], { timeout: GIT_TIMEOUT_MS }).catch(() => ({ stdout: "" }))).stdout.trim() || process.cwd();
-}
-function classifyLandBranchMergeState(prs) {
-  if (!prs) return { state: "unknown", numbers: [] };
-  if (!prs.length) return { state: "no-pr", numbers: [] };
-  const pick = (s) => prs.filter((pr2) => pr2.state.toUpperCase() === s).map((pr2) => pr2.number);
-  const open2 = pick("OPEN");
-  if (open2.length) return { state: "open", numbers: open2 };
-  const known = /* @__PURE__ */ new Set(["OPEN", "CLOSED", "MERGED"]);
-  const unrecognised = prs.filter((pr2) => !known.has(pr2.state.toUpperCase()));
-  if (unrecognised.length) return { state: "unknown", numbers: prs.map((pr2) => pr2.number) };
-  const merged = pick("MERGED");
-  if (!merged.length) return { state: "closed-unmerged", numbers: prs.map((pr2) => pr2.number) };
-  if (merged.length < prs.length) return { state: "mixed", numbers: prs.map((pr2) => pr2.number) };
-  return { state: "merged", numbers: merged };
+  return confirmEnqueueOutcome();
 }
-function describeLandMergeState(v) {
-  const refs = v.numbers.map((n) => `#${n}`).join(", ");
-  switch (v.state) {
-    case "merged":
-      return `PR ${refs} merged`;
-    case "closed-unmerged":
-      return `PR ${refs} CLOSED \u2014 NOT merged`;
-    case "mixed":
-      return `PR ${refs} \u2014 some merged, some CLOSED unmerged; which one owns the branch head is unproven`;
-    case "open":
-      return `PR ${refs} still OPEN \u2014 NOT merged`;
-    case "no-pr":
-      return "no pull request for this branch";
-    case "unknown":
-      return refs ? `PR ${refs} reported a pull-request state this CLI does not recognise \u2014 merge NOT confirmed` : "pull-request state could not be read \u2014 merge NOT confirmed";
-  }
+async function remoteBranchExists2(branch, options = {}) {
+  return checkRemoteBranchExists(branch, {
+    execGit: async (args) => (await execFileP2("git", args, { timeout: GIT_TIMEOUT_MS })).stdout
+  }, options);
 }
-function decideWorktreeLandRefCleanup(input) {
-  if (input.keepRemote) return { action: "proceed" };
-  const verdict = classifyLandBranchMergeState(input.prs);
-  const refs = verdict.numbers.map((n) => `#${n}`).join(", ");
-  if (verdict.state === "unknown") {
-    return verdict.numbers.length ? {
-      action: "keep-remote",
-      reason: "pr-state-unrecognised",
-      message: `pull request ${refs} for '${input.branch}' reported a state this CLI does not recognise \u2014 keeping the remote branch rather than deleting a ref whose merge is unproven`
-    } : {
-      action: "keep-remote",
-      reason: "pr-state-unreadable",
-      message: `could not read the pull-request state for '${input.branch}' \u2014 keeping the remote branch so an unmerged head ref cannot be deleted on a guess`
-    };
-  }
-  if (verdict.state === "open") {
-    return {
-      action: "refuse",
-      reason: "open-pr",
-      message: `'${input.branch}' still has an OPEN pull request (${refs}). Deleting its head ref would auto-close the PR and leave the work on no branch. Merge it first, or re-run with --keep-remote for a local-only clean`
-    };
-  }
-  if (verdict.state === "mixed") {
-    return {
-      action: "keep-remote",
-      reason: "mixed-pr-state",
-      message: `'${input.branch}' has both a merged and a closed-unmerged pull request (${refs}) and nothing here proves which owns the current head \u2014 keeping the remote branch rather than deleting a ref that may hold unmerged work`
-    };
-  }
-  if (verdict.state === "closed-unmerged") {
-    return {
-      action: "refuse",
-      reason: "unmerged-pr",
-      message: `'${input.branch}' has a pull request that never merged (${refs}). The remote branch is the only thing still holding that work. Re-run with --keep-remote for a local-only clean`
-    };
-  }
-  return { action: "proceed" };
+var COMPOSE_TIMEOUT_MS = 12e4;
+function spawnDeferredGcSweep() {
+  spawnDetachedSelf(["worktree", "gc", "sweep-deferred", "--quiet"], { spawn: import_node_child_process11.spawn, execPath: process.execPath, scriptPath: process.argv[1] });
 }
-async function fetchLandBranchPrs(branch, repo) {
+async function createDeferredWorktreeStore() {
   try {
-    const { stdout } = await execFileP2("gh", [
-      "pr",
-      "list",
-      "--head",
-      branch,
-      "--state",
-      "all",
-      "--limit",
-      "20",
-      ...repo ? ["--repo", repo] : [],
-      "--json",
-      "number,state"
-    ], { timeout: GH_TIMEOUT_MS });
-    const parsed = JSON.parse(stdout.trim() || "null");
-    if (!Array.isArray(parsed)) return void 0;
-    return parsed.filter((pr2) => Boolean(pr2) && typeof pr2 === "object" && typeof pr2.number === "number" && typeof pr2.state === "string").map((pr2) => ({ number: pr2.number, state: pr2.state }));
+    const { stdout } = await execFileP2("git", ["rev-parse", "--git-common-dir"], { timeout: GIT_TIMEOUT_MS });
+    return makeDeferredWorktreeStore(deferredWorktreesRegistryPath(stdout.trim()));
   } catch {
     return void 0;
   }
 }
-async function fetchIssueTitle(repo, number) {
+var realWorktreeDirRemover = {
+  probe: (p) => {
+    let st;
+    try {
+      st = (0, import_node_fs27.lstatSync)(p);
+    } catch {
+      return null;
+    }
+    if (st.isSymbolicLink()) return "link";
+    try {
+      (0, import_node_fs27.readlinkSync)(p);
+      return "link";
+    } catch {
+    }
+    return st.isDirectory() ? "dir" : "file";
+  },
+  readdir: (p) => {
+    try {
+      return (0, import_node_fs27.readdirSync)(p);
+    } catch {
+      return [];
+    }
+  },
+  // A directory reparse point (junction / dir-symlink) is detached with rmdir (unlinks the mount point,
+  // leaving the target); a file symlink with unlink. rmdir first, fall back to unlink.
+  detachLink: (p) => {
+    try {
+      (0, import_node_fs27.rmdirSync)(p);
+    } catch {
+      (0, import_node_fs27.unlinkSync)(p);
+    }
+  },
+  removeTree: (p) => (0, import_promises6.rm)(p, { recursive: true, force: true, maxRetries: 5, retryDelay: 200 })
+};
+async function resolvePrimaryCheckout(execGit) {
   try {
-    const { stdout } = await execFileP2("gh", ["issue", "view", String(number), "--repo", repo, "--json", "title", "--jq", ".title"], { timeout: GH_TIMEOUT_MS });
-    const title = stdout.trim();
-    return title || void 0;
+    return parseWorktreePorcelain(await execGit(["worktree", "list", "--porcelain"]))[0]?.path;
   } catch {
     return void 0;
   }
 }
-async function selfShell(args, timeoutMs) {
-  const scriptPath = process.argv[1];
-  const { stdout } = await execFileP2(process.execPath, [scriptPath, ...args], { timeout: timeoutMs });
-  return stdout;
+function worktreeRemoveDeps(execGit) {
+  return {
+    git: execGit,
+    sleep: (ms) => new Promise((resolve5) => setTimeout(resolve5, ms)),
+    // #3064: unlink any reparse point (esp. a `node_modules` junction to base) before the git-native
+    // `worktree remove --force`, which would otherwise recurse through it and empty the base checkout.
+    detachReparsePoints: (worktreePath) => detachReparsePoints(worktreePath, realWorktreeDirRemover),
+    removeWorktreeDir: async (worktreePath) => removeWorktreeTree(worktreePath, await resolvePrimaryCheckout(execGit), realWorktreeDirRemover)
+  };
 }
-function registerWorktreeCommands(program3) {
-  const worktree2 = program3.commands.find((c) => c.name() === "worktree");
-  if (!worktree2) return;
-  const has = (name) => worktree2.commands.some((c) => c.name() === name);
-  if (has("land") && has("list")) return;
-  if (!has("land")) worktree2.command("land").description("post-merge clean: remove the current worktree, delete its local + origin branch, and stop its dev stage (dry-run by default)").option("--apply", "execute the cleanup (default: dry-run preview)").option("--dry-run", "show what would be removed without doing it (default)").option("--remote <name>", "remote whose branch is deleted", DEFAULT_REMOTE).option("--keep-remote", "do not delete the remote (origin) branch").option("--json", "machine-readable output").action(async (o) => {
-    if (o.apply && o.dryRun) return fail("worktree land: choose either --dry-run or --apply");
-    const apply = Boolean(o.apply);
-    try {
-      const wtPath = (await execFileP2("git", ["rev-parse", "--show-toplevel"], { timeout: GIT_TIMEOUT_MS })).stdout.trim();
-      const branch = (await execFileP2("git", ["rev-parse", "--abbrev-ref", "HEAD"], { timeout: GIT_TIMEOUT_MS })).stdout.trim();
-      if (!wtPath || !branch) return fail("worktree land: not inside a git worktree");
-      if (PROTECTED_BRANCHES2.has(branch)) {
-        return fail(`worktree land: refusing to land protected branch '${branch}'`, { code: ERROR_CODES.ERR_BAD_ENUM });
-      }
-      const gitFile = (0, import_node_path25.join)(wtPath, ".git");
-      const isLinked = (0, import_node_fs26.existsSync)(gitFile) && (0, import_node_fs26.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_path25.dirname)(commonDir) : wtPath;
-      const stageSummary = readStageSummary(wtPath);
-      const hasStage = stageSummary != null;
-      const steps = landSteps(branch, true, hasStage);
-      const plan = {
-        command: "worktree land",
-        branch,
-        worktreePath: wtPath,
-        primaryCheckout,
-        remote: o.remote,
-        hasStage,
-        steps
-      };
-      if (!apply) {
-        const preview = { dryRun: true, ...plan, ...o.keepRemote ? { keepRemote: true } : {} };
-        if (o.json) return console.log(JSON.stringify(preview, null, 2));
-        const lines = [`worktree land: dry-run (pass --apply to execute)`, `  branch: ${branch}`, `  worktree: ${wtPath}`];
-        if (hasStage) lines.push(`  stage: port ${stageSummary.port} (will be stopped)`);
-        if (o.keepRemote) lines.push(`  remote branch: kept (--keep-remote)`);
-        for (const s of steps) lines.push(`  - ${s}`);
-        return console.log(lines.join("\n"));
-      }
-      const landDirty = ((await execFileP2("git", ["-C", wtPath, "status", "--porcelain"], { timeout: GIT_TIMEOUT_MS }).catch(() => ({ stdout: "unreadable" }))).stdout || "").trim().length > 0;
-      if (landDirty) {
-        return fail(`worktree land: refusing to land '${branch}' \u2014 uncommitted changes in ${wtPath}; commit, stash, or remove the worktree manually`, { code: ERROR_CODES.ERR_BAD_ENUM });
-      }
-      const landPrs = await fetchLandBranchPrs(branch);
-      const mergeVerdict = classifyLandBranchMergeState(landPrs);
-      const landRefs = decideWorktreeLandRefCleanup({
-        branch,
-        prs: landPrs,
-        keepRemote: Boolean(o.keepRemote)
-      });
-      if (landRefs.action === "refuse") {
-        return fail(`worktree land: ${landRefs.message}`, { code: ERROR_CODES.ERR_BAD_ENUM });
-      }
-      const keepRemoteBranch = Boolean(o.keepRemote) || landRefs.action === "keep-remote";
-      if (landRefs.action === "keep-remote") console.warn(`worktree land: ${landRefs.message}.`);
-      const report = [];
-      if (hasStage) {
-        try {
-          await stopStage({ cwd: wtPath, requiredIdentityCwd: wtPath });
-          report.push({ step: "stop stage", status: "stopped" });
-        } catch (e) {
-          report.push({ step: "stop stage", status: `failed: ${e.message.split("\n")[0]}` });
-        }
-      }
-      releaseCwdIfUnderWorktree(wtPath, primaryCheckout);
-      const removeOutcome = await removeWorktreeWithRecovery(
-        wtPath,
-        worktreeRemoveDeps(async (args) => (await execFileP2("git", ["-C", primaryCheckout, ...args], { timeout: GIT_TIMEOUT_MS })).stdout)
-      );
-      report.push({
-        step: "remove worktree",
-        status: removeOutcome.status === "removed" ? removeOutcome.recovery ? `done (${removeOutcome.recovery})` : "done" : `failed: ${removeOutcome.error ?? "lock held"} \u2014 run: git -C "${primaryCheckout}" worktree remove --force "${wtPath}"`
-      });
-      report.push(await bestEffortGit(["branch", "-D", branch], primaryCheckout, `delete local branch ${branch}`));
-      if (!keepRemoteBranch) {
-        report.push(await bestEffortGit(["push", o.remote, "--delete", branch], void 0, `delete remote branch ${branch}`, GH_MUTATION_TIMEOUT_MS));
-      } else if (!o.keepRemote) {
-        report.push({ step: `delete remote branch ${branch}`, status: `skipped: ${landRefs.action === "keep-remote" ? landRefs.reason : "kept"}` });
-      }
-      report.push(await bestEffortGit(["worktree", "prune"], primaryCheckout, "prune worktree metadata"));
-      const result = {
-        dryRun: false,
-        ...plan,
-        ...o.keepRemote ? { keepRemote: true } : {},
-        // #3566: the merge outcome, machine-readable, so an orchestrator never has to infer it from the
-        // absence of an error. `merged` is the ONLY value that means the work reached the base branch.
-        mergeState: mergeVerdict.state,
-        prNumbers: mergeVerdict.numbers,
-        report
-      };
-      if (o.json) return console.log(JSON.stringify(result, null, 2));
-      console.log(`worktree land: cleaned up branch ${branch} (${describeLandMergeState(mergeVerdict)})`);
-      for (const r of report) console.log(`  ${r.step}: ${r.status}`);
-      if (mergeVerdict.state !== "merged") {
-        console.warn(`worktree land: '${branch}' was cleaned up but NOT merged \u2014 ${describeLandMergeState(mergeVerdict)}. Do not report this work as shipped.`);
-      }
-      if (report.some((r) => r.status.startsWith("failed"))) process.exitCode = 1;
-    } catch (e) {
-      return failGraceful(`worktree land: ${e.message}`);
+async function worktreeHasStageState(worktreePath) {
+  if (stageStateFileBelongsToWorktree(stageStatePath(worktreePath), worktreePath)) return true;
+  try {
+    const { stdout } = await execFileP2("git", ["-C", worktreePath, "rev-parse", "--path-format=absolute", "--git-common-dir"], { timeout: GIT_TIMEOUT_MS });
+    const globalPath = stageGlobalStatePath(worktreePath, stdout.trim());
+    return stageStateFileBelongsToWorktree(globalPath, worktreePath);
+  } catch {
+    return false;
+  }
+}
+function stageStateFileBelongsToWorktree(statePath, worktreePath) {
+  if (!(0, import_node_fs27.existsSync)(statePath)) return false;
+  try {
+    const state = JSON.parse((0, import_node_fs27.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));
+  } catch {
+    return false;
+  }
+}
+function teardownWorktreeStage(worktreePath) {
+  return runWorktreeStageTeardown(worktreePath, {
+    hasStageState: worktreeHasStageState,
+    stopRecordedStage: async (wt) => (await stopStage({ cwd: wt, requiredIdentityCwd: wt })).pid,
+    listComposeProjects: async () => {
+      const { stdout } = await execFileP2("docker", ["compose", "ls", "--all", "--format", "json"], { timeout: GC_GH_TIMEOUT_MS2 });
+      return parseComposeLs(stdout);
+    },
+    composeDown: async (project2) => {
+      await execFileP2("docker", ["compose", "-p", project2, "down", "-v"], { timeout: COMPOSE_TIMEOUT_MS });
     }
   });
-  if (!has("list")) worktree2.command("list").description("list worktrees; --stale surfaces orphaned worktrees/branches/running dev servers with remediation").option("--stale", "show only leaks (merged/closed branches, orphan dirs, stale dev servers)").option("--json", "machine-readable output").action(async (o) => {
-    try {
-      const ctx = await gatherWorktreeContext();
-      if (o.stale) {
-        const leaks = classifyStaleLeaks(ctx);
-        if (o.json) return console.log(JSON.stringify({ stale: leaks, count: leaks.length }, null, 2));
-        return console.log(formatStaleLeaks(leaks));
-      }
-      if (o.json) return console.log(JSON.stringify({ worktrees: ctx.worktrees }, null, 2));
-      if (!ctx.worktrees.length) return console.log("worktree list: no worktrees");
-      const lines = ["worktree list:"];
-      for (const wt of ctx.worktrees) {
-        const tag = wt.primary ? "primary" : "worktree";
-        lines.push(`  ${wt.branch} @ ${wt.path} (${tag})`);
-      }
-      console.log(lines.join("\n"));
-    } catch (e) {
-      return failGraceful(`worktree list: ${e.message}`);
+}
+
+// src/pr-checks-rest.ts
+var REST_GH_TIMEOUT_MS = 2e4;
+async function defaultGhApi(args) {
+  const { stdout } = await execFileP2("gh", ["api", ...args], { timeout: REST_GH_TIMEOUT_MS });
+  return stdout;
+}
+function classifyCheckRun(run) {
+  if (run.status !== "completed") return "pending";
+  switch (run.conclusion) {
+    case "success":
+    case "neutral":
+    case "skipped":
+      return "pass";
+    case "failure":
+    case "timed_out":
+    case "cancelled":
+    case "action_required":
+    case "startup_failure":
+    case "stale":
+      return "fail";
+    default:
+      return "pending";
+  }
+}
+function classifyCommitStatus(state) {
+  if (state === "success") return "pass";
+  if (state === "failure" || state === "error") return "fail";
+  return "pending";
+}
+function dedupeLatestCheckRuns(runs) {
+  const byIdentity = /* @__PURE__ */ new Map();
+  const unkeyed = [];
+  for (const run of runs) {
+    if (!run.name || typeof run.id !== "number") {
+      unkeyed.push(run);
+      continue;
     }
-  });
+    const key = `${run.app_id ?? "unknown-app"}:${run.name}`;
+    const prior = byIdentity.get(key);
+    if (!prior || run.id >= (prior.id ?? 0)) byIdentity.set(key, run);
+  }
+  return [...byIdentity.values(), ...unkeyed];
 }
-async function gatherWorktreeContext() {
-  const repoRoot2 = await repoRootOf();
-  const porcelain = (await execFileP2("git", ["worktree", "list", "--porcelain"], { timeout: GIT_TIMEOUT_MS }).catch(() => ({ stdout: "" }))).stdout;
-  const parsed = parseWorktreePorcelain(porcelain);
-  const primaryPath = parsed[0]?.path ?? repoRoot2;
-  const worktrees = parsed.map((w) => ({ path: toNativePath(w.path), branch: w.branch, primary: w.path === primaryPath }));
-  const branchOut = (await execFileP2("git", ["branch", "--format=%(refname:short)"], { timeout: GIT_TIMEOUT_MS }).catch(() => ({ stdout: "" }))).stdout;
-  const localBranches = branchOut.split(/\r?\n/).map((l) => l.trim()).filter(Boolean);
-  const currentBranch2 = (await execFileP2("git", ["rev-parse", "--abbrev-ref", "HEAD"], { timeout: GIT_TIMEOUT_MS }).catch(() => ({ stdout: "" }))).stdout.trim() || void 0;
-  const openPrBranches = /* @__PURE__ */ new Set();
-  const closedBranches = /* @__PURE__ */ new Set();
+function derivePollState(buckets) {
+  if (!buckets.length) return "no-checks-reported";
+  const anyFailure = buckets.includes("fail");
+  const anyPending = buckets.includes("pending");
+  if (anyFailure) return anyPending ? "failing" : "failure";
+  return anyPending ? "pending" : "success";
+}
+function parseNdjsonLines(stdout) {
+  return stdout.split(/\r?\n/).filter((line) => line.trim()).map((line) => JSON.parse(line));
+}
+function parseRestPrSnapshot(json) {
+  const pr2 = json ?? {};
+  const headSha = pr2.head?.sha ?? "";
+  if (!headSha) throw new Error("pulls endpoint returned no head SHA");
+  const headRepo = pr2.head?.repo?.full_name;
+  const baseRepo = pr2.base?.repo?.full_name;
+  return {
+    headSha,
+    headRef: pr2.head?.ref ?? "",
+    // Only call it a fork when BOTH names are known and differ — an absent name (private/deleted fork)
+    // must not read as same-repo and send a git-ref probe at a branch the base repo does not have.
+    headIsFork: Boolean(headRepo && baseRepo && headRepo !== baseRepo),
+    mergeable: pr2.mergeable === true ? "MERGEABLE" : pr2.mergeable === false ? "CONFLICTING" : "UNKNOWN",
+    baseRef: pr2.base?.ref ?? "development",
+    merged: pr2.merged === true,
+    state: pr2.state ?? ""
+  };
+}
+async function fetchBranchTipSha(repo, ref, gh = defaultGhApi) {
+  if (!ref) return null;
   try {
-    const { stdout } = await execFileP2("gh", ["pr", "list", "--state", "all", "--limit", "200", "--json", "headRefName,state"], { timeout: GH_TIMEOUT_MS });
-    const prs = JSON.parse(stdout || "[]");
-    const byBranch = /* @__PURE__ */ new Map();
-    for (const pr2 of prs) {
-      const arr = byBranch.get(pr2.headRefName) ?? [];
-      arr.push(pr2.state);
-      byBranch.set(pr2.headRefName, arr);
-    }
-    for (const [br, states] of byBranch) {
-      if (states.some((s) => s === "OPEN")) openPrBranches.add(br);
-      else if (states.some((s) => s === "MERGED" || s === "CLOSED")) closedBranches.add(br);
-    }
+    const parsed = JSON.parse(await gh([`repos/${repo}/git/ref/heads/${ref}`]));
+    const sha = parsed.object?.sha;
+    return typeof sha === "string" && sha ? sha : null;
   } catch {
+    return null;
   }
-  const stages = [];
-  for (const wt of worktrees) {
-    const s = readStageSummary(wt.path);
-    if (s) stages.push({ path: wt.path, port: s.port });
-  }
-  const worktreeGitRoot = await currentRepoWorktreeGitRoot(repoRoot2);
-  const primaryRepoRoot = worktreeGitRoot ? (0, import_node_path25.dirname)((0, import_node_path25.dirname)(worktreeGitRoot)) : repoRoot2;
-  const wtRoot = siblingMmiWorktreesRoot(primaryRepoRoot);
-  let orphanDirs = [];
-  if ((0, import_node_fs26.existsSync)(wtRoot)) {
-    orphanDirs = scanOrphanDirs(wtRoot, worktreeGitRoot, {
-      ...defaultOrphanDirScanDeps,
-      listDirs: (root) => worktreeScanDirs(root, primaryRepoRoot, defaultOrphanDirScanDeps.listDirs, isRepoCheckoutDir)
-    });
-  }
-  return { worktrees, localBranches, currentBranch: currentBranch2, openPrBranches, closedBranches, stages, orphanDirs };
 }
-async function bestEffortGit(args, cwd, step, timeoutMs = GIT_TIMEOUT_MS) {
+async function fetchRestPrSnapshot(prNumber, repo, gh = defaultGhApi) {
+  return parseRestPrSnapshot(JSON.parse(await gh([`repos/${repo}/pulls/${prNumber}`])));
+}
+async function fetchHeadCheckRuns(headSha, repo, gh) {
+  const runsOut = await gh(["--paginate", `repos/${repo}/commits/${headSha}/check-runs?per_page=100`, "--jq", ".check_runs[] | {id, name, status, conclusion, app_id: .app.id}"]);
+  return dedupeLatestCheckRuns(parseNdjsonLines(runsOut));
+}
+async function fetchHeadCheckBuckets(headSha, repo, gh) {
+  const [runs, statusesOut] = await Promise.all([
+    fetchHeadCheckRuns(headSha, repo, gh),
+    gh(["--paginate", `repos/${repo}/commits/${headSha}/status?per_page=100`, "--jq", ".statuses[] | {context, state}"])
+  ]);
+  const statuses = parseNdjsonLines(statusesOut);
+  return [...runs.map(classifyCheckRun), ...statuses.map((s) => classifyCommitStatus(s.state))];
+}
+async function pollRestPrChecks(prNumber, repo, gh = defaultGhApi) {
+  const snapshot = await fetchRestPrSnapshot(prNumber, repo, gh);
+  return derivePollState(await fetchHeadCheckBuckets(snapshot.headSha, repo, gh));
+}
+async function pollRestPrMergeable(prNumber, repo, gh = defaultGhApi) {
   try {
-    const fullArgs = cwd ? ["-C", cwd, ...args] : args;
-    await execFileP2("git", fullArgs, { timeout: timeoutMs });
-    return { step, status: "done" };
-  } catch (e) {
-    const msg = e.message.split("\n")[0];
-    if (/not found|already|no such|does not exist|not a valid|couldn't|unable to resolve/i.test(msg)) {
-      return { step, status: "already gone" };
-    }
-    return { step, status: `failed: ${msg}` };
+    return (await fetchRestPrSnapshot(prNumber, repo, gh)).mergeable;
+  } catch {
+    return "UNKNOWN";
   }
 }
-
-// src/issue-commands.ts
-var import_node_fs27 = require("node:fs");
-var import_node_crypto5 = require("node:crypto");
-var ghRunner = async (args, timeoutMs) => (await execFileP2("gh", args, { timeout: timeoutMs })).stdout;
-async function editIssue(client, options, deps = {}) {
-  const parsed = parseIssueRef(options.ref);
-  const repo = parsed.repo ?? options.defaultRepo;
-  if (!repo) throw new Error("could not resolve repo \u2014 pass --repo owner/repo");
-  const url = `https://github.com/${repo}/issues/${parsed.number}`;
-  const patch = {};
-  let bodyChanged = false;
-  if (options.title !== void 0) patch.title = options.title;
-  if (options.body !== void 0 || options.bodyFile !== void 0) {
-    let body;
-    if (options.bodyFile) {
-      const td = deps.textDeps ?? { readFile: (p, e) => Promise.resolve((0, import_node_fs27.readFileSync)(p, e)), readStdin: () => Promise.resolve("") };
-      body = await resolveIssueBody({ body: options.body, bodyFile: options.bodyFile }, td);
-    } else {
-      body = options.body ?? "";
-    }
-    patch.body = body;
-    bodyChanged = true;
-  }
-  if (patch.title !== void 0 || patch.body !== void 0) {
-    await client.rest("PATCH", `repos/${repo}/issues/${parsed.number}`, { body: patch });
-  }
-  const labelsAdded = [];
-  const labelsRemoved = [];
-  if (options.addLabel?.length) {
-    await client.rest("POST", `repos/${repo}/issues/${parsed.number}/labels`, { body: { labels: options.addLabel } });
-    labelsAdded.push(...options.addLabel);
+async function pollRestPrMerged(prNumber, repo, gh = defaultGhApi) {
+  try {
+    return (await fetchRestPrSnapshot(prNumber, repo, gh)).merged;
+  } catch {
+    return false;
   }
-  for (const label of options.removeLabel ?? []) {
-    try {
-      await client.rest("DELETE", `repos/${repo}/issues/${parsed.number}/labels/${encodeURIComponent(label)}`);
-      labelsRemoved.push(label);
-    } catch (e) {
-      if (e instanceof GitHubApiError && e.status === 404) {
-        labelsRemoved.push(label);
-      } else {
-        throw e;
-      }
-    }
+}
+var CI_BUDGET_ANNOTATION_TITLE = "CI budget exceeded";
+var CI_DISK_ANNOTATION_TITLE = "CI runner disk";
+var CI_TOOLCHAIN_ANNOTATION_TITLE = "CI runner toolchain";
+var RUNNER_INFRA_ANNOTATION_TITLES = /* @__PURE__ */ new Set([
+  CI_BUDGET_ANNOTATION_TITLE,
+  CI_DISK_ANNOTATION_TITLE,
+  CI_TOOLCHAIN_ANNOTATION_TITLE
+]);
+function isErrorAnnotation(a) {
+  const level = a.annotation_level?.toLowerCase();
+  return level === "failure" || level === "error";
+}
+function classifyFailedChecks(failing) {
+  const infraFailures = [];
+  const otherFailures = [];
+  for (const check of failing) {
+    const errors = check.annotations.filter(isErrorAnnotation);
+    const allInfra = errors.length > 0 && errors.every((a) => RUNNER_INFRA_ANNOTATION_TITLES.has(a.title?.trim() ?? ""));
+    (allInfra ? infraFailures : otherFailures).push(check.name);
   }
-  let parentResult;
-  if (options.parent) {
-    const run = deps.runGh ?? ghRunner;
-    parentResult = await linkSubIssue(run, options.parent, options.ref, repo);
+  if (infraFailures.length && !otherFailures.length) {
+    return {
+      cause: "runner-infra",
+      infraFailures,
+      otherFailures,
+      reason: `${infraFailures.length} check(s) failed on RUNNER INFRASTRUCTURE, not your diff: ${infraFailures.join(", ")}. No test failed \u2014 the shared runner hit a wall-clock budget kill, ran out of disk, or was missing a toolchain (the check annotation names which). Re-run once the runner drains/heals (gh run rerun --failed); do not debug the diff.`
+    };
   }
   return {
-    number: parsed.number,
-    repo,
-    url,
-    ...patch.title !== void 0 ? { title: patch.title } : {},
-    bodyChanged,
-    labelsAdded,
-    labelsRemoved,
-    ...parentResult ? { parent: parentResult } : {}
+    cause: "checks-failure",
+    infraFailures,
+    otherFailures,
+    reason: infraFailures.length ? `checks failed: ${otherFailures.join(", ")}; separately, ${infraFailures.join(", ")} failed on runner infrastructure, not a test.` : `checks failed: ${otherFailures.join(", ") || "unknown"}.`
   };
 }
-async function closeIssue(client, options, deps = {}) {
-  const parsed = parseIssueRef(options.ref);
-  const repo = parsed.repo ?? options.defaultRepo;
-  if (!repo) throw new Error("could not resolve repo \u2014 pass --repo owner/repo");
-  const url = `https://github.com/${repo}/issues/${parsed.number}`;
-  const reason = options.reason ?? "completed";
-  const stateReason = reason === "duplicate-of" ? "not_planned" : reason === "not-planned" ? "not_planned" : "completed";
-  await client.rest("PATCH", `repos/${repo}/issues/${parsed.number}`, {
-    body: { state: "closed", state_reason: stateReason }
-  });
-  if (reason === "duplicate-of" && options.duplicateOf) {
-    await client.rest("POST", `repos/${repo}/issues/${parsed.number}/comments`, {
-      body: { body: `Duplicate of #${options.duplicateOf}` }
-    });
-  }
-  if (options.comment) {
-    await client.rest("POST", `repos/${repo}/issues/${parsed.number}/comments`, {
-      body: { body: options.comment }
-    });
-  }
-  let board;
+async function diagnoseFailedRestChecks(prNumber, repo, gh = defaultGhApi) {
   try {
-    const cfg = await loadConfigForBoardSelector(options.ref, options.defaultRepo);
-    if (cfg.projectId) {
-      const result = await moveBoardItem({ config: cfg, selector: options.ref, status: "Done", repo, allowPartial: true }, deps);
-      board = { status: result.status, partial: result.partial };
+    const snapshot = await fetchRestPrSnapshot(prNumber, repo, gh);
+    if (!snapshot.headIsFork) {
+      const branchTip = await fetchBranchTipSha(repo, snapshot.headRef, gh);
+      if (branchTip && branchTip !== snapshot.headSha) {
+        return {
+          cause: "stale-head",
+          infraFailures: [],
+          otherFailures: [],
+          reason: `the PR head (${snapshot.headSha.slice(0, 7)}) is BEHIND the branch tip (${branchTip.slice(0, 7)}) \u2014 GitHub likely dropped a \`synchronize\` event, so the reported red is a superseded commit and NO run exists for your current push. This is not your diff failing. Re-push (an empty commit is enough) or close and reopen the PR to re-sync the head and trigger a fresh run.`
+        };
+      }
     }
+    const failing = (await fetchHeadCheckRuns(snapshot.headSha, repo, gh)).filter((run) => classifyCheckRun(run) === "fail" && typeof run.id === "number");
+    if (!failing.length) return null;
+    const annotated = await Promise.all(failing.map(async (run) => ({
+      name: run.name ?? `check-run ${run.id}`,
+      annotations: JSON.parse(await gh([`repos/${repo}/check-runs/${run.id}/annotations`]))
+    })));
+    return classifyFailedChecks(annotated);
   } catch {
+    return null;
   }
-  return { number: parsed.number, repo, url, state: "closed", stateReason, ...board ? { board } : {} };
 }
-async function reopenIssue(client, ref, defaultRepo, deps = {}) {
-  const parsed = parseIssueRef(ref);
-  const repo = parsed.repo ?? defaultRepo;
-  if (!repo) throw new Error("could not resolve repo \u2014 pass --repo owner/repo");
-  const url = `https://github.com/${repo}/issues/${parsed.number}`;
-  await client.rest("PATCH", `repos/${repo}/issues/${parsed.number}`, { body: { state: "open" } });
-  let board;
+async function fetchRestCorePool(gh = defaultGhApi) {
   try {
-    const cfg = await loadConfigForBoardSelector(ref, defaultRepo);
-    if (cfg.projectId) {
-      const result = await moveBoardItem({ config: cfg, selector: ref, status: "Todo", repo, allowPartial: true }, deps);
-      board = { status: result.status, partial: result.partial };
-    }
+    const parsed = JSON.parse(await gh(["rate_limit"]));
+    const core = parsed.resources?.core;
+    if (typeof core?.remaining !== "number" || typeof core?.reset !== "number") return null;
+    return { remaining: core.remaining, reset: core.reset };
   } catch {
+    return null;
   }
-  return { number: parsed.number, repo, url, state: "open", ...board ? { board } : {} };
 }
-async function assignIssue(client, ref, login, defaultRepo) {
-  const parsed = parseIssueRef(ref);
-  const repo = parsed.repo ?? defaultRepo;
-  if (!repo) throw new Error("could not resolve repo \u2014 pass --repo owner/repo");
-  await client.rest("POST", `repos/${repo}/issues/${parsed.number}/assignees`, { body: { assignees: [login] } });
-  return { number: parsed.number, repo, url: `https://github.com/${repo}/issues/${parsed.number}`, login, action: "assigned" };
+
+// src/worktree-lifecycle-commands.ts
+var import_node_fs28 = require("node:fs");
+var import_node_path27 = require("node:path");
+var GH_TIMEOUT_MS = 2e4;
+var DEFAULT_BASE = "origin/development";
+var DEFAULT_REMOTE = "origin";
+var PROTECTED_BRANCHES2 = /* @__PURE__ */ new Set(["development", "main", "master", "rc"]);
+function slugifyIssueTitle(title) {
+  const slug = title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  return slug.slice(0, 50);
 }
-async function unassignIssue(client, ref, login, defaultRepo) {
-  const parsed = parseIssueRef(ref);
-  const repo = parsed.repo ?? defaultRepo;
-  if (!repo) throw new Error("could not resolve repo \u2014 pass --repo owner/repo");
-  await client.rest("DELETE", `repos/${repo}/issues/${parsed.number}/assignees`, { body: { assignees: [login] } });
-  return { number: parsed.number, repo, url: `https://github.com/${repo}/issues/${parsed.number}`, login, action: "unassigned" };
+function buildNewBranchName(issueNumber, slug) {
+  const clean4 = slug.replace(/^[-]+|[-]+$/g, "");
+  return clean4 ? `${issueNumber}-${clean4}` : String(issueNumber);
 }
-var TRANSFER_ISSUE_MUTATION = `
-mutation($issueId: ID!, $repositoryId: ID!) {
-  transferIssue(input: {issueId: $issueId, repositoryId: $repositoryId}) {
-    issue {
-      id
-      number
-      url
-      repository { nameWithOwner }
-    }
+function isIssueRef(target) {
+  return /^#?\d+$/.test(target) || /^[\w.-]+\/[\w.-]+#\d+$/.test(target);
+}
+function worktreeCreatePlan(opts, args) {
+  const target = String(args[0] ?? "");
+  return {
+    command: "worktree create",
+    target,
+    issueForm: isIssueRef(target),
+    claim: Boolean(opts.claim),
+    slug: opts.slug || void 0,
+    from: opts.base || opts.from || DEFAULT_BASE,
+    remote: opts.remote || DEFAULT_REMOTE,
+    repo: opts.repo || void 0,
+    assignee: opts.for || void 0
+  };
+}
+function landSteps(branch, hasWorktree, hasStage) {
+  const steps = [];
+  if (hasStage) steps.push("stop spawned dev stage");
+  if (hasWorktree) steps.push(`remove worktree (branch ${branch})`);
+  steps.push(`delete local branch ${branch}`);
+  steps.push(`delete remote branch ${branch}`);
+  steps.push("prune worktree metadata");
+  return steps;
+}
+function classifyStaleLeaks(input) {
+  const protectedBranches = input.protectedBranches ?? PROTECTED_BRANCHES2;
+  const leaks = [];
+  const worktreeBranches2 = new Set(input.worktrees.filter((w) => !w.primary).map((w) => w.branch));
+  const stageByPath = new Map(input.stages.map((s) => [s.path, s.port]));
+  for (const wt of input.worktrees) {
+    if (wt.primary) continue;
+    if (protectedBranches.has(wt.branch)) continue;
+    if (input.openPrBranches.has(wt.branch)) continue;
+    if (!input.closedBranches.has(wt.branch)) continue;
+    leaks.push({
+      kind: "stale-worktree",
+      ref: wt.branch,
+      detail: `merged/closed branch ${wt.branch} still checked out at ${wt.path}`,
+      remediation: `cd "${wt.path}" && mmi-cli worktree land --apply  (or: mmi-cli worktree gc --apply)`
+    });
   }
-}`;
-var ADD_PROJECT_ITEM_MUTATION = `
-mutation($projectId: ID!, $contentId: ID!) {
-  addProjectV2ItemById(input: {projectId: $projectId, contentId: $contentId}) {
-    item { id }
+  for (const branch of input.localBranches) {
+    if (protectedBranches.has(branch)) continue;
+    if (branch === input.currentBranch) continue;
+    if (input.openPrBranches.has(branch)) continue;
+    if (!input.closedBranches.has(branch)) continue;
+    if (worktreeBranches2.has(branch)) continue;
+    leaks.push({
+      kind: "stale-branch",
+      ref: branch,
+      detail: `merged/closed branch ${branch} has no worktree`,
+      remediation: "mmi-cli worktree gc --apply"
+    });
   }
-}`;
-async function relocateIssue(client, ref, toRepo, defaultRepo, deps = {}) {
-  const parsed = parseIssueRef(ref);
-  const sourceRepo = parsed.repo ?? defaultRepo;
-  if (!sourceRepo) throw new Error("could not resolve the source repo \u2014 pass owner/repo#123 or use --repo");
-  let sourceItemId;
-  let priority;
-  try {
-    const sourceCfg = await loadConfigForBoardSelector(ref, defaultRepo);
-    if (sourceCfg.projectId) {
-      const resolved = resolveBoardConfig(sourceCfg);
-      const lookup = await fetchIssueProjectItem(client, resolved, { repo: sourceRepo, number: parsed.number });
-      sourceItemId = lookup.item?.itemId;
-      priority = lookup.item?.priority;
-    }
-  } catch {
+  for (const wt of input.worktrees) {
+    if (wt.primary) continue;
+    const port = stageByPath.get(wt.path);
+    if (port == null) continue;
+    if (input.openPrBranches.has(wt.branch)) continue;
+    if (protectedBranches.has(wt.branch) && !input.closedBranches.has(wt.branch)) continue;
+    if (!input.closedBranches.has(wt.branch)) continue;
+    leaks.push({
+      kind: "stale-stage",
+      ref: wt.branch,
+      detail: `dev stage on port ${port} still running in ${wt.path} (branch ${wt.branch} merged/closed)`,
+      remediation: `cd "${wt.path}" && mmi-cli stage stop --apply`
+    });
   }
-  const sourceIssue = await client.rest("GET", `repos/${sourceRepo}/issues/${parsed.number}`);
-  const issueNodeId = sourceIssue?.node_id;
-  if (!issueNodeId) throw new Error(`could not resolve node id for ${sourceRepo}#${parsed.number}`);
-  const targetRepoData = await client.rest("GET", `repos/${toRepo}`);
-  const targetRepoNodeId = targetRepoData?.node_id;
-  if (!targetRepoNodeId) throw new Error(`could not resolve node id for repo ${toRepo}`);
-  const transferred = await client.graphql(
-    TRANSFER_ISSUE_MUTATION,
-    { issueId: issueNodeId, repositoryId: targetRepoNodeId }
-  );
-  const newIssue = transferred?.transferIssue?.issue;
-  if (!newIssue?.id || !newIssue.number || !newIssue.url) {
-    throw new Error("transferIssue returned an unexpected response (no issue id/number/url)");
+  const knownPaths = new Set(input.worktrees.map((w) => w.path));
+  for (const dir of input.orphanDirs) {
+    if (knownPaths.has(dir.path)) continue;
+    leaks.push({
+      kind: "orphan-dir",
+      ref: dir.path,
+      // Say only what the inspection proved. `orphaned-folder` proves the `.git` entry is gone while this
+      // repo's worktree metadata still points at the directory — NOT that the directory is empty; gc
+      // checks contents separately, at apply time.
+      detail: dir.reason === "dangling-gitdir" ? "this repo's worktree directory whose git metadata is gone" : "this repo's worktree metadata points here, but the .git entry is gone",
+      // gc --apply re-proves ownership before deleting anything; a raw `rm -rf` does not, so it is never
+      // offered here — following it on a mis-classified dir would destroy another repo's live worktree.
+      remediation: "mmi-cli worktree gc --apply"
+    });
   }
-  const newRepo = newIssue.repository?.nameWithOwner ?? toRepo;
-  const newNumber = newIssue.number;
-  const newUrl = newIssue.url;
-  const newNodeId = newIssue.id;
-  let swept = false;
-  if (sourceItemId) {
+  return leaks;
+}
+var defaultOrphanDirScanDeps = {
+  listDirs: (root) => {
     try {
-      const sourceCfg = await loadConfigForBoardSelector(ref, defaultRepo);
-      if (sourceCfg.projectId) {
-        const resolved = resolveBoardConfig(sourceCfg);
-        const DELETE_MUTATION = `mutation($projectId: ID!, $itemId: ID!) { deleteProjectV2Item(input: {projectId: $projectId, itemId: $itemId}) { deletedItemId } }`;
-        await client.graphql(DELETE_MUTATION, { projectId: resolved.projectId, itemId: sourceItemId });
-        swept = true;
-      }
+      return (0, import_node_fs28.readdirSync)(root, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => (0, import_node_path27.join)(root, e.name));
     } catch {
+      return [];
     }
+  },
+  inspect: inspectSiblingWorktreeDir
+};
+function scanOrphanDirs(worktreesRoot, worktreeGitRoot, deps = defaultOrphanDirScanDeps) {
+  const candidates = [];
+  for (const dir of deps.listDirs(worktreesRoot)) {
+    const { cleanup } = classifySiblingWorktreeDir(deps.inspect(dir, worktreeGitRoot));
+    if (cleanup) candidates.push({ path: dir, reason: cleanup.reason });
   }
-  let added = false;
-  let carriedPriority;
-  try {
-    const destCfg = await loadConfigForBoardSelector(`${newRepo}#${newNumber}`, newRepo);
-    if (destCfg.projectId) {
-      const addResult = await client.graphql(
-        ADD_PROJECT_ITEM_MUTATION,
-        { projectId: destCfg.projectId, contentId: newNodeId }
-      );
-      const newItemId = addResult?.addProjectV2ItemById?.item?.id;
-      if (newItemId && priority) {
-        try {
-          const p = priority.toLowerCase();
-          if (CLI_PRIORITIES.includes(p)) {
-            await setBoardItemPriority(client, destCfg, newItemId, p);
-            carriedPriority = priority;
-          }
-        } catch {
-        }
-      }
-      added = true;
-    }
-  } catch {
+  return candidates;
+}
+function formatStaleLeaks(leaks) {
+  if (!leaks.length) return "worktree list --stale: no leaks found";
+  const lines = [`worktree list --stale: ${leaks.length} leak(s)`];
+  for (const leak of leaks) {
+    lines.push(`  [${leak.kind}] ${leak.ref} \u2014 ${leak.detail}`);
+    lines.push(`      fix: ${leak.remediation}`);
   }
-  return {
-    number: newNumber,
-    repo: newRepo,
-    url: newUrl,
-    previousRepo: sourceRepo,
-    previousNumber: parsed.number,
-    board: { swept, added, ...carriedPriority ? { priority: carriedPriority } : {} }
-  };
+  return lines.join("\n");
 }
-function idempotencyMarker(key) {
-  return `mmi-idempotency:${key}`;
+async function repoRootOf() {
+  return (await execFileP2("git", ["rev-parse", "--show-toplevel"], { timeout: GIT_TIMEOUT_MS }).catch(() => ({ stdout: "" }))).stdout.trim() || process.cwd();
 }
-function appendIdempotencyMarker(body, key) {
-  const marker = `<!-- ${idempotencyMarker(key)} -->`;
-  if (body.includes(marker)) return body;
-  return `${body.replace(/\s+$/, "")}
-
-${marker}
-`;
+function classifyLandBranchMergeState(prs) {
+  if (!prs) return { state: "unknown", numbers: [] };
+  if (!prs.length) return { state: "no-pr", numbers: [] };
+  const pick = (s) => prs.filter((pr2) => pr2.state.toUpperCase() === s).map((pr2) => pr2.number);
+  const open2 = pick("OPEN");
+  if (open2.length) return { state: "open", numbers: open2 };
+  const known = /* @__PURE__ */ new Set(["OPEN", "CLOSED", "MERGED"]);
+  const unrecognised = prs.filter((pr2) => !known.has(pr2.state.toUpperCase()));
+  if (unrecognised.length) return { state: "unknown", numbers: prs.map((pr2) => pr2.number) };
+  const merged = pick("MERGED");
+  if (!merged.length) return { state: "closed-unmerged", numbers: prs.map((pr2) => pr2.number) };
+  if (merged.length < prs.length) return { state: "mixed", numbers: prs.map((pr2) => pr2.number) };
+  return { state: "merged", numbers: merged };
 }
-function rowIdempotencyKey(batchKey, spec) {
-  const identity = `${spec.type}
-${spec.title.trim()}
-${spec.body ?? ""}`;
-  const hash = (0, import_node_crypto5.createHash)("sha256").update(identity).digest("hex").slice(0, 16);
-  return `${batchKey}:${hash}`;
+function describeLandMergeState(v) {
+  const refs = v.numbers.map((n) => `#${n}`).join(", ");
+  switch (v.state) {
+    case "merged":
+      return `PR ${refs} merged`;
+    case "closed-unmerged":
+      return `PR ${refs} CLOSED \u2014 NOT merged`;
+    case "mixed":
+      return `PR ${refs} \u2014 some merged, some CLOSED unmerged; which one owns the branch head is unproven`;
+    case "open":
+      return `PR ${refs} still OPEN \u2014 NOT merged`;
+    case "no-pr":
+      return "no pull request for this branch";
+    case "unknown":
+      return refs ? `PR ${refs} reported a pull-request state this CLI does not recognise \u2014 merge NOT confirmed` : "pull-request state could not be read \u2014 merge NOT confirmed";
+  }
 }
-var BATCH_SPEC_KEYS = /* @__PURE__ */ new Set(["type", "title", "body", "priority", "labels", "parent", "repo"]);
-function validateBatchSpecs(specs) {
-  const errors = [];
-  const validated = [];
-  const validTypes = ["bug", "feature", "task"];
-  for (let i = 0; i < specs.length; i += 1) {
-    const spec = specs[i];
-    const row = i + 1;
-    if (!spec || typeof spec !== "object") {
-      errors.push({ row, error: "not an object" });
-      continue;
-    }
-    const unknown = Object.keys(spec).filter((k) => !BATCH_SPEC_KEYS.has(k));
-    if (unknown.length) {
-      errors.push({ row, error: `unknown key(s): ${unknown.join(", ")} \u2014 expected only: ${[...BATCH_SPEC_KEYS].join(", ")}` });
-      continue;
-    }
-    if (spec.repo !== void 0 && !/^[\w.-]+\/[\w.-]+$/.test(spec.repo)) {
-      errors.push({ row, error: `bad repo "${spec.repo}" \u2014 expected owner/repo` });
-      continue;
-    }
-    if (!validTypes.includes(spec.type)) {
-      errors.push({ row, error: `unknown type "${spec.type}" \u2014 expected one of: ${validTypes.join(", ")}` });
-      continue;
-    }
-    if (!spec.title || !spec.title.trim()) {
-      errors.push({ row, error: "missing or empty title" });
-      continue;
-    }
-    let priority;
-    try {
-      priority = spec.priority ? normalizePriority(spec.priority) : "medium";
-    } catch (e) {
-      errors.push({ row, error: e.message });
-      continue;
-    }
-    validated.push({ row, spec, priority, type: spec.type });
+function decideWorktreeLandRefCleanup(input) {
+  if (input.keepRemote) return { action: "proceed" };
+  const verdict = classifyLandBranchMergeState(input.prs);
+  const refs = verdict.numbers.map((n) => `#${n}`).join(", ");
+  if (verdict.state === "unknown") {
+    return verdict.numbers.length ? {
+      action: "keep-remote",
+      reason: "pr-state-unrecognised",
+      message: `pull request ${refs} for '${input.branch}' reported a state this CLI does not recognise \u2014 keeping the remote branch rather than deleting a ref whose merge is unproven`
+    } : {
+      action: "keep-remote",
+      reason: "pr-state-unreadable",
+      message: `could not read the pull-request state for '${input.branch}' \u2014 keeping the remote branch so an unmerged head ref cannot be deleted on a guess`
+    };
+  }
+  if (verdict.state === "open") {
+    return {
+      action: "refuse",
+      reason: "open-pr",
+      message: `'${input.branch}' still has an OPEN pull request (${refs}). Deleting its head ref would auto-close the PR and leave the work on no branch. Merge it first, or re-run with --keep-remote for a local-only clean`
+    };
+  }
+  if (verdict.state === "mixed") {
+    return {
+      action: "keep-remote",
+      reason: "mixed-pr-state",
+      message: `'${input.branch}' has both a merged and a closed-unmerged pull request (${refs}) and nothing here proves which owns the current head \u2014 keeping the remote branch rather than deleting a ref that may hold unmerged work`
+    };
   }
-  return { ok: errors.length === 0, errors, validated };
-}
-async function createIssuesBatch(specs, options, deps = {}) {
-  const ensureLabels = deps.ensureLabels ?? ensureLabelsExist;
-  const client = deps.client ?? defaultGitHubClient();
-  const runCreate = deps.runCreate ?? (async (args) => (await execFileP2("gh", args, { timeout: GH_MUTATION_TIMEOUT_MS })).stdout);
-  const validation = validateBatchSpecs(specs);
-  if (!validation.ok) {
-    const lines = validation.errors.map((e) => `  row ${e.row}: ${e.error}`).join("\n");
-    throw new Error(`batch validation failed (${validation.errors.length} error(s)):
-${lines}`);
+  if (verdict.state === "closed-unmerged") {
+    return {
+      action: "refuse",
+      reason: "unmerged-pr",
+      message: `'${input.branch}' has a pull request that never merged (${refs}). The remote branch is the only thing still holding that work. Re-run with --keep-remote for a local-only clean`
+    };
   }
-  const defaultRepo = await resolveRepo(options.repo);
-  if (!defaultRepo && validation.validated.some((v) => !v.spec.repo)) {
-    throw new Error("could not resolve repo \u2014 pass --repo owner/repo or set repo per row");
+  return { action: "proceed" };
+}
+async function fetchLandBranchPrs(branch, repo) {
+  try {
+    const { stdout } = await execFileP2("gh", [
+      "pr",
+      "list",
+      "--head",
+      branch,
+      "--state",
+      "all",
+      "--limit",
+      "20",
+      ...repo ? ["--repo", repo] : [],
+      "--json",
+      "number,state"
+    ], { timeout: GH_TIMEOUT_MS });
+    const parsed = JSON.parse(stdout.trim() || "null");
+    if (!Array.isArray(parsed)) return void 0;
+    return parsed.filter((pr2) => Boolean(pr2) && typeof pr2 === "object" && typeof pr2.number === "number" && typeof pr2.state === "string").map((pr2) => ({ number: pr2.number, state: pr2.state }));
+  } catch {
+    return void 0;
   }
-  const rowRepo = (spec) => spec.repo ?? defaultRepo;
-  const labelsByRepo = /* @__PURE__ */ new Map();
-  for (const { spec } of validation.validated) {
-    if (!spec.labels?.length) continue;
-    const bucket = labelsByRepo.get(rowRepo(spec)) ?? /* @__PURE__ */ new Set();
-    for (const label of spec.labels) bucket.add(label);
-    labelsByRepo.set(rowRepo(spec), bucket);
+}
+async function fetchIssueTitle(repo, number) {
+  try {
+    const { stdout } = await execFileP2("gh", ["issue", "view", String(number), "--repo", repo, "--json", "title", "--jq", ".title"], { timeout: GH_TIMEOUT_MS });
+    const title = stdout.trim();
+    return title || void 0;
+  } catch {
+    return void 0;
   }
-  for (const [repo, labels] of labelsByRepo) await ensureLabels([...labels], repo);
-  const created = [];
-  const failures = [];
-  for (const entry of validation.validated) {
-    const { spec, priority, type } = entry;
+}
+async function selfShell(args, timeoutMs) {
+  const scriptPath = process.argv[1];
+  const { stdout } = await execFileP2(process.execPath, [scriptPath, ...args], { timeout: timeoutMs });
+  return stdout;
+}
+function registerWorktreeCommands(program3) {
+  const worktree2 = program3.commands.find((c) => c.name() === "worktree");
+  if (!worktree2) return;
+  const has = (name) => worktree2.commands.some((c) => c.name() === name);
+  if (has("land") && has("list")) return;
+  if (!has("land")) worktree2.command("land").description("post-merge clean: remove the current worktree, delete its local + origin branch, and stop its dev stage (dry-run by default)").option("--apply", "execute the cleanup (default: dry-run preview)").option("--dry-run", "show what would be removed without doing it (default)").option("--remote <name>", "remote whose branch is deleted", DEFAULT_REMOTE).option("--keep-remote", "do not delete the remote (origin) branch").option("--json", "machine-readable output").action(async (o) => {
+    if (o.apply && o.dryRun) return fail("worktree land: choose either --dry-run or --apply");
+    const apply = Boolean(o.apply);
     try {
-      const rowKey = options.idempotencyKey ? rowIdempotencyKey(options.idempotencyKey, spec) : void 0;
-      if (rowKey) {
-        const existing = await findExistingByIdempotencyKey(client, rowKey, rowRepo(spec));
-        if (existing) {
-          created.push({ row: entry.row, ...existing, idempotent: true });
-          continue;
-        }
+      const wtPath = (await execFileP2("git", ["rev-parse", "--show-toplevel"], { timeout: GIT_TIMEOUT_MS })).stdout.trim();
+      const branch = (await execFileP2("git", ["rev-parse", "--abbrev-ref", "HEAD"], { timeout: GIT_TIMEOUT_MS })).stdout.trim();
+      if (!wtPath || !branch) return fail("worktree land: not inside a git worktree");
+      if (PROTECTED_BRANCHES2.has(branch)) {
+        return fail(`worktree land: refusing to land protected branch '${branch}'`, { code: ERROR_CODES.ERR_BAD_ENUM });
       }
-      let body = spec.body ?? "";
-      if (rowKey) {
-        body = appendIdempotencyMarker(body, rowKey);
+      const gitFile = (0, import_node_path27.join)(wtPath, ".git");
+      const isLinked = (0, import_node_fs28.existsSync)(gitFile) && (0, import_node_fs28.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 rowPriority = spec.priority ? priority : options.priority ?? priority;
-      const args = buildIssueArgs({ type, title: spec.title, body, priority: rowPriority, repo: rowRepo(spec), labels: spec.labels });
-      const swapped = await bodyArgsViaFile(args);
-      let row;
-      try {
-        const stdout = await runCreate(swapped.args);
-        const result = parseCreatedUrl(stdout);
-        row = { row: entry.row, number: result.number, url: result.url };
-        created.push(row);
-      } finally {
-        await swapped.cleanup();
+      const commonDir = (await execFileP2("git", ["rev-parse", "--git-common-dir"], { timeout: GIT_TIMEOUT_MS }).catch(() => ({ stdout: "" }))).stdout.trim();
+      const primaryCheckout = commonDir ? (0, import_node_path27.dirname)(commonDir) : wtPath;
+      const stageSummary = readStageSummary(wtPath);
+      const hasStage = stageSummary != null;
+      const steps = landSteps(branch, true, hasStage);
+      const plan = {
+        command: "worktree land",
+        branch,
+        worktreePath: wtPath,
+        primaryCheckout,
+        remote: o.remote,
+        hasStage,
+        steps
+      };
+      if (!apply) {
+        const preview = { dryRun: true, ...plan, ...o.keepRemote ? { keepRemote: true } : {} };
+        if (o.json) return console.log(JSON.stringify(preview, null, 2));
+        const lines = [`worktree land: dry-run (pass --apply to execute)`, `  branch: ${branch}`, `  worktree: ${wtPath}`];
+        if (hasStage) lines.push(`  stage: port ${stageSummary.port} (will be stopped)`);
+        if (o.keepRemote) lines.push(`  remote branch: kept (--keep-remote)`);
+        for (const s of steps) lines.push(`  - ${s}`);
+        return console.log(lines.join("\n"));
       }
-      if (deps.attach) {
-        const attached = await deps.attach(row.number, rowRepo(spec), rowPriority);
-        row.onBoard = attached.onBoard;
-        if (attached.projectItemId) row.projectItemId = attached.projectItemId;
+      const landDirty = ((await execFileP2("git", ["-C", wtPath, "status", "--porcelain"], { timeout: GIT_TIMEOUT_MS }).catch(() => ({ stdout: "unreadable" }))).stdout || "").trim().length > 0;
+      if (landDirty) {
+        return fail(`worktree land: refusing to land '${branch}' \u2014 uncommitted changes in ${wtPath}; commit, stash, or remove the worktree manually`, { code: ERROR_CODES.ERR_BAD_ENUM });
       }
-      const parentRef = spec.parent ?? options.parent;
-      if (parentRef) {
+      const landPrs = await fetchLandBranchPrs(branch);
+      const mergeVerdict = classifyLandBranchMergeState(landPrs);
+      const landRefs = decideWorktreeLandRefCleanup({
+        branch,
+        prs: landPrs,
+        keepRemote: Boolean(o.keepRemote)
+      });
+      if (landRefs.action === "refuse") {
+        return fail(`worktree land: ${landRefs.message}`, { code: ERROR_CODES.ERR_BAD_ENUM });
+      }
+      const keepRemoteBranch = Boolean(o.keepRemote) || landRefs.action === "keep-remote";
+      if (landRefs.action === "keep-remote") console.warn(`worktree land: ${landRefs.message}.`);
+      const landOwner = lookupWorktreeOwner(primaryCheckout, wtPath);
+      const report = [];
+      if (hasStage) {
         try {
-          const run = deps.runGh ?? ghRunner;
-          row.parent = await linkSubIssue(run, parentRef, row.url, rowRepo(spec));
+          await stopStage({ cwd: wtPath, requiredIdentityCwd: wtPath });
+          report.push({ step: "stop stage", status: "stopped" });
         } catch (e) {
-          const err = e;
-          row.parentLinkError = (err.stderr || err.message || String(e)).trim();
-          process.stderr.write(`warning: issue #${row.number} created but NOT linked under ${parentRef}: ${row.parentLinkError}
-`);
+          report.push({ step: "stop stage", status: `failed: ${e.message.split("\n")[0]}` });
         }
       }
-    } catch (e) {
-      const err = e;
-      const note = timeoutKillNote(e, GH_MUTATION_TIMEOUT_MS);
-      failures.push({ row: entry.row, error: (err.stderr || err.message || String(e)).trim() + (note ? ` (${note})` : "") });
-    }
-  }
-  return { created, failures };
-}
-async function findExistingByIdempotencyKey(client, key, repo) {
-  const marker = idempotencyMarker(key);
-  try {
-    const result = await client.rest(
-      "GET",
-      `search/issues?per_page=5&q=${encodeURIComponent(`repo:${repo} "${marker}" in:body`)}`
-    );
-    const open2 = result?.items?.find((item) => item.state === "open" && item.number);
-    if (!open2?.number) return void 0;
-    return { number: open2.number, url: open2.html_url ?? `https://github.com/${repo}/issues/${open2.number}` };
-  } catch {
-    return void 0;
-  }
-}
-function parseCloseReason(raw) {
-  if (raw === void 0) return {};
-  const trimmed = raw.trim().toLowerCase().replace(/[\s_-]+/g, "");
-  if (trimmed === "completed" || trimmed === "complete") return { reason: "completed" };
-  if (trimmed === "notplanned" || trimmed === "notplanned") return { reason: "not-planned" };
-  if (trimmed === "duplicateof" || trimmed === "duplicate") return { reason: "duplicate-of" };
-  throw new Error(`unknown close reason "${raw}" \u2014 expected completed, not-planned, or duplicate-of`);
-}
-function registerIssueLifecycleCommands(program3, deps = {}) {
-  const issue2 = program3.commands.find((c) => c.name() === "issue");
-  if (!issue2) return;
-  mutating(
-    issue2.command("edit <ref>").description("edit an issue title/body/labels or reparent it (--parent) \u2014 reparenting is impossible via raw gh").option("--title <title>", "new title").option("--body <body>", "new body (markdown)").option("--body-file <path|->", "read new body from a UTF-8 file, or stdin with -").option("--add-label <label...>", "label(s) to add (repeatable)").option("--remove-label <label...>", "label(s) to remove (repeatable)").option("--parent <ref>", "reparent: link under this parent (#123, owner/repo#123, or URL)").option("--repo <owner/repo>", "repo for a bare ref (defaults to the current repo)"),
-    (opts, args) => ({ command: "issue edit", ref: args[0], fields: Object.keys(opts).filter((k) => k !== "repo" && opts[k] !== void 0) })
-  ).action(async (ref, o) => {
-    try {
-      const defaultRepo = await resolveRepo(o.repo);
-      const result = await editIssue(defaultGitHubClient(), {
-        ref,
-        defaultRepo,
-        title: o.title,
-        body: o.body,
-        bodyFile: o.bodyFile,
-        addLabel: o.addLabel,
-        removeLabel: o.removeLabel,
-        parent: o.parent
+      releaseCwdIfUnderWorktree(wtPath, primaryCheckout);
+      const removeOutcome = await removeWorktreeWithRecovery(
+        wtPath,
+        worktreeRemoveDeps(async (args) => (await execFileP2("git", ["-C", primaryCheckout, ...args], { timeout: GIT_TIMEOUT_MS })).stdout)
+      );
+      report.push({
+        step: "remove worktree",
+        status: removeOutcome.status === "removed" ? removeOutcome.recovery ? `done (${removeOutcome.recovery})` : "done" : `failed: ${removeOutcome.error ?? "lock held"} \u2014 run: git -C "${primaryCheckout}" worktree remove --force "${wtPath}"`
       });
-      console.log(JSON.stringify(result));
-    } catch (e) {
-      return failGraceful(`issue edit failed: ${e.message}`);
-    }
-  });
-  mutating(
-    issue2.command("close <ref>").description("close an issue and move its board item to Done (--reason completed|not-planned|duplicate-of --duplicate-of <n>)").option("--reason <reason>", "completed | not-planned | duplicate-of (defaults to completed)").option("--duplicate-of <number>", "the issue number this duplicates (use with --reason duplicate-of)").option("--comment <text>", "a closing comment to post").option("--repo <owner/repo>", "repo for a bare ref (defaults to the current repo)"),
-    (opts, args) => {
-      let reason;
-      try {
-        reason = parseCloseReason(opts.reason).reason;
-      } catch (e) {
-        fail(`issue close: ${e.message}`, {
-          code: ERROR_CODES.ERR_BAD_ENUM,
-          offending_flag: "--reason",
-          expected: ["completed", "not-planned", "duplicate-of"]
-        });
+      const landActor = describeActor({ env: process.env, surface: detectSurface(process.env), cwd: wtPath });
+      appendWorktreeEvent(primaryCheckout, {
+        action: removeOutcome.status === "removed" ? "removed" : "failed",
+        command: "worktree land",
+        // NATIVE separators (#3338): `land` reads its path from `git rev-parse`, which emits forward
+        // slashes even on Windows, while `create` and `gc` record the native form. Logging both spellings
+        // puts one worktree under two names in the file an operator greps to find what took theirs.
+        target: toNativePath(wtPath),
+        branch,
+        actor: landActor,
+        owner: landOwner ? { createdAt: landOwner.createdAt, lastSeenAt: landOwner.lastSeenAt, actor: landOwner.actor } : void 0,
+        reason: describeLandMergeState(mergeVerdict)
+      });
+      if (removeOutcome.status === "removed") dropWorktreeOwner(primaryCheckout, wtPath);
+      report.push(await bestEffortGit(["branch", "-D", branch], primaryCheckout, `delete local branch ${branch}`));
+      if (!keepRemoteBranch) {
+        report.push(await bestEffortGit(["push", o.remote, "--delete", branch], void 0, `delete remote branch ${branch}`, GH_MUTATION_TIMEOUT_MS));
+      } else if (!o.keepRemote) {
+        report.push({ step: `delete remote branch ${branch}`, status: `skipped: ${landRefs.action === "keep-remote" ? landRefs.reason : "kept"}` });
       }
-      if (reason === "duplicate-of" && !opts.duplicateOf) {
-        fail("issue close: --reason duplicate-of requires --duplicate-of <number>", {
-          code: ERROR_CODES.ERR_MISSING_FLAG,
-          offending_flag: "--duplicate-of"
-        });
+      report.push(await bestEffortGit(["worktree", "prune"], primaryCheckout, "prune worktree metadata"));
+      const result = {
+        dryRun: false,
+        ...plan,
+        ...o.keepRemote ? { keepRemote: true } : {},
+        // #3566: the merge outcome, machine-readable, so an orchestrator never has to infer it from the
+        // absence of an error. `merged` is the ONLY value that means the work reached the base branch.
+        mergeState: mergeVerdict.state,
+        prNumbers: mergeVerdict.numbers,
+        report
+      };
+      if (o.json) return console.log(JSON.stringify(result, null, 2));
+      console.log(`worktree land: cleaned up branch ${branch} (${describeLandMergeState(mergeVerdict)})`);
+      for (const r of report) console.log(`  ${r.step}: ${r.status}`);
+      if (mergeVerdict.state !== "merged") {
+        console.warn(`worktree land: '${branch}' was cleaned up but NOT merged \u2014 ${describeLandMergeState(mergeVerdict)}. Do not report this work as shipped.`);
       }
-      return { command: "issue close", ref: args[0], reason: reason ?? "completed", duplicateOf: opts.duplicateOf };
-    }
-  ).action(async (ref, o) => {
-    const parsed = parseCloseReason(o.reason);
-    try {
-      const defaultRepo = await resolveRepo(o.repo);
-      const result = await closeIssue(defaultGitHubClient(), {
-        ref,
-        defaultRepo,
-        reason: parsed.reason,
-        duplicateOf: o.duplicateOf ? Number(o.duplicateOf) : void 0,
-        comment: o.comment
-      });
-      console.log(JSON.stringify(result));
-    } catch (e) {
-      return failGraceful(`issue close failed: ${e.message}`);
-    }
-  });
-  mutating(
-    issue2.command("reopen <ref>").description("reopen a closed issue and move its board item back to Todo").option("--repo <owner/repo>", "repo for a bare ref (defaults to the current repo)"),
-    (_opts, args) => ({ command: "issue reopen", ref: args[0] })
-  ).action(async (ref, o) => {
-    try {
-      const defaultRepo = await resolveRepo(o.repo);
-      const result = await reopenIssue(defaultGitHubClient(), ref, defaultRepo);
-      console.log(JSON.stringify(result));
-    } catch (e) {
-      return failGraceful(`issue reopen failed: ${e.message}`);
-    }
-  });
-  mutating(
-    issue2.command("assign <ref> <login>").description("assign a user to an issue \u2014 pure ownership, no board Status change (unlike board claim)").option("--repo <owner/repo>", "repo for a bare ref (defaults to the current repo)"),
-    (_opts, args) => ({ command: "issue assign", ref: args[0], login: args[1] })
-  ).action(async (ref, login, o) => {
-    try {
-      const defaultRepo = await resolveRepo(o.repo);
-      const result = await assignIssue(defaultGitHubClient(), ref, login, defaultRepo);
-      console.log(JSON.stringify(result));
-    } catch (e) {
-      return failGraceful(`issue assign failed: ${e.message}`);
-    }
-  });
-  mutating(
-    issue2.command("unassign <ref> <login>").description("remove a user from an issue \u2014 pure ownership, no board Status change").option("--repo <owner/repo>", "repo for a bare ref (defaults to the current repo)"),
-    (_opts, args) => ({ command: "issue unassign", ref: args[0], login: args[1] })
-  ).action(async (ref, login, o) => {
-    try {
-      const defaultRepo = await resolveRepo(o.repo);
-      const result = await unassignIssue(defaultGitHubClient(), ref, login, defaultRepo);
-      console.log(JSON.stringify(result));
-    } catch (e) {
-      return failGraceful(`issue unassign failed: ${e.message}`);
-    }
-  });
-  mutating(
-    issue2.command("relocate <ref>").description("transfer an issue to another repo, sweep the ghost board item, add to the destination board, and carry priority").requiredOption("--to <owner/repo>", "destination repository").option("--repo <owner/repo>", "source repo for a bare ref (defaults to the current repo)"),
-    (opts, args) => ({ command: "issue relocate", ref: args[0], to: opts.to })
-  ).action(async (ref, o) => {
-    try {
-      const defaultRepo = await resolveRepo(o.repo);
-      const result = await relocateIssue(defaultGitHubClient(), ref, o.to, defaultRepo);
-      console.log(JSON.stringify(result));
+      if (report.some((r) => r.status.startsWith("failed"))) process.exitCode = 1;
     } catch (e) {
-      return failGraceful(`issue relocate failed: ${e.message}`);
+      return failGraceful(`worktree land: ${e.message}`);
     }
   });
-  mutating(
-    issue2.command("unlink-child <parent> <child>").description("unlink a child issue from its parent (inverse of link-child) and print {parentNumber,subIssueNumber,totalCount} JSON").option("--repo <owner/repo>", "repo for bare refs on either side (defaults to the current repo)"),
-    (_opts, args) => ({ command: "issue unlink-child", parent: args[0], child: args[1] })
-  ).action(async (parentRef, childRef, o) => {
-    const defaultRepo = await resolveRepo(o.repo);
+  if (!has("list")) worktree2.command("list").description("list worktrees; --stale surfaces orphaned worktrees/branches/running dev servers with remediation").option("--stale", "show only leaks (merged/closed branches, orphan dirs, stale dev servers)").option("--json", "machine-readable output").action(async (o) => {
     try {
-      const result = await unlinkSubIssue(ghRunner, parentRef, childRef, defaultRepo);
-      console.log(JSON.stringify(result));
+      const ctx = await gatherWorktreeContext();
+      if (o.stale) {
+        const leaks = classifyStaleLeaks(ctx);
+        if (o.json) return console.log(JSON.stringify({ stale: leaks, count: leaks.length }, null, 2));
+        return console.log(formatStaleLeaks(leaks));
+      }
+      if (o.json) return console.log(JSON.stringify({ worktrees: ctx.worktrees }, null, 2));
+      if (!ctx.worktrees.length) return console.log("worktree list: no worktrees");
+      const lines = ["worktree list:"];
+      for (const wt of ctx.worktrees) {
+        const tag = wt.primary ? "primary" : "worktree";
+        lines.push(`  ${wt.branch} @ ${wt.path} (${tag})`);
+      }
+      console.log(lines.join("\n"));
     } catch (e) {
-      const err = e;
-      const note = timeoutKillNote(e, GH_MUTATION_TIMEOUT_MS);
-      return failGraceful(`issue unlink-child: ${(err.stderr || err.message || String(e)).trim()}${note ? ` (${note})` : ""}`);
+      return failGraceful(`worktree list: ${e.message}`);
     }
   });
-  extendCreateCommand(issue2, deps.attach);
 }
-function extendCreateCommand(issue2, batchAttach) {
-  const createCmd = issue2.commands.find((c) => c.name() === "create");
-  if (!createCmd) return;
-  createCmd.option("--batch <file.json>", "create multiple issues from a JSON array file (pre-validates all rows before creating any)").option("--idempotency-key <key>", "create-if-not-exists: skip creation when an issue with this key already exists (retried loops must not duplicate)");
-  const internal = createCmd;
-  const originalListener = internal._actionHandler;
-  internal._actionHandler = async (args) => {
-    const opts = createCmd.opts();
-    if (opts.batch) {
-      let specs;
-      try {
-        const raw = (0, import_node_fs27.readFileSync)(opts.batch, "utf8");
-        specs = JSON.parse(raw);
-        if (!Array.isArray(specs)) throw new Error("batch file must contain a JSON array");
-      } catch (e) {
-        return fail(`issue create --batch: cannot read/parse ${opts.batch}: ${e.message}`);
-      }
-      const validation = validateBatchSpecs(specs);
-      if (!validation.ok) {
-        const lines = validation.errors.map((e) => `  row ${e.row}: ${e.error}`).join("\n");
-        return fail(`issue create --batch: validation failed (${validation.errors.length} error(s)):
-${lines}`);
-      }
-      const batchParent = opts.parent;
-      const batchPriority = opts.priority ? normalizePriority(opts.priority) : void 0;
-      if (opts.dryRun || opts.validateOnly) {
-        const planned = validation.validated.map((v) => ({
-          row: v.row,
-          type: v.type,
-          title: v.spec.title,
-          priority: v.spec.priority ? v.priority : batchPriority ?? v.priority,
-          repo: v.spec.repo,
-          ...v.spec.parent ?? batchParent ? { parent: v.spec.parent ?? batchParent } : {}
-        }));
-        console.log(JSON.stringify(opts.validateOnly ? { ok: true, planned } : { dry_run: true, planned }));
-        return;
-      }
-      try {
-        const result = await createIssuesBatch(specs, {
-          repo: opts.repo,
-          idempotencyKey: opts.idempotencyKey,
-          parent: batchParent,
-          priority: batchPriority
-        }, { attach: batchAttach });
-        console.log(JSON.stringify(result));
-        if (result.failures.length) process.exitCode = 1;
-      } catch (e) {
-        return failGraceful(`issue create --batch failed: ${e.message}`);
-      }
-      return;
+async function gatherWorktreeContext() {
+  const repoRoot2 = await repoRootOf();
+  const porcelain = (await execFileP2("git", ["worktree", "list", "--porcelain"], { timeout: GIT_TIMEOUT_MS }).catch(() => ({ stdout: "" }))).stdout;
+  const parsed = parseWorktreePorcelain(porcelain);
+  const primaryPath = parsed[0]?.path ?? repoRoot2;
+  const worktrees = parsed.map((w) => ({ path: toNativePath(w.path), branch: w.branch, primary: w.path === primaryPath }));
+  const branchOut = (await execFileP2("git", ["branch", "--format=%(refname:short)"], { timeout: GIT_TIMEOUT_MS }).catch(() => ({ stdout: "" }))).stdout;
+  const localBranches = branchOut.split(/\r?\n/).map((l) => l.trim()).filter(Boolean);
+  const currentBranch2 = (await execFileP2("git", ["rev-parse", "--abbrev-ref", "HEAD"], { timeout: GIT_TIMEOUT_MS }).catch(() => ({ stdout: "" }))).stdout.trim() || void 0;
+  const openPrBranches = /* @__PURE__ */ new Set();
+  const closedBranches = /* @__PURE__ */ new Set();
+  try {
+    const { stdout } = await execFileP2("gh", ["pr", "list", "--state", "all", "--limit", "200", "--json", "headRefName,state"], { timeout: GH_TIMEOUT_MS });
+    const prs = JSON.parse(stdout || "[]");
+    const byBranch = /* @__PURE__ */ new Map();
+    for (const pr2 of prs) {
+      const arr = byBranch.get(pr2.headRefName) ?? [];
+      arr.push(pr2.state);
+      byBranch.set(pr2.headRefName, arr);
     }
-    if (opts.idempotencyKey && !opts.dryRun && !opts.validateOnly) {
-      try {
-        const repo = await resolveRepo(opts.repo);
-        if (repo) {
-          const existing = await findExistingByIdempotencyKey(defaultGitHubClient(), opts.idempotencyKey, repo);
-          if (existing) {
-            console.log(JSON.stringify({ ...existing, idempotent: true }));
-            return;
-          }
-        }
-      } catch {
-      }
+    for (const [br, states] of byBranch) {
+      if (states.some((s) => s === "OPEN")) openPrBranches.add(br);
+      else if (states.some((s) => s === "MERGED" || s === "CLOSED")) closedBranches.add(br);
     }
-    return originalListener?.(args);
-  };
-}
-
-// src/train-commands.ts
-var import_node_fs29 = require("node:fs");
-var import_node_path27 = require("node:path");
-
-// src/plugin-guard-io.ts
-var import_node_fs28 = require("node:fs");
-var import_node_path26 = require("node:path");
-var import_node_os6 = require("node:os");
-
-// src/plugin-guard.ts
-function buildPluginGuardDecision(i) {
-  if (!i.isOrgRepo) return { state: "not-org" };
-  if (!i.installRecordPresent) return { state: "no-install" };
-  if (!i.marketplaceClonePresent || !i.pluginCachePresent) return { state: "unresolved" };
-  return { state: "healthy" };
-}
-function buildPluginGuardLine(state, opts = {}) {
-  if (state === "healthy" || state === "not-org") return { exitCode: 0 };
-  const recovery = opts.recovery ?? "mmi-cli plugin heal";
-  const restartHint = opts.restartHint ?? "restart your agent host / reload plugins";
-  const reason = state === "no-install" ? "MMI plugin is not installed for this user/session" : "MMI plugin is installed but its marketplace/cache is unresolved";
-  return {
-    line: `[mmi-guard] ${reason}; run ${recovery} and ${restartHint}.`,
-    exitCode: 1
-  };
-}
-
-// src/plugin-guard-io.ts
-var isWin = process.platform === "win32";
-var MMI_PLUGIN_ID = "mmi@mutmutco";
-var LEGACY_MMI_MARKETPLACE = "mmi";
-function detectSurface(env) {
-  const has = (k) => Boolean(env[k]?.trim());
-  if (env.MMI_AGENT_SURFACE === "codex" || has("CODEX_HOME") || (env.CLAUDE_PLUGIN_ROOT ?? "").includes(".codex")) {
-    return "codex";
+  } catch {
   }
-  if (env.MMI_AGENT_SURFACE === "cursor" || has("CURSOR_TRACE_ID") || has("CURSOR_USER") || has("CURSOR_SESSION_ID") || env.CURSOR_AGENT === "1" || has("CURSOR_EXTENSION_HOST_ROLE")) {
-    return "cursor";
+  const stages = [];
+  for (const wt of worktrees) {
+    const s = readStageSummary(wt.path);
+    if (s) stages.push({ path: wt.path, port: s.port });
   }
-  if (env.MMI_AGENT_SURFACE === "opencode" || has("OPENCODE_CLIENT") || has("OPENCODE_SERVER_USERNAME")) return "opencode";
-  const isClaude = has("CLAUDECODE") || has("CLAUDE_CODE_ENTRYPOINT") || has("CLAUDE_PLUGIN_ROOT") || env.MMI_AGENT_SURFACE === "claude";
-  const isVscode = env.TERM_PROGRAM === "vscode" || has("VSCODE_PID") || has("VSCODE_GIT_ASKPASS_NODE");
-  if (isClaude && isVscode) return "claude-vscode";
-  if (isClaude) return "claude-cli";
-  return "shell";
-}
-function surfaceToken(surface) {
-  switch (surface) {
-    case "claude-cli":
-    case "claude-vscode":
-      return "claude";
-    case "codex":
-      return "codex";
-    case "cursor":
-      return "cursor";
-    case "opencode":
-      return "opencode";
-    case "shell":
-    default:
-      return null;
+  const worktreeGitRoot = await currentRepoWorktreeGitRoot(repoRoot2);
+  const primaryRepoRoot = worktreeGitRoot ? (0, import_node_path27.dirname)((0, import_node_path27.dirname)(worktreeGitRoot)) : repoRoot2;
+  const wtRoot = siblingMmiWorktreesRoot(primaryRepoRoot);
+  let orphanDirs = [];
+  if ((0, import_node_fs28.existsSync)(wtRoot)) {
+    orphanDirs = scanOrphanDirs(wtRoot, worktreeGitRoot, {
+      ...defaultOrphanDirScanDeps,
+      listDirs: (root) => worktreeScanDirs(root, primaryRepoRoot, defaultOrphanDirScanDeps.listDirs, isRepoCheckoutDir)
+    });
   }
+  return { worktrees, localBranches, currentBranch: currentBranch2, openPrBranches, closedBranches, stages, orphanDirs };
 }
-function reloadAction(surface) {
-  switch (surface) {
-    case "claude-vscode":
-      return "restart VS Code";
-    case "codex":
-      return "restart Codex";
-    case "opencode":
-      return "restart OpenCode";
-    case "cursor":
-      return "restart Cursor (or refresh the Team Marketplace from Dashboard \u2192 Settings \u2192 Plugins)";
-    case "claude-cli":
-    case "shell":
-    default:
-      return "restart Claude Code (or run /reload-plugins)";
+async function bestEffortGit(args, cwd, step, timeoutMs = GIT_TIMEOUT_MS) {
+  try {
+    const fullArgs = cwd ? ["-C", cwd, ...args] : args;
+    await execFileP2("git", fullArgs, { timeout: timeoutMs });
+    return { step, status: "done" };
+  } catch (e) {
+    const msg = e.message.split("\n")[0];
+    if (/not found|already|no such|does not exist|not a valid|couldn't|unable to resolve/i.test(msg)) {
+      return { step, status: "already gone" };
+    }
+    return { step, status: `failed: ${msg}` };
   }
 }
-var CLAUDE_RECOVERY = `claude plugin marketplace remove ${LEGACY_MMI_MARKETPLACE} && claude plugin marketplace remove mutmutco && claude plugin marketplace add mutmutco/MMI-Hub --ref main && claude plugin install mmi@mutmutco`;
-var PLUGIN_SURFACE_HEAL = {
-  claude: {
-    delivery: "plugin-cli",
-    recovery: CLAUDE_RECOVERY,
-    healSteps: [
-      { args: ["plugin", "marketplace", "remove", LEGACY_MMI_MARKETPLACE], gated: false },
-      { args: ["plugin", "marketplace", "remove", "mutmutco"], gated: false },
-      { args: ["plugin", "marketplace", "add", "mutmutco/MMI-Hub", "--ref", "main"], gated: true },
-      { args: ["plugin", "install", "mmi@mutmutco"], gated: true },
-      { args: ["plugin", "enable", "mmi@mutmutco"], gated: false }
-    ],
-    fix: (surface) => `${CLAUDE_RECOVERY}   # then ${reloadAction(surface)} to reload MMI commands`,
-    updateRecipe: [CLAUDE_RECOVERY]
+
+// src/issue-commands.ts
+var import_node_fs29 = require("node:fs");
+var import_node_crypto5 = require("node:crypto");
+var ghRunner = async (args, timeoutMs) => (await execFileP2("gh", args, { timeout: timeoutMs })).stdout;
+async function editIssue(client, options, deps = {}) {
+  const parsed = parseIssueRef(options.ref);
+  const repo = parsed.repo ?? options.defaultRepo;
+  if (!repo) throw new Error("could not resolve repo \u2014 pass --repo owner/repo");
+  const url = `https://github.com/${repo}/issues/${parsed.number}`;
+  const patch = {};
+  let bodyChanged = false;
+  if (options.title !== void 0) patch.title = options.title;
+  if (options.body !== void 0 || options.bodyFile !== void 0) {
+    let body;
+    if (options.bodyFile) {
+      const td = deps.textDeps ?? { readFile: (p, e) => Promise.resolve((0, import_node_fs29.readFileSync)(p, e)), readStdin: () => Promise.resolve("") };
+      body = await resolveIssueBody({ body: options.body, bodyFile: options.bodyFile }, td);
+    } else {
+      body = options.body ?? "";
+    }
+    patch.body = body;
+    bodyChanged = true;
   }
-};
-function nonClaudeSurfaceHealMessage(surface) {
-  if (surface === "codex") {
-    return "Codex ships an MMI plugin (#3563). Install or repair it with:\n  codex plugin marketplace add mutmutco/MMI-Hub && codex plugin add mmi@mutmutco\n  Then run /hooks and TRUST the MMI hooks \u2014 bundled hooks are skipped until reviewed.\n  Update the CLI too: npm i -g @mutmutco/cli";
+  if (patch.title !== void 0 || patch.body !== void 0) {
+    await client.rest("PATCH", `repos/${repo}/issues/${parsed.number}`, { body: patch });
   }
-  return "No Hub-shipped MMI plugin on this host \u2014 the Hub ships plugins for Claude and Codex only.\n  Update the CLI instead: npm i -g @mutmutco/cli   (org rules ride an AGENTS.md authored outside the Hub)";
-}
-function healStepAborts(step, ok) {
-  return !ok && step.gated;
-}
-function marketplaceAddSupportsRef(helpText) {
-  if (!helpText) return false;
-  return /(^|\s)--ref(\b|=)/.test(helpText);
+  const labelsAdded = [];
+  const labelsRemoved = [];
+  if (options.addLabel?.length) {
+    await client.rest("POST", `repos/${repo}/issues/${parsed.number}/labels`, { body: { labels: options.addLabel } });
+    labelsAdded.push(...options.addLabel);
+  }
+  for (const label of options.removeLabel ?? []) {
+    try {
+      await client.rest("DELETE", `repos/${repo}/issues/${parsed.number}/labels/${encodeURIComponent(label)}`);
+      labelsRemoved.push(label);
+    } catch (e) {
+      if (e instanceof GitHubApiError && e.status === 404) {
+        labelsRemoved.push(label);
+      } else {
+        throw e;
+      }
+    }
+  }
+  let parentResult;
+  if (options.parent) {
+    const run = deps.runGh ?? ghRunner;
+    parentResult = await linkSubIssue(run, options.parent, options.ref, repo);
+  }
+  return {
+    number: parsed.number,
+    repo,
+    url,
+    ...patch.title !== void 0 ? { title: patch.title } : {},
+    bodyChanged,
+    labelsAdded,
+    labelsRemoved,
+    ...parentResult ? { parent: parentResult } : {}
+  };
 }
-function adaptHealStepsForRefSupport(steps, refSupported) {
-  if (refSupported) return { steps: [...steps], strippedRef: false };
-  let strippedRef = false;
-  const adapted = steps.map((step) => {
-    const refIdx = step.args.indexOf("--ref");
-    const isAdd = step.args.includes("marketplace") && step.args.includes("add");
-    if (!isAdd || refIdx === -1) return step;
-    strippedRef = true;
-    return { ...step, args: [...step.args.slice(0, refIdx), ...step.args.slice(refIdx + 2)] };
+async function closeIssue(client, options, deps = {}) {
+  const parsed = parseIssueRef(options.ref);
+  const repo = parsed.repo ?? options.defaultRepo;
+  if (!repo) throw new Error("could not resolve repo \u2014 pass --repo owner/repo");
+  const url = `https://github.com/${repo}/issues/${parsed.number}`;
+  const reason = options.reason ?? "completed";
+  const stateReason = reason === "duplicate-of" ? "not_planned" : reason === "not-planned" ? "not_planned" : "completed";
+  await client.rest("PATCH", `repos/${repo}/issues/${parsed.number}`, {
+    body: { state: "closed", state_reason: stateReason }
   });
-  return { steps: adapted, strippedRef };
-}
-function recoveryWithoutRef(recovery) {
-  return recovery.replace(/ --ref \S+/g, "");
-}
-function hasProjectInstallRecord(file, pluginId, projectPath) {
-  const records = file?.plugins?.[pluginId];
-  if (!Array.isArray(records)) return false;
-  return records.some((r) => r.scope === "project" && r.projectPath === projectPath);
-}
-function hasUserInstallRecord(file, pluginId) {
-  const records = file?.plugins?.[pluginId];
-  if (!Array.isArray(records)) return false;
-  return records.some((r) => r.scope === "user");
-}
-var CLAUDE_PLUGIN_TIMEOUT_MS = 12e4;
-var NPM_VIEW_TIMEOUT_MS = 15e3;
-function runHostBin(bin, args, opts) {
-  return isWin ? execFileP2("cmd.exe", ["/c", bin, ...args], opts) : execFileP2(bin, args, opts);
-}
-var installedPluginsPath2 = (surface = detectSurface(process.env)) => {
-  const homeDir = surface === "codex" ? ".codex" : ".claude";
-  return (0, import_node_path26.join)((0, import_node_os6.homedir)(), homeDir, "plugins", "installed_plugins.json");
-};
-function readInstalledPlugins(surface = detectSurface(process.env)) {
-  try {
-    return JSON.parse((0, import_node_fs28.readFileSync)(installedPluginsPath2(surface), "utf8"));
-  } catch {
-    return null;
+  if (reason === "duplicate-of" && options.duplicateOf) {
+    await client.rest("POST", `repos/${repo}/issues/${parsed.number}/comments`, {
+      body: { body: `Duplicate of #${options.duplicateOf}` }
+    });
   }
-}
-function marketplaceCloneCandidates(surface, home) {
-  if (surface === "codex") {
-    return [
-      (0, import_node_path26.join)(home, ".codex", ".tmp", "marketplaces", "mutmutco"),
-      (0, import_node_path26.join)(home, ".codex", "plugins", "marketplaces", "mutmutco")
-    ];
+  if (options.comment) {
+    await client.rest("POST", `repos/${repo}/issues/${parsed.number}/comments`, {
+      body: { body: options.comment }
+    });
   }
-  return [(0, import_node_path26.join)(home, ".claude", "plugins", "marketplaces", "mutmutco")];
-}
-function marketplaceClonePresent(surface, home, exists = import_node_fs28.existsSync) {
-  return marketplaceCloneCandidates(surface, home).some(exists);
-}
-async function fetchNpmReleasedVersion() {
+  let board;
   try {
-    const { stdout } = await runHostBin("npm", npmReleasedVersionArgs(), { timeout: NPM_VIEW_TIMEOUT_MS });
-    return parseNpmVersion(stdout);
+    const cfg = await loadConfigForBoardSelector(options.ref, options.defaultRepo);
+    if (cfg.projectId) {
+      const result = await moveBoardItem({ config: cfg, selector: options.ref, status: "Done", repo, allowPartial: true }, deps);
+      board = { status: result.status, partial: result.partial };
+    }
   } catch {
-    return void 0;
   }
+  return { number: parsed.number, repo, url, state: "closed", stateReason, ...board ? { board } : {} };
 }
-var NPM_INSTALL_TIMEOUT_MS = 12e4;
-async function npmSelfUpdateCli(target) {
-  const command = cliUpdateCommand(target);
+async function reopenIssue(client, ref, defaultRepo, deps = {}) {
+  const parsed = parseIssueRef(ref);
+  const repo = parsed.repo ?? defaultRepo;
+  if (!repo) throw new Error("could not resolve repo \u2014 pass --repo owner/repo");
+  const url = `https://github.com/${repo}/issues/${parsed.number}`;
+  await client.rest("PATCH", `repos/${repo}/issues/${parsed.number}`, { body: { state: "open" } });
+  let board;
   try {
-    await runHostBin("npm", ["install", "-g", `@mutmutco/cli@${target ?? "latest"}`], { timeout: NPM_INSTALL_TIMEOUT_MS });
-    return { ok: true, detail: `${command} exited 0` };
-  } catch (e) {
-    return { ok: false, detail: e.message.trim().slice(0, 200).replace(/\s+/g, " ") };
+    const cfg = await loadConfigForBoardSelector(ref, defaultRepo);
+    if (cfg.projectId) {
+      const result = await moveBoardItem({ config: cfg, selector: ref, status: "Todo", repo, allowPartial: true }, deps);
+      board = { status: result.status, partial: result.partial };
+    }
+  } catch {
   }
+  return { number: parsed.number, repo, url, state: "open", ...board ? { board } : {} };
 }
-function snapshotPluginGuardInput(surface = detectSurface(process.env), isOrgRepo = false) {
-  const homeDir = surface === "codex" ? ".codex" : ".claude";
-  const installed = readInstalledPlugins(surface);
-  return {
-    isOrgRepo,
-    installRecordPresent: hasUserInstallRecord(installed, MMI_PLUGIN_ID) || hasProjectInstallRecord(installed, MMI_PLUGIN_ID, process.cwd()),
-    marketplaceClonePresent: marketplaceClonePresent(surface, (0, import_node_os6.homedir)()),
-    pluginCachePresent: (0, import_node_fs28.existsSync)((0, import_node_path26.join)((0, import_node_os6.homedir)(), homeDir, "plugins", "cache", "mutmutco", "mmi"))
-  };
+async function assignIssue(client, ref, login, defaultRepo) {
+  const parsed = parseIssueRef(ref);
+  const repo = parsed.repo ?? defaultRepo;
+  if (!repo) throw new Error("could not resolve repo \u2014 pass --repo owner/repo");
+  await client.rest("POST", `repos/${repo}/issues/${parsed.number}/assignees`, { body: { assignees: [login] } });
+  return { number: parsed.number, repo, url: `https://github.com/${repo}/issues/${parsed.number}`, login, action: "assigned" };
 }
-function claudePluginGuardState(isOrgRepo) {
-  return buildPluginGuardDecision(snapshotPluginGuardInput(detectSurface(process.env), isOrgRepo)).state;
+async function unassignIssue(client, ref, login, defaultRepo) {
+  const parsed = parseIssueRef(ref);
+  const repo = parsed.repo ?? defaultRepo;
+  if (!repo) throw new Error("could not resolve repo \u2014 pass --repo owner/repo");
+  await client.rest("DELETE", `repos/${repo}/issues/${parsed.number}/assignees`, { body: { assignees: [login] } });
+  return { number: parsed.number, repo, url: `https://github.com/${repo}/issues/${parsed.number}`, login, action: "unassigned" };
 }
-async function runClaudePlugin(args) {
+var TRANSFER_ISSUE_MUTATION = `
+mutation($issueId: ID!, $repositoryId: ID!) {
+  transferIssue(input: {issueId: $issueId, repositoryId: $repositoryId}) {
+    issue {
+      id
+      number
+      url
+      repository { nameWithOwner }
+    }
+  }
+}`;
+var ADD_PROJECT_ITEM_MUTATION = `
+mutation($projectId: ID!, $contentId: ID!) {
+  addProjectV2ItemById(input: {projectId: $projectId, contentId: $contentId}) {
+    item { id }
+  }
+}`;
+async function relocateIssue(client, ref, toRepo, defaultRepo, deps = {}) {
+  const parsed = parseIssueRef(ref);
+  const sourceRepo = parsed.repo ?? defaultRepo;
+  if (!sourceRepo) throw new Error("could not resolve the source repo \u2014 pass owner/repo#123 or use --repo");
+  let sourceItemId;
+  let priority;
   try {
-    await runHostBin("claude", args, { timeout: CLAUDE_PLUGIN_TIMEOUT_MS });
-    return true;
+    const sourceCfg = await loadConfigForBoardSelector(ref, defaultRepo);
+    if (sourceCfg.projectId) {
+      const resolved = resolveBoardConfig(sourceCfg);
+      const lookup = await fetchIssueProjectItem(client, resolved, { repo: sourceRepo, number: parsed.number });
+      sourceItemId = lookup.item?.itemId;
+      priority = lookup.item?.priority;
+    }
   } catch {
-    return false;
   }
-}
-async function marketplaceAddRefSupported(bin) {
+  const sourceIssue = await client.rest("GET", `repos/${sourceRepo}/issues/${parsed.number}`);
+  const issueNodeId = sourceIssue?.node_id;
+  if (!issueNodeId) throw new Error(`could not resolve node id for ${sourceRepo}#${parsed.number}`);
+  const targetRepoData = await client.rest("GET", `repos/${toRepo}`);
+  const targetRepoNodeId = targetRepoData?.node_id;
+  if (!targetRepoNodeId) throw new Error(`could not resolve node id for repo ${toRepo}`);
+  const transferred = await client.graphql(
+    TRANSFER_ISSUE_MUTATION,
+    { issueId: issueNodeId, repositoryId: targetRepoNodeId }
+  );
+  const newIssue = transferred?.transferIssue?.issue;
+  if (!newIssue?.id || !newIssue.number || !newIssue.url) {
+    throw new Error("transferIssue returned an unexpected response (no issue id/number/url)");
+  }
+  const newRepo = newIssue.repository?.nameWithOwner ?? toRepo;
+  const newNumber = newIssue.number;
+  const newUrl = newIssue.url;
+  const newNodeId = newIssue.id;
+  let swept = false;
+  if (sourceItemId) {
+    try {
+      const sourceCfg = await loadConfigForBoardSelector(ref, defaultRepo);
+      if (sourceCfg.projectId) {
+        const resolved = resolveBoardConfig(sourceCfg);
+        const DELETE_MUTATION = `mutation($projectId: ID!, $itemId: ID!) { deleteProjectV2Item(input: {projectId: $projectId, itemId: $itemId}) { deletedItemId } }`;
+        await client.graphql(DELETE_MUTATION, { projectId: resolved.projectId, itemId: sourceItemId });
+        swept = true;
+      }
+    } catch {
+    }
+  }
+  let added = false;
+  let carriedPriority;
   try {
-    const { stdout, stderr } = await runHostBin(bin, ["plugin", "marketplace", "add", "--help"], {
-      timeout: CLAUDE_PLUGIN_TIMEOUT_MS
-    });
-    return marketplaceAddSupportsRef(`${stdout}
-${stderr}`);
+    const destCfg = await loadConfigForBoardSelector(`${newRepo}#${newNumber}`, newRepo);
+    if (destCfg.projectId) {
+      const addResult = await client.graphql(
+        ADD_PROJECT_ITEM_MUTATION,
+        { projectId: destCfg.projectId, contentId: newNodeId }
+      );
+      const newItemId = addResult?.addProjectV2ItemById?.item?.id;
+      if (newItemId && priority) {
+        try {
+          const p = priority.toLowerCase();
+          if (CLI_PRIORITIES.includes(p)) {
+            await setBoardItemPriority(client, destCfg, newItemId, p);
+            carriedPriority = priority;
+          }
+        } catch {
+        }
+      }
+      added = true;
+    }
   } catch {
-    return false;
   }
+  return {
+    number: newNumber,
+    repo: newRepo,
+    url: newUrl,
+    previousRepo: sourceRepo,
+    previousNumber: parsed.number,
+    board: { swept, added, ...carriedPriority ? { priority: carriedPriority } : {} }
+  };
 }
-function healBannerLine(bin, token, refSupported) {
-  const installVerb = token === "codex" ? "add" : "install";
-  return refSupported ? `  \u21BB reinstalling the MMI plugin via \`${bin} plugin\` (marketplace remove \u2192 add --ref main \u2192 ${installVerb})\u2026` : `  \u21BB reinstalling the MMI plugin via \`${bin} plugin\` (marketplace remove \u2192 add \u2192 ${installVerb}; release ref pinned by the marketplace manifest)\u2026`;
+function idempotencyMarker(key) {
+  return `mmi-idempotency:${key}`;
 }
-function refAbsenceNote(bin, refSupported) {
-  return refSupported ? "" : `
-  Note: \`${bin}\` has no \`--ref\` option; the marketplace manifest pins the released branch, so none is needed (#2516).`;
+function appendIdempotencyMarker(body, key) {
+  const marker = `<!-- ${idempotencyMarker(key)} -->`;
+  if (body.includes(marker)) return body;
+  return `${body.replace(/\s+$/, "")}
+
+${marker}
+`;
 }
-var PLUGIN_READ_REPO2 = "mutmutco/MMI-Hub";
-function pluginReadGrantNote(login = "<your-github-login>") {
-  return `
-  If the reinstall 404s on ${PLUGIN_READ_REPO2}, you lack read on it. An org owner must grant it (idempotent):
-  gh api -X PUT repos/${PLUGIN_READ_REPO2}/collaborators/${login} -f permission=pull`;
+function rowIdempotencyKey(batchKey, spec) {
+  const identity = `${spec.type}
+${spec.title.trim()}
+${spec.body ?? ""}`;
+  const hash = (0, import_node_crypto5.createHash)("sha256").update(identity).digest("hex").slice(0, 16);
+  return `${batchKey}:${hash}`;
 }
-async function applyPluginHeal(surface, log, opts) {
-  if (!opts?.force && surfaceToken(surface) !== "claude") return false;
-  const tableSteps = PLUGIN_SURFACE_HEAL.claude.healSteps;
-  if (!tableSteps) return false;
-  const refSupported = await marketplaceAddRefSupported("claude");
-  const { steps } = adaptHealStepsForRefSupport(tableSteps, refSupported);
-  log(healBannerLine("claude", "claude", refSupported));
-  const pinsPath = (0, import_node_path26.join)((0, import_node_os6.homedir)(), ...KNOWN_MARKETPLACES_RELATIVE);
-  const pins = captureMarketplacePins(readKnownMarketplacesFile(pinsPath), [MMI_MARKETPLACE_NAME, JERV_MARKETPLACE_NAME]);
-  for (const step of steps) {
-    if (healStepAborts(step, await runClaudePlugin([...step.args]))) return false;
+var BATCH_SPEC_KEYS = /* @__PURE__ */ new Set(["type", "title", "body", "priority", "labels", "parent", "repo"]);
+function validateBatchSpecs(specs) {
+  const errors = [];
+  const validated = [];
+  const validTypes = ["bug", "feature", "task"];
+  for (let i = 0; i < specs.length; i += 1) {
+    const spec = specs[i];
+    const row = i + 1;
+    if (!spec || typeof spec !== "object") {
+      errors.push({ row, error: "not an object" });
+      continue;
+    }
+    const unknown = Object.keys(spec).filter((k) => !BATCH_SPEC_KEYS.has(k));
+    if (unknown.length) {
+      errors.push({ row, error: `unknown key(s): ${unknown.join(", ")} \u2014 expected only: ${[...BATCH_SPEC_KEYS].join(", ")}` });
+      continue;
+    }
+    if (spec.repo !== void 0 && !/^[\w.-]+\/[\w.-]+$/.test(spec.repo)) {
+      errors.push({ row, error: `bad repo "${spec.repo}" \u2014 expected owner/repo` });
+      continue;
+    }
+    if (!validTypes.includes(spec.type)) {
+      errors.push({ row, error: `unknown type "${spec.type}" \u2014 expected one of: ${validTypes.join(", ")}` });
+      continue;
+    }
+    if (!spec.title || !spec.title.trim()) {
+      errors.push({ row, error: "missing or empty title" });
+      continue;
+    }
+    let priority;
+    try {
+      priority = spec.priority ? normalizePriority(spec.priority) : "medium";
+    } catch (e) {
+      errors.push({ row, error: e.message });
+      continue;
+    }
+    validated.push({ row, spec, priority, type: spec.type });
   }
-  const restored = restoreMarketplacePinsOnDisk(pinsPath, pins);
-  if (restored) log(`  ${restored}`);
-  return true;
+  return { ok: errors.length === 0, errors, validated };
 }
-async function healClaudePluginForDoctor(surface = detectSurface(process.env)) {
-  if (surfaceToken(surface) !== "claude") {
-    return { ok: false, detail: `not a Claude surface (${surface}) \u2014 no Hub-shipped plugin to reinstall` };
+async function createIssuesBatch(specs, options, deps = {}) {
+  const ensureLabels = deps.ensureLabels ?? ensureLabelsExist;
+  const client = deps.client ?? defaultGitHubClient();
+  const runCreate = deps.runCreate ?? (async (args) => (await execFileP2("gh", args, { timeout: GH_MUTATION_TIMEOUT_MS })).stdout);
+  const validation = validateBatchSpecs(specs);
+  if (!validation.ok) {
+    const lines = validation.errors.map((e) => `  row ${e.row}: ${e.error}`).join("\n");
+    throw new Error(`batch validation failed (${validation.errors.length} error(s)):
+${lines}`);
   }
-  const steps = [];
-  const ok = await applyPluginHeal(surface, (msg) => steps.push(msg.trim()));
-  const pinNote = steps.find((s) => s.startsWith("re-pinned ") || s.includes("re-pin by hand"));
-  return {
-    ok,
-    detail: ok ? `marketplace remove \u2192 add \u2192 install succeeded${pinNote ? `; ${pinNote}` : ""}` : `\`claude plugin\` reinstall failed or was skipped${steps.length ? ` (${steps[steps.length - 1]})` : ""}`
-  };
-}
-function readKnownMarketplacesFile(path2) {
-  try {
-    return (0, import_node_fs28.existsSync)(path2) ? (0, import_node_fs28.readFileSync)(path2, "utf8") : void 0;
-  } catch {
-    return void 0;
+  const defaultRepo = await resolveRepo(options.repo);
+  if (!defaultRepo && validation.validated.some((v) => !v.spec.repo)) {
+    throw new Error("could not resolve repo \u2014 pass --repo owner/repo or set repo per row");
+  }
+  const rowRepo = (spec) => spec.repo ?? defaultRepo;
+  const labelsByRepo = /* @__PURE__ */ new Map();
+  for (const { spec } of validation.validated) {
+    if (!spec.labels?.length) continue;
+    const bucket = labelsByRepo.get(rowRepo(spec)) ?? /* @__PURE__ */ new Set();
+    for (const label of spec.labels) bucket.add(label);
+    labelsByRepo.set(rowRepo(spec), bucket);
+  }
+  for (const [repo, labels] of labelsByRepo) await ensureLabels([...labels], repo);
+  const created = [];
+  const failures = [];
+  for (const entry of validation.validated) {
+    const { spec, priority, type } = entry;
+    try {
+      const rowKey = options.idempotencyKey ? rowIdempotencyKey(options.idempotencyKey, spec) : void 0;
+      if (rowKey) {
+        const existing = await findExistingByIdempotencyKey(client, rowKey, rowRepo(spec));
+        if (existing) {
+          created.push({ row: entry.row, ...existing, idempotent: true });
+          continue;
+        }
+      }
+      let body = spec.body ?? "";
+      if (rowKey) {
+        body = appendIdempotencyMarker(body, rowKey);
+      }
+      const rowPriority = spec.priority ? priority : options.priority ?? priority;
+      const args = buildIssueArgs({ type, title: spec.title, body, priority: rowPriority, repo: rowRepo(spec), labels: spec.labels });
+      const swapped = await bodyArgsViaFile(args);
+      let row;
+      try {
+        const stdout = await runCreate(swapped.args);
+        const result = parseCreatedUrl(stdout);
+        row = { row: entry.row, number: result.number, url: result.url };
+        created.push(row);
+      } finally {
+        await swapped.cleanup();
+      }
+      if (deps.attach) {
+        const attached = await deps.attach(row.number, rowRepo(spec), rowPriority);
+        row.onBoard = attached.onBoard;
+        if (attached.projectItemId) row.projectItemId = attached.projectItemId;
+      }
+      const parentRef = spec.parent ?? options.parent;
+      if (parentRef) {
+        try {
+          const run = deps.runGh ?? ghRunner;
+          row.parent = await linkSubIssue(run, parentRef, row.url, rowRepo(spec));
+        } catch (e) {
+          const err = e;
+          row.parentLinkError = (err.stderr || err.message || String(e)).trim();
+          process.stderr.write(`warning: issue #${row.number} created but NOT linked under ${parentRef}: ${row.parentLinkError}
+`);
+        }
+      }
+    } catch (e) {
+      const err = e;
+      const note = timeoutKillNote(e, GH_MUTATION_TIMEOUT_MS);
+      failures.push({ row: entry.row, error: (err.stderr || err.message || String(e)).trim() + (note ? ` (${note})` : "") });
+    }
   }
+  return { created, failures };
 }
-function restoreMarketplacePinsOnDisk(path2, pins) {
-  if (pins.size === 0) return void 0;
-  const after = readKnownMarketplacesFile(path2);
-  const next = restoreMarketplacePins(after, pins);
-  if (next === null) return void 0;
+async function findExistingByIdempotencyKey(client, key, repo) {
+  const marker = idempotencyMarker(key);
   try {
-    (0, import_node_fs28.writeFileSync)(path2, next, "utf8");
+    const result = await client.rest(
+      "GET",
+      `search/issues?per_page=5&q=${encodeURIComponent(`repo:${repo} "${marker}" in:body`)}`
+    );
+    const open2 = result?.items?.find((item) => item.state === "open" && item.number);
+    if (!open2?.number) return void 0;
+    return { number: open2.number, url: open2.html_url ?? `https://github.com/${repo}/issues/${open2.number}` };
   } catch {
-    return `could NOT restore ${[...pins.keys()].join(", ")} \u2014 re-pin by hand`;
+    return void 0;
   }
-  const verify = readKnownMarketplacesFile(path2);
-  const failed = [...pins].filter(([name, want]) => {
-    const got = readKnownMarketplace(verify, name);
-    return typeof want.autoUpdate === "boolean" && got.declared !== want.autoUpdate || want.ref !== void 0 && got.ref !== want.ref;
+}
+function parseCloseReason(raw) {
+  if (raw === void 0) return {};
+  const trimmed = raw.trim().toLowerCase().replace(/[\s_-]+/g, "");
+  if (trimmed === "completed" || trimmed === "complete") return { reason: "completed" };
+  if (trimmed === "notplanned" || trimmed === "notplanned") return { reason: "not-planned" };
+  if (trimmed === "duplicateof" || trimmed === "duplicate") return { reason: "duplicate-of" };
+  throw new Error(`unknown close reason "${raw}" \u2014 expected completed, not-planned, or duplicate-of`);
+}
+function registerIssueLifecycleCommands(program3, deps = {}) {
+  const issue2 = program3.commands.find((c) => c.name() === "issue");
+  if (!issue2) return;
+  mutating(
+    issue2.command("edit <ref>").description("edit an issue title/body/labels or reparent it (--parent) \u2014 reparenting is impossible via raw gh").option("--title <title>", "new title").option("--body <body>", "new body (markdown)").option("--body-file <path|->", "read new body from a UTF-8 file, or stdin with -").option("--add-label <label...>", "label(s) to add (repeatable)").option("--remove-label <label...>", "label(s) to remove (repeatable)").option("--parent <ref>", "reparent: link under this parent (#123, owner/repo#123, or URL)").option("--repo <owner/repo>", "repo for a bare ref (defaults to the current repo)"),
+    (opts, args) => ({ command: "issue edit", ref: args[0], fields: Object.keys(opts).filter((k) => k !== "repo" && opts[k] !== void 0) })
+  ).action(async (ref, o) => {
+    try {
+      const defaultRepo = await resolveRepo(o.repo);
+      const result = await editIssue(defaultGitHubClient(), {
+        ref,
+        defaultRepo,
+        title: o.title,
+        body: o.body,
+        bodyFile: o.bodyFile,
+        addLabel: o.addLabel,
+        removeLabel: o.removeLabel,
+        parent: o.parent
+      });
+      console.log(JSON.stringify(result));
+    } catch (e) {
+      return failGraceful(`issue edit failed: ${e.message}`);
+    }
   });
-  return failed.length ? `restore did NOT take for ${failed.map(([n]) => n).join(", ")} \u2014 re-pin by hand` : `re-pinned ${[...pins.keys()].join(", ")} (auto-update + catalog ref survive the reinstall)`;
+  mutating(
+    issue2.command("close <ref>").description("close an issue and move its board item to Done (--reason completed|not-planned|duplicate-of --duplicate-of <n>)").option("--reason <reason>", "completed | not-planned | duplicate-of (defaults to completed)").option("--duplicate-of <number>", "the issue number this duplicates (use with --reason duplicate-of)").option("--comment <text>", "a closing comment to post").option("--repo <owner/repo>", "repo for a bare ref (defaults to the current repo)"),
+    (opts, args) => {
+      let reason;
+      try {
+        reason = parseCloseReason(opts.reason).reason;
+      } catch (e) {
+        fail(`issue close: ${e.message}`, {
+          code: ERROR_CODES.ERR_BAD_ENUM,
+          offending_flag: "--reason",
+          expected: ["completed", "not-planned", "duplicate-of"]
+        });
+      }
+      if (reason === "duplicate-of" && !opts.duplicateOf) {
+        fail("issue close: --reason duplicate-of requires --duplicate-of <number>", {
+          code: ERROR_CODES.ERR_MISSING_FLAG,
+          offending_flag: "--duplicate-of"
+        });
+      }
+      return { command: "issue close", ref: args[0], reason: reason ?? "completed", duplicateOf: opts.duplicateOf };
+    }
+  ).action(async (ref, o) => {
+    const parsed = parseCloseReason(o.reason);
+    try {
+      const defaultRepo = await resolveRepo(o.repo);
+      const result = await closeIssue(defaultGitHubClient(), {
+        ref,
+        defaultRepo,
+        reason: parsed.reason,
+        duplicateOf: o.duplicateOf ? Number(o.duplicateOf) : void 0,
+        comment: o.comment
+      });
+      console.log(JSON.stringify(result));
+    } catch (e) {
+      return failGraceful(`issue close failed: ${e.message}`);
+    }
+  });
+  mutating(
+    issue2.command("reopen <ref>").description("reopen a closed issue and move its board item back to Todo").option("--repo <owner/repo>", "repo for a bare ref (defaults to the current repo)"),
+    (_opts, args) => ({ command: "issue reopen", ref: args[0] })
+  ).action(async (ref, o) => {
+    try {
+      const defaultRepo = await resolveRepo(o.repo);
+      const result = await reopenIssue(defaultGitHubClient(), ref, defaultRepo);
+      console.log(JSON.stringify(result));
+    } catch (e) {
+      return failGraceful(`issue reopen failed: ${e.message}`);
+    }
+  });
+  mutating(
+    issue2.command("assign <ref> <login>").description("assign a user to an issue \u2014 pure ownership, no board Status change (unlike board claim)").option("--repo <owner/repo>", "repo for a bare ref (defaults to the current repo)"),
+    (_opts, args) => ({ command: "issue assign", ref: args[0], login: args[1] })
+  ).action(async (ref, login, o) => {
+    try {
+      const defaultRepo = await resolveRepo(o.repo);
+      const result = await assignIssue(defaultGitHubClient(), ref, login, defaultRepo);
+      console.log(JSON.stringify(result));
+    } catch (e) {
+      return failGraceful(`issue assign failed: ${e.message}`);
+    }
+  });
+  mutating(
+    issue2.command("unassign <ref> <login>").description("remove a user from an issue \u2014 pure ownership, no board Status change").option("--repo <owner/repo>", "repo for a bare ref (defaults to the current repo)"),
+    (_opts, args) => ({ command: "issue unassign", ref: args[0], login: args[1] })
+  ).action(async (ref, login, o) => {
+    try {
+      const defaultRepo = await resolveRepo(o.repo);
+      const result = await unassignIssue(defaultGitHubClient(), ref, login, defaultRepo);
+      console.log(JSON.stringify(result));
+    } catch (e) {
+      return failGraceful(`issue unassign failed: ${e.message}`);
+    }
+  });
+  mutating(
+    issue2.command("relocate <ref>").description("transfer an issue to another repo, sweep the ghost board item, add to the destination board, and carry priority").requiredOption("--to <owner/repo>", "destination repository").option("--repo <owner/repo>", "source repo for a bare ref (defaults to the current repo)"),
+    (opts, args) => ({ command: "issue relocate", ref: args[0], to: opts.to })
+  ).action(async (ref, o) => {
+    try {
+      const defaultRepo = await resolveRepo(o.repo);
+      const result = await relocateIssue(defaultGitHubClient(), ref, o.to, defaultRepo);
+      console.log(JSON.stringify(result));
+    } catch (e) {
+      return failGraceful(`issue relocate failed: ${e.message}`);
+    }
+  });
+  mutating(
+    issue2.command("unlink-child <parent> <child>").description("unlink a child issue from its parent (inverse of link-child) and print {parentNumber,subIssueNumber,totalCount} JSON").option("--repo <owner/repo>", "repo for bare refs on either side (defaults to the current repo)"),
+    (_opts, args) => ({ command: "issue unlink-child", parent: args[0], child: args[1] })
+  ).action(async (parentRef, childRef, o) => {
+    const defaultRepo = await resolveRepo(o.repo);
+    try {
+      const result = await unlinkSubIssue(ghRunner, parentRef, childRef, defaultRepo);
+      console.log(JSON.stringify(result));
+    } catch (e) {
+      const err = e;
+      const note = timeoutKillNote(e, GH_MUTATION_TIMEOUT_MS);
+      return failGraceful(`issue unlink-child: ${(err.stderr || err.message || String(e)).trim()}${note ? ` (${note})` : ""}`);
+    }
+  });
+  extendCreateCommand(issue2, deps.attach);
 }
-async function runGuard(readOrigin) {
-  try {
-    const surface = detectSurface(process.env);
-    if (surfaceToken(surface) !== "claude") {
-      process.exitCode = 0;
+function extendCreateCommand(issue2, batchAttach) {
+  const createCmd = issue2.commands.find((c) => c.name() === "create");
+  if (!createCmd) return;
+  createCmd.option("--batch <file.json>", "create multiple issues from a JSON array file (pre-validates all rows before creating any)").option("--idempotency-key <key>", "create-if-not-exists: skip creation when an issue with this key already exists (retried loops must not duplicate)");
+  const internal = createCmd;
+  const originalListener = internal._actionHandler;
+  internal._actionHandler = async (args) => {
+    const opts = createCmd.opts();
+    if (opts.batch) {
+      let specs;
+      try {
+        const raw = (0, import_node_fs29.readFileSync)(opts.batch, "utf8");
+        specs = JSON.parse(raw);
+        if (!Array.isArray(specs)) throw new Error("batch file must contain a JSON array");
+      } catch (e) {
+        return fail(`issue create --batch: cannot read/parse ${opts.batch}: ${e.message}`);
+      }
+      const validation = validateBatchSpecs(specs);
+      if (!validation.ok) {
+        const lines = validation.errors.map((e) => `  row ${e.row}: ${e.error}`).join("\n");
+        return fail(`issue create --batch: validation failed (${validation.errors.length} error(s)):
+${lines}`);
+      }
+      const batchParent = opts.parent;
+      const batchPriority = opts.priority ? normalizePriority(opts.priority) : void 0;
+      if (opts.dryRun || opts.validateOnly) {
+        const planned = validation.validated.map((v) => ({
+          row: v.row,
+          type: v.type,
+          title: v.spec.title,
+          priority: v.spec.priority ? v.priority : batchPriority ?? v.priority,
+          repo: v.spec.repo,
+          ...v.spec.parent ?? batchParent ? { parent: v.spec.parent ?? batchParent } : {}
+        }));
+        console.log(JSON.stringify(opts.validateOnly ? { ok: true, planned } : { dry_run: true, planned }));
+        return;
+      }
+      try {
+        const result = await createIssuesBatch(specs, {
+          repo: opts.repo,
+          idempotencyKey: opts.idempotencyKey,
+          parent: batchParent,
+          priority: batchPriority
+        }, { attach: batchAttach });
+        console.log(JSON.stringify(result));
+        if (result.failures.length) process.exitCode = 1;
+      } catch (e) {
+        return failGraceful(`issue create --batch failed: ${e.message}`);
+      }
       return;
     }
-    const isOrgRepo = readOrigin ? await isOrgRepoRoot(readOrigin) : await isOrgRepoRoot();
-    const input = snapshotPluginGuardInput(surface, isOrgRepo);
-    const { state } = buildPluginGuardDecision(input);
-    const { line, exitCode } = buildPluginGuardLine(state);
-    if (line) console.error(line);
-    process.exitCode = exitCode;
-  } catch {
-    process.exitCode = 0;
-  }
-}
-async function runPluginHeal(surface = detectSurface(process.env)) {
-  if (surfaceToken(surface) !== "claude") {
-    console.log(nonClaudeSurfaceHealMessage(surfaceToken(surface) ?? void 0));
-    return;
-  }
-  const descriptor = PLUGIN_SURFACE_HEAL.claude;
-  const healed = await applyPluginHeal(surface, console.log, { force: true });
-  if (healed) {
-    console.log(`  \u2713 MMI plugin reinstalled \u2014 ${reloadAction(surface)} to load MMI commands`);
-  } else {
-    const refSupported = await marketplaceAddRefSupported("claude");
-    const recovery = refSupported ? descriptor.recovery : recoveryWithoutRef(descriptor.recovery);
-    const note = refAbsenceNote("claude", refSupported);
-    console.log(`  \u2717 Auto-heal failed or was skipped. Run manually:
-  ${recovery}${note}${pluginReadGrantNote()}`);
-  }
+    if (opts.idempotencyKey && !opts.dryRun && !opts.validateOnly) {
+      try {
+        const repo = await resolveRepo(opts.repo);
+        if (repo) {
+          const existing = await findExistingByIdempotencyKey(defaultGitHubClient(), opts.idempotencyKey, repo);
+          if (existing) {
+            console.log(JSON.stringify({ ...existing, idempotent: true }));
+            return;
+          }
+        }
+      } catch {
+      }
+    }
+    return originalListener?.(args);
+  };
 }
 
+// src/train-commands.ts
+var import_node_fs30 = require("node:fs");
+var import_node_path28 = require("node:path");
+
 // src/train-status.ts
 function buildTrainStatusReport(input) {
   const releaseTrack = resolveReleaseTrack(input.meta, void 0, input.repo);
@@ -23271,7 +23498,7 @@ function formatTrainStatus(r) {
 // src/train-commands.ts
 function readRepoVersion() {
   try {
-    return JSON.parse((0, import_node_fs29.readFileSync)((0, import_node_path27.join)(process.cwd(), ".claude-plugin", "plugin.json"), "utf8")).version || void 0;
+    return JSON.parse((0, import_node_fs30.readFileSync)((0, import_node_path28.join)(process.cwd(), ".claude-plugin", "plugin.json"), "utf8")).version || void 0;
   } catch {
     return void 0;
   }
@@ -23417,9 +23644,9 @@ function registerDeployCommands(program3) {
 }
 
 // src/discovery-commands.ts
-var import_node_fs30 = require("node:fs");
-var import_node_os7 = require("node:os");
-var import_node_path28 = require("node:path");
+var import_node_fs31 = require("node:fs");
+var import_node_os8 = require("node:os");
+var import_node_path29 = require("node:path");
 var GC_GH_TIMEOUT_MS3 = 2e4;
 async function collectStatus() {
   let branch = "";
@@ -23594,10 +23821,10 @@ async function collectOnboardStatus() {
     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_os7.homedir)();
+  const home = (0, import_node_os8.homedir)();
   const plugin = onboardPluginGate({
-    readKnown: () => readFileSyncSafe((0, import_node_path28.join)(home, ...KNOWN_MARKETPLACES_RELATIVE), import_node_fs30.readFileSync),
-    readSettings: () => readFileSyncSafe((0, import_node_path28.join)(home, ".claude", "settings.json"), import_node_fs30.readFileSync)
+    readKnown: () => readFileSyncSafe((0, import_node_path29.join)(home, ...KNOWN_MARKETPLACES_RELATIVE), import_node_fs31.readFileSync),
+    readSettings: () => readFileSyncSafe((0, import_node_path29.join)(home, ".claude", "settings.json"), import_node_fs31.readFileSync)
   });
   return { track, board, registry: registry2, secrets, plugin, nextCommand };
 }
@@ -25017,9 +25244,9 @@ function ghAccountCaveat(announcedLogin, accounts) {
 }
 
 // src/doctor-io.ts
-var import_node_fs31 = require("node:fs");
-var import_node_os8 = require("node:os");
-var import_node_path29 = require("node:path");
+var import_node_fs32 = require("node:fs");
+var import_node_os9 = require("node:os");
+var import_node_path30 = require("node:path");
 var import_node_child_process12 = require("node:child_process");
 var import_node_util8 = require("node:util");
 var execFileP6 = (0, import_node_util8.promisify)(import_node_child_process12.execFile);
@@ -25027,7 +25254,7 @@ var MMI_PLUGIN_ID2 = "mmi@mutmutco";
 function installedClaudePluginVersion() {
   try {
     const file = JSON.parse(
-      (0, import_node_fs31.readFileSync)((0, import_node_path29.join)((0, import_node_os8.homedir)(), ".claude", "plugins", "installed_plugins.json"), "utf8")
+      (0, import_node_fs32.readFileSync)((0, import_node_path30.join)((0, import_node_os9.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;
@@ -25048,13 +25275,13 @@ function worktreeRootSync() {
 }
 var gitignorePath = () => {
   const root = worktreeRootSync();
-  return root === null ? null : (0, import_node_path29.join)(root, ".gitignore");
+  return root === null ? null : (0, import_node_path30.join)(root, ".gitignore");
 };
 function readGitignore() {
   const path2 = gitignorePath();
   if (path2 === null) return null;
   try {
-    return (0, import_node_fs31.readFileSync)(path2, "utf8");
+    return (0, import_node_fs32.readFileSync)(path2, "utf8");
   } catch {
     return null;
   }
@@ -25063,7 +25290,7 @@ function writeGitignore(content) {
   const path2 = gitignorePath();
   if (path2 === null) return false;
   try {
-    (0, import_node_fs31.writeFileSync)(path2, content, "utf8");
+    (0, import_node_fs32.writeFileSync)(path2, content, "utf8");
     return true;
   } catch {
     return false;
@@ -25087,7 +25314,7 @@ async function repoRoot() {
 }
 function hasRepoLocalWorktrees() {
   const root = worktreeRootSync();
-  return root !== null && (0, import_node_fs31.existsSync)((0, import_node_path29.join)(root, ".worktrees"));
+  return root !== null && (0, import_node_fs32.existsSync)((0, import_node_path30.join)(root, ".worktrees"));
 }
 
 // src/index.ts
@@ -25122,8 +25349,8 @@ ${r.stderr ?? ""}`).catch(() => "");
 function ghMultiAccountCaveat(announcedLogin) {
   try {
     const hostsPath = ghHostsConfigPath(process.env, process.platform);
-    if (!hostsPath || !(0, import_node_fs32.existsSync)(hostsPath)) return void 0;
-    return ghAccountCaveat(announcedLogin, parseGhHostsAccounts((0, import_node_fs32.readFileSync)(hostsPath, "utf8")));
+    if (!hostsPath || !(0, import_node_fs33.existsSync)(hostsPath)) return void 0;
+    return ghAccountCaveat(announcedLogin, parseGhHostsAccounts((0, import_node_fs33.readFileSync)(hostsPath, "utf8")));
   } catch {
     return void 0;
   }
@@ -25131,12 +25358,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_path30.join)(home, ".claude", "plugins", ".mmi-env-heal.lock");
+  return (0, import_node_path31.join)(home, ".claude", "plugins", ".mmi-env-heal.lock");
 }
 async function withEnvHealLock(what, run) {
   try {
     return await withFileLock(
-      envHealLockPath((0, import_node_os9.homedir)()),
+      envHealLockPath((0, import_node_os10.homedir)()),
       { staleMs: ENV_HEAL_LOCK_STALE_MS, maxWaitMs: ENV_HEAL_LOCK_MAX_WAIT_MS, label: "mmi env-heal lock" },
       run
     );
@@ -25231,9 +25458,9 @@ function mmiDoctorDeps(opts = {}) {
     },
     pluginCache: () => {
       const plan = buildPluginCachePlan(
-        (0, import_node_os9.homedir)(),
+        (0, import_node_os10.homedir)(),
         runningPluginVersion(process.env, resolveClientVersion()),
-        pluginCacheFsDeps((0, import_node_os9.homedir)(), () => 0)
+        pluginCacheFsDeps((0, import_node_os10.homedir)(), () => 0)
       );
       return {
         stale: plan.prune,
@@ -25279,11 +25506,11 @@ function mmiDoctorDeps(opts = {}) {
     // which branch it would pick one up from. Two local file reads, no network, fail-soft to no rows.
     marketplaceRows: () => {
       try {
-        const home = (0, import_node_os9.homedir)();
+        const home = (0, import_node_os10.homedir)();
         return marketplaceRows(
           MMI_MARKETPLACE_NAME,
-          readFileSyncSafe((0, import_node_path30.join)(home, ...KNOWN_MARKETPLACES_RELATIVE), import_node_fs32.readFileSync),
-          readFileSyncSafe((0, import_node_path30.join)(home, ".claude", "settings.json"), import_node_fs32.readFileSync)
+          readFileSyncSafe((0, import_node_path31.join)(home, ...KNOWN_MARKETPLACES_RELATIVE), import_node_fs33.readFileSync),
+          readFileSyncSafe((0, import_node_path31.join)(home, ".claude", "settings.json"), import_node_fs33.readFileSync)
         );
       } catch {
         return [];
@@ -25413,19 +25640,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_path30.join)(process.cwd(), ".gitignore");
-  const current = (0, import_node_fs32.existsSync)(path2) ? (0, import_node_fs32.readFileSync)(path2, "utf8") : null;
+  const path2 = (0, import_node_path31.join)(process.cwd(), ".gitignore");
+  const current = (0, import_node_fs33.existsSync)(path2) ? (0, import_node_fs33.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_fs32.writeFileSync)(path2, plan.content, "utf8");
+    if (opts.write && plan.changed) (0, import_node_fs33.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_fs32.writeFileSync)(path2, plan.content, "utf8");
+      (0, import_node_fs33.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");
@@ -25535,7 +25762,7 @@ gcCmd.command("sweep-deferred").description("retry IDE-locked deferred worktree
     process.exit(process.exitCode ?? 0);
   });
 });
-gcCmd.option("--dry-run", "show what would be deleted (default)").option("--apply", "delete only the listed clean merged/closed PR local+remote branches, linked worktrees, and stale tracking refs").option("--json", "machine-readable output").option("--scratch", "prune safe local scratch (#1864) instead of git branches/refs; local plans are surfaced advisory-only, never auto-pruned").option("--remote <name>", "remote name", "origin").option("--limit <n>", "PRs to inspect per state", "200").option("--root <path>", "sweep an explicitly named worktrees root instead of the authoritative ../mmi-worktrees (#3471) \u2014 descends into this repo container when present; ownership, dead-dir, and content guards still apply").action(async (o) => {
+gcCmd.option("--dry-run", "show what would be deleted (default)").option("--apply", "delete only the listed clean merged/closed PR local+remote branches, linked worktrees, and stale tracking refs").option("--json", "machine-readable output").option("--scratch", "prune safe local scratch (#1864) instead of git branches/refs; local plans are surfaced advisory-only, never auto-pruned").option("--remote <name>", "remote name", "origin").option("--limit <n>", "PRs to inspect per state", "200").option("--force", "remove worktrees even when the ownership registry shows another session created or worked in them recently (#3580)").option("--root <path>", "sweep an explicitly named worktrees root instead of the authoritative ../mmi-worktrees (#3471) \u2014 descends into this repo container when present; ownership, dead-dir, and content guards still apply").action(async (o) => {
   if (o.apply && o.dryRun) return fail("worktree gc: choose either --dry-run or --apply");
   if (o.scratch) {
     try {
@@ -25551,8 +25778,8 @@ 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_path30.resolve)(o.root);
-    if (!(0, import_node_fs32.existsSync)(root) || !(0, import_node_fs32.statSync)(root).isDirectory()) return fail(`worktree gc: --root ${o.root} is not a directory`);
+    root = (0, import_node_path31.resolve)(o.root);
+    if (!(0, import_node_fs33.existsSync)(root) || !(0, import_node_fs33.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)) {
       return fail(`worktree gc: --root ${root} contains this checkout \u2014 name a worktrees root, not the repo or an ancestor of it`);
@@ -25572,7 +25799,7 @@ gcCmd.option("--dry-run", "show what would be deleted (default)").option("--appl
         // git fsmonitor daemon from inheriting this sweep's stdio pipe and wedging the git call on Windows.
         worktreeRemoveDeps(async (args) => (await execFileP2("git", ["-c", "core.fsmonitor=false", ...args], { timeout: GIT_TIMEOUT_MS })).stdout)
       ).catch(() => void 0);
-      applyResult = await applyGcPlan(plan, o.remote, { root });
+      applyResult = await applyGcPlan(plan, o.remote, { root, force: o.force });
     }
     if (o.json) {
       console.log(JSON.stringify({ dryRun: !o.apply, remote: o.remote, ...root ? { root } : {}, plan, applyResult }, null, 2));
@@ -25616,6 +25843,18 @@ function runWorktreeInstall(command, cwd, quiet) {
 async function primaryCheckoutRoot(from) {
   return primaryCheckoutRootOf(async (args) => (await execFileP2("git", ["-C", from, ...args], { timeout: GIT_TIMEOUT_MS })).stdout);
 }
+async function unprovenWorktreeReason(wtPath, repoRoot2) {
+  if (!(0, import_node_fs33.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) {
+    return `'git worktree list' could not be read from ${repoRoot2}, so ${wtPath} could not be proven registered`;
+  }
+  if (!registered.some((w) => samePath(w.path, wtPath))) {
+    return `${wtPath} exists on disk but 'git worktree list' does not name it \u2014 its git metadata is gone, so it is not a usable worktree`;
+  }
+  return void 0;
+}
 function makeProvisionDeps(worktreeRoot, quiet, log) {
   return {
     runInstall: (command, cwd) => runWorktreeInstall(command, cwd, quiet),
@@ -25626,26 +25865,26 @@ function makeProvisionDeps(worktreeRoot, quiet, log) {
 function acquireWorktreeSetupLock(worktreeRoot) {
   const lockPath = repoRuntimeStatePath(worktreeRoot, "worktree-setup.lock");
   const take = () => {
-    const fd = (0, import_node_fs32.openSync)(lockPath, "wx");
+    const fd = (0, import_node_fs33.openSync)(lockPath, "wx");
     try {
-      (0, import_node_fs32.writeSync)(fd, String(Date.now()));
+      (0, import_node_fs33.writeSync)(fd, String(Date.now()));
     } finally {
-      (0, import_node_fs32.closeSync)(fd);
+      (0, import_node_fs33.closeSync)(fd);
     }
     return () => {
       try {
-        (0, import_node_fs32.rmSync)(lockPath, { force: true });
+        (0, import_node_fs33.rmSync)(lockPath, { force: true });
       } catch {
       }
     };
   };
   try {
-    (0, import_node_fs32.mkdirSync)((0, import_node_path30.dirname)(lockPath), { recursive: true });
+    (0, import_node_fs33.mkdirSync)((0, import_node_path31.dirname)(lockPath), { recursive: true });
     return take();
   } catch {
     try {
-      if (Date.now() - (0, import_node_fs32.statSync)(lockPath).mtimeMs > WORKTREE_SETUP_LOCK_TTL_MS) {
-        (0, import_node_fs32.rmSync)(lockPath, { force: true });
+      if (Date.now() - (0, import_node_fs33.statSync)(lockPath).mtimeMs > WORKTREE_SETUP_LOCK_TTL_MS) {
+        (0, import_node_fs33.rmSync)(lockPath, { force: true });
         return take();
       }
     } catch {
@@ -25658,6 +25897,7 @@ withExamples(mutating(
   worktree.command("create <branch-or-issue>").description("create a worktree from a base ref and provision it (install deps + copy local-only config); an issue ref derives the <issue>-<slug> branch, and --claim claims its board item (#2996, formerly worktree new)").option("--from <ref>", "base ref to branch from", "origin/development").option("--base <ref>", "alias of --from (git's own word for the base ref)").option("--path <path>", "worktree path (default: ../mmi-worktrees/<RepoName>/<branch> \u2014 authoritative; the <RepoName> segment is what makes ownership provable from the path, #3471. gc/list read this root in BOTH the nested and the legacy flat shape)").option("--remote <name>", "remote to fetch when --from is a <remote>/<branch> ref", "origin").option("--slug <slug>", "issue-ref form: override the slug derived from the issue title").option("--claim", "issue-ref form: claim the issue's board item after provisioning").option("--for <login>", "with --claim: assign the board item to this login instead of @me"),
   worktreeCreatePlan
 ).action(async (target, o, cmd) => {
+  let step = "resolve the branch name";
   try {
     if (o.base !== void 0 && cmd.getOptionValueSource("from") === "cli" && o.base !== o.from) {
       return fail(`worktree create: --from and --base are the same option (--base is an alias); got --from ${o.from} and --base ${o.base} \u2014 pass one`);
@@ -25681,10 +25921,12 @@ withExamples(mutating(
     const repoRoot2 = await primaryCheckoutRoot(process.cwd()) ?? process.cwd();
     const wtPath = o.path ?? defaultWorktreePath(repoRoot2, branch);
     const { base, fetchBranch } = resolveWorktreeBase(fromRef, o.remote);
+    step = `fetch the base ref ${fromRef}`;
     if (fetchBranch) {
       const fetchErr = await execFileP2("git", ["fetch", o.remote, fetchBranch], { timeout: GH_MUTATION_TIMEOUT_MS }).then(() => void 0).catch((e) => (e instanceof Error ? e.message : String(e)).split("\n")[0]);
       if (fetchErr) console.error(`  warning: could not fetch ${o.remote}/${fetchBranch} (${fetchErr}); base ${base} may be stale`);
     }
+    step = `git worktree add ${wtPath}`;
     await addWorktreeRobust(wtPath, branch, base, {
       git: async (args) => (await execFileP2("git", args, { timeout: GH_MUTATION_TIMEOUT_MS })).stdout,
       revParse: async (ref) => {
@@ -25700,11 +25942,13 @@ withExamples(mutating(
         if (!o.json) console.error(`  ${m}`);
       }
     });
+    step = "install deps + copy local-only config";
     const report = await provisionWorktree(wtPath, makeProvisionDeps(wtPath, Boolean(o.json), (m) => {
       if (!o.json) console.error(`  ${m}`);
     }));
     let claim;
     let claimError;
+    step = "claim the board item";
     if (issueForm && o.claim && selector) {
       try {
         const claimRaw = await selfShell(
@@ -25716,6 +25960,21 @@ withExamples(mutating(
         claimError = e.message.split("\n")[0];
       }
     }
+    const unproven = await unprovenWorktreeReason(wtPath, repoRoot2);
+    if (unproven) {
+      const detail = `worktree create: reported success but ${unproven}. The create either failed silently or the worktree was removed after it ran (MMI-Hub#3580). Re-run this command; if it recurs, check \`mmi-cli worktree events\` for what removed it.`;
+      if (o.json) {
+        console.log(JSON.stringify({ ok: false, branch, path: wtPath, base, error: detail }, null, 2));
+      } else {
+        console.error(detail);
+      }
+      process.exitCode = 1;
+      return;
+    }
+    const createActor = describeActor({ env: process.env, surface: detectSurface(process.env), cwd: process.cwd() });
+    const createdAt = (/* @__PURE__ */ new Date()).toISOString();
+    recordWorktreeOwner(repoRoot2, { path: wtPath, branch, createdAt, lastSeenAt: createdAt, actor: createActor });
+    appendWorktreeEvent(repoRoot2, { action: "created", command: "worktree create", target: wtPath, branch, actor: createActor });
     if (o.json) {
       return console.log(JSON.stringify({
         branch,
@@ -25734,7 +25993,7 @@ withExamples(mutating(
       else console.log(`  board item ${selector.repo}#${selector.number} claimed`);
     }
   } catch (e) {
-    fail(`worktree create: ${e.message}`);
+    fail(`worktree create: failed at step '${step}' \u2014 ${e.message}`);
   }
 }), [
   "mmi-cli worktree create fix/gc-sweep-2687",
@@ -25765,6 +26024,14 @@ worktree.command("setup [path]").description("provision an existing worktree (in
     release();
   }
 });
+worktree.command("events").description("who created and who removed this repo's worktrees \u2014 the append-only attribution log (#3580)").option("--limit <n>", "most recent events to show", "50").option("--json", "machine-readable output").action(async (o) => {
+  const limit = Number.parseInt(o.limit, 10);
+  if (!Number.isFinite(limit) || limit < 1) return fail("worktree events: --limit must be a positive integer");
+  const primaryRoot = await primaryCheckoutRoot(process.cwd()) ?? process.cwd();
+  const events = readWorktreeEvents(primaryRoot, limit);
+  if (o.json) return console.log(JSON.stringify({ events, count: events.length }, null, 2));
+  console.log(formatWorktreeEvents(events));
+});
 async function ghJson(args, timeout = 1e4) {
   const { stdout } = await execFileP2("gh", args, { timeout });
   return JSON.parse(stdout);
@@ -26087,7 +26354,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_fs32.readFileSync)(o.secretsFile, "utf8")}`);
+      vars.push(`secrets=${(0, import_node_fs33.readFileSync)(o.secretsFile, "utf8")}`);
     } catch (e) {
       return fail(`org project set: cannot read --secrets-file ${o.secretsFile}: ${e.message}`);
     }
@@ -26743,11 +27010,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_path30.join)(cwd, ".github", "workflows");
-  if (!(0, import_node_fs32.existsSync)(wfDir)) return [];
-  return (0, import_node_fs32.readdirSync)(wfDir).filter((name) => /\.(ya?ml)$/i.test(name)).filter((name) => {
+  const wfDir = (0, import_node_path31.join)(cwd, ".github", "workflows");
+  if (!(0, import_node_fs33.existsSync)(wfDir)) return [];
+  return (0, import_node_fs33.readdirSync)(wfDir).filter((name) => /\.(ya?ml)$/i.test(name)).filter((name) => {
     try {
-      return workflowReportsPrChecks((0, import_node_fs32.readFileSync)((0, import_node_path30.join)(wfDir, name), "utf8"));
+      return workflowReportsPrChecks((0, import_node_fs33.readFileSync)((0, import_node_path31.join)(wfDir, name), "utf8"));
     } catch {
       return true;
     }
@@ -26774,16 +27041,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_path30.join)(root, path2);
-      return (0, import_node_fs32.existsSync)(fullPath) ? (0, import_node_fs32.readFileSync)(fullPath, "utf8") : null;
+      const fullPath = (0, import_node_path31.join)(root, path2);
+      return (0, import_node_fs33.existsSync)(fullPath) ? (0, import_node_fs33.readFileSync)(fullPath, "utf8") : null;
     }
   };
 }
 function hubRoot() {
-  const fromPkg = (0, import_node_path30.join)(__dirname, "..", "..");
+  const fromPkg = (0, import_node_path31.join)(__dirname, "..", "..");
   const marker = "skills/bootstrap/seeds/manifest.json";
-  if ((0, import_node_fs32.existsSync)((0, import_node_path30.join)(fromPkg, marker))) return fromPkg;
-  if ((0, import_node_fs32.existsSync)((0, import_node_path30.join)(process.cwd(), marker))) return process.cwd();
+  if ((0, import_node_fs33.existsSync)((0, import_node_path31.join)(fromPkg, marker))) return fromPkg;
+  if ((0, import_node_fs33.existsSync)((0, import_node_path31.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) => {
@@ -27060,7 +27327,7 @@ jsonParity(pr.command("merge <number>").description("merge a PR (squash by defau
     localCleanup = await cleanupPrMergeLocalBranch(headRef, {
       beforeWorktrees,
       startingPath,
-      pathExists: (p) => (0, import_node_fs32.existsSync)(p),
+      pathExists: (p) => (0, import_node_fs33.existsSync)(p),
       execGit: async (args) => (await execFileP2("git", args, { timeout: GIT_TIMEOUT_MS })).stdout,
       teardownWorktreeStage,
       deferredStore,
@@ -27401,10 +27668,10 @@ access.command("audit").description("audit collaborator roles + train-branch pus
     targets = resolution.targets;
   }
   const derivedMatrix = registryProjects ? accessMatrixFromProjects(registryProjects) : {};
-  const fileMatrix = (0, import_node_fs32.existsSync)("access-matrix.json") ? loadAccessMatrix((0, import_node_fs32.readFileSync)("access-matrix.json", "utf8")) : {};
+  const fileMatrix = (0, import_node_fs33.existsSync)("access-matrix.json") ? loadAccessMatrix((0, import_node_fs33.readFileSync)("access-matrix.json", "utf8")) : {};
   const matrix = mergeAccessMatrix(fileMatrix, derivedMatrix);
   const derivedContracts = registryProjects ? dataAccessContractsFromProjects(registryProjects) : { consumers: {} };
-  const fileContracts = (0, import_node_fs32.existsSync)("data-access-contracts.json") ? loadDataAccessContracts((0, import_node_fs32.readFileSync)("data-access-contracts.json", "utf8")) : { consumers: {} };
+  const fileContracts = (0, import_node_fs33.existsSync)("data-access-contracts.json") ? loadDataAccessContracts((0, import_node_fs33.readFileSync)("data-access-contracts.json", "utf8")) : { consumers: {} };
   const dataAccess = mergeDataAccessContracts(fileContracts, derivedContracts);
   const report = await auditOrgAccess(targets, deps, matrix, dataAccess);
   console.log(o.json ? JSON.stringify(report, null, 2) : renderAccessReport(report));
@@ -27438,16 +27705,16 @@ function directoryBytes(path2) {
   let total = 0;
   let entries;
   try {
-    entries = (0, import_node_fs32.readdirSync)(path2, { withFileTypes: true });
+    entries = (0, import_node_fs33.readdirSync)(path2, { withFileTypes: true });
   } catch {
     return 0;
   }
   for (const entry of entries) {
-    const child2 = (0, import_node_path30.join)(path2, entry.name);
+    const child2 = (0, import_node_path31.join)(path2, entry.name);
     if (entry.isDirectory()) total += directoryBytes(child2);
     else {
       try {
-        total += (0, import_node_fs32.statSync)(child2).size;
+        total += (0, import_node_fs33.statSync)(child2).size;
       } catch {
       }
     }
@@ -27455,25 +27722,25 @@ function directoryBytes(path2) {
   return total;
 }
 function listDirEntries(dir) {
-  return (0, import_node_fs32.readdirSync)(dir, { withFileTypes: true }).map((d) => ({ name: d.name, isDirectory: d.isDirectory() }));
+  return (0, import_node_fs33.readdirSync)(dir, { withFileTypes: true }).map((d) => ({ name: d.name, isDirectory: d.isDirectory() }));
 }
 function readInstalledPluginRefs(home) {
   const p = installedPluginsPath(home);
-  if (!(0, import_node_fs32.existsSync)(p)) return [];
+  if (!(0, import_node_fs33.existsSync)(p)) return [];
   try {
-    return installedPluginPaths((0, import_node_fs32.readFileSync)(p, "utf8"));
+    return installedPluginPaths((0, import_node_fs33.readFileSync)(p, "utf8"));
   } catch {
     return null;
   }
 }
 function pluginCacheFsDeps(home, dirBytes) {
   return {
-    exists: (p) => (0, import_node_fs32.existsSync)(p),
-    listVersionDirs: (root) => (0, import_node_fs32.readdirSync)(root, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name),
+    exists: (p) => (0, import_node_fs33.existsSync)(p),
+    listVersionDirs: (root) => (0, import_node_fs33.readdirSync)(root, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name),
     dirBytes,
-    listStagingDirs: (root) => (0, import_node_fs32.readdirSync)(root, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => {
+    listStagingDirs: (root) => (0, import_node_fs33.readdirSync)(root, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => {
       try {
-        return { name: d.name, mtimeMs: newestMtimeMs((0, import_node_path30.join)(root, d.name), listDirEntries, (p) => (0, import_node_fs32.statSync)(p).mtimeMs) };
+        return { name: d.name, mtimeMs: newestMtimeMs((0, import_node_path31.join)(root, d.name), listDirEntries, (p) => (0, import_node_fs33.statSync)(p).mtimeMs) };
       } catch {
         return { name: d.name, mtimeMs: Date.now() };
       }
@@ -27487,10 +27754,10 @@ function stagingApplyFsGuard(home) {
   return {
     referencedPaths: () => readInstalledPluginRefs(home),
     mtimeMs: (name) => {
-      const p = (0, import_node_path30.join)(stagingRoot, name);
-      if (!(0, import_node_fs32.existsSync)(p)) return null;
+      const p = (0, import_node_path31.join)(stagingRoot, name);
+      if (!(0, import_node_fs33.existsSync)(p)) return null;
       try {
-        return newestMtimeMs(p, listDirEntries, (q) => (0, import_node_fs32.statSync)(q).mtimeMs);
+        return newestMtimeMs(p, listDirEntries, (q) => (0, import_node_fs33.statSync)(q).mtimeMs);
       } catch {
         return null;
       }
@@ -27500,13 +27767,13 @@ function stagingApplyFsGuard(home) {
 }
 program2.command("plugin-prune").description(`prune stale cached MMI plugin versions (keeps running + newest, ${PLUGIN_CACHE_KEEP} total) and orphaned temp_git_* staging dirs; dry-run unless --apply (#2903, #2990)`).option("--apply", "actually delete the stale version dirs + orphaned staging dirs (default: report only)").option("--json", "machine-readable output").action((o) => {
   const plan = buildPluginCachePlan(
-    (0, import_node_os9.homedir)(),
+    (0, import_node_os10.homedir)(),
     runningPluginVersion(process.env, resolveClientVersion()),
-    pluginCacheFsDeps((0, import_node_os9.homedir)(), directoryBytes),
+    pluginCacheFsDeps((0, import_node_os10.homedir)(), directoryBytes),
     { withBytes: true }
   );
   const anythingToDelete = plan.prune.length > 0 || plan.staging.length > 0;
-  const result = o.apply && anythingToDelete ? applyPluginCachePlan(plan, (p) => (0, import_node_fs32.rmSync)(p, { recursive: true, force: true }), stagingApplyFsGuard((0, import_node_os9.homedir)())) : void 0;
+  const result = o.apply && anythingToDelete ? applyPluginCachePlan(plan, (p) => (0, import_node_fs33.rmSync)(p, { recursive: true, force: true }), stagingApplyFsGuard((0, import_node_os10.homedir)())) : 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));
@@ -27579,6 +27846,10 @@ program2.command("session-start").description("run the SessionStart verbs (whoam
     spawnDetachedSelf(["worktree", "setup", "--quiet"], { spawn: import_node_child_process13.spawn, execPath: process.execPath, scriptPath: process.argv[1] });
     bannerIo.log(worktreeBanner);
   }
+  if (isLinkedWorktree(process.cwd())) {
+    const primaryRoot = await primaryCheckoutRoot(process.cwd());
+    if (primaryRoot) touchWorktreeOwner(primaryRoot, process.cwd());
+  }
   const payloadChars = measured.chars();
   recordSessionPayload(process.cwd(), payloadChars);
   appendHookActivity(process.cwd(), { event: "SessionStart", script: "session-start", outcome: "ran", action: "session-start hook completed", payloadChars });