@mutmutco/cli 2.30.0 → 2.32.0

package/dist/main.cjs

@@ -3473,18 +3473,28 @@ function versionAtLeast(v, min) {
 }
 
 // src/client-version.ts
-function resolveClientVersion() {
+function resolveClientVersionManifestCandidates(distDir = __dirname) {
+  return [
+    (0, import_node_path2.join)(distDir, "..", "..", ".claude-plugin", "plugin.json"),
+    (0, import_node_path2.join)(distDir, "..", "..", ".cursor-plugin", "plugin.json"),
+    (0, import_node_path2.join)(distDir, "..", "..", ".codex-plugin", "plugin.json"),
+    (0, import_node_path2.join)(distDir, "..", "package.json")
+  ];
+}
+function readVersionFromManifest(path2) {
   try {
-    const manifest = (0, import_node_path2.join)(__dirname, "..", "..", ".claude-plugin", "plugin.json");
-    return JSON.parse((0, import_node_fs2.readFileSync)(manifest, "utf8")).version || "0.0.0";
+    const version = JSON.parse((0, import_node_fs2.readFileSync)(path2, "utf8")).version;
+    return typeof version === "string" && version.trim() ? version.trim() : null;
   } catch {
-    try {
-      const pkg = (0, import_node_path2.join)(__dirname, "..", "package.json");
-      return JSON.parse((0, import_node_fs2.readFileSync)(pkg, "utf8")).version || "0.0.0";
-    } catch {
-      return "0.0.0";
-    }
+    return null;
+  }
+}
+function resolveClientVersion() {
+  for (const manifest of resolveClientVersionManifestCandidates()) {
+    const version = readVersionFromManifest(manifest);
+    if (version) return version;
   }
+  return "0.0.0";
 }
 function clientVersionHeaders() {
   return { [CLIENT_VERSION_HEADER]: resolveClientVersion() };
@@ -4102,7 +4112,7 @@ async function hubAuthToken(deps) {
 var injectedStdin;
 async function readStdin() {
   if (injectedStdin !== void 0) return injectedStdin;
-  if (process.stdin.isTTY) return "";
+  if (process.stdin.isTTY !== false) return "";
   const chunks = [];
   for await (const chunk of process.stdin) chunks.push(chunk);
   return Buffer.concat(chunks).toString("utf8");
@@ -5247,6 +5257,15 @@ function buildIngestPayload(args) {
 
 // src/honcho-client.ts
 var HONCHO_ASSISTANT_PEER = "assistant";
+function parseHonchoQueueStatus(json) {
+  const o = json && typeof json === "object" ? json : {};
+  const pendingRaw = o.pending_work_units ?? o.depth ?? o.queue_depth ?? o.pending;
+  const inProgressRaw = o.in_progress_work_units;
+  const pending = typeof pendingRaw === "number" ? pendingRaw : null;
+  const inProgress = typeof inProgressRaw === "number" ? inProgressRaw : null;
+  const stalled = (pending ?? 0) > 0 && (inProgress ?? 0) === 0;
+  return { pending, inProgress, stalled };
+}
 var enc = encodeURIComponent;
 var base = (apiUrl) => apiUrl.replace(/\/+$/, "");
 var honchoRoutes = {
@@ -5313,20 +5332,28 @@ async function fetchPeerCard(cfg, peer, opts = {}) {
   try {
     const path2 = honchoRoutes.peerCard(cfg.workspace, peer, opts.project);
     const res = await request(cfg, fetchImpl, "GET", path2, void 0, timeoutMs);
-    if (!res.ok) return null;
+    if (!res.ok) return { status: "error", httpStatus: res.status };
     const json = await res.json();
-    return formatPeerCardLines(json?.peer_card, maxChars);
-  } catch {
-    return null;
+    const profile = formatPeerCardLines(json?.peer_card, maxChars);
+    return profile ? { status: "ok", data: profile } : { status: "empty" };
+  } catch (e) {
+    return { status: "error", message: e.message };
   }
 }
 async function fetchPeerCardWithFallback(cfg, peer, project2, opts = {}) {
   if (project2) {
     const scoped = await fetchPeerCard(cfg, peer, { ...opts, project: project2 });
-    if (scoped) return { profile: scoped, scope: "project" };
+    if (scoped.status === "ok") return { profile: scoped.data, scope: "project", status: "ok" };
+    if (scoped.status === "error") {
+      return { profile: null, scope: null, status: "error", httpStatus: scoped.httpStatus, message: scoped.message };
+    }
   }
   const wide = await fetchPeerCard(cfg, peer, opts);
-  return { profile: wide, scope: wide ? "peer" : null };
+  if (wide.status === "ok") return { profile: wide.data, scope: "peer", status: "ok" };
+  if (wide.status === "error") {
+    return { profile: null, scope: null, status: "error", httpStatus: wide.httpStatus, message: wide.message };
+  }
+  return { profile: null, scope: null, status: "empty" };
 }
 async function dialecticChat(cfg, peer, query, opts = {}, fetchImpl = fetch) {
   try {
@@ -5336,25 +5363,44 @@ async function dialecticChat(cfg, peer, query, opts = {}, fetchImpl = fetch) {
       ...opts.target ? { target: opts.target } : {},
       ...opts.sessionId ? { session_id: opts.sessionId } : {}
     }, opts.timeoutMs ?? 15e3);
-    if (!res.ok) return null;
+    if (!res.ok) return { status: "error", httpStatus: res.status };
     const json = await res.json();
-    return (json?.content ?? "").trim() || null;
-  } catch {
-    return null;
+    const answer = (json?.content ?? "").trim();
+    return answer ? { status: "ok", data: answer } : { status: "empty" };
+  } catch (e) {
+    return { status: "error", message: e.message };
   }
 }
 async function probeHoncho(cfg, fetchImpl = fetch, timeoutMs = 3e3, opts = {}) {
+  const emptyQueue = { pending: null, inProgress: null, stalled: false };
   try {
     const healthRes = await request(cfg, fetchImpl, "GET", honchoRoutes.health(), void 0, timeoutMs);
     if (!healthRes.ok) {
-      return { reachable: false, status: healthRes.status, authOk: false, authStatus: void 0 };
+      return { reachable: false, status: healthRes.status, authOk: false, authStatus: void 0, queue: emptyQueue };
     }
     const authPath = opts.peer ? honchoRoutes.peerCard(cfg.workspace, opts.peer) : honchoRoutes.queueStatus(cfg.workspace);
     const authRes = await request(cfg, fetchImpl, "GET", authPath, void 0, timeoutMs);
     const authOk = authRes.status !== 401 && authRes.status !== 403;
-    return { reachable: true, status: healthRes.status, authOk, authStatus: authRes.status };
+    let queue = emptyQueue;
+    if (authPath.includes("/queue/status") && authRes.ok) {
+      try {
+        queue = parseHonchoQueueStatus(await authRes.json());
+      } catch {
+        queue = emptyQueue;
+      }
+    } else {
+      const queueRes = await request(cfg, fetchImpl, "GET", honchoRoutes.queueStatus(cfg.workspace), void 0, timeoutMs);
+      if (queueRes.ok) {
+        try {
+          queue = parseHonchoQueueStatus(await queueRes.json());
+        } catch {
+          queue = emptyQueue;
+        }
+      }
+    }
+    return { reachable: true, status: healthRes.status, authOk, authStatus: authRes.status, queue };
   } catch {
-    return { reachable: false, authOk: false };
+    return { reachable: false, authOk: false, queue: emptyQueue };
   }
 }
 
@@ -5542,8 +5588,21 @@ async function runHonchoContext(opts, io = consoleIo) {
     return;
   }
   const key = await sagaKey(cfg);
-  const { profile, scope } = await fetchPeerCardWithFallback(hc, peer, key.project);
-  if (opts.json) return io.log(JSON.stringify({ peer, project: key.project, cardScope: scope, profile }));
+  const { profile, scope, status, httpStatus, message } = await fetchPeerCardWithFallback(hc, peer, key.project);
+  if (opts.json) {
+    return io.log(JSON.stringify({
+      peer,
+      project: key.project,
+      cardScope: scope,
+      profile,
+      status,
+      ...status === "error" ? { error: { httpStatus, message } } : {}
+    }));
+  }
+  if (status === "error") {
+    io.err(`honcho context: peer card request failed${httpStatus ? ` (${httpStatus})` : ""}${message ? `: ${message}` : ""}`);
+    return;
+  }
   if (!profile) return;
   io.log(opts.banner ? profileBanner(profile, peer, scope === "project" ? key.project : void 0) : profile);
 }
@@ -5567,9 +5626,21 @@ async function runHonchoChat(query, opts, io = consoleIo) {
     io.err("honcho chat: query is empty after redaction");
     return;
   }
-  const answer = await dialecticChat(hc, peer, safeQuery, { target: opts.target });
-  if (opts.json) return io.log(JSON.stringify({ peer, query, answer }));
-  io.log(answer ?? "(no answer \u2014 the profile may be empty or the service is unreachable)");
+  const result = await dialecticChat(hc, peer, safeQuery, { target: opts.target });
+  if (opts.json) {
+    return io.log(JSON.stringify({
+      peer,
+      query,
+      answer: result.status === "ok" ? result.data : null,
+      status: result.status,
+      ...result.status === "error" ? { error: { httpStatus: result.httpStatus, message: result.message } } : {}
+    }));
+  }
+  if (result.status === "error") {
+    io.err(`honcho chat: request failed${result.httpStatus ? ` (${result.httpStatus})` : ""}${result.message ? `: ${result.message}` : ""}`);
+    return;
+  }
+  io.log(result.status === "ok" ? result.data : "(no answer \u2014 the profile may be empty or not yet built)");
 }
 async function runHonchoHealth(o, io = consoleIo) {
   const cfg = await loadConfig();
@@ -5577,12 +5648,19 @@ async function runHonchoHealth(o, io = consoleIo) {
   const apiKey = await honchoApiKey();
   const hc = apiKey ? { apiUrl, apiKey, workspace } : null;
   const peer = honchoPeerId(await honchoLogin(cfg), cfg);
-  const liveness = hc ? await probeHoncho(hc, fetch, 3e3, { peer: peer ?? void 0 }) : { reachable: false, status: void 0, authOk: false, authStatus: void 0 };
+  const liveness = hc ? await probeHoncho(hc, fetch, 3e3, { peer: peer ?? void 0 }) : {
+    reachable: false,
+    status: void 0,
+    authOk: false,
+    authStatus: void 0,
+    queue: { pending: null, inProgress: null, stalled: false }
+  };
   const pending = readHonchoPending().length;
   const ingestSkip = readIngestSkip();
   const ingestSkipMessage = formatIngestSkip(ingestSkip);
+  const deriverStalled = liveness.queue.stalled;
   const report = {
-    ok: !!hc && liveness.reachable && liveness.authOk,
+    ok: !!hc && liveness.reachable && liveness.authOk && !deriverStalled,
     configured: !!hc,
     apiUrl,
     apiKeyConfigured: !!apiKey,
@@ -5593,6 +5671,11 @@ async function runHonchoHealth(o, io = consoleIo) {
     peer: peer ?? null,
     workspace,
     pending,
+    deriverQueue: {
+      pending: liveness.queue.pending,
+      inProgress: liveness.queue.inProgress,
+      stalled: deriverStalled
+    },
     ingestSkip: ingestSkip ?? null,
     ingestSkipMessage: ingestSkipMessage ?? null
   };
@@ -5600,6 +5683,7 @@ async function runHonchoHealth(o, io = consoleIo) {
   if (o.banner) {
     if (report.configured && !report.reachable) io.log(`honcho: configured but unreachable (${pending} pending)`);
     if (report.configured && report.reachable && !report.authOk) io.log("honcho: configured but API key rejected (401/403)");
+    if (deriverStalled) io.log(`honcho: deriver stalled (${liveness.queue.pending} pending, 0 in progress)`);
     if (ingestSkipMessage) io.log(`honcho: ${ingestSkipMessage}`);
     return;
   }
@@ -5608,8 +5692,12 @@ async function runHonchoHealth(o, io = consoleIo) {
   if (report.configured && !report.reachable) io.log(" - service unreachable");
   if (report.configured && report.reachable && !report.authOk) io.log(" - API key rejected (401/403) \u2014 rotate or fix vault path");
   if (!report.peer) io.log(" - no peer identity resolved (gh login) \u2014 ingest will be skipped");
+  if (deriverStalled) io.log(` - deriver stalled (${liveness.queue.pending} pending, 0 in progress)`);
   if (ingestSkipMessage) io.log(` - ${ingestSkipMessage}`);
   if (pending > 0) io.log(` - ${pending} ingest(s) queued locally`);
+  if (liveness.queue.pending != null && liveness.queue.pending > 0) {
+    io.log(` - deriver queue: ${liveness.queue.pending} pending, ${liveness.queue.inProgress ?? 0} in progress`);
+  }
 }
 async function runHonchoKey(o, io = consoleIo) {
   const cfg = await loadConfig();
@@ -7141,7 +7229,7 @@ ${buildReportBody(body, sourceRepo)}`;
 
 // src/skill-lesson.ts
 var SKILL_LESSON_LABEL = "skill-lesson";
-var SKILL_NAMES = ["bootstrap", "grind", "hotfix", "mmi", "rcand", "release", "secrets", "stage"];
+var SKILL_NAMES = ["bootstrap", "browser-automation", "grind", "hotfix", "mmi", "rcand", "release", "secrets", "stage"];
 function assertSkillName(name) {
   const match = SKILL_NAMES.find((skill) => skill === name);
   if (!match) throw new Error(`unknown skill "${name}" \u2014 expected one of: ${SKILL_NAMES.join(", ")}`);
@@ -7267,11 +7355,183 @@ function buildPanelPlan(input) {
   };
 }
 
+// src/grind-policy.ts
+var DEFAULT_SEARCH_DENY_DOMAINS = [
+  "stackoverflow.com",
+  "stackexchange.com",
+  "github.com/issues",
+  "reddit.com"
+];
+
+// src/verify-fusion.ts
+var DEFAULT_MODELS = {
+  builder: "builder-slot",
+  verifier: "verifier-slot",
+  third: "third-slot",
+  synthesizer: "verifier-slot"
+};
+function resolveFusionProviderUrl(explicit) {
+  if (explicit) return explicit;
+  const env = process.env.MMI_FUSION_PROVIDER_URL?.trim();
+  return env || null;
+}
+function buildFusionPlan(input) {
+  const routing = input.routing;
+  const lenses = input.lenses ?? [...GRIND_LENSES];
+  const provider = resolveFusionProviderUrl(input.providerUrl ?? void 0);
+  const models = {
+    ...DEFAULT_MODELS,
+    ...input.models,
+    synthesizer: input.models?.synthesizer ?? input.models?.third ?? input.models?.verifier ?? DEFAULT_MODELS.synthesizer
+  };
+  if (models.verifier === models.builder) {
+    throw new Error("fusion plan: verifier must not equal builder");
+  }
+  if (models.synthesizer === models.builder) {
+    throw new Error("fusion plan: synthesizer must not equal builder");
+  }
+  const toolPolicy = {
+    webSearch: Boolean(input.toolPolicy?.webSearch),
+    maxQueriesPerLens: input.toolPolicy?.maxQueriesPerLens ?? 3,
+    denyDomains: input.toolPolicy?.denyDomains ?? []
+  };
+  return {
+    provider,
+    routing,
+    lenses,
+    models,
+    toolPolicy,
+    criteria: input.criteria,
+    diff: input.diff,
+    fallback: "host-panel",
+    instructions: "Hosted fusion when provider is configured; else spawn host lenses and pipe JSON to `mmi-cli verify synthesize`. Synthesizer slot must differ from builder."
+  };
+}
+function adaptFusionResponse(raw) {
+  if (raw.lenses) {
+    const lenses = parseLensResults(raw.lenses);
+    const base2 = synthesizePanelReport(lenses);
+    return {
+      ...base2,
+      consensus: raw.consensus?.length ? raw.consensus : base2.consensus,
+      contradictions: raw.contradictions ?? base2.contradictions,
+      partial_coverage: raw.partial_coverage ?? base2.partial_coverage,
+      unique_insights: raw.unique_insights ?? base2.unique_insights,
+      blind_spots: raw.blind_spots ?? base2.blind_spots,
+      nits: raw.nits ?? base2.nits
+    };
+  }
+  const blockers = (raw.blockers ?? []).map((b, i) => ({
+    id: `fusion-${i}`,
+    title: b.title,
+    file: b.file,
+    line: b.line,
+    why: b.why,
+    sources: b.sources ?? ["hosted-fusion"]
+  }));
+  return {
+    consensus: raw.consensus ?? [],
+    contradictions: raw.contradictions ?? [],
+    partial_coverage: raw.partial_coverage ?? [],
+    unique_insights: raw.unique_insights ?? [],
+    blind_spots: raw.blind_spots ?? [],
+    blockers,
+    nits: raw.nits ?? []
+  };
+}
+async function runFusionProvider(plan2, deps = {}) {
+  const url = resolveFusionProviderUrl(deps.providerUrl ?? plan2.provider ?? void 0);
+  if (!url) {
+    return { ok: false, source: "fallback", error: "no fusion provider configured" };
+  }
+  const fetchImpl = deps.fetch ?? fetch;
+  const apiKey = deps.apiKey ?? process.env.MMI_FUSION_API_KEY?.trim();
+  const headers = { "content-type": "application/json" };
+  if (apiKey) headers.authorization = `Bearer ${apiKey}`;
+  try {
+    const res = await fetchImpl(url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        routing: plan2.routing,
+        lenses: plan2.lenses,
+        models: plan2.models,
+        toolPolicy: plan2.toolPolicy,
+        criteria: plan2.criteria,
+        diff: plan2.diff
+      }),
+      signal: AbortSignal.timeout(3e4)
+    });
+    if (!res.ok) {
+      return { ok: false, source: "fallback", error: `provider HTTP ${res.status}` };
+    }
+    const body = await res.json();
+    return { ok: true, source: "hosted-fusion", report: adaptFusionResponse(body) };
+  } catch (e) {
+    return { ok: false, source: "fallback", error: e.message };
+  }
+}
+function parseFusionLenses(raw) {
+  return raw.split(",").map((s) => assertGrindLens(s.trim()));
+}
+function parseFusionRouting(raw) {
+  return assertVerifyRouting(raw);
+}
+
 // src/gc.ts
+var DEFERRED_SWEEP_COMMAND = "mmi-cli gc --apply";
+var DEFERRED_NOTE = "Worktree cleanup deferred \u2014 close this folder in your editor (or run cleanup from a shell outside it), then rerun mmi-cli gc --apply.";
 var WORKTREE_LOCK_RE = /EPERM|EBUSY|EACCES|ENOTEMPTY|permission denied|access is denied|used by another process|resource busy|directory not empty/i;
 function isWorktreeLockError(error) {
   return WORKTREE_LOCK_RE.test(error instanceof Error ? error.message : String(error));
 }
+function deferredWorktreesRegistryPath(gitDir) {
+  const base2 = gitDir.replace(/\\/g, "/").replace(/\/+$/, "");
+  return `${base2}/mmi-deferred-worktrees.json`;
+}
+function parseDeferredWorktreesFile(text) {
+  const parsed = JSON.parse(text);
+  if (!parsed || !Array.isArray(parsed.entries)) return [];
+  return parsed.entries.filter((e) => Boolean(e) && typeof e === "object" && typeof e.path === "string" && typeof e.branch === "string" && e.reason === "lock-held").map((e) => ({ ...e, registeredAt: e.registeredAt || (/* @__PURE__ */ new Date(0)).toISOString() }));
+}
+function serializeDeferredWorktrees(entries) {
+  return `${JSON.stringify({ entries }, null, 2)}
+`;
+}
+function deferredPathKey(path2) {
+  return normPath(path2);
+}
+function isPersistentWorktreeLockFailure(outcome) {
+  return outcome.status === "failed" && isWorktreeLockError(outcome.error);
+}
+async function registerDeferredWorktree(store, entry) {
+  const existing = await store.read();
+  const key = deferredPathKey(entry.path);
+  const already = existing.some((e) => deferredPathKey(e.path) === key);
+  if (already) return { entries: existing, newlyRegistered: false };
+  const next = {
+    ...entry,
+    registeredAt: entry.registeredAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    reason: "lock-held"
+  };
+  const entries = [...existing, next];
+  await store.write(entries);
+  return { entries, newlyRegistered: true };
+}
+async function sweepDeferredWorktrees(store, deps) {
+  if (!store) return { removed: [], stillDeferred: [] };
+  const entries = await store.read();
+  if (!entries.length) return { removed: [], stillDeferred: [] };
+  const removed = [];
+  const stillDeferred = [];
+  for (const entry of entries) {
+    const outcome = await removeWorktreeWithRecovery(entry.path, deps);
+    if (outcome.status === "removed") removed.push(entry.path);
+    else stillDeferred.push(entry);
+  }
+  await store.write(stillDeferred);
+  return { removed, stillDeferred };
+}
 var defaultSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 async function removeWorktreeWithRecovery(wtPath, deps) {
   const maxAttempts = deps.maxAttempts ?? 3;
@@ -7337,7 +7597,9 @@ function summarizePrMergeCleanupStatus(input) {
   if (input.remoteBranch.status === "failed") return "warnings";
   if (input.localBranch.status === "failed") return "warnings";
   if (input.localBranch.reason === "worktree-removal-failed") return "warnings";
+  if (input.localBranch.reason === "worktree-removal-deferred") return "warnings";
   if (input.worktree?.status === "failed") return "warnings";
+  if (input.worktree?.status === "deferred") return "warnings";
   return "clean";
 }
 function buildPrMergeResultPayload(input) {
@@ -7565,9 +7827,10 @@ function selectPrMergeCleanupWorktree(branch, before, after, startingPath) {
   if (startingPath && before.some((w) => w.branch === branch && samePath(w.path, startingPath))) return startingPath;
   return void 0;
 }
-function selectSafeWorktreeCwd(worktrees, targetPath) {
+function selectSafeWorktreeCwd(worktrees, targetPath, options) {
   if (!targetPath) return void 0;
-  return worktrees.find((w) => !samePath(w.path, targetPath))?.path;
+  const exists = options?.pathExists ?? (() => true);
+  return worktrees.find((w) => !samePath(w.path, targetPath) && exists(w.path))?.path;
 }
 function branchMissingFromList(branch, stdout) {
   const names = stdout.split(/\r?\n/).map((line) => line.replace(/^\*\s*/, "").trim()).filter(Boolean);
@@ -7598,8 +7861,16 @@ async function cleanupPrMergeLocalBranch(branch, options) {
   }
   const beforeWorktrees = options.beforeWorktrees ?? [];
   const wtPath = selectPrMergeCleanupWorktree(branch, beforeWorktrees, afterWorktrees, options.startingPath);
-  const safeCwd = selectSafeWorktreeCwd([...afterWorktrees, ...beforeWorktrees], wtPath);
+  const safeCwd = selectSafeWorktreeCwd([...afterWorktrees, ...beforeWorktrees], wtPath, {
+    pathExists: options.pathExists
+  });
   const git = (args) => safeCwd ? options.execGit(["-C", safeCwd, ...args]) : options.execGit(args);
+  const removeDeps = {
+    git,
+    sleep: options.sleep ?? defaultSleep,
+    removeWorktreeDir: options.removeWorktreeDir
+  };
+  await sweepDeferredWorktrees(options.deferredStore, removeDeps).catch(() => void 0);
   const mainWorktreePath = beforeWorktrees[0]?.path ?? afterWorktrees[0]?.path;
   const mainWorktreeTarget = Boolean(wtPath && mainWorktreePath && samePath(wtPath, mainWorktreePath));
   if (wtPath && mainWorktreeTarget) {
@@ -7620,6 +7891,37 @@ async function cleanupPrMergeLocalBranch(branch, options) {
     });
     if (outcome.status === "removed") {
       report.worktree = { path: wtPath, status: "removed", stageTeardown, recovery: outcome.recovery };
+    } else if (isPersistentWorktreeLockFailure(outcome) && options.deferredStore) {
+      try {
+        const { newlyRegistered } = await registerDeferredWorktree(options.deferredStore, {
+          path: wtPath,
+          branch,
+          reason: "lock-held"
+        });
+        report.worktree = {
+          path: wtPath,
+          status: "deferred",
+          reason: "lock-held",
+          error: outcome.error,
+          deferredNote: DEFERRED_NOTE,
+          deferredSweepCommand: DEFERRED_SWEEP_COMMAND,
+          ...newlyRegistered ? { safeCleanupCommand: safeWorktreeRemoveCommand(safeCwd, wtPath) } : {},
+          stageTeardown
+        };
+        report.localBranch = { name: branch, status: "not-attempted", reason: "worktree-removal-deferred" };
+        return report;
+      } catch (e) {
+        report.worktree = {
+          path: wtPath,
+          status: "failed",
+          reason: "deferred-registry-unavailable",
+          error: errorMessage(e),
+          safeCleanupCommand: safeWorktreeRemoveCommand(safeCwd, wtPath),
+          stageTeardown
+        };
+        report.localBranch = { name: branch, status: "not-attempted", reason: "worktree-removal-failed" };
+        return report;
+      }
     } else {
       report.worktree = {
         path: wtPath,
@@ -8419,6 +8721,7 @@ var CURSOR_PLUGIN_INSTALL_LABEL = "Cursor Team Marketplace plugin install";
 var CURSOR_MARKETPLACE_INSTALL_GUIDE = "https://github.com/mutmutco/MMI-Hub/blob/development/docs/Guides/cursor-marketplace-install.md";
 var CURSOR_PLUGIN_JSON_REL = ".cursor-plugin/plugin.json";
 var CURSOR_HOOKS_JSON_REL = "hooks/hooks.json";
+var CURSOR_HOOK_CLI_LABEL = "Cursor hook CLI bundle";
 function joinCachePath(root, ...parts) {
   const sep = root.includes("\\") ? "\\" : "/";
   return [root.replace(/[\\/]+$/, ""), ...parts].join(sep);
@@ -8474,6 +8777,20 @@ function buildCursorPluginInstallCheck(input) {
   }
   return { ...base2, cacheRoot: input.cacheRoot, pins: input.pins };
 }
+function buildCursorHookCliCheck(input) {
+  const fix = "update the MMI Team Marketplace plugin (releases ship cli/dist under plugins/mmi/cli/dist) or install mmi-cli on PATH \u2014 Cursor hooks fall back to PATH when the bundled CLI is missing";
+  const base2 = { ok: true, label: CURSOR_HOOK_CLI_LABEL, fix };
+  if (!input.isOrgRepo) return base2;
+  const shouldCheck = input.surface === "cursor" || input.pins.length > 0;
+  if (!shouldCheck) return base2;
+  if (input.pins.length === 0) {
+    if (input.surface === "cursor" && !input.mmiCliOnPath) return { ...base2, ok: false };
+    return base2;
+  }
+  const missingBundle = input.pins.some((p) => !p.hasCliBundle);
+  if (missingBundle && !input.mmiCliOnPath) return { ...base2, ok: false };
+  return base2;
+}
 var HUB_COMPAT_FIX = "update mmi-cli (npm i -g @mutmutco/cli) / refresh the MMI plugin, then rerun doctor";
 function buildHubCompatCheck(input) {
   const label = "Hub compatibility (client version vs Hub minimum)";
@@ -8483,6 +8800,48 @@ function buildHubCompatCheck(input) {
   }
   return { ok: versionAtLeast(input.installedVersion, min), label: `${label}: requires >= ${min}`, fix: HUB_COMPAT_FIX };
 }
+var PLAYWRIGHT_MCP_VISION_CAP_LABEL = "Playwright MCP vision caps (--caps=vision prohibited)";
+var PLAYWRIGHT_MCP_VISION_CAP_FIX = "remove --caps=vision (and vision-first defaults) from Playwright MCP args \u2014 use DOM-first tools; see skills/browser-automation/SKILL.md and bootstrap seed mcp-playwright.template.json";
+function textHasPlaywrightVisionCap(content) {
+  const normalized = content.replace(/\r\n/g, "\n");
+  if (/(?:^|[\s"'`=])--caps=(?:[^"\s\n]*,)?vision\b/m.test(normalized)) return true;
+  if (/\b--caps\s*=\s*["']?vision\b/.test(normalized)) return true;
+  if (/"--caps"\s*,\s*"vision"/.test(normalized)) return true;
+  if (/"caps"\s*:\s*"vision"/.test(normalized)) return true;
+  const playwrightMcp = /@playwright\/mcp/.test(normalized) || /mcp_servers\.playwright/.test(normalized) || /"playwright"\s*:\s*\{/.test(normalized) || /\bmcpServers\b/.test(normalized);
+  if (!playwrightMcp) return false;
+  if (/\bvision[-_]?(?:first|only|mode)\b/i.test(normalized)) return true;
+  return false;
+}
+function buildPlaywrightMcpVisionCapCheck(input) {
+  const base2 = {
+    ok: true,
+    label: PLAYWRIGHT_MCP_VISION_CAP_LABEL,
+    fix: PLAYWRIGHT_MCP_VISION_CAP_FIX
+  };
+  if (!input.isOrgRepo) return base2;
+  const offending = input.configs.filter((c) => textHasPlaywrightVisionCap(c.content)).map((c) => c.path);
+  if (offending.length === 0) return base2;
+  return {
+    ...base2,
+    ok: false,
+    offendingPaths: offending,
+    fix: `${PLAYWRIGHT_MCP_VISION_CAP_FIX} \u2014 found in: ${offending.join(", ")}`
+  };
+}
+var STRAY_BROWSER_ARTIFACT_DIRS = [".playwright-mcp", "playwright-report", "test-results"];
+var BROWSER_ARTIFACTS_LABEL = "browser MCP artifacts outside tmp/ (use tmp/playwright-mcp)";
+var BROWSER_ARTIFACTS_FIX = "move or delete stray Playwright output at repo root; re-run MCP with --output-dir tmp/playwright-mcp \u2014 see skills/browser-automation/SKILL.md";
+function buildBrowserArtifactsCheck(input) {
+  const base2 = { ok: true, label: BROWSER_ARTIFACTS_LABEL, fix: BROWSER_ARTIFACTS_FIX };
+  if (!input.isOrgRepo || input.strayPaths.length === 0) return base2;
+  return {
+    ...base2,
+    ok: false,
+    strayPaths: [...input.strayPaths],
+    fix: `${BROWSER_ARTIFACTS_FIX} \u2014 found: ${input.strayPaths.join(", ")}`
+  };
+}
 
 // src/stage-live.ts
 var import_node_net = require("node:net");
@@ -8856,10 +9215,22 @@ function resolveDeployModel(meta, repo) {
 function projectTypeClearsWebProfile(projectType, deployModel) {
   return projectType === "content" || projectType === "desktop-game" || projectType === "non-deployable" || projectType === "cli-tool" || deployModel === "content" || deployModel === "none" || deployModel === "registry-publish";
 }
-function resolveReleaseTrack(meta) {
+function inferReleaseTrackFromBranches(hints) {
+  if (hints.hasRcBranch) return void 0;
+  if (hints.hasDevelopmentBranch && hints.hasMainBranch) return "direct";
+  return void 0;
+}
+function resolveBootstrapReleaseTrack(cls, explicit) {
+  if (isReleaseTrack(explicit)) return explicit;
+  if (cls === "content") return "trunk";
+  return "full";
+}
+function resolveReleaseTrack(meta, hints) {
   const raw = typeof meta?.releaseTrack === "string" ? meta.releaseTrack : void 0;
   if (isReleaseTrack(raw)) return raw;
   if (meta?.class === "content" || meta?.deployModel === "content") return "trunk";
+  const inferred = hints ? inferReleaseTrackFromBranches(hints) : void 0;
+  if (inferred) return inferred;
   return "full";
 }
 function branchesForTrack(track) {
@@ -9010,6 +9381,18 @@ function ensurePositiveCount(out, emptyMessage) {
   if (!Number.isFinite(count)) throw new Error(`could not parse ahead count: ${out.trim() || "(empty)"}`);
   if (count <= 0) throw new Error(emptyMessage);
 }
+async function remoteBranchExists(deps, branch) {
+  const out = clean(await deps.run("git", ["ls-remote", "origin", `refs/heads/${branch}`]));
+  return out.length > 0;
+}
+async function loadReleaseTrackBranchHints(deps) {
+  const [hasDevelopmentBranch, hasMainBranch, hasRcBranch] = await Promise.all([
+    remoteBranchExists(deps, "development"),
+    remoteBranchExists(deps, "main"),
+    remoteBranchExists(deps, "rc")
+  ]);
+  return { hasDevelopmentBranch, hasMainBranch, hasRcBranch };
+}
 async function buildTrainApplyContext(deps) {
   const repo = requireValue(clean(await deps.run("gh", ["repo", "view", "--json", "nameWithOwner", "--jq", ".nameWithOwner"])), "repo");
   const [owner, name] = repo.split("/");
@@ -9443,7 +9826,8 @@ async function runTrainApply(command, deps, options = {}) {
   await requireCleanTree(deps);
   await deps.run("git", ["fetch", "origin"]);
   const meta = requireProjectMetaForTrain(await loadProjectMeta(deps, ctx), ctx.repo);
-  const directTrack = isHubControlRepo(ctx.repo) || resolveReleaseTrack(meta) === "direct";
+  const branchHints = await loadReleaseTrackBranchHints(deps);
+  const directTrack = isHubControlRepo(ctx.repo) || resolveReleaseTrack(meta, branchHints) === "direct";
   if (command === "rcand") {
     await requireBranch(deps, "development");
     if (directTrack) {
@@ -9502,7 +9886,8 @@ async function runTrainApply(command, deps, options = {}) {
     const requiredChecks2 = await discoverRequiredCheckContexts(deps, ctx, "main");
     const checks2 = await waitForRequiredTrainChecks(deps, ctx, releaseSha2, requiredChecks2);
     await deps.run("git", ["push", "origin", "main"]);
-    const releaseUrl2 = clean(await deps.run("gh", ["release", "create", tag2, "--generate-notes", "--latest", "--repo", ctx.repo])) || void 0;
+    const releaseUrl2 = clean(await deps.run("gh", ["release", "create", tag2, "--target", "main", "--generate-notes", "--latest", "--repo", ctx.repo])) || void 0;
+    await verifyPublishedRelease(deps, ctx.repo, tag2, "main", releaseSha2);
     const announceNote2 = deps.announce ? (await deps.announce({ repo: ctx.repo, tag: tag2, summaryFile: options.announceSummaryFile })).note : void 0;
     const autoRunSince2 = (deps.now ?? Date.now)();
     const d2 = await dispatchDeploy(deps, ctx, "main", "main", deployModel2, watch, autoRunSince2, releaseSha2, "report");
@@ -9534,13 +9919,16 @@ async function runTrainApply(command, deps, options = {}) {
   if (command === "release" && options.dev) {
     await requireBranch(deps, "development");
     await ffOnlyPull(deps, "development");
-    const rcOnlyOut = (await deps.run("git", ["rev-list", "--count", "--right-only", "--cherry-pick", "--no-merges", "origin/development...origin/rc"])).trim();
-    const rcOnly = Number.parseInt(rcOnlyOut, 10);
-    if (!Number.isFinite(rcOnly)) throw new Error(`release --dev: could not count rc-only commits for the guard: ${rcOnlyOut || "(empty)"}`);
-    if (rcOnly > 0) {
-      throw new Error(
-        `release --dev refused: origin/rc carries ${rcOnly} commit(s) not in origin/development \u2014 a development -> main release would drop that rc-only content. Land it on development first, or release the candidate via the default rc -> main path, then rerun.`
-      );
+    const hasRcBranch = branchHints.hasRcBranch ?? false;
+    if (hasRcBranch) {
+      const rcOnlyOut = (await deps.run("git", ["rev-list", "--count", "--right-only", "--cherry-pick", "--no-merges", "origin/development...origin/rc"])).trim();
+      const rcOnly = Number.parseInt(rcOnlyOut, 10);
+      if (!Number.isFinite(rcOnly)) throw new Error(`release --dev: could not count rc-only commits for the guard: ${rcOnlyOut || "(empty)"}`);
+      if (rcOnly > 0) {
+        throw new Error(
+          `release --dev refused: origin/rc carries ${rcOnly} commit(s) not in origin/development \u2014 a development -> main release would drop that rc-only content. Land it on development first, or release the candidate via the default rc -> main path, then rerun.`
+        );
+      }
     }
     ensurePositiveCount(
       await deps.run("git", ["rev-list", "--count", "origin/main..origin/development"]),
@@ -9548,7 +9936,7 @@ async function runTrainApply(command, deps, options = {}) {
     );
     const deployModel2 = await preflight(deps, ctx, "main", meta);
     const tag2 = requireValue(clean(await deps.run("node", ["scripts/next-version.mjs", "cycle"])), "release tag");
-    const rcShaAtRelease = clean(await deps.run("git", ["rev-parse", "origin/rc"]));
+    const rcShaAtRelease = hasRcBranch ? clean(await deps.run("git", ["rev-parse", "origin/rc"])) : "";
     const foldPaths2 = await resolveFoldPaths(deps, deployModel2);
     const tolerated2 = [...foldPaths2, ...RELEASE_TOLERATED_PATHS];
     const predicted2 = await predictMergeConflicts(deps, "origin/main", "origin/development");
@@ -9571,18 +9959,23 @@ async function runTrainApply(command, deps, options = {}) {
     const requiredChecks2 = await discoverRequiredCheckContexts(deps, ctx, "main");
     const checks2 = await waitForRequiredTrainChecks(deps, ctx, releaseSha2, requiredChecks2);
     await deps.run("git", ["push", "origin", "main"]);
-    const releaseUrl2 = clean(await deps.run("gh", ["release", "create", tag2, "--generate-notes", "--latest", "--repo", ctx.repo])) || void 0;
+    const releaseUrl2 = clean(await deps.run("gh", ["release", "create", tag2, "--target", "main", "--generate-notes", "--latest", "--repo", ctx.repo])) || void 0;
+    await verifyPublishedRelease(deps, ctx.repo, tag2, "main", releaseSha2);
     const announceNote2 = deps.announce ? (await deps.announce({ repo: ctx.repo, tag: tag2, summaryFile: options.announceSummaryFile })).note : void 0;
     const autoRunSince2 = (deps.now ?? Date.now)();
     const d2 = await dispatchDeploy(deps, ctx, "main", "main", deployModel2, watch, autoRunSince2, releaseSha2, "report");
-    const retirement2 = await retireRcRuntime(deps, ctx, deployModel2, d2.deployStatus, rcShaAtRelease);
+    const retirement2 = hasRcBranch ? await retireRcRuntime(deps, ctx, deployModel2, d2.deployStatus, rcShaAtRelease) : { status: "not-applicable", note: "no origin/rc branch \u2014 rc runtime retirement skipped" };
     const devRollForward2 = await rollDevelopmentForward(deps, ctx, tag2);
     let rcAlignment2;
-    try {
-      await deps.run("git", ["push", "origin", "main:rc"]);
-      rcAlignment2 = "origin/rc aligned to the released main";
-    } catch (e) {
-      rcAlignment2 = `rc alignment push failed \u2014 align manually with \`git push origin main:rc\`: ${e instanceof Error ? e.message : String(e)}`;
+    if (hasRcBranch) {
+      try {
+        await deps.run("git", ["push", "origin", "main:rc"]);
+        rcAlignment2 = "origin/rc aligned to the released main";
+      } catch (e) {
+        rcAlignment2 = `rc alignment push failed \u2014 align manually with \`git push origin main:rc\`: ${e instanceof Error ? e.message : String(e)}`;
+      }
+    } else {
+      rcAlignment2 = "no origin/rc branch \u2014 rc alignment skipped";
     }
     const environments2 = await buildEnvironments(deps, ctx, deployModel2, d2.deployStatus, retirement2);
     return {
@@ -9987,6 +10380,11 @@ async function deriveHotfixVersion(deps) {
 function hotfixBranch(tag) {
   return `hotfix/${tag}`;
 }
+async function resolveHotfixDeployModel(deps, ctx) {
+  const load = await loadProjectMeta(deps, ctx);
+  const meta = load.status === "ok" ? load.meta : null;
+  return resolveDeployModel2(meta, ctx.repo);
+}
 async function findHotfixPr(deps, ctx, tag) {
   const out = await deps.run("gh", [
     "pr",
@@ -10024,6 +10422,7 @@ async function resolveHotfixSource(deps, ctx, from) {
 }
 async function runHotfixStart(deps, options) {
   const ctx = await buildTrainApplyContext(deps);
+  const deployModel = await resolveHotfixDeployModel(deps, ctx);
   const status = await deps.run("git", ["status", "--porcelain"]);
   if (status.trim()) throw new Error("working tree must be clean before hotfix start");
   await deps.run("git", ["fetch", "origin", "--tags"]);
@@ -10061,18 +10460,23 @@ async function runHotfixStart(deps, options) {
       throw new Error(`cherry-pick of ${label} onto ${branch} conflicted \u2014 aborted; resolve by hand on a manual hotfix branch, keeping the -x trailer (${e.message ?? e})`);
     }
     notes.push(`cherry-picked ${label} onto ${branch} (from origin/main, -x trailer recorded)`);
-    await deps.run("node", ["scripts/release-distribution.mjs", "prepare", version]);
-    const changedFiles = (await deps.run("node", ["scripts/release-distribution.mjs", "changed-files"])).split("\n").map((s) => s.trim()).filter(Boolean);
-    await deps.run("git", ["add", "--", ...changedFiles]);
-    const staged = await deps.run("git", ["diff", "--cached", "--name-only"]);
-    if (staged.trim()) {
-      await deps.run("git", ["commit", "-m", `hotfix ${tag}: lock plugin set + @mutmutco/cli distribution to ${version}`]);
-      notes.push(`distribution prepared + committed for ${version} (${changedFiles.length} locked paths)`);
+    if (deployModel === "hub-serverless") {
+      await deps.run("node", ["scripts/release-distribution.mjs", "prepare", version]);
+      const changedFiles = (await deps.run("node", ["scripts/release-distribution.mjs", "changed-files"])).split("\n").map((s) => s.trim()).filter(Boolean);
+      await deps.run("git", ["add", "--", ...changedFiles]);
+      const staged = await deps.run("git", ["diff", "--cached", "--name-only"]);
+      if (staged.trim()) {
+        await deps.run("git", ["commit", "-m", `hotfix ${tag}: lock plugin set + @mutmutco/cli distribution to ${version}`]);
+        notes.push(`distribution prepared + committed for ${version} (${changedFiles.length} locked paths)`);
+      } else {
+        notes.push("distribution prepare produced no changes \u2014 nothing extra committed");
+      }
     } else {
-      notes.push("distribution prepare produced no changes \u2014 nothing extra committed");
+      notes.push(`distribution bump skipped (deployModel=${deployModel}, Hub-only step)`);
     }
     await deps.run("git", ["push", "-u", "origin", branch]);
   }
+  const bumpNote = deployModel === "hub-serverless" ? " with the locked distribution bump" : "";
   const prUrl = clean2(await deps.run("gh", [
     "pr",
     "create",
@@ -10085,7 +10489,7 @@ async function runHotfixStart(deps, options) {
     "--title",
     `[hotfix] ${tag}`,
     "--body",
-    `Hotfix ${tag}: cherry-pick of ${label} onto origin/main with the locked distribution bump.
+    `Hotfix ${tag}: cherry-pick of ${label} onto origin/main${bumpNote}.
 
 Merge this PR (human-initiated), then run \`mmi-cli hotfix release ${tag}\`.`
   ]));
@@ -10130,6 +10534,7 @@ async function watchReleaseRun(deps, ctx, workflow, sha) {
 }
 async function runHotfixRelease(deps, versionInput, options = {}) {
   const ctx = await buildTrainApplyContext(deps);
+  const deployModel = await resolveHotfixDeployModel(deps, ctx);
   const { tag, version } = normalizeHotfixVersion(versionInput);
   const status = await deps.run("git", ["status", "--porcelain"]);
   if (status.trim()) throw new Error("working tree must be clean before hotfix release");
@@ -10164,33 +10569,74 @@ async function runHotfixRelease(deps, versionInput, options = {}) {
     }
   }
   const runs = [];
-  for (const workflow of HOTFIX_RELEASE_WORKFLOWS) {
-    runs.push(await watchReleaseRun(deps, ctx, workflow, mergedSha));
+  let deployNote;
+  if (deployModel === "hub-serverless") {
+    for (const workflow of HOTFIX_RELEASE_WORKFLOWS) {
+      runs.push(await watchReleaseRun(deps, ctx, workflow, mergedSha));
+    }
+    deployNote = "watched release-triggered deploy.yml + publish.yml";
+  } else if (deployModel === "tenant-container" || deployModel === "solo-container") {
+    const dispatch = await dispatchDeploy(
+      deps,
+      ctx,
+      "main",
+      "main",
+      deployModel,
+      true,
+      (deps.now ?? Date.now)(),
+      mergedSha,
+      "report"
+    );
+    deployNote = dispatch.note;
+    runs.push({
+      workflow: "tenant-deploy.yml",
+      url: dispatch.runUrl,
+      conclusion: dispatch.deployStatus === "success" ? "success" : dispatch.deployStatus === "failure" ? "failure" : dispatch.deployStatus ?? "pending"
+    });
+  } else {
+    deployNote = `no hotfix deploy dispatch for deployModel=${deployModel} \u2014 prod deploy is repo-specific`;
   }
-  const previousRef = clean2(await deps.run("git", ["rev-parse", "--abbrev-ref", "HEAD"]));
   let verifyNote;
-  const publishSucceeded = runs.find((r) => r.workflow === "publish.yml")?.conclusion === "success";
-  try {
-    await deps.run("git", ["-c", "advice.detachedHead=false", "checkout", tag]);
-    const verifyArgs = ["scripts/release-distribution.mjs", "verify", version, ...publishSucceeded ? [] : ["--skip-npm-view"]];
-    const sleep = sleeper(deps);
-    let attempt = 0;
-    for (; ; ) {
-      attempt++;
-      try {
-        await deps.run("node", verifyArgs);
-        break;
-      } catch (err) {
-        if (attempt >= HOTFIX_VERIFY_ATTEMPTS) throw err;
-        await sleep(HOTFIX_VERIFY_RETRY_MS);
+  if (deployModel === "hub-serverless") {
+    const previousRef = clean2(await deps.run("git", ["rev-parse", "--abbrev-ref", "HEAD"]));
+    const publishSucceeded = runs.find((r) => r.workflow === "publish.yml")?.conclusion === "success";
+    try {
+      await deps.run("git", ["-c", "advice.detachedHead=false", "checkout", tag]);
+      const verifyArgs = ["scripts/release-distribution.mjs", "verify", version, ...publishSucceeded ? [] : ["--skip-npm-view"]];
+      const sleep = sleeper(deps);
+      let attempt = 0;
+      for (; ; ) {
+        attempt++;
+        try {
+          await deps.run("node", verifyArgs);
+          break;
+        } catch (err) {
+          if (attempt >= HOTFIX_VERIFY_ATTEMPTS) throw err;
+          await sleep(HOTFIX_VERIFY_RETRY_MS);
+        }
       }
+      const retried = attempt > 1 ? `, after ${attempt} attempts (npm propagation lag)` : "";
+      verifyNote = `distribution verified at ${tag}${publishSucceeded ? ` (npm included${retried})` : " (npm view skipped \u2014 publish run not confirmed)"}`;
+    } finally {
+      if (previousRef && previousRef !== "HEAD") await deps.run("git", ["checkout", previousRef]);
     }
-    const retried = attempt > 1 ? `, after ${attempt} attempts (npm propagation lag)` : "";
-    verifyNote = `distribution verified at ${tag}${publishSucceeded ? ` (npm included${retried})` : " (npm view skipped \u2014 publish run not confirmed)"}`;
-  } finally {
-    if (previousRef && previousRef !== "HEAD") await deps.run("git", ["checkout", previousRef]);
+  } else {
+    verifyNote = `distribution verify skipped (deployModel=${deployModel}, Hub-only step)`;
   }
-  return { ...ctx, command: "hotfix-release", tag, mergedSha, checks, tagNote, releaseNote, runs, verifyNote, announceNote };
+  return {
+    ...ctx,
+    command: "hotfix-release",
+    tag,
+    mergedSha,
+    deployModel,
+    checks,
+    tagNote,
+    releaseNote,
+    runs,
+    deployNote,
+    verifyNote,
+    announceNote
+  };
 }
 function deriveHotfixState(f) {
   if (!f.branchExists && !f.pr && !f.tagPushed && !f.releaseExists) {
@@ -10226,6 +10672,11 @@ async function runHotfixStatus(deps, versionInput) {
         return { ...ctx, command: "hotfix-status", ...latestFacts, ...latestDerived };
       }
     }
+    const inFlight = await findInFlightHotfixVersion(deps, ctx);
+    if (inFlight) {
+      const facts2 = await gatherHotfixFacts(deps, ctx, inFlight.tag, inFlight.version);
+      return { ...ctx, command: "hotfix-status", ...facts2, ...deriveHotfixState(facts2) };
+    }
     ({ tag, version } = await deriveHotfixVersion(deps));
   }
   const facts = await gatherHotfixFacts(deps, ctx, tag, version);
@@ -10271,6 +10722,47 @@ async function gatherHotfixFacts(deps, ctx, tag, version) {
   const npmVersion = await deps.run("npm", ["view", "@mutmutco/cli", "version", "--silent"]).then(clean2, () => "unknown");
   return { tag, version, branchExists, pr: pr2 ? { number: pr2.number, state: pr2.state, url: pr2.url } : null, tagPushed, releaseExists, runs, npmVersion };
 }
+async function findInFlightHotfixVersion(deps, ctx) {
+  const tags = /* @__PURE__ */ new Set();
+  const out = await deps.run("gh", [
+    "pr",
+    "list",
+    "--repo",
+    ctx.repo,
+    "--base",
+    "main",
+    "--state",
+    "all",
+    "--limit",
+    "50",
+    "--json",
+    "headRefName"
+  ]);
+  for (const row of JSON.parse(out || "[]")) {
+    const m = typeof row.headRefName === "string" && /^hotfix\/(v\d+\.\d+\.\d+)/.exec(row.headRefName);
+    if (m) tags.add(m[1]);
+  }
+  const branchOut = clean2(await deps.run("git", ["ls-remote", "origin", "refs/heads/hotfix/v*"]));
+  for (const line of branchOut.split("\n").filter(Boolean)) {
+    const ref = line.split(/\s+/)[1] ?? "";
+    const m = /^refs\/heads\/hotfix\/(v\d+\.\d+\.\d+)/.exec(ref);
+    if (m) tags.add(m[1]);
+  }
+  const sorted = [...tags].sort((a, b) => {
+    const pa = a.slice(1).split(".").map(Number);
+    const pb = b.slice(1).split(".").map(Number);
+    for (let i = 0; i < 3; i++) {
+      if (pa[i] !== pb[i]) return pb[i] - pa[i];
+    }
+    return 0;
+  });
+  for (const tag of sorted) {
+    const version = tag.slice(1);
+    const facts = await gatherHotfixFacts(deps, ctx, tag, version);
+    if (deriveHotfixState(facts).state !== "complete") return { tag, version };
+  }
+  return null;
+}
 
 // src/release-announce.ts
 var ANNOUNCE_REPO = "mutmutco/MMI-Hub";
@@ -10716,6 +11208,9 @@ var requiredIssueTemplates = [
   ".github/ISSUE_TEMPLATE/config.yml"
 ];
 var requiredWorkflows = [];
+var requiredProductWorkflows = [".github/workflows/gate.yml"];
+var requiredProductRulesetRef = ".github/rulesets/mmi-product-required-checks.json";
+var HUB_REPO3 = "mutmutco/MMI-Hub";
 var requiredLabels = ["bug", "feature", "task", "priority:urgent", "priority:high", "priority:medium", "priority:low"];
 var requiredPriorityOptions = ["Urgent", "High", "Medium", "Low"];
 var strayDefaultLabels = ["documentation", "duplicate", "enhancement", "good first issue", "help wanted", "invalid", "question", "wontfix"];
@@ -10728,6 +11223,7 @@ var requiredProjectWorkflows = [
 ];
 var requiredOrgRulesetTypes = ["pull_request", "non_fast_forward", "deletion"];
 var requiredHubStatusChecks = ["cli", "infra", "docs"];
+var requiredProductStatusChecks = ["gate"];
 function expectedBranches(repoClass, releaseTrack) {
   if (isReleaseTrack(releaseTrack)) return branchesForTrack(releaseTrack);
   return repoClass === "content" ? ["main"] : ["development", "rc", "main"];
@@ -10880,6 +11376,16 @@ async function verifyBootstrap(repo, repoClass, deps, releaseTrack) {
   for (const path2 of requiredWorkflows) {
     checks.push({ ok: await contentExists(deps, repo, baseBranch, path2), label: `automation workflow exists: ${path2}` });
   }
+  if (repo !== HUB_REPO3) {
+    for (const path2 of requiredProductWorkflows) {
+      checks.push({ ok: await contentExists(deps, repo, baseBranch, path2), label: `gate workflow exists: ${path2}` });
+    }
+    checks.push({
+      ok: await contentExists(deps, repo, baseBranch, requiredProductRulesetRef),
+      label: "product required-check ruleset reference exists",
+      detail: `expected: ${requiredProductRulesetRef} (apply as an active repo ruleset after bootstrap)`
+    });
+  }
   if (repoClass === "deployable") {
     const trainScript = "scripts/next-version.mjs";
     checks.push({ ok: await contentExists(deps, repo, baseBranch, trainScript), label: `train tooling script exists: ${trainScript}` });
@@ -11015,7 +11521,7 @@ async function verifyBootstrap(repo, repoClass, deps, releaseTrack) {
     label: "covered by an active org ruleset",
     detail: orgRuleset ? void 0 : activeOrgRulesets.length === 0 ? "no active Organization-sourced branch ruleset targets this repo" : `missing rule types: ${missingOrgRuleTypes.join(", ")}`
   });
-  if (repo === "mutmutco/MMI-Hub") {
+  if (repo === HUB_REPO3) {
     const statusChecks = rulesetStatusChecks(rulesets.filter((r) => r.target === "branch" && r.enforcement === "active"));
     const missing = requiredHubStatusChecks.filter((check) => !statusChecks.has(check));
     checks.push({
@@ -11023,6 +11529,14 @@ async function verifyBootstrap(repo, repoClass, deps, releaseTrack) {
       label: "Hub required status checks configured",
       detail: optionDetail(missing)
     });
+  } else {
+    const statusChecks = rulesetStatusChecks(rulesets.filter((r) => r.target === "branch" && r.enforcement === "active"));
+    const missing = requiredProductStatusChecks.filter((check) => !statusChecks.has(check));
+    checks.push({
+      ok: missing.length === 0,
+      label: "product required status checks configured",
+      detail: missing.length ? `missing contexts: ${missing.join(", ")} \u2014 apply ${requiredProductRulesetRef} as an active repo ruleset` : void 0
+    });
   }
   const declaredApis = (deps.requiredGcpApis ?? []).filter((a) => a && a.trim());
   if (declaredApis.length > 0) {
@@ -11074,12 +11588,42 @@ function parseOwnerRepo(repo) {
   return { owner, name, slug: name.toLowerCase(), fullName: `${owner}/${name}` };
 }
 var DEFAULT_INSTALL_CMD = "npm ci";
-function withDerivedRepoVars(vars, parsed, cls) {
+var DEFAULT_GATE_CMD = "npm run check";
+function gateSeedVars(cls, releaseTrack) {
+  const track = releaseTrack ?? (cls === "content" ? "trunk" : "full");
+  if (track === "trunk") {
+    return {
+      GATE_CMD: DEFAULT_GATE_CMD,
+      GATE_PUSH_BRANCHES_YAML: "[main]",
+      GATE_FULL_RUN_BRANCH: "main",
+      GATE_RULESET_BRANCH_REFS_JSON: '["refs/heads/main"]'
+    };
+  }
+  if (track === "direct") {
+    return {
+      GATE_CMD: DEFAULT_GATE_CMD,
+      GATE_PUSH_BRANCHES_YAML: "[development, main]",
+      GATE_FULL_RUN_BRANCH: "development",
+      GATE_RULESET_BRANCH_REFS_JSON: '["refs/heads/development", "refs/heads/main"]'
+    };
+  }
+  return {
+    GATE_CMD: DEFAULT_GATE_CMD,
+    GATE_PUSH_BRANCHES_YAML: "[development, rc, main]",
+    GATE_FULL_RUN_BRANCH: "development",
+    GATE_RULESET_BRANCH_REFS_JSON: '["refs/heads/development", "refs/heads/rc", "refs/heads/main"]'
+  };
+}
+function withDerivedRepoVars(vars, parsed, cls, releaseTrack) {
   const out = { ...vars };
   out.REPO_NAME ??= parsed.name;
   out.REPO_SLUG ??= parsed.slug;
   out.CLASS ??= cls;
   out.INSTALL_CMD ??= DEFAULT_INSTALL_CMD;
+  const track = releaseTrack ?? resolveBootstrapReleaseTrack(cls);
+  for (const [key, value] of Object.entries(gateSeedVars(cls, track))) {
+    out[key] ??= value;
+  }
   return out;
 }
 function planSeedAction(seed, exists) {
@@ -11189,8 +11733,8 @@ function buildRegisterPayload(repo, cls, vars, options = {}) {
     class: cls,
     projectType,
     deployModel,
-    // #917: only emit when explicitly direct/trunk; absent → registry resolves to `full` (no clobber).
-    releaseTrack: isReleaseTrack(options.releaseTrack) ? options.releaseTrack : void 0,
+    // #1359: always persist an explicit track so release tooling never guesses from absence alone.
+    releaseTrack: resolveBootstrapReleaseTrack(cls, options.releaseTrack),
     // Board coords (from GraphQL at bootstrap, passed as --var by the skill).
     projectOwner: vars.PROJECT_OWNER || void 0,
     projectNumber: num(vars.PROJECT_NUMBER),
@@ -11204,6 +11748,11 @@ function buildRegisterPayload(repo, cls, vars, options = {}) {
     kbPointer: `kb/projects/${slug}.md`
   };
   for (const k of Object.keys(payload)) if (payload[k] === void 0) delete payload[k];
+  if (payload.projectId && payload.projectNumber == null) {
+    throw new Error(
+      "bootstrap apply: PROJECT_ID is set but PROJECT_NUMBER is missing \u2014 pass --var PROJECT_NUMBER=<N> or ensure the live board GraphQL query succeeds"
+    );
+  }
   return payload;
 }
 var BOARD_FIELD_VAR_MAP = {
@@ -11216,9 +11765,18 @@ var BOARD_FIELD_VAR_MAP = {
     options: { Urgent: "PRIORITY_URGENT", High: "PRIORITY_HIGH", Medium: "PRIORITY_MEDIUM", Low: "PRIORITY_LOW" }
   }
 };
+function projectV2BoardNode(fieldsJson) {
+  if (Array.isArray(fieldsJson)) return { fields: { nodes: fieldsJson } };
+  const wrapped = fieldsJson;
+  return wrapped?.data?.node ?? wrapped?.node;
+}
 function extractBoardFieldVars(fieldsJson) {
   const out = {};
-  const nodes = Array.isArray(fieldsJson) ? fieldsJson : fieldsJson?.data?.node?.fields?.nodes ?? fieldsJson?.node?.fields?.nodes;
+  const projectNode = projectV2BoardNode(fieldsJson);
+  if (typeof projectNode?.number === "number" && Number.isFinite(projectNode.number)) {
+    out.PROJECT_NUMBER = String(projectNode.number);
+  }
+  const nodes = projectNode?.fields?.nodes;
   if (!Array.isArray(nodes)) return out;
   for (const node of nodes) {
     const field = node;
@@ -11236,7 +11794,7 @@ function extractBoardFieldVars(fieldsJson) {
   return out;
 }
 function boardFieldsQueryArgs(projectId) {
-  const query = "query($id: ID!) { node(id: $id) { ... on ProjectV2 { fields(first: 50) { nodes { ... on ProjectV2SingleSelectField { id name options { id name } } } } } } }";
+  const query = "query($id: ID!) { node(id: $id) { ... on ProjectV2 { number fields(first: 50) { nodes { ... on ProjectV2SingleSelectField { id name options { id name } } } } } } }";
   return ["api", "graphql", "-f", `query=${query}`, "-f", `id=${projectId}`];
 }
 function serializeRegistry(obj) {
@@ -11481,6 +12039,14 @@ function dnsErrorToResolution(code) {
 }
 var STAGES = ["dev", "rc", "main"];
 var DEFAULT_RUNTIME_SECRET_NAMES2 = ["GOOGLE_CLIENT_ID", "GOOGLE_CLIENT_SECRET"];
+function boardRegistryGaps(meta) {
+  if (!meta?.projectId) return [];
+  if (meta.projectNumber != null) return [];
+  return ["projectNumber"];
+}
+function boardRegistryGapMessage(repo) {
+  return `Board META incomplete for ${repo}: registry has projectId but no projectNumber \u2014 board claim and auto-add will fail until projectNumber is backfilled (re-run \`node infra/migrate/seed-registry.mjs\` or \`mmi-cli bootstrap apply --execute\` with board vars)`;
+}
 function slugOfRepo(repoOrSlug) {
   return (repoOrSlug.includes("/") ? repoOrSlug.split("/").pop() : repoOrSlug).toLowerCase();
 }
@@ -11679,6 +12245,7 @@ function buildV2HealPatch(repoOrSlug, meta) {
     }
   }
   const appOwnedGaps = confidentType ? appGapsFor(meta, model, slug, confidentType) : [`Project type is unset and not derivable \u2014 classify with \`mmi-cli project set ${repo} --project-type <web-app|hub-service|content|desktop-game|non-deployable|cli-tool|worker> --deploy-model <tenant-container|solo-container|hub-serverless|serverless|registry-publish|content|none>\` before heal completes the v2 fields (prevents defaulting a non-web repo to tenant-container).`];
+  if (boardRegistryGaps(meta).length) appOwnedGaps.unshift(boardRegistryGapMessage(repo));
   return { slug, patch, appOwnedGaps };
 }
 async function runV2Heal(repoOrSlug, opts, deps) {
@@ -11768,7 +12335,7 @@ async function buildV2Doctor(repoOrSlug, deps) {
     const missing = required.filter((key) => !presentSecrets.has(key));
     return [stage2, { required, present, missing }];
   }));
-  const metaMissing = ["class", "projectType", "deployModel", "vaultPath", "kbPointer"].filter((key) => meta[key] === void 0);
+  const metaMissing = ["class", "projectType", "deployModel", "vaultPath", "kbPointer"].filter((key) => meta[key] === void 0).concat(boardRegistryGaps(meta));
   const ok = !secretsError && metaMissing.length === 0 && Object.values(deployCoords).every((v) => v.ok) && Object.values(secrets2).every((v) => v.missing.length === 0);
   const edgeDomainWarnings = deps.resolveDns ? await probeEdgeDomains(meta, deps.resolveDns) : [];
   return {
@@ -12489,9 +13056,13 @@ async function relevantPlans(deps, signals, opts = {}) {
     deps.err(`northstar relevant: ${e.message}`);
     return;
   }
-  if (!plans.length) return deps.log("no North Stars for this repo yet");
+  if (!plans.length) {
+    if (opts.json) return deps.log(JSON.stringify({ ranked: [] }));
+    return deps.log("no North Stars for this repo yet");
+  }
   const ranked = rankPlansByRelevance(plans, signals, { includeAll: opts.includeAll });
   const top = (opts.includeAll ? ranked : ranked.filter((r) => r.score > 0)).slice(0, opts.limit ?? 5);
+  if (opts.json) return deps.log(JSON.stringify({ ranked: top }));
   if (!top.length) {
     return deps.log(`no task-relevant North Stars among ${plans.length} for this repo \u2014 \`mmi-cli northstar relevant --all\` lists recent ones`);
   }
@@ -12573,9 +13144,14 @@ async function planSync(deps, opts = {}) {
     if (!opts.quiet) deps.err(`northstar sync: list refresh failed: ${e.message}`);
   }
 }
-async function planStatus(deps) {
+async function planStatus(deps, opts = {}) {
   const queue = parseQueue(deps.readQueueRaw());
   const idx = parseIndex(deps.readIndexRaw());
+  if (opts.json) {
+    deps.log(JSON.stringify({ queue, index: idx }));
+    if (queue.some((e) => e.conflict || e.deadLettered)) process.exitCode = 1;
+    return;
+  }
   for (const e of queue) {
     if (e.conflict) deps.err(`${e.slug}  \xB7  CONFLICT \u2014 ${e.conflict}`);
     else if (e.deadLettered) deps.err(`${e.slug}  \xB7  DEAD-LETTER \u2014 ${e.deadLettered}`);
@@ -13034,7 +13610,7 @@ async function runWhoami(io = consoleIo) {
   io.log(JSON.stringify(report));
   return report;
 }
-program2.command("whoami").description('resolve the logged-in human: {login, source, sessionExpiresAt} JSON; source "unknown" (exit 0) when neither the Hub session nor gh can name them').action(async () => {
+program2.command("whoami").description('resolve the logged-in human: {login, source, sessionExpiresAt} JSON; source "unknown" (exit 0) when neither the Hub session nor gh can name them').option("--json", "machine-readable output (default)").action(async () => {
   await runWhoami();
 });
 program2.command("gc").description("dry-run cleanup for merged/closed PR branches and stale tracking refs").option("--dry-run", "show what would be deleted (default)").option("--apply", "delete only the listed clean merged/closed PR branches and stale tracking refs").option("--json", "machine-readable output").option("--remote <name>", "remote name", "origin").option("--limit <n>", "PRs to inspect per state", "200").action(async (o) => {
@@ -13045,7 +13621,14 @@ program2.command("gc").description("dry-run cleanup for merged/closed PR branche
     const plan2 = await gcPlan(o.remote, limit);
     if (o.apply && !o.json) console.log(formatGcPlan(plan2, false));
     let applyResult;
-    if (o.apply) applyResult = await applyGcPlan(plan2, o.remote);
+    if (o.apply) {
+      const deferredStore = await createDeferredWorktreeStore();
+      await sweepDeferredWorktrees(
+        deferredStore,
+        worktreeRemoveDeps(async (args) => (await execFileP2("git", args, { timeout: GIT_TIMEOUT_MS })).stdout)
+      ).catch(() => void 0);
+      applyResult = await applyGcPlan(plan2, o.remote);
+    }
     if (o.json) {
       console.log(JSON.stringify({ dryRun: !o.apply, remote: o.remote, plan: plan2, applyResult }, null, 2));
     } else if (!o.apply) {
@@ -13310,12 +13893,12 @@ function registerNorthStarCommands(cmd) {
     if (!ok) process.exitCode = 1;
   }));
   cmd.command("list").description("list your North Star plans (cross-device)").option("--project <name>", "filter by project").option("--json", "machine-readable output").option("--quiet", "silent when unconfigured/empty/unreachable (SessionStart hook)").option("--fresh", "bypass the local cache and read from the server").action((o) => withPlan(o.quiet ?? false, (d) => planList(d, o)));
-  cmd.command("relevant").description("list North Stars relevant to your current task (branch + claimed issue + changed files)").option("--project <name>", "override the project key").option("--all", "include superseded/graduated and recent non-matching plans").option("--limit <n>", "max results (default 5)").option("--fresh", "bypass the local cache and read from the server").action((o) => withPlan(false, async (d) => {
+  cmd.command("relevant").description("list North Stars relevant to your current task (branch + claimed issue + changed files)").option("--project <name>", "override the project key").option("--all", "include superseded/graduated and recent non-matching plans").option("--limit <n>", "max results (default 5)").option("--fresh", "bypass the local cache and read from the server").option("--json", "machine-readable output").action((o) => withPlan(false, async (d) => {
     const signals = await gatherRelevanceSignals();
-    await relevantPlans(d, signals, { project: o.project, includeAll: o.all, limit: o.limit ? Number(o.limit) : void 0, fresh: o.fresh });
+    await relevantPlans(d, signals, { project: o.project, includeAll: o.all, limit: o.limit ? Number(o.limit) : void 0, fresh: o.fresh, json: o.json });
   }));
   cmd.command("sync").description("drain queued background pushes and refresh the local plan index").option("--quiet", "silent (background worker)").action((o) => withPlan(o.quiet ?? false, (d) => planSync(d, o)));
-  cmd.command("status").description("show pending/conflicted background pushes and the plan-cache age").action(() => withPlan(false, (d) => planStatus(d)));
+  cmd.command("status").description("show pending/conflicted background pushes and the plan-cache age").option("--json", "machine-readable output").action((o) => withPlan(false, (d) => planStatus(d, o)));
   cmd.command("reconcile").description("refresh stale local etags from the server without --force (recovers from an object-store re-stamp)").action(() => withPlan(false, (d) => planReconcile(d)));
   cmd.command("open <slug>").description("pull if needed, then open plans/<slug>.md in $EDITOR").option("--project <name>", "override the project key").action(
     (slug, o) => withPlan(false, async (d) => {
@@ -13954,6 +14537,41 @@ verify.command("synthesize").description("merge lens JSON array into a PanelRepo
     return fail(`verify synthesize: ${e.message}`);
   }
 });
+var fusion = verify.command("fusion").description("optional hosted fusion provider for grind verify (#1377)");
+fusion.command("plan").description("plan a hosted fusion job \u2014 print FusionPlan JSON (falls back to host panel when provider unset)").requiredOption("--criteria-file <path>", "UTF-8 file with success criteria").requiredOption("--diff-file <path>", "UTF-8 file with git diff output").option("--routing <routing>", "Balanced | Budget | Paranoid", "Balanced").option("--lenses <list>", `comma-separated lens names (default: ${GRIND_LENSES.join(",")})`, GRIND_LENSES.join(",")).option("--provider-url <url>", "fusion provider base URL (else MMI_FUSION_PROVIDER_URL)").option("--web-search", "enable bounded web search in fusion tool policy").action(async (o) => {
+  try {
+    const routing = parseFusionRouting(o.routing);
+    const lenses = parseFusionLenses(o.lenses);
+    const criteria = await (0, import_promises5.readFile)(o.criteriaFile, "utf8");
+    const diff = await (0, import_promises5.readFile)(o.diffFile, "utf8");
+    const plan2 = buildFusionPlan({
+      routing,
+      lenses,
+      criteria,
+      diff,
+      providerUrl: o.providerUrl ?? null,
+      toolPolicy: {
+        webSearch: Boolean(o.webSearch),
+        maxQueriesPerLens: 3,
+        denyDomains: [...DEFAULT_SEARCH_DENY_DOMAINS]
+      }
+    });
+    console.log(JSON.stringify(plan2));
+  } catch (e) {
+    return fail(`verify fusion plan: ${e.message}`);
+  }
+});
+fusion.command("run").description("execute hosted fusion from a FusionPlan JSON file; prints PanelReport or fallback envelope").requiredOption("--plan-file <path>", "UTF-8 FusionPlan JSON from verify fusion plan").option("--provider-url <url>", "override fusion provider URL (else plan.provider or MMI_FUSION_PROVIDER_URL)").action(async (o) => {
+  try {
+    const raw = await (0, import_promises5.readFile)(o.planFile, "utf8");
+    const plan2 = JSON.parse(raw);
+    const result = await runFusionProvider(plan2, { providerUrl: o.providerUrl ?? plan2.provider ?? null });
+    console.log(JSON.stringify(result));
+    if (!result.ok) process.exitCode = 1;
+  } catch (e) {
+    return fail(`verify fusion run: ${e.message}`);
+  }
+});
 program2.command("skill-lesson").description("file a skill-lesson on the Hub board (GitHub auth, dedups open lessons) and print {number,url} JSON").requiredOption("--skill <name>", `which skill misfired (${SKILL_NAMES.join(" | ")})`).option("--title <title>", "one-line summary of what misfired").option("--title-file <path|->", "read the one-line summary from a UTF-8 file, or from stdin with -").option("--body <body>", "lesson body: what misfired, the evidence, and the proposed amendment (markdown)").option("--body-file <path|->", "read the lesson body from a UTF-8 file, or from stdin with -").option("--priority <priority>", "urgent | high | medium | low (board Priority field when configured)", "medium").option("--repo <owner/repo>", `target repo (defaults to the org Hub: ${HUB_REPO})`).option("--force", "file a new issue even when an open lesson looks like a duplicate").option("--json", "machine-readable output (already the default \u2014 skill-lesson always prints JSON)").action(async (o) => {
   const targetRepo2 = o.repo ?? HUB_REPO;
   const sourceRepo = await resolveRepo(void 0);
@@ -14026,12 +14644,43 @@ pr.command("create").description("create a PR and print {number,url} JSON").opti
   const created = await ghCreate(buildPrArgs({ title, body, base: o.base, head: o.head, repo: o.repo }));
   console.log(JSON.stringify(created));
 });
-async function remoteBranchExists(branch, options = {}) {
+async function remoteBranchExists2(branch, options = {}) {
   return checkRemoteBranchExists(branch, {
     execGit: async (args) => (await execFileP2("git", args, { timeout: GIT_TIMEOUT_MS })).stdout
   }, options);
 }
 var COMPOSE_TIMEOUT_MS = 12e4;
+async function createDeferredWorktreeStore() {
+  try {
+    const { stdout } = await execFileP2("git", ["rev-parse", "--git-dir"], { timeout: GIT_TIMEOUT_MS });
+    const registryPath = deferredWorktreesRegistryPath(stdout.trim());
+    return {
+      read: async () => {
+        try {
+          return parseDeferredWorktreesFile(await (0, import_promises5.readFile)(registryPath, "utf8"));
+        } catch {
+          return [];
+        }
+      },
+      write: async (entries) => {
+        try {
+          await (0, import_promises5.mkdir)((0, import_node_path13.dirname)(registryPath), { recursive: true });
+          await (0, import_promises5.writeFile)(registryPath, serializeDeferredWorktrees(entries), "utf8");
+        } catch {
+        }
+      }
+    };
+  } catch {
+    return void 0;
+  }
+}
+function worktreeRemoveDeps(execGit) {
+  return {
+    git: execGit,
+    sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+    removeWorktreeDir: async (worktreePath) => (0, import_promises5.rm)(worktreePath, { recursive: true, force: true, maxRetries: 5, retryDelay: 200 })
+  };
+}
 function teardownWorktreeStage(worktreePath) {
   return runWorktreeStageTeardown(worktreePath, {
     hasStageState: (wt) => (0, import_node_fs14.existsSync)(stageStatePath(wt)),
@@ -14053,7 +14702,7 @@ pr.command("merge <number>").description("merge a PR (squash by default) and cle
   const beforeWorktrees = parseWorktreePorcelain(
     (await execFileP2("git", ["worktree", "list", "--porcelain"], { timeout: GIT_TIMEOUT_MS }).catch(() => ({ stdout: "" }))).stdout
   );
-  const remoteBefore = repoArgs.length ? void 0 : await remoteBranchExists(headRef);
+  const remoteBefore = repoArgs.length ? void 0 : await remoteBranchExists2(headRef);
   let remoteDeleteAttempted = false;
   let remoteNotAttemptedReason = repoArgs.length ? "repo-option" : void 0;
   await execFileP2("gh", buildPrMergeArgs({ number, repoArgs, method, auto: o.auto }), { timeout: GH_MUTATION_TIMEOUT_MS }).catch((e) => {
@@ -14081,26 +14730,39 @@ pr.command("merge <number>").description("merge a PR (squash by default) and cle
     attempted: false,
     reason: remoteNotAttemptedReason
   }) : await buildPrMergeRemoteBranchCleanupReport(headRef, {
-    exists: remoteBranchExists
+    exists: remoteBranchExists2
   }, {
     attempted: remoteDeleteAttempted,
     existedBefore: remoteBefore,
     reason: remoteNotAttemptedReason
   });
-  const localCleanup = repoArgs.length ? {
-    branch: headRef,
-    localBranch: { name: headRef, status: "not-attempted", reason: "repo-option" },
-    worktree: void 0
-  } : await cleanupPrMergeLocalBranch(headRef, {
-    beforeWorktrees,
-    startingPath,
-    execGit: async (args) => (await execFileP2("git", args, { timeout: GIT_TIMEOUT_MS })).stdout,
-    teardownWorktreeStage,
-    // Hardened fallback when retried `git worktree remove` still hits a Windows file lock (#967).
-    // `fs.rm` recursive removes a junction as a link (it does not traverse into the target) and its
-    // own maxRetries/retryDelay rides out a handle that an indexer/antivirus releases a moment later.
-    removeWorktreeDir: async (worktreePath) => (0, import_promises5.rm)(worktreePath, { recursive: true, force: true, maxRetries: 5, retryDelay: 200 })
-  });
+  const deferredStore = await createDeferredWorktreeStore();
+  let localCleanup;
+  try {
+    localCleanup = repoArgs.length ? {
+      branch: headRef,
+      localBranch: { name: headRef, status: "not-attempted", reason: "repo-option" },
+      worktree: void 0
+    } : await cleanupPrMergeLocalBranch(headRef, {
+      beforeWorktrees,
+      startingPath,
+      pathExists: (p) => (0, import_node_fs14.existsSync)(p),
+      execGit: async (args) => (await execFileP2("git", args, { timeout: GIT_TIMEOUT_MS })).stdout,
+      teardownWorktreeStage,
+      deferredStore,
+      removeWorktreeDir: worktreeRemoveDeps(async (args) => (await execFileP2("git", args, { timeout: GIT_TIMEOUT_MS })).stdout).removeWorktreeDir
+    });
+  } catch (e) {
+    localCleanup = {
+      branch: headRef,
+      localBranch: {
+        name: headRef,
+        status: "failed",
+        reason: "cleanup-exception",
+        error: e instanceof Error ? e.message : String(e)
+      }
+    };
+  }
   console.log(JSON.stringify(buildPrMergeResultPayload({
     number,
     branch: headRef,
@@ -14567,10 +15229,11 @@ function renderHotfixStart(r) {
 }
 function renderHotfixRelease(r) {
   return [
-    `mmi-cli hotfix release: ${r.tag} at ${r.mergedSha.slice(0, 7)} on ${r.repo}`,
+    `mmi-cli hotfix release: ${r.tag} at ${r.mergedSha.slice(0, 7)} on ${r.repo} (deployModel=${r.deployModel})`,
     `  - checks: ${r.checks}`,
     `  - ${r.tagNote}`,
     `  - ${r.releaseNote}`,
+    `  - deploy: ${r.deployNote}`,
     ...r.runs.map((run) => `  - ${run.workflow}: ${run.conclusion}${run.url ? ` (${run.url})` : ""}`),
     `  - ${r.verifyNote}`,
     ...r.announceNote ? [`  - announce: ${r.announceNote}`] : [],
@@ -14661,6 +15324,7 @@ bootstrap.command("apply <repo>").description("idempotent seed apply from skills
     json: rawFlag("--json")
   };
   if (o.class !== "deployable" && o.class !== "content") return fail("bootstrap apply: --class must be deployable or content");
+  const bootstrapReleaseTrack = resolveBootstrapReleaseTrack(o.class, o.releaseTrack || void 0);
   let parsedRepo;
   try {
     parsedRepo = parseOwnerRepo(repo);
@@ -14680,7 +15344,7 @@ bootstrap.command("apply <repo>").description("idempotent seed apply from skills
     const eq = value.indexOf("=");
     if (eq > 0) rawVars[value.slice(0, eq)] = value.slice(eq + 1);
   }
-  const vars = withDerivedRepoVars(rawVars, parsedRepo, o.class);
+  const vars = withDerivedRepoVars(rawVars, parsedRepo, o.class, bootstrapReleaseTrack);
   if (vars.PROJECT_ID) {
     try {
       const r = await gh(boardFieldsQueryArgs(vars.PROJECT_ID));
@@ -14748,7 +15412,7 @@ bootstrap.command("apply <repo>").description("idempotent seed apply from skills
     registerPayload = buildRegisterPayload(repo, o.class, vars, {
       projectType: o.projectType || void 0,
       deployModel: o.deployModel || void 0,
-      releaseTrack: o.releaseTrack || void 0
+      releaseTrack: bootstrapReleaseTrack
     });
   } catch (e) {
     return fail(`bootstrap apply: ${e.message}`);
@@ -14975,6 +15639,7 @@ function cursorPluginCachePinSnapshots() {
       const path2 = (0, import_node_path13.join)(root, entry.name);
       const pluginJson = (0, import_node_path13.join)(path2, ".cursor-plugin", "plugin.json");
       const hooksJson = (0, import_node_path13.join)(path2, "hooks", "hooks.json");
+      const cliBundle = (0, import_node_path13.join)(path2, "cli", "dist", "index.cjs");
       let isEmpty = true;
       try {
         isEmpty = (0, import_node_fs14.readdirSync)(path2).length === 0;
@@ -14986,6 +15651,7 @@ function cursorPluginCachePinSnapshots() {
         path: path2,
         hasPluginJson: (0, import_node_fs14.existsSync)(pluginJson),
         hasHooksJson: (0, import_node_fs14.existsSync)(hooksJson),
+        hasCliBundle: (0, import_node_fs14.existsSync)(cliBundle),
         isEmpty
       };
     });
@@ -15050,6 +15716,39 @@ function quarantinePluginCacheDirs(plan2) {
   return moved;
 }
 var gitignorePath = () => (0, import_node_path13.join)(process.cwd(), ".gitignore");
+function readTextFile(path2) {
+  try {
+    if (!(0, import_node_fs14.existsSync)(path2)) return null;
+    return (0, import_node_fs14.readFileSync)(path2, "utf8");
+  } catch {
+    return null;
+  }
+}
+function playwrightMcpConfigSnapshots() {
+  const cwd = process.cwd();
+  const home = (0, import_node_os4.homedir)();
+  const candidates = [
+    (0, import_node_path13.join)(cwd, ".cursor", "mcp.json"),
+    (0, import_node_path13.join)(home, ".cursor", "mcp.json"),
+    (0, import_node_path13.join)(home, ".codex", "config.toml")
+  ];
+  const out = [];
+  for (const path2 of candidates) {
+    const content = readTextFile(path2);
+    if (content != null) out.push({ path: path2, content });
+  }
+  return out;
+}
+function strayBrowserArtifactPaths() {
+  const cwd = process.cwd();
+  return STRAY_BROWSER_ARTIFACT_DIRS.filter((rel) => {
+    try {
+      return (0, import_node_fs14.existsSync)((0, import_node_path13.join)(cwd, rel));
+    } catch {
+      return false;
+    }
+  });
+}
 function readGitignore() {
   try {
     return (0, import_node_fs14.readFileSync)(gitignorePath(), "utf8");
@@ -15237,6 +15936,27 @@ async function runDoctor(opts, io = consoleIo) {
       hubCheckout: hubCheckoutForCursorSeed()
     })
   );
+  const cursorPins = cursorPluginCachePinSnapshots() ?? [];
+  checks.push(
+    buildCursorHookCliCheck({
+      isOrgRepo: Boolean(cfg.sagaApiUrl),
+      surface,
+      pins: cursorPins,
+      mmiCliOnPath: onPath
+    })
+  );
+  checks.push(
+    buildPlaywrightMcpVisionCapCheck({
+      isOrgRepo: Boolean(cfg.sagaApiUrl),
+      configs: playwrightMcpConfigSnapshots()
+    })
+  );
+  checks.push(
+    buildBrowserArtifactsCheck({
+      isOrgRepo: Boolean(cfg.sagaApiUrl),
+      strayPaths: strayBrowserArtifactPaths()
+    })
+  );
   const gaps = checks.filter((c) => !c.ok);
   if (opts.banner) {
     if (gaps.length) io.log(`\u26A0 MMI setup needed \u2014 ${gaps.map((g) => g.fix).join(" \xB7 ")} \xB7 guide: ${MMI_AGENTIC_ONBOARDING_GUIDE.url}`);
@@ -15265,7 +15985,7 @@ async function runDoctor(opts, io = consoleIo) {
   io.log(gaps.length ? `
 ${gaps.length} item(s) need attention.` : "\nAll set \u2014 you are ready.");
 }
-program2.command("doctor").description("check onboarding gates (GitHub auth, mmi-cli on PATH, Hub API default, plugin git clone, plugin install record, .gitignore managed block, plugin config drift, installed plugin version, Cursor Team Marketplace plugin install), print fixes, and report per-surface versions + update recipes").option("--banner", "one-line resume summary; silent when all gates pass").option("--guide", "print the MMI Agentic Onboarding guide URL").option("--json", "machine-readable output (read-only inspection \u2014 performs no repairs)").option("--apply", "perform the same auto-repairs as the interactive run (combine with --json for a machine-readable repair run)").option("--no-repo-writes", "env/plugin repairs only \u2014 never mutate the repo working tree; report pending managed .gitignore repairs with the follow-up command (for train preflights)").action((opts) => (
+program2.command("doctor").description("check onboarding gates (GitHub auth, mmi-cli on PATH, Hub API default, plugin git clone, plugin install record, .gitignore managed block, plugin config drift, installed plugin version, Cursor Team Marketplace plugin install, Playwright MCP vision caps, browser artifact hygiene), print fixes, and report per-surface versions + update recipes").option("--banner", "one-line resume summary; silent when all gates pass").option("--guide", "print the MMI Agentic Onboarding guide URL").option("--json", "machine-readable output (read-only inspection \u2014 performs no repairs)").option("--apply", "perform the same auto-repairs as the interactive run (combine with --json for a machine-readable repair run)").option("--no-repo-writes", "env/plugin repairs only \u2014 never mutate the repo working tree; report pending managed .gitignore repairs with the follow-up command (for train preflights)").action((opts) => (
   // Commander maps `--no-repo-writes` to `repoWrites: false`; translate to the explicit `noRepoWrites` flag.
   runDoctor({ ...opts, noRepoWrites: opts.repoWrites === false })
 ));