@mutmutco/hub 4.0.15 → 4.0.16

package/dist/index.cjs

@@ -21,6 +21,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  buildWatcherCommand: () => buildWatcherCommand,
+  clearPending: () => clearPending,
   enumerateSurfaces: () => enumerateSurfaces,
   failConsequence: () => failConsequence,
   formatReconcileReport: () => formatReconcileReport,
@@ -31,24 +33,32 @@ __export(index_exports, {
   launcherSh: () => launcherSh,
   launcherVbs: () => launcherVbs,
   localStartBoundary: () => localStartBoundary,
+  lockShaped: () => lockShaped,
   main: () => main,
+  noteBusyDefer: () => noteBusyDefer,
   ownVersion: () => ownVersion,
+  pendingPath: () => pendingPath,
+  pidAlive: () => pidAlive,
   probeHermesInstallation: () => probeHermesInstallation,
   progressiveRow: () => progressiveRow,
+  readPending: () => readPending,
   reconcileCursorUserHooks: () => reconcileCursorUserHooks,
   reportFooterLines: () => reportFooterLines,
   retryHint: () => retryHint,
+  schedulePendingWatcher: () => schedulePendingWatcher,
   schedulerStatus: () => schedulerStatus,
   startSpinner: () => startSpinner,
   systemdServiceUnit: () => systemdServiceUnit,
   systemdTimerUnit: () => systemdTimerUnit,
   taskXml: () => taskXml,
   updateHeader: () => updateHeader,
-  wrapWords: () => wrapWords
+  watcherLockPath: () => watcherLockPath,
+  wrapWords: () => wrapWords,
+  writePending: () => writePending
 });
 module.exports = __toCommonJS(index_exports);
-var import_node_fs16 = require("node:fs");
-var import_node_path13 = require("node:path");
+var import_node_fs17 = require("node:fs");
+var import_node_path14 = require("node:path");
 
 // src/state.ts
 var import_node_fs = require("node:fs");
@@ -400,16 +410,160 @@ function enumerateSurfaces(env = process.env) {
 }
 
 // src/arm-cli.ts
-var import_node_fs5 = require("node:fs");
+var import_node_fs6 = require("node:fs");
+var import_node_child_process4 = require("node:child_process");
+var import_node_path5 = require("node:path");
+
+// src/pending.ts
 var import_node_child_process3 = require("node:child_process");
+var import_node_fs5 = require("node:fs");
 var import_node_path4 = require("node:path");
+function hubDistPath(env) {
+  const root = globalRoot(env);
+  return root ? (0, import_node_path4.join)(root, "@mutmutco", "hub", "dist", "index.cjs") : null;
+}
+var WATCHER_MAX_WAIT_MS = 4 * 60 * 60 * 1e3;
+function pendingPath(paths) {
+  return (0, import_node_path4.join)(paths.root, "pending.json");
+}
+function watcherLockPath(paths) {
+  return (0, import_node_path4.join)(paths.root, "pending-watcher.lock.d");
+}
+function readPending(paths) {
+  try {
+    const parsed = JSON.parse((0, import_node_fs5.readFileSync)(pendingPath(paths), "utf8"));
+    if (!Array.isArray(parsed)) return [];
+    return parsed.filter((row) => Boolean(row) && typeof row === "object" && typeof row.surface === "string" && typeof row.target === "string" && Array.isArray(row.images) && Array.isArray(row.dirs));
+  } catch {
+    return [];
+  }
+}
+function writePending(paths, records) {
+  (0, import_node_fs5.mkdirSync)(paths.root, { recursive: true });
+  const path = pendingPath(paths);
+  const tmp = `${path}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+  (0, import_node_fs5.writeFileSync)(tmp, `${JSON.stringify(records, null, 2)}
+`, "utf8");
+  (0, import_node_fs5.renameSync)(tmp, path);
+}
+function clearPending(paths, surface) {
+  const records = readPending(paths);
+  if (!records.some((row) => row.surface === surface)) return;
+  writePending(paths, records.filter((row) => row.surface !== surface));
+}
+function pidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error?.code === "EPERM";
+  }
+}
+function lockShaped(detail) {
+  return /EPERM|EBUSY|EACCES|locked|access is denied/i.test(detail);
+}
+function quotePs(value) {
+  return `'${value.replace(/'/gu, "''")}'`;
+}
+function quoteSh(value) {
+  return `'${value.replace(/'/gu, "'\\''")}'`;
+}
+function escapeEre(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+}
+function buildWatcherCommand(opts) {
+  const platform = opts.platform ?? process.platform;
+  const maxWaitMs = opts.maxWaitMs ?? WATCHER_MAX_WAIT_MS;
+  const apply = [opts.node, opts.hubDist, "update"];
+  if (platform === "win32") {
+    const imageChecks2 = opts.images.map((image) => `if (Get-Process -Name ${quotePs(image)} -ErrorAction SilentlyContinue) { return $true }`);
+    const dirChecks2 = opts.dirs.map((dir) => `if (Get-CimInstance Win32_Process -ErrorAction SilentlyContinue | Where-Object { $_.ProcessId -ne $PID -and $_.CommandLine -and $_.CommandLine.IndexOf(${quotePs(dir)}, [System.StringComparison]::OrdinalIgnoreCase) -ge 0 }) { return $true }`);
+    const testBusy2 = `function Test-Busy { ${[...imageChecks2, ...dirChecks2].join("; ")}; return $false }`;
+    const wait2 = `$deadline = (Get-Date).AddMilliseconds(${maxWaitMs}); while ((Get-Date) -lt $deadline -and (Test-Busy)) { Start-Sleep -Seconds 5 }; if (Test-Busy) { exit 0 }`;
+    const lock2 = `$lock = ${quotePs(opts.lockPath)}; if (Test-Path $lock) { $owner = Get-Content "$lock\\pid" -ErrorAction SilentlyContinue; if ($owner -and -not (Get-Process -Id $owner -ErrorAction SilentlyContinue)) { Remove-Item $lock -Recurse -Force -ErrorAction SilentlyContinue } }`;
+    const run2 = `if (New-Item -ItemType Directory -Path $lock -ErrorAction SilentlyContinue) { $PID | Set-Content "$lock\\pid"; try { & ${apply.map(quotePs).join(" ")} *> ${quotePs(opts.logPath)}; Set-Content -Path ${quotePs(opts.codePath)} -Value $LASTEXITCODE } finally { Remove-Item $lock -Recurse -Force -ErrorAction SilentlyContinue } }`;
+    return {
+      file: "powershell",
+      args: ["-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-Command", `${testBusy2}; ${wait2}; ${lock2}; ${run2}`]
+    };
+  }
+  const imageChecks = opts.images.map((image) => `pgrep -xi ${quoteSh(image)} >/dev/null 2>&1 && return 0`);
+  const dirChecks = opts.dirs.map((dir) => `[ -n "$(pgrep -f ${quoteSh(escapeEre(dir))} | grep -vx $$)" ] && return 0`);
+  const testBusy = `test_busy() { ${[...imageChecks, ...dirChecks].join("; ") || ":"}; return 1; }`;
+  const wait = `deadline=$(( $(date +%s) + ${Math.floor(maxWaitMs / 1e3)} )); while [ "$(date +%s)" -lt "$deadline" ] && test_busy; do sleep 5; done; test_busy && exit 0`;
+  const lock = `if [ -d ${quoteSh(opts.lockPath)} ]; then owner=$(cat ${quoteSh(`${opts.lockPath}/pid`)} 2>/dev/null); if [ -n "$owner" ] && ! kill -0 "$owner" 2>/dev/null; then rm -rf ${quoteSh(opts.lockPath)}; fi; fi`;
+  const run = `if mkdir ${quoteSh(opts.lockPath)} 2>/dev/null; then echo $$ > ${quoteSh(`${opts.lockPath}/pid`)}; trap "rm -rf ${quoteSh(opts.lockPath)}" EXIT; ${apply.map(quoteSh).join(" ")} > ${quoteSh(opts.logPath)} 2>&1; echo $? > ${quoteSh(opts.codePath)}; fi`;
+  return { file: "sh", args: ["-c", `${testBusy}; ${wait}; ${lock}; ${run}`] };
+}
+function defaultDetachSpawn(file, args) {
+  const child = (0, import_node_child_process3.spawn)(file, [...args], {
+    detached: process.platform !== "win32",
+    stdio: "ignore",
+    windowsHide: true,
+    shell: false
+  });
+  child.on("error", () => {
+  });
+  child.unref();
+  return child.pid ?? null;
+}
+function schedulePendingWatcher(paths, env = process.env, seam = {}) {
+  const records = readPending(paths);
+  if (!records.length) return { scheduled: false, reason: "no pending applies" };
+  const live = records.find((row) => row.watcherPid && pidAlive(row.watcherPid));
+  if (live) return { scheduled: false, reason: `watcher pid ${live.watcherPid} is already waiting` };
+  const hubDist = seam.hubDist ?? hubDistPath(env);
+  if (!hubDist || !(0, import_node_fs5.existsSync)(hubDist)) return { scheduled: false, reason: "the installed hub bundle is unresolvable \u2014 the hourly tick remains the retry" };
+  const command = buildWatcherCommand({
+    images: [...new Set(records.flatMap((row) => row.images))],
+    dirs: [...new Set(records.flatMap((row) => row.dirs))],
+    node: process.execPath,
+    hubDist,
+    codePath: (0, import_node_path4.join)(paths.root, "pending-result.code"),
+    logPath: (0, import_node_path4.join)(paths.root, "pending-result.log"),
+    lockPath: watcherLockPath(paths)
+  });
+  try {
+    const pid = (seam.detachSpawn ?? defaultDetachSpawn)(command.file, command.args);
+    if (!pid) return { scheduled: false, reason: "watcher spawn returned no pid" };
+    writePending(paths, records.map((row) => ({ ...row, watcherPid: pid })));
+    return { scheduled: true, pid };
+  } catch (error) {
+    return { scheduled: false, reason: String(error?.message ?? error) };
+  }
+}
+function noteBusyDefer(paths, env, entry, seam = {}) {
+  try {
+    const records = readPending(paths);
+    const existing = records.find((row) => row.surface === entry.surface);
+    const next = {
+      surface: entry.surface,
+      target: entry.target,
+      since: existing?.since ?? (/* @__PURE__ */ new Date()).toISOString(),
+      reason: entry.reason,
+      images: entry.images ?? [],
+      dirs: entry.dirs ?? [],
+      watcherPid: existing?.watcherPid
+    };
+    writePending(paths, [...records.filter((row) => row.surface !== entry.surface), next]);
+    const scheduled = schedulePendingWatcher(paths, env, seam);
+    return scheduled.scheduled ? `applies when the host exits (post-exit watcher pid ${scheduled.pid})` : `applies on a quiet tick (${scheduled.reason})`;
+  } catch (error) {
+    return `applies on a quiet tick (pending record failed: ${String(error?.message ?? error).slice(0, 80)})`;
+  }
+}
+function resumePendingWatcher(paths, env = process.env) {
+  return schedulePendingWatcher(paths, env);
+}
+
+// src/arm-cli.ts
 function globalCliDist(env) {
   const root = globalRoot(env);
-  return root ? (0, import_node_path4.join)(root, "@mutmutco", "cli", "dist", "index.cjs") : null;
+  return root ? (0, import_node_path5.join)(root, "@mutmutco", "cli", "dist", "index.cjs") : null;
 }
 function probeCliVersion(distPath) {
   if (!fileExists(distPath)) return null;
-  const probe = (0, import_node_child_process3.spawnSync)(process.execPath, [distPath, "--version"], { encoding: "utf8", windowsHide: true });
+  const probe = (0, import_node_child_process4.spawnSync)(process.execPath, [distPath, "--version"], { encoding: "utf8", windowsHide: true });
   const version = (probe.stdout || "").trim();
   return probe.status === 0 && /^\d+\.\d+\.\d+/.test(version) ? version : null;
 }
