@mutmutco/hub 4.2.7 → 4.3.0

package/dist/index.cjs

@@ -29,6 +29,7 @@ __export(index_exports, {
   clearPending: () => clearPending,
   enumerateSurfaces: () => enumerateSurfaces,
   failConsequence: () => failConsequence,
+  fleetStamp: () => fleetStamp,
   formatReconcileReport: () => formatReconcileReport,
   hermesArm: () => hermesArm,
   hermesHome: () => hermesHome,
@@ -54,15 +55,14 @@ __export(index_exports, {
   probeHermesInstallation: () => probeHermesInstallation,
   probeHermesLaunchStaging: () => probeHermesLaunchStaging,
   probeJervcodeInstallation: () => probeJervcodeInstallation,
-  probeKimiLaunchStaging: () => probeKimiLaunchStaging,
   probeLaunchTargetVersion: () => probeLaunchTargetVersion,
   progressiveRow: () => progressiveRow,
   readLaunchTarget: () => readLaunchTarget,
   readPending: () => readPending,
   reconcileCursorUserHooks: () => reconcileCursorUserHooks,
-  reconcileKimiInstalledPlugin: () => reconcileKimiInstalledPlugin,
   releaseSharedDocLock: () => releaseSharedDocLock,
   reportFooterLines: () => reportFooterLines,
+  retiredSurfaces: () => retiredSurfaces,
   retryHint: () => retryHint,
   schedulePendingWatcher: () => schedulePendingWatcher,
   schedulerStatus: () => schedulerStatus,
@@ -71,11 +71,11 @@ __export(index_exports, {
   sharedDocLockTimeoutReceipt: () => sharedDocLockTimeoutReceipt,
   shouldHandOff: () => shouldHandOff,
   startSpinner: () => startSpinner,
+  surfaceArmPlan: () => surfaceArmPlan,
   systemdServiceUnit: () => systemdServiceUnit,
   systemdTimerUnit: () => systemdTimerUnit,
   taskXml: () => taskXml,
   updateHeader: () => updateHeader,
-  validateKimiInstalledPlugin: () => validateKimiInstalledPlugin,
   watcherLockPath: () => watcherLockPath,
   withSharedDocLock: () => withSharedDocLock,
   wrapWords: () => wrapWords,
@@ -83,9 +83,9 @@ __export(index_exports, {
   writePending: () => writePending
 });
 module.exports = __toCommonJS(index_exports);
-var import_node_child_process12 = require("node:child_process");
+var import_node_child_process10 = require("node:child_process");
 var import_node_fs19 = require("node:fs");
-var import_node_path15 = require("node:path");
+var import_node_path14 = require("node:path");
 
 // src/state.ts
 var import_node_fs = require("node:fs");
@@ -208,6 +208,18 @@ function journalSurfaceRepeatedFail(path, surface, currentRun) {
   }
   return lastVerdict === "fail";
 }
+function retiredSurfaces(events) {
+  const newest = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    if (event.dryRun || !event.surface) continue;
+    if (event.kind === "arm" || event.kind === "surface") newest.set(event.surface, event);
+  }
+  const retired = /* @__PURE__ */ new Set();
+  for (const [surface, event] of newest) {
+    if (event.kind === "surface" && event.retired) retired.add(surface);
+  }
+  return retired;
+}
 function parseSemver(version) {
   const match = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?$/.exec(version.trim());
   if (!match) return null;
@@ -770,7 +782,7 @@ function ensureClaudeMarketplace(env) {
 }
 var CLAUDE_PACKAGE = "@mutmutco/claude-plugin";
 var CLAUDE_MANIFEST = ".claude-plugin/plugin.json";
-var CLAUDE_TREE_MARKERS = [".claude-plugin/plugin.json", "hooks/hooks.json", "bin/mmi-hook"];
+var CLAUDE_TREE_MARKERS = [".claude-plugin/plugin.json"];
 function claudePluginsRoot(env) {
   return (0, import_node_path6.join)(claudeHomeDir(env), "plugins");
 }
@@ -1003,99 +1015,24 @@ function codexArm(options) {
   }
   return { surface: "codex", from, to: options.target, verdict: "ok", detail: `marketplace upgraded; payload refresh and native evidence verified at ${options.target}` };
 }
-var KILO_PACKAGE = "@mutmutco/kilo-plugin";
-function kiloConfigPath(env) {
-  return env.MMI_UPDATER_KILO_CONFIG || (0, import_node_path6.join)((0, import_node_os2.homedir)(), ".config", "kilo", "opencode.json");
-}
-function readKiloConfig(env) {
-  try {
-    const config = JSON.parse((0, import_node_fs7.readFileSync)(kiloConfigPath(env), "utf8"));
-    const specs = Array.isArray(config.plugin) && config.plugin.every((entry) => typeof entry === "string") ? config.plugin : [];
-    return { config, specs };
-  } catch {
-    return null;
-  }
-}
-function isLegacyMmiKiloPath(spec) {
-  const normalized = spec.replaceAll("\\", "/");
-  return /\/(?:MMI-Hub|@jervaise\/jerv-cli)\/\.kilo-plugin\/?$/i.test(normalized);
-}
-function normalizeKiloConfig(env, exact) {
-  const current = readKiloConfig(env);
-  if (!current) return `cannot read ${kiloConfigPath(env)}`;
-  const next = current.specs.filter((spec) => !isLegacyMmiKiloPath(spec));
-  if (!next.includes(exact)) next.push(exact);
-  if (JSON.stringify(next) === JSON.stringify(current.specs)) return null;
-  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);
-    return null;
-  } catch (error) {
-    return `cannot retire legacy Kilo registrations: ${error?.message ?? error}`;
-  }
-}
-function kiloVersion(specs) {
-  const exact = specs?.find((entry) => entry.startsWith(`${KILO_PACKAGE}@`));
-  return exact?.slice(`${KILO_PACKAGE}@`.length) || null;
-}
 function probeNativeHostInstallation(surface, env = process.env, runner = runHostCommand) {
   if (surface === "claude") {
-    const observed = claudeMmi(runner, env);
+    const observed2 = claudeMmi(runner, env);
     return {
-      version: observed.row?.version ?? null,
+      version: observed2.row?.version ?? null,
       location: "claude plugin list --json",
-      detail: observed.error ?? `native host reports enabled=${String(observed.row?.enabled)}`
-    };
-  }
-  if (surface === "codex") {
-    const observed = codexMmi(runner, env);
-    return {
-      version: observed.row?.version ?? null,
-      location: "codex plugin list --json",
-      detail: observed.error ?? `native host reports installed=${String(observed.row?.installed)}, enabled=${String(observed.row?.enabled)}`
+      detail: observed2.error ?? `native host reports enabled=${String(observed2.row?.enabled)}`
     };
   }
-  const config = readKiloConfig(env);
+  const observed = codexMmi(runner, env);
   return {
-    version: kiloVersion(config?.specs ?? null),
-    location: kiloConfigPath(env),
-    detail: config ? "exact package pin read from Kilo config" : "Kilo config was unreadable"
+    version: observed.row?.version ?? null,
+    location: "codex plugin list --json",
+    detail: observed.error ?? `native host reports installed=${String(observed.row?.installed)}, enabled=${String(observed.row?.enabled)}`
   };
 }
-function kiloArm(options) {
-  const env = options.env ?? process.env;
-  const runner = options.runner ?? runHostCommand;
-  const exact = `${KILO_PACKAGE}@${options.target}`;
-  const before = readKiloConfig(env);
-  if (!before) return { surface: "kilo", from: null, to: options.target, verdict: "defer", detail: `cannot read ${kiloConfigPath(env)}` };
-  const from = kiloVersion(before.specs);
-  const legacyCount = before.specs.filter(isLegacyMmiKiloPath).length;
-  if (options.dryRun) {
-    const action = before.specs.includes(exact) ? "keep exact pin" : `configure ${exact} globally`;
-    return { surface: "kilo", from, to: options.target, verdict: "ok", detail: `dry-run: would ${action}${legacyCount ? ` and retire ${legacyCount} legacy MMI path${legacyCount === 1 ? "" : "s"}` : ""} (payload provisions next session)` };
-  }
-  if (!before.specs.includes(exact)) {
-    const install = runner("kilo", ["plugin", exact, "--global", "--force"], env);
-    if (install.status !== 0) {
-      return { surface: "kilo", from, to: options.target, verdict: "defer", detail: `kilo plugin failed: ${failure(install)}` };
-    }
-  }
-  const normalizeError = normalizeKiloConfig(env, exact);
-  if (normalizeError) return { surface: "kilo", from, to: options.target, verdict: "defer", detail: normalizeError };
-  const after = readKiloConfig(env);
-  const legacyAfter = after?.specs.filter(isLegacyMmiKiloPath) ?? [];
-  if (!after?.specs.includes(exact) || legacyAfter.length) {
-    return { surface: "kilo", from, to: kiloVersion(after?.specs ?? null) ?? "unknown", verdict: "fail", detail: `post-install config must contain ${exact} and no legacy MMI paths (legacy=${legacyAfter.length})` };
-  }
-  return { surface: "kilo", from, to: options.target, verdict: "ok", detail: `global config verified at ${exact}; ${legacyCount ? `retired ${legacyCount} legacy MMI path${legacyCount === 1 ? "" : "s"}; ` : ""}payload provisions at next session start` };
-}
 
 // src/surfaces.ts
-function kimiHome(env = process.env) {
-  return env.KIMI_CODE_HOME?.trim() || (0, import_node_path7.join)((0, import_node_os3.homedir)(), ".kimi-code");
-}
 function jervcodeAgentDir(env = process.env) {
   return env.MMI_UPDATER_JERVCODE_AGENT_DIR?.trim() || env.JERVCODE_CODING_AGENT_DIR?.trim() || env.PI_CODING_AGENT_DIR?.trim() || (0, import_node_path7.join)((0, import_node_os3.homedir)(), ".jerv", "agent");
 }
@@ -1110,6 +1047,10 @@ function hermesHostCommand(env = process.env) {
 function hermesHostPresent(env = process.env, runner = runHostCommand) {
   return runner(hermesHostCommand(env), ["--version"], env).status === 0;
 }
+function surfaceArmPlan(token, managedSurfaces) {
+  if (!managedSurfaces) return "arm";
+  return managedSurfaces.includes(token) ? "arm" : "retired";
+}
 function enumerateSurfaces(env = process.env) {
   const home = env.HOME?.trim() || env.USERPROFILE?.trim() || (0, import_node_os3.homedir)();
   const codexHome = env.CODEX_HOME || (0, import_node_path7.join)(home, ".codex");
@@ -1121,11 +1062,6 @@ function enumerateSurfaces(env = process.env) {
     // and the arm could never make the first install. The plugin's absence is a converge action, not
     // a skip. The host root mirrors surfaceConfigRoot('cursor') in cli/src/plugin-guard-io.ts.
     { id: "cursor", marker: (0, import_node_path7.join)(home, ".cursor") },
-    { id: "kilo", marker: (0, import_node_path7.join)(home, ".config", "kilo") },
-    // The host, not the payload (#4951): this marker used to be plugins/managed/mmi — the MMI plugin
-    // itself — so a machine running Kimi WITHOUT the plugin enumerated as "no Kimi" and the arm
-    // could never make the first install. The plugin's absence is a converge action, not a skip.
-    { id: "kimi", marker: kimiHome(env) },
     { id: "jervcode", marker: (0, import_node_path7.join)(jervcodeAgentDir(env), "settings.json") },
     // Host CLI, not HERMES_HOME (#5673): the config tree can survive an uninstall and still carry
     // leftover plugin manifests — that residue must not enumerate as an installed host.
@@ -1225,9 +1161,10 @@ function selfArm(options) {
   });
 }
 
-// src/arm-kimi.ts
-var import_node_child_process7 = require("node:child_process");
+// src/arm-cursor.ts
 var import_node_fs12 = require("node:fs");
+var import_node_child_process7 = require("node:child_process");
+var import_node_os5 = require("node:os");
 var import_node_path9 = require("node:path");
 
 // src/compat.ts
@@ -1241,21 +1178,6 @@ function readManifestCompat(manifestPath) {
   }
 }
 
-// src/kimi-registration.ts
-function validateKimiInstalledPlugin(document, pluginRoot, id) {
-  if (!document || typeof document !== "object" || Array.isArray(document)) return "malformed-document";
-  const plugins = document.plugins;
-  if (!Array.isArray(plugins)) return "malformed-document";
-  const entry = plugins.find(
-    (candidate) => candidate && typeof candidate === "object" && !Array.isArray(candidate) && candidate.id === id
-  );
-  if (!entry) return "absent-record";
-  const record = entry;
-  if (typeof record.root !== "string") return "malformed-record";
-  if (record.root !== pluginRoot) return "foreign-root";
-  return record.enabled ? "healthy" : "disabled";
-}
-
 // src/host-doc-lock.ts
 var import_node_fs11 = require("node:fs");
 var import_node_os4 = require("node:os");
@@ -1366,311 +1288,22 @@ function withSharedDocLock(documentPath, options, fn) {
   }
 }
 
-// src/arm-kimi.ts
-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_path9.join)(root, ...rel.split("/"))));
-}
-function markerVersion(root) {
-  try {
-    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;
-  }
-}
-function packageVersion(root) {
-  try {
-    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;
-  }
-}
-var KIMI_REGISTRATION_LOCK_OWNER = "mmi-hub:kimi-registration";
-function reconcileKimiInstalledPlugin(kimiHomeDir, pluginRoot, id, lock = {}) {
-  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_fs12.existsSync)(path)) {
-    let parsed;
-    try {
-      parsed = JSON.parse((0, import_node_fs12.readFileSync)(path, "utf8"));
-    } catch {
-      return "conflict";
-    }
-    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed) || !Array.isArray(parsed.plugins)) return "conflict";
-    document = parsed;
-  }
-  const plugins = [...document.plugins];
-  const registration = validateKimiInstalledPlugin(document, pluginRoot, id);
-  const index = plugins.findIndex((entry) => typeof entry === "object" && entry !== null && !Array.isArray(entry) && entry.id === id);
-  if (registration === "malformed-record" || registration === "foreign-root") return "conflict";
-  if (index === -1) {
-    plugins.push(fresh);
-  } else {
-    const prior = plugins[index];
-    const next = {
-      ...prior,
-      root: pluginRoot,
-      // A user's explicit disable is their choice and survives; anything else converges to enabled.
-      enabled: prior.enabled === false ? false : true,
-      installedAt: typeof prior.installedAt === "string" ? prior.installedAt : now,
-      originalSource: pluginRoot,
-      source: "local-path"
-    };
-    if (JSON.stringify(next) === JSON.stringify(prior)) return "current";
-    plugins[index] = { ...next, updatedAt: now };
-  }
-  const tmp = `${path}.tmp-${process.pid}`;
-  (0, import_node_fs12.writeFileSync)(tmp, `${JSON.stringify({ ...document, version: 1, plugins }, null, 2)}
-`, "utf8");
-  (0, import_node_fs12.renameSync)(tmp, path);
-  return "updated";
-}
-function probeKimiInstallation(env = process.env) {
-  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" };
-}
-function tail2(output) {
-  return output.split("\n").filter(Boolean).slice(-3).join(" | ");
-}
-function scratchRoot(env) {
-  return (0, import_node_path9.join)(kimiHome(env), ".mmi-updater");
-}
-function pruneScratchDir(root, keep) {
-  try {
-    for (const name of (0, import_node_fs12.readdirSync)(root)) {
-      if (name === keep) continue;
-      try {
-        (0, import_node_fs12.rmSync)((0, import_node_path9.join)(root, name), { recursive: true, force: true });
-      } catch {
-      }
-    }
-  } catch {
-  }
-}
-var KIMI_PROCESS_SEGMENT = /^kimi(-cli|-code)?(\.(exe|cmd|bat|ps1|js|mjs|cjs|py))?$/i;
-function kimiProcessToken(line) {
-  for (const token of line.replace(/["']/g, " ").split(/\s+/)) {
-    if (token && token.split(/[/\\]/).some((segment) => KIMI_PROCESS_SEGMENT.test(segment))) return token;
-  }
-  return null;
-}
-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_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);
-    if (token) return { running: true, evidence: `a live process names kimi (${token})` };
-  }
-  return { running: false, evidence: "no kimi-named process in the process list" };
-}
-function restoreQuarantine(quarantine, live) {
-  try {
-    (0, import_node_fs12.renameSync)(quarantine, live);
-  } catch (error) {
-    return { restored: false, detail: `${error?.message ?? error}` };
-  }
-  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, 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_path9.join)(live, ".kimi-plugin", "plugin.json"))
-  });
-  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_fs12.existsSync)(live) || !treeHealthy(live)) return { detail };
-    if (dryRun) return { detail: `${detail}; installed.json untouched (dry-run)` };
-    let registration;
-    try {
-      registration = reconcileKimiInstalledPlugin(kimiHome(env), live, "mmi");
-    } catch (error) {
-      return { fail: true, detail: `${detail}; installed.json registration FAILED: ${error?.message ?? error}` };
-    }
-    if (registration === "conflict") {
-      return { fail: true, detail: `${detail}; installed.json carries an unparsable or foreign mmi record \u2014 the tree is INERT until a human resolves it; the file was never touched` };
-    }
-    return { detail: `${detail}; installed.json record ${registration === "updated" ? "written" : "already current"}` };
-  };
-  if (installed && compareSemver(installed, target) > 0) {
-    const reg2 = ensureRegistered(`installed ${installed} is above candidate ${target} (monotonic)`);
-    return result(installed, installed, reg2.fail ? "fail" : "skip", reg2.detail);
-  }
-  const highWater = journalHighWater(paths.journalPath, "kimi");
-  if (highWater && compareSemver(highWater, target) > 0) {
-    const reg2 = ensureRegistered(`journal high-water ${highWater} is above candidate ${target} (monotonic)`);
-    return result(installed, highWater, reg2.fail ? "fail" : "skip", reg2.detail);
-  }
-  if (installed === target && treeHealthy(live)) {
-    const reg2 = ensureRegistered(`already at target ${target}`);
-    return result(installed, target, reg2.fail ? "fail" : "ok", reg2.detail);
-  }
-  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_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_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)}`);
-    }
-  }
-  const stagedPackage = packageVersion(staged);
-  if (stagedPackage !== target) {
-    return result(installed, target, "defer", `staged package manifest is ${stagedPackage ?? "unreadable"}, expected ${target}`);
-  }
-  const stagedMarker = markerVersion(staged);
-  if (stagedMarker !== target) {
-    return result(installed, target, "defer", `staged plugin manifest is ${stagedMarker ?? "unreadable"}, expected ${target}`);
-  }
-  if (!treeHealthy(staged)) {
-    return result(installed, target, "defer", `staged tree is missing one of ${TREE_MARKERS.join(", ")}`);
-  }
-  const scratch = scratchRoot(env);
-  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}`);
-    }
-  }
-  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_fs12.existsSync)(live);
-  const generation = `${installed ?? "unknown"}-${Date.now()}`;
-  const quarantine = (0, import_node_path9.join)(quarantineRoot, generation);
-  if (hadLive) {
-    try {
-      (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"] })}` : "";
-      return result(installed, target, "defer", `cannot quarantine the live generation: ${reason}${pending}`);
-    }
-  }
-  try {
-    (0, import_node_fs12.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);
-    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_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_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_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_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_fs13 = require("node:fs");
-var import_node_child_process8 = require("node:child_process");
-var import_node_os5 = require("node:os");
-var import_node_path10 = require("node:path");
 var PACKAGE = "@mutmutco/cursor-plugin";
 var MANIFEST = ".cursor-plugin/plugin.json";
 var USER_HOOKS_FILE = "hooks.json";
-var PLUGIN_HOOKS_REL = ["hooks", "cursor-hooks.json"];
 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"];
+var TREE_FILES = [MANIFEST, "skills/bootstrap/SKILL.md"];
 function cursorPluginsRoot() {
-  return (0, import_node_path10.join)((0, import_node_os5.homedir)(), ".cursor", "plugins");
+  return (0, import_node_path9.join)((0, import_node_os5.homedir)(), ".cursor", "plugins");
 }
-function treeHealthy2(root) {
-  return TREE_FILES.every((rel) => (0, import_node_fs13.existsSync)((0, import_node_path10.join)(root, ...rel.split("/"))));
+function treeHealthy(root) {
+  return TREE_FILES.every((rel) => (0, import_node_fs12.existsSync)((0, import_node_path9.join)(root, ...rel.split("/"))));
 }
 function readJson(root, rel) {
   try {
-    return JSON.parse((0, import_node_fs13.readFileSync)((0, import_node_path10.join)(root, ...rel.split("/")), "utf8"));
+    return JSON.parse((0, import_node_fs12.readFileSync)((0, import_node_path9.join)(root, ...rel.split("/")), "utf8"));
   } catch {
     return null;
   }
@@ -1679,7 +1312,7 @@ function manifest(root) {
   return readJson(root, MANIFEST);
 }
 function probeCursorInstallation() {
-  const location = (0, import_node_path10.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" };
 }
@@ -1694,7 +1327,7 @@ function message(error) {
 }
 function discard(path) {
   try {
-    (0, import_node_fs13.rmSync)(path, { recursive: true, force: true });
+    (0, import_node_fs12.rmSync)(path, { recursive: true, force: true });
   } catch {
   }
 }
@@ -1713,7 +1346,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_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 });
+  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 });
   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);
