@mutmutco/cli 2.35.0 → 2.36.0

package/dist/main.cjs

@@ -3392,7 +3392,7 @@ var program = new Command();
 
 // src/index.ts
 var import_promises5 = require("node:fs/promises");
-var import_node_fs16 = require("node:fs");
+var import_node_fs18 = require("node:fs");
 
 // src/rules-sync.ts
 function normalizeEol(s) {
@@ -4447,6 +4447,7 @@ function buildNoteCapture(summary, o, id, evidence) {
     next: o.next,
     decision: o.decision,
     queueOp,
+    handoffClose: o.handoffClose,
     state,
     source,
     evidence: Object.keys(ev).length ? ev : void 0,
@@ -5080,6 +5081,260 @@ function registerSagaCommands(program3) {
   });
 }
 
+// src/handoff-commands.ts
+var import_node_crypto4 = require("node:crypto");
+
+// src/handoff.ts
+var HANDOFF_PREFIX = "handoff:";
+function clean(value) {
+  return value?.trim() ?? "";
+}
+function normalizeHandoffKey(value) {
+  const key = clean(value);
+  if (!key) throw new Error("handoff key is required");
+  return key;
+}
+function serializeHandoff(record) {
+  return `${HANDOFF_PREFIX}${JSON.stringify(record)}`;
+}
+function parseHandoffText(text) {
+  if (!text.startsWith(HANDOFF_PREFIX)) return null;
+  try {
+    const raw = JSON.parse(text.slice(HANDOFF_PREFIX.length));
+    const state = raw.state;
+    const key = clean(raw.key);
+    const northStarSlug = clean(raw.northStarSlug);
+    const summary = clean(raw.summary);
+    const sourceSessionId = clean(raw.sourceSessionId);
+    const createdAt = clean(raw.createdAt);
+    if (state !== "open" && state !== "claimed" && state !== "cancelled") return null;
+    if (!key || !northStarSlug || !summary || !sourceSessionId || !createdAt) return null;
+    return {
+      state,
+      key,
+      northStarSlug,
+      summary,
+      sourceSessionId,
+      createdAt,
+      claimedBySessionId: clean(raw.claimedBySessionId) || void 0,
+      closedAt: clean(raw.closedAt) || void 0
+    };
+  } catch {
+    return null;
+  }
+}
+function listHandoffs(head, opts = {}) {
+  const parsed = (head.queued ?? []).map((item, index) => ({ done: item.done, index, record: parseHandoffText(item.text) })).filter((x) => x.record !== null);
+  return parsed.filter((x) => opts.includeClosed || x.record.state === "open" && !x.done).map((x) => ({ index: x.index, done: x.done, record: x.record }));
+}
+function findOpenHandoff(head, key) {
+  const normalized = normalizeHandoffKey(key).toLowerCase();
+  return listHandoffs(head).find((item) => item.record.key.toLowerCase() === normalized || item.record.northStarSlug.toLowerCase() === normalized);
+}
+function planOpenHandoff(input) {
+  const key = normalizeHandoffKey(input.key);
+  const northStarSlug = clean(input.northStarSlug);
+  const summary = clean(input.summary);
+  const sourceSessionId = clean(input.sourceSessionId);
+  if (!northStarSlug) throw new Error("north star slug is required");
+  if (!summary) throw new Error("handoff summary is required");
+  if (!sourceSessionId) throw new Error("source session id is required");
+  return {
+    state: "open",
+    key,
+    northStarSlug,
+    summary,
+    sourceSessionId,
+    createdAt: input.createdAt
+  };
+}
+function closeHandoff(record, state, at, claimedBySessionId) {
+  return {
+    ...record,
+    state,
+    closedAt: at,
+    claimedBySessionId: claimedBySessionId || record.claimedBySessionId
+  };
+}
+function formatHandoffLine(item) {
+  const r = item.record;
+  const suffix = r.state === "claimed" && r.claimedBySessionId ? ` -> ${r.claimedBySessionId}` : "";
+  return `${r.key} [${r.state}] northstar:${r.northStarSlug} source:${r.sourceSessionId}${suffix} - ${r.summary}`;
+}
+
+// src/handoff-commands.ts
+var FOREGROUND_FETCH = { attempts: 2, timeoutMs: 8e3 };
+var SESSION_START_FETCH = { attempts: 1, timeoutMs: 3e3 };
+async function fetchState(url, qs, retry = FOREGROUND_FETCH) {
+  const res = await fetchWithRetry(fetch, `${url}/saga/state?${qs}`, { headers: await hubHeaders() }, retry);
+  if (!res.ok) return null;
+  const body = await res.json();
+  if ("state" in body) return body;
+  return { key: null, state: { head: body.head } };
+}
+async function fetchScopedSessions(url, project2, branch, retry = FOREGROUND_FETCH) {
+  const qs = new URLSearchParams({ project: project2, branch });
+  const res = await fetchWithRetry(fetch, `${url}/saga/sessions?${qs}`, { headers: await hubHeaders() }, retry);
+  if (!res.ok) return [];
+  const body = await res.json();
+  return body.sessions ?? [];
+}
+async function fetchSessionHead(url, key, retry = FOREGROUND_FETCH) {
+  const qs = new URLSearchParams(key);
+  const got = await fetchState(url, qs, retry);
+  return got?.state?.head ?? null;
+}
+async function fetchCurrentState() {
+  const cfg = await loadConfig();
+  if (!cfg.sagaApiUrl) return null;
+  const key = await sagaKey(cfg);
+  const got = await fetchState(cfg.sagaApiUrl, new URLSearchParams(key));
+  return got ? { key, head: got.state?.head ?? {} } : null;
+}
+async function collectScopedHandoffs(opts = {}) {
+  const cfg = await loadConfig();
+  if (!cfg.sagaApiUrl) return { handoffs: [], sessions: [] };
+  const key = await sagaKey(cfg);
+  const retry = opts.retry ?? FOREGROUND_FETCH;
+  const sessions = await fetchScopedSessions(cfg.sagaApiUrl, key.project, key.branch, retry);
+  const seen = /* @__PURE__ */ new Set();
+  const handoffs = [];
+  for (const session of sessions) {
+    const head = await fetchSessionHead(cfg.sagaApiUrl, session, retry);
+    if (!head) continue;
+    for (const item of listHandoffs(head, { includeClosed: opts.includeClosed })) {
+      const dedupe = `${item.record.sourceSessionId}:${item.record.key}:${item.record.state}`;
+      if (seen.has(dedupe)) continue;
+      seen.add(dedupe);
+      handoffs.push(item);
+    }
+  }
+  return { handoffs, sessions };
+}
+async function locateOpenHandoff(key, retry = FOREGROUND_FETCH) {
+  const cfg = await loadConfig();
+  if (!cfg.sagaApiUrl) return null;
+  const scopeKey = await sagaKey(cfg);
+  const sessions = await fetchScopedSessions(cfg.sagaApiUrl, scopeKey.project, scopeKey.branch, retry);
+  for (const session of sessions) {
+    const head = await fetchSessionHead(cfg.sagaApiUrl, session, retry);
+    if (!head) continue;
+    const item = findOpenHandoff(head, key);
+    if (item) {
+      return {
+        key: { project: session.project, branch: session.branch, sessionId: session.sessionId },
+        item
+      };
+    }
+  }
+  return null;
+}
+async function locateClaimedHandoff(key, claimedBySessionId, retry = FOREGROUND_FETCH) {
+  const { handoffs } = await collectScopedHandoffs({ includeClosed: true, retry });
+  const normalized = key.toLowerCase();
+  return handoffs.find((item) => {
+    const r = item.record;
+    return r.state === "claimed" && r.claimedBySessionId === claimedBySessionId && (r.key.toLowerCase() === normalized || r.northStarSlug.toLowerCase() === normalized);
+  }) ?? null;
+}
+async function postKeyedNote(key, summary, options) {
+  const cfg = await loadConfig();
+  if (!cfg.sagaApiUrl) fail("handoff: Hub API URL not configured");
+  const sha = await gitOut(["rev-parse", "--short", "HEAD"]);
+  const capture = buildNoteCapture(summary, options, (0, import_node_crypto4.randomUUID)(), { sha: sha || void 0, branch: key.branch });
+  const result = await postCaptureOnce(cfg.sagaApiUrl, { ...capture, ...key });
+  if (!result.ok) fail(`handoff: write failed${result.status ? ` (HTTP ${result.status})` : ""}${result.message ? `: ${result.message}` : ""}`);
+}
+function deriveOpenFields(summary, opts, head, key) {
+  const northStarSlug = opts.northStarSlug ?? head.anchor?.slug;
+  const handoffKey = opts.key ?? northStarSlug;
+  const text = summary?.trim() || head.next?.trim() || head.anchor?.intent?.trim();
+  return planOpenHandoff({
+    key: handoffKey ?? "",
+    northStarSlug: northStarSlug ?? "",
+    summary: text ?? "",
+    sourceSessionId: key.sessionId,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+}
+async function runHandoffOpen(summary, opts, io = consoleIo) {
+  const current = await fetchCurrentState();
+  if (!current) return fail("handoff open: saga state unavailable");
+  let record;
+  try {
+    record = deriveOpenFields(summary, opts, current.head, current.key);
+  } catch (e) {
+    return fail(`handoff open: ${e.message}`);
+  }
+  await postKeyedNote(current.key, `handoff opened ${record.key}`, { queueAdd: serializeHandoff(record), anchorSlug: record.northStarSlug });
+  if (opts.json) return io.log(JSON.stringify({ ok: true, handoff: record }));
+  io.log(`handoff open: ${formatHandoffLine({ index: -1, done: false, record })}`);
+}
+async function runHandoffList(opts, io = consoleIo) {
+  const { handoffs } = await collectScopedHandoffs({ includeClosed: opts.all });
+  if (opts.json) {
+    io.log(JSON.stringify({ handoffs }, null, 2));
+  } else if (!handoffs.length) {
+    io.log("handoff list: none");
+  } else {
+    for (const h of handoffs) io.log(formatHandoffLine(h));
+  }
+  return handoffs;
+}
+async function runHandoffOffer(io = consoleIo, opts = {}) {
+  const retry = opts.fast ? SESSION_START_FETCH : FOREGROUND_FETCH;
+  const { handoffs } = await collectScopedHandoffs({ retry });
+  if (!handoffs.length) return;
+  io.log("Open handoffs:");
+  for (const h of handoffs) io.log(`- ${formatHandoffLine(h)}`);
+  io.log("Use `mmi-cli handoff accept <key>` to claim, `mmi-cli handoff cancel <key>` to close, or decline in chat to leave it open.");
+}
+async function closeSourceHandoff(key, state, opts = {}, io = consoleIo) {
+  const current = await sagaKey(await loadConfig(), resolveSessionId());
+  const located = await locateOpenHandoff(key);
+  if (!located) {
+    if (state === "claimed") {
+      const prior = await locateClaimedHandoff(key, current.sessionId);
+      if (prior) {
+        if (opts.json) return io.log(JSON.stringify({ ok: true, handoff: prior.record, idempotent: true }));
+        return io.log(`handoff claimed: ${formatHandoffLine(prior)} (already accepted)`);
+      }
+    }
+    return fail(`handoff ${state}: no open handoff matching ${key}`);
+  }
+  const closed = closeHandoff(located.item.record, state, (/* @__PURE__ */ new Date()).toISOString(), state === "claimed" ? current.sessionId : void 0);
+  await postKeyedNote(located.key, `handoff ${state} ${located.item.record.key}`, {
+    handoffClose: { index: located.item.index, closedText: serializeHandoff(closed) }
+  });
+  if (state === "claimed") {
+    await postKeyedNote(current, `handoff accepted ${located.item.record.key}`, {
+      anchor: located.item.record.summary,
+      anchorSlug: located.item.record.northStarSlug,
+      anchorForce: true,
+      decision: `accepted handoff ${located.item.record.key} from session ${located.item.record.sourceSessionId}; northstar ${located.item.record.northStarSlug}`,
+      verified: true
+    });
+  }
+  if (opts.json) return io.log(JSON.stringify({ ok: true, handoff: closed }));
+  io.log(`handoff ${state}: ${formatHandoffLine({ index: located.item.index, done: true, record: closed })}`);
+}
+async function runHandoffDecline(key, opts = {}, io = consoleIo) {
+  const located = await locateOpenHandoff(key);
+  if (!located) return fail(`handoff decline: no open handoff matching ${key}`);
+  if (opts.json) return io.log(JSON.stringify({ ok: true, unchanged: true, handoff: located.item.record }));
+  io.log(`handoff decline: left open for re-offer \u2014 ${formatHandoffLine(located.item)}`);
+}
+function registerHandoffCommands(program3) {
+  const handoff = program3.command("handoff").description("explicit saga + North Star handoff lifecycle");
+  handoff.command("open [summary]").description("open a handoff bound to the current North Star slug").option("--key <slug|#issue>", "handoff key (defaults to the current North Star slug)").option("--north-star-slug <slug>", "North Star slug to bind (defaults to current saga anchor slug)").option("--json", "machine-readable output").action((summary, opts) => runHandoffOpen(summary, opts));
+  handoff.command("list").description("list open handoffs for the current repo/branch").option("--all", "include claimed/cancelled records").option("--json", "machine-readable output").action(async (opts) => {
+    await runHandoffList(opts);
+  });
+  handoff.command("accept <key>").description("claim an open handoff and bind this session to its North Star").option("--json", "machine-readable output").action((key, opts) => closeSourceHandoff(key, "claimed", opts));
+  handoff.command("cancel <key>").description("close an open handoff without claiming it").option("--json", "machine-readable output").action((key, opts) => closeSourceHandoff(key, "cancelled", opts));
+  handoff.command("decline <key>").description("leave an open handoff unchanged so it is re-offered later").option("--json", "machine-readable output").action((key, opts) => runHandoffDecline(key, opts));
+}
+
 // src/honcho-commands.ts
 var import_node_child_process5 = require("node:child_process");
 var import_promises3 = require("node:fs/promises");
@@ -5640,7 +5895,7 @@ async function resolveHonchoConfig(cfg = {}, opts = {}) {
 }
 
 // src/honcho-ingest.ts
-var import_node_crypto4 = require("node:crypto");
+var import_node_crypto5 = require("node:crypto");
 var DEFAULT_HONCHO_MAX_CHARS = 4e3;
 var DEFAULT_HONCHO_CARD_MAX_CHARS = 1200;
 var REDACTED = "[REDACTED]";
@@ -5726,7 +5981,7 @@ function buildIngestPayload(args) {
   const maxChars = args.maxChars ?? DEFAULT_HONCHO_MAX_CHARS;
   const messages = args.messages.map((m) => ({ role: m.role, content: capContent(redactSecrets(m.content), maxChars) })).filter((m) => m.content.trim().length > 0);
   return {
-    id: args.id ?? (0, import_node_crypto4.randomUUID)(),
+    id: args.id ?? (0, import_node_crypto5.randomUUID)(),
     workspace: args.workspace,
     peer: args.peer,
     session: args.session,
@@ -6225,8 +6480,205 @@ async function syncDocs(deps, docs2 = SYNCED_DOCS) {
 }
 
 // src/session-start.ts
+var import_node_fs12 = require("node:fs");
+var import_node_path10 = require("node:path");
+
+// src/scratch-gc.ts
 var import_node_fs11 = require("node:fs");
 var import_node_path9 = require("node:path");
+var TMP_STALE_MS = 6e4;
+var FLUSH_LOCK_GC_MS = 6e5;
+var HEAD_TS_STALE_MS = 48 * 36e5;
+var LAST_SKIP_STALE_MS = 24 * 36e5;
+var CONFLICT_COPY_STALE_MS = 24 * 36e5;
+var PLAN_ADVISORY_AGE_MS = 30 * 24 * 36e5;
+var SCRATCH_GC_THROTTLE_MS = 24 * 36e5;
+function scratchGcThrottlePath(mmiRoot) {
+  return (0, import_node_path9.join)(mmiRoot, "head-ts", ".scratch-gc-last");
+}
+function scratchGcDue(stampPath, now = Date.now(), read = import_node_fs11.readFileSync) {
+  try {
+    return now - (Number(read(stampPath, "utf8").trim()) || 0) >= SCRATCH_GC_THROTTLE_MS;
+  } catch {
+    return true;
+  }
+}
+function markScratchGcRun(stampPath, now = Date.now()) {
+  try {
+    (0, import_node_fs11.mkdirSync)((0, import_node_path9.dirname)(stampPath), { recursive: true });
+    (0, import_node_fs11.writeFileSync)(stampPath, String(now), "utf8");
+  } catch {
+  }
+}
+function executeScratchGc(repoRoot, opts, now = Date.now()) {
+  const snap = collectScratchSnapshot(repoRoot);
+  const plan2 = planScratchGc(snap, now);
+  if (!opts.apply) return { plan: plan2 };
+  return { plan: plan2, applied: applyScratchGc(plan2, snap.mmiRoot, now) };
+}
+var NEVER_BASENAMES = /* @__PURE__ */ new Set([".session", "config.json", "saga-pending.jsonl"]);
+var TMP_SIDECAR_BASES = ["saga-pending.jsonl", "last-skip.json"];
+var CONFLICT_COPY_ALLOWLIST = /* @__PURE__ */ new Set(["saga-pending.jsonl", "last-skip.json"]);
+function conflictCopyOriginal(name) {
+  const m = /^(.+) \d+(\.[^.]+)$/.exec(name);
+  return m ? `${m[1]}${m[2]}` : null;
+}
+function isTmpSidecar(name) {
+  return name.endsWith(".tmp") && TMP_SIDECAR_BASES.some((b) => name.startsWith(`${b}.`));
+}
+function planScratchGc(snap, now = Date.now()) {
+  const candidates = [];
+  const normalizePath = (p) => p.replace(/\\/g, "/");
+  const mmiPaths = new Set(snap.mmiFiles.map((f) => normalizePath(f.path)));
+  const headTsPrefix = `${snap.mmiRoot.replace(/[\\/]+$/, "")}/head-ts/`.replace(/\\/g, "/");
+  const days = (ms) => `${Math.floor(ms / 864e5)}d`;
+  for (const f of snap.mmiFiles) {
+    const age = now - f.mtimeMs;
+    const add = (family, reason) => candidates.push({ path: f.path, family, tier: "safe-auto", reason, bytes: f.bytes });
+    if (isTmpSidecar(f.name)) {
+      if (age > TMP_STALE_MS) add("tmp-sidecar", `crashed atomic-write sidecar (${days(age)} old)`);
+      continue;
+    }
+    if (f.name === "saga-flush.lock") {
+      if (age > FLUSH_LOCK_GC_MS) add("flush-lock", `abandoned flush lock (${days(age)} old)`);
+      continue;
+    }
+    if (NEVER_BASENAMES.has(f.name)) continue;
+    if (f.path.replace(/\\/g, "/").startsWith(headTsPrefix) && !f.name.startsWith(".")) {
+      if (age > HEAD_TS_STALE_MS) add("head-ts", `stale throttle stamp (${days(age)} old)`);
+      continue;
+    }
+    if (f.name === "last-skip.json") {
+      if (age > LAST_SKIP_STALE_MS) add("last-skip", `stale ingest-skip hint (${days(age)} old)`);
+      continue;
+    }
+    const orig = conflictCopyOriginal(f.name);
+    if (orig && CONFLICT_COPY_ALLOWLIST.has(orig) && mmiPaths.has(normalizePath((0, import_node_path9.join)(f.dir, orig))) && age > CONFLICT_COPY_STALE_MS) {
+      add("conflict-copy", `cloud-sync conflict copy of ${orig} (${days(age)} old)`);
+    }
+  }
+  if (snap.syncQueueSlugs) {
+    for (const f of snap.planMdFiles) {
+      const slug = f.name.replace(/\.md$/, "");
+      if (snap.syncQueueSlugs.has(slug)) continue;
+      if (now - f.mtimeMs > PLAN_ADVISORY_AGE_MS) {
+        candidates.push({
+          path: f.path,
+          family: "plan",
+          tier: "advisory",
+          reason: `synced plan older than ${Math.floor(PLAN_ADVISORY_AGE_MS / 864e5)}d`,
+          bytes: f.bytes
+        });
+      }
+    }
+  }
+  return {
+    candidates,
+    safeAuto: candidates.filter((c) => c.tier === "safe-auto"),
+    advisory: candidates.filter((c) => c.tier === "advisory")
+  };
+}
+function formatScratchGcPlan(plan2, applied) {
+  if (plan2.candidates.length === 0) return "scratch GC: nothing to prune \u2014 local saga/plan/honcho scratch is clean.";
+  const lines = [];
+  const bytes = plan2.safeAuto.reduce((n, c) => n + c.bytes, 0);
+  lines.push(
+    `scratch GC: ${applied ? "pruned" : "would prune"} ${plan2.safeAuto.length} stale file(s) (${bytes} bytes)` + (plan2.advisory.length ? `; ${plan2.advisory.length} advisory (kept):` : ":")
+  );
+  for (const c of plan2.safeAuto.slice(0, 40)) lines.push(`  - [${c.family}] ${c.path} \u2014 ${c.reason}`);
+  if (plan2.safeAuto.length > 40) lines.push(`  ... +${plan2.safeAuto.length - 40} more`);
+  for (const c of plan2.advisory.slice(0, 20)) lines.push(`  \xB7 [advisory] ${c.path} \u2014 ${c.reason} (kept; review manually)`);
+  return lines.join("\n");
+}
+function scratchGcBannerLine(safeAutoPruned, advisory) {
+  const parts = [];
+  if (safeAutoPruned > 0) parts.push(`pruned ${safeAutoPruned} stale local file(s)`);
+  if (advisory > 0) parts.push(`${advisory} old synced plan(s) prunable \u2014 \`mmi-cli gc --scratch --dry-run\` to review`);
+  return parts.length ? `[cleanup] ${parts.join("; ")}` : void 0;
+}
+function applyScratchGc(plan2, mmiRoot, now = Date.now()) {
+  const result = { pruned: [], skipped: 0, bytes: 0 };
+  let anchor;
+  try {
+    anchor = (0, import_node_fs11.realpathSync)(mmiRoot).replace(/\\/g, "/").replace(/\/+$/, "");
+  } catch {
+    return result;
+  }
+  for (const c of plan2.safeAuto) {
+    try {
+      const real = (0, import_node_fs11.realpathSync)(c.path).replace(/\\/g, "/");
+      if (real !== anchor && !real.startsWith(`${anchor}/`)) {
+        result.skipped += 1;
+        continue;
+      }
+      const st = (0, import_node_fs11.statSync)(c.path);
+      const floor = c.family === "flush-lock" ? FLUSH_LOCK_GC_MS : c.family === "tmp-sidecar" ? TMP_STALE_MS : c.family === "head-ts" ? HEAD_TS_STALE_MS : c.family === "last-skip" ? LAST_SKIP_STALE_MS : CONFLICT_COPY_STALE_MS;
+      if (now - st.mtimeMs <= floor) {
+        result.skipped += 1;
+        continue;
+      }
+      (0, import_node_fs11.unlinkSync)(c.path);
+      result.pruned.push(c.path);
+      result.bytes += c.bytes;
+    } catch {
+      result.skipped += 1;
+    }
+  }
+  return result;
+}
+function collectScratchSnapshot(repoRoot, deps = {}) {
+  const readdir = deps.readdir ?? import_node_fs11.readdirSync;
+  const stat = deps.stat ?? import_node_fs11.statSync;
+  const readFile5 = deps.readFile ?? import_node_fs11.readFileSync;
+  const mmiRoot = (0, import_node_path9.join)(repoRoot, ".mmi");
+  const plansRoot = (0, import_node_path9.join)(repoRoot, "plans");
+  const mmiFiles = [];
+  try {
+    for (const ent of readdir(mmiRoot, { recursive: true, withFileTypes: true })) {
+      if (!ent.isFile()) continue;
+      const dir = ent.parentPath ?? ent.path ?? mmiRoot;
+      const full = (0, import_node_path9.join)(dir, ent.name);
+      try {
+        const st = stat(full);
+        mmiFiles.push({ path: full, dir, name: ent.name, mtimeMs: st.mtimeMs, bytes: st.size });
+      } catch {
+      }
+    }
+  } catch {
+  }
+  const planMdFiles = [];
+  try {
+    for (const ent of readdir(plansRoot, { withFileTypes: true })) {
+      if (!ent.isFile() || !ent.name.endsWith(".md")) continue;
+      const full = (0, import_node_path9.join)(plansRoot, ent.name);
+      try {
+        const st = stat(full);
+        planMdFiles.push({ path: full, dir: plansRoot, name: ent.name, mtimeMs: st.mtimeMs, bytes: st.size });
+      } catch {
+      }
+    }
+  } catch {
+  }
+  let syncQueueSlugs = null;
+  let queueRaw;
+  try {
+    queueRaw = readFile5((0, import_node_path9.join)(plansRoot, ".sync-queue.json"), "utf8");
+  } catch {
+    syncQueueSlugs = /* @__PURE__ */ new Set();
+  }
+  if (queueRaw !== void 0) {
+    try {
+      const parsed = JSON.parse(queueRaw);
+      const entries = Array.isArray(parsed) ? parsed : parsed.entries ?? [];
+      syncQueueSlugs = new Set(entries.map((e) => e.slug).filter((s) => typeof s === "string"));
+    } catch {
+      syncQueueSlugs = null;
+    }
+  }
+  return { mmiRoot, mmiFiles, planMdFiles, syncQueueSlugs };
+}
+
+// src/session-start.ts
 async function runBufferedStep(step) {
   const lines = [];
   const io = {
@@ -6254,6 +6706,7 @@ function buildSessionStartPlan(verbs) {
     parallel: [
       { name: "rules sync", run: verbs.rulesSync },
       { name: "saga show", run: verbs.sagaShow },
+      { name: "handoff offer", run: verbs.handoffOffer },
       // honcho profile (#1162): the behavioral-memory prior, flushed right after the saga resume. A fast
       // peer-card GET, fail-soft + silent when off/empty — it never hangs or noises the banner.
       { name: "honcho profile", run: verbs.honchoContext },
@@ -6277,12 +6730,12 @@ function spawnDetachedSelf(args, deps) {
 }
 function planStoreLines(cwd) {
   const mdFiles = (dir, minSize = 0) => {
-    const p = (0, import_node_path9.join)(cwd, dir);
-    if (!(0, import_node_fs11.existsSync)(p)) return [];
+    const p = (0, import_node_path10.join)(cwd, dir);
+    if (!(0, import_node_fs12.existsSync)(p)) return [];
     try {
-      return (0, import_node_fs11.readdirSync)(p).filter((f) => f.toLowerCase().endsWith(".md")).filter((f) => {
+      return (0, import_node_fs12.readdirSync)(p).filter((f) => f.toLowerCase().endsWith(".md")).filter((f) => {
         try {
-          return (0, import_node_fs11.statSync)((0, import_node_path9.join)(p, f)).size >= minSize;
+          return (0, import_node_fs12.statSync)((0, import_node_path10.join)(p, f)).size >= minSize;
         } catch {
           return false;
         }
@@ -6300,6 +6753,19 @@ function planStoreLines(cwd) {
     out.push(`[plan-store] ${localPlans.length} local plan(s) in plans/ \u2014 ensure new/changed ones are \`mmi-cli plan push\`ed (S3-backed, not git).`);
   return out;
 }
+function scratchGcLines(cwd, env = process.env, now = Date.now()) {
+  if (env.MMI_NO_AUTO_GC) return [];
+  try {
+    const stamp = scratchGcThrottlePath((0, import_node_path10.join)(cwd, ".mmi"));
+    if (!scratchGcDue(stamp, now)) return [];
+    const run = executeScratchGc(cwd, { apply: true }, now);
+    markScratchGcRun(stamp, now);
+    const line = scratchGcBannerLine(run.applied?.pruned.length ?? 0, run.plan.advisory.length);
+    return line ? [line] : [];
+  } catch {
+    return [];
+  }
+}
 function northstarPointer(injected = false) {
   if (injected) {
     return "North Stars: `mmi-cli northstar relevant` for more matches; `northstar pull <slug>` for the full SSOT.";
@@ -6347,6 +6813,71 @@ function recoverPriorityFromEvents(events) {
   return found;
 }
 
+// src/board-dependency.ts
+var DEPENDS_ON_LINE = /^\s*[-*]?\s*\*\*Depends on:\*\*\s*(.+)$/im;
+var ISSUE_REF = /([a-zA-Z0-9_.-]+\/[a-zA-Z0-9_.-]+)#(\d+)/g;
+function parseDependsOnRefs(body) {
+  const match = body.match(DEPENDS_ON_LINE);
+  if (!match) return [];
+  const refs = [];
+  for (const m of match[1].matchAll(ISSUE_REF)) {
+    refs.push({ repo: m[1], number: Number(m[2]) });
+  }
+  return refs;
+}
+async function issueOpen(client, repo, number) {
+  try {
+    const data = await client.rest("GET", `repos/${repo}/issues/${number}`);
+    return data?.state === "OPEN";
+  } catch {
+    return void 0;
+  }
+}
+async function dependencyBlocksClaim(client, body) {
+  const refs = parseDependsOnRefs(body);
+  if (!refs.length) return { blocked: false, openDependencies: [] };
+  const openDependencies = [];
+  for (const ref of refs) {
+    const open = await issueOpen(client, ref.repo, ref.number);
+    if (open === true) openDependencies.push(`${ref.repo}#${ref.number}`);
+  }
+  return { blocked: openDependencies.length > 0, openDependencies };
+}
+async function filterDependencyBlockedClaimables(items, client, opts = {}) {
+  const claimable = [];
+  const blocked = [];
+  const warnings = [];
+  for (const item of items) {
+    if (item.contentType !== "Issue") {
+      claimable.push(item);
+      continue;
+    }
+    let body = item.details?.body;
+    if (body === void 0) {
+      if (opts.requireBundledBody) {
+        claimable.push(item);
+        continue;
+      }
+      try {
+        const data = await client.rest("GET", `repos/${item.repository}/issues/${item.number}`);
+        body = data?.body ?? "";
+      } catch (e) {
+        warnings.push(`dependency check skipped for ${item.ref}: ${e.message}`);
+        claimable.push(item);
+        continue;
+      }
+    }
+    const gate = await dependencyBlocksClaim(client, body);
+    if (gate.blocked) {
+      blocked.push(item);
+      warnings.push(`${item.ref} blocked on open ${gate.openDependencies.join(", ")}`);
+    } else {
+      claimable.push(item);
+    }
+  }
+  return { claimable, blocked, warnings };
+}
+
 // ../infra/board-vocab.mjs
 var BOARD_STATUSES = ["Todo", "In Progress", "In Review", "Done"];
 
@@ -6670,6 +7201,13 @@ async function readBoard(options, deps = {}) {
   if (options.includeBundleDetails) {
     await attachBundleDetails(report, client, options.allowPartial ?? false);
   }
+  for (const scope of ["primary", "secondary"]) {
+    const filtered = await filterDependencyBlockedClaimables(report[scope].claimable, client, {
+      requireBundledBody: Boolean(options.includeBundleDetails)
+    });
+    report[scope].claimable = filtered.claimable;
+    report.warnings.push(...filtered.warnings);
+  }
   return report;
 }
 function findBoardItem(items, selector) {
@@ -6751,6 +7289,11 @@ async function prepareClaimContext(options, selectors, deps, collected) {
     warnings: collected.warnings,
     partial: collected.partial
   };
+  for (const scope of ["primary", "secondary"]) {
+    const filtered = await filterDependencyBlockedClaimables(report[scope].claimable, client);
+    report[scope].claimable = filtered.claimable;
+    report.warnings.push(...filtered.warnings);
+  }
   return { cfg, client, items: collected.items, writable: writable.repos, report };
 }
 async function claimOneBoardItem(ctx, selector, options) {
@@ -6759,6 +7302,21 @@ async function claimOneBoardItem(ctx, selector, options) {
   if (flatItem.status === "Todo" && flatItem.assignees.length === 0 && !ctx.writable.has(flatItem.repository.toLowerCase())) {
     throw new Error(`${flatItem.ref} is not claimable: viewer does not have write access to ${flatItem.repository}`);
   }
+  if (flatItem.contentType === "Issue") {
+    let body = flatItem.details?.body;
+    if (body === void 0) {
+      try {
+        const data = await client.rest("GET", `repos/${flatItem.repository}/issues/${flatItem.number}`);
+        body = data?.body ?? "";
+      } catch {
+        body = "";
+      }
+    }
+    const gate = await dependencyBlocksClaim(client, body);
+    if (gate.blocked) {
+      throw new Error(`${flatItem.ref} is not claimable: blocked on open ${gate.openDependencies.join(", ")}`);
+    }
+  }
   let item = findClaimableItem(report, selector);
   if (item.contentType !== "Issue") throw new Error(`${item.ref} is not an issue`);
   const fresh = (await fetchIssueProjectItem(client, cfg, { repo: item.repository, number: item.number })).item;
@@ -7209,6 +7767,109 @@ async function runBoardSlice(io, deps, opts) {
   }
 }
 
+// src/worktree.ts
+var import_node_fs13 = require("node:fs");
+var import_node_path11 = require("node:path");
+var LOCAL_ONLY_FILES = [".claude/settings.local.json"];
+var PKG = "package.json";
+var LOCKFILE = "package-lock.json";
+var NODE_MODULES = "node_modules";
+var realFsProbe = {
+  isDir: (p) => {
+    try {
+      return (0, import_node_fs13.statSync)(p).isDirectory();
+    } catch {
+      return false;
+    }
+  },
+  isFile: (p) => {
+    try {
+      return (0, import_node_fs13.statSync)(p).isFile();
+    } catch {
+      return false;
+    }
+  },
+  listDirs: (p) => {
+    try {
+      return (0, import_node_fs13.readdirSync)(p, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+    } catch {
+      return [];
+    }
+  }
+};
+function scanInstallDirs(root, fs2 = realFsProbe) {
+  const factsFor = (dir) => {
+    const abs = dir ? (0, import_node_path11.join)(root, dir) : root;
+    return {
+      dir,
+      hasPackageJson: fs2.isFile((0, import_node_path11.join)(abs, PKG)),
+      hasLockfile: fs2.isFile((0, import_node_path11.join)(abs, LOCKFILE)),
+      hasNodeModules: fs2.isDir((0, import_node_path11.join)(abs, NODE_MODULES))
+    };
+  };
+  const children = fs2.listDirs(root).filter((name) => name !== NODE_MODULES && name !== ".git");
+  return [factsFor(""), ...children.map(factsFor).filter((f) => f.hasPackageJson)];
+}
+function npmInstallTargets(dirs) {
+  return dirs.filter((d) => d.hasPackageJson && !d.hasNodeModules).map((d) => ({ dir: d.dir, command: d.hasLockfile ? "npm ci" : "npm install" }));
+}
+function isLinkedWorktree(root, fs2 = realFsProbe) {
+  return fs2.isFile((0, import_node_path11.join)(root, ".git"));
+}
+function worktreeAutoProvisionBanner(root, fs2 = realFsProbe) {
+  if (!isLinkedWorktree(root, fs2)) return null;
+  const pending = npmInstallTargets(scanInstallDirs(root, fs2));
+  if (!pending.length) return null;
+  const where = pending.map((t) => t.dir || ".").join(", ");
+  return `[worktree] provisioning tooling in the background (deps in ${where} + local config) \u2014 \`mmi-cli worktree setup\` to redo`;
+}
+function defaultCopyFile(from, to) {
+  (0, import_node_fs13.mkdirSync)((0, import_node_path11.dirname)(to), { recursive: true });
+  (0, import_node_fs13.copyFileSync)(from, to);
+}
+async function provisionWorktree(worktreeRoot, deps) {
+  const fs2 = deps.fs ?? realFsProbe;
+  const copyFile = deps.copyFile ?? defaultCopyFile;
+  const log = deps.log ?? (() => {
+  });
+  const allDirs = scanInstallDirs(worktreeRoot, fs2);
+  const targets = npmInstallTargets(allDirs);
+  const skippedInstall = allDirs.filter((d) => d.hasPackageJson && d.hasNodeModules).map((d) => d.dir);
+  const installed = [];
+  for (const target of targets) {
+    const cwd = target.dir ? (0, import_node_path11.join)(worktreeRoot, target.dir) : worktreeRoot;
+    log(`installing deps: ${target.command} in ${target.dir || "."}`);
+    await deps.runInstall(target.command, cwd);
+    installed.push(target);
+  }
+  const copied = [];
+  const copySkipped = [];
+  const primary = await deps.primaryCheckout();
+  for (const rel of LOCAL_ONLY_FILES) {
+    const dest = (0, import_node_path11.join)(worktreeRoot, rel);
+    if (fs2.isFile(dest)) {
+      copySkipped.push({ file: rel, reason: "already-present" });
+      continue;
+    }
+    if (!primary) {
+      copySkipped.push({ file: rel, reason: "no-primary" });
+      continue;
+    }
+    if (!fs2.isFile((0, import_node_path11.join)(primary, rel))) {
+      copySkipped.push({ file: rel, reason: "absent-in-primary" });
+      continue;
+    }
+    copyFile((0, import_node_path11.join)(primary, rel), dest);
+    copied.push(rel);
+    log(`copied local config: ${rel}`);
+  }
+  return { worktree: worktreeRoot, installed, skippedInstall, copied, copySkipped };
+}
+function defaultWorktreePath(repoRoot, branch) {
+  const safe = branch.replace(/[/\\]+/g, "-");
+  return (0, import_node_path11.join)((0, import_node_path11.dirname)(repoRoot), "mmi-worktrees", safe);
+}
+
 // src/frontmatter.ts
 function splitFrontmatter(content) {
   const match = /^---\n([\s\S]*?)\n---(?:\n|$)/.exec(content);
@@ -7404,7 +8065,7 @@ async function runNorthstarContext(io, deps) {
 }
 
 // src/index.ts
-var import_node_path14 = require("node:path");
+var import_node_path16 = require("node:path");
 
 // src/merge-ci-policy.ts
 function resolveMergeCiPolicy(input) {
@@ -7816,8 +8477,8 @@ var import_node_os5 = require("node:os");
 // src/gh-create.ts
 var import_promises4 = require("node:fs/promises");
 var import_node_os3 = require("node:os");
-var import_node_path10 = require("node:path");
-var import_node_crypto5 = require("node:crypto");
+var import_node_path12 = require("node:path");
+var import_node_crypto6 = require("node:crypto");
 var ISSUE_TYPES = ["bug", "feature", "task"];
 var GH_MUTATION_TIMEOUT_MS = 12e4;
 function timeoutKillNote(err, timeoutMs) {
@@ -7857,7 +8518,7 @@ async function bodyArgsViaFile(args, deps = {}) {
   } };
   const write = deps.write ?? import_promises4.writeFile;
   const remove = deps.remove ?? import_promises4.unlink;
-  const file = (0, import_node_path10.join)(deps.dir ?? (0, import_node_os3.tmpdir)(), `mmi-gh-body-${process.pid}-${(0, import_node_crypto5.randomBytes)(4).toString("hex")}.md`);
+  const file = (0, import_node_path12.join)(deps.dir ?? (0, import_node_os3.tmpdir)(), `mmi-gh-body-${process.pid}-${(0, import_node_crypto6.randomBytes)(4).toString("hex")}.md`);
   await write(file, args[i + 1], "utf8");
   return {
     args: [...args.slice(0, i), "--body-file", file, ...args.slice(i + 2)],
@@ -8182,7 +8843,7 @@ ${buildReportBody(body, sourceRepo)}`;
 
 // src/skill-lesson.ts
 var SKILL_LESSON_LABEL = "skill-lesson";
-var SKILL_NAMES = ["bootstrap", "browser-automation", "build", "grind", "hotfix", "mmi", "rcand", "release", "secrets", "stage"];
+var SKILL_NAMES = ["bootstrap", "browser-automation", "build", "grind", "handoff", "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(", ")}`);
@@ -8682,12 +9343,12 @@ function buildGcPlan(inputs) {
       skipped.push({ branch, reason: "current-branch" });
       continue;
     }
-    const worktree = worktrees.get(branch);
-    if (worktree?.dirty) {
-      skipped.push({ branch, reason: "dirty-worktree", detail: worktree.path });
+    const worktree2 = worktrees.get(branch);
+    if (worktree2?.dirty) {
+      skipped.push({ branch, reason: "dirty-worktree", detail: worktree2.path });
       continue;
     }
-    branches.push({ branch, prState: state.state, prNumbers: state.numbers, worktreePath: worktree?.path });
+    branches.push({ branch, prState: state.state, prNumbers: state.numbers, worktreePath: worktree2?.path });
   }
   const trackingRefs = [...new Set(inputs.staleTrackingRefs ?? [])].map((ref) => {
     const branch = branchForTrackingRef(ref, remote);
@@ -9226,9 +9887,9 @@ function stalePosixFields(config, shell2) {
 }
 function sanitizeLocalStage(local, stale) {
   if (!stale.length) return local;
-  const clean3 = { ...local };
-  for (const field of stale) delete clean3[field];
-  return clean3;
+  const clean4 = { ...local };
+  for (const field of stale) delete clean4[field];
+  return clean4;
 }
 function staleNote(staleFields, outcome) {
   const list = staleFields.join(", ");
@@ -9274,9 +9935,9 @@ function decideStage(inputs) {
 
 // src/cursor-plugin-seed.ts
 var import_node_child_process7 = require("node:child_process");
-var import_node_fs12 = require("node:fs");
+var import_node_fs14 = require("node:fs");
 var import_node_os4 = require("node:os");
-var import_node_path11 = require("node:path");
+var import_node_path13 = require("node:path");
 var import_node_util6 = require("node:util");
 function isSemverVersion(v) {
   return typeof v === "string" && /^v?\d+\.\d+\.\d+/.test(v.trim());
@@ -9293,17 +9954,17 @@ function ghReleaseTarballApiArgs(tag) {
 }
 function cursorUserGlobalStatePath() {
   if (process.platform === "win32") {
-    const base2 = process.env.APPDATA || (0, import_node_path11.join)((0, import_node_os4.homedir)(), "AppData", "Roaming");
-    return (0, import_node_path11.join)(base2, "Cursor", "User", "globalStorage", "state.vscdb");
+    const base2 = process.env.APPDATA || (0, import_node_path13.join)((0, import_node_os4.homedir)(), "AppData", "Roaming");
+    return (0, import_node_path13.join)(base2, "Cursor", "User", "globalStorage", "state.vscdb");
   }
   if (process.platform === "darwin") {
-    return (0, import_node_path11.join)((0, import_node_os4.homedir)(), "Library", "Application Support", "Cursor", "User", "globalStorage", "state.vscdb");
+    return (0, import_node_path13.join)((0, import_node_os4.homedir)(), "Library", "Application Support", "Cursor", "User", "globalStorage", "state.vscdb");
   }
-  return (0, import_node_path11.join)((0, import_node_os4.homedir)(), ".config", "Cursor", "User", "globalStorage", "state.vscdb");
+  return (0, import_node_path13.join)((0, import_node_os4.homedir)(), ".config", "Cursor", "User", "globalStorage", "state.vscdb");
 }
 async function readCursorThirdPartyExtensibilityEnabled(execFileP5) {
   const dbPath = cursorUserGlobalStatePath();
-  if (!(0, import_node_fs12.existsSync)(dbPath)) return void 0;
+  if (!(0, import_node_fs14.existsSync)(dbPath)) return void 0;
   try {
     const { stdout } = await execFileP5("sqlite3", [dbPath, `SELECT value FROM ItemTable WHERE key = '${CURSOR_THIRD_PARTY_STATE_KEY}';`], {
       timeout: 5e3
@@ -9317,57 +9978,57 @@ async function readCursorThirdPartyExtensibilityEnabled(execFileP5) {
   }
 }
 function syncDirContents(src, dest) {
-  (0, import_node_fs12.mkdirSync)(dest, { recursive: true });
-  for (const name of (0, import_node_fs12.readdirSync)(dest)) {
-    (0, import_node_fs12.rmSync)((0, import_node_path11.join)(dest, name), { recursive: true, force: true });
+  (0, import_node_fs14.mkdirSync)(dest, { recursive: true });
+  for (const name of (0, import_node_fs14.readdirSync)(dest)) {
+    (0, import_node_fs14.rmSync)((0, import_node_path13.join)(dest, name), { recursive: true, force: true });
   }
-  (0, import_node_fs12.cpSync)(src, dest, { recursive: true });
+  (0, import_node_fs14.cpSync)(src, dest, { recursive: true });
 }
 function releaseTag(releasedVersion) {
   return releasedVersion.startsWith("v") ? releasedVersion : `v${releasedVersion}`;
 }
 async function extractPluginMmiFromHubCheckout(hubCheckout, tag, tmpRoot, execFileP5) {
-  const tarFile = (0, import_node_path11.join)(tmpRoot, "archive.tar");
+  const tarFile = (0, import_node_path13.join)(tmpRoot, "archive.tar");
   try {
     await execFileP5("git", gitFetchReleaseTagArgs(hubCheckout, tag), { timeout: 6e4 });
     await execFileP5("git", ["-C", hubCheckout, "archive", "--format=tar", `--output=${tarFile}`, tag, "plugins/mmi"], {
       timeout: 6e4
     });
     await execFileP5("tar", ["-xf", tarFile, "-C", tmpRoot], { timeout: 6e4 });
-    const pluginMmi = (0, import_node_path11.join)(tmpRoot, "plugins", "mmi");
-    return (0, import_node_fs12.existsSync)((0, import_node_path11.join)(pluginMmi, PLUGIN_JSON_REL)) ? pluginMmi : void 0;
+    const pluginMmi = (0, import_node_path13.join)(tmpRoot, "plugins", "mmi");
+    return (0, import_node_fs14.existsSync)((0, import_node_path13.join)(pluginMmi, PLUGIN_JSON_REL)) ? pluginMmi : void 0;
   } catch {
     return void 0;
   }
 }
 async function downloadPluginMmiViaGh(tag, tmpRoot) {
-  const tarPath = (0, import_node_path11.join)(tmpRoot, "repo.tgz");
+  const tarPath = (0, import_node_path13.join)(tmpRoot, "repo.tgz");
   try {
-    (0, import_node_fs12.mkdirSync)(tmpRoot, { recursive: true });
+    (0, import_node_fs14.mkdirSync)(tmpRoot, { recursive: true });
     const { stdout } = await execFileBuffer("gh", ghReleaseTarballApiArgs(tag), {
       timeout: 12e4,
       maxBuffer: 100 * 1024 * 1024,
       encoding: "buffer",
       windowsHide: true
     });
-    (0, import_node_fs12.writeFileSync)(tarPath, stdout);
+    (0, import_node_fs14.writeFileSync)(tarPath, stdout);
     await execFileBuffer("tar", ["-xzf", tarPath, "-C", tmpRoot], { timeout: 12e4, windowsHide: true });
-    const top = (0, import_node_fs12.readdirSync)(tmpRoot).find((entry) => entry !== "repo.tgz");
+    const top = (0, import_node_fs14.readdirSync)(tmpRoot).find((entry) => entry !== "repo.tgz");
     if (!top) return void 0;
-    const pluginMmi = (0, import_node_path11.join)(tmpRoot, top, "plugins", "mmi");
-    return (0, import_node_fs12.existsSync)((0, import_node_path11.join)(pluginMmi, PLUGIN_JSON_REL)) ? pluginMmi : void 0;
+    const pluginMmi = (0, import_node_path13.join)(tmpRoot, top, "plugins", "mmi");
+    return (0, import_node_fs14.existsSync)((0, import_node_path13.join)(pluginMmi, PLUGIN_JSON_REL)) ? pluginMmi : void 0;
   } catch {
     return void 0;
   }
 }
 async function resolvePluginMmiSource(releasedVersion, hubCheckout, tmpRoot, execFileP5) {
-  (0, import_node_fs12.mkdirSync)(tmpRoot, { recursive: true });
+  (0, import_node_fs14.mkdirSync)(tmpRoot, { recursive: true });
   const tag = releaseTag(releasedVersion);
   if (hubCheckout) {
     const fromHub = await extractPluginMmiFromHubCheckout(hubCheckout, tag, tmpRoot, execFileP5);
     if (fromHub) return fromHub;
   }
-  return downloadPluginMmiViaGh(tag, (0, import_node_path11.join)(tmpRoot, "gh"));
+  return downloadPluginMmiViaGh(tag, (0, import_node_path13.join)(tmpRoot, "gh"));
 }
 function cursorPluginPinsNeedingSeed(pins, releasedVersion) {
   if (!isSemverVersion(releasedVersion)) return pins.filter((pin) => !pin.hasPluginJson || !pin.hasHooksJson || pin.isEmpty);
@@ -9388,7 +10049,7 @@ async function applyCursorPluginCacheSeed(input) {
   for (const pin of pinsToSeed) {
     syncDirContents(source, pin.path);
   }
-  (0, import_node_fs12.rmSync)(tmpRoot, { recursive: true, force: true });
+  (0, import_node_fs14.rmSync)(tmpRoot, { recursive: true, force: true });
   return true;
 }
 
@@ -9436,8 +10097,12 @@ var MANAGED_GITIGNORE_LINES = [
   ".claude/worktrees/",
   ".mmi/.session",
   ".mmi/head-ts/",
-  // Recursive so any reuse of the parameterized queue engine in a new .mmi subdir (honcho today, others
-  // later) is ignored too — `**` matches zero dirs, so this still covers the root saga queue.
+  // Honcho's whole runtime dir — its ingest-throttle stamp (`last-skip.json`) is NOT a queue file, so the
+  // recursive patterns below miss it and it dirtied the working tree (blocked a release clean-tree check,
+  // #1472). The dir is pure scratch, so ignore it wholesale, like `.mmi/head-ts/`.
+  ".mmi/honcho/",
+  // Recursive so any reuse of the parameterized queue engine in a new .mmi subdir is ignored too —
+  // `**` matches zero dirs, so this still covers the root saga queue.
   ".mmi/**/saga-pending.jsonl*",
   ".mmi/**/saga-flush.lock",
   ".aws-sam/",
@@ -10106,8 +10771,8 @@ async function runStageLiveDown(deps, t) {
 
 // src/stage-runner.ts
 var import_node_child_process8 = require("node:child_process");
-var import_node_fs13 = require("node:fs");
-var import_node_path12 = require("node:path");
+var import_node_fs15 = require("node:fs");
+var import_node_path14 = require("node:path");
 var import_node_net2 = require("node:net");
 var import_node_util7 = require("node:util");
 var execFileP4 = (0, import_node_util7.promisify)(import_node_child_process8.execFile);
@@ -10152,7 +10817,7 @@ function detectStaleEnvFile(exampleContent, targetContent, mtimes) {
   return void 0;
 }
 function stageStatePath(cwd = process.cwd()) {
-  return (0, import_node_path12.join)(cwd, "tmp", "stage", "state.json");
+  return (0, import_node_path14.join)(cwd, "tmp", "stage", "state.json");
 }
 function mergeEnvSecretsIntoFile(content, secrets2) {
   const lines = content.split(/\r?\n/);
@@ -10235,9 +10900,9 @@ async function shell(command, cwd, timeoutMs) {
   });
 }
 function readState(path2) {
-  if (!(0, import_node_fs13.existsSync)(path2)) return null;
+  if (!(0, import_node_fs15.existsSync)(path2)) return null;
   try {
-    return JSON.parse((0, import_node_fs13.readFileSync)(path2, "utf8"));
+    return JSON.parse((0, import_node_fs15.readFileSync)(path2, "utf8"));
   } catch {
     return null;
   }
@@ -10289,7 +10954,7 @@ async function stopStage(opts = {}) {
     return { ok: true, action: "stop", statePath, message: "no previous stage state found" };
   }
   await killTree(state.pid);
-  (0, import_node_fs13.rmSync)(statePath, { force: true });
+  (0, import_node_fs15.rmSync)(statePath, { force: true });
   return { ok: true, action: "stop", statePath, pid: state.pid, message: `stopped previous stage pid ${state.pid}` };
 }
 async function startStage(config = {}, opts = {}) {
@@ -10298,7 +10963,7 @@ async function startStage(config = {}, opts = {}) {
   const cwd = opts.cwd ?? process.cwd();
   const statePath = opts.statePath ?? stageStatePath(cwd);
   const dir = statePath.slice(0, Math.max(statePath.lastIndexOf("/"), statePath.lastIndexOf("\\")));
-  (0, import_node_fs13.mkdirSync)(dir, { recursive: true });
+  (0, import_node_fs15.mkdirSync)(dir, { recursive: true });
   let stagePort;
   if (config.portRange) {
     const [s, e] = config.portRange;
@@ -10308,14 +10973,14 @@ async function startStage(config = {}, opts = {}) {
   }
   const sub = (s) => s != null && stagePort != null ? s.replace(/\$\{?STAGE_PORT\}?/g, String(stagePort)) : s;
   if (config.ensureEnv) {
-    const target = (0, import_node_path12.join)(cwd, config.ensureEnv.target);
-    const example = (0, import_node_path12.join)(cwd, config.ensureEnv.example);
-    if (!(0, import_node_fs13.existsSync)(target) && (0, import_node_fs13.existsSync)(example)) {
-      (0, import_node_fs13.copyFileSync)(example, target);
-    } else if ((0, import_node_fs13.existsSync)(target) && (0, import_node_fs13.existsSync)(example)) {
-      const stale = detectStaleEnvFile((0, import_node_fs13.readFileSync)(example, "utf8"), (0, import_node_fs13.readFileSync)(target, "utf8"), {
-        exampleMtimeMs: (0, import_node_fs13.statSync)(example).mtimeMs,
-        targetMtimeMs: (0, import_node_fs13.statSync)(target).mtimeMs
+    const target = (0, import_node_path14.join)(cwd, config.ensureEnv.target);
+    const example = (0, import_node_path14.join)(cwd, config.ensureEnv.example);
+    if (!(0, import_node_fs15.existsSync)(target) && (0, import_node_fs15.existsSync)(example)) {
+      (0, import_node_fs15.copyFileSync)(example, target);
+    } else if ((0, import_node_fs15.existsSync)(target) && (0, import_node_fs15.existsSync)(example)) {
+      const stale = detectStaleEnvFile((0, import_node_fs15.readFileSync)(example, "utf8"), (0, import_node_fs15.readFileSync)(target, "utf8"), {
+        exampleMtimeMs: (0, import_node_fs15.statSync)(example).mtimeMs,
+        targetMtimeMs: (0, import_node_fs15.statSync)(target).mtimeMs
       });
       if (stale) {
         const msg = `stale ${config.ensureEnv.target} (${stale}) \u2014 delete it or refresh from ${config.ensureEnv.example} before re-running /stage`;
@@ -10323,8 +10988,8 @@ async function startStage(config = {}, opts = {}) {
         console.error(`mmi-cli stage: ${msg} (allowed via --allow-stale-env)`);
       }
     }
-    if (opts.vaultEnvMerge && Object.keys(opts.vaultEnvMerge).length && (0, import_node_fs13.existsSync)(target)) {
-      (0, import_node_fs13.writeFileSync)(target, mergeEnvSecretsIntoFile((0, import_node_fs13.readFileSync)(target, "utf8"), opts.vaultEnvMerge), "utf8");
+    if (opts.vaultEnvMerge && Object.keys(opts.vaultEnvMerge).length && (0, import_node_fs15.existsSync)(target)) {
+      (0, import_node_fs15.writeFileSync)(target, mergeEnvSecretsIntoFile((0, import_node_fs15.readFileSync)(target, "utf8"), opts.vaultEnvMerge), "utf8");
     }
   }
   const extraEnv = {};
@@ -10349,13 +11014,13 @@ async function startStage(config = {}, opts = {}) {
     healthUrl: sub(config.healthUrl?.trim()) || void 0,
     port: stagePort
   };
-  (0, import_node_fs13.writeFileSync)(statePath, JSON.stringify(state, null, 2), "utf8");
+  (0, import_node_fs15.writeFileSync)(statePath, JSON.stringify(state, null, 2), "utf8");
   try {
     if (state.healthUrl) await waitForHealth(state.healthUrl, opts.timeoutMs ?? 6e4, config.healthAnyStatus);
     else await waitForProcessStability(child);
   } catch (e) {
     await killTree(state.pid);
-    (0, import_node_fs13.rmSync)(statePath, { force: true });
+    (0, import_node_fs15.rmSync)(statePath, { force: true });
     throw e;
   }
   const result = { ok: true, action: "start", statePath, pid: state.pid, port: stagePort, message: `started stage pid ${state.pid}${stagePort != null ? ` on port ${stagePort}` : ""}` };
@@ -10471,7 +11136,7 @@ function resolveDeployModel2(meta, repo) {
   if (isDeployModel(m)) return m;
   return resolveDeployModel(meta, repo);
 }
-function clean(out) {
+function clean2(out) {
   return out.trim();
 }
 function requireValue(value, label) {
@@ -10522,11 +11187,11 @@ async function verifyPublishedRelease(deps, repo, tag, expectedTarget, expectedS
   if (release.targetCommitish !== expectedTarget) {
     throw new Error(`Release ${tag} targetCommitish is ${String(release.targetCommitish || "(missing)")}, expected ${expectedTarget}`);
   }
-  const tagSha = requireValue(clean(await deps.run("git", ["rev-parse", `${tag}^{commit}`])), "release tag sha");
+  const tagSha = requireValue(clean2(await deps.run("git", ["rev-parse", `${tag}^{commit}`])), "release tag sha");
   if (tagSha !== expectedSha) {
     throw new Error(`Release ${tag} tag points at ${tagSha}, expected ${expectedSha}`);
   }
-  const branchOut = clean(await deps.run("git", ["ls-remote", "origin", `refs/heads/${expectedTarget}`]));
+  const branchOut = clean2(await deps.run("git", ["ls-remote", "origin", `refs/heads/${expectedTarget}`]));
   const branchSha = requireValue(branchOut.split(/\s+/)[0] ?? "", `origin/${expectedTarget} sha`);
   if (branchSha !== expectedSha) {
     throw new Error(`origin/${expectedTarget} points at ${branchSha}, expected ${expectedSha}`);
@@ -10586,7 +11251,7 @@ function ensurePositiveCount(out, emptyMessage) {
   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}`]));
+  const out = clean2(await deps.run("git", ["ls-remote", "origin", `refs/heads/${branch}`]));
   return out.length > 0;
 }
 async function loadReleaseTrackBranchHints(deps) {
@@ -10598,10 +11263,10 @@ async function loadReleaseTrackBranchHints(deps) {
   return { hasDevelopmentBranch, hasMainBranch, hasRcBranch };
 }
 async function buildTrainApplyContext(deps) {
-  const repo = requireValue(clean(await deps.run("gh", ["repo", "view", "--json", "nameWithOwner", "--jq", ".nameWithOwner"])), "repo");
+  const repo = requireValue(clean2(await deps.run("gh", ["repo", "view", "--json", "nameWithOwner", "--jq", ".nameWithOwner"])), "repo");
   const [owner, name] = repo.split("/");
   if (!owner || !name) throw new Error(`repo must be owner/name, got ${repo}`);
-  const login = requireValue(clean(await deps.run("gh", ["api", "user", "--jq", ".login"])), "GitHub login");
+  const login = requireValue(clean2(await deps.run("gh", ["api", "user", "--jq", ".login"])), "GitHub login");
   const verdict = await deps.trainAuthority(repo);
   if (!verdict.ok) throw new Error(`${commandAuthorityLabel(owner)}: train authority could not be verified (${verdict.error})`);
   if (!verdict.train) {
@@ -10622,7 +11287,7 @@ async function requireCleanTree(deps) {
   if (status.trim()) throw new Error("working tree must be clean before train apply");
 }
 async function requireBranch(deps, branch) {
-  const current = clean(await deps.run("git", ["rev-parse", "--abbrev-ref", "HEAD"]));
+  const current = clean2(await deps.run("git", ["rev-parse", "--abbrev-ref", "HEAD"]));
   if (current !== branch) throw new Error(`must run from ${branch}, currently on ${current || "(unknown)"}`);
 }
 var HUB_REPO3 = "mutmutco/MMI-Hub";
@@ -10791,7 +11456,7 @@ async function discoverRequiredCheckContexts(deps, ctx, branch) {
   return [...contexts];
 }
 async function findOpenAlignmentPr(deps, ctx) {
-  const out = clean(await deps.run("gh", ["pr", "list", "--repo", ctx.repo, "--base", "development", "--head", "main", "--state", "open", "--json", "number,url"]));
+  const out = clean2(await deps.run("gh", ["pr", "list", "--repo", ctx.repo, "--base", "development", "--head", "main", "--state", "open", "--json", "number,url"]));
   if (!out) return void 0;
   const rows = JSON.parse(out);
   const row = rows.find((r) => typeof r.number === "number" && typeof r.url === "string");
@@ -10819,14 +11484,14 @@ async function rollDevelopmentForward(deps, ctx, tag) {
       note: `alignment PR already open: ${existing.url} \u2014 land it with \`gh pr merge ${existing.number} --merge\``
     };
   }
-  const ahead = clean(await deps.run("git", ["rev-list", "--count", "origin/development..main"]));
+  const ahead = clean2(await deps.run("git", ["rev-list", "--count", "origin/development..main"]));
   if (ahead === "0") {
     return { status: "aligned", note: "development already contains the released main; nothing to roll forward" };
   }
   const body = `Carries the ${tag} release (including the version fold) from \`main\` back to \`development\`.
 
 \`development\` requires status checks, so the release train opens this alignment PR instead of a direct push of the un-checked merge commit (#1143). Land it with a **true merge** (\`gh pr merge --merge\`, not squash) so the merge parentage survives and the misalignment guard stays satisfied.`;
-  const url = clean(await deps.run("gh", ["pr", "create", "--repo", ctx.repo, "--base", "development", "--head", "main", "--title", `chore(release): align development to ${tag}`, "--body", body]));
+  const url = clean2(await deps.run("gh", ["pr", "create", "--repo", ctx.repo, "--base", "development", "--head", "main", "--title", `chore(release): align development to ${tag}`, "--body", body]));
   const number = parsePrNumber(url);
   return {
     status: "pr-pending",
@@ -10892,10 +11557,10 @@ async function waitForRequiredTrainChecks(deps, ctx, sha, required) {
 }
 async function ensureTagPushed(deps, tag, sha) {
   const remoteOut = await deps.run("git", ["ls-remote", "origin", `refs/tags/${tag}`]);
-  const remoteSha = clean(remoteOut).split(/\s+/)[0] || "";
+  const remoteSha = clean2(remoteOut).split(/\s+/)[0] || "";
   let localSha = "";
   try {
-    localSha = clean(await deps.run("git", ["rev-parse", "--verify", `refs/tags/${tag}^{commit}`]));
+    localSha = clean2(await deps.run("git", ["rev-parse", "--verify", `refs/tags/${tag}^{commit}`]));
   } catch {
   }
   if (remoteSha) {
@@ -10918,7 +11583,7 @@ async function ensureTagPushed(deps, tag, sha) {
 }
 async function resolveRcResumeTag(deps, base2, sha) {
   const out = await deps.run("git", ["ls-remote", "--tags", "origin", `refs/tags/${base2}-rc.*`]);
-  const onSha = clean(out).split("\n").map((line) => line.trim()).filter(Boolean).map((line) => line.split(/\s+/)).filter(([refSha]) => refSha === sha).map(([, ref]) => ref.replace(/^refs\/tags\//, "").replace(/\^\{\}$/, "")).filter((ref) => new RegExp(`^${base2.replace(/\./g, "\\.")}-rc\\.\\d+$`).test(ref));
+  const onSha = clean2(out).split("\n").map((line) => line.trim()).filter(Boolean).map((line) => line.split(/\s+/)).filter(([refSha]) => refSha === sha).map(([, ref]) => ref.replace(/^refs\/tags\//, "").replace(/\^\{\}$/, "")).filter((ref) => new RegExp(`^${base2.replace(/\./g, "\\.")}-rc\\.\\d+$`).test(ref));
   const unique = [...new Set(onSha)];
   if (unique.length === 0) return { tag: null };
   const rcNum = (t) => Number.parseInt(t.replace(/^.*-rc\./, ""), 10);
@@ -11043,13 +11708,13 @@ async function runTrainApply(command, deps, options = {}) {
       "nothing to promote: origin/development is not ahead of origin/rc"
     );
     const deployModel2 = await preflight(deps, ctx, "rc", meta);
-    const releaseBase = requireValue(clean(await deps.run("node", ["scripts/next-version.mjs", "cycle"])), "release base");
+    const releaseBase = requireValue(clean2(await deps.run("node", ["scripts/next-version.mjs", "cycle"])), "release base");
     await deps.run("git", ["checkout", "rc"]);
     await ffOnlyPull(deps, "rc");
     await deps.run("git", ["merge", "development", "--no-edit"]);
-    const rcSha = requireValue(clean(await deps.run("git", ["rev-parse", "rc"])), "rc sha");
+    const rcSha = requireValue(clean2(await deps.run("git", ["rev-parse", "rc"])), "rc sha");
     const resume = await resolveRcResumeTag(deps, releaseBase, rcSha);
-    const tag2 = resume.tag ?? requireValue(clean(await deps.run("node", ["scripts/next-version.mjs", "rc"])), "rc tag");
+    const tag2 = resume.tag ?? requireValue(clean2(await deps.run("node", ["scripts/next-version.mjs", "rc"])), "rc tag");
     const resumeNote = resume.tag ? resume.note : void 0;
     await ensureTagPushed(deps, tag2, rcSha);
     const requiredChecks2 = await discoverRequiredCheckContexts(deps, ctx, "rc");
@@ -11067,7 +11732,7 @@ async function runTrainApply(command, deps, options = {}) {
       "nothing to release: origin/development is not ahead of origin/main"
     );
     const deployModel2 = await preflight(deps, ctx, "main", meta);
-    const tag2 = requireValue(clean(await deps.run("node", ["scripts/next-version.mjs", "cycle"])), "release tag");
+    const tag2 = requireValue(clean2(await deps.run("node", ["scripts/next-version.mjs", "cycle"])), "release tag");
     const foldPaths2 = await resolveFoldPaths(deps, deployModel2);
     const tolerated2 = [...foldPaths2, ...RELEASE_TOLERATED_PATHS];
     const predicted2 = await predictMergeConflicts(deps, "origin/main", "origin/development");
@@ -11085,12 +11750,12 @@ async function runTrainApply(command, deps, options = {}) {
       await mergeWithSpineResolution(deps, "development", "development -> main", "theirs", tolerated2);
     }
     const versionFold2 = await foldReleaseVersion(deps, deployModel2, tag2, foldPaths2);
-    const releaseSha2 = requireValue(clean(await deps.run("git", ["rev-parse", "main"])), "release sha");
+    const releaseSha2 = requireValue(clean2(await deps.run("git", ["rev-parse", "main"])), "release sha");
     await ensureTagPushed(deps, tag2, releaseSha2);
     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, "--target", "main", "--generate-notes", "--latest", "--repo", ctx.repo])) || void 0;
+    const releaseUrl2 = clean2(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)();
@@ -11139,8 +11804,8 @@ async function runTrainApply(command, deps, options = {}) {
       "nothing to release: origin/development is not ahead of origin/main"
     );
     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 = hasRcBranch ? clean(await deps.run("git", ["rev-parse", "origin/rc"])) : "";
+    const tag2 = requireValue(clean2(await deps.run("node", ["scripts/next-version.mjs", "cycle"])), "release tag");
+    const rcShaAtRelease = hasRcBranch ? clean2(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");
@@ -11158,12 +11823,12 @@ async function runTrainApply(command, deps, options = {}) {
       await mergeWithSpineResolution(deps, "development", "development -> main", "theirs", tolerated2);
     }
     const versionFold2 = await foldReleaseVersion(deps, deployModel2, tag2, foldPaths2);
-    const releaseSha2 = requireValue(clean(await deps.run("git", ["rev-parse", "main"])), "release sha");
+    const releaseSha2 = requireValue(clean2(await deps.run("git", ["rev-parse", "main"])), "release sha");
     await ensureTagPushed(deps, tag2, releaseSha2);
     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, "--target", "main", "--generate-notes", "--latest", "--repo", ctx.repo])) || void 0;
+    const releaseUrl2 = clean2(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)();
@@ -11230,7 +11895,7 @@ async function runTrainApply(command, deps, options = {}) {
       `hotfix-coverage: ${coverage.uncovered.length} main-only commit(s) not proven in origin/rc \u2014 the candidate would revert a prod hotfix: ${list}. Re-cut /rcand from development, or have the authorized human verify the content is in the candidate and rerun release with --ack <sha>[,<sha>\u2026].`
     );
   }
-  const releasedRcSha = clean(await deps.run("git", ["rev-parse", "origin/rc"]));
+  const releasedRcSha = clean2(await deps.run("git", ["rev-parse", "origin/rc"]));
   await deps.run("git", ["checkout", "main"]);
   await ffOnlyPull(deps, "main");
   if (predicted.length === 0) {
@@ -11238,15 +11903,15 @@ async function runTrainApply(command, deps, options = {}) {
   } else {
     await mergeWithSpineResolution(deps, "rc", "rc -> main", "theirs", tolerated);
   }
-  const tag = requireValue(clean(await deps.run("node", ["scripts/next-version.mjs", "release"])), "release tag");
+  const tag = requireValue(clean2(await deps.run("node", ["scripts/next-version.mjs", "release"])), "release tag");
   const versionFold = await foldReleaseVersion(deps, deployModel, tag, foldPaths);
-  const releaseSha = requireValue(clean(await deps.run("git", ["rev-parse", "main"])), "release sha");
+  const releaseSha = requireValue(clean2(await deps.run("git", ["rev-parse", "main"])), "release sha");
   await ensureTagPushed(deps, tag, releaseSha);
   const requiredChecks = await discoverRequiredCheckContexts(deps, ctx, "main");
   const checks = await waitForRequiredTrainChecks(deps, ctx, releaseSha, requiredChecks);
   await deps.run("git", ["push", "origin", "main"]);
   const autoRunSince = (deps.now ?? Date.now)();
-  const releaseUrl = clean(await deps.run("gh", ["release", "create", tag, "--target", "main", "--generate-notes", "--latest", "--repo", ctx.repo])) || void 0;
+  const releaseUrl = clean2(await deps.run("gh", ["release", "create", tag, "--target", "main", "--generate-notes", "--latest", "--repo", ctx.repo])) || void 0;
   await verifyPublishedRelease(deps, ctx.repo, tag, "main", releaseSha);
   const announceNote = deps.announce ? (await deps.announce({ repo: ctx.repo, tag, summaryFile: options.announceSummaryFile })).note : void 0;
   const d = await dispatchDeploy(deps, ctx, "main", "main", deployModel, watch, autoRunSince, releaseSha, "report");
@@ -11374,7 +12039,7 @@ async function retireRcRuntime(deps, ctx, model, deployStatus, releasedRcSha) {
   }
   try {
     await deps.run("git", ["fetch", "origin", "rc"]);
-    const rcNow = clean(await deps.run("git", ["rev-parse", "origin/rc"]));
+    const rcNow = clean2(await deps.run("git", ["rev-parse", "origin/rc"]));
     if (rcNow !== releasedRcSha) {
       return {
         status: "skipped",
@@ -11406,7 +12071,7 @@ async function runTenantRedeploy(deps, options) {
   const repo = options.repo;
   const [owner, name] = repo.split("/");
   if (!owner || !name) throw new Error(`repo must be owner/name, got ${repo}`);
-  const login = requireValue(clean(await deps.run("gh", ["api", "user", "--jq", ".login"])), "GitHub login");
+  const login = requireValue(clean2(await deps.run("gh", ["api", "user", "--jq", ".login"])), "GitHub login");
   const verdict = await deps.trainAuthority(repo);
   if (!verdict.ok) throw new Error(`${commandAuthorityLabel(owner)}: train authority could not be verified (${verdict.error})`);
   if (!verdict.train) throw new Error(`${commandAuthorityLabel(owner)}: @${login} is ${verdict.role} \u2014 no train authority on ${repo}`);
@@ -11562,7 +12227,7 @@ var HOTFIX_RUN_FIND_ATTEMPTS = 10;
 var HOTFIX_RUN_FIND_DELAY_MS = 15e3;
 var HOTFIX_VERIFY_ATTEMPTS = 5;
 var HOTFIX_VERIFY_RETRY_MS = 6e3;
-function clean2(out) {
+function clean3(out) {
   return out.trim();
 }
 function sleeper(deps) {
@@ -11620,7 +12285,7 @@ async function resolveHotfixSource(deps, ctx, from) {
     if (!sha2) throw new Error(`PR #${num} has no merge commit recorded \u2014 name the commit SHA explicitly`);
     return { sha: sha2, label: `PR #${num} (${sha2.slice(0, 7)})` };
   }
-  const sha = clean2(await deps.run("git", ["rev-parse", "--verify", `${from}^{commit}`]));
+  const sha = clean3(await deps.run("git", ["rev-parse", "--verify", `${from}^{commit}`]));
   if (!sha) throw new Error(`could not resolve commit ${from}`);
   return { sha, label: sha.slice(0, 7) };
 }
@@ -11648,7 +12313,7 @@ async function runHotfixStart(deps, options) {
     };
   }
   const { sha, label } = await resolveHotfixSource(deps, ctx, options.from);
-  const remoteBranch = clean2(await deps.run("git", ["ls-remote", "origin", `refs/heads/${branch}`]));
+  const remoteBranch = clean3(await deps.run("git", ["ls-remote", "origin", `refs/heads/${branch}`]));
   if (remoteBranch) {
     await deps.run("git", ["checkout", branch]);
     const isRulesSource2 = deps.isRulesSource ? await deps.isRulesSource() : false;
@@ -11681,7 +12346,7 @@ async function runHotfixStart(deps, options) {
     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", [
+  const prUrl = clean3(await deps.run("gh", [
     "pr",
     "create",
     "--repo",
@@ -11801,7 +12466,7 @@ async function runHotfixRelease(deps, versionInput, options = {}) {
   }
   let verifyNote;
   if (deployModel === "hub-serverless") {
-    const previousRef = clean2(await deps.run("git", ["rev-parse", "--abbrev-ref", "HEAD"]));
+    const previousRef = clean3(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]);
@@ -11886,9 +12551,9 @@ async function runHotfixStatus(deps, versionInput) {
   return { ...ctx, command: "hotfix-status", ...facts, ...deriveHotfixState(facts) };
 }
 async function gatherHotfixFacts(deps, ctx, tag, version) {
-  const branchExists = Boolean(clean2(await deps.run("git", ["ls-remote", "origin", `refs/heads/${hotfixBranch(tag)}`])));
+  const branchExists = Boolean(clean3(await deps.run("git", ["ls-remote", "origin", `refs/heads/${hotfixBranch(tag)}`])));
   const pr2 = await findHotfixPr(deps, ctx, tag);
-  const remoteTag = clean2(await deps.run("git", ["ls-remote", "origin", `refs/tags/${tag}`]));
+  const remoteTag = clean3(await deps.run("git", ["ls-remote", "origin", `refs/tags/${tag}`]));
   const tagPushed = Boolean(remoteTag);
   const tagSha = remoteTag.split(/\s+/)[0] || "";
   let releaseExists = false;
@@ -11922,7 +12587,7 @@ async function gatherHotfixFacts(deps, ctx, tag, version) {
       }
     }
   }
-  const npmVersion = await deps.run("npm", ["view", "@mutmutco/cli", "version", "--silent"]).then(clean2, () => "unknown");
+  const npmVersion = await deps.run("npm", ["view", "@mutmutco/cli", "version", "--silent"]).then(clean3, () => "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) {
@@ -11945,7 +12610,7 @@ async function findInFlightHotfixVersion(deps, ctx) {
     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*"]));
+  const branchOut = clean3(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);
@@ -12094,7 +12759,7 @@ async function announceRelease(deps, args) {
 }
 
 // src/port-registry.ts
-var import_node_fs14 = require("node:fs");
+var import_node_fs16 = require("node:fs");
 
 // ../infra/port-geometry.mjs
 var PORT_BLOCK = 100;
@@ -12108,8 +12773,8 @@ function nextPortBlock(registry2) {
   return [base2, base2 + PORT_SPAN];
 }
 function loadPortRegistry(path2) {
-  if (!(0, import_node_fs14.existsSync)(path2)) return {};
-  const raw = JSON.parse((0, import_node_fs14.readFileSync)(path2, "utf8"));
+  if (!(0, import_node_fs16.existsSync)(path2)) return {};
+  const raw = JSON.parse((0, import_node_fs16.readFileSync)(path2, "utf8"));
   const out = {};
   for (const [key, value] of Object.entries(raw)) {
     if (Array.isArray(value) && value.length === 2 && value.every((n) => typeof n === "number")) {
@@ -12123,9 +12788,9 @@ function ensurePortRange(repo, path2) {
   const existing = registry2[repo];
   if (existing) return existing;
   const range = nextPortBlock(registry2);
-  const raw = (0, import_node_fs14.existsSync)(path2) ? JSON.parse((0, import_node_fs14.readFileSync)(path2, "utf8")) : {};
+  const raw = (0, import_node_fs16.existsSync)(path2) ? JSON.parse((0, import_node_fs16.readFileSync)(path2, "utf8")) : {};
   raw[repo] = range;
-  (0, import_node_fs14.writeFileSync)(path2, JSON.stringify(raw, null, 2) + "\n", "utf8");
+  (0, import_node_fs16.writeFileSync)(path2, JSON.stringify(raw, null, 2) + "\n", "utf8");
   return range;
 }
 function portCursorSeed(registry2) {
@@ -13919,8 +14584,8 @@ function resolveKbSource(rawBase) {
   return { owner: m[1], repo: m[2], ref: m[3] };
 }
 function buildKbGetArgs(src, path2) {
-  const clean3 = path2.replace(/^\/+/, "");
-  return ["api", `repos/${src.owner}/${src.repo}/contents/${clean3}?ref=${src.ref}`, "-H", "Accept: application/vnd.github.raw"];
+  const clean4 = path2.replace(/^\/+/, "");
+  return ["api", `repos/${src.owner}/${src.repo}/contents/${clean4}?ref=${src.ref}`, "-H", "Accept: application/vnd.github.raw"];
 }
 function buildKbTreeArgs(src) {
   return ["api", `repos/${src.owner}/${src.repo}/git/trees/${src.ref}?recursive=1`];
@@ -13937,10 +14602,10 @@ function parseKbTree(stdout, prefix) {
 }
 
 // src/plan.ts
-var import_node_path13 = require("node:path");
+var import_node_path15 = require("node:path");
 var PLANS_DIR = "plans";
-var META_FILE = (0, import_node_path13.join)(PLANS_DIR, ".plan-meta.json");
-var planPath = (slug) => (0, import_node_path13.join)(PLANS_DIR, `${slug}.md`);
+var META_FILE = (0, import_node_path15.join)(PLANS_DIR, ".plan-meta.json");
+var planPath = (slug) => (0, import_node_path15.join)(PLANS_DIR, `${slug}.md`);
 var metaKey = (project2, slug) => `${project2}/${slug}`;
 function parseMeta(raw) {
   if (!raw) return {};
@@ -13965,7 +14630,7 @@ function hashContent(s) {
 function staleHint(slug) {
   return `remote "${slug}" is newer \u2014 run \`mmi-cli northstar pull ${slug}\` first (your local is based on an older version), or re-push with \`--force\` to overwrite`;
 }
-var INDEX_FILE = (0, import_node_path13.join)(PLANS_DIR, ".index.json");
+var INDEX_FILE = (0, import_node_path15.join)(PLANS_DIR, ".index.json");
 var INDEX_TTL_MS = 6e4;
 function parseIndex(raw) {
   if (!raw) return null;
@@ -13994,7 +14659,7 @@ function mergeIndex(idx, scope, plans, now) {
   const mergedScope = idx.scope === null ? null : [.../* @__PURE__ */ new Set([...idx.scope, ...scope])];
   return { fetchedAt: now, scope: mergedScope, plans: [...kept, ...plans] };
 }
-var QUEUE_FILE = (0, import_node_path13.join)(PLANS_DIR, ".sync-queue.json");
+var QUEUE_FILE = (0, import_node_path15.join)(PLANS_DIR, ".sync-queue.json");
 var QUEUE_MAX_ATTEMPTS = 10;
 function isValidQueueEntry(e) {
   if (!e || typeof e !== "object") return false;
@@ -14443,11 +15108,11 @@ async function planGraduate(deps, slug, opts = {}) {
 }
 
 // src/atomic-write.ts
-var import_node_fs15 = require("node:fs");
+var import_node_fs17 = require("node:fs");
 function atomicWriteFileSync(path2, content) {
   const tmp = `${path2}.${process.pid}.tmp`;
-  (0, import_node_fs15.writeFileSync)(tmp, content, "utf8");
-  (0, import_node_fs15.renameSync)(tmp, path2);
+  (0, import_node_fs17.writeFileSync)(tmp, content, "utf8");
+  (0, import_node_fs17.renameSync)(tmp, path2);
 }
 
 // src/oauth.ts
@@ -14678,7 +15343,7 @@ async function fetchHubVersionInfo(baseUrl) {
 }
 function readRepoVersion() {
   try {
-    return JSON.parse((0, import_node_fs16.readFileSync)((0, import_node_path14.join)(process.cwd(), ".claude-plugin", "plugin.json"), "utf8")).version || void 0;
+    return JSON.parse((0, import_node_fs18.readFileSync)((0, import_node_path16.join)(process.cwd(), ".claude-plugin", "plugin.json"), "utf8")).version || void 0;
   } catch {
     return void 0;
   }
@@ -14804,10 +15469,10 @@ async function runRulesSync(opts, io = consoleIo) {
   for (const entry of fetched) {
     if ("error" in entry) continue;
     const { file, source } = entry;
-    const current = (0, import_node_fs16.existsSync)(file) ? await (0, import_promises5.readFile)(file, "utf8") : null;
+    const current = (0, import_node_fs18.existsSync)(file) ? await (0, import_promises5.readFile)(file, "utf8") : null;
     if (needsUpdate(source, current)) {
       const slash = file.lastIndexOf("/");
-      if (slash > 0) (0, import_node_fs16.mkdirSync)(file.slice(0, slash), { recursive: true });
+      if (slash > 0) (0, import_node_fs18.mkdirSync)(file.slice(0, slash), { recursive: true });
       await (0, import_promises5.writeFile)(file, normalizeEol(source), "utf8");
       changed++;
       if (!opts.quiet) io.log(`mmi-cli rules: updated ${file}`);
@@ -14833,7 +15498,7 @@ async function runDocsSync(opts, io = consoleIo) {
         return null;
       }
     },
-    localContent: async (f) => (0, import_node_fs16.existsSync)(f) ? await (0, import_promises5.readFile)(f, "utf8") : null,
+    localContent: async (f) => (0, import_node_fs18.existsSync)(f) ? await (0, import_promises5.readFile)(f, "utf8") : null,
     writeDoc: async (f, c) => {
       await (0, import_promises5.writeFile)(f, c, "utf8");
     }
@@ -14845,6 +15510,7 @@ async function runDocsSync(opts, io = consoleIo) {
 var docs = program2.command("docs").description("repo-owned authoritative docs");
 docs.command("sync").option("--quiet", "stay silent unless something changed or errored").description("refresh README.md / architecture.md from the repo default branch (keeper-authored); never clobbers uncommitted edits").action((opts) => runDocsSync(opts));
 registerSagaCommands(program2);
+registerHandoffCommands(program2);
 registerHonchoCommands(program2);
 async function runWhoami(io = consoleIo) {
   const cfg = await loadConfig();
@@ -14858,8 +15524,18 @@ async function runWhoami(io = consoleIo) {
 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) => {
+program2.command("gc").description("dry-run cleanup for merged/closed PR branches and stale tracking refs (--scratch: stale local saga/plan/honcho files)").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("--scratch", "prune stale local saga/plan/honcho scratch already recorded remotely (#1474) instead of git branches/refs").option("--remote <name>", "remote name", "origin").option("--limit <n>", "PRs to inspect per state", "200").action(async (o) => {
   if (o.apply && o.dryRun) return fail("gc: choose either --dry-run or --apply");
+  if (o.scratch) {
+    try {
+      const root = (await execFileP2("git", ["rev-parse", "--show-toplevel"], { timeout: GIT_TIMEOUT_MS }).catch(() => ({ stdout: "" }))).stdout.trim() || process.cwd();
+      const run = executeScratchGc(root, { apply: Boolean(o.apply) });
+      if (o.json) return console.log(JSON.stringify({ dryRun: !o.apply, ...run }, null, 2));
+      return console.log(formatScratchGcPlan(run.plan, Boolean(o.apply)));
+    } catch (e) {
+      return fail(`gc --scratch: ${e.message}`);
+    }
+  }
   const limit = Number.parseInt(o.limit, 10);
   if (!Number.isFinite(limit) || limit < 1) return fail("gc: --limit must be a positive integer");
   try {
@@ -14887,6 +15563,120 @@ ${renderGcApplyResult(applyResult)}`);
     fail(`gc: ${e.message}`);
   }
 });
+var NPM_PROVISION_TIMEOUT_MS = 3e5;
+var WORKTREE_SETUP_LOCK_TTL_MS = 10 * 6e4;
+function runWorktreeInstall(command, cwd, quiet) {
+  const [bin, ...args] = command.split(" ");
+  const file = isWin ? "cmd.exe" : bin;
+  const spawnArgs = isWin ? ["/c", bin, ...args] : args;
+  return new Promise((resolve, reject) => {
+    const child = (0, import_node_child_process10.spawn)(file, spawnArgs, { cwd, stdio: quiet ? "ignore" : "inherit", windowsHide: true });
+    const timer = setTimeout(() => {
+      try {
+        child.kill();
+      } catch {
+      }
+      reject(new Error(`${command} timed out after ${NPM_PROVISION_TIMEOUT_MS}ms in ${cwd}`));
+    }, NPM_PROVISION_TIMEOUT_MS);
+    child.on("error", (e) => {
+      clearTimeout(timer);
+      reject(e);
+    });
+    child.on("exit", (code) => {
+      clearTimeout(timer);
+      if (code === 0) resolve();
+      else reject(new Error(`${command} exited ${code} in ${cwd}`));
+    });
+  });
+}
+async function primaryCheckoutRoot(worktreeRoot) {
+  try {
+    const out = (await execFileP2("git", ["-C", worktreeRoot, "rev-parse", "--path-format=absolute", "--git-common-dir"], { timeout: GIT_TIMEOUT_MS })).stdout.trim();
+    return out ? (0, import_node_path16.dirname)(out) : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function makeProvisionDeps(worktreeRoot, quiet, log) {
+  return {
+    runInstall: (command, cwd) => runWorktreeInstall(command, cwd, quiet),
+    primaryCheckout: () => primaryCheckoutRoot(worktreeRoot),
+    log
+  };
+}
+function acquireWorktreeSetupLock(worktreeRoot) {
+  const lockPath = (0, import_node_path16.join)(worktreeRoot, ".mmi", "worktree-setup.lock");
+  const take = () => {
+    const fd = (0, import_node_fs18.openSync)(lockPath, "wx");
+    try {
+      (0, import_node_fs18.writeSync)(fd, String(Date.now()));
+    } finally {
+      (0, import_node_fs18.closeSync)(fd);
+    }
+    return () => {
+      try {
+        (0, import_node_fs18.rmSync)(lockPath, { force: true });
+      } catch {
+      }
+    };
+  };
+  try {
+    (0, import_node_fs18.mkdirSync)((0, import_node_path16.dirname)(lockPath), { recursive: true });
+    return take();
+  } catch {
+    try {
+      if (Date.now() - (0, import_node_fs18.statSync)(lockPath).mtimeMs > WORKTREE_SETUP_LOCK_TTL_MS) {
+        (0, import_node_fs18.rmSync)(lockPath, { force: true });
+        return take();
+      }
+    } catch {
+    }
+    return null;
+  }
+}
+var worktree = program2.command("worktree").description("self-provisioning worktrees \u2014 install deps + copy local-only config");
+worktree.command("create <branch>").description("create a worktree from a base ref and provision it (install deps + copy local-only config)").option("--from <ref>", "base ref to branch from", "origin/development").option("--path <path>", "worktree path (default: ../mmi-worktrees/<branch>)").option("--remote <name>", "remote to fetch the base from", "origin").option("--json", "machine-readable output").action(async (branch, o) => {
+  try {
+    const repoRoot = (await execFileP2("git", ["rev-parse", "--show-toplevel"], { timeout: GIT_TIMEOUT_MS }).catch(() => ({ stdout: "" }))).stdout.trim() || process.cwd();
+    const wtPath = o.path ?? defaultWorktreePath(repoRoot, branch);
+    const baseBranch = o.from.startsWith(`${o.remote}/`) ? o.from.slice(o.remote.length + 1) : void 0;
+    if (baseBranch) await execFileP2("git", ["fetch", o.remote, baseBranch], { timeout: GH_MUTATION_TIMEOUT_MS }).catch(() => void 0);
+    await execFileP2("git", ["worktree", "add", wtPath, "-b", branch, o.from], { timeout: GH_MUTATION_TIMEOUT_MS });
+    const report = await provisionWorktree(wtPath, makeProvisionDeps(wtPath, Boolean(o.json), (m) => {
+      if (!o.json) console.error(`  ${m}`);
+    }));
+    if (o.json) return console.log(JSON.stringify({ branch, path: wtPath, base: o.from, ...report }, null, 2));
+    console.log(`worktree ready: ${wtPath} (branch ${branch} from ${o.from})`);
+    console.log(`  installed: ${report.installed.map((i) => i.dir || ".").join(", ") || "none"}`);
+    console.log(`  copied: ${report.copied.join(", ") || "none"}`);
+  } catch (e) {
+    fail(`worktree create: ${e.message}`);
+  }
+});
+worktree.command("setup [path]").description("provision an existing worktree (install missing deps + copy local-only config); fired automatically by SessionStart").option("--quiet", "no output on success (for the detached SessionStart auto-fire worker)").option("--json", "machine-readable output").action(async (path2, o) => {
+  const root = path2 ?? process.cwd();
+  const release = acquireWorktreeSetupLock(root);
+  if (!release) {
+    if (!o.quiet && !o.json) console.log("worktree setup: another provision is in progress \u2014 skipping");
+    return;
+  }
+  try {
+    const report = await provisionWorktree(root, makeProvisionDeps(root, Boolean(o.quiet), (m) => {
+      if (!o.quiet && !o.json) console.error(`  ${m}`);
+    }));
+    if (o.json) return console.log(JSON.stringify({ path: root, ...report }, null, 2));
+    if (!o.quiet) {
+      console.log(`worktree provisioned: ${root}`);
+      console.log(`  installed: ${report.installed.map((i) => i.dir || ".").join(", ") || "none"}`);
+      console.log(`  copied: ${report.copied.join(", ") || "none"}`);
+    }
+  } catch (e) {
+    if (o.quiet) return void console.error(`[worktree-setup] ${e.message}`);
+    fail(`worktree setup: ${e.message}`);
+  } finally {
+    release();
+  }
+});
 var kb = program2.command("kb").description("org knowledgebase (read-only)");
 kb.command("get <path>").description("print a KB document by path").action(async (path2) => {
   const src = resolveKbSource((await loadConfig()).kbSource);
@@ -15006,7 +15796,7 @@ function detachPlanSync() {
   }
 }
 function makePlanDeps(cfg, io = consoleIo) {
-  const ensureDir = () => (0, import_node_fs16.mkdirSync)(PLANS_DIR, { recursive: true });
+  const ensureDir = () => (0, import_node_fs18.mkdirSync)(PLANS_DIR, { recursive: true });
   return {
     apiUrl: cfg.sagaApiUrl,
     fetch: (url, init = {}) => fetch(url, { ...init, signal: init.signal ?? AbortSignal.timeout(1e4) }),
@@ -15014,24 +15804,24 @@ function makePlanDeps(cfg, io = consoleIo) {
     project: async () => (await sagaKey(cfg)).project,
     readLocal: (slug) => {
       try {
-        return (0, import_node_fs16.readFileSync)(planPath(slug), "utf8");
+        return (0, import_node_fs18.readFileSync)(planPath(slug), "utf8");
       } catch {
         return null;
       }
     },
     writeLocal: (slug, content) => {
       ensureDir();
-      (0, import_node_fs16.writeFileSync)(planPath(slug), content, "utf8");
+      (0, import_node_fs18.writeFileSync)(planPath(slug), content, "utf8");
     },
     removeLocal: (slug) => {
       try {
-        (0, import_node_fs16.rmSync)(planPath(slug));
+        (0, import_node_fs18.rmSync)(planPath(slug));
       } catch {
       }
     },
     readMetaRaw: () => {
       try {
-        return (0, import_node_fs16.readFileSync)(META_FILE, "utf8");
+        return (0, import_node_fs18.readFileSync)(META_FILE, "utf8");
       } catch {
         return null;
       }
@@ -15042,7 +15832,7 @@ function makePlanDeps(cfg, io = consoleIo) {
     },
     readIndexRaw: () => {
       try {
-        return (0, import_node_fs16.readFileSync)(INDEX_FILE, "utf8");
+        return (0, import_node_fs18.readFileSync)(INDEX_FILE, "utf8");
       } catch {
         return null;
       }
@@ -15053,7 +15843,7 @@ function makePlanDeps(cfg, io = consoleIo) {
     },
     readQueueRaw: () => {
       try {
-        return (0, import_node_fs16.readFileSync)(QUEUE_FILE, "utf8");
+        return (0, import_node_fs18.readFileSync)(QUEUE_FILE, "utf8");
       } catch {
         return null;
       }
@@ -15622,7 +16412,7 @@ oauth.command("verify").description("probe Google authorize with an arbitrary po
   if (mismatch) process.exitCode = 1;
 });
 var issue = program2.command("issue").description("issues \u2014 reliable create with structured output");
-issue.command("create").description("create an issue (type \u2192 label) and print {number,url,label} JSON").requiredOption("--type <type>", "bug | feature | task (sets the matching label)").option("--title <title>", "issue title").option("--title-file <path|->", "read the issue title from a UTF-8 file, or from stdin with -").option("--body <body>", "issue body (markdown)").option("--body-file <path|->", "read issue body from a UTF-8 file, or from stdin with -").requiredOption("--priority <priority>", "urgent | high | medium | low (sets the board Priority field only \u2014 never a priority:* label, #416)").option("--repo <owner/repo>", "target repo (defaults to the current repo)").option("--label <label...>", "extra label(s) to attach (repeatable; auto-created if missing)").option("--parent <ref>", "file as a native sub-issue of this parent (#123, owner/repo#123, or URL)").option("--no-related", "skip the auto related-issues comment").action(async (o) => {
+issue.command("create").description("create an issue (type \u2192 label) and print {number,url,label} JSON").requiredOption("--type <type>", "bug | feature | task (sets the matching label)").option("--title <title>", "issue title").option("--title-file <path|->", "read the issue title from a UTF-8 file, or from stdin with -").option("--body <body>", "issue body (markdown)").option("--body-file <path|->", "read issue body from a UTF-8 file, or from stdin with -").option("--priority <priority>", "urgent | high | medium | low (sets the board Priority field only \u2014 never a priority:* label, #416)").option("--repo <owner/repo>", "target repo (defaults to the current repo)").option("--label <label...>", "extra label(s) to attach (repeatable; auto-created if missing)").option("--parent <ref>", "file as a native sub-issue of this parent (#123, owner/repo#123, or URL)").option("--no-related", "skip the auto related-issues comment").action(async (o) => {
   let args;
   let priority;
   let body;
@@ -15630,6 +16420,7 @@ issue.command("create").description("create an issue (type \u2192 label) and pri
   try {
     title = await resolveIssueTitle({ title: o.title, titleFile: o.titleFile }, { readFile: import_promises5.readFile, readStdin });
     body = await resolveIssueBody({ body: o.body, bodyFile: o.bodyFile }, { readFile: import_promises5.readFile, readStdin });
+    if (o.priority === void 0) throw new Error("missing --priority <priority> \u2014 expected one of: urgent, high, medium, low");
     priority = normalizePriority(o.priority);
     args = buildIssueArgs({ type: o.type, title, body, priority, repo: o.repo, labels: o.label });
     if (o.parent !== void 0) parseIssueRef(o.parent);
@@ -15980,9 +16771,9 @@ pr.command("create").description("create a PR and print {number,url} JSON").opti
   console.log(JSON.stringify(created));
 });
 async function listCiWorkflowPaths(cwd = process.cwd()) {
-  const wfDir = (0, import_node_path14.join)(cwd, ".github", "workflows");
-  if (!(0, import_node_fs16.existsSync)(wfDir)) return [];
-  return (0, import_node_fs16.readdirSync)(wfDir).filter((name) => /\.(ya?ml)$/i.test(name)).map((name) => `.github/workflows/${name}`);
+  const wfDir = (0, import_node_path16.join)(cwd, ".github", "workflows");
+  if (!(0, import_node_fs18.existsSync)(wfDir)) return [];
+  return (0, import_node_fs18.readdirSync)(wfDir).filter((name) => /\.(ya?ml)$/i.test(name)).map((name) => `.github/workflows/${name}`);
 }
 async function resolveMergeCiPolicyForCheckout(repoOpt) {
   const repo = repoOpt ?? await resolveRepo();
@@ -16104,7 +16895,7 @@ async function createDeferredWorktreeStore() {
       },
       write: async (entries) => {
         try {
-          await (0, import_promises5.mkdir)((0, import_node_path14.dirname)(registryPath), { recursive: true });
+          await (0, import_promises5.mkdir)((0, import_node_path16.dirname)(registryPath), { recursive: true });
           await (0, import_promises5.writeFile)(registryPath, serializeDeferredWorktrees(entries), "utf8");
         } catch {
         }
@@ -16123,7 +16914,7 @@ function worktreeRemoveDeps(execGit) {
 }
 function teardownWorktreeStage(worktreePath) {
   return runWorktreeStageTeardown(worktreePath, {
-    hasStageState: (wt) => (0, import_node_fs16.existsSync)(stageStatePath(wt)),
+    hasStageState: (wt) => (0, import_node_fs18.existsSync)(stageStatePath(wt)),
     stopRecordedStage: async (wt) => (await stopStage({ cwd: wt })).pid,
     listComposeProjects: async () => {
       const { stdout } = await execFileP2("docker", ["compose", "ls", "--all", "--format", "json"], { timeout: GC_GH_TIMEOUT_MS });
@@ -16186,7 +16977,7 @@ pr.command("merge <number>").description("merge a PR (squash by default) and cle
     } : await cleanupPrMergeLocalBranch(headRef, {
       beforeWorktrees,
       startingPath,
-      pathExists: (p) => (0, import_node_fs16.existsSync)(p),
+      pathExists: (p) => (0, import_node_fs18.existsSync)(p),
       execGit: async (args) => (await execFileP2("git", args, { timeout: GIT_TIMEOUT_MS })).stdout,
       teardownWorktreeStage,
       deferredStore,
@@ -16358,7 +17149,7 @@ function rawValues(flag) {
   return out;
 }
 function printLine(value) {
-  (0, import_node_fs16.writeSync)(1, `${value}
+  (0, import_node_fs18.writeSync)(1, `${value}
 `);
 }
 function stageKeepAlive() {
@@ -16375,8 +17166,8 @@ async function resolveStage() {
     local,
     shell: shellFor(),
     registry: { deployModel: project2?.deployModel, portRange, error: read.ok ? void 0 : read.error },
-    hasCompose: (0, import_node_fs16.existsSync)((0, import_node_path14.join)(process.cwd(), "docker-compose.yml")),
-    hasEnvExample: (0, import_node_fs16.existsSync)((0, import_node_path14.join)(process.cwd(), ".env.example"))
+    hasCompose: (0, import_node_fs18.existsSync)((0, import_node_path16.join)(process.cwd(), "docker-compose.yml")),
+    hasEnvExample: (0, import_node_fs18.existsSync)((0, import_node_path16.join)(process.cwd(), ".env.example"))
   });
 }
 async function fetchStageVaultEnvMerge() {
@@ -16428,9 +17219,9 @@ program2.command("port-range <repo>").description("assign (idempotently) + print
     printLine(o.json ? JSON.stringify({ repo, portRange: [start2, end2], source: "meta" }) : `${repo}: stage.portRange [${start2}, ${end2}]`);
     return;
   }
-  const path2 = (0, import_node_path14.join)(process.cwd(), "infra", "port-ranges.json");
+  const path2 = (0, import_node_path16.join)(process.cwd(), "infra", "port-ranges.json");
   const allocate = async (seed) => {
-    const { stdout } = await execFileP2("node", [(0, import_node_path14.join)(process.cwd(), "infra", "port-ddb.mjs"), String(seed)], { timeout: 15e3 });
+    const { stdout } = await execFileP2("node", [(0, import_node_path16.join)(process.cwd(), "infra", "port-ddb.mjs"), String(seed)], { timeout: 15e3 });
     const parsed = JSON.parse(stdout);
     if (!Array.isArray(parsed.range) || parsed.range.length !== 2) throw new Error("port-ddb: no range in output");
     return parsed.range;
@@ -16801,7 +17592,7 @@ bootstrap.command("verify <repo>").description("audit whether an existing repo i
   const report = await verifyBootstrap(repo, o.class, {
     client: defaultGitHubClient(),
     projectMeta: meta,
-    readLocalFile: (path2) => path2 === "projects.json" && apiProjects != null ? apiProjects : (0, import_node_fs16.existsSync)(path2) ? (0, import_node_fs16.readFileSync)(path2, "utf8") : null,
+    readLocalFile: (path2) => path2 === "projects.json" && apiProjects != null ? apiProjects : (0, import_node_fs18.existsSync)(path2) ? (0, import_node_fs18.readFileSync)(path2, "utf8") : null,
     // requiredGcpApis is stored as an array by a JSON write, but `project set --var KEY=VALUE` stores a raw
     // comma-string — accept either so the seeded value verifies regardless of how it was written.
     requiredGcpApis: (() => {
@@ -16844,12 +17635,12 @@ bootstrap.command("apply <repo>").description("idempotent seed apply from skills
     return fail(`bootstrap apply: ${e.message}`);
   }
   const manifestPath = "skills/bootstrap/seeds/manifest.json";
-  if (!(0, import_node_fs16.existsSync)(manifestPath)) return fail(`bootstrap apply: ${manifestPath} not found; run from the MMI-Hub repo root`);
-  const manifest = loadBootstrapSeeds((0, import_node_fs16.readFileSync)(manifestPath, "utf8"));
+  if (!(0, import_node_fs18.existsSync)(manifestPath)) return fail(`bootstrap apply: ${manifestPath} not found; run from the MMI-Hub repo root`);
+  const manifest = loadBootstrapSeeds((0, import_node_fs18.readFileSync)(manifestPath, "utf8"));
   const baseBranch = o.class === "content" ? "main" : "development";
   const slug = parsedRepo.slug;
   const gh = async (args) => execFileP2("gh", args, { timeout: 2e4 });
-  const readFile5 = (p) => (0, import_node_fs16.existsSync)(p) ? (0, import_node_fs16.readFileSync)(p, "utf8") : null;
+  const readFile5 = (p) => (0, import_node_fs18.existsSync)(p) ? (0, import_node_fs18.readFileSync)(p, "utf8") : null;
   const enc2 = (p) => p.split("/").map(encodeURIComponent).join("/");
   const rawVars = {};
   for (const value of rawValues("--var")) {
@@ -17078,16 +17869,16 @@ access.command("audit").description("audit collaborator roles + train-branch pus
     if (o.class !== "deployable" && o.class !== "content") return failGraceful("access audit: --class must be deployable or content");
     targets = [{ repo: o.repo, class: o.class }];
   } else {
-    const projectsJson = registryProjects ? JSON.stringify({ projects: registryProjects }) : (0, import_node_fs16.existsSync)("projects.json") ? (0, import_node_fs16.readFileSync)("projects.json", "utf8") : null;
+    const projectsJson = registryProjects ? JSON.stringify({ projects: registryProjects }) : (0, import_node_fs18.existsSync)("projects.json") ? (0, import_node_fs18.readFileSync)("projects.json", "utf8") : null;
     if (!projectsJson) return failGraceful("access audit: no project registry \u2014 Hub API unreachable and projects.json not found; run from the MMI-Hub repo root or pass --repo <owner/repo>");
-    const fanoutJson = (0, import_node_fs16.existsSync)(".github/fanout-targets.json") ? (0, import_node_fs16.readFileSync)(".github/fanout-targets.json", "utf8") : null;
+    const fanoutJson = (0, import_node_fs18.existsSync)(".github/fanout-targets.json") ? (0, import_node_fs18.readFileSync)(".github/fanout-targets.json", "utf8") : null;
     targets = loadAccessTargets(projectsJson, fanoutJson);
   }
   const derivedMatrix = registryProjects ? accessMatrixFromProjects(registryProjects) : {};
-  const fileMatrix = (0, import_node_fs16.existsSync)("access-matrix.json") ? loadAccessMatrix((0, import_node_fs16.readFileSync)("access-matrix.json", "utf8")) : {};
+  const fileMatrix = (0, import_node_fs18.existsSync)("access-matrix.json") ? loadAccessMatrix((0, import_node_fs18.readFileSync)("access-matrix.json", "utf8")) : {};
   const matrix = mergeAccessMatrix(fileMatrix, derivedMatrix);
   const derivedContracts = registryProjects ? dataAccessContractsFromProjects(registryProjects) : { consumers: {} };
-  const fileContracts = (0, import_node_fs16.existsSync)("data-access-contracts.json") ? loadDataAccessContracts((0, import_node_fs16.readFileSync)("data-access-contracts.json", "utf8")) : { consumers: {} };
+  const fileContracts = (0, import_node_fs18.existsSync)("data-access-contracts.json") ? loadDataAccessContracts((0, import_node_fs18.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));
@@ -17096,20 +17887,20 @@ access.command("audit").description("audit collaborator roles + train-branch pus
 var isWin = process.platform === "win32";
 var installedPluginsPath = (surface = detectSurface(process.env)) => {
   const homeDir = surface === "codex" ? ".codex" : ".claude";
-  return (0, import_node_path14.join)((0, import_node_os5.homedir)(), homeDir, "plugins", "installed_plugins.json");
+  return (0, import_node_path16.join)((0, import_node_os5.homedir)(), homeDir, "plugins", "installed_plugins.json");
 };
 function readInstalledPlugins() {
   try {
-    return JSON.parse((0, import_node_fs16.readFileSync)(installedPluginsPath(), "utf8"));
+    return JSON.parse((0, import_node_fs18.readFileSync)(installedPluginsPath(), "utf8"));
   } catch {
     return null;
   }
 }
 function installedPluginSources() {
   return ["claude", "codex"].map((surface) => {
-    const recordPath = (0, import_node_path14.join)((0, import_node_os5.homedir)(), `.${surface}`, "plugins", "installed_plugins.json");
+    const recordPath = (0, import_node_path16.join)((0, import_node_os5.homedir)(), `.${surface}`, "plugins", "installed_plugins.json");
     try {
-      return { surface, installed: JSON.parse((0, import_node_fs16.readFileSync)(recordPath, "utf8")), recordPath };
+      return { surface, installed: JSON.parse((0, import_node_fs18.readFileSync)(recordPath, "utf8")), recordPath };
     } catch {
       return { surface, installed: null, recordPath };
     }
@@ -17117,7 +17908,7 @@ function installedPluginSources() {
 }
 function readClaudeSettings() {
   try {
-    return JSON.parse((0, import_node_fs16.readFileSync)((0, import_node_path14.join)(process.cwd(), ".claude", "settings.json"), "utf8"));
+    return JSON.parse((0, import_node_fs18.readFileSync)((0, import_node_path16.join)(process.cwd(), ".claude", "settings.json"), "utf8"));
   } catch {
     return null;
   }
@@ -17139,7 +17930,7 @@ function writeProjectInstallRecord(record) {
     const list = file.plugins[MMI_PLUGIN_ID] ?? [];
     list.push(record);
     file.plugins[MMI_PLUGIN_ID] = list;
-    (0, import_node_fs16.writeFileSync)(installedPluginsPath(), `${JSON.stringify(file, null, 2)}
+    (0, import_node_fs18.writeFileSync)(installedPluginsPath(), `${JSON.stringify(file, null, 2)}
 `, "utf8");
     return true;
   } catch {
@@ -17152,9 +17943,9 @@ function backupAndWriteInstalledPlugins(records, pluginId) {
     if (!file) return false;
     if (!file.plugins) file.plugins = {};
     const path2 = installedPluginsPath();
-    (0, import_node_fs16.copyFileSync)(path2, `${path2}.bak`);
+    (0, import_node_fs18.copyFileSync)(path2, `${path2}.bak`);
     file.plugins[pluginId] = records;
-    (0, import_node_fs16.writeFileSync)(path2, `${JSON.stringify(file, null, 2)}
+    (0, import_node_fs18.writeFileSync)(path2, `${JSON.stringify(file, null, 2)}
 `, "utf8");
     return true;
   } catch {
@@ -17162,35 +17953,35 @@ function backupAndWriteInstalledPlugins(records, pluginId) {
   }
 }
 function cursorPluginCacheRoot() {
-  return (0, import_node_path14.join)((0, import_node_os5.homedir)(), ".cursor", "plugins", "cache", "mmi", "mmi");
+  return (0, import_node_path16.join)((0, import_node_os5.homedir)(), ".cursor", "plugins", "cache", "mmi", "mmi");
 }
 function cursorPluginCachePinSnapshots() {
   const root = cursorPluginCacheRoot();
   try {
-    return (0, import_node_fs16.readdirSync)(root, { withFileTypes: true }).filter((entry) => entry.isDirectory() && !entry.name.startsWith(".")).map((entry) => {
-      const path2 = (0, import_node_path14.join)(root, entry.name);
-      const pluginJson = (0, import_node_path14.join)(path2, ".cursor-plugin", "plugin.json");
-      const hooksJson = (0, import_node_path14.join)(path2, "hooks", "hooks.json");
-      const cliBundle = (0, import_node_path14.join)(path2, "cli", "dist", "index.cjs");
+    return (0, import_node_fs18.readdirSync)(root, { withFileTypes: true }).filter((entry) => entry.isDirectory() && !entry.name.startsWith(".")).map((entry) => {
+      const path2 = (0, import_node_path16.join)(root, entry.name);
+      const pluginJson = (0, import_node_path16.join)(path2, ".cursor-plugin", "plugin.json");
+      const hooksJson = (0, import_node_path16.join)(path2, "hooks", "hooks.json");
+      const cliBundle = (0, import_node_path16.join)(path2, "cli", "dist", "index.cjs");
       let version;
       try {
-        const raw = JSON.parse((0, import_node_fs16.readFileSync)(pluginJson, "utf8"));
+        const raw = JSON.parse((0, import_node_fs18.readFileSync)(pluginJson, "utf8"));
         version = typeof raw.version === "string" ? raw.version : void 0;
       } catch {
         version = void 0;
       }
       let isEmpty = true;
       try {
-        isEmpty = (0, import_node_fs16.readdirSync)(path2).length === 0;
+        isEmpty = (0, import_node_fs18.readdirSync)(path2).length === 0;
       } catch {
         isEmpty = true;
       }
       return {
         name: entry.name,
         path: path2,
-        hasPluginJson: (0, import_node_fs16.existsSync)(pluginJson),
-        hasHooksJson: (0, import_node_fs16.existsSync)(hooksJson),
-        hasCliBundle: (0, import_node_fs16.existsSync)(cliBundle),
+        hasPluginJson: (0, import_node_fs18.existsSync)(pluginJson),
+        hasHooksJson: (0, import_node_fs18.existsSync)(hooksJson),
+        hasCliBundle: (0, import_node_fs18.existsSync)(cliBundle),
         isEmpty,
         version
       };
@@ -17200,19 +17991,19 @@ function cursorPluginCachePinSnapshots() {
   }
 }
 function hubCheckoutForCursorSeed() {
-  const manifest = (0, import_node_path14.join)(process.cwd(), "plugins", "mmi", ".cursor-plugin", "plugin.json");
-  return (0, import_node_fs16.existsSync)(manifest) ? process.cwd() : void 0;
+  const manifest = (0, import_node_path16.join)(process.cwd(), "plugins", "mmi", ".cursor-plugin", "plugin.json");
+  return (0, import_node_fs18.existsSync)(manifest) ? process.cwd() : void 0;
 }
 function mmiPluginCacheRootSnapshots() {
   const roots = [
-    { surface: "claude", root: (0, import_node_path14.join)((0, import_node_os5.homedir)(), ".claude", "plugins", "cache", "mmi", "mmi") },
-    { surface: "codex", root: (0, import_node_path14.join)((0, import_node_os5.homedir)(), ".codex", "plugins", "cache", "mmi", "mmi") }
+    { surface: "claude", root: (0, import_node_path16.join)((0, import_node_os5.homedir)(), ".claude", "plugins", "cache", "mmi", "mmi") },
+    { surface: "codex", root: (0, import_node_path16.join)((0, import_node_os5.homedir)(), ".codex", "plugins", "cache", "mmi", "mmi") }
   ];
   return roots.flatMap(({ surface, root }) => {
     try {
-      const entries = (0, import_node_fs16.readdirSync)(root, { withFileTypes: true }).map((entry) => ({
+      const entries = (0, import_node_fs18.readdirSync)(root, { withFileTypes: true }).map((entry) => ({
         name: entry.name,
-        path: (0, import_node_path14.join)(root, entry.name),
+        path: (0, import_node_path16.join)(root, entry.name),
         isDirectory: entry.isDirectory()
       }));
       return [{ surface, root, entries }];
@@ -17223,7 +18014,7 @@ function mmiPluginCacheRootSnapshots() {
 }
 function hasNestedMmiChild(versionDir) {
   try {
-    return (0, import_node_fs16.statSync)((0, import_node_path14.join)(versionDir, "mmi")).isDirectory();
+    return (0, import_node_fs18.statSync)((0, import_node_path16.join)(versionDir, "mmi")).isDirectory();
   } catch {
     return false;
   }
@@ -17234,26 +18025,28 @@ function nestedPluginTreeSnapshot() {
   );
 }
 function uniqueQuarantineTarget(path2) {
-  if (!(0, import_node_fs16.existsSync)(path2)) return path2;
+  if (!(0, import_node_fs18.existsSync)(path2)) return path2;
   for (let i = 1; i < 100; i += 1) {
     const candidate = `${path2}-${i}`;
-    if (!(0, import_node_fs16.existsSync)(candidate)) return candidate;
+    if (!(0, import_node_fs18.existsSync)(candidate)) return candidate;
   }
   return `${path2}-${Date.now()}`;
 }
 function quarantinePluginCacheDirs(plan2) {
   let moved = 0;
+  const failed = [];
   for (const move of plan2) {
     try {
-      if (!(0, import_node_fs16.existsSync)(move.from)) continue;
+      if (!(0, import_node_fs18.existsSync)(move.from)) continue;
       const target = uniqueQuarantineTarget(move.to);
-      (0, import_node_fs16.mkdirSync)((0, import_node_path14.dirname)(target), { recursive: true });
-      (0, import_node_fs16.renameSync)(move.from, target);
+      (0, import_node_fs18.mkdirSync)((0, import_node_path16.dirname)(target), { recursive: true });
+      (0, import_node_fs18.renameSync)(move.from, target);
       moved += 1;
     } catch {
+      failed.push(move);
     }
   }
-  return moved;
+  return { moved, failed };
 }
 async function robocopyMirrorEmpty(emptyDir, target) {
   try {
@@ -17266,23 +18059,23 @@ async function robocopyMirrorEmpty(emptyDir, target) {
 }
 async function clearNestedPluginTreeDir(targetPath) {
   try {
-    if (!(0, import_node_fs16.existsSync)(targetPath)) return true;
+    if (!(0, import_node_fs18.existsSync)(targetPath)) return true;
     if (isWin) {
-      const emptyDir = (0, import_node_path14.join)((0, import_node_os5.tmpdir)(), `mmi-empty-${Date.now()}`);
-      (0, import_node_fs16.mkdirSync)(emptyDir, { recursive: true });
+      const emptyDir = (0, import_node_path16.join)((0, import_node_os5.tmpdir)(), `mmi-empty-${Date.now()}`);
+      (0, import_node_fs18.mkdirSync)(emptyDir, { recursive: true });
       try {
         await robocopyMirrorEmpty(emptyDir, targetPath);
-        (0, import_node_fs16.rmSync)(targetPath, { recursive: true, force: true });
+        (0, import_node_fs18.rmSync)(targetPath, { recursive: true, force: true });
       } finally {
         try {
-          (0, import_node_fs16.rmSync)(emptyDir, { recursive: true, force: true });
+          (0, import_node_fs18.rmSync)(emptyDir, { recursive: true, force: true });
         } catch {
         }
       }
-      return !(0, import_node_fs16.existsSync)(targetPath);
+      return !(0, import_node_fs18.existsSync)(targetPath);
     }
-    (0, import_node_fs16.rmSync)(targetPath, { recursive: true, force: true });
-    return !(0, import_node_fs16.existsSync)(targetPath);
+    (0, import_node_fs18.rmSync)(targetPath, { recursive: true, force: true });
+    return !(0, import_node_fs18.existsSync)(targetPath);
   } catch {
     return false;
   }
@@ -17295,11 +18088,11 @@ async function applyNestedPluginTreeCleanup(paths, log) {
   }
   return true;
 }
-var gitignorePath = () => (0, import_node_path14.join)(process.cwd(), ".gitignore");
+var gitignorePath = () => (0, import_node_path16.join)(process.cwd(), ".gitignore");
 function readTextFile(path2) {
   try {
-    if (!(0, import_node_fs16.existsSync)(path2)) return null;
-    return (0, import_node_fs16.readFileSync)(path2, "utf8");
+    if (!(0, import_node_fs18.existsSync)(path2)) return null;
+    return (0, import_node_fs18.readFileSync)(path2, "utf8");
   } catch {
     return null;
   }
@@ -17308,9 +18101,9 @@ function playwrightMcpConfigSnapshots() {
   const cwd = process.cwd();
   const home = (0, import_node_os5.homedir)();
   const candidates = [
-    (0, import_node_path14.join)(cwd, ".cursor", "mcp.json"),
-    (0, import_node_path14.join)(home, ".cursor", "mcp.json"),
-    (0, import_node_path14.join)(home, ".codex", "config.toml")
+    (0, import_node_path16.join)(cwd, ".cursor", "mcp.json"),
+    (0, import_node_path16.join)(home, ".cursor", "mcp.json"),
+    (0, import_node_path16.join)(home, ".codex", "config.toml")
   ];
   const out = [];
   for (const path2 of candidates) {
@@ -17323,7 +18116,7 @@ function strayBrowserArtifactPaths() {
   const cwd = process.cwd();
   return STRAY_BROWSER_ARTIFACT_DIRS.filter((rel) => {
     try {
-      return (0, import_node_fs16.existsSync)((0, import_node_path14.join)(cwd, rel));
+      return (0, import_node_fs18.existsSync)((0, import_node_path16.join)(cwd, rel));
     } catch {
       return false;
     }
@@ -17331,14 +18124,14 @@ function strayBrowserArtifactPaths() {
 }
 function readGitignore() {
   try {
-    return (0, import_node_fs16.readFileSync)(gitignorePath(), "utf8");
+    return (0, import_node_fs18.readFileSync)(gitignorePath(), "utf8");
   } catch {
     return null;
   }
 }
 function writeGitignore(content) {
   try {
-    (0, import_node_fs16.writeFileSync)(gitignorePath(), content, "utf8");
+    (0, import_node_fs18.writeFileSync)(gitignorePath(), content, "utf8");
     return true;
   } catch {
     return false;
@@ -17377,7 +18170,7 @@ async function runDoctor(opts, io = consoleIo) {
   let onPath = pathProbe;
   if (!onPath) {
     const root = process.env.CLAUDE_PLUGIN_ROOT;
-    if (root && (0, import_node_fs16.existsSync)(`${root}/bin/mmi-cli${isWin ? ".cmd" : ""}`)) onPath = true;
+    if (root && (0, import_node_fs18.existsSync)(`${root}/bin/mmi-cli${isWin ? ".cmd" : ""}`)) onPath = true;
   }
   checks.push({ ok: onPath, label: "mmi-cli on PATH", fix: "auto-provisioned at session start \u2014 reopen the session, or install the MMI plugin" });
   const surface = detectSurface(process.env);
@@ -17494,7 +18287,8 @@ async function runDoctor(opts, io = consoleIo) {
     installedVersions: installedPluginVersions(installed)
   });
   if (!cacheCleanupCheck.ok && cacheCleanupCheck.quarantinePlan && repairLocal) {
-    const moved = quarantinePluginCacheDirs(cacheCleanupCheck.quarantinePlan);
+    const { moved, failed } = quarantinePluginCacheDirs(cacheCleanupCheck.quarantinePlan);
+    const attempted = moved + failed.length;
     if (moved > 0) {
       const surfaces = [...new Set(cacheCleanupCheck.leftovers?.map((entry) => entry.surface) ?? [])].join("/");
       const names = cacheCleanupCheck.leftovers?.map((entry) => entry.name).join(", ");
@@ -17505,8 +18299,12 @@ async function runDoctor(opts, io = consoleIo) {
         isOrgRepo: Boolean(cfg.sagaApiUrl),
         roots: mmiPluginCacheRootSnapshots(),
         activeVersion: resolveClientVersion(),
-        releasedVersion
+        releasedVersion,
+        installedVersions: installedPluginVersions(installed)
       }),
+      attemptedCount: attempted,
+      failedCount: failed.length,
+      ...failed.length > 0 ? { failedMoves: failed } : {},
       ...moved > 0 ? { cleanedCount: moved } : {}
     };
   }
@@ -17544,7 +18342,7 @@ async function runDoctor(opts, io = consoleIo) {
     isOrgRepo: Boolean(cfg.sagaApiUrl),
     surface,
     cacheRoot: cursorCacheRoot,
-    cacheRootExists: (0, import_node_fs16.existsSync)(cursorCacheRoot),
+    cacheRootExists: (0, import_node_fs18.existsSync)(cursorCacheRoot),
     pins: cursorPins,
     hubCheckout: hubCheckoutForCursorSeed(),
     releasedVersion
@@ -17555,7 +18353,7 @@ async function runDoctor(opts, io = consoleIo) {
       releasedVersion,
       hubCheckout: hubCheckoutForCursorSeed(),
       execFileP: execFileP2,
-      mkdtemp: (prefix) => (0, import_promises5.mkdtemp)((0, import_node_path14.join)((0, import_node_os5.tmpdir)(), prefix)),
+      mkdtemp: (prefix) => (0, import_promises5.mkdtemp)((0, import_node_path16.join)((0, import_node_os5.tmpdir)(), prefix)),
       log: (m) => io.err(m)
     });
     if (seeded) {
@@ -17564,7 +18362,7 @@ async function runDoctor(opts, io = consoleIo) {
         isOrgRepo: Boolean(cfg.sagaApiUrl),
         surface,
         cacheRoot: cursorCacheRoot,
-        cacheRootExists: (0, import_node_fs16.existsSync)(cursorCacheRoot),
+        cacheRootExists: (0, import_node_fs18.existsSync)(cursorCacheRoot),
         pins: cursorPins,
         hubCheckout: hubCheckoutForCursorSeed(),
         releasedVersion
@@ -17647,6 +18445,7 @@ program2.command("session-start").description("run the SessionStart verbs (rules
   const { parallel, sequential } = buildSessionStartPlan({
     rulesSync: (io) => runRulesSync({ quiet: true }, io),
     sagaShow: (io) => runSagaShow({ quiet: true }, io),
+    handoffOffer: (io) => runHandoffOffer(io, { fast: true }),
     // honcho profile (#1162): inject the behavioral-memory prior (peer card). Bounded + fail-soft +
     // silent when off/empty, so it never delays or noises the session banner.
     honchoContext: (io) => runHonchoContext({ quiet: true, banner: true }, io),
@@ -17680,6 +18479,12 @@ program2.command("session-start").description("run the SessionStart verbs (rules
   await runSessionStart(parallel, sequential, consoleIo);
   consoleIo.log(northstarPointer(northstarInjected));
   for (const line of planStoreLines(process.cwd())) consoleIo.log(line);
+  for (const line of scratchGcLines(process.cwd())) consoleIo.log(line);
+  const worktreeBanner = worktreeAutoProvisionBanner(process.cwd());
+  if (worktreeBanner) {
+    spawnDetachedSelf(["worktree", "setup", "--quiet"], { spawn: import_node_child_process10.spawn, execPath: process.execPath, scriptPath: process.argv[1] });
+    consoleIo.log(worktreeBanner);
+  }
 });
 installProcessBackstop();
 program2.parseAsync().catch((e) => failGraceful(e.message));