@mutmutco/hub 3.137.0

package/dist/index.cjs

@@ -0,0 +1,2123 @@
+#!/usr/bin/env node
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  hubStatus: () => hubStatus,
+  launcherVbs: () => launcherVbs,
+  localStartBoundary: () => localStartBoundary,
+  main: () => main,
+  ownVersion: () => ownVersion,
+  schedulerStatus: () => schedulerStatus,
+  taskXml: () => taskXml
+});
+module.exports = __toCommonJS(index_exports);
+var import_node_fs15 = require("node:fs");
+var import_node_path12 = require("node:path");
+
+// src/state.ts
+var import_node_fs = require("node:fs");
+var import_node_os = require("node:os");
+var import_node_path = require("node:path");
+function stateRoot(env = process.env) {
+  return env.MMI_UPDATER_HOME || (0, import_node_path.join)((0, import_node_os.homedir)(), ".mmi", "updater");
+}
+function statePaths(env = process.env) {
+  const root = stateRoot(env);
+  const staging = (0, import_node_path.join)(root, "staging");
+  const gitCache = (0, import_node_path.join)(root, "git-cache", "mmi-hub.git");
+  return { root, staging, gitCache, journalPath: (0, import_node_path.join)(root, "journal.jsonl"), leasePath: (0, import_node_path.join)(root, "lease.lock") };
+}
+function ensureState(env = process.env) {
+  const paths = statePaths(env);
+  (0, import_node_fs.mkdirSync)(paths.staging, { recursive: true });
+  (0, import_node_fs.mkdirSync)((0, import_node_path.dirname)(paths.gitCache), { recursive: true });
+  return paths;
+}
+var UpdaterBusy = class extends Error {
+};
+var LEASE_WAIT_MS = 3e4;
+var LEASE_STALE_MS = 10 * 6e4;
+function tryAcquire(path) {
+  const token = `${Date.now()}-${process.pid}-${Math.random().toString(36).slice(2, 10)}`;
+  try {
+    const fd = (0, import_node_fs.openSync)(path, "wx");
+    (0, import_node_fs.writeFileSync)(fd, JSON.stringify({ token, pid: process.pid, ts: Date.now() }) + "\n");
+    (0, import_node_fs.closeSync)(fd);
+    return {
+      token,
+      release() {
+        try {
+          const current2 = readLease(path);
+          if (current2 && current2.token === token) (0, import_node_fs.unlinkSync)(path);
+        } catch {
+        }
+      }
+    };
+  } catch (error) {
+    if (error?.code !== "EEXIST") throw error;
+  }
+  const current = readLease(path);
+  if (current && Date.now() - current.ts > LEASE_STALE_MS) {
+    try {
+      (0, import_node_fs.renameSync)(path, `${path}.stale-${Date.now()}`);
+      return "stolen-stale";
+    } catch {
+    }
+  }
+  return "taken";
+}
+function readLease(path) {
+  try {
+    return JSON.parse((0, import_node_fs.readFileSync)(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function withLease(path, fn) {
+  const deadline = Date.now() + LEASE_WAIT_MS;
+  for (; ; ) {
+    const attempt = tryAcquire(path);
+    if (typeof attempt === "object") {
+      try {
+        return fn();
+      } finally {
+        attempt.release();
+      }
+    }
+    if (Date.now() >= deadline) {
+      throw new UpdaterBusy(`another updater holds ${path} (waited ${LEASE_WAIT_MS}ms) \u2014 deferring`);
+    }
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 500);
+  }
+}
+function appendJournal(path, event) {
+  try {
+    (0, import_node_fs.mkdirSync)((0, import_node_path.dirname)(path), { recursive: true });
+    const fd = (0, import_node_fs.openSync)(path, "a");
+    (0, import_node_fs.writeFileSync)(fd, JSON.stringify(event) + "\n");
+    (0, import_node_fs.closeSync)(fd);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function journalHighWater(path, surface) {
+  let high = null;
+  try {
+    for (const line of (0, import_node_fs.readFileSync)(path, "utf8").split("\n")) {
+      if (!line.trim()) continue;
+      try {
+        const event = JSON.parse(line);
+        if (event.dryRun) continue;
+        if (event.surface === surface && event.verdict === "ok" && event.to && (!high || compareSemver(event.to, high) > 0)) {
+          high = event.to;
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return high;
+}
+function parseSemver(version) {
+  const match = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?$/.exec(version.trim());
+  if (!match) return null;
+  return { major: +match[1], minor: +match[2], patch: +match[3], pre: match[4] ? match[4].split(".") : [] };
+}
+function compareSemver(a, b) {
+  const va = parseSemver(a);
+  const vb = parseSemver(b);
+  if (!va || !vb) return 0;
+  if (va.major !== vb.major) return va.major - vb.major;
+  if (va.minor !== vb.minor) return va.minor - vb.minor;
+  if (va.patch !== vb.patch) return va.patch - vb.patch;
+  if (!va.pre.length && !vb.pre.length) return 0;
+  if (!va.pre.length) return 1;
+  if (!vb.pre.length) return -1;
+  return va.pre.join(".") < vb.pre.join(".") ? -1 : va.pre.join(".") > vb.pre.join(".") ? 1 : 0;
+}
+function fileExists(path) {
+  return (0, import_node_fs.existsSync)(path);
+}
+
+// src/npm.ts
+var import_node_child_process = require("node:child_process");
+var import_node_fs2 = require("node:fs");
+var import_node_path2 = require("node:path");
+var cachedNpm = null;
+function resolveNpm(env = process.env) {
+  if (env.MMI_UPDATER_NPM) return { kind: "command", command: env.MMI_UPDATER_NPM };
+  if (cachedNpm) return cachedNpm;
+  if (process.platform === "win32") {
+    const where = (0, import_node_child_process.spawnSync)("where.exe", ["npm.cmd"], { encoding: "utf8", windowsHide: true });
+    const first = where.stdout.split("\n").map((l) => l.trim()).find(Boolean);
+    if (where.status === 0 && first) {
+      const script = (0, import_node_path2.join)((0, import_node_path2.dirname)(first), "node_modules", "npm", "bin", "npm-cli.js");
+      if ((0, import_node_fs2.existsSync)(script)) {
+        cachedNpm = { kind: "node-script", script };
+        return cachedNpm;
+      }
+      cachedNpm = { kind: "command", command: first };
+      return cachedNpm;
+    }
+  }
+  cachedNpm = { kind: "command", command: "npm" };
+  return cachedNpm;
+}
+function runNpm(args, env = process.env, options = {}) {
+  const npm = resolveNpm(env);
+  const result = npm.kind === "node-script" ? (0, import_node_child_process.spawnSync)(process.execPath, [npm.script, ...args], { encoding: "utf8", env, cwd: options.cwd, windowsHide: true }) : (0, import_node_child_process.spawnSync)(npm.command, args, { encoding: "utf8", env, cwd: options.cwd, shell: process.platform === "win32", windowsHide: true });
+  return { status: result.status, stdout: result.stdout ?? "", stderr: result.stderr ?? "" };
+}
+function npmView(spec, field, env = process.env) {
+  const args = ["view", spec, "--json"];
+  if (field) args.splice(2, 0, field);
+  const result = runNpm(args, env);
+  if (result.status !== 0 || !result.stdout.trim()) return null;
+  try {
+    return JSON.parse(result.stdout);
+  } catch {
+    return null;
+  }
+}
+function npmVersions(packageName, env = process.env) {
+  const versions = npmView(packageName, "versions", env);
+  return Array.isArray(versions) ? versions.filter((v) => typeof v === "string") : [];
+}
+
+// src/gate.ts
+var import_node_child_process2 = require("node:child_process");
+var import_node_fs3 = require("node:fs");
+function parseBom(text) {
+  const bom = JSON.parse(text);
+  if (typeof bom?.version !== "string" || typeof bom?.sourceCommit !== "string" || !Array.isArray(bom?.artifacts)) {
+    throw new Error("distribution-bom.json at tag is malformed (version/sourceCommit/artifacts)");
+  }
+  return bom;
+}
+function npmPackRows(bom) {
+  return bom.artifacts.filter((row) => row.identity?.kind === "npm-pack" && row.identity.packagePath);
+}
+var GateEnvError = class extends Error {
+};
+function git(cachePath, args) {
+  const result = (0, import_node_child_process2.spawnSync)("git", ["-C", cachePath, ...args], { encoding: "utf8", windowsHide: true });
+  return { status: result.status, stdout: (result.stdout ?? "").trim(), stderr: result.stderr ?? "" };
+}
+function ensureBareCache(cachePath, repoUrl) {
+  const probe = (0, import_node_child_process2.spawnSync)("git", ["--version"], { encoding: "utf8", windowsHide: true });
+  if (probe.status !== 0) {
+    throw new GateEnvError("git is not available \u2014 the release gate needs a git client");
+  }
+  if (!(0, import_node_fs3.existsSync)(cachePath)) {
+    const init = (0, import_node_child_process2.spawnSync)("git", ["init", "--bare", cachePath], { encoding: "utf8", windowsHide: true });
+    if (init.status !== 0) throw new GateEnvError(`cannot create bare cache at ${cachePath}: ${init.stderr}`);
+  }
+}
+function fetchIntoCache(cachePath, repoUrl, refspec) {
+  const result = git(cachePath, ["fetch", "--no-tags", repoUrl, refspec]);
+  return result.status === 0;
+}
+function resolveTagCommit(cachePath, tag) {
+  const result = git(cachePath, ["rev-parse", `refs/tags/${tag}^{commit}`]);
+  return result.status === 0 ? result.stdout : null;
+}
+function isAncestor(cachePath, ancestor, descendant) {
+  return git(cachePath, ["merge-base", "--is-ancestor", ancestor, descendant]).status === 0;
+}
+function isAncestorOfMain(cachePath, commit) {
+  return isAncestor(cachePath, commit, "refs/heads/main");
+}
+function showFile(cachePath, commit, path) {
+  const result = git(cachePath, ["show", `${commit}:${path}`]);
+  return result.status === 0 ? result.stdout : null;
+}
+function gateCandidate(cachePath, repoUrl, candidate) {
+  const tag = `v${candidate}`;
+  if (!fetchIntoCache(cachePath, repoUrl, `refs/tags/${tag}:refs/tags/${tag}`)) {
+    return { ok: false, reason: `tag ${tag} not found` };
+  }
+  const commit = resolveTagCommit(cachePath, tag);
+  if (!commit) return { ok: false, reason: `tag ${tag} resolves to no commit` };
+  if (!isAncestorOfMain(cachePath, commit)) {
+    return { ok: false, reason: `tag ${tag} commit is not reachable from main` };
+  }
+  const bomText = showFile(cachePath, commit, "distribution-bom.json");
+  if (!bomText) return { ok: false, reason: `distribution-bom.json absent at ${tag}` };
+  let bom;
+  try {
+    bom = parseBom(bomText);
+  } catch (error) {
+    return { ok: false, reason: `BOM at ${tag} unparseable: ${error?.message ?? error}` };
+  }
+  if (bom.version !== candidate) {
+    return { ok: false, reason: `BOM at ${tag} stamps ${bom.version}, not ${candidate}` };
+  }
+  if (!isAncestor(cachePath, bom.sourceCommit, commit)) {
+    return { ok: false, reason: `BOM at ${tag} stamps sourceCommit ${bom.sourceCommit.slice(0, 12)} which the tag commit does not contain` };
+  }
+  return { ok: true, tagCommit: commit, bom };
+}
+function checkAtomicity(cachePath, tagCommit, bom, candidate, npm) {
+  const rows = [];
+  for (const row of npmPackRows(bom)) {
+    if (row.version !== candidate) {
+      rows.push({ id: row.id, ok: false, detail: `BOM row at ${row.version}, candidate ${candidate}` });
+      continue;
+    }
+    const manifestText = showFile(cachePath, tagCommit, `${row.identity.packagePath}/package.json`);
+    let name;
+    let manifestVersion;
+    try {
+      const manifest2 = JSON.parse(manifestText ?? "");
+      name = manifest2.name;
+      manifestVersion = manifest2.version;
+    } catch {
+    }
+    if (!name || manifestVersion !== candidate) {
+      rows.push({ id: row.id, name, ok: false, detail: `package.json at ${row.identity.packagePath} is not stamped ${candidate}` });
+      continue;
+    }
+    const integrity = npm.distIntegrity(`${name}@${candidate}`);
+    if (!integrity) {
+      rows.push({ id: row.id, name, ok: false, detail: `${name}@${candidate} not on npm` });
+      continue;
+    }
+    if (integrity !== row.identity.value) {
+      rows.push({ id: row.id, name, ok: false, detail: `${name}@${candidate} dist.integrity differs from BOM identity` });
+      continue;
+    }
+    rows.push({ id: row.id, name, ok: true, detail: `${name}@${candidate} published, integrity matches` });
+  }
+  return { ok: rows.length > 0 && rows.every((row) => row.ok), rows };
+}
+
+// src/surfaces.ts
+var import_node_fs4 = 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 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") },
+    { id: "cursor", marker: (0, import_node_path3.join)(home, ".cursor", "plugins", "local", "mmi") },
+    { 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") }
+  ].map((probe) => ({ ...probe, present: (0, import_node_fs4.existsSync)(probe.marker) }));
+}
+
+// src/arm-cli.ts
+var import_node_fs5 = require("node:fs");
+var import_node_child_process3 = require("node:child_process");
+var import_node_path4 = require("node:path");
+function globalCliDist(env) {
+  const prefix = runNpm(["prefix", "-g"], env);
+  if (prefix.status !== 0 || !prefix.stdout.trim()) return null;
+  return (0, import_node_path4.join)(prefix.stdout.trim(), "node_modules", "@mutmutco", "cli", "dist", "index.cjs");
+}
+function probeCliVersion(distPath) {
+  if (!fileExists(distPath)) return null;
+  const probe = (0, import_node_child_process3.spawnSync)(process.execPath, [distPath, "--version"], { encoding: "utf8", windowsHide: true });
+  const 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_path4.join)(paths.staging, "cli", target);
+  const stageDist = (0, import_node_path4.join)(stageRoot, "node_modules", "@mutmutco", "cli", "dist", "index.cjs");
+  if (!fileExists(stageDist)) {
+    (0, import_node_fs5.mkdirSync)(stageRoot, { recursive: true });
+    (0, import_node_fs5.writeFileSync)((0, import_node_path4.join)(stageRoot, "package.json"), JSON.stringify({ name: "mmi-updater-stage", private: true }) + "\n");
+    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_fs5.readFileSync)((0, import_node_path4.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) {
+    return { surface: "cli", from: installed, to: target, verdict: "defer", detail: `global install failed: ${(globalInstall.stderr || globalInstall.stdout).split("\n").filter(Boolean).slice(-3).join(" | ")}` };
+  }
+  const switched = probeCliVersion(globalCliDist(env) ?? "");
+  if (switched !== target) {
+    return { surface: "cli", from: installed, to: switched ?? installed ?? "unknown", verdict: "fail", detail: `post-switch probe returned ${switched ?? "dead"}, expected ${target}` };
+  }
+  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_fs6 = require("node:fs");
+var import_node_child_process4 = require("node:child_process");
+var import_node_path5 = require("node:path");
+function globalDist(env, packageName, distRel) {
+  const prefix = runNpm(["prefix", "-g"], env);
+  if (prefix.status !== 0 || !prefix.stdout.trim()) return null;
+  return (0, import_node_path5.join)(prefix.stdout.trim(), "node_modules", ...packageName.split("/"), ...distRel.split("/"));
+}
+function probeVersion(distPath) {
+  if (!fileExists(distPath)) return null;
+  const probe = (0, import_node_child_process4.spawnSync)(process.execPath, [distPath, "--version"], { encoding: "utf8", windowsHide: true });
+  const version = (probe.stdout || "").trim();
+  return probe.status === 0 && /^\d+\.\d+\.\d+/.test(version) ? version : null;
+}
+function tail(output) {
+  return output.split("\n").filter(Boolean).slice(-3).join(" | ");
+}
+function stagePackage(options) {
+  const { surface, packageName, target, witness, paths, env } = options;
+  const stageRoot = (0, import_node_path5.join)(paths.staging, surface, target);
+  const packageRoot = (0, import_node_path5.join)(stageRoot, "node_modules", ...packageName.split("/"));
+  if (!fileExists((0, import_node_path5.join)(packageRoot, ...witness.split("/")))) {
+    (0, import_node_fs6.mkdirSync)(stageRoot, { recursive: true });
+    (0, import_node_fs6.writeFileSync)((0, import_node_path5.join)(stageRoot, "package.json"), JSON.stringify({ name: "mmi-updater-stage", private: true }) + "\n");
+    const 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)}` };
+    }
+  }
+  let stagedManifestVersion;
+  try {
+    stagedManifestVersion = JSON.parse((0, import_node_fs6.readFileSync)((0, import_node_path5.join)(packageRoot, "package.json"), "utf8")).version;
+  } catch {
+  }
+  if (stagedManifestVersion !== target) {
+    return { defer: `staged manifest is ${stagedManifestVersion ?? "unreadable"}, expected ${target}` };
+  }
+  return { packageRoot };
+}
+function npmGlobalArm(options) {
+  const env = options.env ?? process.env;
+  const { surface, packageName, distRel, target, dryRun, paths } = options;
+  const spec = `${packageName}@${target}`;
+  const result = (from, to, verdict, detail) => ({ surface, from, to, verdict, detail });
+  const dist = globalDist(env, packageName, distRel);
+  const installed = dist ? probeVersion(dist) : null;
+  if (installed && compareSemver(installed, target) > 0) {
+    return result(installed, installed, "skip", `installed ${installed} is above candidate ${target} (monotonic)`);
+  }
+  const highWater = journalHighWater(paths.journalPath, surface);
+  if (highWater && compareSemver(highWater, target) > 0) {
+    return result(installed, highWater, "skip", `journal high-water ${highWater} is above candidate ${target} (monotonic)`);
+  }
+  if (installed === target) {
+    return result(installed, target, "ok", `already at target ${target}`);
+  }
+  if (dryRun) {
+    return result(installed, target, "ok", `dry-run: would converge ${installed ?? "absent"} -> ${target}`);
+  }
+  const staged = stagePackage({ surface, packageName, target, witness: distRel, paths, env });
+  if ("defer" in staged) {
+    return result(installed, target, "defer", staged.defer);
+  }
+  const stageDist = (0, import_node_path5.join)(staged.packageRoot, ...distRel.split("/"));
+  const stagedVersion = probeVersion(stageDist);
+  if (stagedVersion !== target) {
+    return result(installed, target, "defer", `staged binary probed ${stagedVersion ?? "dead"}, expected ${target}`);
+  }
+  const globalInstall = runNpm(["install", "-g", "--no-audit", "--no-fund", spec], env);
+  if (globalInstall.status !== 0) {
+    return result(installed, target, "defer", `global install failed: ${tail(globalInstall.stderr || globalInstall.stdout)}`);
+  }
+  const switched = probeVersion(globalDist(env, packageName, distRel) ?? "");
+  if (switched !== target) {
+    return result(installed, switched ?? installed ?? "unknown", "fail", `post-switch probe returned ${switched ?? "dead"}, expected ${target}`);
+  }
+  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/arm-host-plugins.ts
+var import_node_child_process5 = require("node:child_process");
+var import_node_fs7 = require("node:fs");
+var import_node_os3 = require("node:os");
+var import_node_path6 = require("node:path");
+function cmdArg(value) {
+  return /^[A-Za-z0-9_@./:\\=+-]+$/.test(value) ? value : `"${value.replaceAll('"', '""')}"`;
+}
+var runHostCommand = (command, args, env) => {
+  const result = process.platform === "win32" ? (0, import_node_child_process5.spawnSync)("cmd.exe", ["/d", "/s", "/c", [command, ...args].map(cmdArg).join(" ")], {
+    encoding: "utf8",
+    env,
+    input: "",
+    timeout: 12e4,
+    windowsHide: true
+  }) : (0, import_node_child_process5.spawnSync)(command, args, {
+    encoding: "utf8",
+    env,
+    input: "",
+    timeout: 12e4,
+    windowsHide: true
+  });
+  return { status: result.status, stdout: result.stdout ?? "", stderr: result.stderr ?? "" };
+};
+function failure(result) {
+  return (result.stderr || result.stdout).split("\n").filter(Boolean).slice(-3).join(" | ") || `exit ${result.status ?? "signal"}`;
+}
+function parseJson(result) {
+  if (result.status !== 0) return null;
+  try {
+    return JSON.parse(result.stdout);
+  } catch {
+    return null;
+  }
+}
+function claudeMmi(runner, env) {
+  const result = runner("claude", ["plugin", "list", "--json"], env);
+  const parsed = parseJson(result);
+  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 claudeMarketplacesPath(env) {
+  return env.MMI_UPDATER_CLAUDE_MARKETPLACES || (0, import_node_path6.join)((0, import_node_os3.homedir)(), ".claude", "plugins", "known_marketplaces.json");
+}
+var CLAUDE_PROCESS_SEGMENT = /^claude(-code|-cli)?(\.(exe|cmd|bat|ps1|js|mjs|cjs|py))?$/;
+function claudeProcessSegment(line) {
+  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 claudeHostRunning(env) {
+  const marker = env.CLAUDE_CODE_SESSION_ID?.trim() ? "CLAUDE_CODE_SESSION_ID" : env.CLAUDECODE?.trim() ? "CLAUDECODE" : env.CLAUDE_PLUGIN_ROOT?.trim() ? "CLAUDE_PLUGIN_ROOT" : null;
+  if (marker) return { running: true, evidence: `${marker} is set \u2014 this process is itself inside a Claude hook` };
+  const result = process.platform === "win32" ? (0, import_node_child_process5.spawnSync)("powershell.exe", ["-NoProfile", "-Command", "Get-CimInstance Win32_Process | ForEach-Object { $_.Name + ' ' + $_.CommandLine }"], { encoding: "utf8", windowsHide: true, timeout: 15e3 }) : (0, import_node_child_process5.spawnSync)("ps", ["-eo", "args="], { encoding: "utf8", windowsHide: true, timeout: 15e3 });
+  if (result.status !== 0 || !(result.stdout ?? "").trim()) return { running: true, evidence: "the process list is unreadable \u2014 unsafe to write" };
+  for (const line of result.stdout.split(/\r?\n/)) {
+    const segment = claudeProcessSegment(line);
+    if (segment) return { running: true, evidence: `a live process names claude (${segment})` };
+  }
+  return { running: false, evidence: "no claude-named process in the process list" };
+}
+function ensureClaudeSingleWriter(env, dryRun) {
+  const path = claudeMarketplacesPath(env);
+  let body;
+  try {
+    body = JSON.parse((0, import_node_fs7.readFileSync)(path, "utf8"));
+  } catch {
+    return { ok: false, detail: `cannot read ${path}` };
+  }
+  const registration = body.mutmutco;
+  if (!registration || typeof registration !== "object") return { ok: false, detail: "mutmutco marketplace is not registered" };
+  if (registration.autoUpdate !== true) return { ok: true };
+  if (dryRun) return { ok: true, detail: "would disable Claude background autoUpdate (updater is the single writer)" };
+  const quiescence = claudeHostRunning(env);
+  if (quiescence.running) {
+    return { ok: false, detail: `Claude background autoUpdate is on, but Claude Code is running and would overwrite the registration \u2014 defer until the host is absent: ${quiescence.evidence}` };
+  }
+  registration.autoUpdate = false;
+  const tmp = `${path}.tmp-${process.pid}`;
+  try {
+    (0, import_node_fs7.writeFileSync)(tmp, JSON.stringify(body, null, 2) + "\n", "utf8");
+    (0, import_node_fs7.renameSync)(tmp, path);
+    const reread = JSON.parse((0, import_node_fs7.readFileSync)(path, "utf8"));
+    return reread?.mutmutco?.autoUpdate === false ? { ok: true, detail: "disabled Claude background autoUpdate (updater is the single writer)" } : { ok: false, detail: "Claude background autoUpdate write did not persist" };
+  } catch (error) {
+    return { ok: false, detail: `cannot disable Claude background autoUpdate: ${error?.message ?? error}` };
+  }
+}
+function claudeArm(options) {
+  const env = options.env ?? process.env;
+  const runner = options.runner ?? runHostCommand;
+  const before = claudeMmi(runner, env);
+  if (before.error) return { surface: "claude", from: null, to: options.target, verdict: "defer", detail: before.error };
+  const from = before.row?.version ?? null;
+  const singleWriter = ensureClaudeSingleWriter(env, options.dryRun);
+  if (!singleWriter.ok) return { surface: "claude", from, to: options.target, verdict: "defer", detail: singleWriter.detail ?? "cannot establish updater as the single writer" };
+  if (options.dryRun) {
+    const writer = singleWriter.detail ? `; ${singleWriter.detail}` : "";
+    return { surface: "claude", from, to: options.target, verdict: "ok", detail: `dry-run: would refresh mutmutco and converge mmi@mutmutco ${from ?? "absent"} -> ${options.target}${writer}` };
+  }
+  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)}` };
+  }
+  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) {
+    const writer = singleWriter.detail ? `${singleWriter.detail}; ` : "";
+    return { surface: "claude", from, to: options.target, verdict: "ok", detail: `${writer}catalog refreshed; installed+enabled at target ${options.target}` };
+  }
+  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)}` };
+  }
+  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) {
+    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)}` };
+    }
+    observed = claudeMmi(runner, env);
+  }
+  if (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` };
+  }
+  return { surface: "claude", from, to: options.target, verdict: "ok", detail: `catalog refreshed; converged and verified ${from ?? "absent"} -> ${options.target}` };
+}
+function codexMmi(runner, env) {
+  const result = runner("codex", ["plugin", "list", "--json"], env);
+  const parsed = parseJson(result);
+  if (!parsed || !Array.isArray(parsed.installed)) return { row: null, error: `codex plugin list --json failed: ${failure(result)}` };
+  return { row: parsed.installed.find((row) => row.pluginId === "mmi@mutmutco") ?? null };
+}
+function codexArm(options) {
+  const env = options.env ?? process.env;
+  const runner = options.runner ?? runHostCommand;
+  const before = codexMmi(runner, env);
+  if (before.error) return { surface: "codex", from: null, to: options.target, verdict: "defer", detail: before.error };
+  const from = before.row?.version ?? null;
+  if (options.dryRun) {
+    return { surface: "codex", from, to: options.target, verdict: "ok", detail: `dry-run: would upgrade mutmutco and converge mmi@mutmutco ${from ?? "absent"} -> ${options.target}` };
+  }
+  const upgrade = runner("codex", ["plugin", "marketplace", "upgrade", "mutmutco", "--json"], env);
+  const upgradeJson = parseJson(upgrade);
+  if (upgrade.status !== 0 || !upgradeJson || (upgradeJson.errors?.length ?? 0) > 0) {
+    return { surface: "codex", from, to: options.target, verdict: "defer", detail: `marketplace upgrade failed: ${failure(upgrade)}` };
+  }
+  let observed = codexMmi(runner, env);
+  if (observed.error) return { surface: "codex", from, to: options.target, verdict: "defer", detail: observed.error };
+  if (!observed.row) {
+    const install = runner("codex", ["plugin", "add", "mmi@mutmutco", "--json"], env);
+    if (install.status !== 0) {
+      return { surface: "codex", from, to: options.target, verdict: "defer", detail: `plugin add failed: ${failure(install)}` };
+    }
+    observed = codexMmi(runner, env);
+  }
+  if (observed.row?.version !== options.target || observed.row.installed !== true || observed.row.enabled !== true) {
+    return { surface: "codex", from, to: observed.row?.version ?? "unknown", verdict: "fail", detail: `post-upgrade evidence is version ${observed.row?.version ?? "missing"}, installed=${String(observed.row?.installed)}, enabled=${String(observed.row?.enabled)}, expected ${options.target}/true/true` };
+  }
+  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_os3.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);
+    return {
+      version: observed.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)}`
+    };
+  }
+  const config = readKiloConfig(env);
+  return {
+    version: kiloVersion(config?.specs ?? null),
+    location: kiloConfigPath(env),
+    detail: config ? "exact package pin read from Kilo config" : "Kilo config was unreadable"
+  };
+}
+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/arm-kimi.ts
+var import_node_child_process6 = require("node:child_process");
+var import_node_fs9 = require("node:fs");
+var import_node_path7 = require("node:path");
+
+// src/compat.ts
+var import_node_fs8 = require("node:fs");
+function readManifestCompat(manifestPath) {
+  try {
+    const parsed = JSON.parse((0, import_node_fs8.readFileSync)(manifestPath, "utf8"));
+    return typeof parsed.mmiCompat === "string" ? parsed.mmiCompat : void 0;
+  } catch {
+    return void 0;
+  }
+}
+
+// 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_path7.join)(root, ...rel.split("/"))));
+}
+function markerVersion(root) {
+  try {
+    const version = JSON.parse((0, import_node_fs9.readFileSync)((0, import_node_path7.join)(root, ".kimi-plugin", "plugin.json"), "utf8")).version;
+    return typeof version === "string" ? version : null;
+  } catch {
+    return null;
+  }
+}
+function packageVersion(root) {
+  try {
+    const version = JSON.parse((0, import_node_fs9.readFileSync)((0, import_node_path7.join)(root, "package.json"), "utf8")).version;
+    return typeof version === "string" ? version : null;
+  } catch {
+    return null;
+  }
+}
+function probeKimiInstallation(env = process.env) {
+  const location = (0, import_node_path7.join)(kimiHome(env), "plugins", "managed", "mmi");
+  const 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_path7.join)(kimiHome(env), ".mmi-updater");
+}
+function pruneScratchDir(root, keep) {
+  try {
+    for (const name of (0, import_node_fs9.readdirSync)(root)) {
+      if (name === keep) continue;
+      try {
+        (0, import_node_fs9.rmSync)((0, import_node_path7.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_process6.spawnSync)("powershell.exe", ["-NoProfile", "-Command", "Get-CimInstance Win32_Process | ForEach-Object { $_.Name + ' ' + $_.CommandLine }"], { encoding: "utf8", windowsHide: true, timeout: 15e3 }) : (0, import_node_child_process6.spawnSync)("ps", ["-eo", "args="], { encoding: "utf8", windowsHide: true, timeout: 15e3 });
+  if (result.status !== 0 || !(result.stdout ?? "").trim()) return { running: true, evidence: "the process list is unreadable \u2014 unsafe to write" };
+  for (const line of result.stdout.split(/\r?\n/)) {
+    const 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_fs9.renameSync)(quarantine, live);
+  } catch (error) {
+    return { restored: false, detail: `${error?.message ?? error}` };
+  }
+  if (!(0, import_node_fs9.existsSync)(live)) return { restored: false, detail: `${live} is still absent after the restore rename` };
+  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) => ({
+    surface: "kimi",
+    from,
+    to,
+    verdict,
+    detail,
+    // C11: the constraint of the tree LEFT at `live` — read at result time, so ok carries the new
+    // manifest's declaration and defer/fail carry the previous tree's (#4973 reconsult ruling).
+    compat: readManifestCompat((0, import_node_path7.join)(live, ".kimi-plugin", "plugin.json"))
+  });
+  const managedParent = (0, import_node_path7.join)(kimiHome(env), "plugins", "managed");
+  const live = (0, import_node_path7.join)(managedParent, "mmi");
+  const installed = markerVersion(live);
+  if (installed && compareSemver(installed, target) > 0) {
+    return result(installed, installed, "skip", `installed ${installed} is above candidate ${target} (monotonic)`);
+  }
+  const highWater = journalHighWater(paths.journalPath, "kimi");
+  if (highWater && compareSemver(highWater, target) > 0) {
+    return result(installed, highWater, "skip", `journal high-water ${highWater} is above candidate ${target} (monotonic)`);
+  }
+  if (installed === target && treeHealthy(live)) {
+    return result(installed, target, "ok", `already at target ${target}`);
+  }
+  if (dryRun) {
+    return result(installed, target, "ok", `dry-run: would converge ${installed ?? "absent"} -> ${target} (tarball generation switch while Kimi is absent)`);
+  }
+  const stageRoot = (0, import_node_path7.join)(paths.staging, "kimi", target);
+  const staged = (0, import_node_path7.join)(stageRoot, "node_modules", ...KIMI_PACKAGE.split("/"));
+  if (!treeHealthy(staged)) {
+    (0, import_node_fs9.mkdirSync)(stageRoot, { recursive: true });
+    (0, import_node_fs9.writeFileSync)((0, import_node_path7.join)(stageRoot, "package.json"), JSON.stringify({ name: "mmi-updater-stage", private: true }) + "\n");
+    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 quiescence = kimiHostRunning(env);
+  if (quiescence.running) {
+    return result(installed, target, "defer", `Kimi may be running \u2014 the managed tree is switched only while the host is absent: ${quiescence.evidence}`);
+  }
+  const scratch = scratchRoot(env);
+  const incomingRoot = (0, import_node_path7.join)(scratch, "incoming");
+  const incoming = (0, import_node_path7.join)(incomingRoot, target);
+  const quarantineRoot = (0, import_node_path7.join)(scratch, "quarantine");
+  const rejectedRoot = (0, import_node_path7.join)(scratch, "rejected");
+  try {
+    (0, import_node_fs9.mkdirSync)(managedParent, { recursive: true });
+    (0, import_node_fs9.mkdirSync)(quarantineRoot, { recursive: true });
+    (0, import_node_fs9.rmSync)(incomingRoot, { recursive: true, force: true });
+    (0, import_node_fs9.cpSync)(staged, incoming, { recursive: true });
+  } catch (error) {
+    return result(installed, target, "defer", `cannot place the incoming generation under ${scratch}: ${error?.message ?? error}`);
+  }
+  if (markerVersion(incoming) !== target || !treeHealthy(incoming)) {
+    return result(installed, target, "defer", `incoming generation verifies as ${markerVersion(incoming) ?? "unreadable"}, expected ${target}`);
+  }
+  const hadLive = (0, import_node_fs9.existsSync)(live);
+  const generation = `${installed ?? "unknown"}-${Date.now()}`;
+  const quarantine = (0, import_node_path7.join)(quarantineRoot, generation);
+  if (hadLive) {
+    try {
+      (0, import_node_fs9.renameSync)(live, quarantine);
+    } catch (error) {
+      return result(installed, target, "defer", `cannot quarantine the live generation: ${error?.message ?? error}`);
+    }
+  }
+  try {
+    (0, import_node_fs9.renameSync)(incoming, live);
+  } catch (error) {
+    const failed = `cannot switch the new generation in: ${error?.message ?? error}`;
+    if (!hadLive) {
+      return result(installed, target, "defer", `${failed} \u2014 no generation was displaced; ${live} is still absent`);
+    }
+    const restore = restoreQuarantine(quarantine, live);
+    return restore.restored ? result(installed, installed ?? "unknown", "defer", `${failed} \u2014 the previous generation is back in place (${restore.detail})`) : result(installed, "none", "fail", `${failed}; ROLLBACK FAILED (${restore.detail}) \u2014 ${live} now has NO plugin and Kimi enforces nothing until this is repaired; the known-good generation is intact at ${quarantine}`);
+  }
+  const switched = markerVersion(live);
+  if (switched !== target || !treeHealthy(live)) {
+    const observed = `post-switch marker is ${switched ?? "unreadable"}, expected ${target}`;
+    const rejectedName = `${target}-${Date.now()}`;
+    try {
+      (0, import_node_fs9.mkdirSync)(rejectedRoot, { recursive: true });
+      (0, import_node_fs9.renameSync)(live, (0, import_node_path7.join)(rejectedRoot, rejectedName));
+    } catch (error) {
+      return result(installed, switched ?? "unknown", "fail", `${observed} \u2014 the unverified tree could NOT be moved aside (${error?.message ?? error}) and is STILL LIVE at ${live}${hadLive ? `; the previous generation is intact at ${quarantine}` : ""}`);
+    }
+    pruneScratchDir(rejectedRoot, rejectedName);
+    if (!hadLive) {
+      return result(installed, "none", "fail", `${observed} \u2014 the unverified tree is parked at ${(0, import_node_path7.join)(rejectedRoot, rejectedName)}; ${live} is absent (there was no previous generation to restore)`);
+    }
+    const restore = restoreQuarantine(quarantine, live);
+    return restore.restored ? result(installed, installed ?? "unknown", "fail", `${observed} \u2014 the unverified tree is parked at ${(0, import_node_path7.join)(rejectedRoot, rejectedName)}; rolled back to ${installed ?? "the previous generation"} and read back (${restore.detail})`) : result(installed, "none", "fail", `${observed}; ROLLBACK FAILED (${restore.detail}) \u2014 ${live} now has NO plugin and Kimi enforces nothing until this is repaired; the known-good generation is intact at ${quarantine}`);
+  }
+  pruneScratchDir(quarantineRoot, hadLive ? generation : null);
+  pruneScratchDir(rejectedRoot, null);
+  try {
+    (0, import_node_fs9.rmSync)(incomingRoot, { recursive: true, force: true });
+  } catch {
+  }
+  return result(installed, target, "ok", `converged ${installed ?? "absent"} -> ${target} (staged, verified, switched${hadLive ? `; previous generation quarantined at ${quarantine}` : ""})`);
+}
+
+// src/arm-cursor.ts
+var import_node_fs10 = require("node:fs");
+var import_node_child_process7 = require("node:child_process");
+var import_node_os4 = require("node:os");
+var import_node_path8 = require("node:path");
+var PACKAGE = "@mutmutco/cursor-plugin";
+var MANIFEST = ".cursor-plugin/plugin.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"];
+function cursorPluginsRoot() {
+  return (0, import_node_path8.join)((0, import_node_os4.homedir)(), ".cursor", "plugins");
+}
+function treeHealthy2(root) {
+  return TREE_FILES.every((rel) => (0, import_node_fs10.existsSync)((0, import_node_path8.join)(root, ...rel.split("/"))));
+}
+function readJson(root, rel) {
+  try {
+    return JSON.parse((0, import_node_fs10.readFileSync)((0, import_node_path8.join)(root, ...rel.split("/")), "utf8"));
+  } catch {
+    return null;
+  }
+}
+function manifest(root) {
+  return readJson(root, MANIFEST);
+}
+function probeCursorInstallation() {
+  const location = (0, import_node_path8.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" };
+}
+function mmiOwned(root) {
+  return manifest(root)?.name === "mmi" || readJson(root, "package.json")?.name === PACKAGE;
+}
+function safeSegment(value) {
+  return value.replace(/[^0-9A-Za-z.+-]/g, "_").slice(0, 40) || "unknown";
+}
+function message(error) {
+  return String(error?.message ?? error).trim().replace(/\s+/g, " ").slice(0, 200);
+}
+function discard(path) {
+  try {
+    (0, import_node_fs10.rmSync)(path, { recursive: true, force: true });
+  } catch {
+  }
+}
+function cursorExecutable(line) {
+  const trimmed = line.trim();
+  if (!trimmed) return null;
+  const quoted = /^"([^"]+)"|^'([^']+)'/.exec(trimmed);
+  const executable = quoted ? quoted[1] ?? quoted[2] : trimmed.split(/\s+/)[0];
+  const base = executable.split(/[/\\]/).pop() ?? "";
+  const host = /^cursor(\.exe)?$/i.test(base) || /[/\\]Cursor\.app[/\\]/i.test(executable);
+  return host ? executable.slice(0, 160) : null;
+}
+function cursorHostEvidence(env) {
+  for (const marker of ["CURSOR_TRACE_ID", "CURSOR_SESSION_ID", "CURSOR_EXTENSION_HOST_ROLE"]) {
+    if (env[marker]?.trim()) return `env marker ${marker}`;
+  }
+  if (env.CURSOR_AGENT === "1") return "env marker CURSOR_AGENT=1";
+  const result = process.platform === "win32" ? (0, import_node_child_process7.spawnSync)("powershell.exe", ["-NoProfile", "-Command", "Get-CimInstance Win32_Process | ForEach-Object { $_.CommandLine }"], { encoding: "utf8", windowsHide: true, timeout: 15e3 }) : (0, import_node_child_process7.spawnSync)("ps", ["-eo", "args="], { encoding: "utf8", windowsHide: true, timeout: 15e3 });
+  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);
+    if (executable) return `process ${executable}`;
+  }
+  return null;
+}
+function writeRollbackPointer(root, entry) {
+  const path = (0, import_node_path8.join)(root, "quarantine", "rollback.json");
+  const tmp = `${path}.tmp-${process.pid}`;
+  try {
+    (0, import_node_fs10.writeFileSync)(tmp, JSON.stringify({ surface: "cursor", ts: (/* @__PURE__ */ new Date()).toISOString(), ...entry }, null, 2) + "\n", "utf8");
+    (0, import_node_fs10.renameSync)(tmp, path);
+  } catch {
+    discard(tmp);
+  }
+}
+function mtimeMs(path) {
+  try {
+    return (0, import_node_fs10.statSync)(path).mtimeMs;
+  } catch {
+    return 0;
+  }
+}
+function pruneQuarantine(root, keep) {
+  const dir = (0, import_node_path8.join)(root, "quarantine");
+  let generations;
+  try {
+    generations = (0, import_node_fs10.readdirSync)(dir, { withFileTypes: true }).filter((entry) => entry.isDirectory() && entry.name.startsWith("mmi-")).map((entry) => (0, import_node_path8.join)(dir, entry.name)).sort((a, b) => mtimeMs(b) - mtimeMs(a));
+  } catch {
+    return 0;
+  }
+  let stranded = 0;
+  try {
+    for (const entry of (0, import_node_fs10.readdirSync)(dir, { withFileTypes: true })) {
+      if (!entry.isFile() || !/^rollback\.json\.tmp-\d+$/.test(entry.name)) continue;
+      const path = (0, import_node_path8.join)(dir, entry.name);
+      if (Date.now() - mtimeMs(path) < STRANDED_TMP_AGE_MS) continue;
+      discard(path);
+      stranded += 1;
+    }
+  } catch {
+  }
+  const retained = new Set([...new Set([keep, ...generations].filter((path) => !!path))].slice(0, KEEP_GENERATIONS - 1));
+  let pruned = 0;
+  for (const path of generations) {
+    if (retained.has(path)) continue;
+    discard(path);
+    pruned += 1;
+  }
+  return pruned + stranded;
+}
+function restorePrevious(live, quarantined, broken) {
+  try {
+    (0, import_node_fs10.renameSync)(live, broken);
+  } catch {
+    return "kept-broken";
+  }
+  try {
+    (0, import_node_fs10.renameSync)(quarantined, live);
+    return "restored";
+  } catch {
+    try {
+      (0, import_node_fs10.renameSync)(broken, live);
+      return "kept-broken";
+    } catch {
+      return "lost";
+    }
+  }
+}
+function cursorArm(options) {
+  const env = options.env ?? process.env;
+  const { target, dryRun, paths } = options;
+  const root = cursorPluginsRoot();
+  const live = (0, import_node_path8.join)(root, "local", "mmi");
+  const result = (from, to, verdict, detail) => ({
+    surface: "cursor",
+    from,
+    to,
+    verdict,
+    detail,
+    // C11: the constraint of the generation LEFT at `live` — read at result time, so a failed
+    // switch reports the restored generation's declaration, not the rejected one's (#4973).
+    compat: readManifestCompat((0, import_node_path8.join)(live, MANIFEST))
+  });
+  const current = manifest(live);
+  const installed = current?.version ?? null;
+  if (installed && compareSemver(installed, target) > 0) {
+    return result(installed, installed, "skip", `installed ${installed} is above candidate ${target} (monotonic)`);
+  }
+  const highWater = journalHighWater(paths.journalPath, "cursor");
+  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)) {
+    return result(installed, target, "ok", `already at target ${target}`);
+  }
+  if ((0, import_node_fs10.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) {
+    return result(installed, target, "ok", `dry-run: would stage ${PACKAGE}@${target} and switch ${installed ?? "absent"} -> ${target} while Cursor is absent`);
+  }
+  const staged = stagePackage({ surface: "cursor", packageName: PACKAGE, target, witness: MANIFEST, paths, env });
+  if ("defer" in staged) {
+    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`);
+  }
+  const busy = cursorHostEvidence(env);
+  if (busy) {
+    return result(installed, target, "defer", `Cursor is running (${busy}) \u2014 the plugin tree is only swapped while the host is absent`);
+  }
+  const stamp = Date.now();
+  const incoming = (0, import_node_path8.join)(root, "staging", `mmi-${safeSegment(target)}-${stamp}`);
+  const quarantined = (0, import_node_path8.join)(root, "quarantine", `mmi-${safeSegment(installed ?? "unknown")}-${stamp}`);
+  for (const dir of ["local", "staging", "quarantine"]) (0, import_node_fs10.mkdirSync)((0, import_node_path8.join)(root, dir), { recursive: true });
+  try {
+    discard(incoming);
+    (0, import_node_fs10.cpSync)(staged.packageRoot, incoming, { recursive: true });
+  } catch (error) {
+    discard(incoming);
+    return result(installed, target, "defer", `copy into ${root} failed: ${message(error)}`);
+  }
+  if (manifest(incoming)?.version !== target || !treeHealthy2(incoming)) {
+    discard(incoming);
+    return result(installed, target, "defer", "the copy on the Cursor volume did not reproduce the verified tree");
+  }
+  const started = cursorHostEvidence(env);
+  if (started) {
+    discard(incoming);
+    return result(installed, target, "defer", `Cursor started during staging (${started}) \u2014 the plugin tree is only swapped while the host is absent`);
+  }
+  let displaced = false;
+  try {
+    if ((0, import_node_fs10.existsSync)(live)) {
+      (0, import_node_fs10.renameSync)(live, quarantined);
+      displaced = true;
+    }
+    (0, import_node_fs10.renameSync)(incoming, live);
+  } catch (error) {
+    if (displaced && !(0, import_node_fs10.existsSync)(live)) {
+      try {
+        (0, import_node_fs10.renameSync)(quarantined, live);
+      } catch {
+      }
+    }
+    discard(incoming);
+    return result(installed, target, "defer", `generation switch failed, previous generation retained: ${message(error)}`);
+  }
+  const evidence = manifest(live)?.version;
+  if (evidence !== target || !treeHealthy2(live)) {
+    const broken = `${(0, import_node_path8.join)(root, "quarantine", `mmi-${safeSegment(evidence ?? "broken")}-${stamp}`)}-failed`;
+    const outcome = displaced ? restorePrevious(live, quarantined, broken) : "none";
+    const detail = outcome === "restored" ? `restored the previous generation ${installed ?? "unknown"}, unverified tree kept at ${broken}` : outcome === "lost" ? `restore failed and ${live} is missing \u2014 the previous generation is at ${quarantined}` : displaced ? `restore failed, the unverified tree is still live and the previous generation is at ${quarantined}` : "nothing was displaced \u2014 there is no previous generation to restore";
+    writeRollbackPointer(root, outcome === "restored" ? { installed: installed ?? "unknown", previous: null, generation: null } : { installed: evidence ?? "unknown", previous: installed, generation: displaced ? quarantined : null });
+    return result(installed, outcome === "restored" ? installed ?? "unknown" : evidence ?? "unknown", "fail", `post-switch marker reads ${evidence ?? "missing"}, expected ${target}; ${detail}`);
+  }
+  writeRollbackPointer(root, { installed: target, previous: installed, generation: displaced ? quarantined : null });
+  const pruned = pruneQuarantine(root, displaced ? quarantined : null);
+  const previous = displaced ? `previous generation quarantined at ${quarantined}` : "no previous generation to quarantine";
+  return result(installed, target, "ok", `switched ${installed ?? "absent"} -> ${target}; ${previous}${pruned ? `; pruned ${pruned} older generation${pruned === 1 ? "" : "s"}` : ""}`);
+}
+
+// src/arm-jervcode.ts
+var import_node_fs11 = require("node:fs");
+var import_node_path9 = require("node:path");
+var PI_PACKAGE = "@mutmutco/pi-plugin";
+function hostEnv(env) {
+  const dir = jervcodeAgentDir(env);
+  return { ...env, JERVCODE_CODING_AGENT_DIR: dir, PI_CODING_AGENT_DIR: dir };
+}
+function hostCommands(_env) {
+  return ["pi", "jervcode"];
+}
+function readPackageSpecs(env) {
+  try {
+    const settings = JSON.parse((0, import_node_fs11.readFileSync)((0, import_node_path9.join)(jervcodeAgentDir(env), "settings.json"), "utf8"));
+    return Array.isArray(settings.packages) ? settings.packages.filter((entry) => typeof entry === "string") : [];
+  } catch {
+    return null;
+  }
+}
+function installedVersion(env) {
+  try {
+    const manifest2 = JSON.parse((0, import_node_fs11.readFileSync)((0, import_node_path9.join)(jervcodeAgentDir(env), "npm", "node_modules", ...PI_PACKAGE.split("/"), "package.json"), "utf8"));
+    return typeof manifest2.version === "string" ? manifest2.version : null;
+  } catch {
+    return null;
+  }
+}
+function probeJervcodeInstallation(env = process.env) {
+  const location = (0, import_node_path9.join)(jervcodeAgentDir(env), "npm", "node_modules", ...PI_PACKAGE.split("/"));
+  const version = installedVersion(env);
+  return { version, location, detail: version ? "materialized pi package manifest" : "materialized pi package manifest was unreadable" };
+}
+function isLegacyMmiPiPath(spec) {
+  return /[/\\]mutmutco[/\\]mmi[/\\]\d+\.\d+\.\d+[/\\]\.pi-plugin[/\\]?$/i.test(spec);
+}
+function failure2(result) {
+  return (result.stderr || result.stdout).split("\n").filter(Boolean).slice(-3).join(" | ") || `exit ${result.status ?? "signal"}`;
+}
+function jervcodeArm(options) {
+  const env = options.env ?? process.env;
+  const runner = options.runner ?? runHostCommand;
+  const exact = `npm:${PI_PACKAGE}@${options.target}`;
+  const result = (from2, to, verdict, detail) => ({
+    surface: "jervcode",
+    from: from2,
+    to,
+    verdict,
+    detail,
+    // C11: the constraint of the package pi LEFT materialised — read at result time, so defer/fail
+    // carry the previous payload's declaration (#4973 reconsult ruling).
+    compat: readManifestCompat((0, import_node_path9.join)(jervcodeAgentDir(env), "npm", "node_modules", ...PI_PACKAGE.split("/"), "package.json"))
+  });
+  const before = readPackageSpecs(env);
+  if (!before) return result(null, options.target, "defer", `cannot read ${(0, import_node_path9.join)(jervcodeAgentDir(env), "settings.json")}`);
+  const from = installedVersion(env);
+  const legacy = before.filter(isLegacyMmiPiPath);
+  const highWater = journalHighWater(options.paths.journalPath, "jervcode");
+  const floor = from && compareSemver(from, options.target) > 0 ? `installed ${from} is above candidate ${options.target} (monotonic)` : highWater && compareSemver(highWater, options.target) > 0 ? `journal high-water ${highWater} is above candidate ${options.target} (monotonic)` : null;
+  if (options.dryRun) {
+    const action = floor ? `hold ${from ?? "the install"} and skip the install (${floor})` : before.includes(exact) && from === options.target ? "keep exact pin" : `install ${exact}`;
+    return { surface: "jervcode", from, to: options.target, verdict: "ok", detail: `dry-run: would ${action}${legacy.length ? ` and retire ${legacy.length} legacy claude-cache path registration${legacy.length === 1 ? "" : "s"}` : ""}`, compat: readManifestCompat((0, import_node_path9.join)(jervcodeAgentDir(env), "npm", "node_modules", ...PI_PACKAGE.split("/"), "package.json")) };
+  }
+  const hosted = hostEnv(env);
+  const commands = hostCommands(env);
+  const command = commands.find((bin) => runner(bin, ["--version"], hosted).status === 0);
+  if (!command) return { surface: "jervcode", from, to: options.target, verdict: "defer", detail: "neither `jervcode` nor `pi` answered --version \u2014 the host CLI is not on PATH", compat: readManifestCompat((0, import_node_path9.join)(jervcodeAgentDir(env), "npm", "node_modules", ...PI_PACKAGE.split("/"), "package.json")) };
+  if (!floor && (!before.includes(exact) || from !== options.target)) {
+    const install = runner(command, ["install", exact], hosted);
+    if (install.status !== 0) {
+      return { surface: "jervcode", from, to: options.target, verdict: "defer", detail: `${command} install ${exact} failed: ${failure2(install)}`, compat: readManifestCompat((0, import_node_path9.join)(jervcodeAgentDir(env), "npm", "node_modules", ...PI_PACKAGE.split("/"), "package.json")) };
+    }
+  }
+  for (const stale of legacy) {
+    const removed = runner(command, ["remove", stale], hosted);
+    if (removed.status !== 0) {
+      return { surface: "jervcode", from, to: options.target, verdict: "defer", detail: `${command} remove of the legacy registration failed: ${failure2(removed)}`, compat: readManifestCompat((0, import_node_path9.join)(jervcodeAgentDir(env), "npm", "node_modules", ...PI_PACKAGE.split("/"), "package.json")) };
+    }
+  }
+  const after = readPackageSpecs(env);
+  const converged = installedVersion(env);
+  const legacyAfter = after?.filter(isLegacyMmiPiPath) ?? [];
+  const retired = legacy.length ? `; retired ${legacy.length} legacy claude-cache path registration${legacy.length === 1 ? "" : "s"}` : "";
+  if (floor && !legacyAfter.length) {
+    return { surface: "jervcode", from, to: converged ?? highWater ?? options.target, verdict: "skip", detail: `${floor}${retired}`, compat: readManifestCompat((0, import_node_path9.join)(jervcodeAgentDir(env), "npm", "node_modules", ...PI_PACKAGE.split("/"), "package.json")) };
+  }
+  if (!after?.includes(exact) || converged !== options.target || legacyAfter.length) {
+    return {
+      surface: "jervcode",
+      from,
+      to: converged ?? "unknown",
+      verdict: "fail",
+      detail: `post-install evidence is spec=${after?.includes(exact) ? exact : "missing"}, materialised ${converged ?? "nothing"}, legacy=${legacyAfter.length}; expected ${exact} materialised at ${options.target} with no legacy paths`
+    };
+  }
+  return {
+    surface: "jervcode",
+    from,
+    to: options.target,
+    verdict: "ok",
+    detail: `${exact} pinned and materialised at ${options.target}${retired}; loads at the next seat launch`
+  };
+}
+
+// src/reap.ts
+var import_node_child_process8 = require("node:child_process");
+var import_node_fs12 = require("node:fs");
+var import_node_path10 = 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_fs12.readdirSync)(path, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+  } catch {
+    return [];
+  }
+}
+function generationSets(root) {
+  const children = listDirs(root);
+  if (children.some((name) => parseSemver(name))) return [root];
+  return children.map((name) => (0, import_node_path10.join)(root, name)).filter((path) => listDirs(path).some((name) => parseSemver(name)));
+}
+function pruneGenerations(root, category, dryRun) {
+  let reaped = 0;
+  const failures = [];
+  for (const set of generationSets(root)) {
+    const versions = listDirs(set).filter((name) => parseSemver(name)).sort((a, b) => compareSemver(b, a));
+    for (const version of versions.slice(KEEP_GENERATIONS2)) {
+      if (dryRun) {
+        reaped += 1;
+        continue;
+      }
+      try {
+        (0, import_node_fs12.rmSync)((0, import_node_path10.join)(set, version), { recursive: true, force: true });
+        reaped += 1;
+      } catch (error) {
+        failures.push(`${version}: ${error?.code ?? error?.message ?? error}`);
+      }
+    }
+  }
+  if (!reaped && !failures.length) return { category, reaped: 0, verdict: "skip", detail: `${root}: within keep-${KEEP_GENERATIONS2}` };
+  const verb = dryRun ? "dry-run: would prune" : "pruned";
+  const stuck = failures.length ? `; ${failures.length} locked (${failures.join(", ")})` : "";
+  return { category, reaped, verdict: failures.length ? "defer" : "ok", detail: `${verb} ${reaped} generation(s) below keep-${KEEP_GENERATIONS2} under ${root}${stuck}` };
+}
+var LEASE_STEAL_SCRATCH = /^lease\.lock\.stale-\d+$/;
+function atomicWriteScratch(path) {
+  const literal = (0, import_node_path10.basename)(path).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return { dir: (0, import_node_path10.dirname)(path), pattern: new RegExp(`^${literal}\\.tmp-\\d+$`) };
+}
+function reapScratch(context, dryRun) {
+  const category = "scratch";
+  const scanned = /* @__PURE__ */ new Map();
+  const scan = (dir, pattern) => void scanned.set(dir, [...scanned.get(dir) ?? [], pattern]);
+  scan(context.root, LEASE_STEAL_SCRATCH);
+  for (const path of context.atomicWritePaths) {
+    const { dir, pattern } = atomicWriteScratch(path);
+    scan(dir, pattern);
+  }
+  const now = Date.now();
+  let reaped = 0;
+  const failures = [];
+  const unreadable = [];
+  for (const [dir, patterns] of scanned) {
+    let entries;
+    try {
+      entries = (0, import_node_fs12.readdirSync)(dir, { withFileTypes: true });
+    } catch {
+      unreadable.push(dir);
+      continue;
+    }
+    for (const entry of entries) {
+      if (!patterns.some((pattern) => pattern.test(entry.name))) continue;
+      if (!entry.isFile()) continue;
+      const path = (0, import_node_path10.join)(dir, entry.name);
+      let ageMs;
+      try {
+        ageMs = now - (0, import_node_fs12.statSync)(path).mtimeMs;
+      } catch {
+        continue;
+      }
+      if (ageMs < SCRATCH_AGE_MS) continue;
+      if (dryRun) {
+        reaped += 1;
+        continue;
+      }
+      try {
+        (0, import_node_fs12.rmSync)(path, { force: true });
+        reaped += 1;
+      } catch (error) {
+        failures.push(`${entry.name}: ${error?.code ?? error?.message ?? error}`);
+      }
+    }
+  }
+  const swept = [...scanned.keys()].filter((dir) => !unreadable.includes(dir));
+  if (!reaped && !failures.length) return { category, reaped: 0, verdict: "skip", detail: `no scratch older than ${SCRATCH_AGE_MS / 36e5}h under ${swept.join(", ") || "any readable scratch directory"}` };
+  const verb = dryRun ? "dry-run: would remove" : "removed";
+  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_process8.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;
+  const guarded = (category, run) => {
+    try {
+      return run();
+    } catch (error) {
+      return { category, reaped: 0, verdict: "fail", detail: `reap failed: ${error?.message ?? error}` };
+    }
+  };
+  const atomicWritePaths = [claudeMarketplacesPath(env), kiloConfigPath(env)];
+  return [
+    guarded("staging-prune", () => pruneGenerations(paths.staging, "staging-prune", dryRun)),
+    guarded("scratch", () => reapScratch({ root: paths.root, atomicWritePaths }, dryRun)),
+    guarded("hook-orphans", () => reapHookOrphans(dryRun))
+  ];
+}
+
+// src/reconcile.ts
+var REPO_URL_DEFAULT = "https://github.com/mutmutco/MMI-Hub.git";
+var CANDIDATE_BOUND_DEFAULT = 12;
+function reconcile(options) {
+  const env = options.env ?? process.env;
+  const say = (line) => options.narrate?.(line);
+  const run = `${(/* @__PURE__ */ new Date()).toISOString()}-${process.pid}`;
+  const paths = ensureState(env);
+  const repoUrl = env.MMI_UPDATER_REPO || REPO_URL_DEFAULT;
+  const bound = Number(env.MMI_UPDATER_CANDIDATES || CANDIDATE_BOUND_DEFAULT) || CANDIDATE_BOUND_DEFAULT;
+  const journal = (event) => {
+    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, exit: 0 };
+  const recordArm = (arm) => {
+    journal({ kind: "arm", surface: arm.surface, from: arm.from, to: arm.to, verdict: arm.verdict, detail: arm.detail, compat: arm.compat });
+    if (arm.verdict === "defer") summary.exit = Math.max(summary.exit, 2);
+    if (arm.verdict === "fail") summary.exit = Math.max(summary.exit, 3);
+  };
+  try {
+    say("acquiring single-writer lease");
+    return withLease(paths.leasePath, () => {
+      summary.reap = reap({ paths, dryRun: options.dryRun, env });
+      for (const row of summary.reap) journal({ kind: "reap", surface: row.category, verdict: row.verdict, count: row.reaped, detail: row.detail });
+      for (const row of summary.reap.filter((entry) => entry.verdict !== "skip")) say(`reap ${row.category}: ${row.verdict}${row.detail ? " \u2014 " + row.detail : ""}`);
+      say("polling npm for @mutmutco/cli versions");
+      const versions = npmVersions("@mutmutco/cli", env).sort((a, b) => compareSemver(b, a));
+      if (!versions.length) {
+        journal({ kind: "poll", verdict: "fail", detail: "@mutmutco/cli has no npm versions \u2014 cannot discover a candidate" });
+        summary.exit = 1;
+        summary.detail = "npm poll returned no versions for @mutmutco/cli";
+        return summary;
+      }
+      say("fetching release BOM gate cache");
+      ensureBareCache(paths.gitCache, repoUrl);
+      fetchIntoCache(paths.gitCache, repoUrl, "refs/heads/main:refs/heads/main");
+      for (const candidate of versions.slice(0, bound)) {
+        say(`gating candidate v${candidate}`);
+        const gate = gateCandidate(paths.gitCache, repoUrl, candidate);
+        if (!gate.ok) {
+          say(`candidate v${candidate} rejected (${gate.reason ?? "gate"})`);
+          journal({ kind: "candidate-reject", to: candidate, verdict: "skip", detail: gate.reason ?? "gate rejected" });
+          continue;
+        }
+        const atomicity = checkAtomicity(paths.gitCache, gate.tagCommit, gate.bom, candidate, {
+          distIntegrity: (spec) => {
+            const integrity = npmView(spec, "dist.integrity", env);
+            return typeof integrity === "string" ? integrity : null;
+          }
+        });
+        if (!atomicity.ok) {
+          journal({ kind: "candidate-reject", to: candidate, verdict: "skip", detail: `atomicity: ${atomicity.rows.filter((row) => !row.ok).map((row) => row.detail).join("; ")}` });
+          continue;
+        }
+        summary.target = candidate;
+        summary.gate = `tag v${candidate} reachable from main, BOM stamp coherent`;
+        summary.atomicity = atomicity;
+        journal({ kind: "target", to: candidate, verdict: "ok", detail: summary.gate });
+        break;
+      }
+      if (!summary.target) {
+        say("no green target \u2014 deferred");
+        journal({ kind: "target", verdict: "defer", detail: `no green candidate in the newest ${Math.min(bound, versions.length)} versions \u2014 registry not ready for this fleet stamp yet` });
+        for (const probe of enumerateSurfaces(env)) {
+          summary.surfaces.push({ id: probe.id, present: probe.present, action: probe.present ? "deferred-no-target" : "absent-skip" });
+          journal({ kind: "surface", surface: probe.id, present: probe.present, verdict: "skip", detail: probe.present ? "present; no green target yet" : `absent (${probe.marker}) \u2014 skipped` });
+        }
+        return summary;
+      }
+      say(`target v${summary.target} (${summary.gate})`);
+      say(`cli: converging to v${summary.target}`);
+      const cli = cliArm({ target: summary.target, dryRun: options.dryRun, paths, env });
+      summary.cli = cli;
+      recordArm(cli);
+      say(`cli: ${cli.verdict}${cli.detail ? " \u2014 " + cli.detail : ""}`);
+      for (const probe of enumerateSurfaces(env)) {
+        if (!probe.present) {
+          summary.surfaces.push({ id: probe.id, present: false, action: "absent-skip" });
+          journal({ kind: "surface", surface: probe.id, present: false, verdict: "skip", detail: `absent (${probe.marker}) \u2014 skipped` });
+          continue;
+        }
+        say(`${probe.id}: converging to v${summary.target}`);
+        const arm = probe.id === "claude" ? claudeArm({ target: summary.target, dryRun: options.dryRun, env }) : probe.id === "codex" ? codexArm({ target: summary.target, dryRun: options.dryRun, env }) : 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 }) : null;
+        if (arm) {
+          summary.plugins.push(arm);
+          summary.surfaces.push({ id: probe.id, present: true, action: `arm-${arm.verdict}` });
+          recordArm(arm);
+          say(`${probe.id}: ${arm.verdict}${arm.detail ? " \u2014 " + arm.detail : ""}`);
+        } else {
+          summary.surfaces.push({ id: probe.id, present: true, action: "arm-pending" });
+          journal({ kind: "surface", surface: probe.id, present: true, verdict: "skip", detail: `present, its converge arm has not landed yet (target ${summary.target})` });
+        }
+      }
+      say("updater: self-bootstrap");
+      const self = selfArm({ target: summary.target, dryRun: options.dryRun, paths, env });
+      summary.updater = self;
+      recordArm(self);
+      say(`updater: ${self.verdict}${self.detail ? " \u2014 " + self.detail : ""}`);
+      return summary;
+    });
+  } catch (error) {
+    if (error instanceof UpdaterBusy || error instanceof GateEnvError) {
+      journal({ kind: "reconcile", verdict: "defer", detail: error.message });
+      summary.exit = 1;
+      summary.detail = error.message;
+      return summary;
+    }
+    throw error;
+  } finally {
+    if (!summary.journalOk && summary.exit < 4) summary.exit = 4;
+  }
+}
+
+// src/scheduler.ts
+var import_node_child_process9 = require("node:child_process");
+var import_node_fs13 = require("node:fs");
+var import_node_path11 = require("node:path");
+var TASK_NAME = "MMI Fleet Updater";
+var LAUNCHER_FILE = "reconcile-hidden.vbs";
+var RUN_BOUND = "PT15M";
+var REPEAT_INTERVAL = "PT1H";
+var CADENCE = `hourly from registration, StartWhenAvailable, single-instance, ${RUN_BOUND} bound`;
+function schtasks(args) {
+  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 xmlEscape(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function localStartBoundary(now) {
+  const pad = (value) => String(value).padStart(2, "0");
+  return `${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())}T${pad(now.getHours())}:${pad(now.getMinutes())}:${pad(now.getSeconds())}`;
+}
+function launcherVbs(nodeExe, hubDist) {
+  const vbsQuote = (value) => value.replaceAll('"', '""');
+  return `' MMI Hub maintenance launcher \u2014 generated by \`mmi-hub autoupdate on\`.
+' wscript //B starts node with the window hidden so the hourly tick never flashes a console.
+' The exit code is propagated and reported by \`mmi-hub status\`.
+Dim shell, code
+Set shell = CreateObject("WScript.Shell")
+code = shell.Run("""${vbsQuote(nodeExe)}"" ""${vbsQuote(hubDist)}"" update", 0, True)
+WScript.Quit code
+`;
+}
+function taskXml(launcherPath, workDir, userId, startBoundary) {
+  return `<?xml version="1.0" encoding="UTF-16"?>
+<Task version="1.2" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">
+  <RegistrationInfo>
+    <Description>MMI Hub maintenance \u2014 converge this machine's MMI surfaces to the newest gated release</Description>
+  </RegistrationInfo>
+  <Triggers>
+    <TimeTrigger>
+      <StartBoundary>${xmlEscape(startBoundary)}</StartBoundary>
+      <Enabled>true</Enabled>
+      <Repetition>
+        <Interval>${REPEAT_INTERVAL}</Interval>
+        <StopAtDurationEnd>false</StopAtDurationEnd>
+      </Repetition>
+    </TimeTrigger>
+  </Triggers>
+  <Principals>
+    <Principal id="Author">
+      <UserId>${xmlEscape(userId)}</UserId>
+      <LogonType>InteractiveToken</LogonType>
+      <RunLevel>LeastPrivilege</RunLevel>
+    </Principal>
+  </Principals>
+  <Settings>
+    <MultipleInstancesPolicy>IgnoreNew</MultipleInstancesPolicy>
+    <DisallowStartIfOnBatteries>false</DisallowStartIfOnBatteries>
+    <StopIfGoingOnBatteries>false</StopIfGoingOnBatteries>
+    <AllowHardTerminate>true</AllowHardTerminate>
+    <StartWhenAvailable>true</StartWhenAvailable>
+    <ExecutionTimeLimit>${RUN_BOUND}</ExecutionTimeLimit>
+    <Enabled>true</Enabled>
+  </Settings>
+  <Actions Context="Author">
+    <Exec>
+      <Command>wscript.exe</Command>
+      <Arguments>//B //Nologo "${xmlEscape(launcherPath)}"</Arguments>
+      <WorkingDirectory>${xmlEscape(workDir)}</WorkingDirectory>
+    </Exec>
+  </Actions>
+</Task>
+`;
+}
+function readLauncher(path) {
+  try {
+    return (0, import_node_fs13.readFileSync)(path, "utf8");
+  } catch {
+    return null;
+  }
+}
+function psQuote(value) {
+  return `'${value.replaceAll("'", "''")}'`;
+}
+function elevatedRelaunch(mode, env) {
+  if (env.MMI_UPDATER_ELEVATED_RETRY === "1") return false;
+  const self = process.argv[1];
+  const command = self ? `"${process.execPath}" "${self}" autoupdate ${mode}` : `mmi-hub autoupdate ${mode}`;
+  const relaunch = (0, import_node_child_process9.spawnSync)(
+    "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 }
+  );
+  return relaunch.status === 0;
+}
+var NEVER_RUN_RESULT = 267011;
+var NEVER_RUN_YEAR = 1999;
+function taskRunInfo() {
+  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 }
+  );
+  if (result.status !== 0) return null;
+  try {
+    const parsed = JSON.parse(result.stdout);
+    return {
+      lastRunTime: typeof parsed.LastRunTime === "string" ? parsed.LastRunTime : null,
+      lastTaskResult: typeof parsed.LastTaskResult === "number" ? parsed.LastTaskResult : null,
+      nextRunTime: typeof parsed.NextRunTime === "string" ? parsed.NextRunTime : null
+    };
+  } catch {
+    return null;
+  }
+}
+function neverRan(info) {
+  return info.lastTaskResult === NEVER_RUN_RESULT || (info.lastRunTime?.includes(String(NEVER_RUN_YEAR)) ?? false);
+}
+function schedulerStatus(env = process.env) {
+  const empty = { lastRunTime: null, lastTaskResult: null, nextRunTime: null };
+  if (process.platform !== "win32") {
+    return { ok: false, supported: false, enabled: false, ...empty, detail: "automatic scheduling is available on Windows Task Scheduler only" };
+  }
+  const query = schtasks(["/query", "/tn", TASK_NAME, "/xml"]);
+  if (query.status !== 0) {
+    return { ok: false, supported: true, enabled: false, ...empty, 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_path11.join)(statePaths(env).root, LAUNCHER_FILE);
+  const info = taskRunInfo();
+  const runInfo = info ?? empty;
+  const fail = (detail) => ({ ok: false, supported: true, enabled: true, ...runInfo, detail });
+  if (!query.stdout.includes(launcherPath)) {
+    return fail(`"${TASK_NAME}" action does not run the hidden launcher ${launcherPath} \u2014 run \`mmi-hub autoupdate on\``);
+  }
+  const launcher = readLauncher(launcherPath);
+  if (hubDist && !launcher?.includes(hubDist)) {
+    return fail(`"${TASK_NAME}" launcher does not point at the current @mutmutco/hub dist ${hubDist} \u2014 run \`mmi-hub autoupdate on\``);
+  }
+  if (query.stdout.includes("<LogonTrigger>")) {
+    return fail(`"${TASK_NAME}" still carries the dormant logon-only trigger \u2014 run \`mmi-hub autoupdate on\``);
+  }
+  if (!query.stdout.includes("<TimeTrigger>") || !query.stdout.includes(`<Interval>${REPEAT_INTERVAL}</Interval>`)) {
+    return fail(`"${TASK_NAME}" has no ${REPEAT_INTERVAL}-repeating TimeTrigger \u2014 run \`mmi-hub autoupdate on\``);
+  }
+  if (info && neverRan(info) && !info.nextRunTime) {
+    return fail(`"${TASK_NAME}" has never run and has no next run time \u2014 run \`mmi-hub autoupdate on\``);
+  }
+  const points = `points at ${hubDist ?? "the registered Hub dist"}`;
+  const ran = !info ? "run history unreadable" : neverRan(info) ? "never run yet" : `last run ${info.lastRunTime} \u2192 exit ${info.lastTaskResult ?? "unknown"}`;
+  return { ok: true, supported: true, enabled: true, ...runInfo, detail: `"${TASK_NAME}" registered ${CADENCE}; ${points}; ${ran}; next ${runInfo.nextRunTime ?? "unscheduled"}` };
+}
+function installTask(env = process.env) {
+  if (process.platform !== "win32") return { ok: false, detail: "scheduler registration is Windows Task Scheduler only" };
+  const current = schedulerStatus(env);
+  if (current.ok) return { ok: true, detail: `already enabled \u2014 ${current.detail}` };
+  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 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_path11.join)(paths.root, LAUNCHER_FILE);
+  (0, import_node_fs13.writeFileSync)(launcherPath, launcherVbs(process.execPath, hubDist), "utf8");
+  const xmlPath = (0, import_node_path11.join)(paths.root, "task.xml");
+  (0, import_node_fs13.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);
+    if (!denied || !elevatedRelaunch("on", env)) {
+      return { ok: false, detail: denied ? "task creation needs elevation and UAC consent was not granted \u2014 run `mmi-hub autoupdate on` from an elevated terminal" : `schtasks /create failed: ${(create.stderr || create.stdout).trim()}` };
+    }
+    const verify = schedulerStatus(env);
+    return verify.ok ? { ok: true, detail: `enabled "${TASK_NAME}" (elevated) \u2014 ${CADENCE}` } : { ok: false, detail: `elevated registration did not take: ${verify.detail}` };
+  }
+  return { ok: true, detail: `enabled "${TASK_NAME}" \u2014 ${CADENCE} \u2192 ${hubDist}` };
+}
+function uninstallTask(env = process.env) {
+  if (process.platform !== "win32") return { ok: false, detail: "scheduler registration is Windows Task Scheduler only" };
+  const del = schtasks(["/delete", "/tn", TASK_NAME, "/f"]);
+  if (del.status !== 0) {
+    const query = schtasks(["/query", "/tn", TASK_NAME]);
+    if (query.status !== 0 && !/access is denied/i.test(del.stderr + del.stdout)) {
+      dropLauncher(env);
+      return { ok: true, detail: `automatic updates already off \u2014 "${TASK_NAME}" is not registered; installed tooling was kept` };
+    }
+    const denied = /access is denied/i.test(del.stderr + del.stdout);
+    if (!denied || !elevatedRelaunch("off", env)) {
+      return { ok: false, detail: denied ? "task deletion needs elevation and UAC consent was not granted \u2014 run `mmi-hub autoupdate off` from an elevated terminal" : `schtasks /delete failed: ${(del.stderr || del.stdout).trim()}` };
+    }
+    if (schtasks(["/query", "/tn", TASK_NAME]).status === 0) {
+      return { ok: false, detail: `elevated deletion did not take: "${TASK_NAME}" is still registered` };
+    }
+  }
+  dropLauncher(env);
+  return { ok: true, detail: `automatic updates off \u2014 removed "${TASK_NAME}"; installed tooling was kept` };
+}
+function dropLauncher(env) {
+  try {
+    (0, import_node_fs13.rmSync)((0, import_node_path11.join)(statePaths(env).root, LAUNCHER_FILE), { force: true });
+  } catch {
+  }
+}
+
+// src/status.ts
+var import_node_fs14 = require("node:fs");
+function readJournal(path) {
+  try {
+    const events = (0, import_node_fs14.readFileSync)(path, "utf8").split("\n").filter((line) => line.trim()).map((line) => {
+      try {
+        return JSON.parse(line);
+      } catch {
+        return null;
+      }
+    }).filter((event) => event !== null);
+    return { events, error: null };
+  } catch (error) {
+    return error?.code === "ENOENT" ? { events: [], error: null } : { events: [], error: `journal unreadable: ${error?.message ?? error}` };
+  }
+}
+function versionState(installed, expected) {
+  if (!installed || !expected) return "unknown";
+  const relation = compareSemver(installed, expected);
+  return relation === 0 ? "current" : relation > 0 ? "ahead" : "behind";
+}
+function hubStatus(hubVersion, env = process.env, invokedPath = process.argv[1]) {
+  const paths = statePaths(env);
+  const { events, error } = readJournal(paths.journalPath);
+  const realEvents = events.filter((event) => !event.dryRun);
+  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 actual = /* @__PURE__ */ new Map();
+  const hubDist = globalDist(env, "@mutmutco/hub", "dist/index.cjs");
+  const globalHubVersion = hubDist ? probeVersion(hubDist) : null;
+  actual.set("hub", globalHubVersion ? { version: globalHubVersion, location: hubDist, detail: "absolute global Hub binary" } : { version: hubVersion, location: invokedPath ?? null, detail: "currently executing Hub bundle (global package location unavailable)" });
+  actual.set("cli", probeCliInstallation(env));
+  for (const surface of enumerateSurfaces(env).filter((probe) => probe.present)) {
+    if (surface.id === "claude" || surface.id === "codex" || surface.id === "kilo") {
+      actual.set(surface.id, probeNativeHostInstallation(surface.id, env));
+    } else if (surface.id === "kimi") {
+      actual.set(surface.id, probeKimiInstallation(env));
+    } else if (surface.id === "cursor") {
+      actual.set(surface.id, probeCursorInstallation());
+    } else if (surface.id === "jervcode") {
+      actual.set(surface.id, probeJervcodeInstallation(env));
+    }
+  }
+  const installed = {};
+  for (const [surface, probe] of actual) {
+    installed[surface] = {
+      installed: probe.version,
+      expected: expectedVersion,
+      location: probe.location,
+      state: versionState(probe.version, expectedVersion),
+      detail: probe.detail
+    };
+  }
+  const schedule = schedulerStatus(env);
+  const failures = [];
+  if (error) failures.push(`${error} \u2014 inspect permissions for ${paths.journalPath}`);
+  if (!events.length && !error) failures.push("no maintenance journal yet \u2014 run `mmi-hub install`");
+  if (!schedule.ok) failures.push(schedule.detail);
+  for (const [surface, row] of Object.entries(installed)) {
+    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\``);
+  }
+  for (const event of latestRunEvents) {
+    if ((event.kind === "arm" || event.kind === "reconcile") && (event.verdict === "fail" || event.verdict === "defer")) {
+      const surface = event.surface === "updater" ? "hub" : event.surface ?? event.kind;
+      failures.push(`last run ${surface}: ${event.detail ?? event.verdict} \u2014 run \`mmi-hub update\``);
+    }
+  }
+  return {
+    hubVersion,
+    expectedVersion,
+    installed,
+    schedule,
+    lastRun: latestEvent ? { id: latestEvent.run, at: latestEvent.ts } : null,
+    journalPath: paths.journalPath,
+    failures: [...new Set(failures)]
+  };
+}
+function formatHubStatus(status) {
+  const lines = [
+    `mmi-hub ${status.hubVersion} status`,
+    `  expected: ${status.expectedVersion ?? "unknown (no gated target recorded)"}`,
+    "  installed:"
+  ];
+  for (const [surface, row] of Object.entries(status.installed)) {
+    lines.push(`    ${surface}: ${row.installed ?? "unknown"} (expected ${row.expected ?? "unknown"}; ${row.state})`);
+    lines.push(`      ${row.location ?? "location unavailable"} \u2014 ${row.detail}`);
+  }
+  lines.push(`  autoupdate: ${status.schedule.enabled ? "on" : "off"} \u2014 ${status.schedule.detail}`);
+  lines.push(`  last run: ${status.lastRun ? `${status.lastRun.at} (${status.lastRun.id})` : "never recorded"}`);
+  if (status.failures.length) {
+    lines.push("  actionable failures:");
+    for (const failure3 of status.failures) lines.push(`    - ${failure3}`);
+  } else {
+    lines.push("  actionable failures: none");
+  }
+  return lines.join("\n");
+}
+
+// src/index.ts
+function ownVersion() {
+  try {
+    return JSON.parse((0, import_node_fs15.readFileSync)((0, import_node_path12.join)(__dirname, "..", "package.json"), "utf8")).version;
+  } catch {
+    return "0.0.0";
+  }
+}
+var HELP = `mmi-hub ${ownVersion()} \u2014 install and maintain MMI tooling
+
+  status [--json]                  read installed/expected versions, hourly schedule, last run,
+                                   and actionable failures (default; never heals)
+  install [--json]                 converge the CLI and every present host surface now, then enable
+                                   hourly automatic updates
+  update [--dry-run] [--json]      converge immediately to the newest gated release
+  autoupdate on|off                idempotently enable or disable hourly convergence; off keeps tools
+  --version                        print the Hub maintenance package version
+
+State remains under $MMI_UPDATER_HOME (default ~/.mmi/updater) for the compatibility window. The
+Windows task name also remains "MMI Fleet Updater", so existing installations migrate in place.
+Status performs no npm install, host repair, scheduler write, state mkdir, or repository cleanup.`;
+function printReconcile(summary, json) {
+  if (json) {
+    process.stdout.write(JSON.stringify(summary, null, 2) + "\n");
+    return;
+  }
+  const target = summary.target ?? "none (deferred)";
+  process.stdout.write(`mmi-hub: target ${target}
+`);
+  if (summary.cli) process.stdout.write(`  cli: ${summary.cli.verdict} \u2014 ${summary.cli.detail}
+`);
+  for (const arm of summary.plugins) process.stdout.write(`  ${arm.surface}: ${arm.verdict} \u2014 ${arm.detail}
+`);
+  if (summary.updater) process.stdout.write(`  hub: ${summary.updater.verdict} \u2014 ${summary.updater.detail}
+`);
+  for (const row of summary.reap.filter((entry) => entry.verdict !== "skip")) {
+    process.stdout.write(`  maintenance ${row.category}: ${row.verdict} \u2014 ${row.detail}
+`);
+  }
+  const armed = new Set(summary.plugins.map((arm) => arm.surface));
+  for (const surface of summary.surfaces.filter((surface2) => !armed.has(surface2.id))) {
+    process.stdout.write(`  ${surface.id}: ${surface.present ? "present" : "absent"} (${surface.action})
+`);
+  }
+}
+function runUpdate(args) {
+  const narrate = (line) => {
+    process.stderr.write(`mmi-hub: ${line}
+`);
+  };
+  return reconcile({ dryRun: args.includes("--dry-run"), narrate });
+}
+function main(args = process.argv.slice(2)) {
+  if (args.includes("--version")) {
+    process.stdout.write(ownVersion() + "\n");
+    return 0;
+  }
+  if (args.includes("--help") || args.includes("-h")) {
+    process.stdout.write(HELP + "\n");
+    return 0;
+  }
+  const command = args.find((arg) => !arg.startsWith("--")) ?? "status";
+  const json = args.includes("--json");
+  if (command === "status") {
+    const status = hubStatus(ownVersion());
+    process.stdout.write(json ? JSON.stringify(status, null, 2) + "\n" : formatHubStatus(status) + "\n");
+    return status.failures.length ? 1 : 0;
+  }
+  if (command === "update") {
+    const summary = runUpdate(args);
+    printReconcile(summary, json);
+    return summary.exit;
+  }
+  if (command === "install") {
+    const summary = runUpdate(args);
+    const schedule = installTask();
+    if (json) {
+      process.stdout.write(JSON.stringify({ convergence: summary, autoupdate: schedule }, null, 2) + "\n");
+    } else {
+      printReconcile(summary, false);
+      process.stdout.write(`mmi-hub install: ${schedule.detail}
+`);
+    }
+    return Math.max(summary.exit, schedule.ok ? 0 : 1);
+  }
+  if (command === "autoupdate") {
+    const commandIndex = args.indexOf(command);
+    const mode = args[commandIndex + 1];
+    if (mode !== "on" && mode !== "off") {
+      process.stderr.write("mmi-hub autoupdate requires on or off\n");
+      return 1;
+    }
+    const result = mode === "on" ? installTask() : uninstallTask();
+    process.stdout.write(json ? JSON.stringify({ mode, ...result }, null, 2) + "\n" : `mmi-hub autoupdate ${mode}: ${result.detail}
+`);
+    return result.ok ? 0 : 1;
+  }
+  process.stdout.write(HELP + "\n");
+  return 1;
+}
+if (typeof require !== "undefined" && require.main === module) {
+  process.exit(main());
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  hubStatus,
+  launcherVbs,
+  localStartBoundary,
+  main,
+  ownVersion,
+  schedulerStatus,
+  taskXml
+});