@@ -1722,73 +1355,45 @@ function cursorHostEvidence(env) {
   return null;
 }
 function resolvedPluginRoot(root) {
-  return (0, import_node_path10.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));
-}
-function resolveCommand(command, pluginRoot) {
-  return command.replaceAll("${CURSOR_PLUGIN_ROOT}", resolvedPluginRoot(pluginRoot));
-}
-function desiredUserHooks(pluginRoot) {
-  try {
-    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();
-    for (const [event, entries] of Object.entries(hooks)) {
-      if (!Array.isArray(entries)) return null;
-      desired.set(event, entries.map((entry) => {
-        const command = typeof entry.command === "string" ? entry.command : "";
-        return { ...entry, command: resolveCommand(command, pluginRoot) };
-      }));
-    }
-    return desired;
-  } catch {
-    return null;
-  }
+  if (typeof entry !== "object" || entry === null || typeof entry.command !== "string") return false;
+  const command = entry.command;
+  return command.includes(resolvedPluginRoot(pluginRoot)) || /(?:mmi-hook|hook-run\.mjs|hook-policy\.mjs)/i.test(command);
 }
-function mergeUserHooks(existing, desired, pluginRoot) {
+function stripUserHooks(existing, pluginRoot) {
   if (typeof existing !== "object" || existing === null || Array.isArray(existing)) return null;
-  const merged = { ...existing };
-  const hooks = merged.hooks ?? {};
+  const stripped = { ...existing };
+  const hooks = stripped.hooks;
   if (typeof hooks !== "object" || hooks === null || Array.isArray(hooks)) return null;
-  const nextHooks = {};
+  const nextHooks = { ...hooks };
   for (const [event, entries] of Object.entries(hooks)) {
     if (!Array.isArray(entries)) return null;
     const kept = entries.filter((entry) => !isMmiEntry(entry, pluginRoot));
-    nextHooks[event] = [...kept, ...desired.get(event) ?? []];
+    if (kept.length) nextHooks[event] = kept;
+    else delete nextHooks[event];
   }
-  for (const [event, entries] of desired) {
-    if (!(event in hooks)) nextHooks[event] = entries;
-  }
-  merged.hooks = nextHooks;
-  return merged;
+  stripped.hooks = nextHooks;
+  return stripped;
 }
 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_path10.join)(homeDir, ".cursor", USER_HOOKS_FILE);
