@mutmutco/hub 4.1.9 → 4.1.10

package/dist/index.cjs

@@ -23,6 +23,8 @@ var index_exports = {};
 __export(index_exports, {
   acquireSharedDocLock: () => acquireSharedDocLock,
   buildWatcherCommand: () => buildWatcherCommand,
+  claudeArm: () => claudeArm,
+  claudeHostEvidence: () => claudeHostEvidence,
   clearLaunchTarget: () => clearLaunchTarget,
   clearPending: () => clearPending,
   enumerateSurfaces: () => enumerateSurfaces,
@@ -30,7 +32,9 @@ __export(index_exports, {
   formatReconcileReport: () => formatReconcileReport,
   hermesArm: () => hermesArm,
   hermesHome: () => hermesHome,
+  hermesHostCommand: () => hermesHostCommand,
   hermesHostEvidence: () => hermesHostEvidence,
+  hermesHostPresent: () => hermesHostPresent,
   hubStatus: () => hubStatus,
   launchdPlist: () => launchdPlist,
   launcherSh: () => launcherSh,
@@ -45,6 +49,7 @@ __export(index_exports, {
   parseNpmDistIntegrity: () => parseNpmDistIntegrity,
   pendingPath: () => pendingPath,
   pidAlive: () => pidAlive,
+  probeClaudeLaunchStaging: () => probeClaudeLaunchStaging,
   probeCursorLaunchStaging: () => probeCursorLaunchStaging,
   probeHermesInstallation: () => probeHermesInstallation,
   probeHermesLaunchStaging: () => probeHermesLaunchStaging,
@@ -400,66 +405,39 @@ function checkAtomicity(cachePath, tagCommit, bom, candidate, npm) {
 }
 
 // src/surfaces.ts
-var import_node_fs4 = require("node:fs");
+var import_node_fs8 = require("node:fs");
+var import_node_os3 = require("node:os");
+var import_node_path7 = require("node:path");
+
+// src/arm-host-plugins.ts
+var import_node_child_process5 = require("node:child_process");
+var import_node_fs7 = require("node:fs");
 var import_node_os2 = require("node:os");
-var import_node_path3 = require("node:path");
-function kimiHome(env = process.env) {
-  return env.KIMI_CODE_HOME?.trim() || (0, import_node_path3.join)((0, import_node_os2.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_path3.join)((0, import_node_os2.homedir)(), ".jerv", "agent");
-}
-function hermesHome(env = process.env, platform = process.platform) {
-  if (env.HERMES_HOME?.trim()) return env.HERMES_HOME.trim();
-  if (platform === "win32") return (0, import_node_path3.join)(env.LOCALAPPDATA?.trim() || (0, import_node_path3.join)((0, import_node_os2.homedir)(), "AppData", "Local"), "hermes");
-  return (0, import_node_path3.join)((0, import_node_os2.homedir)(), ".hermes");
-}
-function enumerateSurfaces(env = process.env) {
-  const home = (0, import_node_os2.homedir)();
-  const codexHome = env.CODEX_HOME || (0, import_node_path3.join)(home, ".codex");
-  return [
-    { id: "claude", marker: (0, import_node_path3.join)(home, ".claude", "plugins", "installed_plugins.json") },
-    { id: "codex", marker: (0, import_node_path3.join)(codexHome, "plugins", "installed_plugins.json") },
-    // The host, not the payload (#4951, #5356): this marker used to be plugins/local/mmi — the MMI
-    // plugin tree itself — so a machine running Cursor WITHOUT the plugin enumerated as "no Cursor"
-    // 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_path3.join)(home, ".cursor") },
-    { id: "kilo", marker: (0, import_node_path3.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_path3.join)(jervcodeAgentDir(env), "settings.json") },
-    // The host root is the marker, not plugins/mmi: an installed Hermes without MMI must be
-    // discovered so its native plugin tree can be converged for the first time.
-    { id: "hermes", marker: hermesHome(env) }
-  ].map((probe) => ({ ...probe, present: (0, import_node_fs4.existsSync)(probe.marker) }));
-}
+var import_node_path6 = require("node:path");
 
-// src/arm-cli.ts
-var import_node_fs6 = require("node:fs");
+// src/arm-npm-global.ts
+var import_node_fs5 = require("node:fs");
 var import_node_child_process4 = require("node:child_process");
-var import_node_path5 = require("node:path");
+var import_node_path4 = require("node:path");
 
 // src/pending.ts
 var import_node_child_process3 = require("node:child_process");
-var import_node_fs5 = require("node:fs");
-var import_node_path4 = require("node:path");
+var import_node_fs4 = require("node:fs");
+var import_node_path3 = require("node:path");
 function hubDistPath(env) {
   const root = globalRoot(env);
-  return root ? (0, import_node_path4.join)(root, "@mutmutco", "hub", "dist", "index.cjs") : null;
+  return root ? (0, import_node_path3.join)(root, "@mutmutco", "hub", "dist", "index.cjs") : null;
 }
 var WATCHER_MAX_WAIT_MS = 4 * 60 * 60 * 1e3;
 function pendingPath(paths) {
-  return (0, import_node_path4.join)(paths.root, "pending.json");
+  return (0, import_node_path3.join)(paths.root, "pending.json");
 }
 function watcherLockPath(paths) {
-  return (0, import_node_path4.join)(paths.root, "pending-watcher.lock.d");
+  return (0, import_node_path3.join)(paths.root, "pending-watcher.lock.d");
 }
 function readPending(paths) {
   try {
-    const parsed = JSON.parse((0, import_node_fs5.readFileSync)(pendingPath(paths), "utf8"));
+    const parsed = JSON.parse((0, import_node_fs4.readFileSync)(pendingPath(paths), "utf8"));
     if (!Array.isArray(parsed)) return [];
     return parsed.filter((row) => Boolean(row) && typeof row === "object" && typeof row.surface === "string" && typeof row.target === "string" && Array.isArray(row.images) && Array.isArray(row.dirs));
   } catch {
@@ -467,12 +445,12 @@ function readPending(paths) {
   }
 }
 function writePending(paths, records) {
-  (0, import_node_fs5.mkdirSync)(paths.root, { recursive: true });
+  (0, import_node_fs4.mkdirSync)(paths.root, { recursive: true });
   const path = pendingPath(paths);
   const tmp = `${path}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
-  (0, import_node_fs5.writeFileSync)(tmp, `${JSON.stringify(records, null, 2)}
+  (0, import_node_fs4.writeFileSync)(tmp, `${JSON.stringify(records, null, 2)}
 `, "utf8");
-  (0, import_node_fs5.renameSync)(tmp, path);
+  (0, import_node_fs4.renameSync)(tmp, path);
 }
 function clearPending(paths, surface) {
   const records = readPending(paths);
@@ -541,14 +519,14 @@ function schedulePendingWatcher(paths, env = process.env, seam = {}) {
   const live = records.find((row) => row.watcherPid && pidAlive(row.watcherPid));
   if (live) return { scheduled: false, reason: `watcher pid ${live.watcherPid} is already waiting` };
   const hubDist = seam.hubDist ?? hubDistPath(env);
-  if (!hubDist || !(0, import_node_fs5.existsSync)(hubDist)) return { scheduled: false, reason: "the installed hub bundle is unresolvable \u2014 the hourly tick remains the retry" };
+  if (!hubDist || !(0, import_node_fs4.existsSync)(hubDist)) return { scheduled: false, reason: "the installed hub bundle is unresolvable \u2014 the hourly tick remains the retry" };
   const command = buildWatcherCommand({
     images: [...new Set(records.flatMap((row) => row.images))],
     dirs: [...new Set(records.flatMap((row) => row.dirs))],
     node: process.execPath,
     hubDist,
-    codePath: (0, import_node_path4.join)(paths.root, "pending-result.code"),
-    logPath: (0, import_node_path4.join)(paths.root, "pending-result.log"),
+    codePath: (0, import_node_path3.join)(paths.root, "pending-result.code"),
+    logPath: (0, import_node_path3.join)(paths.root, "pending-result.log"),
     lockPath: watcherLockPath(paths)
   });
   try {
@@ -584,88 +562,14 @@ function resumePendingWatcher(paths, env = process.env) {
   return schedulePendingWatcher(paths, env);
 }
 
-// src/arm-cli.ts
-function globalCliDist(env) {
-  const root = globalRoot(env);
-  return root ? (0, import_node_path5.join)(root, "@mutmutco", "cli", "dist", "index.cjs") : null;
-}
-function probeCliVersion(distPath) {
-  if (!fileExists(distPath)) return null;
-  const probe = (0, import_node_child_process4.spawnSync)(process.execPath, [distPath, "--version"], { encoding: "utf8", windowsHide: true });
-  const version = (probe.stdout || "").trim();
-  return probe.status === 0 && /^\d+\.\d+\.\d+/.test(version) ? version : null;
-}
-function probeCliInstallation(env = process.env) {
-  const location = globalCliDist(env);
-  const version = location ? probeCliVersion(location) : null;
-  return { version, location, detail: version ? `absolute binary reported ${version}` : "global @mutmutco/cli binary was not readable" };
-}
-function cliArm(options) {
-  const env = options.env ?? process.env;
-  const { target, dryRun, paths } = options;
-  const dist = globalCliDist(env);
-  const installed = dist ? probeCliVersion(dist) : null;
-  if (installed && compareSemver(installed, target) > 0) {
-    return { surface: "cli", from: installed, to: installed, verdict: "skip", detail: `installed ${installed} is above candidate ${target} (monotonic)` };
-  }
-  const highWater = journalHighWater(paths.journalPath, "cli");
-  if (highWater && compareSemver(highWater, target) > 0) {
-    return { surface: "cli", from: installed, to: highWater, verdict: "skip", detail: `journal high-water ${highWater} is above candidate ${target} (monotonic)` };
-  }
-  if (installed === target) {
-    return { surface: "cli", from: installed, to: target, verdict: "ok", detail: `already at target ${target}` };
-  }
-  if (dryRun) {
-    return { surface: "cli", from: installed, to: target, verdict: "ok", detail: `dry-run: would converge ${installed ?? "absent"} -> ${target}` };
-  }
-  const stageRoot = (0, import_node_path5.join)(paths.staging, "cli", target);
-  const stageDist = (0, import_node_path5.join)(stageRoot, "node_modules", "@mutmutco", "cli", "dist", "index.cjs");
-  if (!fileExists(stageDist)) {
-    (0, import_node_fs6.mkdirSync)(stageRoot, { recursive: true });
-    (0, import_node_fs6.writeFileSync)((0, import_node_path5.join)(stageRoot, "package.json"), JSON.stringify({ name: "mmi-updater-stage", private: true }) + "\n");
-    const install = runNpm(["install", "--prefix", stageRoot, "--no-audit", "--no-fund", "--no-package-lock", `@mutmutco/cli@${target}`], env);
-    if (install.status !== 0) {
-      return { surface: "cli", from: installed, to: target, verdict: "defer", detail: `staging install failed: ${(install.stderr || install.stdout).split("\n").filter(Boolean).slice(-3).join(" | ")}` };
-    }
-  }
-  let stagedManifestVersion;
-  try {
-    stagedManifestVersion = JSON.parse((0, import_node_fs6.readFileSync)((0, import_node_path5.join)(stageRoot, "node_modules", "@mutmutco", "cli", "package.json"), "utf8")).version;
-  } catch {
-  }
-  if (stagedManifestVersion !== target) {
-    return { surface: "cli", from: installed, to: target, verdict: "defer", detail: `staged manifest is ${stagedManifestVersion ?? "unreadable"}, expected ${target}` };
-  }
-  const stagedVersion = probeCliVersion(stageDist);
-  if (stagedVersion !== target) {
-    return { surface: "cli", from: installed, to: target, verdict: "defer", detail: `staged binary probed ${stagedVersion ?? "dead"}, expected ${target}` };
-  }
-  const globalInstall = runNpm(["install", "-g", "--no-audit", "--no-fund", `@mutmutco/cli@${target}`], env);
-  if (globalInstall.status !== 0) {
-    const reason = `global install failed: ${(globalInstall.stderr || globalInstall.stdout).split("\n").filter(Boolean).slice(-3).join(" | ")}`;
-    const root = globalRoot(env);
-    const pending = lockShaped(reason) && root ? ` \u2014 ${noteBusyDefer(paths, env, { surface: "cli", target, reason, dirs: [root] })}` : "";
-    return { surface: "cli", from: installed, to: target, verdict: "defer", detail: `${reason}${pending}` };
-  }
-  const switchedDist = globalCliDist(env);
-  const switched = probeCliVersion(switchedDist ?? "");
-  if (switched !== target) {
-    return { surface: "cli", from: installed, to: switched ?? installed ?? "unknown", verdict: "fail", detail: `post-switch probe returned ${switched ?? "dead"} at ${switchedDist ?? "an unresolvable path"}, expected ${target}; the global install already ran \u2014 nothing was rolled back` };
-  }
-  return { surface: "cli", from: installed, to: target, verdict: "ok", detail: `converged ${installed ?? "absent"} -> ${target} (staged, verified, switched)` };
-}
-
 // src/arm-npm-global.ts
-var import_node_fs7 = require("node:fs");
-var import_node_child_process5 = require("node:child_process");
-var import_node_path6 = require("node:path");
 function globalDist(env, packageName, distRel) {
   const root = globalRoot(env);
-  return root ? (0, import_node_path6.join)(root, ...packageName.split("/"), ...distRel.split("/")) : null;
+  return root ? (0, import_node_path4.join)(root, ...packageName.split("/"), ...distRel.split("/")) : null;
 }
 function probeVersion(distPath) {
   if (!fileExists(distPath)) return null;
-  const probe = (0, import_node_child_process5.spawnSync)(process.execPath, [distPath, "--version"], { encoding: "utf8", windowsHide: true });
+  const probe = (0, import_node_child_process4.spawnSync)(process.execPath, [distPath, "--version"], { encoding: "utf8", windowsHide: true });
   const version = (probe.stdout || "").trim();
   return probe.status === 0 && /^\d+\.\d+\.\d+/.test(version) ? version : null;
 }
@@ -674,11 +578,11 @@ function tail(output) {
 }
 function stagePackage(options) {
   const { surface, packageName, target, witness, paths, env } = options;
-  const stageRoot = (0, import_node_path6.join)(paths.staging, surface, target);
-  const packageRoot = (0, import_node_path6.join)(stageRoot, "node_modules", ...packageName.split("/"));
-  if (!fileExists((0, import_node_path6.join)(packageRoot, ...witness.split("/")))) {
-    (0, import_node_fs7.mkdirSync)(stageRoot, { recursive: true });
-    (0, import_node_fs7.writeFileSync)((0, import_node_path6.join)(stageRoot, "package.json"), JSON.stringify({ name: "mmi-updater-stage", private: true }) + "\n");
+  const stageRoot = (0, import_node_path4.join)(paths.staging, surface, target);
+  const packageRoot = (0, import_node_path4.join)(stageRoot, "node_modules", ...packageName.split("/"));
+  if (!fileExists((0, import_node_path4.join)(packageRoot, ...witness.split("/")))) {
+    (0, import_node_fs5.mkdirSync)(stageRoot, { recursive: true });
+    (0, import_node_fs5.writeFileSync)((0, import_node_path4.join)(stageRoot, "package.json"), JSON.stringify({ name: "mmi-updater-stage", private: true }) + "\n");
     const install = runNpm(["install", "--prefix", stageRoot, "--no-audit", "--no-fund", "--no-package-lock", `${packageName}@${target}`], env);
     if (install.status !== 0) {
       return { defer: `staging install failed: ${tail(install.stderr || install.stdout)}` };
@@ -686,7 +590,7 @@ function stagePackage(options) {
   }
   let stagedManifestVersion;
   try {
-    stagedManifestVersion = JSON.parse((0, import_node_fs7.readFileSync)((0, import_node_path6.join)(packageRoot, "package.json"), "utf8")).version;
+    stagedManifestVersion = JSON.parse((0, import_node_fs5.readFileSync)((0, import_node_path4.join)(packageRoot, "package.json"), "utf8")).version;
   } catch {
   }
   if (stagedManifestVersion !== target) {
@@ -718,7 +622,7 @@ function npmGlobalArm(options) {
   if ("defer" in staged) {
     return result(installed, target, "defer", staged.defer);
   }
-  const stageDist = (0, import_node_path6.join)(staged.packageRoot, ...distRel.split("/"));
+  const stageDist = (0, import_node_path4.join)(staged.packageRoot, ...distRel.split("/"));
   const stagedVersion = probeVersion(stageDist);
   if (stagedVersion !== target) {
     return result(installed, target, "defer", `staged binary probed ${stagedVersion ?? "dead"}, expected ${target}`);
@@ -738,21 +642,56 @@ function npmGlobalArm(options) {
   return result(installed, target, "ok", `converged ${installed ?? "absent"} -> ${target} (staged, verified, switched)`);
 }
 
-// src/arm-self.ts
-function selfArm(options) {
-  return npmGlobalArm({
-    surface: "updater",
-    packageName: "@mutmutco/hub",
-    distRel: "dist/index.cjs",
-    ...options
+// src/launch-staging.ts
+var import_node_fs6 = require("node:fs");
+var import_node_path5 = require("node:path");
+function readLaunchTarget(path) {
+  try {
+    const parsed = JSON.parse((0, import_node_fs6.readFileSync)(path, "utf8"));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+    const row = parsed;
+    if (typeof row.surface !== "string" || typeof row.target !== "string" || typeof row.since !== "string" || typeof row.incoming !== "string") return null;
+    return row;
+  } catch {
+    return null;
+  }
+}
+function writeLaunchTarget(path, record) {
+  (0, import_node_fs6.mkdirSync)((0, import_node_path5.join)(path, ".."), { recursive: true });
+  const tmp = `${path}.tmp-${process.pid}-${Math.random().toString(36).slice(2)}`;
+  (0, import_node_fs6.writeFileSync)(tmp, `${JSON.stringify(record, null, 2)}
+`, "utf8");
+  (0, import_node_fs6.renameSync)(tmp, path);
+}
+function clearLaunchTarget(path) {
+  try {
+    (0, import_node_fs6.rmSync)(path, { force: true });
+  } catch {
+  }
+}
+function noteLaunchStaged(paths, env, options, seam = {}) {
+  writeLaunchTarget(options.launchTargetPath, {
+    surface: options.surface,
+    target: options.target,
+    since: (/* @__PURE__ */ new Date()).toISOString(),
+    incoming: options.incoming
   });
+  return noteBusyDefer(paths, env, {
+    surface: options.surface,
+    target: options.target,
+    reason: options.reason,
+    images: options.images,
+    dirs: options.dirs
+  }, seam);
+}
+function probeLaunchTargetVersion(launchTargetPath, versionAt) {
+  const record = readLaunchTarget(launchTargetPath);
+  if (!record || !(0, import_node_fs6.existsSync)(record.incoming)) return null;
+  const version = versionAt(record.incoming);
+  return version === record.target ? record.target : null;
 }
 
 // src/arm-host-plugins.ts
-var import_node_child_process6 = require("node:child_process");
-var import_node_fs8 = require("node:fs");
-var import_node_os3 = require("node:os");
-var import_node_path7 = require("node:path");
 var REPO_URL_DEFAULT = "https://github.com/mutmutco/MMI-Hub.git";
 var MMI_MARKETPLACE_REPO = "mutmutco/MMI-Hub";
 function convergedAtOrAbove(installed, target, healthy) {
@@ -762,13 +701,13 @@ function cmdArg(value) {
   return /^[A-Za-z0-9_@./:\\=+-]+$/.test(value) ? value : `"${value.replaceAll('"', '""')}"`;
 }
 var runHostCommand = (command, args, env) => {
-  const result = process.platform === "win32" ? (0, import_node_child_process6.spawnSync)("cmd.exe", ["/d", "/s", "/c", [command, ...args].map(cmdArg).join(" ")], {
+  const result = process.platform === "win32" ? (0, import_node_child_process5.spawnSync)("cmd.exe", ["/d", "/s", "/c", [command, ...args].map(cmdArg).join(" ")], {
     encoding: "utf8",
     env,
     input: "",
     timeout: 12e4,
     windowsHide: true
-  }) : (0, import_node_child_process6.spawnSync)(command, args, {
+  }) : (0, import_node_child_process5.spawnSync)(command, args, {
     encoding: "utf8",
     env,
     input: "",
@@ -794,14 +733,18 @@ function claudeMmi(runner, env) {
   if (!Array.isArray(parsed)) return { row: null, error: `claude plugin list --json failed: ${failure(result)}` };
   return { row: parsed.find((row) => row.id === "mmi@mutmutco") ?? null };
 }
+function claudeHomeDir(env) {
+  const home = env.HOME?.trim() || env.USERPROFILE?.trim() || (0, import_node_os2.homedir)();
+  return (0, import_node_path6.join)(home, ".claude");
+}
 function claudeMarketplacesPath(env) {
-  return env.MMI_UPDATER_CLAUDE_MARKETPLACES || (0, import_node_path7.join)((0, import_node_os3.homedir)(), ".claude", "plugins", "known_marketplaces.json");
+  return env.MMI_UPDATER_CLAUDE_MARKETPLACES || (0, import_node_path6.join)(claudeHomeDir(env), "plugins", "known_marketplaces.json");
 }
 function ensureClaudeMarketplace(env) {
   const path = claudeMarketplacesPath(env);
   let body;
   try {
-    body = JSON.parse((0, import_node_fs8.readFileSync)(path, "utf8"));
+    body = JSON.parse((0, import_node_fs7.readFileSync)(path, "utf8"));
   } catch (error) {
     if (error?.code === "ENOENT") return { ok: false, detail: `${path} does not exist \u2014 mutmutco marketplace is not registered`, unregistered: true };
     return { ok: false, detail: `cannot read ${path}` };
@@ -821,54 +764,185 @@ function ensureClaudeMarketplace(env) {
   }
   return { ok: true };
 }
+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"];
+function claudePluginsRoot(env) {
+  return (0, import_node_path6.join)(claudeHomeDir(env), "plugins");
+}
+function claudeMarkerVersion(root) {
+  try {
+    const version = JSON.parse((0, import_node_fs7.readFileSync)((0, import_node_path6.join)(root, ...CLAUDE_MANIFEST.split("/")), "utf8")).version;
+    return typeof version === "string" ? version : null;
+  } catch {
+    return null;
+  }
+}
+function claudeTreeHealthy(root) {
+  return CLAUDE_TREE_MARKERS.every((rel) => fileExists((0, import_node_path6.join)(root, ...rel.split("/"))));
+}
+var CLAUDE_PROCESS_SEGMENT = /^claude(-code|-cli)?(\.(exe|cmd|bat|ps1|js|mjs|cjs|py))?$/i;
+var HUB_UPDATE_COMMAND = /(?:\bmmi-hub(?:\.(?:cmd|exe|bat|ps1))?\b|@mutmutco[/\\]hub[/\\]dist[/\\]index\.(?:cjs|mjs|js))[\s'"]+update\b/i;
+function claudeProcessToken(line) {
+  if (HUB_UPDATE_COMMAND.test(line)) return null;
+  for (const token of line.replace(/["']/g, " ").split(/\s+/)) {
+    for (const segment of token.split(/[/\\]/)) {
+      if (CLAUDE_PROCESS_SEGMENT.test(segment)) return segment;
+    }
+  }
+  return null;
+}
+function realClaudeProcessListing() {
+  const result = process.platform === "win32" ? (0, import_node_child_process5.spawnSync)("powershell.exe", ["-NoProfile", "-Command", "Get-CimInstance Win32_Process | ForEach-Object { $_.Name + ' ' + $_.CommandLine }"], { encoding: "utf8", windowsHide: true, timeout: 15e3 }) : (0, import_node_child_process5.spawnSync)("ps", ["-eo", "args="], { encoding: "utf8", windowsHide: true, timeout: 15e3 });
+  return result.status === 0 ? result.stdout ?? "" : null;
+}
+function claudeHostEvidence(env, processListProvider) {
+  for (const marker of ["CLAUDE_CODE_SESSION_ID", "CLAUDECODE", "CLAUDE_PLUGIN_ROOT"]) {
+    if (env[marker]?.trim()) return `env marker ${marker}`;
+  }
+  const listing = processListProvider ? processListProvider() : realClaudeProcessListing();
+  if (listing === null || !listing.trim()) return "the process list is unreadable (unsafe to write)";
+  for (const line of listing.split(/\r?\n/)) {
+    const token = claudeProcessToken(line);
+    if (token) return `a live process names claude (${token})`;
+  }
+  return null;
+}
+function probeClaudeLaunchStaging(env = process.env) {
+  return probeLaunchTargetVersion((0, import_node_path6.join)(claudePluginsRoot(env), "staging", "launch-target.json"), claudeMarkerVersion);
+}
 function claudeArm(options) {
   const env = options.env ?? process.env;
   const runner = options.runner ?? runHostCommand;
+  const paths = options.paths ?? ensureState(env);
+  const target = options.target;
   const repoUrl = options.repoUrl ?? (env.MMI_UPDATER_REPO || REPO_URL_DEFAULT);
+  const home = claudeHomeDir(env);
+  const result = (from2, to, verdict, detail, launchStaged = false) => ({
+    surface: "claude",
+    from: from2,
+    to,
+    verdict,
+    detail,
+    launchStaged: launchStaged || void 0
+  });
   const before = claudeMmi(runner, env);
-  if (before.error) return { surface: "claude", from: null, to: options.target, verdict: "defer", detail: before.error };
+  if (before.error) return result(null, target, "defer", before.error);
   const from = before.row?.version ?? null;
+  if (from && compareSemver(from, target) > 0) {
+    return result(from, from, "skip", `installed ${from} is above candidate ${target} (monotonic)`);
+  }
+  const highWater = journalHighWater(paths.journalPath, "claude");
+  if (highWater && compareSemver(highWater, target) > 0) {
+    return result(from, highWater, "skip", `journal high-water ${highWater} is above candidate ${target} (monotonic)`);
+  }
   let marketplaceTrust = ensureClaudeMarketplace(env);
   if (!marketplaceTrust.ok && marketplaceTrust.unregistered) {
     const add = runner("claude", ["plugin", "marketplace", "add", repoUrl], env);
-    if (add.status !== 0) return { surface: "claude", from, to: options.target, verdict: "defer", detail: `mutmutco marketplace was not registered and marketplace add failed: ${failure(add)}` };
+    if (add.status !== 0) return result(from, target, "defer", `mutmutco marketplace was not registered and marketplace add failed: ${failure(add)}`);
     marketplaceTrust = ensureClaudeMarketplace(env);
   }
-  if (!marketplaceTrust.ok) return { surface: "claude", from, to: options.target, verdict: "defer", detail: marketplaceTrust.detail ?? "cannot trust the mutmutco marketplace registration" };
+  if (!marketplaceTrust.ok) return result(from, target, "defer", marketplaceTrust.detail ?? "cannot trust the mutmutco marketplace registration");
+  const pluginsRoot = claudePluginsRoot(env);
+  const launchTargetPath = (0, import_node_path6.join)(pluginsRoot, "staging", "launch-target.json");
   if (options.dryRun) {
-    return { surface: "claude", from, to: options.target, verdict: "ok", detail: `dry-run: would refresh mutmutco and converge mmi@mutmutco ${from ?? "absent"} -> ${options.target}` };
+    return result(from, target, "ok", `dry-run: would refresh mutmutco, stage ${target} on the Claude volume, and converge mmi@mutmutco ${from ?? "absent"} -> ${target}`);
   }
   const marketplace = runner("claude", ["plugin", "marketplace", "update", "mutmutco"], env);
   if (marketplace.status !== 0) {
-    return { surface: "claude", from, to: options.target, verdict: "defer", detail: `marketplace update failed: ${failure(marketplace)}` };
+    return result(from, target, "defer", `marketplace update failed: ${failure(marketplace)}`);
   }
   let observed = claudeMmi(runner, env);
-  if (observed.error) return { surface: "claude", from, to: options.target, verdict: "defer", detail: observed.error };
-  if (observed.row?.version === options.target && observed.row.enabled === true) {
-    return { surface: "claude", from, to: options.target, verdict: "ok", detail: `catalog refreshed; installed+enabled at target ${options.target}` };
+  if (observed.error) return result(from, target, "defer", observed.error);
+  if (observed.row?.version === target && observed.row.enabled === true) {
+    clearLaunchTarget(launchTargetPath);
+    return result(from, target, "ok", `catalog refreshed; installed+enabled at target ${target}`);
+  }
+  const incomingRoot = (0, import_node_path6.join)(pluginsRoot, "staging", "incoming");
+  const incoming = (0, import_node_path6.join)(incomingRoot, target);
+  const priorLaunch = readLaunchTarget(launchTargetPath);
+  const reuseIncoming = priorLaunch?.target === target && priorLaunch.incoming === incoming && claudeMarkerVersion(incoming) === target && claudeTreeHealthy(incoming);
+  if (!reuseIncoming) {
+    const staged = stagePackage({ surface: "claude", packageName: CLAUDE_PACKAGE, target, witness: CLAUDE_MANIFEST, paths, env });
+    if ("defer" in staged) return result(from, target, "defer", staged.defer);
+    if (claudeMarkerVersion(staged.packageRoot) !== target || !claudeTreeHealthy(staged.packageRoot)) {
+      return result(from, target, "defer", `staged Claude manifest is ${claudeMarkerVersion(staged.packageRoot) ?? "unreadable"} or its tree is incomplete (expected ${target})`);
+    }
+    try {
+      (0, import_node_fs7.mkdirSync)((0, import_node_path6.join)(pluginsRoot, "staging"), { recursive: true });
+      (0, import_node_fs7.rmSync)(incomingRoot, { recursive: true, force: true });
+      (0, import_node_fs7.cpSync)(staged.packageRoot, incoming, { recursive: true });
+    } catch (error) {
+      return result(from, target, "defer", `cannot place incoming Claude generation: ${error?.message ?? error}`);
+    }
+    if (claudeMarkerVersion(incoming) !== target || !claudeTreeHealthy(incoming)) {
+      (0, import_node_fs7.rmSync)(incomingRoot, { recursive: true, force: true });
+      return result(from, target, "defer", "incoming Claude generation did not reproduce the verified payload");
+    }
+  }
+  const busy = claudeHostEvidence(env, options.processListProvider);
+  if (busy) {
+    const pending = noteLaunchStaged(paths, env, {
+      surface: "claude",
+      target,
+      reason: busy,
+      launchTargetPath,
+      incoming,
+      images: ["claude"],
+      dirs: [home]
+    });
+    return result(from, target, "ok", `staged ${target} for next launch while Claude Code is running (${busy}) \u2014 ${pending}`, true);
+  }
+  const started = claudeHostEvidence(env, options.processListProvider);
+  if (started) {
+    const pending = noteLaunchStaged(paths, env, {
+      surface: "claude",
+      target,
+      reason: started,
+      launchTargetPath,
+      incoming,
+      images: ["claude"],
+      dirs: [home]
+    });
+    return result(from, target, "ok", `staged ${target} for next launch \u2014 Claude Code started during staging (${started}) \u2014 ${pending}`, true);
+  }
+  const cacheTarget = (0, import_node_path6.join)(pluginsRoot, "cache", "mutmutco", "mmi", target);
+  try {
+    if (!(0, import_node_fs7.existsSync)(cacheTarget) || claudeMarkerVersion(cacheTarget) !== target || !claudeTreeHealthy(cacheTarget)) {
+      (0, import_node_fs7.rmSync)(cacheTarget, { recursive: true, force: true });
+      (0, import_node_fs7.mkdirSync)((0, import_node_path6.join)(cacheTarget, ".."), { recursive: true });
+      (0, import_node_fs7.cpSync)(incoming, cacheTarget, { recursive: true });
+    }
+  } catch (error) {
+    return result(from, target, "defer", `cannot populate Claude plugin cache: ${error?.message ?? error}`);
   }
   const scope = observed.row?.scope || before.row?.scope || "user";
   const command = observed.row ? ["plugin", "update", "mmi@mutmutco", "--scope", scope] : ["plugin", "install", "mmi@mutmutco", "--scope", scope];
   const converge = runner("claude", command, env);
   if (converge.status !== 0) {
-    return { surface: "claude", from, to: options.target, verdict: "defer", detail: `${observed.row ? "plugin update" : "plugin install"} failed: ${failure(converge)}` };
+    return result(from, target, "defer", `${observed.row ? "plugin update" : "plugin install"} failed: ${failure(converge)}`);
   }
   observed = claudeMmi(runner, env);
-  if (observed.error) return { surface: "claude", from, to: options.target, verdict: "defer", detail: observed.error };
-  if (observed.row && observed.row.version === options.target && observed.row.enabled !== true) {
+  if (observed.error) return result(from, target, "defer", observed.error);
+  if (observed.row && observed.row.version === target && observed.row.enabled !== true) {
     const enable = runner("claude", ["plugin", "enable", "mmi@mutmutco", "--scope", observed.row.scope || scope], env);
     if (enable.status !== 0) {
-      return { surface: "claude", from, to: options.target, verdict: "defer", detail: `plugin enable failed: ${failure(enable)}` };
+      return result(from, target, "defer", `plugin enable failed: ${failure(enable)}`);
     }
     observed = claudeMmi(runner, env);
   }
-  if (!convergedAtOrAbove(observed.row?.version, options.target, observed.row?.enabled === true)) {
-    return { surface: "claude", from, to: observed.row?.version ?? "unknown", verdict: "fail", detail: `post-update evidence is version ${observed.row?.version ?? "missing"}, enabled=${String(observed.row?.enabled)}, expected ${options.target}/true` };
+  if (!convergedAtOrAbove(observed.row?.version, target, observed.row?.enabled === true)) {
+    return result(from, observed.row?.version ?? "unknown", "fail", `post-update evidence is version ${observed.row?.version ?? "missing"}, enabled=${String(observed.row?.enabled)}, expected ${target}/true`);
   }
-  if (observed.row.version !== options.target) {
-    return { surface: "claude", from, to: observed.row.version, verdict: "skip", detail: `installed ${observed.row.version} is above candidate ${options.target} (monotonic)` };
+  if (observed.row.version !== target) {
+    return result(from, observed.row.version, "skip", `installed ${observed.row.version} is above candidate ${target} (monotonic)`);
   }
-  return { surface: "claude", from, to: options.target, verdict: "ok", detail: `catalog refreshed; converged and verified ${from ?? "absent"} -> ${options.target}` };
+  clearLaunchTarget(launchTargetPath);
+  try {
+    (0, import_node_fs7.rmSync)(incomingRoot, { recursive: true, force: true });
+  } catch {
+  }
+  return result(from, target, "ok", `catalog refreshed; converged and verified ${from ?? "absent"} -> ${target}`);
 }
 var SNAPSHOT_MISSING = /marketplace snapshot|marketplace root does not contain/i;
 function codexMmi(runner, env) {
@@ -927,11 +1001,11 @@ function codexArm(options) {
 }
 var KILO_PACKAGE = "@mutmutco/kilo-plugin";
 function kiloConfigPath(env) {
-  return env.MMI_UPDATER_KILO_CONFIG || (0, import_node_path7.join)((0, import_node_os3.homedir)(), ".config", "kilo", "opencode.json");
+  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_fs8.readFileSync)(kiloConfigPath(env), "utf8"));
+    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 {
@@ -951,8 +1025,8 @@ function normalizeKiloConfig(env, exact) {
   const path = kiloConfigPath(env);
   const tmp = `${path}.tmp-${process.pid}`;
   try {
-    (0, import_node_fs8.writeFileSync)(tmp, JSON.stringify({ ...current.config, plugin: next }, null, 2) + "\n", "utf8");
-    (0, import_node_fs8.renameSync)(tmp, path);
+    (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}`;
@@ -1014,71 +1088,150 @@ function kiloArm(options) {
   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");
+}
+function hermesHome(env = process.env, platform = process.platform) {
+  if (env.HERMES_HOME?.trim()) return env.HERMES_HOME.trim();
+  if (platform === "win32") return (0, import_node_path7.join)(env.LOCALAPPDATA?.trim() || (0, import_node_path7.join)((0, import_node_os3.homedir)(), "AppData", "Local"), "hermes");
+  return (0, import_node_path7.join)((0, import_node_os3.homedir)(), ".hermes");
+}
+function hermesHostCommand(env = process.env) {
+  return env.MMI_UPDATER_HERMES?.trim() || "hermes";
+}
+function hermesHostPresent(env = process.env, runner = runHostCommand) {
+  return runner(hermesHostCommand(env), ["--version"], env).status === 0;
+}
+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");
+  return [
+    { id: "claude", marker: (0, import_node_path7.join)(home, ".claude", "plugins", "installed_plugins.json") },
+    { id: "codex", marker: (0, import_node_path7.join)(codexHome, "plugins", "installed_plugins.json") },
+    // The host, not the payload (#4951, #5356): this marker used to be plugins/local/mmi — the MMI
+    // plugin tree itself — so a machine running Cursor WITHOUT the plugin enumerated as "no Cursor"
+    // 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.
+    { id: "hermes", marker: `${hermesHostCommand(env)} --version` }
+  ].map((probe) => ({
+    ...probe,
+    present: probe.id === "hermes" ? hermesHostPresent(env) : (0, import_node_fs8.existsSync)(probe.marker)
+  }));
+}
+
+// src/arm-cli.ts
+var import_node_fs9 = require("node:fs");
+var import_node_child_process6 = require("node:child_process");
+var import_node_path8 = require("node:path");
+function globalCliDist(env) {
+  const root = globalRoot(env);
+  return root ? (0, import_node_path8.join)(root, "@mutmutco", "cli", "dist", "index.cjs") : null;
+}
+function probeCliVersion(distPath) {
+  if (!fileExists(distPath)) return null;
+  const probe = (0, import_node_child_process6.spawnSync)(process.execPath, [distPath, "--version"], { encoding: "utf8", windowsHide: true });
+  const version = (probe.stdout || "").trim();
+  return probe.status === 0 && /^\d+\.\d+\.\d+/.test(version) ? version : null;
+}
+function probeCliInstallation(env = process.env) {
+  const location = globalCliDist(env);
+  const version = location ? probeCliVersion(location) : null;
+  return { version, location, detail: version ? `absolute binary reported ${version}` : "global @mutmutco/cli binary was not readable" };
+}
+function cliArm(options) {
+  const env = options.env ?? process.env;
+  const { target, dryRun, paths } = options;
+  const dist = globalCliDist(env);
+  const installed = dist ? probeCliVersion(dist) : null;
+  if (installed && compareSemver(installed, target) > 0) {
+    return { surface: "cli", from: installed, to: installed, verdict: "skip", detail: `installed ${installed} is above candidate ${target} (monotonic)` };
+  }
+  const highWater = journalHighWater(paths.journalPath, "cli");
+  if (highWater && compareSemver(highWater, target) > 0) {
+    return { surface: "cli", from: installed, to: highWater, verdict: "skip", detail: `journal high-water ${highWater} is above candidate ${target} (monotonic)` };
+  }
+  if (installed === target) {
+    return { surface: "cli", from: installed, to: target, verdict: "ok", detail: `already at target ${target}` };
+  }
+  if (dryRun) {
+    return { surface: "cli", from: installed, to: target, verdict: "ok", detail: `dry-run: would converge ${installed ?? "absent"} -> ${target}` };
+  }
+  const stageRoot = (0, import_node_path8.join)(paths.staging, "cli", target);
+  const stageDist = (0, import_node_path8.join)(stageRoot, "node_modules", "@mutmutco", "cli", "dist", "index.cjs");
+  if (!fileExists(stageDist)) {
+    (0, import_node_fs9.mkdirSync)(stageRoot, { recursive: true });
+    (0, import_node_fs9.writeFileSync)((0, import_node_path8.join)(stageRoot, "package.json"), JSON.stringify({ name: "mmi-updater-stage", private: true }) + "\n");
+    const install = runNpm(["install", "--prefix", stageRoot, "--no-audit", "--no-fund", "--no-package-lock", `@mutmutco/cli@${target}`], env);
+    if (install.status !== 0) {
+      return { surface: "cli", from: installed, to: target, verdict: "defer", detail: `staging install failed: ${(install.stderr || install.stdout).split("\n").filter(Boolean).slice(-3).join(" | ")}` };
+    }
+  }
+  let stagedManifestVersion;
+  try {
+    stagedManifestVersion = JSON.parse((0, import_node_fs9.readFileSync)((0, import_node_path8.join)(stageRoot, "node_modules", "@mutmutco", "cli", "package.json"), "utf8")).version;
+  } catch {
+  }
+  if (stagedManifestVersion !== target) {
+    return { surface: "cli", from: installed, to: target, verdict: "defer", detail: `staged manifest is ${stagedManifestVersion ?? "unreadable"}, expected ${target}` };
+  }
+  const stagedVersion = probeCliVersion(stageDist);
+  if (stagedVersion !== target) {
+    return { surface: "cli", from: installed, to: target, verdict: "defer", detail: `staged binary probed ${stagedVersion ?? "dead"}, expected ${target}` };
+  }
+  const globalInstall = runNpm(["install", "-g", "--no-audit", "--no-fund", `@mutmutco/cli@${target}`], env);
+  if (globalInstall.status !== 0) {
+    const reason = `global install failed: ${(globalInstall.stderr || globalInstall.stdout).split("\n").filter(Boolean).slice(-3).join(" | ")}`;
+    const root = globalRoot(env);
+    const pending = lockShaped(reason) && root ? ` \u2014 ${noteBusyDefer(paths, env, { surface: "cli", target, reason, dirs: [root] })}` : "";
+    return { surface: "cli", from: installed, to: target, verdict: "defer", detail: `${reason}${pending}` };
+  }
+  const switchedDist = globalCliDist(env);
+  const switched = probeCliVersion(switchedDist ?? "");
+  if (switched !== target) {
+    return { surface: "cli", from: installed, to: switched ?? installed ?? "unknown", verdict: "fail", detail: `post-switch probe returned ${switched ?? "dead"} at ${switchedDist ?? "an unresolvable path"}, expected ${target}; the global install already ran \u2014 nothing was rolled back` };
+  }
+  return { surface: "cli", from: installed, to: target, verdict: "ok", detail: `converged ${installed ?? "absent"} -> ${target} (staged, verified, switched)` };
+}
+
+// src/arm-self.ts
+function selfArm(options) {
+  return npmGlobalArm({
+    surface: "updater",
+    packageName: "@mutmutco/hub",
+    distRel: "dist/index.cjs",
+    ...options
+  });
+}
+
 // src/arm-kimi.ts
 var import_node_child_process7 = require("node:child_process");
 var import_node_fs12 = require("node:fs");
 var import_node_path9 = require("node:path");
 
 // src/compat.ts
-var import_node_fs9 = require("node:fs");
+var import_node_fs10 = require("node:fs");
 function readManifestCompat(manifestPath) {
   try {
-    const parsed = JSON.parse((0, import_node_fs9.readFileSync)(manifestPath, "utf8"));
+    const parsed = JSON.parse((0, import_node_fs10.readFileSync)(manifestPath, "utf8"));
     return typeof parsed.mmiCompat === "string" ? parsed.mmiCompat : void 0;
   } catch {
     return void 0;
   }
 }
 
-// src/launch-staging.ts
-var import_node_fs10 = require("node:fs");
-var import_node_path8 = require("node:path");
-function readLaunchTarget(path) {
-  try {
-    const parsed = JSON.parse((0, import_node_fs10.readFileSync)(path, "utf8"));
-    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
-    const row = parsed;
-    if (typeof row.surface !== "string" || typeof row.target !== "string" || typeof row.since !== "string" || typeof row.incoming !== "string") return null;
-    return row;
-  } catch {
-    return null;
-  }
-}
-function writeLaunchTarget(path, record) {
-  (0, import_node_fs10.mkdirSync)((0, import_node_path8.join)(path, ".."), { recursive: true });
-  const tmp = `${path}.tmp-${process.pid}-${Math.random().toString(36).slice(2)}`;
-  (0, import_node_fs10.writeFileSync)(tmp, `${JSON.stringify(record, null, 2)}
-`, "utf8");
-  (0, import_node_fs10.renameSync)(tmp, path);
-}
-function clearLaunchTarget(path) {
-  try {
-    (0, import_node_fs10.rmSync)(path, { force: true });
-  } catch {
-  }
-}
-function noteLaunchStaged(paths, env, options, seam = {}) {
-  writeLaunchTarget(options.launchTargetPath, {
-    surface: options.surface,
-    target: options.target,
-    since: (/* @__PURE__ */ new Date()).toISOString(),
-    incoming: options.incoming
-  });
-  return noteBusyDefer(paths, env, {
-    surface: options.surface,
-    target: options.target,
-    reason: options.reason,
-    images: options.images,
-    dirs: options.dirs
-  }, seam);
-}
-function probeLaunchTargetVersion(launchTargetPath, versionAt) {
-  const record = readLaunchTarget(launchTargetPath);
-  if (!record || !(0, import_node_fs10.existsSync)(record.incoming)) return null;
-  const version = versionAt(record.incoming);
-  return version === record.target ? record.target : null;
-}
-
 // src/kimi-registration.ts
 function validateKimiInstalledPlugin(document, pluginRoot, id) {
   if (!document || typeof document !== "object" || Array.isArray(document)) return "malformed-document";
@@ -1863,10 +2016,48 @@ function installedVersion(env) {
     return null;
   }
 }
-function probeJervcodeInstallation(env = process.env) {
-  const location = (0, import_node_path11.join)(jervcodeAgentDir(env), "npm", "node_modules", ...PI_PACKAGE.split("/"));
-  const version = installedVersion(env);
-  return { version, location, detail: version ? "materialized pi package manifest" : "materialized pi package manifest was unreadable" };
+function materializedManifestLocation(env) {
+  return (0, import_node_path11.join)(jervcodeAgentDir(env), "npm", "node_modules", ...PI_PACKAGE.split("/"));
+}
+function parseHostJson(result) {
+  if (result.status !== 0) return null;
+  try {
+    return JSON.parse(result.stdout);
+  } catch {
+    return null;
+  }
+}
+function probeJervcodeInstallation(env = process.env, runner = runHostCommand) {
+  const manifestLocation = materializedManifestLocation(env);
+  const manifestVersion = installedVersion(env);
+  const manifestEvidence = () => ({
+    version: manifestVersion,
+    location: manifestLocation,
+    detail: manifestVersion ? "materialized pi package manifest" : "materialized pi package manifest was unreadable"
+  });
+  const hosted = hostEnv(env);
+  const command = hostCommands(env).find((bin) => runner(bin, ["--version"], hosted).status === 0);
+  if (!command) return manifestEvidence();
+  const hostLocation = `${command} plugin list --json`;
+  const result = runner(command, ["plugin", "list", "--json"], hosted);
+  const parsed = parseHostJson(result);
+  const row = Array.isArray(parsed?.npm) ? parsed.npm.find((entry) => entry.name === PI_PACKAGE) ?? null : null;
+  if (row?.version) {
+    return {
+      version: row.version,
+      location: hostLocation,
+      detail: `native host reports enabled=${String(row.enabled ?? true)}`
+    };
+  }
+  const hostError = !parsed || !Array.isArray(parsed.npm) ? `${command} plugin list --json failed: ${failure2(result)}` : `${command} plugin list --json did not list ${PI_PACKAGE}`;
+  if (manifestVersion) {
+    return {
+      version: manifestVersion,
+      location: manifestLocation,
+      detail: `${hostError}; using materialized pi package manifest`
+    };
+  }
+  return { version: null, location: hostLocation, detail: hostError };
 }
 function isLegacyMmiPiPath(spec) {
   return /[/\\]mutmutco[/\\]mmi[/\\]\d+\.\d+\.\d+[/\\]\.pi-plugin[/\\]?$/i.test(spec);
@@ -1945,7 +2136,7 @@ var import_node_child_process9 = require("node:child_process");
 var import_node_path12 = require("node:path");
 var PACKAGE2 = "@mutmutco/hermes-plugin";
 var MANIFEST2 = "plugin.yaml";
-var TREE_MARKERS2 = [MANIFEST2, "__init__.py", "skills"];
+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");
@@ -1960,14 +2151,36 @@ function yamlVersion(root) {
     return null;
   }
 }
-function treeHealthy3(root) {
-  return TREE_MARKERS2.slice(0, 2).every((file) => (0, import_node_fs15.existsSync)((0, import_node_path12.join)(root, file))) && (() => {
-    try {
-      return (0, import_node_fs15.statSync)((0, import_node_path12.join)(root, "skills")).isDirectory();
-    } catch {
-      return false;
+function packageTreeMarkers(root) {
+  try {
+    const files = JSON.parse((0, import_node_fs15.readFileSync)((0, import_node_path12.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());
     }
-  })();
+  } catch {
+  }
+  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;
+  try {
+    const stat = (0, import_node_fs15.statSync)(path);
+    return stat.isFile() || stat.isDirectory();
+  } catch {
+    return false;
+  }
+}
+function treeHealth(root) {
+  const missing = packageTreeMarkers(root).filter((rel) => !markerPresent(root, rel));
+  return { healthy: missing.length === 0, missing };
+}
+function treeHealthy3(root) {
+  return treeHealth(root).healthy;
+}
+function treeIncompleteDetail(root, label) {
+  const { healthy, missing } = treeHealth(root);
+  return healthy ? null : `${label} tree is missing ${missing.join(", ")}`;
 }
 function packageIdentity(root) {
   try {
@@ -1994,14 +2207,14 @@ function message2(error) {
   return String(error?.message ?? error).replace(/\s+/g, " ").slice(0, 200);
 }
 var HERMES_PROCESS_SEGMENT = /^hermes(-cli|-code)?(\.(exe|cmd|bat|ps1|js|mjs|cjs|py))?$/i;
-var HUB_UPDATE_COMMAND = /(?:\bmmi-hub(?:\.(?:cmd|exe|bat|ps1))?\b|@mutmutco[/\\]hub[/\\]dist[/\\]index\.(?:cjs|mjs|js))[\s'"]+update\b/i;
+var HUB_UPDATE_COMMAND2 = /(?:\bmmi-hub(?:\.(?:cmd|exe|bat|ps1))?\b|@mutmutco[/\\]hub[/\\]dist[/\\]index\.(?:cjs|mjs|js))[\s'"]+update\b/i;
 function hermesProcessToken(line, home) {
   const normalized = line.replace(/["']/g, " ");
   const tokens = normalized.split(/\s+/);
   const hermesToken = (candidates) => candidates.find((token) => token && token.split(/[/\\]/).some((segment) => HERMES_PROCESS_SEGMENT.test(segment))) ?? null;
   const direct = hermesToken(tokens.slice(0, 2));
   if (direct) return direct;
-  if (HUB_UPDATE_COMMAND.test(line)) return null;
+  if (HUB_UPDATE_COMMAND2.test(line)) return null;
   return hermesToken(tokens) ?? (home && normalized.toLowerCase().includes(home.toLowerCase()) ? home : null);
 }
 function realProcessListing() {
@@ -2050,7 +2263,9 @@ function hermesArm(options) {
     detail,
     launchStaged: launchStaged || void 0
   });
-  if (!(0, import_node_fs15.existsSync)(home)) return result(null, options.target, "skip", `absent (${home}) \u2014 skipped without writes`);
+  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)) {
     return result(installed, options.target, "defer", `${live} carries no ${PACKAGE2} package identity \u2014 refusing to displace an unmanaged Hermes mmi plugin`);
   }
@@ -2065,9 +2280,12 @@ function hermesArm(options) {
   if (options.dryRun) return result(installed, options.target, "ok", `dry-run: would stage ${PACKAGE2}@${options.target}, atomically switch ${installed ?? "absent"} -> ${options.target}, then provision skills into ${(0, import_node_path12.join)(home, "skills", "mmi")}`);
   const staged = stagePackage({ surface: "hermes", packageName: PACKAGE2, target: options.target, witness: MANIFEST2, paths: options.paths, env });
   if ("defer" in staged) return result(installed, options.target, "defer", staged.defer);
-  if (yamlVersion(staged.packageRoot) !== options.target || !treeHealthy3(staged.packageRoot)) {
-    return result(installed, options.target, "defer", `staged Hermes manifest is ${yamlVersion(staged.packageRoot) ?? "unreadable"} or its tree is incomplete (expected ${options.target})`);
+  const stagedVersion = yamlVersion(staged.packageRoot);
+  if (stagedVersion !== options.target) {
+    return result(installed, options.target, "defer", `staged Hermes manifest is ${stagedVersion ?? "unreadable"}, expected ${options.target}`);
   }
+  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");
@@ -2084,9 +2302,15 @@ function hermesArm(options) {
     } catch (error) {
       return result(installed, options.target, "defer", `cannot place incoming Hermes generation: ${message2(error)}`);
     }
-    if (yamlVersion(incoming) !== options.target || !treeHealthy3(incoming)) {
+    const incomingVersion = yamlVersion(incoming);
+    if (incomingVersion !== options.target) {
+      discard2(incomingRoot);
+      return result(installed, options.target, "defer", `incoming Hermes manifest is ${incomingVersion ?? "unreadable"}, expected ${options.target}`);
+    }
+    const incomingTree = treeIncompleteDetail(incoming, "incoming Hermes");
+    if (incomingTree) {
       discard2(incomingRoot);
-      return result(installed, options.target, "defer", "incoming Hermes generation did not reproduce the verified payload");
+      return result(installed, options.target, "defer", incomingTree);
     }
   }
   const busy = hermesHostEvidence(env, home, options.processListProvider);
@@ -2116,16 +2340,19 @@ function hermesArm(options) {
     const pending = lockShaped(reason) ? ` \u2014 ${noteBusyDefer(options.paths, env, { surface: "hermes", target: options.target, reason, images: ["hermes"], dirs: [home] })}` : "";
     return result(installed, options.target, "defer", `Hermes generation switch failed; previous generation retained: ${reason}${pending}`);
   }
-  if (yamlVersion(live) !== options.target || !treeHealthy3(live)) {
+  const 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 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);
     } catch (error) {
-      return result(installed, yamlVersion(live) ?? "unknown", "fail", `post-switch Hermes verification failed and recovery failed: ${message2(error)}`);
+      return result(installed, liveVersion ?? "unknown", "fail", `post-switch Hermes verification failed and recovery failed: ${message2(error)}`);
     }
-    return result(installed, displaced ? installed ?? "unknown" : "none", "fail", `post-switch Hermes verification failed; rejected generation parked at ${broken}${displaced ? "; previous generation restored" : ""}`);
+    return result(installed, displaced ? installed ?? "unknown" : "none", "fail", `post-switch Hermes verification failed (${verifyDetail}); rejected generation parked at ${broken}${displaced ? "; previous generation restored" : ""}`);
   }
   discard2(incomingRoot);
   clearLaunchTarget(launchTargetPath);
@@ -2535,7 +2762,7 @@ function reconcile(options) {
           continue;
         }
         say(`${probe.id}: converging to v${summary.target}`);
-        const arm = probe.id === "claude" ? claudeArm({ target: summary.target, dryRun: options.dryRun, 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 === "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;
         if (arm) {
           summary.plugins.push(arm);
           summary.surfaces.push({ id: probe.id, present: true, action: `arm-${arm.verdict}` });
@@ -3048,14 +3275,19 @@ function hubStatus(hubVersion, env = process.env, invokedPath = process.argv[1])
   const expectedVersion = [...realEvents].reverse().find((event) => event.kind === "target" && event.verdict === "ok" && event.to)?.to ?? null;
   const latestEvent = realEvents.at(-1) ?? null;
   const latestRunEvents = latestEvent ? realEvents.filter((event) => event.run === latestEvent.run) : [];
+  const probes = enumerateSurfaces(env);
+  const presentSurfaces = new Set(probes.filter((probe) => probe.present).map((probe) => probe.id));
   const actual = /* @__PURE__ */ new Map();
   const hubDist = globalDist(env, "@mutmutco/hub", "dist/index.cjs");
   const globalHubVersion = hubDist ? probeVersion(hubDist) : null;
   actual.set("hub", globalHubVersion ? { version: globalHubVersion, staged: null, location: hubDist, detail: "absolute global Hub binary" } : { version: hubVersion, staged: null, location: invokedPath ?? null, detail: "currently executing Hub bundle (global package location unavailable)" });
   const cliProbe = probeCliInstallation(env);
   actual.set("cli", { version: cliProbe.version, staged: null, location: cliProbe.location, detail: cliProbe.detail });
-  for (const surface of enumerateSurfaces(env).filter((probe) => probe.present)) {
-    if (surface.id === "claude" || surface.id === "codex" || surface.id === "kilo") {
+  for (const surface of probes.filter((probe) => probe.present)) {
+    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);
       actual.set(surface.id, { version: probe.version, staged: null, location: probe.location, detail: probe.detail });
     } else if (surface.id === "kimi") {
@@ -3095,6 +3327,9 @@ function hubStatus(hubVersion, env = process.env, invokedPath = process.argv[1])
   }
   for (const event of latestRunEvents) {
     if ((event.kind === "arm" || event.kind === "reconcile") && (event.verdict === "fail" || event.verdict === "defer")) {
+      if (event.kind === "arm" && event.surface && event.surface !== "cli" && event.surface !== "updater" && !presentSurfaces.has(event.surface)) {
+        continue;
+      }
       const surface = event.surface === "updater" ? "hub" : event.surface ?? event.kind;
       const repeat = event.kind === "arm" && event.verdict === "fail" && event.surface && journalSurfaceRepeatedFail(paths.journalPath, event.surface, latestEvent.run);
       failures.push(repeat ? `last run ${surface}: ${event.detail ?? event.verdict} \u2014 already failed the previous run too; \`mmi-hub update\` will not clear it, inspect the journal` : `last run ${surface}: ${event.detail ?? event.verdict} \u2014 run \`mmi-hub update\``);
@@ -3539,6 +3774,8 @@ if (typeof require !== "undefined" && require.main === module) {
 0 && (module.exports = {
   acquireSharedDocLock,
   buildWatcherCommand,
+  claudeArm,
+  claudeHostEvidence,
   clearLaunchTarget,
   clearPending,
   enumerateSurfaces,
@@ -3546,7 +3783,9 @@ if (typeof require !== "undefined" && require.main === module) {
   formatReconcileReport,
   hermesArm,
   hermesHome,
+  hermesHostCommand,
   hermesHostEvidence,
+  hermesHostPresent,
   hubStatus,
   launchdPlist,
   launcherSh,
@@ -3561,6 +3800,7 @@ if (typeof require !== "undefined" && require.main === module) {
   parseNpmDistIntegrity,
   pendingPath,
   pidAlive,
+  probeClaudeLaunchStaging,
   probeCursorLaunchStaging,
   probeHermesInstallation,
   probeHermesLaunchStaging,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mutmutco/hub",
-  "version": "4.1.9",
+  "version": "4.1.10",
   "description": "Install and maintain the MMI CLI and every present host surface from one release-gated Hub command.",
   "type": "module",
   "license": "UNLICENSED",