@mutmutco/hub 4.5.27 → 4.5.29

package/dist/index.cjs

@@ -66,6 +66,7 @@ __export(index_exports, {
   renderNotice: () => renderNotice,
   renderReport: () => renderReport,
   reportCounts: () => reportCounts,
+  resolvePayloadTarball: () => resolvePayloadTarball,
   retiredSurfaces: () => retiredSurfaces,
   retryHint: () => retryHint,
   runMaintenance: () => runMaintenance2,
@@ -75,6 +76,7 @@ __export(index_exports, {
   sharedDocLockTimeoutReceipt: () => sharedDocLockTimeoutReceipt,
   shippedTargetFrom: () => shippedTargetFrom,
   shouldHandOff: () => shouldHandOff,
+  stagePackage: () => stagePackage,
   statusScreen: () => statusScreen,
   surfaceArmPlan: () => surfaceArmPlan,
   systemdServiceUnit: () => systemdServiceUnit,
@@ -87,8 +89,8 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 var import_node_child_process9 = require("node:child_process");
-var import_node_fs24 = require("node:fs");
-var import_node_path16 = require("node:path");
+var import_node_fs27 = require("node:fs");
+var import_node_path18 = require("node:path");
 
 // ../installer/face/src/face.ts
 var import_node_fs = require("node:fs");
@@ -1262,14 +1264,14 @@ async function runMaintenance(product, args, dependencies) {
 
 // ../installer/launcher/src/refresh.ts
 var import_node_child_process = require("node:child_process");
-var import_node_fs6 = require("node:fs");
+var import_node_fs8 = require("node:fs");
 var import_node_os2 = require("node:os");
-var import_node_path3 = require("node:path");
+var import_node_path4 = require("node:path");
 
 // ../installer/launcher/src/acquisition.ts
 var import_node_crypto2 = require("node:crypto");
-var import_node_fs5 = require("node:fs");
-var import_node_path2 = require("node:path");
+var import_node_fs7 = require("node:fs");
+var import_node_path3 = require("node:path");
 
 // ../installer/launcher/src/download.ts
 async function readDownload(response, onProgress, expectedSize) {
@@ -1290,6 +1292,7 @@ async function readDownload(response, onProgress, expectedSize) {
 }
 
 // ../installer/launcher/src/store.ts
+var import_node_fs5 = require("node:fs");
 var import_node_os = require("node:os");
 var import_node_path = require("node:path");
 function defaultProductDir(product) {
@@ -1300,9 +1303,40 @@ function defaultProductDir(product) {
   const home = process.env.HOME ?? (0, import_node_os.tmpdir)();
   return (0, import_node_path.join)(home, `.${product}`);
 }
+function tokensPath(dir) {
+  return (0, import_node_path.join)(dir, "tokens.json");
+}
+function readTokens(dir) {
+  try {
+    const data = JSON.parse((0, import_node_fs5.readFileSync)(tokensPath(dir), "utf8"));
+    if (typeof data.accessToken !== "string" || !data.accessToken) return null;
+    if (typeof data.expiresAt !== "number" || !Number.isFinite(data.expiresAt)) return null;
+    const tokens = { accessToken: data.accessToken, expiresAt: data.expiresAt };
+    if (typeof data.refreshToken === "string" && data.refreshToken) tokens.refreshToken = data.refreshToken;
+    if (typeof data.clientId === "string" && data.clientId) tokens.clientId = data.clientId;
+    return tokens;
+  } catch {
+    return null;
+  }
+}
+function writeTokens(dir, tokens) {
+  (0, import_node_fs5.mkdirSync)(dir, { recursive: true });
+  try {
+    (0, import_node_fs5.writeFileSync)(tokensPath(dir), `${JSON.stringify(tokens)}
+`, { mode: 384 });
+  } catch {
+    (0, import_node_fs5.writeFileSync)(tokensPath(dir), `${JSON.stringify(tokens)}
+`);
+  }
+}
+function clearTokens(dir) {
+  (0, import_node_fs5.rmSync)(tokensPath(dir), { force: true });
+}
 
 // ../installer/launcher/src/payload.ts
 var import_node_crypto = require("node:crypto");
+var import_node_fs6 = require("node:fs");
+var import_node_path2 = require("node:path");
 
 // ../installer/launcher/src/canonical.ts
 function canonicalJson(value) {
@@ -1340,6 +1374,18 @@ function publicKeyBytes(config) {
 }
 
 // ../installer/launcher/src/payload.ts
+var NeedsLoginError = class extends Error {
+  constructor() {
+    super("signed out \u2014 run login first");
+    this.name = "NeedsLoginError";
+  }
+};
+var ForbiddenError = class extends Error {
+  constructor() {
+    super("this install is not allowed for your account \u2014 access was revoked or never granted.");
+    this.name = "ForbiddenError";
+  }
+};
 function canonicalManifestBytes(manifest2) {
   return Buffer.from(
     canonicalJson({
@@ -1370,6 +1416,26 @@ function verifyFileBytes(entry, bytes) {
   if (entry.size !== bytes.length) return false;
   return (0, import_node_crypto.createHash)("sha256").update(bytes).digest("hex") === entry.sha256.toLowerCase();
 }
+async function readErrorCode(response) {
+  try {
+    const data = await response.json();
+    return typeof data.error === "string" ? data.error : "";
+  } catch {
+    return "";
+  }
+}
+function throwForStatus(status, errorCode) {
+  if (status === 401) throw new NeedsLoginError();
+  if (status === 403) throw new ForbiddenError();
+  throw new Error(
+    errorCode ? `the release server refused the request (${status}: ${errorCode})` : `the release server refused the request (${status})`
+  );
+}
+async function getJson(url, accessToken, fetchImpl) {
+  const response = await fetchImpl(url, { headers: { authorization: `Bearer ${accessToken}` } });
+  if (!response.ok) throwForStatus(response.status, await readErrorCode(response));
+  return { status: response.status, json: await response.json() };
+}
 function parseManifest(json) {
   if (typeof json !== "object" || json === null) throw new Error("the release manifest is not an object");
   const record = json;
@@ -1399,24 +1465,42 @@ function safeManifestPath(rawPath) {
   }
   return segments.join("/");
 }
+async function fetchVerifiedManifest(config, accessToken, fetchImpl = fetch) {
+  const { json } = await getJson(`${config.host}/release/manifest`, accessToken, fetchImpl);
+  const manifest2 = parseManifest(json);
+  if (!verifyManifest(manifest2, manifest2.signature, config)) {
+    throw new Error("the release manifest signature is invalid \u2014 refusing to install anything.");
+  }
+  return manifest2;
+}
+var VERSION_CACHE_RE = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+function versionCacheRoot(dir, version) {
+  return VERSION_CACHE_RE.test(version) ? (0, import_node_path2.join)(dir, "payload-cache", version) : "";
+}
+function cachedPayloadForVersion(dir, version) {
+  const root = versionCacheRoot(dir, version);
+  if (!root) return null;
+  const payload = (0, import_node_path2.join)(root, "payload");
+  return (0, import_node_fs6.existsSync)(payload) ? payload : null;
+}
 
 // ../installer/launcher/src/acquisition.ts
 function lockInstallation(dir) {
-  (0, import_node_fs5.mkdirSync)(dir, { recursive: true });
-  const path = (0, import_node_path2.join)(dir, "installation.lock");
+  (0, import_node_fs7.mkdirSync)(dir, { recursive: true });
+  const path = (0, import_node_path3.join)(dir, "installation.lock");
   const owner = `${process.pid}:${(0, import_node_crypto2.randomUUID)()}`;
   try {
-    (0, import_node_fs5.writeFileSync)(path, owner, { flag: "wx", mode: 384 });
+    (0, import_node_fs7.writeFileSync)(path, owner, { flag: "wx", mode: 384 });
   } catch (error) {
     if (error.code !== "EEXIST") throw error;
     const recovery = `${path}.recovery`;
     try {
-      (0, import_node_fs5.writeFileSync)(recovery, owner, { flag: "wx", mode: 384, flush: true });
+      (0, import_node_fs7.writeFileSync)(recovery, owner, { flag: "wx", mode: 384, flush: true });
     } catch {
       throw new Error("installation lock recovery is already pending");
     }
     try {
-      const previous = (0, import_node_fs5.readFileSync)(path, "utf8");
+      const previous = (0, import_node_fs7.readFileSync)(path, "utf8");
       const pid = Number(previous.split(":")[0]);
       if (!Number.isInteger(pid) || pid <= 0) throw new Error("installation lock is malformed; recovery required");
       try {
@@ -1425,15 +1509,15 @@ function lockInstallation(dir) {
       } catch (probe) {
         if (probe.code !== "ESRCH") throw probe;
       }
-      (0, import_node_fs5.unlinkSync)(path);
-      (0, import_node_fs5.writeFileSync)(path, owner, { flag: "wx", mode: 384, flush: true });
+      (0, import_node_fs7.unlinkSync)(path);
+      (0, import_node_fs7.writeFileSync)(path, owner, { flag: "wx", mode: 384, flush: true });
     } finally {
-      (0, import_node_fs5.unlinkSync)(recovery);
+      (0, import_node_fs7.unlinkSync)(recovery);
     }
   }
   let released = false;
   return () => {
-    if (!released && (0, import_node_fs5.readFileSync)(path, "utf8") === owner) (0, import_node_fs5.unlinkSync)(path);
+    if (!released && (0, import_node_fs7.readFileSync)(path, "utf8") === owner) (0, import_node_fs7.unlinkSync)(path);
     released = true;
   };
 }
@@ -1484,14 +1568,14 @@ function compareVersions(a, b) {
 }
 function recordedPath(productDir) {
   try {
-    const saved = JSON.parse((0, import_node_fs6.readFileSync)((0, import_node_path3.join)(productDir, LAUNCHER_RECORD_FILE), "utf8"));
+    const saved = JSON.parse((0, import_node_fs8.readFileSync)((0, import_node_path4.join)(productDir, LAUNCHER_RECORD_FILE), "utf8"));
     return typeof saved.path === "string" && saved.path ? saved.path : null;
   } catch {
     return null;
   }
 }
 function installedPath(target, productDir, platform) {
-  return platform === "win32" ? (0, import_node_path3.join)(productDir, "bin", `${target.bin}.exe`) : (0, import_node_path3.join)((0, import_node_os2.homedir)(), ".local", "bin", target.bin);
+  return platform === "win32" ? (0, import_node_path4.join)(productDir, "bin", `${target.bin}.exe`) : (0, import_node_path4.join)((0, import_node_os2.homedir)(), ".local", "bin", target.bin);
 }
 function parseLauncherVersion(stdout, bin) {
   const text = String(stdout).trim();
@@ -1506,17 +1590,17 @@ function runVersion(path, bin) {
   });
 }
 function removeStale(file) {
-  const prefix = `${(0, import_node_path3.basename)(file)}.old-`;
+  const prefix = `${(0, import_node_path4.basename)(file)}.old-`;
   let names;
   try {
-    names = (0, import_node_fs6.readdirSync)((0, import_node_path3.dirname)(file));
+    names = (0, import_node_fs8.readdirSync)((0, import_node_path4.dirname)(file));
   } catch {
     return;
   }
   for (const name of names) {
     if (!name.startsWith(prefix)) continue;
     try {
-      (0, import_node_fs6.rmSync)((0, import_node_path3.join)((0, import_node_path3.dirname)(file), name), { force: true });
+      (0, import_node_fs8.rmSync)((0, import_node_path4.join)((0, import_node_path4.dirname)(file), name), { force: true });
     } catch {
     }
   }
@@ -1528,8 +1612,8 @@ async function refreshLauncher(target, options = {}) {
   if (!key) return null;
   const productDir = options.productDir ?? defaultProductDir(target.product);
   const recorded = recordedPath(productDir);
-  const file = options.path ?? (recorded && (0, import_node_fs6.existsSync)(recorded) ? recorded : installedPath(target, productDir, platform));
-  if (!(0, import_node_fs6.existsSync)(file) || (0, import_node_fs6.lstatSync)(file).isSymbolicLink()) return null;
+  const file = options.path ?? (recorded && (0, import_node_fs8.existsSync)(recorded) ? recorded : installedPath(target, productDir, platform));
+  if (!(0, import_node_fs8.existsSync)(file) || (0, import_node_fs8.lstatSync)(file).isSymbolicLink()) return null;
   if (!options.dryRun) removeStale(file);
   const from = await (options.readVersion ?? ((path) => runVersion(path, target.bin)))(file);
   if (!from) return null;
@@ -1565,19 +1649,19 @@ async function refreshLauncher(target, options = {}) {
     }
     if (!verifyFileBytes(entry, bytes)) return arm("fail", from, "The downloaded launcher failed its checksum.");
     try {
-      (0, import_node_fs6.writeFileSync)(next, bytes, { mode: 493 });
-      if (platform !== "win32") (0, import_node_fs6.chmodSync)(next, 493);
+      (0, import_node_fs8.writeFileSync)(next, bytes, { mode: 493 });
+      if (platform !== "win32") (0, import_node_fs8.chmodSync)(next, 493);
       if (platform === "win32") {
         moved = `${file}.old-${process.pid}-${Date.now()}`;
-        (0, import_node_fs6.renameSync)(file, moved);
+        (0, import_node_fs8.renameSync)(file, moved);
       }
-      (0, import_node_fs6.renameSync)(next, file);
+      (0, import_node_fs8.renameSync)(next, file);
     } catch {
       try {
-        if (moved && !(0, import_node_fs6.existsSync)(file)) (0, import_node_fs6.renameSync)(moved, file);
+        if (moved && !(0, import_node_fs8.existsSync)(file)) (0, import_node_fs8.renameSync)(moved, file);
       } catch {
       }
-      (0, import_node_fs6.rmSync)(next, { force: true });
+      (0, import_node_fs8.rmSync)(next, { force: true });
       return arm("fail", from, "The launcher could not be replaced.");
     }
     return arm("ok", record.version, "");
@@ -1604,22 +1688,22 @@ var installer_product_default = {
 };
 
 // src/state.ts
-var import_node_fs7 = require("node:fs");
+var import_node_fs9 = require("node:fs");
 var import_node_os3 = require("node:os");
-var import_node_path4 = require("node:path");
+var import_node_path5 = require("node:path");
 function stateRoot(env = process.env) {
-  return env.MMI_UPDATER_HOME || (0, import_node_path4.join)((0, import_node_os3.homedir)(), ".mmi", "updater");
+  return env.MMI_UPDATER_HOME || (0, import_node_path5.join)((0, import_node_os3.homedir)(), ".mmi", "updater");
 }
 function statePaths(env = process.env) {
   const root = stateRoot(env);
-  const staging = (0, import_node_path4.join)(root, "staging");
-  const gitCache = (0, import_node_path4.join)(root, "git-cache", "mmi-hub.git");
-  return { root, staging, gitCache, journalPath: (0, import_node_path4.join)(root, "journal.jsonl"), leasePath: (0, import_node_path4.join)(root, "lease.lock") };
+  const staging = (0, import_node_path5.join)(root, "staging");
+  const gitCache = (0, import_node_path5.join)(root, "git-cache", "mmi-hub.git");
+  return { root, staging, gitCache, journalPath: (0, import_node_path5.join)(root, "journal.jsonl"), leasePath: (0, import_node_path5.join)(root, "lease.lock") };
 }
 function ensureState(env = process.env) {
   const paths = statePaths(env);
-  (0, import_node_fs7.mkdirSync)(paths.staging, { recursive: true });
-  (0, import_node_fs7.mkdirSync)((0, import_node_path4.dirname)(paths.gitCache), { recursive: true });
+  (0, import_node_fs9.mkdirSync)(paths.staging, { recursive: true });
+  (0, import_node_fs9.mkdirSync)((0, import_node_path5.dirname)(paths.gitCache), { recursive: true });
   return paths;
 }
 var UpdaterBusy = class extends Error {
@@ -1629,15 +1713,15 @@ 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_fs7.openSync)(path, "wx");
-    (0, import_node_fs7.writeFileSync)(fd, JSON.stringify({ token, pid: process.pid, ts: Date.now() }) + "\n");
-    (0, import_node_fs7.closeSync)(fd);
+    const fd = (0, import_node_fs9.openSync)(path, "wx");
+    (0, import_node_fs9.writeFileSync)(fd, JSON.stringify({ token, pid: process.pid, ts: Date.now() }) + "\n");
+    (0, import_node_fs9.closeSync)(fd);
     return {
       token,
       release() {
         try {
           const current2 = readLease(path);
-          if (current2 && current2.token === token) (0, import_node_fs7.unlinkSync)(path);
+          if (current2 && current2.token === token) (0, import_node_fs9.unlinkSync)(path);
         } catch {
         }
       }
@@ -1648,7 +1732,7 @@ function tryAcquire(path) {
   const current = readLease(path);
   if (current && Date.now() - current.ts > LEASE_STALE_MS) {
     try {
-      (0, import_node_fs7.renameSync)(path, `${path}.stale-${Date.now()}`);
+      (0, import_node_fs9.renameSync)(path, `${path}.stale-${Date.now()}`);
       return "stolen-stale";
     } catch {
     }
@@ -1657,7 +1741,7 @@ function tryAcquire(path) {
 }
 function readLease(path) {
   try {
-    return JSON.parse((0, import_node_fs7.readFileSync)(path, "utf8"));
+    return JSON.parse((0, import_node_fs9.readFileSync)(path, "utf8"));
   } catch {
     return null;
   }
@@ -1682,10 +1766,10 @@ function withLease(path, fn, waitMs = LEASE_WAIT_MS) {
 }
 function appendJournal(path, event) {
   try {
-    (0, import_node_fs7.mkdirSync)((0, import_node_path4.dirname)(path), { recursive: true });
-    const fd = (0, import_node_fs7.openSync)(path, "a");
-    (0, import_node_fs7.writeFileSync)(fd, JSON.stringify(event) + "\n");
-    (0, import_node_fs7.closeSync)(fd);
+    (0, import_node_fs9.mkdirSync)((0, import_node_path5.dirname)(path), { recursive: true });
+    const fd = (0, import_node_fs9.openSync)(path, "a");
+    (0, import_node_fs9.writeFileSync)(fd, JSON.stringify(event) + "\n");
+    (0, import_node_fs9.closeSync)(fd);
     return true;
   } catch {
     return false;
@@ -1704,7 +1788,7 @@ function journalHighWater(path, surface, events) {
 function parseJournal(path) {
   const events = [];
   try {
-    for (const line of (0, import_node_fs7.readFileSync)(path, "utf8").split("\n")) {
+    for (const line of (0, import_node_fs9.readFileSync)(path, "utf8").split("\n")) {
       if (!line.trim()) continue;
       try {
         events.push(JSON.parse(line));
@@ -1718,7 +1802,7 @@ function parseJournal(path) {
 function journalSurfaceRepeatedFail(path, surface, currentRun) {
   let lastVerdict = null;
   try {
-    for (const line of (0, import_node_fs7.readFileSync)(path, "utf8").split("\n")) {
+    for (const line of (0, import_node_fs9.readFileSync)(path, "utf8").split("\n")) {
       if (!line.trim()) continue;
       try {
         const event = JSON.parse(line);
@@ -1761,7 +1845,7 @@ function compareSemver(a, b) {
   return va.pre.join(".") < vb.pre.join(".") ? -1 : va.pre.join(".") > vb.pre.join(".") ? 1 : 0;
 }
 function fileExists(path) {
-  return (0, import_node_fs7.existsSync)(path);
+  return (0, import_node_fs9.existsSync)(path);
 }
 
 // src/reconcile.ts
@@ -1769,8 +1853,8 @@ var import_node_perf_hooks2 = require("node:perf_hooks");
 
 // src/npm.ts
 var import_node_child_process2 = require("node:child_process");
-var import_node_fs8 = require("node:fs");
-var import_node_path5 = require("node:path");
+var import_node_fs10 = require("node:fs");
+var import_node_path6 = require("node:path");
 var cachedNpm = null;
 function resolveNpm(env = process.env) {
   if (env.MMI_UPDATER_NPM) return { kind: "command", command: env.MMI_UPDATER_NPM };
@@ -1779,8 +1863,8 @@ function resolveNpm(env = process.env) {
     const where = (0, import_node_child_process2.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_path5.join)((0, import_node_path5.dirname)(first), "node_modules", "npm", "bin", "npm-cli.js");
-      if ((0, import_node_fs8.existsSync)(script)) {
+      const script = (0, import_node_path6.join)((0, import_node_path6.dirname)(first), "node_modules", "npm", "bin", "npm-cli.js");
+      if ((0, import_node_fs10.existsSync)(script)) {
         cachedNpm = { kind: "node-script", script };
         return cachedNpm;
       }
@@ -1788,14 +1872,14 @@ function resolveNpm(env = process.env) {
       return cachedNpm;
     }
   }
-  const bundled = (0, import_node_path5.join)((0, import_node_path5.dirname)(process.execPath), "..", "lib", "node_modules", "npm", "bin", "npm-cli.js");
-  if ((0, import_node_fs8.existsSync)(bundled)) {
+  const bundled = (0, import_node_path6.join)((0, import_node_path6.dirname)(process.execPath), "..", "lib", "node_modules", "npm", "bin", "npm-cli.js");
+  if ((0, import_node_fs10.existsSync)(bundled)) {
     cachedNpm = { kind: "node-script", script: bundled };
     return cachedNpm;
   }
   const located = (0, import_node_child_process2.spawnSync)("/bin/sh", ["-lc", "command -v npm"], { encoding: "utf8", windowsHide: true });
   const resolved = (located.stdout ?? "").trim().split("\n").map((line) => line.trim()).find(Boolean);
-  if (located.status === 0 && resolved && (0, import_node_fs8.existsSync)(resolved)) {
+  if (located.status === 0 && resolved && (0, import_node_fs10.existsSync)(resolved)) {
     cachedNpm = { kind: "command", command: resolved };
     return cachedNpm;
   }
@@ -1877,7 +1961,7 @@ function npmVersions(packageName, env = process.env) {
 
 // src/gate.ts
 var import_node_child_process3 = require("node:child_process");
-var import_node_fs9 = require("node:fs");
+var import_node_fs11 = require("node:fs");
 function parseBom(text) {
   const bom = JSON.parse(text);
   if (typeof bom?.version !== "string" || typeof bom?.sourceCommit !== "string" || !Array.isArray(bom?.artifacts)) {
@@ -1899,7 +1983,7 @@ function ensureBareCache(cachePath, repoUrl) {
   if (probe.status !== 0) {
     throw new GateEnvError("git is not available \u2014 the release gate needs a git client");
   }
-  if (!(0, import_node_fs9.existsSync)(cachePath)) {
+  if (!(0, import_node_fs11.existsSync)(cachePath)) {
     const init = (0, import_node_child_process3.spawnSync)("git", ["init", "--bare", cachePath], { encoding: "utf8", windowsHide: true });
     if (init.status !== 0) throw new GateEnvError(`cannot create bare cache at ${cachePath}: ${init.stderr}`);
   }
@@ -2006,39 +2090,39 @@ async function checkAtomicity(cachePath, tagCommit, bom, candidate, npm) {
 }
 
 // src/surfaces.ts
-var import_node_fs14 = require("node:fs");
+var import_node_fs16 = require("node:fs");
 var import_node_os5 = require("node:os");
-var import_node_path10 = require("node:path");
+var import_node_path11 = require("node:path");
 
 // src/arm-host-plugins.ts
 var import_node_child_process6 = require("node:child_process");
-var import_node_fs13 = require("node:fs");
+var import_node_fs15 = require("node:fs");
 var import_node_os4 = require("node:os");
-var import_node_path9 = require("node:path");
+var import_node_path10 = require("node:path");
 
 // src/arm-npm-global.ts
-var import_node_fs11 = require("node:fs");
+var import_node_fs13 = require("node:fs");
 var import_node_child_process5 = require("node:child_process");
-var import_node_path7 = require("node:path");
+var import_node_path8 = require("node:path");
 
 // src/pending.ts
 var import_node_child_process4 = require("node:child_process");
-var import_node_fs10 = require("node:fs");
-var import_node_path6 = require("node:path");
+var import_node_fs12 = require("node:fs");
+var import_node_path7 = require("node:path");
 function hubDistPath(env) {
   const root = globalRoot(env);
-  return root ? (0, import_node_path6.join)(root, "@mutmutco", "hub", "dist", "index.cjs") : null;
+  return root ? (0, import_node_path7.join)(root, "@mutmutco", "hub", "dist", "index.cjs") : null;
 }
 var WATCHER_MAX_WAIT_MS = 4 * 60 * 60 * 1e3;
 function pendingPath(paths) {
-  return (0, import_node_path6.join)(paths.root, "pending.json");
+  return (0, import_node_path7.join)(paths.root, "pending.json");
 }
 function watcherLockPath(paths) {
-  return (0, import_node_path6.join)(paths.root, "pending-watcher.lock.d");
+  return (0, import_node_path7.join)(paths.root, "pending-watcher.lock.d");
 }
 function readPending(paths) {
   try {
-    const parsed = JSON.parse((0, import_node_fs10.readFileSync)(pendingPath(paths), "utf8"));
+    const parsed = JSON.parse((0, import_node_fs12.readFileSync)(pendingPath(paths), "utf8"));
     if (!Array.isArray(parsed)) return [];
     return parsed.filter((row) => Boolean(row) && typeof row === "object" && typeof row.surface === "string" && typeof row.target === "string" && Array.isArray(row.images) && Array.isArray(row.dirs));
   } catch {
@@ -2046,12 +2130,12 @@ function readPending(paths) {
   }
 }
 function writePending(paths, records) {
-  (0, import_node_fs10.mkdirSync)(paths.root, { recursive: true });
+  (0, import_node_fs12.mkdirSync)(paths.root, { recursive: true });
   const path = pendingPath(paths);
   const tmp = `${path}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
-  (0, import_node_fs10.writeFileSync)(tmp, `${JSON.stringify(records, null, 2)}
+  (0, import_node_fs12.writeFileSync)(tmp, `${JSON.stringify(records, null, 2)}
 `, "utf8");
-  (0, import_node_fs10.renameSync)(tmp, path);
+  (0, import_node_fs12.renameSync)(tmp, path);
 }
 function clearPending(paths, surface) {
   const records = readPending(paths);
@@ -2120,14 +2204,14 @@ function schedulePendingWatcher(paths, env = process.env, seam = {}) {
   const live = records.find((row) => row.watcherPid && pidAlive(row.watcherPid));
   if (live) return { scheduled: false, reason: `watcher pid ${live.watcherPid} is already waiting` };
   const hubDist = seam.hubDist ?? hubDistPath(env);
-  if (!hubDist || !(0, import_node_fs10.existsSync)(hubDist)) return { scheduled: false, reason: "the installed hub bundle is unresolvable \u2014 the hourly tick remains the retry" };
+  if (!hubDist || !(0, import_node_fs12.existsSync)(hubDist)) return { scheduled: false, reason: "the installed hub bundle is unresolvable \u2014 the hourly tick remains the retry" };
   const command = buildWatcherCommand({
     images: [...new Set(records.flatMap((row) => row.images))],
     dirs: [...new Set(records.flatMap((row) => row.dirs))],
     node: process.execPath,
     hubDist,
-    codePath: (0, import_node_path6.join)(paths.root, "pending-result.code"),
-    logPath: (0, import_node_path6.join)(paths.root, "pending-result.log"),
+    codePath: (0, import_node_path7.join)(paths.root, "pending-result.code"),
+    logPath: (0, import_node_path7.join)(paths.root, "pending-result.log"),
     lockPath: watcherLockPath(paths)
   });
   try {
@@ -2166,7 +2250,7 @@ function resumePendingWatcher(paths, env = process.env) {
 // src/arm-npm-global.ts
 function globalDist(env, packageName, distRel) {
   const root = globalRoot(env);
-  return root ? (0, import_node_path7.join)(root, ...packageName.split("/"), ...distRel.split("/")) : null;
+  return root ? (0, import_node_path8.join)(root, ...packageName.split("/"), ...distRel.split("/")) : null;
 }
 function probeVersion(distPath) {
   if (!fileExists(distPath)) return null;
@@ -2180,7 +2264,7 @@ function tail(output) {
 function manifestVersion(packageRoot) {
   if (!packageRoot) return null;
   try {
-    const version = JSON.parse((0, import_node_fs11.readFileSync)((0, import_node_path7.join)(packageRoot, "package.json"), "utf8")).version;
+    const version = JSON.parse((0, import_node_fs13.readFileSync)((0, import_node_path8.join)(packageRoot, "package.json"), "utf8")).version;
     return typeof version === "string" ? version : null;
   } catch {
     return null;
@@ -2188,34 +2272,40 @@ function manifestVersion(packageRoot) {
 }
 function stagePackage(options) {
   const { surface, packageName, target, witness, paths, env } = options;
-  const stageRoot = (0, import_node_path7.join)(paths.staging, surface, target);
-  const packageRoot = (0, import_node_path7.join)(stageRoot, "node_modules", ...packageName.split("/"));
-  if (!fileExists((0, import_node_path7.join)(packageRoot, ...witness.split("/")))) {
-    (0, import_node_fs11.mkdirSync)(stageRoot, { recursive: true });
-    (0, import_node_fs11.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", `${packageName}@${target}`], env);
+  const stageRoot = (0, import_node_path8.join)(paths.staging, surface, target);
+  const packageRoot = (0, import_node_path8.join)(stageRoot, "node_modules", ...packageName.split("/"));
+  const sourceTarball = (0, import_node_path8.join)(stageRoot, "source.tgz");
+  const staged = fileExists((0, import_node_path8.join)(packageRoot, ...witness.split("/")));
+  if (options.payload && typeof options.payload !== "string") return options.payload;
+  if (!staged) {
+    (0, import_node_fs13.mkdirSync)(stageRoot, { recursive: true });
+    (0, import_node_fs13.writeFileSync)((0, import_node_path8.join)(stageRoot, "package.json"), JSON.stringify({ name: "mmi-updater-stage", private: true }) + "\n");
+    (0, import_node_fs13.rmSync)(sourceTarball, { force: true });
+    if (typeof options.payload === "string") (0, import_node_fs13.copyFileSync)(options.payload, sourceTarball);
+    const install = runNpm(["install", "--prefix", stageRoot, "--no-audit", "--no-fund", "--no-package-lock", typeof options.payload === "string" ? sourceTarball : `${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_fs11.readFileSync)((0, import_node_path7.join)(packageRoot, "package.json"), "utf8")).version;
+    stagedManifestVersion = JSON.parse((0, import_node_fs13.readFileSync)((0, import_node_path8.join)(packageRoot, "package.json"), "utf8")).version;
   } catch {
   }
   if (stagedManifestVersion !== target) {
     return { defer: `staged manifest is ${stagedManifestVersion ?? "unreadable"}, expected ${target}` };
   }
-  return { packageRoot };
+  return { packageRoot, source: fileExists(sourceTarball) ? "payload" : "npm", ...fileExists(sourceTarball) ? { tarball: sourceTarball } : {} };
 }
 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 });
+  let source;
+  const result = (from, to, verdict, detail) => ({ surface, from, to, verdict, detail, ...source ? { source } : {} });
   const highWater = journalHighWater(paths.journalPath, surface, options.journalEvents);
   const localRoot = globalRoot(env);
-  const localVersion = localRoot ? manifestVersion((0, import_node_path7.join)(localRoot, ...packageName.split("/"))) : null;
+  const localVersion = localRoot ? manifestVersion((0, import_node_path8.join)(localRoot, ...packageName.split("/"))) : null;
   if (localVersion === target && highWater === target) {
     return result(localVersion, target, "ok", `already at target ${target} (installed manifest + journal high-water)`);
   }
@@ -2233,16 +2323,17 @@ function npmGlobalArm(options) {
   if (dryRun) {
     return result(installed, target, "ok", `dry-run: would converge ${installed ?? "absent"} -> ${target}`);
   }
-  const staged = stagePackage({ surface, packageName, target, witness: distRel, paths, env });
+  const staged = stagePackage({ surface, packageName, target, witness: distRel, paths, env, payload: options.payload });
   if ("defer" in staged) {
     return result(installed, target, "defer", staged.defer);
   }
-  const stageDist = (0, import_node_path7.join)(staged.packageRoot, ...distRel.split("/"));
+  source = staged.source;
+  const stageDist = (0, import_node_path8.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);
+  const globalInstall = runNpm(["install", "-g", "--no-audit", "--no-fund", staged.tarball ?? spec], env);
   if (globalInstall.status !== 0) {
     const reason = `global install failed: ${tail(globalInstall.stderr || globalInstall.stdout)}`;
     const root = globalRoot(env);
@@ -2258,11 +2349,11 @@ function npmGlobalArm(options) {
 }
 
 // src/launch-staging.ts
-var import_node_fs12 = require("node:fs");
-var import_node_path8 = require("node:path");
+var import_node_fs14 = require("node:fs");
+var import_node_path9 = require("node:path");
 function readLaunchTarget(path) {
   try {
-    const parsed = JSON.parse((0, import_node_fs12.readFileSync)(path, "utf8"));
+    const parsed = JSON.parse((0, import_node_fs14.readFileSync)(path, "utf8"));
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
     const row = parsed;
     if (typeof row.surface !== "string" || typeof row.target !== "string" || typeof row.since !== "string" || typeof row.incoming !== "string") return null;
@@ -2272,15 +2363,15 @@ function readLaunchTarget(path) {
   }
 }
 function writeLaunchTarget(path, record) {
-  (0, import_node_fs12.mkdirSync)((0, import_node_path8.join)(path, ".."), { recursive: true });
+  (0, import_node_fs14.mkdirSync)((0, import_node_path9.join)(path, ".."), { recursive: true });
   const tmp = `${path}.tmp-${process.pid}-${Math.random().toString(36).slice(2)}`;
-  (0, import_node_fs12.writeFileSync)(tmp, `${JSON.stringify(record, null, 2)}
+  (0, import_node_fs14.writeFileSync)(tmp, `${JSON.stringify(record, null, 2)}
 `, "utf8");
-  (0, import_node_fs12.renameSync)(tmp, path);
+  (0, import_node_fs14.renameSync)(tmp, path);
 }
 function clearLaunchTarget(path) {
   try {
-    (0, import_node_fs12.rmSync)(path, { force: true });
+    (0, import_node_fs14.rmSync)(path, { force: true });
   } catch {
   }
 }
@@ -2301,7 +2392,7 @@ function noteLaunchStaged(paths, env, options, seam = {}) {
 }
 function probeLaunchTargetVersion(launchTargetPath, versionAt) {
   const record = readLaunchTarget(launchTargetPath);
-  if (!record || !(0, import_node_fs12.existsSync)(record.incoming)) return null;
+  if (!record || !(0, import_node_fs14.existsSync)(record.incoming)) return null;
   const version = versionAt(record.incoming);
   return version === record.target ? record.target : null;
 }
@@ -2350,16 +2441,16 @@ function claudeMmi(runner, env) {
 }
 function claudeHomeDir(env) {
   const home = env.HOME?.trim() || env.USERPROFILE?.trim() || (0, import_node_os4.homedir)();
-  return (0, import_node_path9.join)(home, ".claude");
+  return (0, import_node_path10.join)(home, ".claude");
 }
 function claudeMarketplacesPath(env) {
-  return env.MMI_UPDATER_CLAUDE_MARKETPLACES || (0, import_node_path9.join)(claudeHomeDir(env), "plugins", "known_marketplaces.json");
+  return env.MMI_UPDATER_CLAUDE_MARKETPLACES || (0, import_node_path10.join)(claudeHomeDir(env), "plugins", "known_marketplaces.json");
 }
 function ensureClaudeMarketplace(env) {
   const path = claudeMarketplacesPath(env);
   let body;
   try {
-    body = JSON.parse((0, import_node_fs13.readFileSync)(path, "utf8"));
+    body = JSON.parse((0, import_node_fs15.readFileSync)(path, "utf8"));
   } catch (error) {
     if (error?.code === "ENOENT") return { ok: false, detail: `${path} does not exist \u2014 mutmutco marketplace is not registered`, unregistered: true };
     return { ok: false, detail: `cannot read ${path}` };
@@ -2383,24 +2474,24 @@ var CLAUDE_PACKAGE = "@mutmutco/claude-plugin";
 var CLAUDE_MANIFEST = ".claude-plugin/plugin.json";
 var CLAUDE_TREE_MARKERS = [".claude-plugin/plugin.json"];
 function claudePluginsRoot(env) {
-  return (0, import_node_path9.join)(claudeHomeDir(env), "plugins");
+  return (0, import_node_path10.join)(claudeHomeDir(env), "plugins");
 }
 function claudeMarkerVersion(root) {
   try {
-    const version = JSON.parse((0, import_node_fs13.readFileSync)((0, import_node_path9.join)(root, ...CLAUDE_MANIFEST.split("/")), "utf8")).version;
+    const version = JSON.parse((0, import_node_fs15.readFileSync)((0, import_node_path10.join)(root, ...CLAUDE_MANIFEST.split("/")), "utf8")).version;
     return typeof version === "string" ? version : null;
   } catch {
     return null;
   }
 }
 function claudeTreeHealthy(root) {
-  return CLAUDE_TREE_MARKERS.every((rel) => fileExists((0, import_node_path9.join)(root, ...rel.split("/"))));
+  return CLAUDE_TREE_MARKERS.every((rel) => fileExists((0, import_node_path10.join)(root, ...rel.split("/"))));
 }
 function claudeNpmEnv(env) {
   return { ...env, npm_config_allow_remote: "all" };
 }
 function probeClaudeLaunchStaging(env = process.env) {
-  return probeLaunchTargetVersion((0, import_node_path9.join)(claudePluginsRoot(env), "staging", "launch-target.json"), claudeMarkerVersion);
+  return probeLaunchTargetVersion((0, import_node_path10.join)(claudePluginsRoot(env), "staging", "launch-target.json"), claudeMarkerVersion);
 }
 function claudeArm(options) {
   const env = options.env ?? process.env;
@@ -2408,12 +2499,14 @@ function claudeArm(options) {
   const paths = options.paths ?? ensureState(env);
   const target = options.target;
   const repoUrl = options.repoUrl ?? (env.MMI_UPDATER_REPO || REPO_URL_DEFAULT);
+  let source;
   const result = (from2, to, verdict, detail) => ({
     surface: "claude",
     from: from2,
     to,
     verdict,
-    detail
+    detail,
+    ...source ? { source } : {}
   });
   const before = claudeMmi(runner, env);
   if (before.error) return result(null, target, "defer", before.error);
@@ -2433,7 +2526,7 @@ function claudeArm(options) {
   }
   if (!marketplaceTrust.ok) return result(from, target, "defer", marketplaceTrust.detail ?? "cannot trust the mutmutco marketplace registration");
   const pluginsRoot = claudePluginsRoot(env);
-  const launchTargetPath = (0, import_node_path9.join)(pluginsRoot, "staging", "launch-target.json");
+  const launchTargetPath = (0, import_node_path10.join)(pluginsRoot, "staging", "launch-target.json");
   if (options.dryRun) {
     return result(from, target, "ok", `dry-run: would refresh mutmutco, stage ${target} on the Claude volume, and converge mmi@mutmutco ${from ?? "absent"} -> ${target}`);
   }
@@ -2447,34 +2540,35 @@ function claudeArm(options) {
     clearLaunchTarget(launchTargetPath);
     return result(from, target, "ok", `catalog refreshed; installed+enabled at target ${target}`);
   }
-  const incomingRoot = (0, import_node_path9.join)(pluginsRoot, "staging", "incoming");
-  const incoming = (0, import_node_path9.join)(incomingRoot, target);
+  const incomingRoot = (0, import_node_path10.join)(pluginsRoot, "staging", "incoming");
+  const incoming = (0, import_node_path10.join)(incomingRoot, target);
   const priorLaunch = readLaunchTarget(launchTargetPath);
   const reuseIncoming = priorLaunch?.target === target && priorLaunch.incoming === incoming && claudeMarkerVersion(incoming) === target && claudeTreeHealthy(incoming);
   if (!reuseIncoming) {
-    const staged = stagePackage({ surface: "claude", packageName: CLAUDE_PACKAGE, target, witness: CLAUDE_MANIFEST, paths, env });
+    const staged = stagePackage({ surface: "claude", packageName: CLAUDE_PACKAGE, target, witness: CLAUDE_MANIFEST, paths, env, payload: options.payload });
     if ("defer" in staged) return result(from, target, "defer", staged.defer);
+    source = staged.source;
     if (claudeMarkerVersion(staged.packageRoot) !== target || !claudeTreeHealthy(staged.packageRoot)) {
       return result(from, target, "defer", `staged Claude manifest is ${claudeMarkerVersion(staged.packageRoot) ?? "unreadable"} or its tree is incomplete (expected ${target})`);
     }
     try {
-      (0, import_node_fs13.mkdirSync)((0, import_node_path9.join)(pluginsRoot, "staging"), { recursive: true });
-      (0, import_node_fs13.rmSync)(incomingRoot, { recursive: true, force: true });
-      (0, import_node_fs13.cpSync)(staged.packageRoot, incoming, { recursive: true });
+      (0, import_node_fs15.mkdirSync)((0, import_node_path10.join)(pluginsRoot, "staging"), { recursive: true });
+      (0, import_node_fs15.rmSync)(incomingRoot, { recursive: true, force: true });
+      (0, import_node_fs15.cpSync)(staged.packageRoot, incoming, { recursive: true });
     } catch (error) {
       return result(from, target, "defer", `cannot place incoming Claude generation: ${error?.message ?? error}`);
     }
     if (claudeMarkerVersion(incoming) !== target || !claudeTreeHealthy(incoming)) {
-      (0, import_node_fs13.rmSync)(incomingRoot, { recursive: true, force: true });
+      (0, import_node_fs15.rmSync)(incomingRoot, { recursive: true, force: true });
       return result(from, target, "defer", "incoming Claude generation did not reproduce the verified payload");
     }
   }
-  const cacheTarget = (0, import_node_path9.join)(pluginsRoot, "cache", "mutmutco", "mmi", target);
+  const cacheTarget = (0, import_node_path10.join)(pluginsRoot, "cache", "mutmutco", "mmi", target);
   try {
-    if (!(0, import_node_fs13.existsSync)(cacheTarget) || claudeMarkerVersion(cacheTarget) !== target || !claudeTreeHealthy(cacheTarget)) {
-      (0, import_node_fs13.rmSync)(cacheTarget, { recursive: true, force: true });
-      (0, import_node_fs13.mkdirSync)((0, import_node_path9.join)(cacheTarget, ".."), { recursive: true });
-      (0, import_node_fs13.cpSync)(incoming, cacheTarget, { recursive: true });
+    if (!(0, import_node_fs15.existsSync)(cacheTarget) || claudeMarkerVersion(cacheTarget) !== target || !claudeTreeHealthy(cacheTarget)) {
+      (0, import_node_fs15.rmSync)(cacheTarget, { recursive: true, force: true });
+      (0, import_node_fs15.mkdirSync)((0, import_node_path10.join)(cacheTarget, ".."), { recursive: true });
+      (0, import_node_fs15.cpSync)(incoming, cacheTarget, { recursive: true });
     }
   } catch (error) {
     return result(from, target, "defer", `cannot populate Claude plugin cache: ${error?.message ?? error}`);
@@ -2502,7 +2596,7 @@ function claudeArm(options) {
   }
   clearLaunchTarget(launchTargetPath);
   try {
-    (0, import_node_fs13.rmSync)(incomingRoot, { recursive: true, force: true });
+    (0, import_node_fs15.rmSync)(incomingRoot, { recursive: true, force: true });
   } catch {
   }
   return result(from, target, "ok", `catalog refreshed; converged and verified ${from ?? "absent"} -> ${target}`);
@@ -2581,12 +2675,12 @@ function probeNativeHostInstallation(surface, env = process.env, runner = runHos
 
 // src/surfaces.ts
 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_path10.join)((0, import_node_os5.homedir)(), ".jerv", "agent");
+  return env.MMI_UPDATER_JERVCODE_AGENT_DIR?.trim() || env.JERVCODE_CODING_AGENT_DIR?.trim() || env.PI_CODING_AGENT_DIR?.trim() || (0, import_node_path11.join)((0, import_node_os5.homedir)(), ".jerv", "agent");
 }
 function hermesHome(env = process.env, platform = process.platform) {
   if (env.HERMES_HOME?.trim()) return env.HERMES_HOME.trim();
-  if (platform === "win32") return (0, import_node_path10.join)(env.LOCALAPPDATA?.trim() || (0, import_node_path10.join)((0, import_node_os5.homedir)(), "AppData", "Local"), "hermes");
-  return (0, import_node_path10.join)((0, import_node_os5.homedir)(), ".hermes");
+  if (platform === "win32") return (0, import_node_path11.join)(env.LOCALAPPDATA?.trim() || (0, import_node_path11.join)((0, import_node_os5.homedir)(), "AppData", "Local"), "hermes");
+  return (0, import_node_path11.join)((0, import_node_os5.homedir)(), ".hermes");
 }
 function hermesHostCommand(env = process.env) {
   return env.MMI_UPDATER_HERMES?.trim() || "hermes";
@@ -2600,36 +2694,36 @@ function surfaceArmPlan(token, managedSurfaces) {
 }
 function enumerateSurfaces(env = process.env) {
   const home = env.HOME?.trim() || env.USERPROFILE?.trim() || (0, import_node_os5.homedir)();
-  const codexHome = env.CODEX_HOME || (0, import_node_path10.join)(home, ".codex");
+  const codexHome = env.CODEX_HOME || (0, import_node_path11.join)(home, ".codex");
   return [
-    { id: "claude", marker: (0, import_node_path10.join)(home, ".claude", "plugins", "installed_plugins.json") },
-    { id: "codex", marker: (0, import_node_path10.join)(codexHome, "plugins", "installed_plugins.json") },
+    { id: "claude", marker: (0, import_node_path11.join)(home, ".claude", "plugins", "installed_plugins.json") },
+    { id: "codex", marker: (0, import_node_path11.join)(codexHome, "plugins", "installed_plugins.json") },
     // The host, not the payload (#4951, #5356): this marker used to be plugins/local/mmi — the MMI
     // plugin tree itself — so a machine running Cursor WITHOUT the plugin enumerated as "no Cursor"
     // and the arm could never make the first install. The plugin's absence is a converge action, not
     // a skip. The host root mirrors surfaceConfigRoot('cursor') in cli/src/plugin-guard-io.ts.
-    { id: "cursor", marker: (0, import_node_path10.join)(home, ".cursor") },
-    { id: "jervcode", marker: (0, import_node_path10.join)(jervcodeAgentDir(env), "settings.json") },
+    { id: "cursor", marker: (0, import_node_path11.join)(home, ".cursor") },
+    { id: "jervcode", marker: (0, import_node_path11.join)(jervcodeAgentDir(env), "settings.json") },
     // Host CLI, not HERMES_HOME (#5673): the config tree can survive an uninstall and still carry
     // leftover plugin manifests — that residue must not enumerate as an installed host.
     { id: "hermes", marker: `${hermesHostCommand(env)} --version` }
   ].map((probe) => ({
     ...probe,
-    present: probe.id === "hermes" ? hermesHostPresent(env) : (0, import_node_fs14.existsSync)(probe.marker)
+    present: probe.id === "hermes" ? hermesHostPresent(env) : (0, import_node_fs16.existsSync)(probe.marker)
   }));
 }
 
 // src/arm-cursor.ts
-var import_node_fs17 = require("node:fs");
+var import_node_fs19 = require("node:fs");
 var import_node_child_process7 = require("node:child_process");
 var import_node_os7 = require("node:os");
-var import_node_path11 = require("node:path");
+var import_node_path12 = require("node:path");
 
 // src/compat.ts
-var import_node_fs15 = require("node:fs");
+var import_node_fs17 = require("node:fs");
 function readManifestCompat(manifestPath) {
   try {
-    const parsed = JSON.parse((0, import_node_fs15.readFileSync)(manifestPath, "utf8"));
+    const parsed = JSON.parse((0, import_node_fs17.readFileSync)(manifestPath, "utf8"));
     return typeof parsed.mmiCompat === "string" ? parsed.mmiCompat : void 0;
   } catch {
     return void 0;
@@ -2637,7 +2731,7 @@ function readManifestCompat(manifestPath) {
 }
 
 // src/host-doc-lock.ts
-var import_node_fs16 = require("node:fs");
+var import_node_fs18 = require("node:fs");
 var import_node_os6 = require("node:os");
 var SHARED_DOC_LOCK_STALE_MS = 3e4;
 var SHARED_DOC_LOCK_ATTEMPTS = 50;
@@ -2651,7 +2745,7 @@ function lockContent(options) {
 }
 function readHolder(lockPath) {
   try {
-    const parsed = JSON.parse((0, import_node_fs16.readFileSync)(lockPath, "utf8"));
+    const parsed = JSON.parse((0, import_node_fs18.readFileSync)(lockPath, "utf8"));
     if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return null;
     return parsed;
   } catch {
@@ -2663,7 +2757,7 @@ function lockAgeMs(lockPath, now) {
   const declared = typeof holder?.acquiredAt === "string" ? Date.parse(holder.acquiredAt) : Number.NaN;
   if (!Number.isNaN(declared)) return Math.max(0, now - declared);
   try {
-    return Math.max(0, now - (0, import_node_fs16.statSync)(lockPath).mtimeMs);
+    return Math.max(0, now - (0, import_node_fs18.statSync)(lockPath).mtimeMs);
   } catch {
     return 0;
   }
@@ -2686,9 +2780,9 @@ function acquireSharedDocLock(documentPath, options) {
   for (let attempt = 0; attempt < attempts; attempt += 1) {
     let fd;
     try {
-      fd = (0, import_node_fs16.openSync)(lockPath, "wx");
-      (0, import_node_fs16.writeSync)(fd, content);
-      (0, import_node_fs16.closeSync)(fd);
+      fd = (0, import_node_fs18.openSync)(lockPath, "wx");
+      (0, import_node_fs18.writeSync)(fd, content);
+      (0, import_node_fs18.closeSync)(fd);
       return {
         documentPath,
         lockPath,
@@ -2701,11 +2795,11 @@ function acquireSharedDocLock(documentPath, options) {
     } catch (error) {
       if (fd !== void 0) {
         try {
-          (0, import_node_fs16.closeSync)(fd);
+          (0, import_node_fs18.closeSync)(fd);
         } catch {
         }
         try {
-          (0, import_node_fs16.unlinkSync)(lockPath);
+          (0, import_node_fs18.unlinkSync)(lockPath);
         } catch {
         }
       }
@@ -2714,12 +2808,12 @@ function acquireSharedDocLock(documentPath, options) {
     if (lockAgeMs(lockPath, Date.now()) >= staleAfterMs) {
       const aside = `${lockPath}.stale-${Date.now()}`;
       try {
-        (0, import_node_fs16.renameSync)(lockPath, aside);
+        (0, import_node_fs18.renameSync)(lockPath, aside);
       } catch {
         continue;
       }
       try {
-        (0, import_node_fs16.rmSync)(aside, { force: true });
+        (0, import_node_fs18.rmSync)(aside, { force: true });
       } catch {
       }
       continue;
@@ -2732,7 +2826,7 @@ function releaseSharedDocLock(handle) {
   try {
     const holder = readHolder(handle.lockPath);
     if (holder && holder.owner === handle.owner && Number(holder.pid) === handle.pid) {
-      (0, import_node_fs16.unlinkSync)(handle.lockPath);
+      (0, import_node_fs18.unlinkSync)(handle.lockPath);
     }
   } catch {
   }
@@ -2754,14 +2848,14 @@ var KEEP_GENERATIONS = 2;
 var STRANDED_TMP_AGE_MS = 24 * 60 * 6e4;
 var TREE_FILES = [MANIFEST, "skills/bootstrap/SKILL.md"];
 function cursorPluginsRoot() {
-  return (0, import_node_path11.join)((0, import_node_os7.homedir)(), ".cursor", "plugins");
+  return (0, import_node_path12.join)((0, import_node_os7.homedir)(), ".cursor", "plugins");
 }
 function treeHealthy(root) {
-  return TREE_FILES.every((rel) => (0, import_node_fs17.existsSync)((0, import_node_path11.join)(root, ...rel.split("/"))));
+  return TREE_FILES.every((rel) => (0, import_node_fs19.existsSync)((0, import_node_path12.join)(root, ...rel.split("/"))));
 }
 function readJson(root, rel) {
   try {
-    return JSON.parse((0, import_node_fs17.readFileSync)((0, import_node_path11.join)(root, ...rel.split("/")), "utf8"));
+    return JSON.parse((0, import_node_fs19.readFileSync)((0, import_node_path12.join)(root, ...rel.split("/")), "utf8"));
   } catch {
     return null;
   }
@@ -2770,7 +2864,7 @@ function manifest(root) {
   return readJson(root, MANIFEST);
 }
 function probeCursorInstallation() {
-  const location = (0, import_node_path11.join)(cursorPluginsRoot(), "local", "mmi");
+  const location = (0, import_node_path12.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" };
 }
@@ -2785,7 +2879,7 @@ function message(error) {
 }
 function discard(path) {
   try {
-    (0, import_node_fs17.rmSync)(path, { recursive: true, force: true });
+    (0, import_node_fs19.rmSync)(path, { recursive: true, force: true });
   } catch {
   }
 }
@@ -2813,7 +2907,7 @@ function cursorHostEvidence(env) {
   return null;
 }
 function resolvedPluginRoot(root) {
-  return (0, import_node_path11.join)(root).replace(/\\/g, "/");
+  return (0, import_node_path12.join)(root).replace(/\\/g, "/");
 }
 function isMmiEntry(entry, pluginRoot) {
   if (typeof entry !== "object" || entry === null || typeof entry.command !== "string") return false;
@@ -2837,12 +2931,12 @@ function stripUserHooks(existing, pluginRoot) {
 }
 var CURSOR_HOOKS_LOCK_OWNER = "mmi-hub:cursor-hooks";
 function reconcileCursorUserHooks(pluginRoot, homeDir, lock = {}) {
-  const path = (0, import_node_path11.join)(homeDir, ".cursor", USER_HOOKS_FILE);
+  const path = (0, import_node_path12.join)(homeDir, ".cursor", USER_HOOKS_FILE);
   return withSharedDocLock(path, { owner: CURSOR_HOOKS_LOCK_OWNER, ...lock }, () => {
-    if (!(0, import_node_fs17.existsSync)(path)) return "current";
+    if (!(0, import_node_fs19.existsSync)(path)) return "current";
     let existing;
     try {
-      existing = JSON.parse((0, import_node_fs17.readFileSync)(path, "utf8"));
+      existing = JSON.parse((0, import_node_fs19.readFileSync)(path, "utf8"));
     } catch {
       return "user-conflict";
     }
@@ -2850,8 +2944,8 @@ function reconcileCursorUserHooks(pluginRoot, homeDir, lock = {}) {
     if (!stripped) return "user-conflict";
     if (JSON.stringify(stripped) === JSON.stringify(existing)) return "current";
     const tmp = `${path}.tmp-${process.pid}`;
-    (0, import_node_fs17.writeFileSync)(tmp, JSON.stringify(stripped, null, 2) + "\n", "utf8");
-    (0, import_node_fs17.renameSync)(tmp, path);
+    (0, import_node_fs19.writeFileSync)(tmp, JSON.stringify(stripped, null, 2) + "\n", "utf8");
+    (0, import_node_fs19.renameSync)(tmp, path);
     return "updated";
   });
 }
@@ -2866,41 +2960,41 @@ function userHooksDetail(pluginRoot, homeDir) {
     case "updated":
       return "; user hooks legacy entries stripped";
     case "user-conflict":
-      return `; USER HOOKS CONFLICT at ${(0, import_node_path11.join)(homeDir, ".cursor", USER_HOOKS_FILE)} \u2014 legacy entries were not changed`;
+      return `; USER HOOKS CONFLICT at ${(0, import_node_path12.join)(homeDir, ".cursor", USER_HOOKS_FILE)} \u2014 legacy entries were not changed`;
     default:
       return "";
   }
 }
 function writeRollbackPointer(root, entry) {
-  const path = (0, import_node_path11.join)(root, "quarantine", "rollback.json");
+  const path = (0, import_node_path12.join)(root, "quarantine", "rollback.json");
   const tmp = `${path}.tmp-${process.pid}`;
   try {
-    (0, import_node_fs17.writeFileSync)(tmp, JSON.stringify({ surface: "cursor", ts: (/* @__PURE__ */ new Date()).toISOString(), ...entry }, null, 2) + "\n", "utf8");
-    (0, import_node_fs17.renameSync)(tmp, path);
+    (0, import_node_fs19.writeFileSync)(tmp, JSON.stringify({ surface: "cursor", ts: (/* @__PURE__ */ new Date()).toISOString(), ...entry }, null, 2) + "\n", "utf8");
+    (0, import_node_fs19.renameSync)(tmp, path);
   } catch {
     discard(tmp);
   }
 }
 function mtimeMs(path) {
   try {
-    return (0, import_node_fs17.statSync)(path).mtimeMs;
+    return (0, import_node_fs19.statSync)(path).mtimeMs;
   } catch {
     return 0;
   }
 }
 function pruneQuarantine(root, keep) {
-  const dir = (0, import_node_path11.join)(root, "quarantine");
+  const dir = (0, import_node_path12.join)(root, "quarantine");
   let generations;
   try {
-    generations = (0, import_node_fs17.readdirSync)(dir, { withFileTypes: true }).filter((entry) => entry.isDirectory() && entry.name.startsWith("mmi-")).map((entry) => (0, import_node_path11.join)(dir, entry.name)).sort((a, b) => mtimeMs(b) - mtimeMs(a));
+    generations = (0, import_node_fs19.readdirSync)(dir, { withFileTypes: true }).filter((entry) => entry.isDirectory() && entry.name.startsWith("mmi-")).map((entry) => (0, import_node_path12.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_fs17.readdirSync)(dir, { withFileTypes: true })) {
+    for (const entry of (0, import_node_fs19.readdirSync)(dir, { withFileTypes: true })) {
       if (!entry.isFile() || !/^rollback\.json\.tmp-\d+$/.test(entry.name)) continue;
-      const path = (0, import_node_path11.join)(dir, entry.name);
+      const path = (0, import_node_path12.join)(dir, entry.name);
       if (Date.now() - mtimeMs(path) < STRANDED_TMP_AGE_MS) continue;
       discard(path);
       stranded += 1;
@@ -2918,16 +3012,16 @@ function pruneQuarantine(root, keep) {
 }
 function restorePrevious(live, quarantined, broken) {
   try {
-    (0, import_node_fs17.renameSync)(live, broken);
+    (0, import_node_fs19.renameSync)(live, broken);
   } catch {
     return "kept-broken";
   }
   try {
-    (0, import_node_fs17.renameSync)(quarantined, live);
+    (0, import_node_fs19.renameSync)(quarantined, live);
     return "restored";
   } catch {
     try {
-      (0, import_node_fs17.renameSync)(broken, live);
+      (0, import_node_fs19.renameSync)(broken, live);
       return "kept-broken";
     } catch {
       return "lost";
@@ -2938,9 +3032,11 @@ function cursorArm(options) {
   const env = options.env ?? process.env;
   const { target, dryRun, paths } = options;
   const root = cursorPluginsRoot();
-  const live = (0, import_node_path11.join)(root, "local", "mmi");
+  const live = (0, import_node_path12.join)(root, "local", "mmi");
+  let source;
   const result = (from, to, verdict, detail, launchStaged = false) => ({
     surface: "cursor",
+    ...source ? { source } : {},
     from,
     to,
     verdict,
@@ -2948,7 +3044,7 @@ function cursorArm(options) {
     launchStaged: launchStaged || void 0,
     // C11: the constraint of the generation LEFT at `live` — read at result time, so a failed
     // switch reports the restored generation's declaration, not the rejected one's (#4973).
-    compat: readManifestCompat((0, import_node_path11.join)(live, MANIFEST))
+    compat: readManifestCompat((0, import_node_path12.join)(live, MANIFEST))
   });
   const current = manifest(live);
   const installed = current?.version ?? null;
@@ -2962,30 +3058,31 @@ function cursorArm(options) {
   if (installed === target && treeHealthy(live)) {
     return result(installed, target, "ok", `already at target ${target}${userHooksDetail(live, (0, import_node_os7.homedir)())}`);
   }
-  if ((0, import_node_fs17.existsSync)(live) && !mmiOwned(live)) {
+  if ((0, import_node_fs19.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 });
+  const staged = stagePackage({ surface: "cursor", packageName: PACKAGE, target, witness: MANIFEST, paths, env, payload: options.payload });
   if ("defer" in staged) {
     return result(installed, target, "defer", staged.defer);
   }
+  source = staged.source;
   const stagedMarker = manifest(staged.packageRoot)?.version;
   if (stagedMarker !== target || !treeHealthy(staged.packageRoot)) {
     return result(installed, target, "defer", `staged tree marker is ${stagedMarker ?? "unreadable"} and the tree is ${treeHealthy(staged.packageRoot) ? "complete" : "incomplete"}, expected ${target} and complete`);
   }
-  const launchTargetPath = (0, import_node_path11.join)(root, "staging", "launch-target.json");
+  const launchTargetPath = (0, import_node_path12.join)(root, "staging", "launch-target.json");
   const priorLaunch = readLaunchTarget(launchTargetPath);
-  let incoming = priorLaunch?.target === target && priorLaunch.incoming.startsWith((0, import_node_path11.join)(root, "staging")) && manifest(priorLaunch.incoming)?.version === target && treeHealthy(priorLaunch.incoming) ? priorLaunch.incoming : (0, import_node_path11.join)(root, "staging", `mmi-${safeSegment(target)}-${Date.now()}`);
+  let incoming = priorLaunch?.target === target && priorLaunch.incoming.startsWith((0, import_node_path12.join)(root, "staging")) && manifest(priorLaunch.incoming)?.version === target && treeHealthy(priorLaunch.incoming) ? priorLaunch.incoming : (0, import_node_path12.join)(root, "staging", `mmi-${safeSegment(target)}-${Date.now()}`);
   const reuseIncoming = incoming === priorLaunch?.incoming;
-  if (!reuseIncoming || !(0, import_node_fs17.existsSync)(incoming)) {
-    incoming = (0, import_node_path11.join)(root, "staging", `mmi-${safeSegment(target)}-${Date.now()}`);
-    for (const dir of ["local", "staging", "quarantine"]) (0, import_node_fs17.mkdirSync)((0, import_node_path11.join)(root, dir), { recursive: true });
+  if (!reuseIncoming || !(0, import_node_fs19.existsSync)(incoming)) {
+    incoming = (0, import_node_path12.join)(root, "staging", `mmi-${safeSegment(target)}-${Date.now()}`);
+    for (const dir of ["local", "staging", "quarantine"]) (0, import_node_fs19.mkdirSync)((0, import_node_path12.join)(root, dir), { recursive: true });
     try {
       discard(incoming);
-      (0, import_node_fs17.cpSync)(staged.packageRoot, incoming, { recursive: true });
+      (0, import_node_fs19.cpSync)(staged.packageRoot, incoming, { recursive: true });
     } catch (error) {
       discard(incoming);
       return result(installed, target, "defer", `copy into ${root} failed: ${message(error)}`);
@@ -3008,8 +3105,8 @@ function cursorArm(options) {
     return result(installed, target, "ok", `staged ${target} for next launch while Cursor is running (${busy}) \u2014 ${pending}`, true);
   }
   const stamp = Date.now();
-  const quarantined = (0, import_node_path11.join)(root, "quarantine", `mmi-${safeSegment(installed ?? "unknown")}-${stamp}`);
-  for (const dir of ["local", "staging", "quarantine"]) (0, import_node_fs17.mkdirSync)((0, import_node_path11.join)(root, dir), { recursive: true });
+  const quarantined = (0, import_node_path12.join)(root, "quarantine", `mmi-${safeSegment(installed ?? "unknown")}-${stamp}`);
+  for (const dir of ["local", "staging", "quarantine"]) (0, import_node_fs19.mkdirSync)((0, import_node_path12.join)(root, dir), { recursive: true });
   const started = cursorHostEvidence(env);
   if (started) {
     const pending = noteLaunchStaged(paths, env, {
@@ -3024,15 +3121,15 @@ function cursorArm(options) {
   }
   let displaced = false;
   try {
-    if ((0, import_node_fs17.existsSync)(live)) {
-      (0, import_node_fs17.renameSync)(live, quarantined);
+    if ((0, import_node_fs19.existsSync)(live)) {
+      (0, import_node_fs19.renameSync)(live, quarantined);
       displaced = true;
     }
-    (0, import_node_fs17.renameSync)(incoming, live);
+    (0, import_node_fs19.renameSync)(incoming, live);
   } catch (error) {
-    if (displaced && !(0, import_node_fs17.existsSync)(live)) {
+    if (displaced && !(0, import_node_fs19.existsSync)(live)) {
       try {
-        (0, import_node_fs17.renameSync)(quarantined, live);
+        (0, import_node_fs19.renameSync)(quarantined, live);
       } catch {
       }
     }
@@ -3043,7 +3140,7 @@ function cursorArm(options) {
   }
   const evidence = manifest(live)?.version;
   if (evidence !== target || !treeHealthy(live)) {
-    const broken = `${(0, import_node_path11.join)(root, "quarantine", `mmi-${safeSegment(evidence ?? "broken")}-${stamp}`)}-failed`;
+    const broken = `${(0, import_node_path12.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 });
@@ -3056,12 +3153,12 @@ function cursorArm(options) {
   return result(installed, target, "ok", `switched ${installed ?? "absent"} -> ${target}; ${previous}${pruned ? `; pruned ${pruned} older generation${pruned === 1 ? "" : "s"}` : ""}${userHooksDetail(live, (0, import_node_os7.homedir)())}`);
 }
 function probeCursorLaunchStaging() {
-  return probeLaunchTargetVersion((0, import_node_path11.join)(cursorPluginsRoot(), "staging", "launch-target.json"), (root) => manifest(root)?.version ?? null);
+  return probeLaunchTargetVersion((0, import_node_path12.join)(cursorPluginsRoot(), "staging", "launch-target.json"), (root) => manifest(root)?.version ?? null);
 }
 
 // src/arm-jervcode.ts
-var import_node_fs18 = require("node:fs");
-var import_node_path12 = require("node:path");
+var import_node_fs20 = require("node:fs");
+var import_node_path13 = require("node:path");
 var PI_PACKAGE = "@mutmutco/pi-plugin";
 function hostEnv(env) {
   const dir = jervcodeAgentDir(env);
@@ -3072,7 +3169,7 @@ function hostCommands(_env) {
 }
 function readPackageSpecs(env) {
   try {
-    const settings = JSON.parse((0, import_node_fs18.readFileSync)((0, import_node_path12.join)(jervcodeAgentDir(env), "settings.json"), "utf8"));
+    const settings = JSON.parse((0, import_node_fs20.readFileSync)((0, import_node_path13.join)(jervcodeAgentDir(env), "settings.json"), "utf8"));
     return Array.isArray(settings.packages) ? settings.packages.filter((entry) => typeof entry === "string") : [];
   } catch {
     return null;
@@ -3080,14 +3177,14 @@ function readPackageSpecs(env) {
 }
 function installedVersion(env) {
   try {
-    const manifest2 = JSON.parse((0, import_node_fs18.readFileSync)((0, import_node_path12.join)(jervcodeAgentDir(env), "npm", "node_modules", ...PI_PACKAGE.split("/"), "package.json"), "utf8"));
+    const manifest2 = JSON.parse((0, import_node_fs20.readFileSync)((0, import_node_path13.join)(jervcodeAgentDir(env), "npm", "node_modules", ...PI_PACKAGE.split("/"), "package.json"), "utf8"));
     return typeof manifest2.version === "string" ? manifest2.version : null;
   } catch {
     return null;
   }
 }
 function materializedManifestLocation(env) {
-  return (0, import_node_path12.join)(jervcodeAgentDir(env), "npm", "node_modules", ...PI_PACKAGE.split("/"));
+  return (0, import_node_path13.join)(jervcodeAgentDir(env), "npm", "node_modules", ...PI_PACKAGE.split("/"));
 }
 var PI_LIST_SPEC = new RegExp(`npm:${PI_PACKAGE.replace("/", "\\/")}@(\\S+)`);
 function parseListText(stdout) {
@@ -3146,32 +3243,32 @@ function jervcodeArm(options) {
     detail,
     // C11: the constraint of the package pi LEFT materialised — read at result time, so defer/fail
     // carry the previous payload's declaration (#4973 reconsult ruling).
-    compat: readManifestCompat((0, import_node_path12.join)(jervcodeAgentDir(env), "npm", "node_modules", ...PI_PACKAGE.split("/"), "package.json"))
+    compat: readManifestCompat((0, import_node_path13.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_path12.join)(jervcodeAgentDir(env), "settings.json")}`);
+  if (!before) return result(null, options.target, "defer", `cannot read ${(0, import_node_path13.join)(jervcodeAgentDir(env), "settings.json")}`);
   const from = installedVersion(env);
   const legacy = before.filter(isLegacyMmiPiPath);
   const highWater = journalHighWater(options.paths.journalPath, "jervcode", options.journalEvents);
   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_path12.join)(jervcodeAgentDir(env), "npm", "node_modules", ...PI_PACKAGE.split("/"), "package.json")) };
+    return { surface: "jervcode", from, to: options.target, verdict: "ok", detail: `dry-run: would ${action}${legacy.length ? ` and retire ${legacy.length} legacy claude-cache path registration${legacy.length === 1 ? "" : "s"}` : ""}`, compat: readManifestCompat((0, import_node_path13.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_path12.join)(jervcodeAgentDir(env), "npm", "node_modules", ...PI_PACKAGE.split("/"), "package.json")) };
+  if (!command) return { surface: "jervcode", from, to: options.target, verdict: "defer", detail: "neither `jervcode` nor `pi` answered --version \u2014 the host CLI is not on PATH", compat: readManifestCompat((0, import_node_path13.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_path12.join)(jervcodeAgentDir(env), "npm", "node_modules", ...PI_PACKAGE.split("/"), "package.json")) };
+      return { surface: "jervcode", from, to: options.target, verdict: "defer", detail: `${command} install ${exact} failed: ${failure2(install)}`, compat: readManifestCompat((0, import_node_path13.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_path12.join)(jervcodeAgentDir(env), "npm", "node_modules", ...PI_PACKAGE.split("/"), "package.json")) };
+      return { surface: "jervcode", from, to: options.target, verdict: "defer", detail: `${command} remove of the legacy registration failed: ${failure2(removed)}`, compat: readManifestCompat((0, import_node_path13.join)(jervcodeAgentDir(env), "npm", "node_modules", ...PI_PACKAGE.split("/"), "package.json")) };
     }
   }
   const after = readPackageSpecs(env);
@@ -3179,7 +3276,7 @@ function jervcodeArm(options) {
   const legacyAfter = after?.filter(isLegacyMmiPiPath) ?? [];
   const retired = legacy.length ? `; retired ${legacy.length} legacy claude-cache path registration${legacy.length === 1 ? "" : "s"}` : "";
   if (floor && !legacyAfter.length) {
-    return { surface: "jervcode", from, to: converged ?? highWater ?? options.target, verdict: "skip", detail: `${floor}${retired}`, compat: readManifestCompat((0, import_node_path12.join)(jervcodeAgentDir(env), "npm", "node_modules", ...PI_PACKAGE.split("/"), "package.json")) };
+    return { surface: "jervcode", from, to: converged ?? highWater ?? options.target, verdict: "skip", detail: `${floor}${retired}`, compat: readManifestCompat((0, import_node_path13.join)(jervcodeAgentDir(env), "npm", "node_modules", ...PI_PACKAGE.split("/"), "package.json")) };
   }
   if (!after?.includes(exact) || converged !== options.target || legacyAfter.length) {
     return {
@@ -3200,14 +3297,14 @@ function jervcodeArm(options) {
 }
 
 // src/arm-hermes.ts
-var import_node_fs19 = require("node:fs");
-var import_node_path13 = require("node:path");
+var import_node_fs21 = require("node:fs");
+var import_node_path14 = require("node:path");
 var PACKAGE2 = "@mutmutco/hermes-plugin";
 var MANIFEST2 = "plugin.yaml";
 var TREE_MARKERS_FALLBACK = [MANIFEST2, "__init__.py", "skills"];
 function yamlVersion(root) {
   try {
-    const text = (0, import_node_fs19.readFileSync)((0, import_node_path13.join)(root, MANIFEST2), "utf8");
+    const text = (0, import_node_fs21.readFileSync)((0, import_node_path14.join)(root, MANIFEST2), "utf8");
     try {
       const version = JSON.parse(text).version;
       if (typeof version === "string" && version.trim()) return version.trim();
@@ -3221,7 +3318,7 @@ function yamlVersion(root) {
 }
 function packageTreeMarkers(root) {
   try {
-    const files = JSON.parse((0, import_node_fs19.readFileSync)((0, import_node_path13.join)(root, "package.json"), "utf8")).files;
+    const files = JSON.parse((0, import_node_fs21.readFileSync)((0, import_node_path14.join)(root, "package.json"), "utf8")).files;
     if (Array.isArray(files) && files.length && files.every((entry) => typeof entry === "string" && entry.trim())) {
       return files.map((entry) => entry.trim());
     }
@@ -3230,10 +3327,10 @@ function packageTreeMarkers(root) {
   return TREE_MARKERS_FALLBACK;
 }
 function markerPresent(root, rel) {
-  const path = (0, import_node_path13.join)(root, ...rel.split("/"));
-  if (!(0, import_node_fs19.existsSync)(path)) return false;
+  const path = (0, import_node_path14.join)(root, ...rel.split("/"));
+  if (!(0, import_node_fs21.existsSync)(path)) return false;
   try {
-    const stat = (0, import_node_fs19.statSync)(path);
+    const stat = (0, import_node_fs21.statSync)(path);
     return stat.isFile() || stat.isDirectory();
   } catch {
     return false;
@@ -3252,13 +3349,13 @@ function treeIncompleteDetail(root, label) {
 }
 function packageIdentity(root) {
   try {
-    return JSON.parse((0, import_node_fs19.readFileSync)((0, import_node_path13.join)(root, "package.json"), "utf8")).name === PACKAGE2;
+    return JSON.parse((0, import_node_fs21.readFileSync)((0, import_node_path14.join)(root, "package.json"), "utf8")).name === PACKAGE2;
   } catch {
     return false;
   }
 }
 function probeHermesInstallation(env = process.env) {
-  const location = (0, import_node_path13.join)(hermesHome(env), "plugins", "mmi");
+  const location = (0, import_node_path14.join)(hermesHome(env), "plugins", "mmi");
   const version = yamlVersion(location);
   return { version, location, detail: version ? "installed Hermes plugin manifest" : "installed Hermes plugin manifest was unreadable" };
 }
@@ -3267,7 +3364,7 @@ function mmiOwned2(root) {
 }
 function discard2(path) {
   try {
-    (0, import_node_fs19.rmSync)(path, { recursive: true, force: true });
+    (0, import_node_fs21.rmSync)(path, { recursive: true, force: true });
   } catch {
   }
 }
@@ -3275,19 +3372,19 @@ function message2(error) {
   return String(error?.message ?? error).replace(/\s+/g, " ").slice(0, 200);
 }
 function materializeHermesSkills(home) {
-  const pluginSkills = (0, import_node_path13.join)(home, "plugins", "mmi", "skills");
-  const skillsRoot = (0, import_node_path13.join)(home, "skills");
-  const targetRoot = (0, import_node_path13.join)(skillsRoot, "mmi");
+  const pluginSkills = (0, import_node_path14.join)(home, "plugins", "mmi", "skills");
+  const skillsRoot = (0, import_node_path14.join)(home, "skills");
+  const targetRoot = (0, import_node_path14.join)(skillsRoot, "mmi");
   try {
-    if (!(0, import_node_fs19.existsSync)(pluginSkills)) return { ok: false, detail: `plugin skills tree missing at ${pluginSkills}` };
-    const names = (0, import_node_fs19.readdirSync)(pluginSkills, { withFileTypes: true }).filter((entry) => entry.isDirectory() && !entry.name.startsWith("_")).map((entry) => entry.name);
+    if (!(0, import_node_fs21.existsSync)(pluginSkills)) return { ok: false, detail: `plugin skills tree missing at ${pluginSkills}` };
+    const names = (0, import_node_fs21.readdirSync)(pluginSkills, { withFileTypes: true }).filter((entry) => entry.isDirectory() && !entry.name.startsWith("_")).map((entry) => entry.name);
     if (!names.length) return { ok: false, detail: `plugin skills tree is empty at ${pluginSkills}` };
-    (0, import_node_fs19.mkdirSync)(skillsRoot, { recursive: true });
-    const incoming = (0, import_node_path13.join)(skillsRoot, ".mmi-incoming");
+    (0, import_node_fs21.mkdirSync)(skillsRoot, { recursive: true });
+    const incoming = (0, import_node_path14.join)(skillsRoot, ".mmi-incoming");
     discard2(incoming);
-    (0, import_node_fs19.cpSync)(pluginSkills, incoming, { recursive: true });
+    (0, import_node_fs21.cpSync)(pluginSkills, incoming, { recursive: true });
     discard2(targetRoot);
-    (0, import_node_fs19.renameSync)(incoming, targetRoot);
+    (0, import_node_fs21.renameSync)(incoming, targetRoot);
     return { ok: true, detail: `provisioned ${names.length} skills to ${targetRoot}` };
   } catch (error) {
     return { ok: false, detail: message2(error) };
@@ -3309,8 +3406,8 @@ function hermesHomes(env = process.env) {
   const root = hermesHome(env);
   const homes = [root];
   try {
-    for (const entry of (0, import_node_fs19.readdirSync)((0, import_node_path13.join)(root, "profiles"), { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
-      if (entry.isDirectory() && !entry.name.startsWith(".")) homes.push((0, import_node_path13.join)(root, "profiles", entry.name));
+    for (const entry of (0, import_node_fs21.readdirSync)((0, import_node_path14.join)(root, "profiles"), { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+      if (entry.isDirectory() && !entry.name.startsWith(".")) homes.push((0, import_node_path14.join)(root, "profiles", entry.name));
     }
   } catch {
   }
@@ -3336,29 +3433,32 @@ function hermesArm(options) {
   const primary = results[0].result;
   if (results.length === 1) return primary;
   const worst = results.reduce((a, b) => VERDICT_RANK[b.result.verdict] > VERDICT_RANK[a.result.verdict] ? b : a);
-  const detail = results.map(({ home, result }, index) => `${index === 0 ? "home" : `profile ${(0, import_node_path13.basename)(home)}`}: ${result.detail}`).join(" | ");
+  const detail = results.map(({ home, result }, index) => `${index === 0 ? "home" : `profile ${(0, import_node_path14.basename)(home)}`}: ${result.detail}`).join(" | ");
   return {
     surface: "hermes",
     from: primary.from,
     to: primary.to,
     verdict: worst.result.verdict,
     detail: `${homes.length} Hermes homes \u2014 ${detail}`,
-    launchStaged: results.some(({ result }) => result.launchStaged) || void 0
+    launchStaged: results.some(({ result }) => result.launchStaged) || void 0,
+    source: primary.source
   };
 }
 function armHermesHome(home, env, options, primary) {
-  const parent = (0, import_node_path13.join)(home, "plugins");
-  const live = (0, import_node_path13.join)(parent, "mmi");
+  const parent = (0, import_node_path14.join)(home, "plugins");
+  const live = (0, import_node_path14.join)(parent, "mmi");
   const installed = yamlVersion(live);
+  let source;
   const result = (from, to, verdict, detail, launchStaged = false) => ({
     surface: "hermes",
     from,
     to,
     verdict,
     detail,
-    launchStaged: launchStaged || void 0
+    launchStaged: launchStaged || void 0,
+    ...source ? { source } : {}
   });
-  if ((0, import_node_fs19.existsSync)(live) && !mmiOwned2(live)) {
+  if ((0, import_node_fs21.existsSync)(live) && !mmiOwned2(live)) {
     return result(installed, options.target, "defer", `${live} carries no ${PACKAGE2} package identity \u2014 refusing to displace an unmanaged Hermes mmi plugin`);
   }
   if (installed && compareSemver(installed, options.target) > 0) return result(installed, installed, "skip", `installed ${installed} is above candidate ${options.target} (monotonic)`);
@@ -3372,28 +3472,29 @@ function armHermesHome(home, env, options, primary) {
     if (!enabled2.ok) return result(installed, options.target, "fail", `plugin at target ${options.target}, but ${enabled2.detail}`);
     return result(installed, options.target, "ok", `already at target ${options.target}; ${skills2.detail}; ${enabled2.detail}`);
   }
-  if (options.dryRun) return result(installed, options.target, "ok", `dry-run: would stage ${PACKAGE2}@${options.target}, atomically switch ${installed ?? "absent"} -> ${options.target}, provision skills into ${(0, import_node_path13.join)(home, "skills", "mmi")}, then enable mmi in plugins.enabled`);
-  const staged = stagePackage({ surface: "hermes", packageName: PACKAGE2, target: options.target, witness: MANIFEST2, paths: options.paths, env });
+  if (options.dryRun) return result(installed, options.target, "ok", `dry-run: would stage ${PACKAGE2}@${options.target}, atomically switch ${installed ?? "absent"} -> ${options.target}, provision skills into ${(0, import_node_path14.join)(home, "skills", "mmi")}, then enable mmi in plugins.enabled`);
+  const staged = stagePackage({ surface: "hermes", packageName: PACKAGE2, target: options.target, witness: MANIFEST2, paths: options.paths, env, payload: options.payload });
   if ("defer" in staged) return result(installed, options.target, "defer", staged.defer);
+  source = staged.source;
   const stagedVersion = yamlVersion(staged.packageRoot);
   if (stagedVersion !== options.target) {
     return result(installed, options.target, "defer", `staged Hermes manifest is ${stagedVersion ?? "unreadable"}, expected ${options.target}`);
   }
   const stagedTree = treeIncompleteDetail(staged.packageRoot, "staged Hermes");
   if (stagedTree) return result(installed, options.target, "defer", stagedTree);
-  const scratch = (0, import_node_path13.join)(home, ".mmi-updater");
-  const launchTargetPath = (0, import_node_path13.join)(scratch, "launch-target.json");
-  const incomingRoot = (0, import_node_path13.join)(scratch, "incoming");
-  const incoming = (0, import_node_path13.join)(incomingRoot, options.target);
-  const quarantine = (0, import_node_path13.join)(scratch, "quarantine", `${installed ?? "unknown"}-${Date.now()}`);
+  const scratch = (0, import_node_path14.join)(home, ".mmi-updater");
+  const launchTargetPath = (0, import_node_path14.join)(scratch, "launch-target.json");
+  const incomingRoot = (0, import_node_path14.join)(scratch, "incoming");
+  const incoming = (0, import_node_path14.join)(incomingRoot, options.target);
+  const quarantine = (0, import_node_path14.join)(scratch, "quarantine", `${installed ?? "unknown"}-${Date.now()}`);
   const priorLaunch = readLaunchTarget(launchTargetPath);
   const reuseIncoming = priorLaunch?.target === options.target && priorLaunch.incoming === incoming && yamlVersion(incoming) === options.target && treeHealthy2(incoming);
   if (!reuseIncoming) {
     try {
-      (0, import_node_fs19.mkdirSync)(parent, { recursive: true });
-      (0, import_node_fs19.mkdirSync)((0, import_node_path13.join)(scratch, "quarantine"), { recursive: true });
+      (0, import_node_fs21.mkdirSync)(parent, { recursive: true });
+      (0, import_node_fs21.mkdirSync)((0, import_node_path14.join)(scratch, "quarantine"), { recursive: true });
       discard2(incomingRoot);
-      (0, import_node_fs19.cpSync)(staged.packageRoot, incoming, { recursive: true });
+      (0, import_node_fs21.cpSync)(staged.packageRoot, incoming, { recursive: true });
     } catch (error) {
       return result(installed, options.target, "defer", `cannot place incoming Hermes generation: ${message2(error)}`);
     }
@@ -3408,14 +3509,14 @@ function armHermesHome(home, env, options, primary) {
       return result(installed, options.target, "defer", incomingTree);
     }
   }
-  const displaced = (0, import_node_fs19.existsSync)(live);
+  const displaced = (0, import_node_fs21.existsSync)(live);
   try {
-    (0, import_node_fs19.mkdirSync)((0, import_node_path13.join)(scratch, "quarantine"), { recursive: true });
-    if (displaced) (0, import_node_fs19.renameSync)(live, quarantine);
-    (0, import_node_fs19.renameSync)(incoming, live);
+    (0, import_node_fs21.mkdirSync)((0, import_node_path14.join)(scratch, "quarantine"), { recursive: true });
+    if (displaced) (0, import_node_fs21.renameSync)(live, quarantine);
+    (0, import_node_fs21.renameSync)(incoming, live);
   } catch (error) {
-    if (displaced && !(0, import_node_fs19.existsSync)(live)) try {
-      (0, import_node_fs19.renameSync)(quarantine, live);
+    if (displaced && !(0, import_node_fs21.existsSync)(live)) try {
+      (0, import_node_fs21.renameSync)(quarantine, live);
     } catch {
     }
     discard2(incomingRoot);
@@ -3426,12 +3527,12 @@ function armHermesHome(home, env, options, primary) {
   const liveVersion = yamlVersion(live);
   const liveTree = treeIncompleteDetail(live, "live Hermes");
   if (liveVersion !== options.target || liveTree) {
-    const broken = (0, import_node_path13.join)(scratch, "rejected", `${options.target}-${Date.now()}`);
+    const broken = (0, import_node_path14.join)(scratch, "rejected", `${options.target}-${Date.now()}`);
     const verifyDetail = liveVersion !== options.target ? `manifest is ${liveVersion ?? "unreadable"}, expected ${options.target}` : liveTree;
     try {
-      (0, import_node_fs19.mkdirSync)((0, import_node_path13.join)(scratch, "rejected"), { recursive: true });
-      (0, import_node_fs19.renameSync)(live, broken);
-      if (displaced) (0, import_node_fs19.renameSync)(quarantine, live);
+      (0, import_node_fs21.mkdirSync)((0, import_node_path14.join)(scratch, "rejected"), { recursive: true });
+      (0, import_node_fs21.renameSync)(live, broken);
+      if (displaced) (0, import_node_fs21.renameSync)(quarantine, live);
     } catch (error) {
       return result(installed, liveVersion ?? "unknown", "fail", `post-switch Hermes verification failed and recovery failed: ${message2(error)}`);
     }
@@ -3446,12 +3547,199 @@ function armHermesHome(home, env, options, primary) {
   return result(installed, options.target, "ok", `converged ${installed ?? "absent"} -> ${options.target} (staged, verified, switched${displaced ? `; previous generation quarantined at ${quarantine}` : ""}); ${skills.detail}; ${enabled.detail}`);
 }
 function probeHermesLaunchStaging(env = process.env) {
-  return probeLaunchTargetVersion((0, import_node_path13.join)(hermesHome(env), ".mmi-updater", "launch-target.json"), yamlVersion);
+  return probeLaunchTargetVersion((0, import_node_path14.join)(hermesHome(env), ".mmi-updater", "launch-target.json"), yamlVersion);
+}
+
+// src/payload-source.ts
+var import_node_fs22 = require("node:fs");
+var import_node_path15 = require("node:path");
+
+// ../installer/launcher/src/login-github.ts
+async function postJson(url, body, fetchImpl) {
+  return fetchImpl(url, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify(body)
+  });
+}
+async function readBody(response) {
+  try {
+    return await response.text();
+  } catch {
+    return "";
+  }
+}
+function gateRefusal(method, url, status, body) {
+  const head = body.replace(/\s+/g, " ").trim().slice(0, 200);
+  return `the sign-in server refused the request \u2014 ${method} ${url} \u2192 ${status}${head ? `: ${head}` : ""}`;
+}
+async function refreshAccessToken(config, refreshToken, fetchImpl = fetch) {
+  const url = `${config.host}/gate/refresh`;
+  const response = await postJson(url, { refresh_token: refreshToken }, fetchImpl);
+  if (response.status === 403) return null;
+  if (!response.ok) {
+    throw new Error(gateRefusal("POST", url, response.status, await readBody(response)));
+  }
+  const data = await response.json();
+  if (typeof data.access_token !== "string" || typeof data.expires_in !== "number") {
+    throw new Error("the sign-in server returned a malformed refresh");
+  }
+  return {
+    accessToken: data.access_token,
+    expiresIn: data.expires_in,
+    ...typeof data.refresh_token === "string" ? { refreshToken: data.refresh_token } : {}
+  };
+}
+
+// ../installer/launcher/src/login-google.ts
+async function refreshGoogleToken(host, clientId, refreshToken, fetchImpl = fetch) {
+  const server = host.replace(/\/+$/, "");
+  const response = await fetchImpl(`${server}/oauth/token`, {
+    method: "POST",
+    headers: { "content-type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({
+      grant_type: "refresh_token",
+      refresh_token: refreshToken,
+      client_id: clientId
+    }).toString()
+  });
+  if (!response.ok) return null;
+  const tokens = await response.json();
+  if (typeof tokens.access_token !== "string" || typeof tokens.expires_in !== "number") return null;
+  return {
+    accessToken: tokens.access_token,
+    refreshToken: typeof tokens.refresh_token === "string" ? tokens.refresh_token : refreshToken,
+    expiresIn: tokens.expires_in
+  };
+}
+
+// ../installer/launcher/src/tokens.ts
+async function ensureFreshToken(config, dir, fetchImpl = fetch) {
+  const stored = readTokens(dir);
+  if (!stored) return null;
+  if (stored.expiresAt - Date.now() > 6e4) return stored.accessToken;
+  if (!stored.refreshToken) return null;
+  if (config.loginKind === "github") {
+    const refreshed2 = await refreshAccessToken(config, stored.refreshToken, fetchImpl);
+    if (!refreshed2) {
+      clearTokens(dir);
+      return null;
+    }
+    writeTokens(dir, {
+      accessToken: refreshed2.accessToken,
+      refreshToken: refreshed2.refreshToken ?? stored.refreshToken,
+      expiresAt: Date.now() + refreshed2.expiresIn * 1e3
+    });
+    return refreshed2.accessToken;
+  }
+  if (!stored.clientId) {
+    clearTokens(dir);
+    return null;
+  }
+  const refreshed = await refreshGoogleToken(config.host, stored.clientId, stored.refreshToken, fetchImpl);
+  if (!refreshed) {
+    clearTokens(dir);
+    return null;
+  }
+  writeTokens(dir, {
+    accessToken: refreshed.accessToken,
+    refreshToken: refreshed.refreshToken,
+    expiresAt: Date.now() + refreshed.expiresIn * 1e3,
+    clientId: stored.clientId
+  });
+  return refreshed.accessToken;
+}
+
+// src/payload-source.ts
+var PayloadIntegrityError = class extends Error {
+};
+function tarballName(name, version) {
+  return `${name.replace("@", "").replace("/", "-")}-${version}.tgz`;
+}
+var mmiConfig = {
+  product: installer_product_default.launcher.product,
+  host: installer_product_default.launcher.host,
+  publicKey: installer_product_default.launcher.key,
+  binName: installer_product_default.launcher.bin,
+  loginKind: "github"
+};
+async function resolvePayloadTarball(options) {
+  const { packageName, version, paths } = options;
+  if (!/^\d+\.\d+\.\d+[A-Za-z0-9._-]*$/.test(version)) return null;
+  const file = tarballName(packageName, version);
+  const dir = options.productDir ?? (process.env.LAUNCHER_DIR || defaultProductDir("mmi"));
+  const launcherCache = cachedPayloadForVersion(dir, version);
+  if (launcherCache) {
+    try {
+      const metadata = JSON.parse((0, import_node_fs22.readFileSync)((0, import_node_path15.join)(launcherCache, "payload.json"), "utf8"));
+      if (metadata.version === version && (0, import_node_fs22.existsSync)((0, import_node_path15.join)(launcherCache, file))) return (0, import_node_path15.join)(launcherCache, file);
+    } catch {
+    }
+  }
+  const config = options.config ?? mmiConfig;
+  const cache = (0, import_node_path15.join)(paths.root, "payload-cache", version);
+  const manifestFile = (0, import_node_path15.join)(cache, "manifest.json");
+  let manifest2 = null;
+  try {
+    manifest2 = parseManifest(JSON.parse((0, import_node_fs22.readFileSync)(manifestFile, "utf8")));
+    if (!verifyManifest(manifest2, manifest2.signature, config)) throw new PayloadIntegrityError("cached release manifest signature is invalid");
+    if (manifest2.version !== version) throw new PayloadIntegrityError("cached release manifest version is wrong");
+  } catch (error) {
+    if (error instanceof PayloadIntegrityError) throw error;
+    if ((0, import_node_fs22.existsSync)(manifestFile)) throw new PayloadIntegrityError("cached release manifest is malformed");
+    manifest2 = null;
+  }
+  const cachedEntry = manifest2?.files.find((entry2) => entry2.path === file);
+  if (cachedEntry && (0, import_node_fs22.existsSync)((0, import_node_path15.join)(cache, file))) {
+    if (!verifyFileBytes(cachedEntry, (0, import_node_fs22.readFileSync)((0, import_node_path15.join)(cache, file)))) throw new PayloadIntegrityError(`cached ${file} failed its checksum`);
+    return (0, import_node_path15.join)(cache, file);
+  }
+  if (!(0, import_node_fs22.existsSync)(dir)) return null;
+  let token;
+  try {
+    token = await ensureFreshToken(config, dir, options.fetchImpl);
+  } catch {
+    return null;
+  }
+  if (!token) return null;
+  const fetchImpl = options.fetchImpl ?? fetch;
+  try {
+    manifest2 = await fetchVerifiedManifest(config, token, (url, init) => fetchImpl(url, { ...init, signal: AbortSignal.timeout(1e4) }));
+  } catch (error) {
+    if (error instanceof NeedsLoginError || error instanceof ForbiddenError || error instanceof TypeError || error.name === "AbortError") return null;
+    if (String(error.message).startsWith("the release server refused")) return null;
+    throw new PayloadIntegrityError(`release manifest verification failed: ${error.message}`);
+  }
+  if (manifest2.version !== version) return null;
+  const entry = manifest2.files.find((candidate) => candidate.path === file);
+  if (!entry) return null;
+  let bytes;
+  try {
+    const encoded = entry.path.split("/").map(encodeURIComponent).join("/");
+    const response = await fetchImpl(`${config.host}/release/${encoded}`, { headers: { authorization: `Bearer ${token}` }, signal: AbortSignal.timeout(3e5) });
+    if (!response.ok) return null;
+    bytes = Buffer.from(await response.arrayBuffer());
+  } catch {
+    return null;
+  }
+  if (!verifyFileBytes(entry, bytes)) throw new PayloadIntegrityError(`${file} failed its checksum`);
+  (0, import_node_fs22.mkdirSync)(cache, { recursive: true });
+  const temporary = (0, import_node_path15.join)(cache, `${file}.${process.pid}.tmp`);
+  try {
+    (0, import_node_fs22.writeFileSync)(temporary, bytes);
+    (0, import_node_fs22.renameSync)(temporary, (0, import_node_path15.join)(cache, file));
+    const signed = `${manifestFile}.${process.pid}.tmp`;
+    (0, import_node_fs22.writeFileSync)(signed, JSON.stringify(manifest2));
+    (0, import_node_fs22.renameSync)(signed, manifestFile);
+  } finally {
+    (0, import_node_fs22.rmSync)(temporary, { force: true });
+  }
+  return (0, import_node_path15.join)(cache, file);
 }
 
 // src/reap.ts
-var import_node_fs20 = require("node:fs");
-var import_node_path14 = require("node:path");
+var import_node_fs23 = require("node:fs");
+var import_node_path16 = require("node:path");
 var import_node_perf_hooks = require("node:perf_hooks");
 function elapsedMs(startedAt) {
   return Math.round((import_node_perf_hooks.performance.now() - startedAt) * 10) / 10;
@@ -3460,7 +3748,7 @@ var KEEP_GENERATIONS2 = 2;
 var SCRATCH_AGE_MS = 24 * 60 * 6e4;
 function listDirs(path) {
   try {
-    return (0, import_node_fs20.readdirSync)(path, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+    return (0, import_node_fs23.readdirSync)(path, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
   } catch {
     return [];
   }
@@ -3468,7 +3756,7 @@ function listDirs(path) {
 function generationSets(root) {
   const children = listDirs(root);
   if (children.some((name) => parseSemver(name))) return [root];
-  return children.map((name) => (0, import_node_path14.join)(root, name)).filter((path) => listDirs(path).some((name) => parseSemver(name)));
+  return children.map((name) => (0, import_node_path16.join)(root, name)).filter((path) => listDirs(path).some((name) => parseSemver(name)));
 }
 function pruneGenerations(root, category, dryRun) {
   let reaped = 0;
@@ -3481,7 +3769,7 @@ function pruneGenerations(root, category, dryRun) {
         continue;
       }
       try {
-        (0, import_node_fs20.rmSync)((0, import_node_path14.join)(set, version), { recursive: true, force: true });
+        (0, import_node_fs23.rmSync)((0, import_node_path16.join)(set, version), { recursive: true, force: true });
         reaped += 1;
       } catch (error) {
         failures.push(`${version}: ${error?.code ?? error?.message ?? error}`);
@@ -3495,8 +3783,8 @@ function pruneGenerations(root, category, dryRun) {
 }
 var LEASE_STEAL_SCRATCH = /^lease\.lock\.stale-\d+$/;
 function atomicWriteScratch(path) {
-  const literal = (0, import_node_path14.basename)(path).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  return { dir: (0, import_node_path14.dirname)(path), pattern: new RegExp(`^${literal}\\.tmp-\\d+$`) };
+  const literal = (0, import_node_path16.basename)(path).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return { dir: (0, import_node_path16.dirname)(path), pattern: new RegExp(`^${literal}\\.tmp-\\d+$`) };
 }
 function reapScratch(context, dryRun) {
   const category = "scratch";
@@ -3514,7 +3802,7 @@ function reapScratch(context, dryRun) {
   for (const [dir, patterns] of scanned) {
     let entries;
     try {
-      entries = (0, import_node_fs20.readdirSync)(dir, { withFileTypes: true });
+      entries = (0, import_node_fs23.readdirSync)(dir, { withFileTypes: true });
     } catch {
       unreadable.push(dir);
       continue;
@@ -3522,10 +3810,10 @@ function reapScratch(context, dryRun) {
     for (const entry of entries) {
       if (!patterns.some((pattern) => pattern.test(entry.name))) continue;
       if (!entry.isFile()) continue;
-      const path = (0, import_node_path14.join)(dir, entry.name);
+      const path = (0, import_node_path16.join)(dir, entry.name);
       let ageMs;
       try {
-        ageMs = now - (0, import_node_fs20.statSync)(path).mtimeMs;
+        ageMs = now - (0, import_node_fs23.statSync)(path).mtimeMs;
       } catch {
         continue;
       }
@@ -3535,7 +3823,7 @@ function reapScratch(context, dryRun) {
         continue;
       }
       try {
-        (0, import_node_fs20.rmSync)(path, { force: true });
+        (0, import_node_fs23.rmSync)(path, { force: true });
         reaped += 1;
       } catch (error) {
         failures.push(`${entry.name}: ${error?.code ?? error?.message ?? error}`);
@@ -3594,7 +3882,8 @@ async function reconcile(options) {
   const summary = { run, target: null, gate: null, managedSurfaces: null, atomicity: null, cli: null, updater: null, plugins: [], reap: [], surfaces: [], journalOk: true, reexec: null, exit: 0 };
   const recordArm = (arm, durationMs) => {
     if (arm.verdict === "fail") arm.repeatFailure = journalSurfaceRepeatedFail(paths.journalPath, arm.surface, run);
-    journal({ kind: "arm", surface: arm.surface, from: arm.from, to: arm.to, verdict: arm.verdict, detail: arm.detail, compat: arm.compat, durationMs });
+    if (arm.source && !arm.detail.includes(`source: ${arm.source}`)) arm.detail += ` (source: ${arm.source})`;
+    journal({ kind: "arm", surface: arm.surface, from: arm.from, to: arm.to, verdict: arm.verdict, detail: arm.detail, source: arm.source, compat: arm.compat, durationMs });
     options.onArm?.({ ...arm, ...durationMs === void 0 ? {} : { durationMs } });
     if (arm.verdict === "ok" && !options.dryRun && !arm.launchStaged) clearPending(paths, arm.surface);
     if (arm.verdict === "defer") summary.exit = Math.max(summary.exit, 2);
@@ -3679,10 +3968,20 @@ async function reconcile(options) {
       phase("resolve", "ok");
       options.onTargetResolved?.(summary.target, summary.gate);
       phase("check", "running");
+      const payloadFor = async (packageName) => {
+        if (options.dryRun) return null;
+        try {
+          return await resolvePayloadTarball({ packageName, version: summary.target, paths });
+        } catch (error) {
+          if (error instanceof PayloadIntegrityError) return { defer: `payload integrity refusal: ${error.message}` };
+          return null;
+        }
+      };
       say("updater: self-bootstrap");
       const selfStartedAt = import_node_perf_hooks2.performance.now();
       const self = npmGlobalArm({
         surface: "updater",
+        payload: await payloadFor("@mutmutco/hub"),
         packageName: "@mutmutco/hub",
         distRel: "dist/index.cjs",
         target: summary.target,
@@ -3705,6 +4004,7 @@ async function reconcile(options) {
       const cliStartedAt = import_node_perf_hooks2.performance.now();
       const cli = npmGlobalArm({
         surface: "cli",
+        payload: await payloadFor("@mutmutco/cli"),
         packageName: "@mutmutco/cli",
         distRel: "dist/index.cjs",
         target: summary.target,
@@ -3730,7 +4030,9 @@ async function reconcile(options) {
         }
         say(`${probe.id}: converging to v${summary.target}`);
         const armStartedAt = import_node_perf_hooks2.performance.now();
-        const arm = probe.id === "claude" ? claudeArm({ target: summary.target, dryRun: options.dryRun, paths, env, repoUrl, journalEvents }) : probe.id === "codex" ? codexArm({ target: summary.target, dryRun: options.dryRun, env, repoUrl }) : probe.id === "cursor" ? cursorArm({ target: summary.target, dryRun: options.dryRun, paths, env, journalEvents }) : probe.id === "jervcode" ? jervcodeArm({ target: summary.target, dryRun: options.dryRun, paths, env, journalEvents }) : probe.id === "hermes" ? hermesArm({ target: summary.target, dryRun: options.dryRun, paths, env, hostPresent: probe.present, journalEvents }) : null;
+        const packageName = probe.id === "claude" ? "@mutmutco/claude-plugin" : probe.id === "cursor" ? "@mutmutco/cursor-plugin" : probe.id === "hermes" ? "@mutmutco/hermes-plugin" : null;
+        const payload = packageName ? await payloadFor(packageName) : null;
+        const arm = probe.id === "claude" ? claudeArm({ target: summary.target, dryRun: options.dryRun, paths, env, repoUrl, journalEvents, payload }) : probe.id === "codex" ? codexArm({ target: summary.target, dryRun: options.dryRun, env, repoUrl }) : probe.id === "cursor" ? cursorArm({ target: summary.target, dryRun: options.dryRun, paths, env, journalEvents, payload }) : probe.id === "jervcode" ? jervcodeArm({ target: summary.target, dryRun: options.dryRun, paths, env, journalEvents }) : probe.id === "hermes" ? hermesArm({ target: summary.target, dryRun: options.dryRun, paths, env, hostPresent: probe.present, journalEvents, payload }) : null;
         if (arm) {
           summary.plugins.push(arm);
           summary.surfaces.push({ id: probe.id, present: true, action: `arm-${arm.verdict}` });
@@ -3766,9 +4068,9 @@ async function reconcile(options) {
 
 // src/scheduler.ts
 var import_node_child_process8 = require("node:child_process");
-var import_node_fs21 = require("node:fs");
+var import_node_fs24 = require("node:fs");
 var import_node_os8 = require("node:os");
-var import_node_path15 = require("node:path");
+var import_node_path17 = require("node:path");
 var TASK_NAME = "MMI Fleet Updater";
 var LAUNCHER_FILE = "reconcile-hidden.vbs";
 var RUN_BOUND = "PT15M";
@@ -3926,7 +4228,7 @@ WantedBy=timers.target
 }
 function readFileOrNull(path) {
   try {
-    return (0, import_node_fs21.readFileSync)(path, "utf8");
+    return (0, import_node_fs24.readFileSync)(path, "utf8");
   } catch {
     return null;
   }
@@ -3975,7 +4277,7 @@ function windowsSchedulerStatus(env) {
     return { ok: false, supported: true, enabled: false, ...EMPTY_RUN_INFO, detail: `"${TASK_NAME}" is not registered \u2014 run \`mmi-hub autoupdate on\`` };
   }
   const hubDist = globalDist(env, "@mutmutco/hub", "dist/index.cjs");
-  const launcherPath = (0, import_node_path15.join)(statePaths(env).root, LAUNCHER_FILE);
+  const launcherPath = (0, import_node_path17.join)(statePaths(env).root, LAUNCHER_FILE);
   const info = taskRunInfo();
   const runInfo = info ?? EMPTY_RUN_INFO;
   const fail2 = (detail) => ({ ok: false, supported: true, enabled: true, ...runInfo, detail });
@@ -4000,13 +4302,13 @@ function windowsSchedulerStatus(env) {
   return { ok: true, supported: true, enabled: true, ...runInfo, detail: `"${TASK_NAME}" registered ${CADENCE}; ${points}; ${ran}; next ${runInfo.nextRunTime ?? "unscheduled"}` };
 }
 function darwinSchedulerStatus(env) {
-  const plistPath = (0, import_node_path15.join)((0, import_node_os8.homedir)(), "Library", "LaunchAgents", LAUNCHD_PLIST_NAME);
+  const plistPath = (0, import_node_path17.join)((0, import_node_os8.homedir)(), "Library", "LaunchAgents", LAUNCHD_PLIST_NAME);
   const plist = readFileOrNull(plistPath);
   if (!plist) {
     return { ok: false, supported: true, enabled: false, ...EMPTY_RUN_INFO, detail: `"${LAUNCHD_LABEL}" is not registered \u2014 run \`mmi-hub autoupdate on\`` };
   }
   const hubDist = globalDist(env, "@mutmutco/hub", "dist/index.cjs");
-  const launcherPath = (0, import_node_path15.join)(statePaths(env).root, POSIX_LAUNCHER_FILE);
+  const launcherPath = (0, import_node_path17.join)(statePaths(env).root, POSIX_LAUNCHER_FILE);
   const fail2 = (detail) => ({ ok: false, supported: true, enabled: true, ...EMPTY_RUN_INFO, detail });
   if (!plist.includes(launcherPath)) {
     return fail2(`"${LAUNCHD_LABEL}" does not run the reconcile launcher ${launcherPath} \u2014 run \`mmi-hub autoupdate on\``);
@@ -4026,15 +4328,15 @@ function darwinSchedulerStatus(env) {
   return { ok: true, supported: true, enabled: true, ...EMPTY_RUN_INFO, detail: `"${LAUNCHD_LABEL}" registered ${POSIX_CADENCE}; ${points}` };
 }
 function linuxSchedulerStatus(env) {
-  const unitDir = (0, import_node_path15.join)((0, import_node_os8.homedir)(), ".config", "systemd", "user");
-  const timerPath = (0, import_node_path15.join)(unitDir, SYSTEMD_TIMER_NAME);
+  const unitDir = (0, import_node_path17.join)((0, import_node_os8.homedir)(), ".config", "systemd", "user");
+  const timerPath = (0, import_node_path17.join)(unitDir, SYSTEMD_TIMER_NAME);
   const timer = readFileOrNull(timerPath);
-  const service = readFileOrNull((0, import_node_path15.join)(unitDir, SYSTEMD_SERVICE_NAME));
+  const service = readFileOrNull((0, import_node_path17.join)(unitDir, SYSTEMD_SERVICE_NAME));
   if (!timer || !service) {
     return { ok: false, supported: true, enabled: false, ...EMPTY_RUN_INFO, detail: `"${SYSTEMD_TIMER_NAME}" is not registered \u2014 run \`mmi-hub autoupdate on\`` };
   }
   const hubDist = globalDist(env, "@mutmutco/hub", "dist/index.cjs");
-  const launcherPath = (0, import_node_path15.join)(statePaths(env).root, POSIX_LAUNCHER_FILE);
+  const launcherPath = (0, import_node_path17.join)(statePaths(env).root, POSIX_LAUNCHER_FILE);
   const fail2 = (detail) => ({ ok: false, supported: true, enabled: true, ...EMPTY_RUN_INFO, detail });
   if (!service.includes(launcherPath)) {
     return fail2(`"${SYSTEMD_SERVICE_NAME}" does not run the reconcile launcher ${launcherPath} \u2014 run \`mmi-hub autoupdate on\``);
@@ -4073,10 +4375,10 @@ function installWindowsTask(env) {
   const paths = ensureState(env);
   const userId = `${env.USERDOMAIN || env.COMPUTERNAME || ""}\\${env.USERNAME || ""}`.replace(/^\\/, "");
   if (!env.USERNAME) return { ok: false, detail: "cannot resolve the registering user (USERNAME unset) \u2014 the task principal must be explicit" };
-  const launcherPath = (0, import_node_path15.join)(paths.root, LAUNCHER_FILE);
-  (0, import_node_fs21.writeFileSync)(launcherPath, launcherVbs(process.execPath, hubDist), "utf8");
-  const xmlPath = (0, import_node_path15.join)(paths.root, "task.xml");
-  (0, import_node_fs21.writeFileSync)(xmlPath, "\uFEFF" + taskXml(launcherPath, paths.root, userId, localStartBoundary(/* @__PURE__ */ new Date())), "utf16le");
+  const launcherPath = (0, import_node_path17.join)(paths.root, LAUNCHER_FILE);
+  (0, import_node_fs24.writeFileSync)(launcherPath, launcherVbs(process.execPath, hubDist), "utf8");
+  const xmlPath = (0, import_node_path17.join)(paths.root, "task.xml");
+  (0, import_node_fs24.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);
@@ -4092,11 +4394,11 @@ function refreshPosixLauncher(env) {
   const hubDist = globalDist(env, "@mutmutco/hub", "dist/index.cjs");
   if (!hubDist) return null;
   const paths = ensureState(env);
-  const launcherPath = (0, import_node_path15.join)(paths.root, POSIX_LAUNCHER_FILE);
+  const launcherPath = (0, import_node_path17.join)(paths.root, POSIX_LAUNCHER_FILE);
   const desired = launcherSh(process.execPath, hubDist);
   if (readFileOrNull(launcherPath) === desired) return null;
-  (0, import_node_fs21.writeFileSync)(launcherPath, desired, "utf8");
-  (0, import_node_fs21.chmodSync)(launcherPath, 493);
+  (0, import_node_fs24.writeFileSync)(launcherPath, desired, "utf8");
+  (0, import_node_fs24.chmodSync)(launcherPath, 493);
   return launcherPath;
 }
 function installLaunchd(env) {
@@ -4108,13 +4410,13 @@ function installLaunchd(env) {
   const hubDist = globalDist(env, "@mutmutco/hub", "dist/index.cjs");
   if (!hubDist) return { ok: false, detail: "cannot resolve the global @mutmutco/hub dist \u2014 run `npm install -g @mutmutco/hub` first" };
   const paths = ensureState(env);
-  const launcherPath = (0, import_node_path15.join)(paths.root, POSIX_LAUNCHER_FILE);
-  (0, import_node_fs21.writeFileSync)(launcherPath, launcherSh(process.execPath, hubDist), "utf8");
-  (0, import_node_fs21.chmodSync)(launcherPath, 493);
-  const agentsDir = (0, import_node_path15.join)((0, import_node_os8.homedir)(), "Library", "LaunchAgents");
-  (0, import_node_fs21.mkdirSync)(agentsDir, { recursive: true });
-  const plistPath = (0, import_node_path15.join)(agentsDir, LAUNCHD_PLIST_NAME);
-  (0, import_node_fs21.writeFileSync)(plistPath, launchdPlist(launcherPath, paths.root), "utf8");
+  const launcherPath = (0, import_node_path17.join)(paths.root, POSIX_LAUNCHER_FILE);
+  (0, import_node_fs24.writeFileSync)(launcherPath, launcherSh(process.execPath, hubDist), "utf8");
+  (0, import_node_fs24.chmodSync)(launcherPath, 493);
+  const agentsDir = (0, import_node_path17.join)((0, import_node_os8.homedir)(), "Library", "LaunchAgents");
+  (0, import_node_fs24.mkdirSync)(agentsDir, { recursive: true });
+  const plistPath = (0, import_node_path17.join)(agentsDir, LAUNCHD_PLIST_NAME);
+  (0, import_node_fs24.writeFileSync)(plistPath, launchdPlist(launcherPath, paths.root), "utf8");
   launchctl(["bootout", `gui/${uid()}/${LAUNCHD_LABEL}`]);
   const load = launchctl(["bootstrap", `gui/${uid()}`, plistPath]);
   if (load.status !== 0) {
@@ -4132,13 +4434,13 @@ function installSystemdTimer(env) {
   const hubDist = globalDist(env, "@mutmutco/hub", "dist/index.cjs");
   if (!hubDist) return { ok: false, detail: "cannot resolve the global @mutmutco/hub dist \u2014 run `npm install -g @mutmutco/hub` first" };
   const paths = ensureState(env);
-  const launcherPath = (0, import_node_path15.join)(paths.root, POSIX_LAUNCHER_FILE);
-  (0, import_node_fs21.writeFileSync)(launcherPath, launcherSh(process.execPath, hubDist), "utf8");
-  (0, import_node_fs21.chmodSync)(launcherPath, 493);
-  const unitDir = (0, import_node_path15.join)((0, import_node_os8.homedir)(), ".config", "systemd", "user");
-  (0, import_node_fs21.mkdirSync)(unitDir, { recursive: true });
-  (0, import_node_fs21.writeFileSync)((0, import_node_path15.join)(unitDir, SYSTEMD_SERVICE_NAME), systemdServiceUnit(launcherPath, paths.root), "utf8");
-  (0, import_node_fs21.writeFileSync)((0, import_node_path15.join)(unitDir, SYSTEMD_TIMER_NAME), systemdTimerUnit(), "utf8");
+  const launcherPath = (0, import_node_path17.join)(paths.root, POSIX_LAUNCHER_FILE);
+  (0, import_node_fs24.writeFileSync)(launcherPath, launcherSh(process.execPath, hubDist), "utf8");
+  (0, import_node_fs24.chmodSync)(launcherPath, 493);
+  const unitDir = (0, import_node_path17.join)((0, import_node_os8.homedir)(), ".config", "systemd", "user");
+  (0, import_node_fs24.mkdirSync)(unitDir, { recursive: true });
+  (0, import_node_fs24.writeFileSync)((0, import_node_path17.join)(unitDir, SYSTEMD_SERVICE_NAME), systemdServiceUnit(launcherPath, paths.root), "utf8");
+  (0, import_node_fs24.writeFileSync)((0, import_node_path17.join)(unitDir, SYSTEMD_TIMER_NAME), systemdTimerUnit(), "utf8");
   const reload = systemctlUser(["daemon-reload"]);
   if (reload.status !== 0) {
     return { ok: false, detail: `systemctl --user daemon-reload failed: ${(reload.stderr || reload.stdout).trim() || "unknown error \u2014 is a user systemd instance running?"}` };
@@ -4176,28 +4478,28 @@ function uninstallWindowsTask(env) {
   return { ok: true, detail: `automatic updates off \u2014 removed "${TASK_NAME}"; installed tooling was kept` };
 }
 function uninstallLaunchd(env) {
-  const plistPath = (0, import_node_path15.join)((0, import_node_os8.homedir)(), "Library", "LaunchAgents", LAUNCHD_PLIST_NAME);
+  const plistPath = (0, import_node_path17.join)((0, import_node_os8.homedir)(), "Library", "LaunchAgents", LAUNCHD_PLIST_NAME);
   const boot = launchctl(["bootout", `gui/${uid()}/${LAUNCHD_LABEL}`]);
-  if (boot.status !== 0 && (0, import_node_fs21.existsSync)(plistPath)) {
+  if (boot.status !== 0 && (0, import_node_fs24.existsSync)(plistPath)) {
     return { ok: false, detail: `launchctl bootout failed: ${(boot.stderr || boot.stdout).trim() || "unknown error"}` };
   }
   try {
-    (0, import_node_fs21.rmSync)(plistPath, { force: true });
+    (0, import_node_fs24.rmSync)(plistPath, { force: true });
   } catch {
   }
   dropLauncher(env, POSIX_LAUNCHER_FILE);
   return { ok: true, detail: `automatic updates off \u2014 removed "${LAUNCHD_LABEL}"; installed tooling was kept` };
 }
 function uninstallSystemdTimer(env) {
-  const unitDir = (0, import_node_path15.join)((0, import_node_os8.homedir)(), ".config", "systemd", "user");
-  const timerPath = (0, import_node_path15.join)(unitDir, SYSTEMD_TIMER_NAME);
+  const unitDir = (0, import_node_path17.join)((0, import_node_os8.homedir)(), ".config", "systemd", "user");
+  const timerPath = (0, import_node_path17.join)(unitDir, SYSTEMD_TIMER_NAME);
   const disable = systemctlUser(["disable", "--now", SYSTEMD_TIMER_NAME]);
-  if (disable.status !== 0 && (0, import_node_fs21.existsSync)(timerPath)) {
+  if (disable.status !== 0 && (0, import_node_fs24.existsSync)(timerPath)) {
     return { ok: false, detail: `systemctl --user disable --now ${SYSTEMD_TIMER_NAME} failed: ${(disable.stderr || disable.stdout).trim() || "unknown error"}` };
   }
   try {
-    (0, import_node_fs21.rmSync)(timerPath, { force: true });
-    (0, import_node_fs21.rmSync)((0, import_node_path15.join)(unitDir, SYSTEMD_SERVICE_NAME), { force: true });
+    (0, import_node_fs24.rmSync)(timerPath, { force: true });
+    (0, import_node_fs24.rmSync)((0, import_node_path17.join)(unitDir, SYSTEMD_SERVICE_NAME), { force: true });
   } catch {
   }
   systemctlUser(["daemon-reload"]);
@@ -4212,16 +4514,16 @@ function uninstallTask(env = process.env) {
 }
 function dropLauncher(env, file) {
   try {
-    (0, import_node_fs21.rmSync)((0, import_node_path15.join)(statePaths(env).root, file), { force: true });
+    (0, import_node_fs24.rmSync)((0, import_node_path17.join)(statePaths(env).root, file), { force: true });
   } catch {
   }
 }
 
 // src/status.ts
-var import_node_fs22 = require("node:fs");
+var import_node_fs25 = require("node:fs");
 function readJournal(path) {
   try {
-    const events = (0, import_node_fs22.readFileSync)(path, "utf8").split("\n").filter((line) => line.trim()).map((line) => {
+    const events = (0, import_node_fs25.readFileSync)(path, "utf8").split("\n").filter((line) => line.trim()).map((line) => {
       try {
         return JSON.parse(line);
       } catch {
@@ -4430,14 +4732,14 @@ function reportCounts(summary) {
 }
 
 // src/stamp.ts
-var import_node_fs23 = require("node:fs");
+var import_node_fs26 = require("node:fs");
 var ALWAYS_ARMED = ["cli", "updater"];
 var PLUGIN_ARMS = /* @__PURE__ */ new Set(["claude", "codex", "jervcode", "cursor", "hermes"]);
 function fleetStamp(env = process.env) {
   const paths = statePaths(env);
   let events = [];
   try {
-    events = (0, import_node_fs23.readFileSync)(paths.journalPath, "utf8").split("\n").filter((line) => line.trim()).map((line) => {
+    events = (0, import_node_fs26.readFileSync)(paths.journalPath, "utf8").split("\n").filter((line) => line.trim()).map((line) => {
       try {
         return JSON.parse(line);
       } catch {
@@ -4487,7 +4789,7 @@ function fleetStamp(env = process.env) {
 // src/index.ts
 function ownVersion() {
   try {
-    return JSON.parse((0, import_node_fs24.readFileSync)((0, import_node_path16.join)(__dirname, "..", "package.json"), "utf8")).version;
+    return JSON.parse((0, import_node_fs27.readFileSync)((0, import_node_path18.join)(__dirname, "..", "package.json"), "utf8")).version;
   } catch {
     return "0.0.0";
   }
@@ -4650,6 +4952,7 @@ if (typeof require !== "undefined" && require.main === module) {
   renderNotice,
   renderReport,
   reportCounts,
+  resolvePayloadTarball,
   retiredSurfaces,
   retryHint,
   runMaintenance,
@@ -4659,6 +4962,7 @@ if (typeof require !== "undefined" && require.main === module) {
   sharedDocLockTimeoutReceipt,
   shippedTargetFrom,
   shouldHandOff,
+  stagePackage,
   statusScreen,
   surfaceArmPlan,
   systemdServiceUnit,