+  const path = (0, import_node_path9.join)(homeDir, ".cursor", USER_HOOKS_FILE);
   return withSharedDocLock(path, { owner: CURSOR_HOOKS_LOCK_OWNER, ...lock }, () => {
-    if (!(0, import_node_fs13.existsSync)(path)) {
-      const fresh = `${path}.tmp-${process.pid}`;
-      (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";
-    }
+    if (!(0, import_node_fs12.existsSync)(path)) return "current";
     let existing;
     try {
-      existing = JSON.parse((0, import_node_fs13.readFileSync)(path, "utf8"));
+      existing = JSON.parse((0, import_node_fs12.readFileSync)(path, "utf8"));
     } catch {
       return "user-conflict";
     }
-    const merged = mergeUserHooks(existing, desired, pluginRoot);
-    if (!merged) return "user-conflict";
-    if (JSON.stringify(merged) === JSON.stringify(existing)) return "current";
+    const stripped = stripUserHooks(existing, pluginRoot);
+    if (!stripped) return "user-conflict";
+    if (JSON.stringify(stripped) === JSON.stringify(existing)) return "current";
     const tmp = `${path}.tmp-${process.pid}`;
-    (0, import_node_fs13.writeFileSync)(tmp, JSON.stringify(merged, null, 2) + "\n", "utf8");
-    (0, import_node_fs13.renameSync)(tmp, path);
+    (0, import_node_fs12.writeFileSync)(tmp, JSON.stringify(stripped, null, 2) + "\n", "utf8");
+    (0, import_node_fs12.renameSync)(tmp, path);
     return "updated";
   });
 }
