@mutmutco/hub 4.1.7 → 4.1.8

package/dist/index.cjs

@@ -23,6 +23,7 @@ var index_exports = {};
 __export(index_exports, {
   acquireSharedDocLock: () => acquireSharedDocLock,
   buildWatcherCommand: () => buildWatcherCommand,
+  clearLaunchTarget: () => clearLaunchTarget,
   clearPending: () => clearPending,
   enumerateSurfaces: () => enumerateSurfaces,
   failConsequence: () => failConsequence,
@@ -38,13 +39,19 @@ __export(index_exports, {
   lockShaped: () => lockShaped,
   main: () => main,
   noteBusyDefer: () => noteBusyDefer,
+  noteLaunchStaged: () => noteLaunchStaged,
   npmStringField: () => npmStringField,
   ownVersion: () => ownVersion,
   parseNpmDistIntegrity: () => parseNpmDistIntegrity,
   pendingPath: () => pendingPath,
   pidAlive: () => pidAlive,
+  probeCursorLaunchStaging: () => probeCursorLaunchStaging,
   probeHermesInstallation: () => probeHermesInstallation,
+  probeHermesLaunchStaging: () => probeHermesLaunchStaging,
+  probeKimiLaunchStaging: () => probeKimiLaunchStaging,
+  probeLaunchTargetVersion: () => probeLaunchTargetVersion,
   progressiveRow: () => progressiveRow,
+  readLaunchTarget: () => readLaunchTarget,
   readPending: () => readPending,
   reconcileCursorUserHooks: () => reconcileCursorUserHooks,
   reconcileKimiInstalledPlugin: () => reconcileKimiInstalledPlugin,
@@ -64,11 +71,12 @@ __export(index_exports, {
   watcherLockPath: () => watcherLockPath,
   withSharedDocLock: () => withSharedDocLock,
   wrapWords: () => wrapWords,
+  writeLaunchTarget: () => writeLaunchTarget,
   writePending: () => writePending
 });
 module.exports = __toCommonJS(index_exports);
-var import_node_fs18 = require("node:fs");
-var import_node_path14 = require("node:path");
+var import_node_fs19 = require("node:fs");
+var import_node_path15 = require("node:path");
 
 // src/state.ts
 var import_node_fs = require("node:fs");
@@ -1008,8 +1016,8 @@ function kiloArm(options) {
 
 // src/arm-kimi.ts
 var import_node_child_process7 = require("node:child_process");
-var import_node_fs11 = require("node:fs");
-var import_node_path8 = require("node:path");
+var import_node_fs12 = require("node:fs");
+var import_node_path9 = require("node:path");
 
 // src/compat.ts
 var import_node_fs9 = require("node:fs");
@@ -1022,6 +1030,55 @@ function readManifestCompat(manifestPath) {
   }
 }
 
+// src/launch-staging.ts
+var import_node_fs10 = require("node:fs");
+var import_node_path8 = require("node:path");
+function readLaunchTarget(path) {
+  try {
+    const parsed = JSON.parse((0, import_node_fs10.readFileSync)(path, "utf8"));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+    const row = parsed;
+    if (typeof row.surface !== "string" || typeof row.target !== "string" || typeof row.since !== "string" || typeof row.incoming !== "string") return null;
+    return row;
+  } catch {
+    return null;
+  }
+}
+function writeLaunchTarget(path, record) {
+  (0, import_node_fs10.mkdirSync)((0, import_node_path8.join)(path, ".."), { recursive: true });
+  const tmp = `${path}.tmp-${process.pid}-${Math.random().toString(36).slice(2)}`;
+  (0, import_node_fs10.writeFileSync)(tmp, `${JSON.stringify(record, null, 2)}
+`, "utf8");
+  (0, import_node_fs10.renameSync)(tmp, path);
+}
+function clearLaunchTarget(path) {
+  try {
+    (0, import_node_fs10.rmSync)(path, { force: true });
+  } catch {
+  }
+}
+function noteLaunchStaged(paths, env, options, seam = {}) {
+  writeLaunchTarget(options.launchTargetPath, {
+    surface: options.surface,
+    target: options.target,
+    since: (/* @__PURE__ */ new Date()).toISOString(),
+    incoming: options.incoming
+  });
+  return noteBusyDefer(paths, env, {
+    surface: options.surface,
+    target: options.target,
+    reason: options.reason,
+    images: options.images,
+    dirs: options.dirs
+  }, seam);
+}
+function probeLaunchTargetVersion(launchTargetPath, versionAt) {
+  const record = readLaunchTarget(launchTargetPath);
+  if (!record || !(0, import_node_fs10.existsSync)(record.incoming)) return null;
+  const version = versionAt(record.incoming);
+  return version === record.target ? record.target : null;
+}
+
 // src/kimi-registration.ts
 function validateKimiInstalledPlugin(document, pluginRoot, id) {
   if (!document || typeof document !== "object" || Array.isArray(document)) return "malformed-document";
@@ -1038,7 +1095,7 @@ function validateKimiInstalledPlugin(document, pluginRoot, id) {
 }
 
 // src/host-doc-lock.ts
-var import_node_fs10 = require("node:fs");
+var import_node_fs11 = require("node:fs");
 var import_node_os4 = require("node:os");
 var SHARED_DOC_LOCK_STALE_MS = 3e4;
 var SHARED_DOC_LOCK_ATTEMPTS = 50;
@@ -1052,7 +1109,7 @@ function lockContent(options) {
 }
 function readHolder(lockPath) {
   try {
-    const parsed = JSON.parse((0, import_node_fs10.readFileSync)(lockPath, "utf8"));
+    const parsed = JSON.parse((0, import_node_fs11.readFileSync)(lockPath, "utf8"));
     if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return null;
     return parsed;
   } catch {
@@ -1064,7 +1121,7 @@ function lockAgeMs(lockPath, now) {
   const declared = typeof holder?.acquiredAt === "string" ? Date.parse(holder.acquiredAt) : Number.NaN;
   if (!Number.isNaN(declared)) return Math.max(0, now - declared);
   try {
-    return Math.max(0, now - (0, import_node_fs10.statSync)(lockPath).mtimeMs);
+    return Math.max(0, now - (0, import_node_fs11.statSync)(lockPath).mtimeMs);
   } catch {
     return 0;
   }
@@ -1087,9 +1144,9 @@ function acquireSharedDocLock(documentPath, options) {
   for (let attempt = 0; attempt < attempts; attempt += 1) {
     let fd;
     try {
-      fd = (0, import_node_fs10.openSync)(lockPath, "wx");
-      (0, import_node_fs10.writeSync)(fd, content);
-      (0, import_node_fs10.closeSync)(fd);
+      fd = (0, import_node_fs11.openSync)(lockPath, "wx");
+      (0, import_node_fs11.writeSync)(fd, content);
+      (0, import_node_fs11.closeSync)(fd);
       return {
         documentPath,
         lockPath,
@@ -1102,11 +1159,11 @@ function acquireSharedDocLock(documentPath, options) {
     } catch (error) {
       if (fd !== void 0) {
         try {
-          (0, import_node_fs10.closeSync)(fd);
+          (0, import_node_fs11.closeSync)(fd);
         } catch {
         }
         try {
-          (0, import_node_fs10.unlinkSync)(lockPath);
+          (0, import_node_fs11.unlinkSync)(lockPath);
         } catch {
         }
       }
@@ -1115,12 +1172,12 @@ function acquireSharedDocLock(documentPath, options) {
     if (lockAgeMs(lockPath, Date.now()) >= staleAfterMs) {
       const aside = `${lockPath}.stale-${Date.now()}`;
       try {
-        (0, import_node_fs10.renameSync)(lockPath, aside);
+        (0, import_node_fs11.renameSync)(lockPath, aside);
       } catch {
         continue;
       }
       try {
-        (0, import_node_fs10.rmSync)(aside, { force: true });
+        (0, import_node_fs11.rmSync)(aside, { force: true });
       } catch {
       }
       continue;
@@ -1133,7 +1190,7 @@ function releaseSharedDocLock(handle) {
   try {
     const holder = readHolder(handle.lockPath);
     if (holder && holder.owner === handle.owner && Number(holder.pid) === handle.pid) {
-      (0, import_node_fs10.unlinkSync)(handle.lockPath);
+      (0, import_node_fs11.unlinkSync)(handle.lockPath);
     }
   } catch {
   }
@@ -1151,11 +1208,11 @@ function withSharedDocLock(documentPath, options, fn) {
 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_path8.join)(root, ...rel.split("/"))));
+  return TREE_MARKERS.every((rel) => fileExists((0, import_node_path9.join)(root, ...rel.split("/"))));
 }
 function markerVersion(root) {
   try {
-    const version = JSON.parse((0, import_node_fs11.readFileSync)((0, import_node_path8.join)(root, ".kimi-plugin", "plugin.json"), "utf8")).version;
+    const version = JSON.parse((0, import_node_fs12.readFileSync)((0, import_node_path9.join)(root, ".kimi-plugin", "plugin.json"), "utf8")).version;
     return typeof version === "string" ? version : null;
   } catch {
     return null;
@@ -1163,7 +1220,7 @@ function markerVersion(root) {
 }
 function packageVersion(root) {
   try {
-    const version = JSON.parse((0, import_node_fs11.readFileSync)((0, import_node_path8.join)(root, "package.json"), "utf8")).version;
+    const version = JSON.parse((0, import_node_fs12.readFileSync)((0, import_node_path9.join)(root, "package.json"), "utf8")).version;
     return typeof version === "string" ? version : null;
   } catch {
     return null;
@@ -1171,18 +1228,18 @@ function packageVersion(root) {
 }
 var KIMI_REGISTRATION_LOCK_OWNER = "mmi-hub:kimi-registration";
 function reconcileKimiInstalledPlugin(kimiHomeDir, pluginRoot, id, lock = {}) {
-  const path = (0, import_node_path8.join)(kimiHomeDir, "plugins", "installed.json");
-  (0, import_node_fs11.mkdirSync)((0, import_node_path8.join)(kimiHomeDir, "plugins"), { recursive: true });
+  const path = (0, import_node_path9.join)(kimiHomeDir, "plugins", "installed.json");
+  (0, import_node_fs12.mkdirSync)((0, import_node_path9.join)(kimiHomeDir, "plugins"), { recursive: true });
   return withSharedDocLock(path, { owner: KIMI_REGISTRATION_LOCK_OWNER, ...lock }, () => mergeKimiInstalledPlugin(path, pluginRoot, id));
 }
 function mergeKimiInstalledPlugin(path, pluginRoot, id) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const fresh = { id, root: pluginRoot, enabled: true, installedAt: now, updatedAt: now, originalSource: pluginRoot, source: "local-path" };
   let document = { version: 1, plugins: [] };
-  if ((0, import_node_fs11.existsSync)(path)) {
+  if ((0, import_node_fs12.existsSync)(path)) {
     let parsed;
     try {
-      parsed = JSON.parse((0, import_node_fs11.readFileSync)(path, "utf8"));
+      parsed = JSON.parse((0, import_node_fs12.readFileSync)(path, "utf8"));
     } catch {
       return "conflict";
     }
@@ -1210,13 +1267,13 @@ function mergeKimiInstalledPlugin(path, pluginRoot, id) {
     plugins[index] = { ...next, updatedAt: now };
   }
   const tmp = `${path}.tmp-${process.pid}`;
-  (0, import_node_fs11.writeFileSync)(tmp, `${JSON.stringify({ ...document, version: 1, plugins }, null, 2)}
+  (0, import_node_fs12.writeFileSync)(tmp, `${JSON.stringify({ ...document, version: 1, plugins }, null, 2)}
 `, "utf8");
-  (0, import_node_fs11.renameSync)(tmp, path);
+  (0, import_node_fs12.renameSync)(tmp, path);
   return "updated";
 }
 function probeKimiInstallation(env = process.env) {
-  const location = (0, import_node_path8.join)(kimiHome(env), "plugins", "managed", "mmi");
+  const location = (0, import_node_path9.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" };
 }
@@ -1224,14 +1281,14 @@ function tail2(output) {
   return output.split("\n").filter(Boolean).slice(-3).join(" | ");
 }
 function scratchRoot(env) {
-  return (0, import_node_path8.join)(kimiHome(env), ".mmi-updater");
+  return (0, import_node_path9.join)(kimiHome(env), ".mmi-updater");
 }
 function pruneScratchDir(root, keep) {
   try {
-    for (const name of (0, import_node_fs11.readdirSync)(root)) {
+    for (const name of (0, import_node_fs12.readdirSync)(root)) {
       if (name === keep) continue;
       try {
-        (0, import_node_fs11.rmSync)((0, import_node_path8.join)(root, name), { recursive: true, force: true });
+        (0, import_node_fs12.rmSync)((0, import_node_path9.join)(root, name), { recursive: true, force: true });
       } catch {
       }
     }
@@ -1257,31 +1314,32 @@ function kimiHostRunning(env) {
 }
 function restoreQuarantine(quarantine, live) {
   try {
-    (0, import_node_fs11.renameSync)(quarantine, live);
+    (0, import_node_fs12.renameSync)(quarantine, live);
   } catch (error) {
     return { restored: false, detail: `${error?.message ?? error}` };
   }
-  if (!(0, import_node_fs11.existsSync)(live)) return { restored: false, detail: `${live} is still absent after the restore rename` };
+  if (!(0, import_node_fs12.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) {
   const env = options.env ?? process.env;
   const { target, dryRun, paths } = options;
-  const result = (from, to, verdict, detail) => ({
+  const result = (from, to, verdict, detail, launchStaged = false) => ({
     surface: "kimi",
     from,
     to,
     verdict,
     detail,
+    launchStaged: launchStaged || void 0,
     // 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_path8.join)(live, ".kimi-plugin", "plugin.json"))
+    compat: readManifestCompat((0, import_node_path9.join)(live, ".kimi-plugin", "plugin.json"))
   });
-  const managedParent = (0, import_node_path8.join)(kimiHome(env), "plugins", "managed");
-  const live = (0, import_node_path8.join)(managedParent, "mmi");
+  const managedParent = (0, import_node_path9.join)(kimiHome(env), "plugins", "managed");
+  const live = (0, import_node_path9.join)(managedParent, "mmi");
   const installed = markerVersion(live);
   const ensureRegistered = (detail) => {
-    if (!(0, import_node_fs11.existsSync)(live) || !treeHealthy(live)) return { detail };
+    if (!(0, import_node_fs12.existsSync)(live) || !treeHealthy(live)) return { detail };
     if (dryRun) return { detail: `${detail}; installed.json untouched (dry-run)` };
     let registration;
     try {
@@ -1310,11 +1368,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_path8.join)(paths.staging, "kimi", target);
-  const staged = (0, import_node_path8.join)(stageRoot, "node_modules", ...KIMI_PACKAGE.split("/"));
+  const stageRoot = (0, import_node_path9.join)(paths.staging, "kimi", target);
+  const staged = (0, import_node_path9.join)(stageRoot, "node_modules", ...KIMI_PACKAGE.split("/"));
   if (!treeHealthy(staged)) {
-    (0, import_node_fs11.mkdirSync)(stageRoot, { recursive: true });
-    (0, import_node_fs11.writeFileSync)((0, import_node_path8.join)(stageRoot, "package.json"), JSON.stringify({ name: "mmi-updater-stage", private: true }) + "\n");
+    (0, import_node_fs12.mkdirSync)(stageRoot, { recursive: true });
+    (0, import_node_fs12.writeFileSync)((0, import_node_path9.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)}`);
@@ -1331,33 +1389,57 @@ function kimiArm(options) {
   if (!treeHealthy(staged)) {
     return result(installed, target, "defer", `staged tree is missing one of ${TREE_MARKERS.join(", ")}`);
   }
-  const quiescence = kimiHostRunning(env);
-  if (quiescence.running) {
-    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_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_fs11.mkdirSync)(managedParent, { recursive: true });
-    (0, import_node_fs11.mkdirSync)(quarantineRoot, { recursive: true });
-    (0, import_node_fs11.rmSync)(incomingRoot, { recursive: true, force: true });
-    (0, import_node_fs11.cpSync)(staged, incoming, { recursive: true });
-  } catch (error) {
-    return result(installed, target, "defer", `cannot place the incoming generation under ${scratch}: ${error?.message ?? error}`);
+  const launchTargetPath = (0, import_node_path9.join)(scratch, "launch-target.json");
+  const incomingRoot = (0, import_node_path9.join)(scratch, "incoming");
+  const incoming = (0, import_node_path9.join)(incomingRoot, target);
+  const quarantineRoot = (0, import_node_path9.join)(scratch, "quarantine");
+  const rejectedRoot = (0, import_node_path9.join)(scratch, "rejected");
+  const priorLaunch = readLaunchTarget(launchTargetPath);
+  const reuseIncoming = priorLaunch?.target === target && priorLaunch.incoming === incoming && markerVersion(incoming) === target && treeHealthy(incoming);
+  if (!reuseIncoming) {
+    try {
+      (0, import_node_fs12.mkdirSync)(managedParent, { recursive: true });
+      (0, import_node_fs12.mkdirSync)(quarantineRoot, { recursive: true });
+      (0, import_node_fs12.rmSync)(incomingRoot, { recursive: true, force: true });
+      (0, import_node_fs12.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}`);
+    }
   }
-  if (markerVersion(incoming) !== target || !treeHealthy(incoming)) {
-    return result(installed, target, "defer", `incoming generation verifies as ${markerVersion(incoming) ?? "unreadable"}, expected ${target}`);
+  const quiescence = kimiHostRunning(env);
+  if (quiescence.running) {
+    const pending = noteLaunchStaged(paths, env, {
+      surface: "kimi",
+      target,
+      reason: quiescence.evidence,
+      launchTargetPath,
+      incoming,
+      dirs: ["kimi"]
+    });
+    return result(installed, target, "ok", `staged ${target} for next launch while Kimi is running (${quiescence.evidence}) \u2014 ${pending}`, true);
+  }
+  const started = kimiHostRunning(env);
+  if (started.running) {
+    const pending = noteLaunchStaged(paths, env, {
+      surface: "kimi",
+      target,
+      reason: started.evidence,
+      launchTargetPath,
+      incoming,
+      dirs: ["kimi"]
+    });
+    return result(installed, target, "ok", `staged ${target} for next launch \u2014 Kimi started during staging (${started.evidence}) \u2014 ${pending}`, true);
   }
-  const hadLive = (0, import_node_fs11.existsSync)(live);
+  const hadLive = (0, import_node_fs12.existsSync)(live);
   const generation = `${installed ?? "unknown"}-${Date.now()}`;
-  const quarantine = (0, import_node_path8.join)(quarantineRoot, generation);
+  const quarantine = (0, import_node_path9.join)(quarantineRoot, generation);
   if (hadLive) {
     try {
-      (0, import_node_fs11.renameSync)(live, quarantine);
+      (0, import_node_fs12.renameSync)(live, quarantine);
     } catch (error) {
       const reason = String(error?.message ?? error);
       const pending = lockShaped(reason) ? ` \u2014 ${noteBusyDefer(options.paths, env, { surface: "kimi", target, reason, dirs: ["kimi"] })}` : "";
@@ -1365,7 +1447,7 @@ function kimiArm(options) {
     }
   }
   try {
-    (0, import_node_fs11.renameSync)(incoming, live);
+    (0, import_node_fs12.renameSync)(incoming, live);
   } catch (error) {
     const failed = `cannot switch the new generation in: ${error?.message ?? error}`;
     if (!hadLive) {
@@ -1380,33 +1462,37 @@ function kimiArm(options) {
     const observed = `post-switch marker is ${switched ?? "unreadable"}, expected ${target}`;
     const rejectedName = `${target}-${Date.now()}`;
     try {
-      (0, import_node_fs11.mkdirSync)(rejectedRoot, { recursive: true });
-      (0, import_node_fs11.renameSync)(live, (0, import_node_path8.join)(rejectedRoot, rejectedName));
+      (0, import_node_fs12.mkdirSync)(rejectedRoot, { recursive: true });
+      (0, import_node_fs12.renameSync)(live, (0, import_node_path9.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_path8.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_path9.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_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}`);
+    return restore.restored ? result(installed, installed ?? "unknown", "fail", `${observed} \u2014 the unverified tree is parked at ${(0, import_node_path9.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_fs11.rmSync)(incomingRoot, { recursive: true, force: true });
+    (0, import_node_fs12.rmSync)(incomingRoot, { recursive: true, force: true });
   } catch {
   }
+  clearLaunchTarget(launchTargetPath);
   const reg = ensureRegistered(`converged ${installed ?? "absent"} -> ${target} (staged, verified, switched${hadLive ? `; previous generation quarantined at ${quarantine}` : ""})`);
   return result(installed, target, reg.fail ? "fail" : "ok", reg.detail);
 }
+function probeKimiLaunchStaging(env = process.env) {
+  return probeLaunchTargetVersion((0, import_node_path9.join)(scratchRoot(env), "launch-target.json"), markerVersion);
+}
 
 // src/arm-cursor.ts
-var import_node_fs12 = require("node:fs");
+var import_node_fs13 = require("node:fs");
 var import_node_child_process8 = require("node:child_process");
 var import_node_os5 = require("node:os");
-var import_node_path9 = require("node:path");
+var import_node_path10 = require("node:path");
 var PACKAGE = "@mutmutco/cursor-plugin";
 var MANIFEST = ".cursor-plugin/plugin.json";
 var USER_HOOKS_FILE = "hooks.json";
@@ -1415,14 +1501,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_path9.join)((0, import_node_os5.homedir)(), ".cursor", "plugins");
+  return (0, import_node_path10.join)((0, import_node_os5.homedir)(), ".cursor", "plugins");
 }
 function treeHealthy2(root) {
-  return TREE_FILES.every((rel) => (0, import_node_fs12.existsSync)((0, import_node_path9.join)(root, ...rel.split("/"))));
+  return TREE_FILES.every((rel) => (0, import_node_fs13.existsSync)((0, import_node_path10.join)(root, ...rel.split("/"))));
 }
 function readJson(root, rel) {
   try {
-    return JSON.parse((0, import_node_fs12.readFileSync)((0, import_node_path9.join)(root, ...rel.split("/")), "utf8"));
+    return JSON.parse((0, import_node_fs13.readFileSync)((0, import_node_path10.join)(root, ...rel.split("/")), "utf8"));
   } catch {
     return null;
   }
@@ -1431,7 +1517,7 @@ function manifest(root) {
   return readJson(root, MANIFEST);
 }
 function probeCursorInstallation() {
-  const location = (0, import_node_path9.join)(cursorPluginsRoot(), "local", "mmi");
+  const location = (0, import_node_path10.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" };
 }
@@ -1446,7 +1532,7 @@ function message(error) {
 }
 function discard(path) {
   try {
-    (0, import_node_fs12.rmSync)(path, { recursive: true, force: true });
+    (0, import_node_fs13.rmSync)(path, { recursive: true, force: true });
   } catch {
   }
 }
@@ -1474,7 +1560,7 @@ function cursorHostEvidence(env) {
   return null;
 }
 function resolvedPluginRoot(root) {
-  return (0, import_node_path9.join)(root).replace(/\\/g, "/");
+  return (0, import_node_path10.join)(root).replace(/\\/g, "/");
 }
 function isMmiEntry(entry, pluginRoot) {
   return typeof entry === "object" && entry !== null && typeof entry.command === "string" && entry.command.includes(resolvedPluginRoot(pluginRoot));
@@ -1484,7 +1570,7 @@ function resolveCommand(command, pluginRoot) {
 }
 function desiredUserHooks(pluginRoot) {
   try {
-    const doc = JSON.parse((0, import_node_fs12.readFileSync)((0, import_node_path9.join)(pluginRoot, ...PLUGIN_HOOKS_REL), "utf8"));
+    const doc = JSON.parse((0, import_node_fs13.readFileSync)((0, import_node_path10.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();
@@ -1521,17 +1607,17 @@ var CURSOR_HOOKS_LOCK_OWNER = "mmi-hub:cursor-hooks";
 function reconcileCursorUserHooks(pluginRoot, homeDir, lock = {}) {
   const desired = desiredUserHooks(pluginRoot);
   if (!desired) return "source-unreadable";
-  const path = (0, import_node_path9.join)(homeDir, ".cursor", USER_HOOKS_FILE);
+  const path = (0, import_node_path10.join)(homeDir, ".cursor", USER_HOOKS_FILE);
   return withSharedDocLock(path, { owner: CURSOR_HOOKS_LOCK_OWNER, ...lock }, () => {
-    if (!(0, import_node_fs12.existsSync)(path)) {
+    if (!(0, import_node_fs13.existsSync)(path)) {
       const fresh = `${path}.tmp-${process.pid}`;
-      (0, import_node_fs12.writeFileSync)(fresh, JSON.stringify({ version: 1, hooks: Object.fromEntries(desired) }, null, 2) + "\n", "utf8");
-      (0, import_node_fs12.renameSync)(fresh, path);
+      (0, import_node_fs13.writeFileSync)(fresh, JSON.stringify({ version: 1, hooks: Object.fromEntries(desired) }, null, 2) + "\n", "utf8");
+      (0, import_node_fs13.renameSync)(fresh, path);
       return "updated";
     }
     let existing;
     try {
-      existing = JSON.parse((0, import_node_fs12.readFileSync)(path, "utf8"));
+      existing = JSON.parse((0, import_node_fs13.readFileSync)(path, "utf8"));
     } catch {
       return "user-conflict";
     }
@@ -1539,8 +1625,8 @@ function reconcileCursorUserHooks(pluginRoot, homeDir, lock = {}) {
     if (!merged) return "user-conflict";
     if (JSON.stringify(merged) === JSON.stringify(existing)) return "current";
     const tmp = `${path}.tmp-${process.pid}`;
-    (0, import_node_fs12.writeFileSync)(tmp, JSON.stringify(merged, null, 2) + "\n", "utf8");
-    (0, import_node_fs12.renameSync)(tmp, path);
+    (0, import_node_fs13.writeFileSync)(tmp, JSON.stringify(merged, null, 2) + "\n", "utf8");
+    (0, import_node_fs13.renameSync)(tmp, path);
     return "updated";
   });
 }
@@ -1555,7 +1641,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_path9.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_path10.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:
@@ -1563,35 +1649,35 @@ function userHooksDetail(pluginRoot, homeDir) {
   }
 }
 function writeRollbackPointer(root, entry) {
-  const path = (0, import_node_path9.join)(root, "quarantine", "rollback.json");
+  const path = (0, import_node_path10.join)(root, "quarantine", "rollback.json");
   const tmp = `${path}.tmp-${process.pid}`;
   try {
-    (0, import_node_fs12.writeFileSync)(tmp, JSON.stringify({ surface: "cursor", ts: (/* @__PURE__ */ new Date()).toISOString(), ...entry }, null, 2) + "\n", "utf8");
-    (0, import_node_fs12.renameSync)(tmp, path);
+    (0, import_node_fs13.writeFileSync)(tmp, JSON.stringify({ surface: "cursor", ts: (/* @__PURE__ */ new Date()).toISOString(), ...entry }, null, 2) + "\n", "utf8");
+    (0, import_node_fs13.renameSync)(tmp, path);
   } catch {
     discard(tmp);
   }
 }
 function mtimeMs(path) {
   try {
-    return (0, import_node_fs12.statSync)(path).mtimeMs;
+    return (0, import_node_fs13.statSync)(path).mtimeMs;
   } catch {
     return 0;
   }
 }
 function pruneQuarantine(root, keep) {
-  const dir = (0, import_node_path9.join)(root, "quarantine");
+  const dir = (0, import_node_path10.join)(root, "quarantine");
   let generations;
   try {
-    generations = (0, import_node_fs12.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));
+    generations = (0, import_node_fs13.readdirSync)(dir, { withFileTypes: true }).filter((entry) => entry.isDirectory() && entry.name.startsWith("mmi-")).map((entry) => (0, import_node_path10.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_fs12.readdirSync)(dir, { withFileTypes: true })) {
+    for (const entry of (0, import_node_fs13.readdirSync)(dir, { withFileTypes: true })) {
       if (!entry.isFile() || !/^rollback\.json\.tmp-\d+$/.test(entry.name)) continue;
-      const path = (0, import_node_path9.join)(dir, entry.name);
+      const path = (0, import_node_path10.join)(dir, entry.name);
       if (Date.now() - mtimeMs(path) < STRANDED_TMP_AGE_MS) continue;
       discard(path);
       stranded += 1;
@@ -1609,16 +1695,16 @@ function pruneQuarantine(root, keep) {
 }
 function restorePrevious(live, quarantined, broken) {
   try {
-    (0, import_node_fs12.renameSync)(live, broken);
+    (0, import_node_fs13.renameSync)(live, broken);
   } catch {
     return "kept-broken";
   }
   try {
-    (0, import_node_fs12.renameSync)(quarantined, live);
+    (0, import_node_fs13.renameSync)(quarantined, live);
     return "restored";
   } catch {
     try {
-      (0, import_node_fs12.renameSync)(broken, live);
+      (0, import_node_fs13.renameSync)(broken, live);
       return "kept-broken";
     } catch {
       return "lost";
@@ -1629,16 +1715,17 @@ function cursorArm(options) {
   const env = options.env ?? process.env;
   const { target, dryRun, paths } = options;
   const root = cursorPluginsRoot();
-  const live = (0, import_node_path9.join)(root, "local", "mmi");
-  const result = (from, to, verdict, detail) => ({
+  const live = (0, import_node_path10.join)(root, "local", "mmi");
+  const result = (from, to, verdict, detail, launchStaged = false) => ({
     surface: "cursor",
     from,
     to,
     verdict,
     detail,
+    launchStaged: launchStaged || void 0,
     // 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_path9.join)(live, MANIFEST))
+    compat: readManifestCompat((0, import_node_path10.join)(live, MANIFEST))
   });
   const current = manifest(live);
   const installed = current?.version ?? null;
@@ -1652,7 +1739,7 @@ function cursorArm(options) {
   if (installed === target && treeHealthy2(live)) {
     return result(installed, target, "ok", `already at target ${target}${userHooksDetail(live, (0, import_node_os5.homedir)())}`);
   }
-  if ((0, import_node_fs12.existsSync)(live) && !mmiOwned(live)) {
+  if ((0, import_node_fs13.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) {
@@ -1666,43 +1753,63 @@ function cursorArm(options) {
   if (stagedMarker !== target || !treeHealthy2(staged.packageRoot)) {
     return result(installed, target, "defer", `staged tree marker is ${stagedMarker ?? "unreadable"} and the tree is ${treeHealthy2(staged.packageRoot) ? "complete" : "incomplete"}, expected ${target} and complete`);
   }
+  const launchTargetPath = (0, import_node_path10.join)(root, "staging", "launch-target.json");
+  const priorLaunch = readLaunchTarget(launchTargetPath);
+  let incoming = priorLaunch?.target === target && priorLaunch.incoming.startsWith((0, import_node_path10.join)(root, "staging")) && manifest(priorLaunch.incoming)?.version === target && treeHealthy2(priorLaunch.incoming) ? priorLaunch.incoming : (0, import_node_path10.join)(root, "staging", `mmi-${safeSegment(target)}-${Date.now()}`);
+  const reuseIncoming = incoming === priorLaunch?.incoming;
+  if (!reuseIncoming || !(0, import_node_fs13.existsSync)(incoming)) {
+    incoming = (0, import_node_path10.join)(root, "staging", `mmi-${safeSegment(target)}-${Date.now()}`);
+    for (const dir of ["local", "staging", "quarantine"]) (0, import_node_fs13.mkdirSync)((0, import_node_path10.join)(root, dir), { recursive: true });
+    try {
+      discard(incoming);
+      (0, import_node_fs13.cpSync)(staged.packageRoot, incoming, { recursive: true });
+    } catch (error) {
+      discard(incoming);
+      return result(installed, target, "defer", `copy into ${root} failed: ${message(error)}`);
+    }
+    if (manifest(incoming)?.version !== target || !treeHealthy2(incoming)) {
+      discard(incoming);
+      return result(installed, target, "defer", "the copy on the Cursor volume did not reproduce the verified tree");
+    }
+  }
   const busy = cursorHostEvidence(env);
   if (busy) {
-    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 pending = noteLaunchStaged(paths, env, {
+      surface: "cursor",
+      target,
+      reason: busy,
+      launchTargetPath,
+      incoming,
+      images: ["Cursor"]
+    });
+    return result(installed, target, "ok", `staged ${target} for next launch while Cursor is running (${busy}) \u2014 ${pending}`, true);
   }
   const stamp = Date.now();
-  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_fs12.mkdirSync)((0, import_node_path9.join)(root, dir), { recursive: true });
-  try {
-    discard(incoming);
-    (0, import_node_fs12.cpSync)(staged.packageRoot, incoming, { recursive: true });
-  } catch (error) {
-    discard(incoming);
-    return result(installed, target, "defer", `copy into ${root} failed: ${message(error)}`);
-  }
-  if (manifest(incoming)?.version !== target || !treeHealthy2(incoming)) {
-    discard(incoming);
-    return result(installed, target, "defer", "the copy on the Cursor volume did not reproduce the verified tree");
-  }
+  const quarantined = (0, import_node_path10.join)(root, "quarantine", `mmi-${safeSegment(installed ?? "unknown")}-${stamp}`);
+  for (const dir of ["local", "staging", "quarantine"]) (0, import_node_fs13.mkdirSync)((0, import_node_path10.join)(root, dir), { recursive: true });
   const started = cursorHostEvidence(env);
   if (started) {
-    discard(incoming);
-    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}`);
+    const pending = noteLaunchStaged(paths, env, {
+      surface: "cursor",
+      target,
+      reason: started,
+      launchTargetPath,
+      incoming,
+      images: ["Cursor"]
+    });
+    return result(installed, target, "ok", `staged ${target} for next launch \u2014 Cursor started during staging (${started}) \u2014 ${pending}`, true);
   }
   let displaced = false;
   try {
-    if ((0, import_node_fs12.existsSync)(live)) {
-      (0, import_node_fs12.renameSync)(live, quarantined);
+    if ((0, import_node_fs13.existsSync)(live)) {
+      (0, import_node_fs13.renameSync)(live, quarantined);
       displaced = true;
     }
-    (0, import_node_fs12.renameSync)(incoming, live);
+    (0, import_node_fs13.renameSync)(incoming, live);
   } catch (error) {
-    if (displaced && !(0, import_node_fs12.existsSync)(live)) {
+    if (displaced && !(0, import_node_fs13.existsSync)(live)) {
       try {
-        (0, import_node_fs12.renameSync)(quarantined, live);
+        (0, import_node_fs13.renameSync)(quarantined, live);
       } catch {
       }
     }
@@ -1713,21 +1820,25 @@ function cursorArm(options) {
   }
   const evidence = manifest(live)?.version;
   if (evidence !== target || !treeHealthy2(live)) {
-    const broken = `${(0, import_node_path9.join)(root, "quarantine", `mmi-${safeSegment(evidence ?? "broken")}-${stamp}`)}-failed`;
+    const broken = `${(0, import_node_path10.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 });
     return result(installed, outcome === "restored" ? installed ?? "unknown" : evidence ?? "unknown", "fail", `post-switch marker reads ${evidence ?? "missing"}, expected ${target}; ${detail}`);
   }
   writeRollbackPointer(root, { installed: target, previous: installed, generation: displaced ? quarantined : null });
+  clearLaunchTarget(launchTargetPath);
   const pruned = pruneQuarantine(root, displaced ? quarantined : null);
   const previous = displaced ? `previous generation quarantined at ${quarantined}` : "no previous generation to quarantine";
   return result(installed, target, "ok", `switched ${installed ?? "absent"} -> ${target}; ${previous}${pruned ? `; pruned ${pruned} older generation${pruned === 1 ? "" : "s"}` : ""}${userHooksDetail(live, (0, import_node_os5.homedir)())}`);
 }
+function probeCursorLaunchStaging() {
+  return probeLaunchTargetVersion((0, import_node_path10.join)(cursorPluginsRoot(), "staging", "launch-target.json"), (root) => manifest(root)?.version ?? null);
+}
 
 // src/arm-jervcode.ts
-var import_node_fs13 = require("node:fs");
-var import_node_path10 = require("node:path");
+var import_node_fs14 = require("node:fs");
+var import_node_path11 = require("node:path");
 var PI_PACKAGE = "@mutmutco/pi-plugin";
 function hostEnv(env) {
   const dir = jervcodeAgentDir(env);
@@ -1738,7 +1849,7 @@ function hostCommands(_env) {
 }
 function readPackageSpecs(env) {
   try {
-    const settings = JSON.parse((0, import_node_fs13.readFileSync)((0, import_node_path10.join)(jervcodeAgentDir(env), "settings.json"), "utf8"));
+    const settings = JSON.parse((0, import_node_fs14.readFileSync)((0, import_node_path11.join)(jervcodeAgentDir(env), "settings.json"), "utf8"));
     return Array.isArray(settings.packages) ? settings.packages.filter((entry) => typeof entry === "string") : [];
   } catch {
     return null;
@@ -1746,14 +1857,14 @@ function readPackageSpecs(env) {
 }
 function installedVersion(env) {
   try {
-    const manifest2 = JSON.parse((0, import_node_fs13.readFileSync)((0, import_node_path10.join)(jervcodeAgentDir(env), "npm", "node_modules", ...PI_PACKAGE.split("/"), "package.json"), "utf8"));
+    const manifest2 = JSON.parse((0, import_node_fs14.readFileSync)((0, import_node_path11.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_path10.join)(jervcodeAgentDir(env), "npm", "node_modules", ...PI_PACKAGE.split("/"));
+  const location = (0, import_node_path11.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" };
 }
@@ -1775,32 +1886,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_path10.join)(jervcodeAgentDir(env), "npm", "node_modules", ...PI_PACKAGE.split("/"), "package.json"))
+    compat: readManifestCompat((0, import_node_path11.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_path10.join)(jervcodeAgentDir(env), "settings.json")}`);
+  if (!before) return result(null, options.target, "defer", `cannot read ${(0, import_node_path11.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_path10.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_path11.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_path10.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_path11.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_path10.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_path11.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_path10.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_path11.join)(jervcodeAgentDir(env), "npm", "node_modules", ...PI_PACKAGE.split("/"), "package.json")) };
     }
   }
   const after = readPackageSpecs(env);
@@ -1808,7 +1919,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_path10.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_path11.join)(jervcodeAgentDir(env), "npm", "node_modules", ...PI_PACKAGE.split("/"), "package.json")) };
   }
   if (!after?.includes(exact) || converged !== options.target || legacyAfter.length) {
     return {
@@ -1829,15 +1940,15 @@ function jervcodeArm(options) {
 }
 
 // src/arm-hermes.ts
-var import_node_fs14 = require("node:fs");
+var import_node_fs15 = require("node:fs");
 var import_node_child_process9 = require("node:child_process");
-var import_node_path11 = require("node:path");
+var import_node_path12 = 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_fs14.readFileSync)((0, import_node_path11.join)(root, MANIFEST2), "utf8");
+    const text = (0, import_node_fs15.readFileSync)((0, import_node_path12.join)(root, MANIFEST2), "utf8");
     try {
       const version = JSON.parse(text).version;
       if (typeof version === "string" && version.trim()) return version.trim();
@@ -1850,9 +1961,9 @@ function yamlVersion(root) {
   }
 }
 function treeHealthy3(root) {
-  return TREE_MARKERS2.slice(0, 2).every((file) => (0, import_node_fs14.existsSync)((0, import_node_path11.join)(root, file))) && (() => {
+  return TREE_MARKERS2.slice(0, 2).every((file) => (0, import_node_fs15.existsSync)((0, import_node_path12.join)(root, file))) && (() => {
     try {
-      return (0, import_node_fs14.statSync)((0, import_node_path11.join)(root, "skills")).isDirectory();
+      return (0, import_node_fs15.statSync)((0, import_node_path12.join)(root, "skills")).isDirectory();
     } catch {
       return false;
     }
@@ -1860,13 +1971,13 @@ function treeHealthy3(root) {
 }
 function packageIdentity(root) {
   try {
-    return JSON.parse((0, import_node_fs14.readFileSync)((0, import_node_path11.join)(root, "package.json"), "utf8")).name === PACKAGE2;
+    return JSON.parse((0, import_node_fs15.readFileSync)((0, import_node_path12.join)(root, "package.json"), "utf8")).name === PACKAGE2;
   } catch {
     return false;
   }
 }
 function probeHermesInstallation(env = process.env) {
-  const location = (0, import_node_path11.join)(hermesHome(env), "plugins", "mmi");
+  const location = (0, import_node_path12.join)(hermesHome(env), "plugins", "mmi");
   const version = yamlVersion(location);
   return { version, location, detail: version ? "installed Hermes plugin manifest" : "installed Hermes plugin manifest was unreadable" };
 }
@@ -1875,7 +1986,7 @@ function mmiOwned2(root) {
 }
 function discard2(path) {
   try {
-    (0, import_node_fs14.rmSync)(path, { recursive: true, force: true });
+    (0, import_node_fs15.rmSync)(path, { recursive: true, force: true });
   } catch {
   }
 }
@@ -1907,19 +2018,19 @@ function hermesHostEvidence(env, home, processListProvider) {
   return null;
 }
 function materializeHermesSkills(home) {
-  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");
+  const pluginSkills = (0, import_node_path12.join)(home, "plugins", "mmi", "skills");
+  const skillsRoot = (0, import_node_path12.join)(home, "skills");
+  const targetRoot = (0, import_node_path12.join)(skillsRoot, "mmi");
   try {
-    if (!(0, import_node_fs14.existsSync)(pluginSkills)) return { ok: false, detail: `plugin skills tree missing at ${pluginSkills}` };
-    const names = (0, import_node_fs14.readdirSync)(pluginSkills, { withFileTypes: true }).filter((entry) => entry.isDirectory() && !entry.name.startsWith("_")).map((entry) => entry.name);
+    if (!(0, import_node_fs15.existsSync)(pluginSkills)) return { ok: false, detail: `plugin skills tree missing at ${pluginSkills}` };
+    const names = (0, import_node_fs15.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_fs14.mkdirSync)(skillsRoot, { recursive: true });
-    const incoming = (0, import_node_path11.join)(skillsRoot, ".mmi-incoming");
+    (0, import_node_fs15.mkdirSync)(skillsRoot, { recursive: true });
+    const incoming = (0, import_node_path12.join)(skillsRoot, ".mmi-incoming");
     discard2(incoming);
-    (0, import_node_fs14.cpSync)(pluginSkills, incoming, { recursive: true });
+    (0, import_node_fs15.cpSync)(pluginSkills, incoming, { recursive: true });
     discard2(targetRoot);
-    (0, import_node_fs14.renameSync)(incoming, targetRoot);
+    (0, import_node_fs15.renameSync)(incoming, targetRoot);
     return { ok: true, detail: `provisioned ${names.length} skills to ${targetRoot}` };
   } catch (error) {
     return { ok: false, detail: message2(error) };
@@ -1928,18 +2039,19 @@ function materializeHermesSkills(home) {
 function hermesArm(options) {
   const env = options.env ?? process.env;
   const home = hermesHome(env);
-  const parent = (0, import_node_path11.join)(home, "plugins");
-  const live = (0, import_node_path11.join)(parent, "mmi");
+  const parent = (0, import_node_path12.join)(home, "plugins");
+  const live = (0, import_node_path12.join)(parent, "mmi");
   const installed = yamlVersion(live);
-  const result = (from, to, verdict, detail) => ({
+  const result = (from, to, verdict, detail, launchStaged = false) => ({
     surface: "hermes",
     from,
     to,
     verdict,
-    detail
+    detail,
+    launchStaged: launchStaged || void 0
   });
-  if (!(0, import_node_fs14.existsSync)(home)) return result(null, options.target, "skip", `absent (${home}) \u2014 skipped without writes`);
-  if ((0, import_node_fs14.existsSync)(live) && !mmiOwned2(live)) {
+  if (!(0, import_node_fs15.existsSync)(home)) return result(null, options.target, "skip", `absent (${home}) \u2014 skipped without writes`);
+  if ((0, import_node_fs15.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)`);
@@ -1950,41 +2062,53 @@ 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_path11.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_path12.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_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_fs14.mkdirSync)(parent, { recursive: true });
-    (0, import_node_fs14.mkdirSync)((0, import_node_path11.join)(scratch, "quarantine"), { recursive: true });
-    discard2(incomingRoot);
-    (0, import_node_fs14.cpSync)(staged.packageRoot, incoming, { recursive: true });
-  } catch (error) {
-    return result(installed, options.target, "defer", `cannot place incoming Hermes generation: ${message2(error)}`);
-  }
-  if (yamlVersion(incoming) !== options.target || !treeHealthy3(incoming)) {
-    discard2(incomingRoot);
-    return result(installed, options.target, "defer", "incoming Hermes generation did not reproduce the verified payload");
+  const scratch = (0, import_node_path12.join)(home, ".mmi-updater");
+  const launchTargetPath = (0, import_node_path12.join)(scratch, "launch-target.json");
+  const incomingRoot = (0, import_node_path12.join)(scratch, "incoming");
+  const incoming = (0, import_node_path12.join)(incomingRoot, options.target);
+  const quarantine = (0, import_node_path12.join)(scratch, "quarantine", `${installed ?? "unknown"}-${Date.now()}`);
+  const priorLaunch = readLaunchTarget(launchTargetPath);
+  const reuseIncoming = priorLaunch?.target === options.target && priorLaunch.incoming === incoming && yamlVersion(incoming) === options.target && treeHealthy3(incoming);
+  if (!reuseIncoming) {
+    try {
+      (0, import_node_fs15.mkdirSync)(parent, { recursive: true });
+      (0, import_node_fs15.mkdirSync)((0, import_node_path12.join)(scratch, "quarantine"), { recursive: true });
+      discard2(incomingRoot);
+      (0, import_node_fs15.cpSync)(staged.packageRoot, incoming, { recursive: true });
+    } catch (error) {
+      return result(installed, options.target, "defer", `cannot place incoming Hermes generation: ${message2(error)}`);
+    }
+    if (yamlVersion(incoming) !== options.target || !treeHealthy3(incoming)) {
+      discard2(incomingRoot);
+      return result(installed, options.target, "defer", "incoming Hermes generation did not reproduce the verified payload");
+    }
   }
   const busy = hermesHostEvidence(env, home, options.processListProvider);
   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 pending = noteLaunchStaged(options.paths, env, {
+      surface: "hermes",
+      target: options.target,
+      reason: busy,
+      launchTargetPath,
+      incoming,
+      images: ["hermes"],
+      dirs: [home]
+    });
+    return result(installed, options.target, "ok", `staged ${options.target} for next launch while Hermes is running (${busy}) \u2014 ${pending}`, true);
   }
-  const displaced = (0, import_node_fs14.existsSync)(live);
+  const displaced = (0, import_node_fs15.existsSync)(live);
   try {
-    if (displaced) (0, import_node_fs14.renameSync)(live, quarantine);
-    (0, import_node_fs14.renameSync)(incoming, live);
+    if (displaced) (0, import_node_fs15.renameSync)(live, quarantine);
+    (0, import_node_fs15.renameSync)(incoming, live);
   } catch (error) {
-    if (displaced && !(0, import_node_fs14.existsSync)(live)) try {
-      (0, import_node_fs14.renameSync)(quarantine, live);
+    if (displaced && !(0, import_node_fs15.existsSync)(live)) try {
+      (0, import_node_fs15.renameSync)(quarantine, live);
     } catch {
     }
     discard2(incomingRoot);
@@ -1993,26 +2117,30 @@ function hermesArm(options) {
     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_path11.join)(scratch, "rejected", `${options.target}-${Date.now()}`);
+    const broken = (0, import_node_path12.join)(scratch, "rejected", `${options.target}-${Date.now()}`);
     try {
-      (0, import_node_fs14.mkdirSync)((0, import_node_path11.join)(scratch, "rejected"), { recursive: true });
-      (0, import_node_fs14.renameSync)(live, broken);
-      if (displaced) (0, import_node_fs14.renameSync)(quarantine, live);
+      (0, import_node_fs15.mkdirSync)((0, import_node_path12.join)(scratch, "rejected"), { recursive: true });
+      (0, import_node_fs15.renameSync)(live, broken);
+      if (displaced) (0, import_node_fs15.renameSync)(quarantine, live);
     } catch (error) {
       return result(installed, yamlVersion(live) ?? "unknown", "fail", `post-switch Hermes verification failed and recovery failed: ${message2(error)}`);
     }
     return result(installed, displaced ? installed ?? "unknown" : "none", "fail", `post-switch Hermes verification failed; rejected generation parked at ${broken}${displaced ? "; previous generation restored" : ""}`);
   }
   discard2(incomingRoot);
+  clearLaunchTarget(launchTargetPath);
   const skills = materializeHermesSkills(home);
   if (!skills.ok) return result(installed, options.target, "fail", `plugin converged to ${options.target}, but skills provisioning failed: ${skills.detail}`);
   return result(installed, options.target, "ok", `converged ${installed ?? "absent"} -> ${options.target} (staged, verified, atomically switched${displaced ? `; previous generation quarantined at ${quarantine}` : ""}); ${skills.detail}`);
 }
+function probeHermesLaunchStaging(env = process.env) {
+  return probeLaunchTargetVersion((0, import_node_path12.join)(hermesHome(env), ".mmi-updater", "launch-target.json"), yamlVersion);
+}
 
 // src/reap.ts
 var import_node_child_process10 = require("node:child_process");
-var import_node_fs15 = require("node:fs");
-var import_node_path12 = require("node:path");
+var import_node_fs16 = require("node:fs");
+var import_node_path13 = require("node:path");
 var KEEP_GENERATIONS2 = 2;
 var SCRATCH_AGE_MS = 24 * 60 * 6e4;
 var ORPHAN_MIN_AGE_MS = 10 * 6e4;
@@ -2020,7 +2148,7 @@ var SNAPSHOT_TIMEOUT_MS = 2e4;
 var MAX_UNWIND_ROUNDS = 4;
 function listDirs(path) {
   try {
-    return (0, import_node_fs15.readdirSync)(path, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+    return (0, import_node_fs16.readdirSync)(path, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
   } catch {
     return [];
   }
@@ -2028,7 +2156,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_path12.join)(root, name)).filter((path) => listDirs(path).some((name) => parseSemver(name)));
+  return children.map((name) => (0, import_node_path13.join)(root, name)).filter((path) => listDirs(path).some((name) => parseSemver(name)));
 }
 function pruneGenerations(root, category, dryRun) {
   let reaped = 0;
@@ -2041,7 +2169,7 @@ function pruneGenerations(root, category, dryRun) {
         continue;
       }
       try {
-        (0, import_node_fs15.rmSync)((0, import_node_path12.join)(set, version), { recursive: true, force: true });
+        (0, import_node_fs16.rmSync)((0, import_node_path13.join)(set, version), { recursive: true, force: true });
         reaped += 1;
       } catch (error) {
         failures.push(`${version}: ${error?.code ?? error?.message ?? error}`);
@@ -2055,8 +2183,8 @@ function pruneGenerations(root, category, dryRun) {
 }
 var LEASE_STEAL_SCRATCH = /^lease\.lock\.stale-\d+$/;
 function atomicWriteScratch(path) {
-  const literal = (0, import_node_path12.basename)(path).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  return { dir: (0, import_node_path12.dirname)(path), pattern: new RegExp(`^${literal}\\.tmp-\\d+$`) };
+  const literal = (0, import_node_path13.basename)(path).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return { dir: (0, import_node_path13.dirname)(path), pattern: new RegExp(`^${literal}\\.tmp-\\d+$`) };
 }
 function reapScratch(context, dryRun) {
   const category = "scratch";
@@ -2074,7 +2202,7 @@ function reapScratch(context, dryRun) {
   for (const [dir, patterns] of scanned) {
     let entries;
     try {
-      entries = (0, import_node_fs15.readdirSync)(dir, { withFileTypes: true });
+      entries = (0, import_node_fs16.readdirSync)(dir, { withFileTypes: true });
     } catch {
       unreadable.push(dir);
       continue;
@@ -2082,10 +2210,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_path12.join)(dir, entry.name);
+      const path = (0, import_node_path13.join)(dir, entry.name);
       let ageMs;
       try {
-        ageMs = now - (0, import_node_fs15.statSync)(path).mtimeMs;
+        ageMs = now - (0, import_node_fs16.statSync)(path).mtimeMs;
       } catch {
         continue;
       }
@@ -2095,7 +2223,7 @@ function reapScratch(context, dryRun) {
         continue;
       }
       try {
-        (0, import_node_fs15.rmSync)(path, { force: true });
+        (0, import_node_fs16.rmSync)(path, { force: true });
         reaped += 1;
       } catch (error) {
         failures.push(`${entry.name}: ${error?.code ?? error?.message ?? error}`);
@@ -2335,7 +2463,7 @@ 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 === "ok" && !options.dryRun && !arm.launchStaged) 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);
   };
@@ -2440,9 +2568,9 @@ function reconcile(options) {
 
 // src/scheduler.ts
 var import_node_child_process11 = require("node:child_process");
-var import_node_fs16 = require("node:fs");
+var import_node_fs17 = require("node:fs");
 var import_node_os6 = require("node:os");
-var import_node_path13 = require("node:path");
+var import_node_path14 = require("node:path");
 var TASK_NAME = "MMI Fleet Updater";
 var LAUNCHER_FILE = "reconcile-hidden.vbs";
 var RUN_BOUND = "PT15M";
@@ -2600,7 +2728,7 @@ WantedBy=timers.target
 }
 function readFileOrNull(path) {
   try {
-    return (0, import_node_fs16.readFileSync)(path, "utf8");
+    return (0, import_node_fs17.readFileSync)(path, "utf8");
   } catch {
     return null;
   }
@@ -2649,7 +2777,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_path13.join)(statePaths(env).root, LAUNCHER_FILE);
+  const launcherPath = (0, import_node_path14.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 });
@@ -2674,13 +2802,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_path13.join)((0, import_node_os6.homedir)(), "Library", "LaunchAgents", LAUNCHD_PLIST_NAME);
+  const plistPath = (0, import_node_path14.join)((0, import_node_os6.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_path13.join)(statePaths(env).root, POSIX_LAUNCHER_FILE);
+  const launcherPath = (0, import_node_path14.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\``);
@@ -2700,15 +2828,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_path13.join)((0, import_node_os6.homedir)(), ".config", "systemd", "user");
-  const timerPath = (0, import_node_path13.join)(unitDir, SYSTEMD_TIMER_NAME);
+  const unitDir = (0, import_node_path14.join)((0, import_node_os6.homedir)(), ".config", "systemd", "user");
+  const timerPath = (0, import_node_path14.join)(unitDir, SYSTEMD_TIMER_NAME);
   const timer = readFileOrNull(timerPath);
-  const service = readFileOrNull((0, import_node_path13.join)(unitDir, SYSTEMD_SERVICE_NAME));
+  const service = readFileOrNull((0, import_node_path14.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_path13.join)(statePaths(env).root, POSIX_LAUNCHER_FILE);
+  const launcherPath = (0, import_node_path14.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\``);
@@ -2747,10 +2875,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_path13.join)(paths.root, LAUNCHER_FILE);
-  (0, import_node_fs16.writeFileSync)(launcherPath, launcherVbs(process.execPath, hubDist), "utf8");
-  const xmlPath = (0, import_node_path13.join)(paths.root, "task.xml");
-  (0, import_node_fs16.writeFileSync)(xmlPath, "\uFEFF" + taskXml(launcherPath, paths.root, userId, localStartBoundary(/* @__PURE__ */ new Date())), "utf16le");
+  const launcherPath = (0, import_node_path14.join)(paths.root, LAUNCHER_FILE);
+  (0, import_node_fs17.writeFileSync)(launcherPath, launcherVbs(process.execPath, hubDist), "utf8");
+  const xmlPath = (0, import_node_path14.join)(paths.root, "task.xml");
+  (0, import_node_fs17.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);
@@ -2766,11 +2894,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_path13.join)(paths.root, POSIX_LAUNCHER_FILE);
+  const launcherPath = (0, import_node_path14.join)(paths.root, POSIX_LAUNCHER_FILE);
   const desired = launcherSh(process.execPath, hubDist);
   if (readFileOrNull(launcherPath) === desired) return null;
-  (0, import_node_fs16.writeFileSync)(launcherPath, desired, "utf8");
-  (0, import_node_fs16.chmodSync)(launcherPath, 493);
+  (0, import_node_fs17.writeFileSync)(launcherPath, desired, "utf8");
+  (0, import_node_fs17.chmodSync)(launcherPath, 493);
   return launcherPath;
 }
 function installLaunchd(env) {
@@ -2782,13 +2910,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_path13.join)(paths.root, POSIX_LAUNCHER_FILE);
-  (0, import_node_fs16.writeFileSync)(launcherPath, launcherSh(process.execPath, hubDist), "utf8");
-  (0, import_node_fs16.chmodSync)(launcherPath, 493);
-  const agentsDir = (0, import_node_path13.join)((0, import_node_os6.homedir)(), "Library", "LaunchAgents");
-  (0, import_node_fs16.mkdirSync)(agentsDir, { recursive: true });
-  const plistPath = (0, import_node_path13.join)(agentsDir, LAUNCHD_PLIST_NAME);
-  (0, import_node_fs16.writeFileSync)(plistPath, launchdPlist(launcherPath, paths.root), "utf8");
+  const launcherPath = (0, import_node_path14.join)(paths.root, POSIX_LAUNCHER_FILE);
+  (0, import_node_fs17.writeFileSync)(launcherPath, launcherSh(process.execPath, hubDist), "utf8");
+  (0, import_node_fs17.chmodSync)(launcherPath, 493);
+  const agentsDir = (0, import_node_path14.join)((0, import_node_os6.homedir)(), "Library", "LaunchAgents");
+  (0, import_node_fs17.mkdirSync)(agentsDir, { recursive: true });
+  const plistPath = (0, import_node_path14.join)(agentsDir, LAUNCHD_PLIST_NAME);
+  (0, import_node_fs17.writeFileSync)(plistPath, launchdPlist(launcherPath, paths.root), "utf8");
   launchctl(["bootout", `gui/${uid()}/${LAUNCHD_LABEL}`]);
   const load = launchctl(["bootstrap", `gui/${uid()}`, plistPath]);
   if (load.status !== 0) {
@@ -2806,13 +2934,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_path13.join)(paths.root, POSIX_LAUNCHER_FILE);
-  (0, import_node_fs16.writeFileSync)(launcherPath, launcherSh(process.execPath, hubDist), "utf8");
-  (0, import_node_fs16.chmodSync)(launcherPath, 493);
-  const unitDir = (0, import_node_path13.join)((0, import_node_os6.homedir)(), ".config", "systemd", "user");
-  (0, import_node_fs16.mkdirSync)(unitDir, { recursive: true });
-  (0, import_node_fs16.writeFileSync)((0, import_node_path13.join)(unitDir, SYSTEMD_SERVICE_NAME), systemdServiceUnit(launcherPath, paths.root), "utf8");
-  (0, import_node_fs16.writeFileSync)((0, import_node_path13.join)(unitDir, SYSTEMD_TIMER_NAME), systemdTimerUnit(), "utf8");
+  const launcherPath = (0, import_node_path14.join)(paths.root, POSIX_LAUNCHER_FILE);
+  (0, import_node_fs17.writeFileSync)(launcherPath, launcherSh(process.execPath, hubDist), "utf8");
+  (0, import_node_fs17.chmodSync)(launcherPath, 493);
+  const unitDir = (0, import_node_path14.join)((0, import_node_os6.homedir)(), ".config", "systemd", "user");
+  (0, import_node_fs17.mkdirSync)(unitDir, { recursive: true });
+  (0, import_node_fs17.writeFileSync)((0, import_node_path14.join)(unitDir, SYSTEMD_SERVICE_NAME), systemdServiceUnit(launcherPath, paths.root), "utf8");
+  (0, import_node_fs17.writeFileSync)((0, import_node_path14.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?"}` };
@@ -2850,28 +2978,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_path13.join)((0, import_node_os6.homedir)(), "Library", "LaunchAgents", LAUNCHD_PLIST_NAME);
+  const plistPath = (0, import_node_path14.join)((0, import_node_os6.homedir)(), "Library", "LaunchAgents", LAUNCHD_PLIST_NAME);
   const boot = launchctl(["bootout", `gui/${uid()}/${LAUNCHD_LABEL}`]);
-  if (boot.status !== 0 && (0, import_node_fs16.existsSync)(plistPath)) {
+  if (boot.status !== 0 && (0, import_node_fs17.existsSync)(plistPath)) {
     return { ok: false, detail: `launchctl bootout failed: ${(boot.stderr || boot.stdout).trim() || "unknown error"}` };
   }
   try {
-    (0, import_node_fs16.rmSync)(plistPath, { force: true });
+    (0, import_node_fs17.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_path13.join)((0, import_node_os6.homedir)(), ".config", "systemd", "user");
-  const timerPath = (0, import_node_path13.join)(unitDir, SYSTEMD_TIMER_NAME);
+  const unitDir = (0, import_node_path14.join)((0, import_node_os6.homedir)(), ".config", "systemd", "user");
+  const timerPath = (0, import_node_path14.join)(unitDir, SYSTEMD_TIMER_NAME);
   const disable = systemctlUser(["disable", "--now", SYSTEMD_TIMER_NAME]);
-  if (disable.status !== 0 && (0, import_node_fs16.existsSync)(timerPath)) {
+  if (disable.status !== 0 && (0, import_node_fs17.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_fs16.rmSync)(timerPath, { force: true });
-    (0, import_node_fs16.rmSync)((0, import_node_path13.join)(unitDir, SYSTEMD_SERVICE_NAME), { force: true });
+    (0, import_node_fs17.rmSync)(timerPath, { force: true });
+    (0, import_node_fs17.rmSync)((0, import_node_path14.join)(unitDir, SYSTEMD_SERVICE_NAME), { force: true });
   } catch {
   }
   systemctlUser(["daemon-reload"]);
@@ -2886,16 +3014,16 @@ function uninstallTask(env = process.env) {
 }
 function dropLauncher(env, file) {
   try {
-    (0, import_node_fs16.rmSync)((0, import_node_path13.join)(statePaths(env).root, file), { force: true });
+    (0, import_node_fs17.rmSync)((0, import_node_path14.join)(statePaths(env).root, file), { force: true });
   } catch {
   }
 }
 
 // src/status.ts
-var import_node_fs17 = require("node:fs");
+var import_node_fs18 = require("node:fs");
 function readJournal(path) {
   try {
-    const events = (0, import_node_fs17.readFileSync)(path, "utf8").split("\n").filter((line) => line.trim()).map((line) => {
+    const events = (0, import_node_fs18.readFileSync)(path, "utf8").split("\n").filter((line) => line.trim()).map((line) => {
       try {
         return JSON.parse(line);
       } catch {
@@ -2907,7 +3035,8 @@ function readJournal(path) {
     return error?.code === "ENOENT" ? { events: [], error: null } : { events: [], error: `journal unreadable: ${error?.message ?? error}` };
   }
 }
-function versionState(installed, expected) {
+function versionState(installed, staged, expected) {
+  if (staged && expected && staged === expected && installed !== expected) return "staged";
   if (!installed || !expected) return "unknown";
   const relation = compareSemver(installed, expected);
   return relation === 0 ? "current" : relation > 0 ? "ahead" : "behind";
@@ -2922,28 +3051,36 @@ function hubStatus(hubVersion, env = process.env, invokedPath = process.argv[1])
   const actual = /* @__PURE__ */ new Map();
   const hubDist = globalDist(env, "@mutmutco/hub", "dist/index.cjs");
   const globalHubVersion = hubDist ? probeVersion(hubDist) : null;
-  actual.set("hub", globalHubVersion ? { version: globalHubVersion, location: hubDist, detail: "absolute global Hub binary" } : { version: hubVersion, location: invokedPath ?? null, detail: "currently executing Hub bundle (global package location unavailable)" });
-  actual.set("cli", probeCliInstallation(env));
+  actual.set("hub", globalHubVersion ? { version: globalHubVersion, staged: null, location: hubDist, detail: "absolute global Hub binary" } : { version: hubVersion, staged: null, location: invokedPath ?? null, detail: "currently executing Hub bundle (global package location unavailable)" });
+  const cliProbe = probeCliInstallation(env);
+  actual.set("cli", { version: cliProbe.version, staged: null, location: cliProbe.location, detail: cliProbe.detail });
   for (const surface of enumerateSurfaces(env).filter((probe) => probe.present)) {
     if (surface.id === "claude" || surface.id === "codex" || surface.id === "kilo") {
-      actual.set(surface.id, probeNativeHostInstallation(surface.id, env));
+      const probe = probeNativeHostInstallation(surface.id, env);
+      actual.set(surface.id, { version: probe.version, staged: null, location: probe.location, detail: probe.detail });
     } else if (surface.id === "kimi") {
-      actual.set(surface.id, probeKimiInstallation(env));
+      const probe = probeKimiInstallation(env);
+      actual.set(surface.id, { version: probe.version, staged: probeKimiLaunchStaging(env), location: probe.location, detail: probe.detail });
     } else if (surface.id === "cursor") {
-      actual.set(surface.id, probeCursorInstallation());
+      const probe = probeCursorInstallation();
+      actual.set(surface.id, { version: probe.version, staged: probeCursorLaunchStaging(), location: probe.location, detail: probe.detail });
     } else if (surface.id === "jervcode") {
-      actual.set(surface.id, probeJervcodeInstallation(env));
+      const probe = probeJervcodeInstallation(env);
+      actual.set(surface.id, { version: probe.version, staged: null, location: probe.location, detail: probe.detail });
     } else if (surface.id === "hermes") {
-      actual.set(surface.id, probeHermesInstallation(env));
+      const probe = probeHermesInstallation(env);
+      actual.set(surface.id, { version: probe.version, staged: probeHermesLaunchStaging(env), location: probe.location, detail: probe.detail });
     }
   }
   const installed = {};
   for (const [surface, probe] of actual) {
+    const staged = probe.staged ?? null;
     installed[surface] = {
       installed: probe.version,
+      staged,
       expected: expectedVersion,
       location: probe.location,
-      state: versionState(probe.version, expectedVersion),
+      state: versionState(probe.version, staged, expectedVersion),
       detail: probe.detail
     };
   }
@@ -2980,7 +3117,8 @@ function formatHubStatus(status) {
     "  installed:"
   ];
   for (const [surface, row] of Object.entries(status.installed)) {
-    lines.push(`    ${surface}: ${row.installed ?? "unknown"} (expected ${row.expected ?? "unknown"}; ${row.state})`);
+    const staged = row.staged ? `; staged ${row.staged} for next launch` : "";
+    lines.push(`    ${surface}: loaded ${row.installed ?? "unknown"}${staged} (expected ${row.expected ?? "unknown"}; ${row.state})`);
     lines.push(`      ${row.location ?? "location unavailable"} \u2014 ${row.detail}`);
   }
   lines.push(`  autoupdate: ${status.schedule.enabled ? "on" : "off"} \u2014 ${status.schedule.detail}`);
@@ -3042,8 +3180,8 @@ function failConsequence(row) {
   return matchFirst(FAIL_CONSEQUENCE, detail) ?? "update failed \u2014 previous version kept";
 }
 function classify(arm) {
-  const kind = arm.verdict === "ok" ? arm.from !== null && arm.from === arm.to ? "current" : "updated" : arm.verdict === "skip" ? "keep" : arm.verdict === "defer" ? "retry" : "failed";
-  const note = kind === "updated" ? ACTIVATION_NOTE[arm.surface] ?? null : kind === "keep" ? "above target" : kind === "retry" ? retryHint(arm.detail) : null;
+  const kind = arm.verdict === "ok" ? arm.from !== null && arm.from === arm.to && !arm.launchStaged ? "current" : "updated" : arm.verdict === "skip" ? "keep" : arm.verdict === "defer" ? "retry" : "failed";
+  const note = kind === "updated" ? arm.launchStaged ? "next launch" : ACTIVATION_NOTE[arm.surface] ?? null : kind === "keep" ? "above target" : kind === "retry" ? retryHint(arm.detail) : null;
   return { name: arm.surface === "updater" ? "hub" : arm.surface, from: arm.from, to: arm.to, kind, note, detail: arm.detail, repeatFailure: arm.repeatFailure === true };
 }
 function statusText(kind, dryRun) {
@@ -3273,7 +3411,7 @@ function startSpinner(enabled) {
 // src/index.ts
 function ownVersion() {
   try {
-    return JSON.parse((0, import_node_fs18.readFileSync)((0, import_node_path14.join)(__dirname, "..", "package.json"), "utf8")).version;
+    return JSON.parse((0, import_node_fs19.readFileSync)((0, import_node_path15.join)(__dirname, "..", "package.json"), "utf8")).version;
   } catch {
     return "0.0.0";
   }
@@ -3401,6 +3539,7 @@ if (typeof require !== "undefined" && require.main === module) {
 0 && (module.exports = {
   acquireSharedDocLock,
   buildWatcherCommand,
+  clearLaunchTarget,
   clearPending,
   enumerateSurfaces,
   failConsequence,
@@ -3416,13 +3555,19 @@ if (typeof require !== "undefined" && require.main === module) {
   lockShaped,
   main,
   noteBusyDefer,
+  noteLaunchStaged,
   npmStringField,
   ownVersion,
   parseNpmDistIntegrity,
   pendingPath,
   pidAlive,
+  probeCursorLaunchStaging,
   probeHermesInstallation,
+  probeHermesLaunchStaging,
+  probeKimiLaunchStaging,
+  probeLaunchTargetVersion,
   progressiveRow,
+  readLaunchTarget,
   readPending,
   reconcileCursorUserHooks,
   reconcileKimiInstalledPlugin,
@@ -3442,5 +3587,6 @@ if (typeof require !== "undefined" && require.main === module) {
   watcherLockPath,
   withSharedDocLock,
   wrapWords,
+  writeLaunchTarget,
   writePending
 });