@@ -436,11 +590,11 @@ function cliArm(options) {
   if (dryRun) {
     return { surface: "cli", from: installed, to: target, verdict: "ok", detail: `dry-run: would converge ${installed ?? "absent"} -> ${target}` };
   }
-  const stageRoot = (0, import_node_path4.join)(paths.staging, "cli", target);
-  const stageDist = (0, import_node_path4.join)(stageRoot, "node_modules", "@mutmutco", "cli", "dist", "index.cjs");
+  const stageRoot = (0, import_node_path5.join)(paths.staging, "cli", target);
+  const stageDist = (0, import_node_path5.join)(stageRoot, "node_modules", "@mutmutco", "cli", "dist", "index.cjs");
   if (!fileExists(stageDist)) {
-    (0, import_node_fs5.mkdirSync)(stageRoot, { recursive: true });
-    (0, import_node_fs5.writeFileSync)((0, import_node_path4.join)(stageRoot, "package.json"), JSON.stringify({ name: "mmi-updater-stage", private: true }) + "\n");
+    (0, import_node_fs6.mkdirSync)(stageRoot, { recursive: true });
+    (0, import_node_fs6.writeFileSync)((0, import_node_path5.join)(stageRoot, "package.json"), JSON.stringify({ name: "mmi-updater-stage", private: true }) + "\n");
     const install = runNpm(["install", "--prefix", stageRoot, "--no-audit", "--no-fund", "--no-package-lock", `@mutmutco/cli@${target}`], env);
     if (install.status !== 0) {
       return { surface: "cli", from: installed, to: target, verdict: "defer", detail: `staging install failed: ${(install.stderr || install.stdout).split("\n").filter(Boolean).slice(-3).join(" | ")}` };
@@ -448,7 +602,7 @@ function cliArm(options) {
   }
   let stagedManifestVersion;
   try {
-    stagedManifestVersion = JSON.parse((0, import_node_fs5.readFileSync)((0, import_node_path4.join)(stageRoot, "node_modules", "@mutmutco", "cli", "package.json"), "utf8")).version;
+    stagedManifestVersion = JSON.parse((0, import_node_fs6.readFileSync)((0, import_node_path5.join)(stageRoot, "node_modules", "@mutmutco", "cli", "package.json"), "utf8")).version;
   } catch {
   }
   if (stagedManifestVersion !== target) {
@@ -460,7 +614,10 @@ function cliArm(options) {
   }
   const globalInstall = runNpm(["install", "-g", "--no-audit", "--no-fund", `@mutmutco/cli@${target}`], env);
   if (globalInstall.status !== 0) {
-    return { surface: "cli", from: installed, to: target, verdict: "defer", detail: `global install failed: ${(globalInstall.stderr || globalInstall.stdout).split("\n").filter(Boolean).slice(-3).join(" | ")}` };
+    const reason = `global install failed: ${(globalInstall.stderr || globalInstall.stdout).split("\n").filter(Boolean).slice(-3).join(" | ")}`;
+    const root = globalRoot(env);
+    const pending = lockShaped(reason) && root ? ` \u2014 ${noteBusyDefer(paths, env, { surface: "cli", target, reason, dirs: [root] })}` : "";
+    return { surface: "cli", from: installed, to: target, verdict: "defer", detail: `${reason}${pending}` };
   }
   const switchedDist = globalCliDist(env);
   const switched = probeCliVersion(switchedDist ?? "");
@@ -471,16 +628,16 @@ function cliArm(options) {
 }
 
 // src/arm-npm-global.ts
-var import_node_fs6 = require("node:fs");
-var import_node_child_process4 = require("node:child_process");
-var import_node_path5 = require("node:path");
+var import_node_fs7 = require("node:fs");
+var import_node_child_process5 = require("node:child_process");
+var import_node_path6 = require("node:path");
 function globalDist(env, packageName, distRel) {
   const root = globalRoot(env);
-  return root ? (0, import_node_path5.join)(root, ...packageName.split("/"), ...distRel.split("/")) : null;
+  return root ? (0, import_node_path6.join)(root, ...packageName.split("/"), ...distRel.split("/")) : null;
 }
 function probeVersion(distPath) {
   if (!fileExists(distPath)) return null;
-  const probe = (0, import_node_child_process4.spawnSync)(process.execPath, [distPath, "--version"], { encoding: "utf8", windowsHide: true });
+  const probe = (0, import_node_child_process5.spawnSync)(process.execPath, [distPath, "--version"], { encoding: "utf8", windowsHide: true });
   const version = (probe.stdout || "").trim();
   return probe.status === 0 && /^\d+\.\d+\.\d+/.test(version) ? version : null;
 }
@@ -489,11 +646,11 @@ function tail(output) {
 }
 function stagePackage(options) {
   const { surface, packageName, target, witness, paths, env } = options;
-  const stageRoot = (0, import_node_path5.join)(paths.staging, surface, target);
-  const packageRoot = (0, import_node_path5.join)(stageRoot, "node_modules", ...packageName.split("/"));
-  if (!fileExists((0, import_node_path5.join)(packageRoot, ...witness.split("/")))) {
-    (0, import_node_fs6.mkdirSync)(stageRoot, { recursive: true });
-    (0, import_node_fs6.writeFileSync)((0, import_node_path5.join)(stageRoot, "package.json"), JSON.stringify({ name: "mmi-updater-stage", private: true }) + "\n");
+  const stageRoot = (0, import_node_path6.join)(paths.staging, surface, target);
+  const packageRoot = (0, import_node_path6.join)(stageRoot, "node_modules", ...packageName.split("/"));
+  if (!fileExists((0, import_node_path6.join)(packageRoot, ...witness.split("/")))) {
+    (0, import_node_fs7.mkdirSync)(stageRoot, { recursive: true });
+    (0, import_node_fs7.writeFileSync)((0, import_node_path6.join)(stageRoot, "package.json"), JSON.stringify({ name: "mmi-updater-stage", private: true }) + "\n");
     const install = runNpm(["install", "--prefix", stageRoot, "--no-audit", "--no-fund", "--no-package-lock", `${packageName}@${target}`], env);
     if (install.status !== 0) {
       return { defer: `staging install failed: ${tail(install.stderr || install.stdout)}` };
@@ -501,7 +658,7 @@ function stagePackage(options) {
   }
   let stagedManifestVersion;
   try {
-    stagedManifestVersion = JSON.parse((0, import_node_fs6.readFileSync)((0, import_node_path5.join)(packageRoot, "package.json"), "utf8")).version;
+    stagedManifestVersion = JSON.parse((0, import_node_fs7.readFileSync)((0, import_node_path6.join)(packageRoot, "package.json"), "utf8")).version;
   } catch {
   }
   if (stagedManifestVersion !== target) {
@@ -533,14 +690,17 @@ function npmGlobalArm(options) {
   if ("defer" in staged) {
     return result(installed, target, "defer", staged.defer);
   }
-  const stageDist = (0, import_node_path5.join)(staged.packageRoot, ...distRel.split("/"));
+  const stageDist = (0, import_node_path6.join)(staged.packageRoot, ...distRel.split("/"));
   const stagedVersion = probeVersion(stageDist);
   if (stagedVersion !== target) {
     return result(installed, target, "defer", `staged binary probed ${stagedVersion ?? "dead"}, expected ${target}`);
   }
   const globalInstall = runNpm(["install", "-g", "--no-audit", "--no-fund", spec], env);
   if (globalInstall.status !== 0) {
-    return result(installed, target, "defer", `global install failed: ${tail(globalInstall.stderr || globalInstall.stdout)}`);
+    const reason = `global install failed: ${tail(globalInstall.stderr || globalInstall.stdout)}`;
+    const root = globalRoot(env);
+    const pending = lockShaped(reason) && root ? ` \u2014 ${noteBusyDefer(paths, env, { surface, target, reason, dirs: [root] })}` : "";
+    return result(installed, target, "defer", `${reason}${pending}`);
   }
   const switchedDist = globalDist(env, packageName, distRel);
   const switched = probeVersion(switchedDist ?? "");
@@ -561,10 +721,10 @@ function selfArm(options) {
 }
 
 // src/arm-host-plugins.ts
-var import_node_child_process5 = require("node:child_process");
-var import_node_fs7 = require("node:fs");
+var import_node_child_process6 = require("node:child_process");
+var import_node_fs8 = require("node:fs");
 var import_node_os3 = require("node:os");
-var import_node_path6 = require("node:path");
+var import_node_path7 = require("node:path");
 var REPO_URL_DEFAULT = "https://github.com/mutmutco/MMI-Hub.git";
 var MMI_MARKETPLACE_REPO = "mutmutco/MMI-Hub";
 function convergedAtOrAbove(installed, target, healthy) {
@@ -574,13 +734,13 @@ function cmdArg(value) {
   return /^[A-Za-z0-9_@./:\\=+-]+$/.test(value) ? value : `"${value.replaceAll('"', '""')}"`;
 }
 var runHostCommand = (command, args, env) => {
-  const result = process.platform === "win32" ? (0, import_node_child_process5.spawnSync)("cmd.exe", ["/d", "/s", "/c", [command, ...args].map(cmdArg).join(" ")], {
+  const result = process.platform === "win32" ? (0, import_node_child_process6.spawnSync)("cmd.exe", ["/d", "/s", "/c", [command, ...args].map(cmdArg).join(" ")], {
     encoding: "utf8",
     env,
     input: "",
     timeout: 12e4,
     windowsHide: true
-  }) : (0, import_node_child_process5.spawnSync)(command, args, {
+  }) : (0, import_node_child_process6.spawnSync)(command, args, {
     encoding: "utf8",
     env,
     input: "",
@@ -607,7 +767,7 @@ function claudeMmi(runner, env) {
   return { row: parsed.find((row) => row.id === "mmi@mutmutco") ?? null };
 }
 function claudeMarketplacesPath(env) {
-  return env.MMI_UPDATER_CLAUDE_MARKETPLACES || (0, import_node_path6.join)((0, import_node_os3.homedir)(), ".claude", "plugins", "known_marketplaces.json");
+  return env.MMI_UPDATER_CLAUDE_MARKETPLACES || (0, import_node_path7.join)((0, import_node_os3.homedir)(), ".claude", "plugins", "known_marketplaces.json");
 }
 var CLAUDE_PROCESS_SEGMENT = /^claude(-code|-cli)?(\.(exe|cmd|bat|ps1|js|mjs|cjs|py))?$/;
 function claudeProcessSegment(line) {
@@ -621,7 +781,7 @@ function claudeProcessSegment(line) {
 function claudeHostRunning(env) {
   const marker = env.CLAUDE_CODE_SESSION_ID?.trim() ? "CLAUDE_CODE_SESSION_ID" : env.CLAUDECODE?.trim() ? "CLAUDECODE" : env.CLAUDE_PLUGIN_ROOT?.trim() ? "CLAUDE_PLUGIN_ROOT" : null;
   if (marker) return { running: true, evidence: `${marker} is set \u2014 this process is itself inside a Claude hook` };
-  const result = process.platform === "win32" ? (0, import_node_child_process5.spawnSync)("powershell.exe", ["-NoProfile", "-Command", "Get-CimInstance Win32_Process | ForEach-Object { $_.Name + ' ' + $_.CommandLine }"], { encoding: "utf8", windowsHide: true, timeout: 15e3 }) : (0, import_node_child_process5.spawnSync)("ps", ["-eo", "args="], { encoding: "utf8", windowsHide: true, timeout: 15e3 });
+  const result = process.platform === "win32" ? (0, import_node_child_process6.spawnSync)("powershell.exe", ["-NoProfile", "-Command", "Get-CimInstance Win32_Process | ForEach-Object { $_.Name + ' ' + $_.CommandLine }"], { encoding: "utf8", windowsHide: true, timeout: 15e3 }) : (0, import_node_child_process6.spawnSync)("ps", ["-eo", "args="], { encoding: "utf8", windowsHide: true, timeout: 15e3 });
   if (result.status !== 0 || !(result.stdout ?? "").trim()) return { running: true, evidence: "the process list is unreadable \u2014 unsafe to write" };
   for (const line of result.stdout.split(/\r?\n/)) {
     const segment = claudeProcessSegment(line);
@@ -633,7 +793,7 @@ function ensureClaudeSingleWriter(env, dryRun) {
   const path = claudeMarketplacesPath(env);
   let body;
   try {
-    body = JSON.parse((0, import_node_fs7.readFileSync)(path, "utf8"));
+    body = JSON.parse((0, import_node_fs8.readFileSync)(path, "utf8"));
   } catch (error) {
     if (error?.code === "ENOENT") return { ok: false, detail: `${path} does not exist \u2014 mutmutco marketplace is not registered`, unregistered: true };
     return { ok: false, detail: `cannot read ${path}` };
@@ -645,7 +805,10 @@ function ensureClaudeSingleWriter(env, dryRun) {
   if (registeredRepo !== MMI_MARKETPLACE_REPO) {
     return {
       ok: false,
-      detail: `mutmutco marketplace is registered to ${registeredRepo ?? "a non-github source"}, not ${MMI_MARKETPLACE_REPO} \u2014 a retired or foreign repo is squatting the name; re-register it (claude plugin marketplace remove mutmutco && claude plugin marketplace add ${REPO_URL_DEFAULT}) before the updater can trust it`
+      // Remedy must use the github shorthand (#5369): `marketplace add <url>` registers
+      // source:'git', which fails this same github-provenance check forever; `add owner/repo`
+      // registers source:'github' and passes.
+      detail: `mutmutco marketplace is registered to ${registeredRepo ?? "a non-github source"}, not ${MMI_MARKETPLACE_REPO} \u2014 a retired or foreign repo is squatting the name; re-register it (claude plugin marketplace remove mutmutco && claude plugin marketplace add ${MMI_MARKETPLACE_REPO}) before the updater can trust it`
     };
   }
   if (registration.autoUpdate !== true) return { ok: true };
@@ -657,9 +820,9 @@ function ensureClaudeSingleWriter(env, dryRun) {
   registration.autoUpdate = false;
   const tmp = `${path}.tmp-${process.pid}`;
   try {
-    (0, import_node_fs7.writeFileSync)(tmp, JSON.stringify(body, null, 2) + "\n", "utf8");
-    (0, import_node_fs7.renameSync)(tmp, path);
-    const reread = JSON.parse((0, import_node_fs7.readFileSync)(path, "utf8"));
+    (0, import_node_fs8.writeFileSync)(tmp, JSON.stringify(body, null, 2) + "\n", "utf8");
+    (0, import_node_fs8.renameSync)(tmp, path);
+    const reread = JSON.parse((0, import_node_fs8.readFileSync)(path, "utf8"));
     return reread?.mutmutco?.autoUpdate === false ? { ok: true, detail: "disabled Claude background autoUpdate (updater is the single writer)" } : { ok: false, detail: "Claude background autoUpdate write did not persist" };
   } catch (error) {
     return { ok: false, detail: `cannot disable Claude background autoUpdate: ${error?.message ?? error}` };
@@ -773,11 +936,11 @@ function codexArm(options) {
 }
 var KILO_PACKAGE = "@mutmutco/kilo-plugin";
 function kiloConfigPath(env) {
-  return env.MMI_UPDATER_KILO_CONFIG || (0, import_node_path6.join)((0, import_node_os3.homedir)(), ".config", "kilo", "opencode.json");
+  return env.MMI_UPDATER_KILO_CONFIG || (0, import_node_path7.join)((0, import_node_os3.homedir)(), ".config", "kilo", "opencode.json");
 }
 function readKiloConfig(env) {
   try {
-    const config = JSON.parse((0, import_node_fs7.readFileSync)(kiloConfigPath(env), "utf8"));
+    const config = JSON.parse((0, import_node_fs8.readFileSync)(kiloConfigPath(env), "utf8"));
     const specs = Array.isArray(config.plugin) && config.plugin.every((entry) => typeof entry === "string") ? config.plugin : [];
     return { config, specs };
   } catch {
@@ -797,8 +960,8 @@ function normalizeKiloConfig(env, exact) {
   const path = kiloConfigPath(env);
   const tmp = `${path}.tmp-${process.pid}`;
   try {
-    (0, import_node_fs7.writeFileSync)(tmp, JSON.stringify({ ...current.config, plugin: next }, null, 2) + "\n", "utf8");
-    (0, import_node_fs7.renameSync)(tmp, path);
+    (0, import_node_fs8.writeFileSync)(tmp, JSON.stringify({ ...current.config, plugin: next }, null, 2) + "\n", "utf8");
+    (0, import_node_fs8.renameSync)(tmp, path);
     return null;
   } catch (error) {
     return `cannot retire legacy Kilo registrations: ${error?.message ?? error}`;
@@ -861,15 +1024,15 @@ function kiloArm(options) {
 }
 
 // src/arm-kimi.ts
-var import_node_child_process6 = require("node:child_process");
-var import_node_fs9 = require("node:fs");
-var import_node_path7 = require("node:path");
+var import_node_child_process7 = require("node:child_process");
+var import_node_fs10 = require("node:fs");
+var import_node_path8 = require("node:path");
 
 // src/compat.ts
-var import_node_fs8 = require("node:fs");
+var import_node_fs9 = require("node:fs");
 function readManifestCompat(manifestPath) {
   try {
-    const parsed = JSON.parse((0, import_node_fs8.readFileSync)(manifestPath, "utf8"));
+    const parsed = JSON.parse((0, import_node_fs9.readFileSync)(manifestPath, "utf8"));
     return typeof parsed.mmiCompat === "string" ? parsed.mmiCompat : void 0;
   } catch {
     return void 0;
@@ -880,11 +1043,11 @@ function readManifestCompat(manifestPath) {
 var KIMI_PACKAGE = "@mutmutco/kimi-plugin";
 var TREE_MARKERS = [".kimi-plugin/plugin.json", "skills/mmi/SKILL.md", "scripts/hook-run.mjs"];
 function treeHealthy(root) {
-  return TREE_MARKERS.every((rel) => fileExists((0, import_node_path7.join)(root, ...rel.split("/"))));
+  return TREE_MARKERS.every((rel) => fileExists((0, import_node_path8.join)(root, ...rel.split("/"))));
 }
 function markerVersion(root) {
   try {
-    const version = JSON.parse((0, import_node_fs9.readFileSync)((0, import_node_path7.join)(root, ".kimi-plugin", "plugin.json"), "utf8")).version;
+    const version = JSON.parse((0, import_node_fs10.readFileSync)((0, import_node_path8.join)(root, ".kimi-plugin", "plugin.json"), "utf8")).version;
     return typeof version === "string" ? version : null;
   } catch {
     return null;
@@ -892,14 +1055,14 @@ function markerVersion(root) {
 }
 function packageVersion(root) {
   try {
-    const version = JSON.parse((0, import_node_fs9.readFileSync)((0, import_node_path7.join)(root, "package.json"), "utf8")).version;
+    const version = JSON.parse((0, import_node_fs10.readFileSync)((0, import_node_path8.join)(root, "package.json"), "utf8")).version;
     return typeof version === "string" ? version : null;
   } catch {
     return null;
   }
 }
 function probeKimiInstallation(env = process.env) {
-  const location = (0, import_node_path7.join)(kimiHome(env), "plugins", "managed", "mmi");
+  const location = (0, import_node_path8.join)(kimiHome(env), "plugins", "managed", "mmi");
   const version = markerVersion(location);
   return { version, location, detail: version ? "installed Kimi plugin manifest" : "installed Kimi plugin manifest was unreadable" };
 }
@@ -907,14 +1070,14 @@ function tail2(output) {
   return output.split("\n").filter(Boolean).slice(-3).join(" | ");
 }
 function scratchRoot(env) {
-  return (0, import_node_path7.join)(kimiHome(env), ".mmi-updater");
+  return (0, import_node_path8.join)(kimiHome(env), ".mmi-updater");
 }
 function pruneScratchDir(root, keep) {
   try {
-    for (const name of (0, import_node_fs9.readdirSync)(root)) {
+    for (const name of (0, import_node_fs10.readdirSync)(root)) {
       if (name === keep) continue;
       try {
-        (0, import_node_fs9.rmSync)((0, import_node_path7.join)(root, name), { recursive: true, force: true });
+        (0, import_node_fs10.rmSync)((0, import_node_path8.join)(root, name), { recursive: true, force: true });
       } catch {
       }
     }
@@ -930,7 +1093,7 @@ function kimiProcessToken(line) {
 }
 function kimiHostRunning(env) {
   if (env.KIMI_PLUGIN_ROOT?.trim()) return { running: true, evidence: "KIMI_PLUGIN_ROOT is set \u2014 this process is itself inside a Kimi hook" };
-  const result = process.platform === "win32" ? (0, import_node_child_process6.spawnSync)("powershell.exe", ["-NoProfile", "-Command", "Get-CimInstance Win32_Process | ForEach-Object { $_.Name + ' ' + $_.CommandLine }"], { encoding: "utf8", windowsHide: true, timeout: 15e3 }) : (0, import_node_child_process6.spawnSync)("ps", ["-eo", "args="], { encoding: "utf8", windowsHide: true, timeout: 15e3 });
+  const result = process.platform === "win32" ? (0, import_node_child_process7.spawnSync)("powershell.exe", ["-NoProfile", "-Command", "Get-CimInstance Win32_Process | ForEach-Object { $_.Name + ' ' + $_.CommandLine }"], { encoding: "utf8", windowsHide: true, timeout: 15e3 }) : (0, import_node_child_process7.spawnSync)("ps", ["-eo", "args="], { encoding: "utf8", windowsHide: true, timeout: 15e3 });
   if (result.status !== 0 || !(result.stdout ?? "").trim()) return { running: true, evidence: "the process list is unreadable \u2014 unsafe to write" };
   for (const line of result.stdout.split(/\r?\n/)) {
     const token = kimiProcessToken(line);
@@ -940,11 +1103,11 @@ function kimiHostRunning(env) {
 }
 function restoreQuarantine(quarantine, live) {
   try {
-    (0, import_node_fs9.renameSync)(quarantine, live);
+    (0, import_node_fs10.renameSync)(quarantine, live);
   } catch (error) {
     return { restored: false, detail: `${error?.message ?? error}` };
   }
-  if (!(0, import_node_fs9.existsSync)(live)) return { restored: false, detail: `${live} is still absent after the restore rename` };
+  if (!(0, import_node_fs10.existsSync)(live)) return { restored: false, detail: `${live} is still absent after the restore rename` };
   return { restored: true, detail: `marker ${markerVersion(live) ?? "unreadable"}` };
 }
 function kimiArm(options) {
@@ -958,10 +1121,10 @@ function kimiArm(options) {
     detail,
     // C11: the constraint of the tree LEFT at `live` — read at result time, so ok carries the new
     // manifest's declaration and defer/fail carry the previous tree's (#4973 reconsult ruling).
-    compat: readManifestCompat((0, import_node_path7.join)(live, ".kimi-plugin", "plugin.json"))
+    compat: readManifestCompat((0, import_node_path8.join)(live, ".kimi-plugin", "plugin.json"))
   });
-  const managedParent = (0, import_node_path7.join)(kimiHome(env), "plugins", "managed");
-  const live = (0, import_node_path7.join)(managedParent, "mmi");
+  const managedParent = (0, import_node_path8.join)(kimiHome(env), "plugins", "managed");
+  const live = (0, import_node_path8.join)(managedParent, "mmi");
   const installed = markerVersion(live);
   if (installed && compareSemver(installed, target) > 0) {
     return result(installed, installed, "skip", `installed ${installed} is above candidate ${target} (monotonic)`);
@@ -976,11 +1139,11 @@ function kimiArm(options) {
   if (dryRun) {
     return result(installed, target, "ok", `dry-run: would converge ${installed ?? "absent"} -> ${target} (tarball generation switch while Kimi is absent)`);
   }
-  const stageRoot = (0, import_node_path7.join)(paths.staging, "kimi", target);
-  const staged = (0, import_node_path7.join)(stageRoot, "node_modules", ...KIMI_PACKAGE.split("/"));
+  const stageRoot = (0, import_node_path8.join)(paths.staging, "kimi", target);
+  const staged = (0, import_node_path8.join)(stageRoot, "node_modules", ...KIMI_PACKAGE.split("/"));
   if (!treeHealthy(staged)) {
-    (0, import_node_fs9.mkdirSync)(stageRoot, { recursive: true });
-    (0, import_node_fs9.writeFileSync)((0, import_node_path7.join)(stageRoot, "package.json"), JSON.stringify({ name: "mmi-updater-stage", private: true }) + "\n");
+    (0, import_node_fs10.mkdirSync)(stageRoot, { recursive: true });
+    (0, import_node_fs10.writeFileSync)((0, import_node_path8.join)(stageRoot, "package.json"), JSON.stringify({ name: "mmi-updater-stage", private: true }) + "\n");
     const install = runNpm(["install", "--prefix", stageRoot, "--no-audit", "--no-fund", "--no-package-lock", `${KIMI_PACKAGE}@${target}`], env);
     if (install.status !== 0) {
       return result(installed, target, "defer", `staging install failed: ${tail2(install.stderr || install.stdout)}`);
@@ -999,75 +1162,79 @@ function kimiArm(options) {
   }
   const quiescence = kimiHostRunning(env);
   if (quiescence.running) {
-    return result(installed, target, "defer", `Kimi may be running \u2014 the managed tree is switched only while the host is absent: ${quiescence.evidence}`);
+    const pending = options.dryRun ? "" : ` ${noteBusyDefer(options.paths, env, { surface: "kimi", target, reason: quiescence.evidence, dirs: ["kimi"] })}`;
+    return result(installed, target, "defer", `Kimi may be running \u2014 the managed tree is switched only while the host is absent: ${quiescence.evidence}${pending ? ` \u2014${pending}` : ""}`);
   }
   const scratch = scratchRoot(env);
-  const incomingRoot = (0, import_node_path7.join)(scratch, "incoming");
-  const incoming = (0, import_node_path7.join)(incomingRoot, target);
-  const quarantineRoot = (0, import_node_path7.join)(scratch, "quarantine");
-  const rejectedRoot = (0, import_node_path7.join)(scratch, "rejected");
+  const incomingRoot = (0, import_node_path8.join)(scratch, "incoming");
+  const incoming = (0, import_node_path8.join)(incomingRoot, target);
+  const quarantineRoot = (0, import_node_path8.join)(scratch, "quarantine");
+  const rejectedRoot = (0, import_node_path8.join)(scratch, "rejected");
   try {
-    (0, import_node_fs9.mkdirSync)(managedParent, { recursive: true });
-    (0, import_node_fs9.mkdirSync)(quarantineRoot, { recursive: true });
-    (0, import_node_fs9.rmSync)(incomingRoot, { recursive: true, force: true });
-    (0, import_node_fs9.cpSync)(staged, incoming, { recursive: true });
+    (0, import_node_fs10.mkdirSync)(managedParent, { recursive: true });
+    (0, import_node_fs10.mkdirSync)(quarantineRoot, { recursive: true });
+    (0, import_node_fs10.rmSync)(incomingRoot, { recursive: true, force: true });
+    (0, import_node_fs10.cpSync)(staged, incoming, { recursive: true });
   } catch (error) {
     return result(installed, target, "defer", `cannot place the incoming generation under ${scratch}: ${error?.message ?? error}`);
   }
   if (markerVersion(incoming) !== target || !treeHealthy(incoming)) {
     return result(installed, target, "defer", `incoming generation verifies as ${markerVersion(incoming) ?? "unreadable"}, expected ${target}`);
   }
-  const hadLive = (0, import_node_fs9.existsSync)(live);
+  const hadLive = (0, import_node_fs10.existsSync)(live);
   const generation = `${installed ?? "unknown"}-${Date.now()}`;
-  const quarantine = (0, import_node_path7.join)(quarantineRoot, generation);
+  const quarantine = (0, import_node_path8.join)(quarantineRoot, generation);
   if (hadLive) {
     try {
-      (0, import_node_fs9.renameSync)(live, quarantine);
+      (0, import_node_fs10.renameSync)(live, quarantine);
     } catch (error) {
-      return result(installed, target, "defer", `cannot quarantine the live generation: ${error?.message ?? error}`);
+      const reason = String(error?.message ?? error);
+      const pending = lockShaped(reason) ? ` \u2014 ${noteBusyDefer(options.paths, env, { surface: "kimi", target, reason, dirs: ["kimi"] })}` : "";
+      return result(installed, target, "defer", `cannot quarantine the live generation: ${reason}${pending}`);
     }
   }
   try {
-    (0, import_node_fs9.renameSync)(incoming, live);
+    (0, import_node_fs10.renameSync)(incoming, live);
   } catch (error) {
     const failed = `cannot switch the new generation in: ${error?.message ?? error}`;
     if (!hadLive) {
       return result(installed, target, "defer", `${failed} \u2014 no generation was displaced; ${live} is still absent`);
     }
     const restore = restoreQuarantine(quarantine, live);
-    return restore.restored ? result(installed, installed ?? "unknown", "defer", `${failed} \u2014 the previous generation is back in place (${restore.detail})`) : result(installed, "none", "fail", `${failed}; ROLLBACK FAILED (${restore.detail}) \u2014 ${live} now has NO plugin and Kimi enforces nothing until this is repaired; the known-good generation is intact at ${quarantine}`);
+    const pending = restore.restored && lockShaped(failed) ? ` \u2014 ${noteBusyDefer(options.paths, env, { surface: "kimi", target, reason: failed, dirs: ["kimi"] })}` : "";
+    return restore.restored ? result(installed, installed ?? "unknown", "defer", `${failed} \u2014 the previous generation is back in place (${restore.detail})${pending}`) : result(installed, "none", "fail", `${failed}; ROLLBACK FAILED (${restore.detail}) \u2014 ${live} now has NO plugin and Kimi enforces nothing until this is repaired; the known-good generation is intact at ${quarantine}`);
   }
   const switched = markerVersion(live);
   if (switched !== target || !treeHealthy(live)) {
     const observed = `post-switch marker is ${switched ?? "unreadable"}, expected ${target}`;
     const rejectedName = `${target}-${Date.now()}`;
     try {
-      (0, import_node_fs9.mkdirSync)(rejectedRoot, { recursive: true });
-      (0, import_node_fs9.renameSync)(live, (0, import_node_path7.join)(rejectedRoot, rejectedName));
+      (0, import_node_fs10.mkdirSync)(rejectedRoot, { recursive: true });
+      (0, import_node_fs10.renameSync)(live, (0, import_node_path8.join)(rejectedRoot, rejectedName));
     } catch (error) {
       return result(installed, switched ?? "unknown", "fail", `${observed} \u2014 the unverified tree could NOT be moved aside (${error?.message ?? error}) and is STILL LIVE at ${live}${hadLive ? `; the previous generation is intact at ${quarantine}` : ""}`);
     }
     pruneScratchDir(rejectedRoot, rejectedName);
     if (!hadLive) {
-      return result(installed, "none", "fail", `${observed} \u2014 the unverified tree is parked at ${(0, import_node_path7.join)(rejectedRoot, rejectedName)}; ${live} is absent (there was no previous generation to restore)`);
+      return result(installed, "none", "fail", `${observed} \u2014 the unverified tree is parked at ${(0, import_node_path8.join)(rejectedRoot, rejectedName)}; ${live} is absent (there was no previous generation to restore)`);
     }
     const restore = restoreQuarantine(quarantine, live);
-    return restore.restored ? result(installed, installed ?? "unknown", "fail", `${observed} \u2014 the unverified tree is parked at ${(0, import_node_path7.join)(rejectedRoot, rejectedName)}; rolled back to ${installed ?? "the previous generation"} and read back (${restore.detail})`) : result(installed, "none", "fail", `${observed}; ROLLBACK FAILED (${restore.detail}) \u2014 ${live} now has NO plugin and Kimi enforces nothing until this is repaired; the known-good generation is intact at ${quarantine}`);
+    return restore.restored ? result(installed, installed ?? "unknown", "fail", `${observed} \u2014 the unverified tree is parked at ${(0, import_node_path8.join)(rejectedRoot, rejectedName)}; rolled back to ${installed ?? "the previous generation"} and read back (${restore.detail})`) : result(installed, "none", "fail", `${observed}; ROLLBACK FAILED (${restore.detail}) \u2014 ${live} now has NO plugin and Kimi enforces nothing until this is repaired; the known-good generation is intact at ${quarantine}`);
   }
   pruneScratchDir(quarantineRoot, hadLive ? generation : null);
   pruneScratchDir(rejectedRoot, null);
   try {
-    (0, import_node_fs9.rmSync)(incomingRoot, { recursive: true, force: true });
+    (0, import_node_fs10.rmSync)(incomingRoot, { recursive: true, force: true });
   } catch {
   }
   return result(installed, target, "ok", `converged ${installed ?? "absent"} -> ${target} (staged, verified, switched${hadLive ? `; previous generation quarantined at ${quarantine}` : ""})`);
 }
 
 // src/arm-cursor.ts
-var import_node_fs10 = require("node:fs");
-var import_node_child_process7 = require("node:child_process");
+var import_node_fs11 = require("node:fs");
+var import_node_child_process8 = require("node:child_process");
 var import_node_os4 = require("node:os");
-var import_node_path8 = require("node:path");
+var import_node_path9 = require("node:path");
 var PACKAGE = "@mutmutco/cursor-plugin";
 var MANIFEST = ".cursor-plugin/plugin.json";
 var USER_HOOKS_FILE = "hooks.json";
@@ -1076,14 +1243,14 @@ var KEEP_GENERATIONS = 2;
 var STRANDED_TMP_AGE_MS = 24 * 60 * 6e4;
 var TREE_FILES = [MANIFEST, "skills/mmi/SKILL.md", "hooks/cursor-hooks.json", "scripts/hook-run.mjs", "scripts/hook-policy.mjs"];
 function cursorPluginsRoot() {
-  return (0, import_node_path8.join)((0, import_node_os4.homedir)(), ".cursor", "plugins");
+  return (0, import_node_path9.join)((0, import_node_os4.homedir)(), ".cursor", "plugins");
 }
 function treeHealthy2(root) {
-  return TREE_FILES.every((rel) => (0, import_node_fs10.existsSync)((0, import_node_path8.join)(root, ...rel.split("/"))));
+  return TREE_FILES.every((rel) => (0, import_node_fs11.existsSync)((0, import_node_path9.join)(root, ...rel.split("/"))));
 }
 function readJson(root, rel) {
   try {
-    return JSON.parse((0, import_node_fs10.readFileSync)((0, import_node_path8.join)(root, ...rel.split("/")), "utf8"));
+    return JSON.parse((0, import_node_fs11.readFileSync)((0, import_node_path9.join)(root, ...rel.split("/")), "utf8"));
   } catch {
     return null;
   }
@@ -1092,7 +1259,7 @@ function manifest(root) {
   return readJson(root, MANIFEST);
 }
 function probeCursorInstallation() {
-  const location = (0, import_node_path8.join)(cursorPluginsRoot(), "local", "mmi");
+  const location = (0, import_node_path9.join)(cursorPluginsRoot(), "local", "mmi");
   const version = manifest(location)?.version ?? null;
   return { version, location, detail: version ? "installed Cursor plugin manifest" : "installed Cursor plugin manifest was unreadable" };
 }
@@ -1107,7 +1274,7 @@ function message(error) {
 }
 function discard(path) {
   try {
-    (0, import_node_fs10.rmSync)(path, { recursive: true, force: true });
+    (0, import_node_fs11.rmSync)(path, { recursive: true, force: true });
   } catch {
   }
 }
@@ -1126,7 +1293,7 @@ function cursorHostEvidence(env) {
     if (env[marker]?.trim()) return `env marker ${marker}`;
   }
   if (env.CURSOR_AGENT === "1") return "env marker CURSOR_AGENT=1";
-  const result = process.platform === "win32" ? (0, import_node_child_process7.spawnSync)("powershell.exe", ["-NoProfile", "-Command", "Get-CimInstance Win32_Process | ForEach-Object { $_.CommandLine }"], { encoding: "utf8", windowsHide: true, timeout: 15e3 }) : (0, import_node_child_process7.spawnSync)("ps", ["-eo", "args="], { encoding: "utf8", windowsHide: true, timeout: 15e3 });
+  const result = process.platform === "win32" ? (0, import_node_child_process8.spawnSync)("powershell.exe", ["-NoProfile", "-Command", "Get-CimInstance Win32_Process | ForEach-Object { $_.CommandLine }"], { encoding: "utf8", windowsHide: true, timeout: 15e3 }) : (0, import_node_child_process8.spawnSync)("ps", ["-eo", "args="], { encoding: "utf8", windowsHide: true, timeout: 15e3 });
   if (result.status !== 0 || !(result.stdout ?? "").trim()) return "the process table is unreadable (unsafe to write)";
   for (const line of result.stdout.split(/\r?\n/)) {
     const executable = cursorExecutable(line);
@@ -1135,7 +1302,7 @@ function cursorHostEvidence(env) {
   return null;
 }
 function resolvedPluginRoot(root) {
-  return (0, import_node_path8.join)(root).replace(/\\/g, "/");
+  return (0, import_node_path9.join)(root).replace(/\\/g, "/");
 }
 function isMmiEntry(entry, pluginRoot) {
   return typeof entry === "object" && entry !== null && typeof entry.command === "string" && entry.command.includes(resolvedPluginRoot(pluginRoot));
@@ -1145,7 +1312,7 @@ function resolveCommand(command, pluginRoot) {
 }
 function desiredUserHooks(pluginRoot) {
   try {
-    const doc = JSON.parse((0, import_node_fs10.readFileSync)((0, import_node_path8.join)(pluginRoot, ...PLUGIN_HOOKS_REL), "utf8"));
+    const doc = JSON.parse((0, import_node_fs11.readFileSync)((0, import_node_path9.join)(pluginRoot, ...PLUGIN_HOOKS_REL), "utf8"));
     const hooks = doc.hooks;
     if (typeof hooks !== "object" || hooks === null || Array.isArray(hooks)) return null;
     const desired = /* @__PURE__ */ new Map();
@@ -1181,14 +1348,14 @@ function mergeUserHooks(existing, desired, pluginRoot) {
 function reconcileCursorUserHooks(pluginRoot, homeDir) {
   const desired = desiredUserHooks(pluginRoot);
   if (!desired) return "source-unreadable";
-  const path = (0, import_node_path8.join)(homeDir, ".cursor", USER_HOOKS_FILE);
-  if (!(0, import_node_fs10.existsSync)(path)) {
-    (0, import_node_fs10.writeFileSync)(path, JSON.stringify({ version: 1, hooks: Object.fromEntries(desired) }, null, 2) + "\n", "utf8");
+  const path = (0, import_node_path9.join)(homeDir, ".cursor", USER_HOOKS_FILE);
+  if (!(0, import_node_fs11.existsSync)(path)) {
+    (0, import_node_fs11.writeFileSync)(path, JSON.stringify({ version: 1, hooks: Object.fromEntries(desired) }, null, 2) + "\n", "utf8");
     return "updated";
   }
   let existing;
   try {
-    existing = JSON.parse((0, import_node_fs10.readFileSync)(path, "utf8"));
+    existing = JSON.parse((0, import_node_fs11.readFileSync)(path, "utf8"));
   } catch {
     return "user-conflict";
   }
@@ -1196,8 +1363,8 @@ function reconcileCursorUserHooks(pluginRoot, homeDir) {
   if (!merged) return "user-conflict";
   if (JSON.stringify(merged) === JSON.stringify(existing)) return "current";
   const tmp = `${path}.tmp-${process.pid}`;
-  (0, import_node_fs10.writeFileSync)(tmp, JSON.stringify(merged, null, 2) + "\n", "utf8");
-  (0, import_node_fs10.renameSync)(tmp, path);
+  (0, import_node_fs11.writeFileSync)(tmp, JSON.stringify(merged, null, 2) + "\n", "utf8");
+  (0, import_node_fs11.renameSync)(tmp, path);
   return "updated";
 }
 function userHooksDetail(pluginRoot, homeDir) {
@@ -1205,7 +1372,7 @@ function userHooksDetail(pluginRoot, homeDir) {
     case "updated":
       return "; user hooks bridged into ~/.cursor/hooks.json";
     case "user-conflict":
-      return `; USER HOOKS CONFLICT at ${(0, import_node_path8.join)(homeDir, ".cursor", USER_HOOKS_FILE)} \u2014 Cursor gates are NOT bridged; fix or remove that file and reconcile`;
+      return `; USER HOOKS CONFLICT at ${(0, import_node_path9.join)(homeDir, ".cursor", USER_HOOKS_FILE)} \u2014 Cursor gates are NOT bridged; fix or remove that file and reconcile`;
     case "source-unreadable":
       return "; user hooks source unreadable \u2014 Cursor gates are NOT bridged";
     default:
@@ -1213,35 +1380,35 @@ function userHooksDetail(pluginRoot, homeDir) {
   }
 }
 function writeRollbackPointer(root, entry) {
-  const path = (0, import_node_path8.join)(root, "quarantine", "rollback.json");
+  const path = (0, import_node_path9.join)(root, "quarantine", "rollback.json");
   const tmp = `${path}.tmp-${process.pid}`;
   try {
-    (0, import_node_fs10.writeFileSync)(tmp, JSON.stringify({ surface: "cursor", ts: (/* @__PURE__ */ new Date()).toISOString(), ...entry }, null, 2) + "\n", "utf8");
-    (0, import_node_fs10.renameSync)(tmp, path);
+    (0, import_node_fs11.writeFileSync)(tmp, JSON.stringify({ surface: "cursor", ts: (/* @__PURE__ */ new Date()).toISOString(), ...entry }, null, 2) + "\n", "utf8");
+    (0, import_node_fs11.renameSync)(tmp, path);
   } catch {
     discard(tmp);
   }
 }
 function mtimeMs(path) {
   try {
-    return (0, import_node_fs10.statSync)(path).mtimeMs;
+    return (0, import_node_fs11.statSync)(path).mtimeMs;
   } catch {
     return 0;
   }
 }
 function pruneQuarantine(root, keep) {
-  const dir = (0, import_node_path8.join)(root, "quarantine");
+  const dir = (0, import_node_path9.join)(root, "quarantine");
   let generations;
   try {
-    generations = (0, import_node_fs10.readdirSync)(dir, { withFileTypes: true }).filter((entry) => entry.isDirectory() && entry.name.startsWith("mmi-")).map((entry) => (0, import_node_path8.join)(dir, entry.name)).sort((a, b) => mtimeMs(b) - mtimeMs(a));
+    generations = (0, import_node_fs11.readdirSync)(dir, { withFileTypes: true }).filter((entry) => entry.isDirectory() && entry.name.startsWith("mmi-")).map((entry) => (0, import_node_path9.join)(dir, entry.name)).sort((a, b) => mtimeMs(b) - mtimeMs(a));
   } catch {
     return 0;
   }
   let stranded = 0;
   try {
-    for (const entry of (0, import_node_fs10.readdirSync)(dir, { withFileTypes: true })) {
+    for (const entry of (0, import_node_fs11.readdirSync)(dir, { withFileTypes: true })) {
       if (!entry.isFile() || !/^rollback\.json\.tmp-\d+$/.test(entry.name)) continue;
-      const path = (0, import_node_path8.join)(dir, entry.name);
+      const path = (0, import_node_path9.join)(dir, entry.name);
       if (Date.now() - mtimeMs(path) < STRANDED_TMP_AGE_MS) continue;
       discard(path);
       stranded += 1;
@@ -1259,16 +1426,16 @@ function pruneQuarantine(root, keep) {
 }
 function restorePrevious(live, quarantined, broken) {
   try {
-    (0, import_node_fs10.renameSync)(live, broken);
+    (0, import_node_fs11.renameSync)(live, broken);
   } catch {
     return "kept-broken";
   }
   try {
-    (0, import_node_fs10.renameSync)(quarantined, live);
+    (0, import_node_fs11.renameSync)(quarantined, live);
     return "restored";
   } catch {
     try {
-      (0, import_node_fs10.renameSync)(broken, live);
+      (0, import_node_fs11.renameSync)(broken, live);
       return "kept-broken";
     } catch {
       return "lost";
@@ -1279,7 +1446,7 @@ function cursorArm(options) {
   const env = options.env ?? process.env;
   const { target, dryRun, paths } = options;
   const root = cursorPluginsRoot();
-  const live = (0, import_node_path8.join)(root, "local", "mmi");
+  const live = (0, import_node_path9.join)(root, "local", "mmi");
   const result = (from, to, verdict, detail) => ({
     surface: "cursor",
     from,
@@ -1288,7 +1455,7 @@ function cursorArm(options) {
     detail,
     // C11: the constraint of the generation LEFT at `live` — read at result time, so a failed
     // switch reports the restored generation's declaration, not the rejected one's (#4973).
-    compat: readManifestCompat((0, import_node_path8.join)(live, MANIFEST))
+    compat: readManifestCompat((0, import_node_path9.join)(live, MANIFEST))
   });
   const current = manifest(live);
   const installed = current?.version ?? null;
@@ -1302,7 +1469,7 @@ function cursorArm(options) {
   if (installed === target && treeHealthy2(live)) {
     return result(installed, target, "ok", `already at target ${target}${userHooksDetail(live, (0, import_node_os4.homedir)())}`);
   }
-  if ((0, import_node_fs10.existsSync)(live) && !mmiOwned(live)) {
+  if ((0, import_node_fs11.existsSync)(live) && !mmiOwned(live)) {
     return result(installed, target, "defer", `${live} carries no MMI ownership marker (plugin manifest name, or a ${PACKAGE} package.json) \u2014 refusing to displace an unmanaged directory (mmi-cli plugin heal adopts it)`);
   }
   if (dryRun) {
@@ -1318,15 +1485,16 @@ function cursorArm(options) {
   }
   const busy = cursorHostEvidence(env);
   if (busy) {
-    return result(installed, target, "defer", `Cursor is running (${busy}) \u2014 the plugin tree is only swapped while the host is absent`);
+    const pending = dryRun ? "" : ` \u2014 ${noteBusyDefer(paths, env, { surface: "cursor", target, reason: busy, images: ["Cursor"] })}`;
+    return result(installed, target, "defer", `Cursor is running (${busy}) \u2014 the plugin tree is only swapped while the host is absent${pending}`);
   }
   const stamp = Date.now();
-  const incoming = (0, import_node_path8.join)(root, "staging", `mmi-${safeSegment(target)}-${stamp}`);
-  const quarantined = (0, import_node_path8.join)(root, "quarantine", `mmi-${safeSegment(installed ?? "unknown")}-${stamp}`);
-  for (const dir of ["local", "staging", "quarantine"]) (0, import_node_fs10.mkdirSync)((0, import_node_path8.join)(root, dir), { recursive: true });
+  const incoming = (0, import_node_path9.join)(root, "staging", `mmi-${safeSegment(target)}-${stamp}`);
+  const quarantined = (0, import_node_path9.join)(root, "quarantine", `mmi-${safeSegment(installed ?? "unknown")}-${stamp}`);
+  for (const dir of ["local", "staging", "quarantine"]) (0, import_node_fs11.mkdirSync)((0, import_node_path9.join)(root, dir), { recursive: true });
   try {
     discard(incoming);
-    (0, import_node_fs10.cpSync)(staged.packageRoot, incoming, { recursive: true });
+    (0, import_node_fs11.cpSync)(staged.packageRoot, incoming, { recursive: true });
   } catch (error) {
     discard(incoming);
     return result(installed, target, "defer", `copy into ${root} failed: ${message(error)}`);
@@ -1338,28 +1506,31 @@ function cursorArm(options) {
   const started = cursorHostEvidence(env);
   if (started) {
     discard(incoming);
-    return result(installed, target, "defer", `Cursor started during staging (${started}) \u2014 the plugin tree is only swapped while the host is absent`);
+    const pending = noteBusyDefer(paths, env, { surface: "cursor", target, reason: started, images: ["Cursor"] });
+    return result(installed, target, "defer", `Cursor started during staging (${started}) \u2014 the plugin tree is only swapped while the host is absent \u2014 ${pending}`);
   }
   let displaced = false;
   try {
-    if ((0, import_node_fs10.existsSync)(live)) {
-      (0, import_node_fs10.renameSync)(live, quarantined);
+    if ((0, import_node_fs11.existsSync)(live)) {
+      (0, import_node_fs11.renameSync)(live, quarantined);
       displaced = true;
     }
-    (0, import_node_fs10.renameSync)(incoming, live);
+    (0, import_node_fs11.renameSync)(incoming, live);
   } catch (error) {
-    if (displaced && !(0, import_node_fs10.existsSync)(live)) {
+    if (displaced && !(0, import_node_fs11.existsSync)(live)) {
       try {
-        (0, import_node_fs10.renameSync)(quarantined, live);
+        (0, import_node_fs11.renameSync)(quarantined, live);
       } catch {
       }
     }
     discard(incoming);
-    return result(installed, target, "defer", `generation switch failed, previous generation retained: ${message(error)}`);
+    const reason = message(error);
+    const pending = lockShaped(reason) ? ` \u2014 ${noteBusyDefer(paths, env, { surface: "cursor", target, reason, images: ["Cursor"] })}` : "";
+    return result(installed, target, "defer", `generation switch failed, previous generation retained: ${reason}${pending}`);
   }
   const evidence = manifest(live)?.version;
   if (evidence !== target || !treeHealthy2(live)) {
-    const broken = `${(0, import_node_path8.join)(root, "quarantine", `mmi-${safeSegment(evidence ?? "broken")}-${stamp}`)}-failed`;
+    const broken = `${(0, import_node_path9.join)(root, "quarantine", `mmi-${safeSegment(evidence ?? "broken")}-${stamp}`)}-failed`;
     const outcome = displaced ? restorePrevious(live, quarantined, broken) : "none";
     const detail = outcome === "restored" ? `restored the previous generation ${installed ?? "unknown"}, unverified tree kept at ${broken}` : outcome === "lost" ? `restore failed and ${live} is missing \u2014 the previous generation is at ${quarantined}` : displaced ? `restore failed, the unverified tree is still live and the previous generation is at ${quarantined}` : "nothing was displaced \u2014 there is no previous generation to restore";
     writeRollbackPointer(root, outcome === "restored" ? { installed: installed ?? "unknown", previous: null, generation: null } : { installed: evidence ?? "unknown", previous: installed, generation: displaced ? quarantined : null });
@@ -1372,8 +1543,8 @@ function cursorArm(options) {
 }
 
 // src/arm-jervcode.ts
-var import_node_fs11 = require("node:fs");
-var import_node_path9 = require("node:path");
+var import_node_fs12 = require("node:fs");
+var import_node_path10 = require("node:path");
 var PI_PACKAGE = "@mutmutco/pi-plugin";
 function hostEnv(env) {
   const dir = jervcodeAgentDir(env);
@@ -1384,7 +1555,7 @@ function hostCommands(_env) {
 }
 function readPackageSpecs(env) {
   try {
-    const settings = JSON.parse((0, import_node_fs11.readFileSync)((0, import_node_path9.join)(jervcodeAgentDir(env), "settings.json"), "utf8"));
+    const settings = JSON.parse((0, import_node_fs12.readFileSync)((0, import_node_path10.join)(jervcodeAgentDir(env), "settings.json"), "utf8"));
     return Array.isArray(settings.packages) ? settings.packages.filter((entry) => typeof entry === "string") : [];
   } catch {
     return null;
@@ -1392,14 +1563,14 @@ function readPackageSpecs(env) {
 }
 function installedVersion(env) {
   try {
-    const manifest2 = JSON.parse((0, import_node_fs11.readFileSync)((0, import_node_path9.join)(jervcodeAgentDir(env), "npm", "node_modules", ...PI_PACKAGE.split("/"), "package.json"), "utf8"));
+    const manifest2 = JSON.parse((0, import_node_fs12.readFileSync)((0, import_node_path10.join)(jervcodeAgentDir(env), "npm", "node_modules", ...PI_PACKAGE.split("/"), "package.json"), "utf8"));
     return typeof manifest2.version === "string" ? manifest2.version : null;
   } catch {
     return null;
   }
 }
 function probeJervcodeInstallation(env = process.env) {
-  const location = (0, import_node_path9.join)(jervcodeAgentDir(env), "npm", "node_modules", ...PI_PACKAGE.split("/"));
+  const location = (0, import_node_path10.join)(jervcodeAgentDir(env), "npm", "node_modules", ...PI_PACKAGE.split("/"));
   const version = installedVersion(env);
   return { version, location, detail: version ? "materialized pi package manifest" : "materialized pi package manifest was unreadable" };
 }
@@ -1421,32 +1592,32 @@ function jervcodeArm(options) {
     detail,
     // C11: the constraint of the package pi LEFT materialised — read at result time, so defer/fail
     // carry the previous payload's declaration (#4973 reconsult ruling).
-    compat: readManifestCompat((0, import_node_path9.join)(jervcodeAgentDir(env), "npm", "node_modules", ...PI_PACKAGE.split("/"), "package.json"))
+    compat: readManifestCompat((0, import_node_path10.join)(jervcodeAgentDir(env), "npm", "node_modules", ...PI_PACKAGE.split("/"), "package.json"))
   });
   const before = readPackageSpecs(env);
-  if (!before) return result(null, options.target, "defer", `cannot read ${(0, import_node_path9.join)(jervcodeAgentDir(env), "settings.json")}`);
+  if (!before) return result(null, options.target, "defer", `cannot read ${(0, import_node_path10.join)(jervcodeAgentDir(env), "settings.json")}`);
   const from = installedVersion(env);
   const legacy = before.filter(isLegacyMmiPiPath);
   const highWater = journalHighWater(options.paths.journalPath, "jervcode");
   const floor = from && compareSemver(from, options.target) > 0 ? `installed ${from} is above candidate ${options.target} (monotonic)` : highWater && compareSemver(highWater, options.target) > 0 ? `journal high-water ${highWater} is above candidate ${options.target} (monotonic)` : null;
   if (options.dryRun) {
     const action = floor ? `hold ${from ?? "the install"} and skip the install (${floor})` : before.includes(exact) && from === options.target ? "keep exact pin" : `install ${exact}`;
-    return { surface: "jervcode", from, to: options.target, verdict: "ok", detail: `dry-run: would ${action}${legacy.length ? ` and retire ${legacy.length} legacy claude-cache path registration${legacy.length === 1 ? "" : "s"}` : ""}`, compat: readManifestCompat((0, import_node_path9.join)(jervcodeAgentDir(env), "npm", "node_modules", ...PI_PACKAGE.split("/"), "package.json")) };
+    return { surface: "jervcode", from, to: options.target, verdict: "ok", detail: `dry-run: would ${action}${legacy.length ? ` and retire ${legacy.length} legacy claude-cache path registration${legacy.length === 1 ? "" : "s"}` : ""}`, compat: readManifestCompat((0, import_node_path10.join)(jervcodeAgentDir(env), "npm", "node_modules", ...PI_PACKAGE.split("/"), "package.json")) };
   }
   const hosted = hostEnv(env);
   const commands = hostCommands(env);
   const command = commands.find((bin) => runner(bin, ["--version"], hosted).status === 0);
-  if (!command) return { surface: "jervcode", from, to: options.target, verdict: "defer", detail: "neither `jervcode` nor `pi` answered --version \u2014 the host CLI is not on PATH", compat: readManifestCompat((0, import_node_path9.join)(jervcodeAgentDir(env), "npm", "node_modules", ...PI_PACKAGE.split("/"), "package.json")) };
+  if (!command) return { surface: "jervcode", from, to: options.target, verdict: "defer", detail: "neither `jervcode` nor `pi` answered --version \u2014 the host CLI is not on PATH", compat: readManifestCompat((0, import_node_path10.join)(jervcodeAgentDir(env), "npm", "node_modules", ...PI_PACKAGE.split("/"), "package.json")) };
   if (!floor && (!before.includes(exact) || from !== options.target)) {
     const install = runner(command, ["install", exact], hosted);
     if (install.status !== 0) {
-      return { surface: "jervcode", from, to: options.target, verdict: "defer", detail: `${command} install ${exact} failed: ${failure2(install)}`, compat: readManifestCompat((0, import_node_path9.join)(jervcodeAgentDir(env), "npm", "node_modules", ...PI_PACKAGE.split("/"), "package.json")) };
+      return { surface: "jervcode", from, to: options.target, verdict: "defer", detail: `${command} install ${exact} failed: ${failure2(install)}`, compat: readManifestCompat((0, import_node_path10.join)(jervcodeAgentDir(env), "npm", "node_modules", ...PI_PACKAGE.split("/"), "package.json")) };
     }
   }
   for (const stale of legacy) {
     const removed = runner(command, ["remove", stale], hosted);
     if (removed.status !== 0) {
-      return { surface: "jervcode", from, to: options.target, verdict: "defer", detail: `${command} remove of the legacy registration failed: ${failure2(removed)}`, compat: readManifestCompat((0, import_node_path9.join)(jervcodeAgentDir(env), "npm", "node_modules", ...PI_PACKAGE.split("/"), "package.json")) };
+      return { surface: "jervcode", from, to: options.target, verdict: "defer", detail: `${command} remove of the legacy registration failed: ${failure2(removed)}`, compat: readManifestCompat((0, import_node_path10.join)(jervcodeAgentDir(env), "npm", "node_modules", ...PI_PACKAGE.split("/"), "package.json")) };
     }
   }
   const after = readPackageSpecs(env);
@@ -1454,7 +1625,7 @@ function jervcodeArm(options) {
   const legacyAfter = after?.filter(isLegacyMmiPiPath) ?? [];
   const retired = legacy.length ? `; retired ${legacy.length} legacy claude-cache path registration${legacy.length === 1 ? "" : "s"}` : "";
   if (floor && !legacyAfter.length) {
-    return { surface: "jervcode", from, to: converged ?? highWater ?? options.target, verdict: "skip", detail: `${floor}${retired}`, compat: readManifestCompat((0, import_node_path9.join)(jervcodeAgentDir(env), "npm", "node_modules", ...PI_PACKAGE.split("/"), "package.json")) };
+    return { surface: "jervcode", from, to: converged ?? highWater ?? options.target, verdict: "skip", detail: `${floor}${retired}`, compat: readManifestCompat((0, import_node_path10.join)(jervcodeAgentDir(env), "npm", "node_modules", ...PI_PACKAGE.split("/"), "package.json")) };
   }
   if (!after?.includes(exact) || converged !== options.target || legacyAfter.length) {
     return {
@@ -1475,14 +1646,15 @@ function jervcodeArm(options) {
 }
 
 // src/arm-hermes.ts
-var import_node_fs12 = require("node:fs");
-var import_node_path10 = require("node:path");
+var import_node_fs13 = require("node:fs");
+var import_node_child_process9 = require("node:child_process");
+var import_node_path11 = require("node:path");
 var PACKAGE2 = "@mutmutco/hermes-plugin";
 var MANIFEST2 = "plugin.yaml";
 var TREE_MARKERS2 = [MANIFEST2, "__init__.py", "skills"];
 function yamlVersion(root) {
   try {
-    const text = (0, import_node_fs12.readFileSync)((0, import_node_path10.join)(root, MANIFEST2), "utf8");
+    const text = (0, import_node_fs13.readFileSync)((0, import_node_path11.join)(root, MANIFEST2), "utf8");
     try {
       const version = JSON.parse(text).version;
       if (typeof version === "string" && version.trim()) return version.trim();
@@ -1495,9 +1667,9 @@ function yamlVersion(root) {
   }
 }
 function treeHealthy3(root) {
-  return TREE_MARKERS2.slice(0, 2).every((file) => (0, import_node_fs12.existsSync)((0, import_node_path10.join)(root, file))) && (() => {
+  return TREE_MARKERS2.slice(0, 2).every((file) => (0, import_node_fs13.existsSync)((0, import_node_path11.join)(root, file))) && (() => {
     try {
-      return (0, import_node_fs12.statSync)((0, import_node_path10.join)(root, "skills")).isDirectory();
+      return (0, import_node_fs13.statSync)((0, import_node_path11.join)(root, "skills")).isDirectory();
     } catch {
       return false;
     }
@@ -1505,13 +1677,13 @@ function treeHealthy3(root) {
 }
 function packageIdentity(root) {
   try {
-    return JSON.parse((0, import_node_fs12.readFileSync)((0, import_node_path10.join)(root, "package.json"), "utf8")).name === PACKAGE2;
+    return JSON.parse((0, import_node_fs13.readFileSync)((0, import_node_path11.join)(root, "package.json"), "utf8")).name === PACKAGE2;
   } catch {
     return false;
   }
 }
 function probeHermesInstallation(env = process.env) {
-  const location = (0, import_node_path10.join)(hermesHome(env), "plugins", "mmi");
+  const location = (0, import_node_path11.join)(hermesHome(env), "plugins", "mmi");
   const version = yamlVersion(location);
   return { version, location, detail: version ? "installed Hermes plugin manifest" : "installed Hermes plugin manifest was unreadable" };
 }
@@ -1520,27 +1692,45 @@ function mmiOwned2(root) {
 }
 function discard2(path) {
   try {
-    (0, import_node_fs12.rmSync)(path, { recursive: true, force: true });
+    (0, import_node_fs13.rmSync)(path, { recursive: true, force: true });
   } catch {
   }
 }
 function message2(error) {
   return String(error?.message ?? error).replace(/\s+/g, " ").slice(0, 200);
 }
+var HERMES_PROCESS_SEGMENT = /^hermes(-cli|-code)?(\.(exe|cmd|bat|ps1|js|mjs|cjs|py))?$/i;
+function hermesProcessToken(line, home) {
+  const normalized = line.replace(/["']/g, " ");
+  if (home && normalized.toLowerCase().includes(home.toLowerCase())) return home;
+  for (const token of normalized.split(/\s+/)) {
+    if (token && token.split(/[/\\]/).some((segment) => HERMES_PROCESS_SEGMENT.test(segment))) return token;
+  }
+  return null;
+}
+function hermesHostEvidence(env, home) {
+  const result = process.platform === "win32" ? (0, import_node_child_process9.spawnSync)("powershell.exe", ["-NoProfile", "-Command", "Get-CimInstance Win32_Process | ForEach-Object { $_.Name + ' ' + $_.CommandLine }"], { encoding: "utf8", windowsHide: true, timeout: 15e3 }) : (0, import_node_child_process9.spawnSync)("ps", ["-eo", "args="], { encoding: "utf8", windowsHide: true, timeout: 15e3 });
+  if (result.status !== 0 || !(result.stdout ?? "").trim()) return "the process list is unreadable (unsafe to write)";
+  for (const line of result.stdout.split(/\r?\n/)) {
+    const token = hermesProcessToken(line, home);
+    if (token) return `a live process names hermes (${token})`;
+  }
+  return null;
+}
 function materializeHermesSkills(home) {
-  const pluginSkills = (0, import_node_path10.join)(home, "plugins", "mmi", "skills");
-  const skillsRoot = (0, import_node_path10.join)(home, "skills");
-  const targetRoot = (0, import_node_path10.join)(skillsRoot, "mmi");
+  const pluginSkills = (0, import_node_path11.join)(home, "plugins", "mmi", "skills");
+  const skillsRoot = (0, import_node_path11.join)(home, "skills");
+  const targetRoot = (0, import_node_path11.join)(skillsRoot, "mmi");
   try {
-    if (!(0, import_node_fs12.existsSync)(pluginSkills)) return { ok: false, detail: `plugin skills tree missing at ${pluginSkills}` };
-    const names = (0, import_node_fs12.readdirSync)(pluginSkills, { withFileTypes: true }).filter((entry) => entry.isDirectory() && !entry.name.startsWith("_")).map((entry) => entry.name);
+    if (!(0, import_node_fs13.existsSync)(pluginSkills)) return { ok: false, detail: `plugin skills tree missing at ${pluginSkills}` };
+    const names = (0, import_node_fs13.readdirSync)(pluginSkills, { withFileTypes: true }).filter((entry) => entry.isDirectory() && !entry.name.startsWith("_")).map((entry) => entry.name);
     if (!names.length) return { ok: false, detail: `plugin skills tree is empty at ${pluginSkills}` };
-    (0, import_node_fs12.mkdirSync)(skillsRoot, { recursive: true });
-    const incoming = (0, import_node_path10.join)(skillsRoot, ".mmi-incoming");
+    (0, import_node_fs13.mkdirSync)(skillsRoot, { recursive: true });
+    const incoming = (0, import_node_path11.join)(skillsRoot, ".mmi-incoming");
     discard2(incoming);
-    (0, import_node_fs12.cpSync)(pluginSkills, incoming, { recursive: true });
+    (0, import_node_fs13.cpSync)(pluginSkills, incoming, { recursive: true });
     discard2(targetRoot);
-    (0, import_node_fs12.renameSync)(incoming, targetRoot);
+    (0, import_node_fs13.renameSync)(incoming, targetRoot);
     return { ok: true, detail: `provisioned ${names.length} skills to ${targetRoot}` };
   } catch (error) {
     return { ok: false, detail: message2(error) };
@@ -1549,8 +1739,8 @@ function materializeHermesSkills(home) {
 function hermesArm(options) {
   const env = options.env ?? process.env;
   const home = hermesHome(env);
-  const parent = (0, import_node_path10.join)(home, "plugins");
-  const live = (0, import_node_path10.join)(parent, "mmi");
+  const parent = (0, import_node_path11.join)(home, "plugins");
+  const live = (0, import_node_path11.join)(parent, "mmi");
   const installed = yamlVersion(live);
   const result = (from, to, verdict, detail) => ({
     surface: "hermes",
@@ -1559,8 +1749,8 @@ function hermesArm(options) {
     verdict,
     detail
   });
-  if (!(0, import_node_fs12.existsSync)(home)) return result(null, options.target, "skip", `absent (${home}) \u2014 skipped without writes`);
-  if ((0, import_node_fs12.existsSync)(live) && !mmiOwned2(live)) {
+  if (!(0, import_node_fs13.existsSync)(home)) return result(null, options.target, "skip", `absent (${home}) \u2014 skipped without writes`);
+  if ((0, import_node_fs13.existsSync)(live) && !mmiOwned2(live)) {
     return result(installed, options.target, "defer", `${live} carries no ${PACKAGE2} package identity \u2014 refusing to displace an unmanaged Hermes mmi plugin`);
   }
   if (installed && compareSemver(installed, options.target) > 0) return result(installed, installed, "skip", `installed ${installed} is above candidate ${options.target} (monotonic)`);
@@ -1571,21 +1761,21 @@ function hermesArm(options) {
     if (!skills2.ok) return result(installed, options.target, "fail", `plugin at target ${options.target}, but skills provisioning failed: ${skills2.detail}`);
     return result(installed, options.target, "ok", `already at target ${options.target}; ${skills2.detail}`);
   }
-  if (options.dryRun) return result(installed, options.target, "ok", `dry-run: would stage ${PACKAGE2}@${options.target}, atomically switch ${installed ?? "absent"} -> ${options.target}, then provision skills into ${(0, import_node_path10.join)(home, "skills", "mmi")}`);
+  if (options.dryRun) return result(installed, options.target, "ok", `dry-run: would stage ${PACKAGE2}@${options.target}, atomically switch ${installed ?? "absent"} -> ${options.target}, then provision skills into ${(0, import_node_path11.join)(home, "skills", "mmi")}`);
   const staged = stagePackage({ surface: "hermes", packageName: PACKAGE2, target: options.target, witness: MANIFEST2, paths: options.paths, env });
   if ("defer" in staged) return result(installed, options.target, "defer", staged.defer);
   if (yamlVersion(staged.packageRoot) !== options.target || !treeHealthy3(staged.packageRoot)) {
     return result(installed, options.target, "defer", `staged Hermes manifest is ${yamlVersion(staged.packageRoot) ?? "unreadable"} or its tree is incomplete (expected ${options.target})`);
   }
-  const scratch = (0, import_node_path10.join)(home, ".mmi-updater");
-  const incomingRoot = (0, import_node_path10.join)(scratch, "incoming");
-  const incoming = (0, import_node_path10.join)(incomingRoot, options.target);
-  const quarantine = (0, import_node_path10.join)(scratch, "quarantine", `${installed ?? "unknown"}-${Date.now()}`);
+  const scratch = (0, import_node_path11.join)(home, ".mmi-updater");
+  const incomingRoot = (0, import_node_path11.join)(scratch, "incoming");
+  const incoming = (0, import_node_path11.join)(incomingRoot, options.target);
+  const quarantine = (0, import_node_path11.join)(scratch, "quarantine", `${installed ?? "unknown"}-${Date.now()}`);
   try {
-    (0, import_node_fs12.mkdirSync)(parent, { recursive: true });
-    (0, import_node_fs12.mkdirSync)((0, import_node_path10.join)(scratch, "quarantine"), { recursive: true });
+    (0, import_node_fs13.mkdirSync)(parent, { recursive: true });
+    (0, import_node_fs13.mkdirSync)((0, import_node_path11.join)(scratch, "quarantine"), { recursive: true });
     discard2(incomingRoot);
-    (0, import_node_fs12.cpSync)(staged.packageRoot, incoming, { recursive: true });
+    (0, import_node_fs13.cpSync)(staged.packageRoot, incoming, { recursive: true });
   } catch (error) {
     return result(installed, options.target, "defer", `cannot place incoming Hermes generation: ${message2(error)}`);
   }
@@ -1593,24 +1783,32 @@ function hermesArm(options) {
     discard2(incomingRoot);
     return result(installed, options.target, "defer", "incoming Hermes generation did not reproduce the verified payload");
   }
-  const displaced = (0, import_node_fs12.existsSync)(live);
+  const busy = hermesHostEvidence(env, home);
+  if (busy) {
+    discard2(incomingRoot);
+    const pending = noteBusyDefer(options.paths, env, { surface: "hermes", target: options.target, reason: busy, images: ["hermes"], dirs: [home] });
+    return result(installed, options.target, "defer", `Hermes may be running \u2014 the plugin tree is only swapped while the host is absent: ${busy} \u2014 ${pending}`);
+  }
+  const displaced = (0, import_node_fs13.existsSync)(live);
   try {
-    if (displaced) (0, import_node_fs12.renameSync)(live, quarantine);
-    (0, import_node_fs12.renameSync)(incoming, live);
+    if (displaced) (0, import_node_fs13.renameSync)(live, quarantine);
+    (0, import_node_fs13.renameSync)(incoming, live);
   } catch (error) {
-    if (displaced && !(0, import_node_fs12.existsSync)(live)) try {
-      (0, import_node_fs12.renameSync)(quarantine, live);
+    if (displaced && !(0, import_node_fs13.existsSync)(live)) try {
+      (0, import_node_fs13.renameSync)(quarantine, live);
     } catch {
     }
     discard2(incomingRoot);
-    return result(installed, options.target, "defer", `Hermes generation switch failed; previous generation retained: ${message2(error)}`);
+    const reason = message2(error);
+    const pending = lockShaped(reason) ? ` \u2014 ${noteBusyDefer(options.paths, env, { surface: "hermes", target: options.target, reason, images: ["hermes"], dirs: [home] })}` : "";
+    return result(installed, options.target, "defer", `Hermes generation switch failed; previous generation retained: ${reason}${pending}`);
   }
   if (yamlVersion(live) !== options.target || !treeHealthy3(live)) {
-    const broken = (0, import_node_path10.join)(scratch, "rejected", `${options.target}-${Date.now()}`);
+    const broken = (0, import_node_path11.join)(scratch, "rejected", `${options.target}-${Date.now()}`);
     try {
-      (0, import_node_fs12.mkdirSync)((0, import_node_path10.join)(scratch, "rejected"), { recursive: true });
-      (0, import_node_fs12.renameSync)(live, broken);
-      if (displaced) (0, import_node_fs12.renameSync)(quarantine, live);
+      (0, import_node_fs13.mkdirSync)((0, import_node_path11.join)(scratch, "rejected"), { recursive: true });
+      (0, import_node_fs13.renameSync)(live, broken);
+      if (displaced) (0, import_node_fs13.renameSync)(quarantine, live);
     } catch (error) {
       return result(installed, yamlVersion(live) ?? "unknown", "fail", `post-switch Hermes verification failed and recovery failed: ${message2(error)}`);
     }
@@ -1623,9 +1821,9 @@ function hermesArm(options) {
 }
 
 // src/reap.ts
-var import_node_child_process8 = require("node:child_process");
-var import_node_fs13 = require("node:fs");
-var import_node_path11 = require("node:path");
+var import_node_child_process10 = require("node:child_process");
+var import_node_fs14 = require("node:fs");
+var import_node_path12 = require("node:path");
 var KEEP_GENERATIONS2 = 2;
 var SCRATCH_AGE_MS = 24 * 60 * 6e4;
 var ORPHAN_MIN_AGE_MS = 10 * 6e4;
@@ -1633,7 +1831,7 @@ var SNAPSHOT_TIMEOUT_MS = 2e4;
 var MAX_UNWIND_ROUNDS = 4;
 function listDirs(path) {
   try {
-    return (0, import_node_fs13.readdirSync)(path, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+    return (0, import_node_fs14.readdirSync)(path, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
   } catch {
     return [];
   }
@@ -1641,7 +1839,7 @@ function listDirs(path) {
 function generationSets(root) {
   const children = listDirs(root);
   if (children.some((name) => parseSemver(name))) return [root];
-  return children.map((name) => (0, import_node_path11.join)(root, name)).filter((path) => listDirs(path).some((name) => parseSemver(name)));
+  return children.map((name) => (0, import_node_path12.join)(root, name)).filter((path) => listDirs(path).some((name) => parseSemver(name)));
 }
 function pruneGenerations(root, category, dryRun) {
   let reaped = 0;
@@ -1654,7 +1852,7 @@ function pruneGenerations(root, category, dryRun) {
         continue;
       }
       try {
-        (0, import_node_fs13.rmSync)((0, import_node_path11.join)(set, version), { recursive: true, force: true });
+        (0, import_node_fs14.rmSync)((0, import_node_path12.join)(set, version), { recursive: true, force: true });
         reaped += 1;
       } catch (error) {
         failures.push(`${version}: ${error?.code ?? error?.message ?? error}`);
@@ -1668,8 +1866,8 @@ function pruneGenerations(root, category, dryRun) {
 }
 var LEASE_STEAL_SCRATCH = /^lease\.lock\.stale-\d+$/;
 function atomicWriteScratch(path) {
-  const literal = (0, import_node_path11.basename)(path).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  return { dir: (0, import_node_path11.dirname)(path), pattern: new RegExp(`^${literal}\\.tmp-\\d+$`) };
+  const literal = (0, import_node_path12.basename)(path).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return { dir: (0, import_node_path12.dirname)(path), pattern: new RegExp(`^${literal}\\.tmp-\\d+$`) };
 }
 function reapScratch(context, dryRun) {
   const category = "scratch";
@@ -1687,7 +1885,7 @@ function reapScratch(context, dryRun) {
   for (const [dir, patterns] of scanned) {
     let entries;
     try {
-      entries = (0, import_node_fs13.readdirSync)(dir, { withFileTypes: true });
+      entries = (0, import_node_fs14.readdirSync)(dir, { withFileTypes: true });
     } catch {
       unreadable.push(dir);
       continue;
@@ -1695,10 +1893,10 @@ function reapScratch(context, dryRun) {
     for (const entry of entries) {
       if (!patterns.some((pattern) => pattern.test(entry.name))) continue;
       if (!entry.isFile()) continue;
-      const path = (0, import_node_path11.join)(dir, entry.name);
+      const path = (0, import_node_path12.join)(dir, entry.name);
       let ageMs;
       try {
-        ageMs = now - (0, import_node_fs13.statSync)(path).mtimeMs;
+        ageMs = now - (0, import_node_fs14.statSync)(path).mtimeMs;
       } catch {
         continue;
       }
@@ -1708,7 +1906,7 @@ function reapScratch(context, dryRun) {
         continue;
       }
       try {
-        (0, import_node_fs13.rmSync)(path, { force: true });
+        (0, import_node_fs14.rmSync)(path, { force: true });
         reaped += 1;
       } catch (error) {
         failures.push(`${entry.name}: ${error?.code ?? error?.message ?? error}`);
@@ -1824,7 +2022,7 @@ function stillTheProvenProcess(rows, kill) {
 }
 var SNAPSHOT_COMMAND = "Get-CimInstance Win32_Process | Select-Object ProcessId,ParentProcessId,Name,CommandLine,@{n='Started';e={if ($_.CreationDate) { $_.CreationDate.ToUniversalTime().ToString('o') }}} | ConvertTo-Json -Compress";
 function processSnapshot() {
-  const result = (0, import_node_child_process8.spawnSync)("powershell.exe", ["-NoProfile", "-Command", SNAPSHOT_COMMAND], { encoding: "utf8", windowsHide: true, timeout: SNAPSHOT_TIMEOUT_MS });
+  const result = (0, import_node_child_process10.spawnSync)("powershell.exe", ["-NoProfile", "-Command", SNAPSHOT_COMMAND], { encoding: "utf8", windowsHide: true, timeout: SNAPSHOT_TIMEOUT_MS });
   if (result.status !== 0 || !(result.stdout ?? "").trim()) return null;
   try {
     const parsed = JSON.parse(result.stdout);
@@ -1948,12 +2146,20 @@ function reconcile(options) {
     if (arm.verdict === "fail") arm.repeatFailure = journalSurfaceRepeatedFail(paths.journalPath, arm.surface, run);
     journal({ kind: "arm", surface: arm.surface, from: arm.from, to: arm.to, verdict: arm.verdict, detail: arm.detail, compat: arm.compat });
     options.onArm?.(arm);
+    if (arm.verdict === "ok" && !options.dryRun) clearPending(paths, arm.surface);
     if (arm.verdict === "defer") summary.exit = Math.max(summary.exit, 2);
     if (arm.verdict === "fail") summary.exit = Math.max(summary.exit, 3);
   };
   try {
     say("acquiring single-writer lease");
     return withLease(paths.leasePath, () => {
+      if (!options.dryRun) {
+        const pendingBefore = readPending(paths);
+        if (pendingBefore.length) {
+          const resumed = resumePendingWatcher(paths, env);
+          journal({ kind: "pending", verdict: "ok", count: pendingBefore.length, detail: resumed.scheduled ? `${pendingBefore.length} pending appl${pendingBefore.length === 1 ? "y" : "ies"}; post-exit watcher pid ${resumed.pid} waiting` : `${pendingBefore.length} pending appl${pendingBefore.length === 1 ? "y" : "ies"}; ${resumed.reason}` });
+        }
+      }
       summary.reap = reap({ paths, dryRun: options.dryRun, env });
       for (const row of summary.reap) journal({ kind: "reap", surface: row.category, verdict: row.verdict, count: row.reaped, detail: row.detail });
       for (const row of summary.reap.filter((entry) => entry.verdict !== "skip")) say(`reap ${row.category}: ${row.verdict}${row.detail ? " \u2014 " + row.detail : ""}`);
@@ -2047,10 +2253,10 @@ function reconcile(options) {
 }
 
 // src/scheduler.ts
-var import_node_child_process9 = require("node:child_process");
-var import_node_fs14 = require("node:fs");
+var import_node_child_process11 = require("node:child_process");
+var import_node_fs15 = require("node:fs");
 var import_node_os5 = require("node:os");
-var import_node_path12 = require("node:path");
+var import_node_path13 = require("node:path");
 var TASK_NAME = "MMI Fleet Updater";
 var LAUNCHER_FILE = "reconcile-hidden.vbs";
 var RUN_BOUND = "PT15M";
@@ -2066,15 +2272,15 @@ var SYSTEMD_UNIT = "mmi-hub-updater";
 var SYSTEMD_SERVICE_NAME = `${SYSTEMD_UNIT}.service`;
 var SYSTEMD_TIMER_NAME = `${SYSTEMD_UNIT}.timer`;
 function schtasks(args) {
-  const result = (0, import_node_child_process9.spawnSync)("schtasks.exe", args, { encoding: "utf8", windowsHide: true });
+  const result = (0, import_node_child_process11.spawnSync)("schtasks.exe", args, { encoding: "utf8", windowsHide: true });
   return { status: result.status, stdout: result.stdout ?? "", stderr: result.stderr ?? "" };
 }
 function launchctl(args) {
-  const result = (0, import_node_child_process9.spawnSync)("launchctl", args, { encoding: "utf8", windowsHide: true });
+  const result = (0, import_node_child_process11.spawnSync)("launchctl", args, { encoding: "utf8", windowsHide: true });
   return { status: result.status, stdout: result.stdout ?? "", stderr: result.stderr ?? "" };
 }
 function systemctlUser(args) {
-  const result = (0, import_node_child_process9.spawnSync)("systemctl", ["--user", ...args], { encoding: "utf8", windowsHide: true });
+  const result = (0, import_node_child_process11.spawnSync)("systemctl", ["--user", ...args], { encoding: "utf8", windowsHide: true });
   return { status: result.status, stdout: result.stdout ?? "", stderr: result.stderr ?? "" };
 }
 function uid() {
@@ -2099,7 +2305,7 @@ WScript.Quit code
 `;
 }
 function loginPath(fallback = process.env.PATH ?? "") {
-  const probe = (0, import_node_child_process9.spawnSync)("/bin/sh", ["-lc", 'printf %s "$PATH"'], { encoding: "utf8", windowsHide: true, timeout: 1e4 });
+  const probe = (0, import_node_child_process11.spawnSync)("/bin/sh", ["-lc", 'printf %s "$PATH"'], { encoding: "utf8", windowsHide: true, timeout: 1e4 });
   const captured = (probe.status === 0 ? probe.stdout ?? "" : "").trim();
   const source = captured || fallback;
   const durable = source.split(":").filter((entry) => entry && !/^\/(?:private\/)?(?:tmp|var\/folders)\//.test(entry));
@@ -2208,7 +2414,7 @@ WantedBy=timers.target
 }
 function readFileOrNull(path) {
   try {
-    return (0, import_node_fs14.readFileSync)(path, "utf8");
+    return (0, import_node_fs15.readFileSync)(path, "utf8");
   } catch {
     return null;
   }
@@ -2220,7 +2426,7 @@ function elevatedRelaunch(mode, env) {
   if (env.MMI_UPDATER_ELEVATED_RETRY === "1") return false;
   const self = process.argv[1];
   const command = self ? `"${process.execPath}" "${self}" autoupdate ${mode}` : `mmi-hub autoupdate ${mode}`;
-  const relaunch = (0, import_node_child_process9.spawnSync)(
+  const relaunch = (0, import_node_child_process11.spawnSync)(
     "powershell.exe",
     ["-NoProfile", "-Command", `Start-Process -Verb RunAs -Wait -WindowStyle Hidden -FilePath 'cmd.exe' -ArgumentList '/c',${psQuote(`set MMI_UPDATER_ELEVATED_RETRY=1&& ${command}`)}`],
     { encoding: "utf8", windowsHide: true }
@@ -2231,7 +2437,7 @@ var NEVER_RUN_RESULT = 267011;
 var NEVER_RUN_YEAR = 1999;
 var EMPTY_RUN_INFO = { lastRunTime: null, lastTaskResult: null, nextRunTime: null };
 function taskRunInfo() {
-  const result = (0, import_node_child_process9.spawnSync)(
+  const result = (0, import_node_child_process11.spawnSync)(
     "powershell.exe",
     ["-NoProfile", "-Command", `$stamp = { param($t) if ($t) { $t.ToString('yyyy-MM-dd HH:mm:ss') } }; Get-ScheduledTaskInfo -TaskName '${TASK_NAME}' | Select-Object @{n='LastRunTime';e={& $stamp $_.LastRunTime}},LastTaskResult,@{n='NextRunTime';e={& $stamp $_.NextRunTime}} | ConvertTo-Json -Compress`],
     { encoding: "utf8", windowsHide: true, timeout: 3e4 }
@@ -2257,7 +2463,7 @@ function windowsSchedulerStatus(env) {
     return { ok: false, supported: true, enabled: false, ...EMPTY_RUN_INFO, detail: `"${TASK_NAME}" is not registered \u2014 run \`mmi-hub autoupdate on\`` };
   }
   const hubDist = globalDist(env, "@mutmutco/hub", "dist/index.cjs");
-  const launcherPath = (0, import_node_path12.join)(statePaths(env).root, LAUNCHER_FILE);
+  const launcherPath = (0, import_node_path13.join)(statePaths(env).root, LAUNCHER_FILE);
   const info = taskRunInfo();
   const runInfo = info ?? EMPTY_RUN_INFO;
   const fail = (detail) => ({ ok: false, supported: true, enabled: true, ...runInfo, detail });
@@ -2282,13 +2488,13 @@ function windowsSchedulerStatus(env) {
   return { ok: true, supported: true, enabled: true, ...runInfo, detail: `"${TASK_NAME}" registered ${CADENCE}; ${points}; ${ran}; next ${runInfo.nextRunTime ?? "unscheduled"}` };
 }
 function darwinSchedulerStatus(env) {
-  const plistPath = (0, import_node_path12.join)((0, import_node_os5.homedir)(), "Library", "LaunchAgents", LAUNCHD_PLIST_NAME);
+  const plistPath = (0, import_node_path13.join)((0, import_node_os5.homedir)(), "Library", "LaunchAgents", LAUNCHD_PLIST_NAME);
   const plist = readFileOrNull(plistPath);
   if (!plist) {
     return { ok: false, supported: true, enabled: false, ...EMPTY_RUN_INFO, detail: `"${LAUNCHD_LABEL}" is not registered \u2014 run \`mmi-hub autoupdate on\`` };
   }
   const hubDist = globalDist(env, "@mutmutco/hub", "dist/index.cjs");
-  const launcherPath = (0, import_node_path12.join)(statePaths(env).root, POSIX_LAUNCHER_FILE);
+  const launcherPath = (0, import_node_path13.join)(statePaths(env).root, POSIX_LAUNCHER_FILE);
   const fail = (detail) => ({ ok: false, supported: true, enabled: true, ...EMPTY_RUN_INFO, detail });
   if (!plist.includes(launcherPath)) {
     return fail(`"${LAUNCHD_LABEL}" does not run the reconcile launcher ${launcherPath} \u2014 run \`mmi-hub autoupdate on\``);
@@ -2308,15 +2514,15 @@ function darwinSchedulerStatus(env) {
   return { ok: true, supported: true, enabled: true, ...EMPTY_RUN_INFO, detail: `"${LAUNCHD_LABEL}" registered ${POSIX_CADENCE}; ${points}` };
 }
 function linuxSchedulerStatus(env) {
-  const unitDir = (0, import_node_path12.join)((0, import_node_os5.homedir)(), ".config", "systemd", "user");
-  const timerPath = (0, import_node_path12.join)(unitDir, SYSTEMD_TIMER_NAME);
+  const unitDir = (0, import_node_path13.join)((0, import_node_os5.homedir)(), ".config", "systemd", "user");
+  const timerPath = (0, import_node_path13.join)(unitDir, SYSTEMD_TIMER_NAME);
   const timer = readFileOrNull(timerPath);
-  const service = readFileOrNull((0, import_node_path12.join)(unitDir, SYSTEMD_SERVICE_NAME));
+  const service = readFileOrNull((0, import_node_path13.join)(unitDir, SYSTEMD_SERVICE_NAME));
   if (!timer || !service) {
     return { ok: false, supported: true, enabled: false, ...EMPTY_RUN_INFO, detail: `"${SYSTEMD_TIMER_NAME}" is not registered \u2014 run \`mmi-hub autoupdate on\`` };
   }
   const hubDist = globalDist(env, "@mutmutco/hub", "dist/index.cjs");
-  const launcherPath = (0, import_node_path12.join)(statePaths(env).root, POSIX_LAUNCHER_FILE);
+  const launcherPath = (0, import_node_path13.join)(statePaths(env).root, POSIX_LAUNCHER_FILE);
   const fail = (detail) => ({ ok: false, supported: true, enabled: true, ...EMPTY_RUN_INFO, detail });
   if (!service.includes(launcherPath)) {
     return fail(`"${SYSTEMD_SERVICE_NAME}" does not run the reconcile launcher ${launcherPath} \u2014 run \`mmi-hub autoupdate on\``);
@@ -2355,10 +2561,10 @@ function installWindowsTask(env) {
   const paths = ensureState(env);
   const userId = `${env.USERDOMAIN || env.COMPUTERNAME || ""}\\${env.USERNAME || ""}`.replace(/^\\/, "");
   if (!env.USERNAME) return { ok: false, detail: "cannot resolve the registering user (USERNAME unset) \u2014 the task principal must be explicit" };
-  const launcherPath = (0, import_node_path12.join)(paths.root, LAUNCHER_FILE);
-  (0, import_node_fs14.writeFileSync)(launcherPath, launcherVbs(process.execPath, hubDist), "utf8");
-  const xmlPath = (0, import_node_path12.join)(paths.root, "task.xml");
-  (0, import_node_fs14.writeFileSync)(xmlPath, "\uFEFF" + taskXml(launcherPath, paths.root, userId, localStartBoundary(/* @__PURE__ */ new Date())), "utf16le");
+  const launcherPath = (0, import_node_path13.join)(paths.root, LAUNCHER_FILE);
+  (0, import_node_fs15.writeFileSync)(launcherPath, launcherVbs(process.execPath, hubDist), "utf8");
+  const xmlPath = (0, import_node_path13.join)(paths.root, "task.xml");
+  (0, import_node_fs15.writeFileSync)(xmlPath, "\uFEFF" + taskXml(launcherPath, paths.root, userId, localStartBoundary(/* @__PURE__ */ new Date())), "utf16le");
   const create = schtasks(["/create", "/tn", TASK_NAME, "/xml", xmlPath, "/f"]);
   if (create.status !== 0) {
     const denied = /access is denied/i.test(create.stderr + create.stdout);
@@ -2374,11 +2580,11 @@ function refreshPosixLauncher(env) {
   const hubDist = globalDist(env, "@mutmutco/hub", "dist/index.cjs");
   if (!hubDist) return null;
   const paths = ensureState(env);
-  const launcherPath = (0, import_node_path12.join)(paths.root, POSIX_LAUNCHER_FILE);
+  const launcherPath = (0, import_node_path13.join)(paths.root, POSIX_LAUNCHER_FILE);
   const desired = launcherSh(process.execPath, hubDist);
   if (readFileOrNull(launcherPath) === desired) return null;
-  (0, import_node_fs14.writeFileSync)(launcherPath, desired, "utf8");
-  (0, import_node_fs14.chmodSync)(launcherPath, 493);
+  (0, import_node_fs15.writeFileSync)(launcherPath, desired, "utf8");
+  (0, import_node_fs15.chmodSync)(launcherPath, 493);
   return launcherPath;
 }
 function installLaunchd(env) {
@@ -2390,13 +2596,13 @@ function installLaunchd(env) {
   const hubDist = globalDist(env, "@mutmutco/hub", "dist/index.cjs");
   if (!hubDist) return { ok: false, detail: "cannot resolve the global @mutmutco/hub dist \u2014 run `npm install -g @mutmutco/hub` first" };
   const paths = ensureState(env);
-  const launcherPath = (0, import_node_path12.join)(paths.root, POSIX_LAUNCHER_FILE);
-  (0, import_node_fs14.writeFileSync)(launcherPath, launcherSh(process.execPath, hubDist), "utf8");
-  (0, import_node_fs14.chmodSync)(launcherPath, 493);
-  const agentsDir = (0, import_node_path12.join)((0, import_node_os5.homedir)(), "Library", "LaunchAgents");
-  (0, import_node_fs14.mkdirSync)(agentsDir, { recursive: true });
-  const plistPath = (0, import_node_path12.join)(agentsDir, LAUNCHD_PLIST_NAME);
-  (0, import_node_fs14.writeFileSync)(plistPath, launchdPlist(launcherPath, paths.root), "utf8");
+  const launcherPath = (0, import_node_path13.join)(paths.root, POSIX_LAUNCHER_FILE);
+  (0, import_node_fs15.writeFileSync)(launcherPath, launcherSh(process.execPath, hubDist), "utf8");
+  (0, import_node_fs15.chmodSync)(launcherPath, 493);
+  const agentsDir = (0, import_node_path13.join)((0, import_node_os5.homedir)(), "Library", "LaunchAgents");
+  (0, import_node_fs15.mkdirSync)(agentsDir, { recursive: true });
+  const plistPath = (0, import_node_path13.join)(agentsDir, LAUNCHD_PLIST_NAME);
+  (0, import_node_fs15.writeFileSync)(plistPath, launchdPlist(launcherPath, paths.root), "utf8");
   launchctl(["bootout", `gui/${uid()}/${LAUNCHD_LABEL}`]);
   const load = launchctl(["bootstrap", `gui/${uid()}`, plistPath]);
   if (load.status !== 0) {
@@ -2414,13 +2620,13 @@ function installSystemdTimer(env) {
   const hubDist = globalDist(env, "@mutmutco/hub", "dist/index.cjs");
   if (!hubDist) return { ok: false, detail: "cannot resolve the global @mutmutco/hub dist \u2014 run `npm install -g @mutmutco/hub` first" };
   const paths = ensureState(env);
-  const launcherPath = (0, import_node_path12.join)(paths.root, POSIX_LAUNCHER_FILE);
-  (0, import_node_fs14.writeFileSync)(launcherPath, launcherSh(process.execPath, hubDist), "utf8");
-  (0, import_node_fs14.chmodSync)(launcherPath, 493);
-  const unitDir = (0, import_node_path12.join)((0, import_node_os5.homedir)(), ".config", "systemd", "user");
-  (0, import_node_fs14.mkdirSync)(unitDir, { recursive: true });
-  (0, import_node_fs14.writeFileSync)((0, import_node_path12.join)(unitDir, SYSTEMD_SERVICE_NAME), systemdServiceUnit(launcherPath, paths.root), "utf8");
-  (0, import_node_fs14.writeFileSync)((0, import_node_path12.join)(unitDir, SYSTEMD_TIMER_NAME), systemdTimerUnit(), "utf8");
+  const launcherPath = (0, import_node_path13.join)(paths.root, POSIX_LAUNCHER_FILE);
+  (0, import_node_fs15.writeFileSync)(launcherPath, launcherSh(process.execPath, hubDist), "utf8");
+  (0, import_node_fs15.chmodSync)(launcherPath, 493);
+  const unitDir = (0, import_node_path13.join)((0, import_node_os5.homedir)(), ".config", "systemd", "user");
+  (0, import_node_fs15.mkdirSync)(unitDir, { recursive: true });
+  (0, import_node_fs15.writeFileSync)((0, import_node_path13.join)(unitDir, SYSTEMD_SERVICE_NAME), systemdServiceUnit(launcherPath, paths.root), "utf8");
+  (0, import_node_fs15.writeFileSync)((0, import_node_path13.join)(unitDir, SYSTEMD_TIMER_NAME), systemdTimerUnit(), "utf8");
   const reload = systemctlUser(["daemon-reload"]);
   if (reload.status !== 0) {
     return { ok: false, detail: `systemctl --user daemon-reload failed: ${(reload.stderr || reload.stdout).trim() || "unknown error \u2014 is a user systemd instance running?"}` };
@@ -2458,28 +2664,28 @@ function uninstallWindowsTask(env) {
   return { ok: true, detail: `automatic updates off \u2014 removed "${TASK_NAME}"; installed tooling was kept` };
 }
 function uninstallLaunchd(env) {
-  const plistPath = (0, import_node_path12.join)((0, import_node_os5.homedir)(), "Library", "LaunchAgents", LAUNCHD_PLIST_NAME);
+  const plistPath = (0, import_node_path13.join)((0, import_node_os5.homedir)(), "Library", "LaunchAgents", LAUNCHD_PLIST_NAME);
   const boot = launchctl(["bootout", `gui/${uid()}/${LAUNCHD_LABEL}`]);
-  if (boot.status !== 0 && (0, import_node_fs14.existsSync)(plistPath)) {
+  if (boot.status !== 0 && (0, import_node_fs15.existsSync)(plistPath)) {
     return { ok: false, detail: `launchctl bootout failed: ${(boot.stderr || boot.stdout).trim() || "unknown error"}` };
   }
   try {
-    (0, import_node_fs14.rmSync)(plistPath, { force: true });
+    (0, import_node_fs15.rmSync)(plistPath, { force: true });
   } catch {
   }
   dropLauncher(env, POSIX_LAUNCHER_FILE);
   return { ok: true, detail: `automatic updates off \u2014 removed "${LAUNCHD_LABEL}"; installed tooling was kept` };
 }
 function uninstallSystemdTimer(env) {
-  const unitDir = (0, import_node_path12.join)((0, import_node_os5.homedir)(), ".config", "systemd", "user");
-  const timerPath = (0, import_node_path12.join)(unitDir, SYSTEMD_TIMER_NAME);
+  const unitDir = (0, import_node_path13.join)((0, import_node_os5.homedir)(), ".config", "systemd", "user");
+  const timerPath = (0, import_node_path13.join)(unitDir, SYSTEMD_TIMER_NAME);
   const disable = systemctlUser(["disable", "--now", SYSTEMD_TIMER_NAME]);
-  if (disable.status !== 0 && (0, import_node_fs14.existsSync)(timerPath)) {
+  if (disable.status !== 0 && (0, import_node_fs15.existsSync)(timerPath)) {
     return { ok: false, detail: `systemctl --user disable --now ${SYSTEMD_TIMER_NAME} failed: ${(disable.stderr || disable.stdout).trim() || "unknown error"}` };
   }
   try {
-    (0, import_node_fs14.rmSync)(timerPath, { force: true });
-    (0, import_node_fs14.rmSync)((0, import_node_path12.join)(unitDir, SYSTEMD_SERVICE_NAME), { force: true });
+    (0, import_node_fs15.rmSync)(timerPath, { force: true });
+    (0, import_node_fs15.rmSync)((0, import_node_path13.join)(unitDir, SYSTEMD_SERVICE_NAME), { force: true });
   } catch {
   }
   systemctlUser(["daemon-reload"]);
@@ -2494,16 +2700,16 @@ function uninstallTask(env = process.env) {
 }
 function dropLauncher(env, file) {
   try {
-    (0, import_node_fs14.rmSync)((0, import_node_path12.join)(statePaths(env).root, file), { force: true });
+    (0, import_node_fs15.rmSync)((0, import_node_path13.join)(statePaths(env).root, file), { force: true });
   } catch {
   }
 }
 
 // src/status.ts
-var import_node_fs15 = require("node:fs");
+var import_node_fs16 = require("node:fs");
 function readJournal(path) {
   try {
-    const events = (0, import_node_fs15.readFileSync)(path, "utf8").split("\n").filter((line) => line.trim()).map((line) => {
+    const events = (0, import_node_fs16.readFileSync)(path, "utf8").split("\n").filter((line) => line.trim()).map((line) => {
       try {
         return JSON.parse(line);
       } catch {
@@ -2622,6 +2828,7 @@ var YELLOW = "\x1B[33m";
 var RED = "\x1B[31m";
 var RESET = "\x1B[0m";
 var RETRY_HINTS = [
+  [/applies when the host exits|applies on a quiet tick/, "installs when the app closes"],
   [/in flight|changed while/, "rerun update \u2014 host race"],
   [/is running|live process|inside a .* hook/, "close app, rerun update"],
   [/staging install failed|etarget|e404|network|fetch failed/, "check network/login, rerun"],
@@ -2880,7 +3087,7 @@ function startSpinner(enabled) {
 // src/index.ts
 function ownVersion() {
   try {
-    return JSON.parse((0, import_node_fs16.readFileSync)((0, import_node_path13.join)(__dirname, "..", "package.json"), "utf8")).version;
+    return JSON.parse((0, import_node_fs17.readFileSync)((0, import_node_path14.join)(__dirname, "..", "package.json"), "utf8")).version;
   } catch {
     return "0.0.0";
   }
@@ -3006,6 +3213,8 @@ if (typeof require !== "undefined" && require.main === module) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  buildWatcherCommand,
+  clearPending,
   enumerateSurfaces,
   failConsequence,
   formatReconcileReport,
@@ -3016,18 +3225,26 @@ if (typeof require !== "undefined" && require.main === module) {
   launcherSh,
   launcherVbs,
   localStartBoundary,
+  lockShaped,
   main,
+  noteBusyDefer,
   ownVersion,
+  pendingPath,
+  pidAlive,
   probeHermesInstallation,
   progressiveRow,
+  readPending,
   reconcileCursorUserHooks,
   reportFooterLines,
   retryHint,
+  schedulePendingWatcher,
   schedulerStatus,
   startSpinner,
   systemdServiceUnit,
   systemdTimerUnit,
   taskXml,
   updateHeader,
-  wrapWords
+  watcherLockPath,
+  wrapWords,
+  writePending
 });