@@ -1801,45 +1406,43 @@ function userHooksDetail(pluginRoot, homeDir) {
   }
   switch (verdict) {
     case "updated":
-      return "; user hooks bridged into ~/.cursor/hooks.json";
+      return "; user hooks legacy entries stripped";
     case "user-conflict":
-      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";
+      return `; USER HOOKS CONFLICT at ${(0, import_node_path9.join)(homeDir, ".cursor", USER_HOOKS_FILE)} \u2014 legacy entries were not changed`;
     default:
       return "";
   }
 }
 function writeRollbackPointer(root, entry) {
-  const path = (0, import_node_path10.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_fs13.writeFileSync)(tmp, JSON.stringify({ surface: "cursor", ts: (/* @__PURE__ */ new Date()).toISOString(), ...entry }, null, 2) + "\n", "utf8");
-    (0, import_node_fs13.renameSync)(tmp, path);
+    (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);
   } catch {
     discard(tmp);
   }
 }
 function mtimeMs(path) {
   try {
-    return (0, import_node_fs13.statSync)(path).mtimeMs;
+    return (0, import_node_fs12.statSync)(path).mtimeMs;
   } catch {
     return 0;
   }
 }
 function pruneQuarantine(root, keep) {
-  const dir = (0, import_node_path10.join)(root, "quarantine");
+  const dir = (0, import_node_path9.join)(root, "quarantine");
   let generations;
   try {
-    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));
+    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));
   } catch {
     return 0;
   }
   let stranded = 0;
   try {
-    for (const entry of (0, import_node_fs13.readdirSync)(dir, { withFileTypes: true })) {
+    for (const entry of (0, import_node_fs12.readdirSync)(dir, { withFileTypes: true })) {
       if (!entry.isFile() || !/^rollback\.json\.tmp-\d+$/.test(entry.name)) continue;
-      const path = (0, import_node_path10.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;
@@ -1857,16 +1460,16 @@ function pruneQuarantine(root, keep) {
 }
 function restorePrevious(live, quarantined, broken) {
   try {
-    (0, import_node_fs13.renameSync)(live, broken);
+    (0, import_node_fs12.renameSync)(live, broken);
   } catch {
     return "kept-broken";
   }
   try {
-    (0, import_node_fs13.renameSync)(quarantined, live);
+    (0, import_node_fs12.renameSync)(quarantined, live);
     return "restored";
   } catch {
     try {
-      (0, import_node_fs13.renameSync)(broken, live);
+      (0, import_node_fs12.renameSync)(broken, live);
       return "kept-broken";
     } catch {
       return "lost";
@@ -1877,7 +1480,7 @@ function cursorArm(options) {
   const env = options.env ?? process.env;
   const { target, dryRun, paths } = options;
   const root = cursorPluginsRoot();
-  const live = (0, import_node_path10.join)(root, "local", "mmi");
+  const live = (0, import_node_path9.join)(root, "local", "mmi");
   const result = (from, to, verdict, detail, launchStaged = false) => ({
     surface: "cursor",
     from,
@@ -1887,7 +1490,7 @@ function cursorArm(options) {
     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_path10.join)(live, MANIFEST))
+    compat: readManifestCompat((0, import_node_path9.join)(live, MANIFEST))
   });
   const current = manifest(live);
   const installed = current?.version ?? null;
@@ -1898,10 +1501,10 @@ function cursorArm(options) {
   if (highWater && compareSemver(highWater, target) > 0) {
     return result(installed, highWater, "skip", `journal high-water ${highWater} is above candidate ${target} (monotonic)`);
   }
-  if (installed === target && treeHealthy2(live)) {
+  if (installed === target && treeHealthy(live)) {
     return result(installed, target, "ok", `already at target ${target}${userHooksDetail(live, (0, import_node_os5.homedir)())}`);
   }
-  if ((0, import_node_fs13.existsSync)(live) && !mmiOwned(live)) {
+  if ((0, import_node_fs12.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) {
@@ -1912,24 +1515,24 @@ function cursorArm(options) {
     return result(installed, target, "defer", staged.defer);
   }
   const stagedMarker = manifest(staged.packageRoot)?.version;
-  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`);
+  if (stagedMarker !== target || !treeHealthy(staged.packageRoot)) {
+    return result(installed, target, "defer", `staged tree marker is ${stagedMarker ?? "unreadable"} and the tree is ${treeHealthy(staged.packageRoot) ? "complete" : "incomplete"}, expected ${target} and complete`);
   }
-  const launchTargetPath = (0, import_node_path10.join)(root, "staging", "launch-target.json");
+  const launchTargetPath = (0, import_node_path9.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()}`);
+  let incoming = priorLaunch?.target === target && priorLaunch.incoming.startsWith((0, import_node_path9.join)(root, "staging")) && manifest(priorLaunch.incoming)?.version === target && treeHealthy(priorLaunch.incoming) ? priorLaunch.incoming : (0, import_node_path9.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 });
+  if (!reuseIncoming || !(0, import_node_fs12.existsSync)(incoming)) {
+    incoming = (0, import_node_path9.join)(root, "staging", `mmi-${safeSegment(target)}-${Date.now()}`);
+    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_fs13.cpSync)(staged.packageRoot, incoming, { recursive: true });
+      (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)) {
+    if (manifest(incoming)?.version !== target || !treeHealthy(incoming)) {
       discard(incoming);
       return result(installed, target, "defer", "the copy on the Cursor volume did not reproduce the verified tree");
     }
@@ -1947,8 +1550,8 @@ function cursorArm(options) {
     return result(installed, target, "ok", `staged ${target} for next launch while Cursor is running (${busy}) \u2014 ${pending}`, true);
   }
   const stamp = Date.now();
-  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 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 });
   const started = cursorHostEvidence(env);
   if (started) {
     const pending = noteLaunchStaged(paths, env, {
@@ -1963,15 +1566,15 @@ function cursorArm(options) {
   }
   let displaced = false;
   try {
-    if ((0, import_node_fs13.existsSync)(live)) {
-      (0, import_node_fs13.renameSync)(live, quarantined);
+    if ((0, import_node_fs12.existsSync)(live)) {
+      (0, import_node_fs12.renameSync)(live, quarantined);
       displaced = true;
     }
-    (0, import_node_fs13.renameSync)(incoming, live);
+    (0, import_node_fs12.renameSync)(incoming, live);
   } catch (error) {
-    if (displaced && !(0, import_node_fs13.existsSync)(live)) {
+    if (displaced && !(0, import_node_fs12.existsSync)(live)) {
       try {
-        (0, import_node_fs13.renameSync)(quarantined, live);
+        (0, import_node_fs12.renameSync)(quarantined, live);
       } catch {
       }
     }
@@ -1981,8 +1584,8 @@ function cursorArm(options) {
     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_path10.join)(root, "quarantine", `mmi-${safeSegment(evidence ?? "broken")}-${stamp}`)}-failed`;
+  if (evidence !== target || !treeHealthy(live)) {
+    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 });
@@ -1995,12 +1598,12 @@ function cursorArm(options) {
   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);
+  return probeLaunchTargetVersion((0, import_node_path9.join)(cursorPluginsRoot(), "staging", "launch-target.json"), (root) => manifest(root)?.version ?? null);
 }
 
 // src/arm-jervcode.ts
-var import_node_fs14 = require("node:fs");
-var import_node_path11 = require("node:path");
+var import_node_fs13 = require("node:fs");
+var import_node_path10 = require("node:path");
 var PI_PACKAGE = "@mutmutco/pi-plugin";
 function hostEnv(env) {
   const dir = jervcodeAgentDir(env);
@@ -2011,7 +1614,7 @@ function hostCommands(_env) {
 }
 function readPackageSpecs(env) {
   try {
-    const settings = JSON.parse((0, import_node_fs14.readFileSync)((0, import_node_path11.join)(jervcodeAgentDir(env), "settings.json"), "utf8"));
+    const settings = JSON.parse((0, import_node_fs13.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;
@@ -2019,14 +1622,14 @@ function readPackageSpecs(env) {
 }
 function installedVersion(env) {
   try {
-    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"));
+    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"));
     return typeof manifest2.version === "string" ? manifest2.version : null;
   } catch {
     return null;
   }
 }
 function materializedManifestLocation(env) {
-  return (0, import_node_path11.join)(jervcodeAgentDir(env), "npm", "node_modules", ...PI_PACKAGE.split("/"));
+  return (0, import_node_path10.join)(jervcodeAgentDir(env), "npm", "node_modules", ...PI_PACKAGE.split("/"));
 }
 var PI_LIST_SPEC = new RegExp(`npm:${PI_PACKAGE.replace("/", "\\/")}@(\\S+)`);
 function parseListText(stdout) {
@@ -2085,32 +1688,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_path11.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_path11.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_path11.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_path11.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_path11.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_path11.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);
@@ -2118,7 +1721,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_path11.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 {
@@ -2139,15 +1742,15 @@ function jervcodeArm(options) {
 }
 
 // src/arm-hermes.ts
-var import_node_fs15 = require("node:fs");
-var import_node_child_process9 = require("node:child_process");
-var import_node_path12 = require("node:path");
+var import_node_fs14 = require("node:fs");
+var import_node_child_process8 = require("node:child_process");
+var import_node_path11 = require("node:path");
 var PACKAGE2 = "@mutmutco/hermes-plugin";
 var MANIFEST2 = "plugin.yaml";
 var TREE_MARKERS_FALLBACK = [MANIFEST2, "__init__.py", "skills"];
 function yamlVersion(root) {
   try {
-    const text = (0, import_node_fs15.readFileSync)((0, import_node_path12.join)(root, MANIFEST2), "utf8");
+    const text = (0, import_node_fs14.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();
@@ -2161,7 +1764,7 @@ function yamlVersion(root) {
 }
 function packageTreeMarkers(root) {
   try {
-    const files = JSON.parse((0, import_node_fs15.readFileSync)((0, import_node_path12.join)(root, "package.json"), "utf8")).files;
+    const files = JSON.parse((0, import_node_fs14.readFileSync)((0, import_node_path11.join)(root, "package.json"), "utf8")).files;
     if (Array.isArray(files) && files.length && files.every((entry) => typeof entry === "string" && entry.trim())) {
       return files.map((entry) => entry.trim());
     }
@@ -2170,10 +1773,10 @@ function packageTreeMarkers(root) {
   return TREE_MARKERS_FALLBACK;
 }
 function markerPresent(root, rel) {
-  const path = (0, import_node_path12.join)(root, ...rel.split("/"));
-  if (!(0, import_node_fs15.existsSync)(path)) return false;
+  const path = (0, import_node_path11.join)(root, ...rel.split("/"));
+  if (!(0, import_node_fs14.existsSync)(path)) return false;
   try {
-    const stat = (0, import_node_fs15.statSync)(path);
+    const stat = (0, import_node_fs14.statSync)(path);
     return stat.isFile() || stat.isDirectory();
   } catch {
     return false;
@@ -2183,7 +1786,7 @@ function treeHealth(root) {
   const missing = packageTreeMarkers(root).filter((rel) => !markerPresent(root, rel));
   return { healthy: missing.length === 0, missing };
 }
-function treeHealthy3(root) {
+function treeHealthy2(root) {
   return treeHealth(root).healthy;
 }
 function treeIncompleteDetail(root, label) {
@@ -2192,13 +1795,13 @@ function treeIncompleteDetail(root, label) {
 }
 function packageIdentity(root) {
   try {
-    return JSON.parse((0, import_node_fs15.readFileSync)((0, import_node_path12.join)(root, "package.json"), "utf8")).name === PACKAGE2;
+    return JSON.parse((0, import_node_fs14.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_path12.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" };
 }
@@ -2207,7 +1810,7 @@ function mmiOwned2(root) {
 }
 function discard2(path) {
   try {
-    (0, import_node_fs15.rmSync)(path, { recursive: true, force: true });
+    (0, import_node_fs14.rmSync)(path, { recursive: true, force: true });
   } catch {
   }
 }
@@ -2226,7 +1829,7 @@ function hermesProcessToken(line, home) {
   return hermesToken(tokens) ?? (home && normalized.toLowerCase().includes(home.toLowerCase()) ? home : null);
 }
 function realProcessListing() {
-  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 });
+  const result = process.platform === "win32" ? (0, import_node_child_process8.spawnSync)("powershell.exe", ["-NoProfile", "-Command", "Get-CimInstance Win32_Process | ForEach-Object { $_.Name + ' ' + $_.CommandLine }"], { encoding: "utf8", windowsHide: true, timeout: 15e3 }) : (0, import_node_child_process8.spawnSync)("ps", ["-eo", "args="], { encoding: "utf8", windowsHide: true, timeout: 15e3 });
   return result.status === 0 ? result.stdout ?? "" : null;
 }
 function hermesHostEvidence(env, home, processListProvider) {
@@ -2239,19 +1842,19 @@ function hermesHostEvidence(env, home, processListProvider) {
   return null;
 }
 function materializeHermesSkills(home) {
-  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");
+  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_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 (!(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 (!names.length) return { ok: false, detail: `plugin skills tree is empty at ${pluginSkills}` };
-    (0, import_node_fs15.mkdirSync)(skillsRoot, { recursive: true });
-    const incoming = (0, import_node_path12.join)(skillsRoot, ".mmi-incoming");
+    (0, import_node_fs14.mkdirSync)(skillsRoot, { recursive: true });
+    const incoming = (0, import_node_path11.join)(skillsRoot, ".mmi-incoming");
     discard2(incoming);
-    (0, import_node_fs15.cpSync)(pluginSkills, incoming, { recursive: true });
+    (0, import_node_fs14.cpSync)(pluginSkills, incoming, { recursive: true });
     discard2(targetRoot);
-    (0, import_node_fs15.renameSync)(incoming, targetRoot);
+    (0, import_node_fs14.renameSync)(incoming, targetRoot);
     return { ok: true, detail: `provisioned ${names.length} skills to ${targetRoot}` };
   } catch (error) {
     return { ok: false, detail: message2(error) };
@@ -2260,8 +1863,8 @@ function materializeHermesSkills(home) {
 function hermesArm(options) {
   const env = options.env ?? process.env;
   const home = hermesHome(env);
-  const parent = (0, import_node_path12.join)(home, "plugins");
-  const live = (0, import_node_path12.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, launchStaged = false) => ({
     surface: "hermes",
@@ -2274,18 +1877,18 @@ function hermesArm(options) {
   if (!hermesHostPresent(env, options.hostCommandRunner)) {
     return result(null, options.target, "skip", `host absent (${hermesHostCommand(env)} CLI not on PATH) \u2014 skipped without writes`);
   }
-  if ((0, import_node_fs15.existsSync)(live) && !mmiOwned2(live)) {
+  if ((0, import_node_fs14.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)`);
   const highWater = journalHighWater(options.paths.journalPath, "hermes");
   if (highWater && compareSemver(highWater, options.target) > 0) return result(installed, highWater, "skip", `journal high-water ${highWater} is above candidate ${options.target} (monotonic)`);
-  if (installed === options.target && treeHealthy3(live)) {
+  if (installed === options.target && treeHealthy2(live)) {
     const skills2 = materializeHermesSkills(home);
     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_path12.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);
   const stagedVersion = yamlVersion(staged.packageRoot);
@@ -2294,19 +1897,19 @@ function hermesArm(options) {
   }
   const stagedTree = treeIncompleteDetail(staged.packageRoot, "staged Hermes");
   if (stagedTree) return result(installed, options.target, "defer", stagedTree);
-  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 scratch = (0, import_node_path11.join)(home, ".mmi-updater");
+  const launchTargetPath = (0, import_node_path11.join)(scratch, "launch-target.json");
+  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()}`);
   const priorLaunch = readLaunchTarget(launchTargetPath);
-  const reuseIncoming = priorLaunch?.target === options.target && priorLaunch.incoming === incoming && yamlVersion(incoming) === options.target && treeHealthy3(incoming);
+  const reuseIncoming = priorLaunch?.target === options.target && priorLaunch.incoming === incoming && yamlVersion(incoming) === options.target && treeHealthy2(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 });
+      (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_fs15.cpSync)(staged.packageRoot, incoming, { recursive: true });
+      (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)}`);
     }
@@ -2334,13 +1937,13 @@ function hermesArm(options) {
     });
     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_fs15.existsSync)(live);
+  const displaced = (0, import_node_fs14.existsSync)(live);
   try {
-    if (displaced) (0, import_node_fs15.renameSync)(live, quarantine);
-    (0, import_node_fs15.renameSync)(incoming, live);
+    if (displaced) (0, import_node_fs14.renameSync)(live, quarantine);
+    (0, import_node_fs14.renameSync)(incoming, live);
   } catch (error) {
-    if (displaced && !(0, import_node_fs15.existsSync)(live)) try {
-      (0, import_node_fs15.renameSync)(quarantine, live);
+    if (displaced && !(0, import_node_fs14.existsSync)(live)) try {
+      (0, import_node_fs14.renameSync)(quarantine, live);
     } catch {
     }
     discard2(incomingRoot);
@@ -2351,12 +1954,12 @@ function hermesArm(options) {
   const liveVersion = yamlVersion(live);
   const liveTree = treeIncompleteDetail(live, "live Hermes");
   if (liveVersion !== options.target || liveTree) {
-    const broken = (0, import_node_path12.join)(scratch, "rejected", `${options.target}-${Date.now()}`);
+    const broken = (0, import_node_path11.join)(scratch, "rejected", `${options.target}-${Date.now()}`);
     const verifyDetail = liveVersion !== options.target ? `manifest is ${liveVersion ?? "unreadable"}, expected ${options.target}` : liveTree;
     try {
-      (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);
+      (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);
     } catch (error) {
       return result(installed, liveVersion ?? "unknown", "fail", `post-switch Hermes verification failed and recovery failed: ${message2(error)}`);
     }
@@ -2369,21 +1972,17 @@ function hermesArm(options) {
   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);
+  return probeLaunchTargetVersion((0, import_node_path11.join)(hermesHome(env), ".mmi-updater", "launch-target.json"), yamlVersion);
 }
 
 // src/reap.ts
-var import_node_child_process10 = require("node:child_process");
-var import_node_fs16 = require("node:fs");
-var import_node_path13 = require("node:path");
+var import_node_fs15 = 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;
-var SNAPSHOT_TIMEOUT_MS = 2e4;
-var MAX_UNWIND_ROUNDS = 4;
 function listDirs(path) {
   try {
-    return (0, import_node_fs16.readdirSync)(path, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+    return (0, import_node_fs15.readdirSync)(path, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
   } catch {
     return [];
   }
@@ -2391,7 +1990,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_path13.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;
@@ -2404,7 +2003,7 @@ function pruneGenerations(root, category, dryRun) {
         continue;
       }
       try {
-        (0, import_node_fs16.rmSync)((0, import_node_path13.join)(set, version), { recursive: true, force: true });
+        (0, import_node_fs15.rmSync)((0, import_node_path12.join)(set, version), { recursive: true, force: true });
         reaped += 1;
       } catch (error) {
         failures.push(`${version}: ${error?.code ?? error?.message ?? error}`);
@@ -2418,8 +2017,8 @@ function pruneGenerations(root, category, dryRun) {
 }
 var LEASE_STEAL_SCRATCH = /^lease\.lock\.stale-\d+$/;
 function atomicWriteScratch(path) {
-  const literal = (0, import_node_path13.basename)(path).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  return { dir: (0, import_node_path13.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";
@@ -2437,7 +2036,7 @@ function reapScratch(context, dryRun) {
   for (const [dir, patterns] of scanned) {
     let entries;
     try {
-      entries = (0, import_node_fs16.readdirSync)(dir, { withFileTypes: true });
+      entries = (0, import_node_fs15.readdirSync)(dir, { withFileTypes: true });
     } catch {
       unreadable.push(dir);
       continue;
@@ -2445,10 +2044,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_path13.join)(dir, entry.name);
+      const path = (0, import_node_path12.join)(dir, entry.name);
       let ageMs;
       try {
-        ageMs = now - (0, import_node_fs16.statSync)(path).mtimeMs;
+        ageMs = now - (0, import_node_fs15.statSync)(path).mtimeMs;
       } catch {
         continue;
       }
@@ -2458,7 +2057,7 @@ function reapScratch(context, dryRun) {
         continue;
       }
       try {
-        (0, import_node_fs16.rmSync)(path, { force: true });
+        (0, import_node_fs15.rmSync)(path, { force: true });
         reaped += 1;
       } catch (error) {
         failures.push(`${entry.name}: ${error?.code ?? error?.message ?? error}`);
@@ -2471,194 +2070,6 @@ function reapScratch(context, dryRun) {
   const stuck = failures.length ? `; ${failures.length} locked (${failures.join(", ")})` : "";
   return { category, reaped, verdict: failures.length ? "defer" : "ok", detail: `${verb} ${reaped} aged scratch entr(ies) under ${swept.join(", ")}${stuck}` };
 }
-var HOOK_IMAGES = /* @__PURE__ */ new Set(["mmi-hook.exe", "node.exe", "cmd.exe", "powershell.exe", "pwsh.exe"]);
-var HOOK_ARTIFACT = /(?:^|[\\/])(?:mmi-hook(?:-console)?(?:\.exe|\.cmd|\.bat)?|hook-run\.mjs)$/i;
-var NODE_INTERPRETER = /(?:^|[\\/])node(?:\.exe)?$/i;
-var NODE_VALUE_FLAGS = /* @__PURE__ */ new Set(["-e", "--eval", "-p", "--print", "-r", "--require", "--import", "--loader", "--experimental-loader", "-C", "--conditions"]);
-var CMD_SHELL = /(?:^|[\\/])cmd(?:\.exe)?$/i;
-var CMD_RUN_FLAGS = /* @__PURE__ */ new Set(["/c", "/k"]);
-var PS_SHELL = /(?:^|[\\/])(?:powershell|pwsh)(?:\.exe)?$/i;
-var PS_COMMAND_FLAGS = /* @__PURE__ */ new Set(["-command", "-c"]);
-var SEPARATORS = ["&", "|"];
-function tokenize(commandLine) {
-  const tokens = [];
-  let current = "";
-  let quoted = false;
-  let slashes = 0;
-  for (const char of commandLine) {
-    if (char === "\\") {
-      slashes += 1;
-      continue;
-    }
-    if (char === '"') {
-      current += "\\".repeat(slashes >> 1);
-      if (slashes % 2) current += '"';
-      else quoted = !quoted;
-      slashes = 0;
-      continue;
-    }
-    current += "\\".repeat(slashes);
-    slashes = 0;
-    if (!quoted && /\s/.test(char)) {
-      if (current) tokens.push(current);
-      current = "";
-      continue;
-    }
-    current += char;
-  }
-  current += "\\".repeat(slashes);
-  if (current) tokens.push(current);
-  return tokens;
-}
-function invocation(commandLine) {
-  let tokens = tokenize(commandLine);
-  if (tokens.length && CMD_SHELL.test(tokens[0])) {
-    const flag = tokens.findIndex((token) => CMD_RUN_FLAGS.has(token.toLowerCase()));
-    if (flag < 0) return [];
-    const rest = tokens.slice(flag + 1);
-    tokens = rest.length === 1 ? tokenize(rest[0]) : rest;
-  } else if (tokens.length && PS_SHELL.test(tokens[0])) {
-    const flag = tokens.findIndex((token) => PS_COMMAND_FLAGS.has(token.toLowerCase()));
-    if (flag < 0) return [];
-    const rest = tokens.slice(flag + 1);
-    tokens = rest.length === 1 ? tokenize(rest[0]) : rest;
-    if (tokens[0] === "&") tokens = tokens.slice(1);
-  }
-  const cut = tokens.findIndex((token) => SEPARATORS.some((separator) => token.includes(separator)));
-  return cut < 0 ? tokens : tokens.slice(0, cut);
-}
-function hookProgram(tokens) {
-  if (!tokens.length) return null;
-  if (HOOK_ARTIFACT.test(tokens[0])) return tokens[0];
-  if (!NODE_INTERPRETER.test(tokens[0])) return null;
-  let at = 1;
-  while (at < tokens.length && tokens[at].startsWith("-")) {
-    const flag = tokens[at].toLowerCase();
-    at += !flag.includes("=") && NODE_VALUE_FLAGS.has(flag) ? 2 : 1;
-  }
-  return at < tokens.length && HOOK_ARTIFACT.test(tokens[at]) ? tokens[at] : null;
-}
-function flagValue(tokens, flag) {
-  const at = tokens.indexOf(flag);
-  return at >= 0 && at + 1 < tokens.length ? tokens[at + 1] : null;
-}
-function selectHookOrphans(rows, livePids, options) {
-  const kills = [];
-  for (const row of rows) {
-    if (row.pid === options.selfPid) continue;
-    if (!HOOK_IMAGES.has(row.name.toLowerCase())) continue;
-    const tokens = invocation(row.commandLine);
-    const program = hookProgram(tokens);
-    if (!program) continue;
-    const surface = flagValue(tokens, "--surface");
-    const gate = flagValue(tokens, "--gate");
-    if (!surface || !gate) continue;
-    if (livePids.has(row.ppid)) continue;
-    if (row.startedMs === null) continue;
-    const ageMs = options.now - row.startedMs;
-    if (ageMs < options.minAgeMs) continue;
-    kills.push({
-      pid: row.pid,
-      name: row.name,
-      reason: `runs ${program} --surface ${surface} --gate ${gate}; parent ${row.ppid} absent from the snapshot; alive ${Math.round(ageMs / 6e4)}m`,
-      identity: row
-    });
-  }
-  return kills;
-}
-function stillTheProvenProcess(rows, kill) {
-  const live = rows.find((row) => row.pid === kill.pid);
-  if (!live) return false;
-  const same = live.name === kill.identity.name && live.commandLine === kill.identity.commandLine && live.startedMs === kill.identity.startedMs && live.ppid === kill.identity.ppid;
-  return same && !rows.some((row) => row.pid === kill.identity.ppid);
-}
-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_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);
-    const rows = Array.isArray(parsed) ? parsed : [parsed];
-    return rows.filter((row) => typeof row?.ProcessId === "number").map((row) => ({
-      pid: row.ProcessId,
-      ppid: typeof row.ParentProcessId === "number" ? row.ParentProcessId : -1,
-      name: typeof row.Name === "string" ? row.Name : "",
-      commandLine: typeof row.CommandLine === "string" ? row.CommandLine : "",
-      startedMs: typeof row.Started === "string" ? Number.isNaN(Date.parse(row.Started)) ? null : Date.parse(row.Started) : null
-    }));
-  } catch {
-    return null;
-  }
-}
-function reapHookOrphans(dryRun) {
-  const category = "hook-orphans";
-  if (process.platform !== "win32") {
-    return { category, reaped: 0, verdict: "skip", detail: "dead-parent hook reap is Windows-only (#4943 class) \u2014 skipped" };
-  }
-  const snapshot = processSnapshot();
-  if (!snapshot) {
-    return { category, reaped: 0, verdict: "skip", detail: "process list unreadable \u2014 nothing is provably an orphan, so nothing was killed" };
-  }
-  const select = (rows) => selectHookOrphans(rows, new Set(rows.map((row) => row.pid)), { now: Date.now(), selfPid: process.pid, minAgeMs: ORPHAN_MIN_AGE_MS });
-  const first = select(snapshot);
-  if (!first.length) return { category, reaped: 0, verdict: "skip", detail: `no dead-parent MMI hook descendants among ${snapshot.length} processes` };
-  if (dryRun) {
-    const named2 = first.map((kill) => `${kill.name}#${kill.pid} (${kill.reason})`).join("; ");
-    return { category, reaped: first.length, verdict: "ok", detail: `dry-run: would kill ${first.length} dead-parent hook orphan(s) in the first unwind round: ${named2}` };
-  }
-  const reaped = [];
-  const survived = [];
-  const declined = [];
-  const attempted = /* @__PURE__ */ new Set();
-  let pending = first;
-  let rounds = 0;
-  let halted = "";
-  while (pending.length && rounds < MAX_UNWIND_ROUNDS) {
-    rounds += 1;
-    const confirm = processSnapshot();
-    if (!confirm) {
-      halted = "a re-validation snapshot was unreadable, so the remaining rows were not killed";
-      break;
-    }
-    const proven = pending.filter((kill) => stillTheProvenProcess(confirm, kill));
-    declined.push(...pending.filter((kill) => !proven.includes(kill)));
-    for (const kill of pending) attempted.add(kill.pid);
-    pending = [];
-    if (!proven.length) break;
-    for (const orphan of proven) {
-      try {
-        process.kill(orphan.pid);
-      } catch {
-      }
-    }
-    const after = processSnapshot();
-    if (!after) {
-      halted = `${proven.length} kill(s) were issued but the verification snapshot was unreadable \u2014 they are not claimed reaped`;
-      break;
-    }
-    const alive = new Set(after.map((row) => row.pid));
-    for (const orphan of proven) (alive.has(orphan.pid) ? survived : reaped).push(orphan);
-    pending = select(after).filter((kill) => !attempted.has(kill.pid));
-  }
-  const notes = [];
-  if (survived.length) notes.push(`${survived.length} survived the kill (${survived.map((kill) => kill.pid).join(", ")})`);
-  if (declined.length) notes.push(`${declined.length} declined at re-validation \u2014 gone on its own, or no longer the row that was proven (${declined.map((kill) => kill.pid).join(", ")})`);
-  if (pending.length) {
-    const why = rounds >= MAX_UNWIND_ROUNDS ? `the ${MAX_UNWIND_ROUNDS}-round unwind budget ran out` : "this tick stopped short";
-    notes.push(`${pending.length} hook orphan(s) still standing because ${why} (${pending.map((kill) => `${kill.name}#${kill.pid}`).join(", ")}) \u2014 next tick continues`);
-  }
-  if (halted) notes.push(halted);
-  const named = reaped.map((kill) => `${kill.name}#${kill.pid} (${kill.reason})`).join("; ");
-  if (!notes.length) {
-    return { category, reaped: reaped.length, verdict: "ok", detail: `reaped ${reaped.length} dead-parent hook orphan(s) over ${rounds} unwind round(s), verified gone: ${named}` };
-  }
-  return {
-    category,
-    reaped: reaped.length,
-    verdict: "defer",
-    detail: `reaped ${reaped.length} dead-parent hook orphan(s) over ${rounds} unwind round(s)${named ? ` (${named})` : ""}; ${notes.join("; ")}`
-  };
-}
 function reap(options) {
   const { paths, dryRun } = options;
   const env = options.env ?? process.env;
@@ -2669,11 +2080,10 @@ function reap(options) {
       return { category, reaped: 0, verdict: "fail", detail: `reap failed: ${error?.message ?? error}` };
     }
   };
-  const atomicWritePaths = [claudeMarketplacesPath(env), kiloConfigPath(env)];
+  const atomicWritePaths = [claudeMarketplacesPath(env)];
   return [
     guarded("staging-prune", () => pruneGenerations(paths.staging, "staging-prune", dryRun)),
-    guarded("scratch", () => reapScratch({ root: paths.root, atomicWritePaths }, dryRun)),
-    guarded("hook-orphans", () => reapHookOrphans(dryRun))
+    guarded("scratch", () => reapScratch({ root: paths.root, atomicWritePaths }, dryRun))
   ];
 }
 
@@ -2698,7 +2108,7 @@ function reconcile(options) {
     const stamped = options.dryRun ? { ...event, dryRun: true } : event;
     if (!appendJournal(paths.journalPath, { ts: (/* @__PURE__ */ new Date()).toISOString(), run, ...stamped })) summary.journalOk = false;
   };
-  const summary = { run, target: null, gate: null, atomicity: null, cli: null, updater: null, plugins: [], reap: [], surfaces: [], journalOk: true, reexec: null, exit: 0 };
+  const summary = { run, target: null, gate: null, managedSurfaces: null, atomicity: null, cli: null, updater: null, plugins: [], reap: [], surfaces: [], journalOk: true, reexec: null, exit: 0 };
   const recordArm = (arm) => {
     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 });
@@ -2747,6 +2157,7 @@ function reconcile(options) {
           continue;
         }
         summary.target = candidate;
+        summary.managedSurfaces = Array.isArray(gate.bom?.managedSurfaces) ? gate.bom.managedSurfaces.map(String) : null;
         summary.gate = `tag v${candidate} reachable from main, BOM stamp coherent`;
         summary.atomicity = atomicity;
         journal({ kind: "target", to: candidate, verdict: "ok", detail: summary.gate });
@@ -2786,8 +2197,14 @@ function reconcile(options) {
           journal({ kind: "surface", surface: probe.id, present: false, verdict: "skip", detail: `absent (${probe.marker}) \u2014 skipped` });
           continue;
         }
+        if (surfaceArmPlan(probe.id, summary.managedSurfaces) === "retired") {
+          summary.surfaces.push({ id: probe.id, present: true, action: "retired-at-source" });
+          journal({ kind: "surface", surface: probe.id, present: true, verdict: "skip", retired: true, detail: `not in release v${summary.target} managedSurfaces \u2014 retired at source` });
+          say(`${probe.id}: retired at source (not in release v${summary.target})`);
+          continue;
+        }
         say(`${probe.id}: converging to v${summary.target}`);
-        const arm = probe.id === "claude" ? claudeArm({ target: summary.target, dryRun: options.dryRun, paths, env, repoUrl }) : probe.id === "codex" ? codexArm({ target: summary.target, dryRun: options.dryRun, env, repoUrl }) : probe.id === "kilo" ? kiloArm({ target: summary.target, dryRun: options.dryRun, env }) : probe.id === "kimi" ? kimiArm({ target: summary.target, dryRun: options.dryRun, paths, env }) : probe.id === "cursor" ? cursorArm({ target: summary.target, dryRun: options.dryRun, paths, env }) : probe.id === "jervcode" ? jervcodeArm({ target: summary.target, dryRun: options.dryRun, paths, env }) : probe.id === "hermes" ? hermesArm({ target: summary.target, dryRun: options.dryRun, paths, env }) : null;
+        const arm = probe.id === "claude" ? claudeArm({ target: summary.target, dryRun: options.dryRun, paths, env, repoUrl }) : probe.id === "codex" ? codexArm({ target: summary.target, dryRun: options.dryRun, env, repoUrl }) : probe.id === "cursor" ? cursorArm({ target: summary.target, dryRun: options.dryRun, paths, env }) : probe.id === "jervcode" ? jervcodeArm({ target: summary.target, dryRun: options.dryRun, paths, env }) : probe.id === "hermes" ? hermesArm({ target: summary.target, dryRun: options.dryRun, paths, env }) : null;
         if (arm) {
           summary.plugins.push(arm);
           summary.surfaces.push({ id: probe.id, present: true, action: `arm-${arm.verdict}` });
@@ -2814,10 +2231,10 @@ function reconcile(options) {
 }
 
 // src/scheduler.ts
-var import_node_child_process11 = require("node:child_process");
-var import_node_fs17 = require("node:fs");
+var import_node_child_process9 = require("node:child_process");
+var import_node_fs16 = require("node:fs");
 var import_node_os6 = require("node:os");
-var import_node_path14 = 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";
@@ -2833,15 +2250,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_process11.spawnSync)("schtasks.exe", args, { encoding: "utf8", windowsHide: true });
+  const result = (0, import_node_child_process9.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_process11.spawnSync)("launchctl", args, { encoding: "utf8", windowsHide: true });
+  const result = (0, import_node_child_process9.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_process11.spawnSync)("systemctl", ["--user", ...args], { encoding: "utf8", windowsHide: true });
+  const result = (0, import_node_child_process9.spawnSync)("systemctl", ["--user", ...args], { encoding: "utf8", windowsHide: true });
   return { status: result.status, stdout: result.stdout ?? "", stderr: result.stderr ?? "" };
 }
 function uid() {
@@ -2866,7 +2283,7 @@ WScript.Quit code
 `;
 }
 function loginPath(fallback = process.env.PATH ?? "") {
-  const probe = (0, import_node_child_process11.spawnSync)("/bin/sh", ["-lc", 'printf %s "$PATH"'], { encoding: "utf8", windowsHide: true, timeout: 1e4 });
+  const probe = (0, import_node_child_process9.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));
@@ -2975,7 +2392,7 @@ WantedBy=timers.target
 }
 function readFileOrNull(path) {
   try {
-    return (0, import_node_fs17.readFileSync)(path, "utf8");
+    return (0, import_node_fs16.readFileSync)(path, "utf8");
   } catch {
     return null;
   }
@@ -2987,7 +2404,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_process11.spawnSync)(
+  const relaunch = (0, import_node_child_process9.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 }
@@ -2998,7 +2415,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_process11.spawnSync)(
+  const result = (0, import_node_child_process9.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 }
@@ -3024,7 +2441,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_path14.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 });
@@ -3049,13 +2466,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_path14.join)((0, import_node_os6.homedir)(), "Library", "LaunchAgents", LAUNCHD_PLIST_NAME);
+  const plistPath = (0, import_node_path13.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_path14.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\``);
@@ -3075,15 +2492,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_path14.join)((0, import_node_os6.homedir)(), ".config", "systemd", "user");
-  const timerPath = (0, import_node_path14.join)(unitDir, SYSTEMD_TIMER_NAME);
+  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 timer = readFileOrNull(timerPath);
-  const service = readFileOrNull((0, import_node_path14.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_path14.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\``);
@@ -3122,10 +2539,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_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 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 create = schtasks(["/create", "/tn", TASK_NAME, "/xml", xmlPath, "/f"]);
   if (create.status !== 0) {
     const denied = /access is denied/i.test(create.stderr + create.stdout);
@@ -3141,11 +2558,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_path14.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_fs17.writeFileSync)(launcherPath, desired, "utf8");
-  (0, import_node_fs17.chmodSync)(launcherPath, 493);
+  (0, import_node_fs16.writeFileSync)(launcherPath, desired, "utf8");
+  (0, import_node_fs16.chmodSync)(launcherPath, 493);
   return launcherPath;
 }
 function installLaunchd(env) {
@@ -3157,13 +2574,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_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");
+  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");
   launchctl(["bootout", `gui/${uid()}/${LAUNCHD_LABEL}`]);
   const load = launchctl(["bootstrap", `gui/${uid()}`, plistPath]);
   if (load.status !== 0) {
@@ -3181,13 +2598,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_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 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 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?"}` };
@@ -3225,28 +2642,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_path14.join)((0, import_node_os6.homedir)(), "Library", "LaunchAgents", LAUNCHD_PLIST_NAME);
+  const plistPath = (0, import_node_path13.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_fs17.existsSync)(plistPath)) {
+  if (boot.status !== 0 && (0, import_node_fs16.existsSync)(plistPath)) {
     return { ok: false, detail: `launchctl bootout failed: ${(boot.stderr || boot.stdout).trim() || "unknown error"}` };
   }
   try {
-    (0, import_node_fs17.rmSync)(plistPath, { force: true });
+    (0, import_node_fs16.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_path14.join)((0, import_node_os6.homedir)(), ".config", "systemd", "user");
-  const timerPath = (0, import_node_path14.join)(unitDir, SYSTEMD_TIMER_NAME);
+  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 disable = systemctlUser(["disable", "--now", SYSTEMD_TIMER_NAME]);
-  if (disable.status !== 0 && (0, import_node_fs17.existsSync)(timerPath)) {
+  if (disable.status !== 0 && (0, import_node_fs16.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_fs17.rmSync)(timerPath, { force: true });
-    (0, import_node_fs17.rmSync)((0, import_node_path14.join)(unitDir, SYSTEMD_SERVICE_NAME), { force: true });
+    (0, import_node_fs16.rmSync)(timerPath, { force: true });
+    (0, import_node_fs16.rmSync)((0, import_node_path13.join)(unitDir, SYSTEMD_SERVICE_NAME), { force: true });
   } catch {
   }
   systemctlUser(["daemon-reload"]);
@@ -3261,16 +2678,16 @@ function uninstallTask(env = process.env) {
 }
 function dropLauncher(env, file) {
   try {
-    (0, import_node_fs17.rmSync)((0, import_node_path14.join)(statePaths(env).root, file), { force: true });
+    (0, import_node_fs16.rmSync)((0, import_node_path13.join)(statePaths(env).root, file), { force: true });
   } catch {
   }
 }
 
 // src/status.ts
-var import_node_fs18 = require("node:fs");
+var import_node_fs17 = require("node:fs");
 function readJournal(path) {
   try {
-    const events = (0, import_node_fs18.readFileSync)(path, "utf8").split("\n").filter((line) => line.trim()).map((line) => {
+    const events = (0, import_node_fs17.readFileSync)(path, "utf8").split("\n").filter((line) => line.trim()).map((line) => {
       try {
         return JSON.parse(line);
       } catch {
@@ -3307,12 +2724,9 @@ function hubStatus(hubVersion, env = process.env, invokedPath = process.argv[1])
     if (surface.id === "claude") {
       const probe = probeNativeHostInstallation("claude", env);
       actual.set(surface.id, { version: probe.version, staged: probeClaudeLaunchStaging(env), location: probe.location, detail: probe.detail });
-    } else if (surface.id === "codex" || surface.id === "kilo") {
-      const probe = probeNativeHostInstallation(surface.id, env);
+    } else if (surface.id === "codex") {
+      const probe = probeNativeHostInstallation("codex", env);
       actual.set(surface.id, { version: probe.version, staged: null, location: probe.location, detail: probe.detail });
-    } else if (surface.id === "kimi") {
-      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") {
       const probe = probeCursorInstallation();
       actual.set(surface.id, { version: probe.version, staged: probeCursorLaunchStaging(), location: probe.location, detail: probe.detail });
@@ -3325,6 +2739,7 @@ function hubStatus(hubVersion, env = process.env, invokedPath = process.argv[1])
     }
   }
   const installed = {};
+  const retired = retiredSurfaces(realEvents);
   for (const [surface, probe] of actual) {
     const staged = probe.staged ?? null;
     installed[surface] = {
@@ -3332,7 +2747,7 @@ function hubStatus(hubVersion, env = process.env, invokedPath = process.argv[1])
       staged,
       expected: expectedVersion,
       location: probe.location,
-      state: versionState(probe.version, staged, expectedVersion),
+      state: retired.has(surface) ? "retired" : versionState(probe.version, staged, expectedVersion),
       detail: probe.detail
     };
   }
@@ -3342,6 +2757,7 @@ function hubStatus(hubVersion, env = process.env, invokedPath = process.argv[1])
   if (!events.length && !error) failures.push("no maintenance journal yet \u2014 run `mmi-hub install`");
   if (!schedule.ok && schedule.supported) failures.push(schedule.detail);
   for (const [surface, row] of Object.entries(installed)) {
+    if (row.state === "retired") continue;
     if (!row.installed) failures.push(`${surface}: installed version is unreadable at ${row.location ?? "an unknown location"} \u2014 run \`mmi-hub update\``);
     if (row.state === "behind") failures.push(`${surface}: installed ${row.installed} is behind expected ${row.expected} \u2014 run \`mmi-hub update\``);
   }
@@ -3395,10 +2811,8 @@ var MIN_NOTE_SPACE = 8;
 var ACTIVATION_NOTE = {
   claude: "next session",
   codex: "next session",
-  kimi: "next session",
   jervcode: "next launch",
   cursor: "on reload",
-  kilo: "after restart",
   hermes: "after restart",
   updater: "next run"
 };
@@ -3409,7 +2823,7 @@ 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"],
+  [/is running|live process/, "close app, rerun update"],
   [/staging install failed|etarget|e404|network|fetch failed/, "check network/login, rerun"],
   [/not on npm|no green|registry not ready/, "release still publishing"],
   [/elevat|access is denied/, "run from elevated terminal"]
@@ -3672,10 +3086,65 @@ function startSpinner(enabled) {
   };
 }
 
+// src/stamp.ts
+var import_node_fs18 = require("node:fs");
+var ALWAYS_ARMED = ["cli", "updater"];
+var PLUGIN_ARMS = /* @__PURE__ */ new Set(["claude", "codex", "jervcode", "cursor", "hermes"]);
+function fleetStamp(env = process.env) {
+  const paths = statePaths(env);
+  let events = [];
+  try {
+    events = (0, import_node_fs18.readFileSync)(paths.journalPath, "utf8").split("\n").filter((line) => line.trim()).map((line) => {
+      try {
+        return JSON.parse(line);
+      } catch {
+        return null;
+      }
+    }).filter((event) => event !== null);
+  } catch {
+    return "fleet: no journal yet \u2014 MMI Hub maintenance has not run on this machine";
+  }
+  const target = [...events].reverse().find((event) => event.kind === "target" && event.verdict === "ok" && event.to)?.to ?? null;
+  if (!target) {
+    return "fleet: no gated release observed yet (registry not ready is a state, not a failure)";
+  }
+  const lastArm = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    if (event.dryRun) continue;
+    if (event.kind === "arm" && event.surface) lastArm.set(event.surface, event);
+  }
+  const probes = enumerateSurfaces(env);
+  const retired = retiredSurfaces(events);
+  const required = [
+    ...ALWAYS_ARMED,
+    ...probes.filter((probe) => probe.present && PLUGIN_ARMS.has(probe.id) && !retired.has(probe.id)).map((probe) => probe.id)
+  ];
+  const drift = [];
+  const healthy = [];
+  for (const surface of required) {
+    const arm = lastArm.get(surface);
+    if (!arm) {
+      drift.push(`${surface} never converged`);
+    } else if (arm.verdict === "ok" && (arm.to === target || (arm.detail ?? "").includes("already at target"))) {
+      healthy.push(surface);
+    } else {
+      drift.push(`${surface} ${arm.from ?? "absent"} \u2192 ${arm.to ?? "?"} (${arm.verdict})`);
+    }
+  }
+  const pending = probes.filter((probe) => probe.present && !PLUGIN_ARMS.has(probe.id)).map((probe) => probe.id);
+  const retiredPresent = probes.filter((probe) => probe.present && retired.has(probe.id)).map((probe) => probe.id);
+  if (drift.length) {
+    return `fleet drift: target ${target} \u2014 ${drift.join("; ")}`;
+  }
+  const pendingNote = pending.length ? ` \xB7 ${pending.length} surface${pending.length === 1 ? "" : "s"} pending an arm: ${pending.join(" ")}` : "";
+  const retiredNote = retiredPresent.length ? ` \xB7 retired at source: ${retiredPresent.join(" ")}` : "";
+  return `fleet ${target} \u2713 ${healthy.join("\xB7")}${pendingNote}${retiredNote}`;
+}
+
 // src/index.ts
 function ownVersion() {
   try {
-    return JSON.parse((0, import_node_fs19.readFileSync)((0, import_node_path15.join)(__dirname, "..", "package.json"), "utf8")).version;
+    return JSON.parse((0, import_node_fs19.readFileSync)((0, import_node_path14.join)(__dirname, "..", "package.json"), "utf8")).version;
   } catch {
     return "0.0.0";
   }
@@ -3714,7 +3183,7 @@ function handOff(reexec, args, json) {
 
 `);
   }
-  const child = (0, import_node_child_process12.spawnSync)(process.execPath, [reexec.dist, ...args], {
+  const child = (0, import_node_child_process10.spawnSync)(process.execPath, [reexec.dist, ...args], {
     stdio: "inherit",
     windowsHide: true,
     env: { ...process.env, MMI_UPDATER_REEXEC: "1" }
@@ -3840,6 +3309,7 @@ if (typeof require !== "undefined" && require.main === module) {
   clearPending,
   enumerateSurfaces,
   failConsequence,
+  fleetStamp,
   formatReconcileReport,
   hermesArm,
   hermesHome,
@@ -3865,15 +3335,14 @@ if (typeof require !== "undefined" && require.main === module) {
   probeHermesInstallation,
   probeHermesLaunchStaging,
   probeJervcodeInstallation,
-  probeKimiLaunchStaging,
   probeLaunchTargetVersion,
   progressiveRow,
   readLaunchTarget,
   readPending,
   reconcileCursorUserHooks,
-  reconcileKimiInstalledPlugin,
   releaseSharedDocLock,
   reportFooterLines,
+  retiredSurfaces,
   retryHint,
   schedulePendingWatcher,
   schedulerStatus,
@@ -3882,11 +3351,11 @@ if (typeof require !== "undefined" && require.main === module) {
   sharedDocLockTimeoutReceipt,
   shouldHandOff,
   startSpinner,
+  surfaceArmPlan,
   systemdServiceUnit,
   systemdTimerUnit,
   taskXml,
   updateHeader,
-  validateKimiInstalledPlugin,
   watcherLockPath,
   withSharedDocLock,
   wrapWords,