@mutmutco/hub 4.5.6 → 4.5.7

package/dist/index.cjs

@@ -40,6 +40,7 @@ __export(index_exports, {
   hermesHostEvidence: () => hermesHostEvidence,
   hermesHostPresent: () => hermesHostPresent,
   hubStatus: () => hubStatus,
+  hubStatusReport: () => hubStatusReport,
   launchdPlist: () => launchdPlist,
   launcherSh: () => launcherSh,
   launcherVbs: () => launcherVbs,
@@ -64,6 +65,8 @@ __export(index_exports, {
   reconcile: () => reconcile,
   reconcileCursorUserHooks: () => reconcileCursorUserHooks,
   releaseSharedDocLock: () => releaseSharedDocLock,
+  renderNotice: () => renderNotice,
+  renderReport: () => renderReport,
   reportCounts: () => reportCounts,
   retiredSurfaces: () => retiredSurfaces,
   retryHint: () => retryHint,
@@ -74,6 +77,7 @@ __export(index_exports, {
   sharedDocLockTimeoutReceipt: () => sharedDocLockTimeoutReceipt,
   shippedTargetFrom: () => shippedTargetFrom,
   shouldHandOff: () => shouldHandOff,
+  statusScreen: () => statusScreen,
   surfaceArmPlan: () => surfaceArmPlan,
   systemdServiceUnit: () => systemdServiceUnit,
   systemdTimerUnit: () => systemdTimerUnit,
@@ -84,9 +88,9 @@ __export(index_exports, {
   writePending: () => writePending
 });
 module.exports = __toCommonJS(index_exports);
-var import_node_child_process10 = require("node:child_process");
-var import_node_fs22 = require("node:fs");
-var import_node_path13 = require("node:path");
+var import_node_child_process11 = require("node:child_process");
+var import_node_fs24 = require("node:fs");
+var import_node_path16 = require("node:path");
 
 // ../installer/face/src/face.ts
 var import_node_fs = require("node:fs");
@@ -96,6 +100,7 @@ var PRODUCTS = Object.freeze({
   "mm-strategy": Object.freeze({
     name: "MM Strategy",
     installWarm: "Welcome. Let's get you ready.",
+    checkWarm: "Here's where things stand.",
     accent: "38;2;249;115;22",
     warm: "Welcome back. Checking for updates...",
     doctor: "mm-strategy doctor"
@@ -103,6 +108,7 @@ var PRODUCTS = Object.freeze({
   "mmi-hub": Object.freeze({
     name: "mmi-hub",
     installWarm: "Welcome. Let's get you ready.",
+    checkWarm: "Here's where things stand.",
     accent: "38;2;125;211;252",
     warm: "Welcome back. Checking for updates...",
     doctor: "mmi doctor"
@@ -110,6 +116,7 @@ var PRODUCTS = Object.freeze({
   "jerv-hub": Object.freeze({
     name: "jerv-hub",
     installWarm: "Welcome. Let's get you ready.",
+    checkWarm: "Here's where things stand.",
     accent: "38;2;248;113;113",
     warm: "Welcome back. Checking for updates...",
     doctor: "jerv doctor"
@@ -117,6 +124,7 @@ var PRODUCTS = Object.freeze({
   jervcode: Object.freeze({
     name: "JervCode",
     installWarm: "Welcome. Let's get you ready.",
+    checkWarm: "Here's where things stand.",
     accent: "38;2;192;132;252",
     warm: "Welcome back. Checking for updates...",
     doctor: "jervcode doctor"
@@ -232,7 +240,7 @@ function createFace({ product, color = false, columns, env = process.env, operat
   const welcome = () => continuesFace || nested ? [] : [
     `${paint(identity.accent, GLYPH.diamond)}  ${paint(identity.accent, identity.name)} \u2014 Mutatis Mutandis`,
     bar(),
-    `${bar()}  ${operation === "install" ? identity.installWarm : identity.warm}`,
+    `${bar()}  ${operation === "install" ? identity.installWarm : operation === "check" ? identity.checkWarm : identity.warm}`,
     bar()
   ];
   const continues = (phase, kind = "ok") => {
@@ -262,7 +270,11 @@ function createFace({ product, color = false, columns, env = process.env, operat
     const content = Math.min(width - 6, Math.max(...body.map(visibleWidth)));
     const rule = paint(identity.accent, GLYPH.rule.repeat(content + 4));
     const frame = (left, right) => `${paint(identity.accent, left)}${rule}${paint(identity.accent, right)}`;
-    const bodyRow = (line) => line.startsWith(GLYPH.check) ? `${paint(identity.accent, GLYPH.check)}${line.slice(1)}` : line;
+    const headGlyph = { [GLYPH.check]: identity.accent, [GLYPH.cross]: identity.accent, [GLYPH.dot]: PALETTE.muted };
+    const bodyRow = (line) => {
+      const sgr = headGlyph[line.charAt(0)];
+      return sgr ? `${paint(sgr, line.charAt(0))}${line.slice(1)}` : line;
+    };
     return [
       frame(GLYPH.boxTop, GLYPH.boxTopEnd),
       ...body.map((line) => `${paint(identity.accent, GLYPH.bar)}  ${bodyRow(line)}${" ".repeat(Math.max(0, content - visibleWidth(line)))}  ${paint(identity.accent, GLYPH.bar)}`),
@@ -288,6 +300,9 @@ function createFace({ product, color = false, columns, env = process.env, operat
 // ../installer/face/src/shell.ts
 var RELAY_INDENT = " ".repeat(TITLE_COLUMN - 1);
 
+// ../installer/face/src/rows.ts
+var plainText = (text) => String(text).replaceAll("\u2192", "->").replaceAll("\xB7", "-").replaceAll("\u2014", "-").replaceAll("\u2026", "...");
+
 // ../installer/face/src/spinner.ts
 var import_node_fs2 = require("node:fs");
 var import_node_worker_threads = require("node:worker_threads");
@@ -468,48 +483,48 @@ function assertFaceConformance(lines, options) {
   const identity = identityFor(options.product);
   const width = options.columns ?? 100;
   const rendered = lines.flatMap((line) => String(line).split("\n"));
-  const plain = rendered.map(stripColor);
-  const head = plain[0] ?? "";
+  const plain2 = rendered.map(stripColor);
+  const head = plain2[0] ?? "";
   const signOffLine = `${GLYPH.diamond}  ${identity.name} \xB7 Mutatis Mutandis`;
   const opensWithWelcome = head.startsWith(GLYPH.diamond) && head !== signOffLine;
   if (options.complete && options.tty !== false) {
     const welcome = `${GLYPH.diamond}  ${identity.name} \u2014 Mutatis Mutandis`;
-    const welcomes = plain.filter((line) => line === welcome).length;
-    const receipts = plain.filter((line) => line.startsWith(GLYPH.boxTop)).length;
-    const signOffs = plain.filter((line) => line === signOffLine).length;
+    const welcomes = plain2.filter((line) => line === welcome).length;
+    const receipts = plain2.filter((line) => line.startsWith(GLYPH.boxTop)).length;
+    const signOffs = plain2.filter((line) => line === signOffLine).length;
     if (welcomes !== (options.nested ? 0 : 1) || signOffs !== (options.nested ? 0 : 1) || !options.nested && receipts !== 1) {
       fail("complete run", "expected one console owner, one welcome, one receipt and one sign-off");
     }
-    for (const line of plain) {
+    for (const line of plain2) {
       if (line && ![GLYPH.bar, GLYPH.diamond, GLYPH.hollow, GLYPH.boxTop, GLYPH.boxBottom].some((glyph) => line.startsWith(glyph))) {
         fail("complete run", `unframed output: ${JSON.stringify(line)}`);
       }
     }
   }
   if (rendered.length === 0) fail("R7 render before you ship", "no rendered lines were given to the guard");
-  const greetings = plain.filter((line) => ["\u2014", "-"].some((separator) => line.includes(`${identity.name} ${separator} Mutatis Mutandis`)));
+  const greetings = plain2.filter((line) => ["\u2014", "-"].some((separator) => line.includes(`${identity.name} ${separator} Mutatis Mutandis`)));
   if (greetings.length > 1) fail("R8 one welcome per run", "duplicate product greeting");
-  if (plain.filter((line) => line.startsWith(GLYPH.boxTop)).length > 1) {
+  if (plain2.filter((line) => line.startsWith(GLYPH.boxTop)).length > 1) {
     fail("R8 one receipt per run", "duplicate receipt");
   }
   if (options.nested === true) {
     if (opensWithWelcome) {
       fail("R8 a nested run draws no welcome", `an outer console already greeted the user; this run opened with ${JSON.stringify(head)}`);
     }
-    const signOffAt = plain.findIndex((line) => line === signOffLine);
+    const signOffAt = plain2.findIndex((line) => line === signOffLine);
     if (signOffAt !== -1) {
       fail("R8 a nested run draws no sign-off", `the outer console closes the run; line ${signOffAt + 1} signs off`);
     }
-    const boxAt = plain.findIndex((line) => line.startsWith(GLYPH.boxTop));
+    const boxAt = plain2.findIndex((line) => line.startsWith(GLYPH.boxTop));
     if (boxAt !== -1) {
-      const headline = plain.slice(boxAt + 1).find((line) => line.startsWith(GLYPH.bar) && line.trim() !== GLYPH.bar) ?? "";
+      const headline = plain2.slice(boxAt + 1).find((line) => line.startsWith(GLYPH.bar) && line.trim() !== GLYPH.bar) ?? "";
       if (headline.includes(GLYPH.check)) {
         fail("R8 a nested run draws no success receipt", `the outer console owns the outcome; this run printed ${JSON.stringify(headline.trim())}`);
       }
     }
   }
   if (options.tty === false) {
-    for (const line of plain) {
+    for (const line of plain2) {
       const glyph = [...line].find((char) => ALLOWED.has(char));
       if (glyph) fail("non-TTY lane is plain", `a piped run emitted ${JSON.stringify(glyph)} in ${JSON.stringify(line)}`);
     }
@@ -518,32 +533,32 @@ function assertFaceConformance(lines, options) {
     }
     return;
   }
-  for (const line of plain) {
+  for (const line of plain2) {
     if (line.startsWith(`${GLYPH.bar}  ${GLYPH.hollow}  `)) {
       fail("note step uses U+25CF", `U+25C7 is the note-box opener in ${JSON.stringify(line)}`);
     }
   }
-  for (const line of plain) {
+  for (const line of plain2) {
     if (/[\u25c6\u25c7\u2714\u2716\u25cf] (?! )/u.test(line)) {
       fail("R4 two spaces after a glyph", `a single space follows the glyph in ${JSON.stringify(line)}`);
     }
   }
-  for (const line of plain) {
+  for (const line of plain2) {
     for (const [glyph, why] of FORBIDDEN) {
       if (line.includes(glyph)) fail("glyph set", `${why} (in ${JSON.stringify(line)})`);
     }
     const emoji = [...line].find((char) => EMOJI.test(char) && !ALLOWED.has(char));
     if (emoji) fail("glyph set", `emoji ${JSON.stringify(emoji)} in ${JSON.stringify(line)}`);
   }
-  const top = plain.findIndex((line) => line.startsWith(GLYPH.boxTop));
+  const top = plain2.findIndex((line) => line.startsWith(GLYPH.boxTop));
   if (top !== -1) {
-    const bottom = plain.findIndex((line, index) => index > top && line.startsWith(GLYPH.boxBottom));
+    const bottom = plain2.findIndex((line, index) => index > top && line.startsWith(GLYPH.boxBottom));
     if (bottom === -1) fail("R5 receipt frame", "the receipt box opens and never closes");
-    if (!plain[top].endsWith(GLYPH.boxTopEnd)) fail("R5 receipt frame", `the top row does not pair its corners: ${JSON.stringify(plain[top])}`);
-    if (!plain[bottom].endsWith(GLYPH.boxBottomEnd)) fail("R5 receipt frame", `the bottom row does not pair its corners: ${JSON.stringify(plain[bottom])}`);
-    const widths = new Set(plain.slice(top, bottom + 1).map(visibleWidth));
+    if (!plain2[top].endsWith(GLYPH.boxTopEnd)) fail("R5 receipt frame", `the top row does not pair its corners: ${JSON.stringify(plain2[top])}`);
+    if (!plain2[bottom].endsWith(GLYPH.boxBottomEnd)) fail("R5 receipt frame", `the bottom row does not pair its corners: ${JSON.stringify(plain2[bottom])}`);
+    const widths = new Set(plain2.slice(top, bottom + 1).map(visibleWidth));
     if (widths.size !== 1) fail("R5 receipt frame", `the box is ragged: widths ${[...widths].join(", ")}`);
-    const rows = plain.slice(top + 1, bottom);
+    const rows = plain2.slice(top + 1, bottom);
     if (rows.length > 0 && rows[0].includes(GLYPH.check)) {
       if (rows.length < 3) {
         fail("R9 the receipt says what changed", `a success receipt has three lines \u2014 ready, what changed, the health command \u2014 and this one has ${rows.length}: ${JSON.stringify(rows.map((row) => row.trim()))}`);
@@ -552,9 +567,9 @@ function assertFaceConformance(lines, options) {
       if (changed === "") fail("R9 the receipt says what changed", "the middle line of the success receipt is blank");
     }
   }
-  const inReceipt = (index) => top !== -1 && index >= top && index <= plain.findIndex((line, at) => at > top && line.startsWith(GLYPH.boxBottom));
+  const inReceipt = (index) => top !== -1 && index >= top && index <= plain2.findIndex((line, at) => at > top && line.startsWith(GLYPH.boxBottom));
   const welcomeEnd = opensWithWelcome ? 4 : 0;
-  for (const [index, line] of plain.entries()) {
+  for (const [index, line] of plain2.entries()) {
     if (index < welcomeEnd || inReceipt(index)) continue;
     if (!line.startsWith(GLYPH.bar) || line.trim() === GLYPH.bar) continue;
     const after = [...line.slice(1)];
@@ -565,18 +580,18 @@ function assertFaceConformance(lines, options) {
       fail("R1 one rail, one left edge", `text starts at column ${edge} without a glyph there; a line that carries no glyph belongs at the title column (${TITLE_COLUMN + 1}): ${JSON.stringify(line)}`);
     }
   }
-  for (const line of plain) {
+  for (const line of plain2) {
     if (/\(node:\d+\)|DeprecationWarning|ExperimentalWarning/u.test(line)) {
       fail("R2 no foreign output in the face", `a Node warning reached the face: ${JSON.stringify(line)} \u2014 fix the spawn, or run the child with --no-deprecation`);
     }
   }
-  const receiptStart = top === -1 ? plain.length : top;
-  for (const line of plain.slice(0, receiptStart)) {
+  const receiptStart = top === -1 ? plain2.length : top;
+  for (const line of plain2.slice(0, receiptStart)) {
     if (/[\u2714\u2716\u25cf\u25c7]/u.test(line) && /([A-Za-z]:\\|\/(?:home|Users|opt|usr)\/)/u.test(line)) {
       fail("R3 paths live in the receipt", `a step line carries a path: ${JSON.stringify(line)}`);
     }
   }
-  for (const line of plain) {
+  for (const line of plain2) {
     if (visibleWidth(line) > width) {
       fail("width cap", `a line is ${visibleWidth(line)} columns wide, cap ${width}: ${JSON.stringify(line)}`);
     }
@@ -584,7 +599,7 @@ function assertFaceConformance(lines, options) {
   if (opensWithWelcome) {
     const expected = `${GLYPH.diamond}  ${identity.name} \u2014 Mutatis Mutandis`;
     if (head !== expected) fail("welcome is the product table's", `expected ${JSON.stringify(expected)}, got ${JSON.stringify(head)}`);
-    const warm = plain.slice(1, 4).find((line) => line.includes(identity.warm) || line.includes(identity.installWarm));
+    const warm = plain2.slice(1, 4).find((line) => [identity.warm, identity.installWarm, identity.checkWarm].some((text) => line.includes(text)));
     if (!warm) fail("welcome is the product table's", `the warm line for ${options.product} is missing or reworded`);
   }
   const painted = rendered.join("\n");
@@ -647,22 +662,44 @@ function validateInstallerProduct(value) {
   if (doctor !== identity.doctor) return fail2("doctor");
   if (!Array.isArray(input.surfaces) || input.surfaces.length === 0) return fail2("surfaces");
   const ids = /* @__PURE__ */ new Set();
-  const surfaces = input.surfaces.map((raw) => {
-    if (!raw || typeof raw !== "object" || Array.isArray(raw)) return fail2("surface");
-    const source = raw;
-    const id = text(source.id, "surface.id");
+  const surfaces = input.surfaces.map((raw2) => {
+    if (!raw2 || typeof raw2 !== "object" || Array.isArray(raw2)) return fail2("surface");
+    const source2 = raw2;
+    const id = text(source2.id, "surface.id");
     if (ids.has(id)) return fail2("duplicate surface.id");
     ids.add(id);
     const surface = { id };
     for (const field of ["npm", "bin", "kind", "activation"]) {
-      if (source[field] !== void 0) surface[field] = text(source[field], `surface.${field}`);
+      if (source2[field] !== void 0) surface[field] = text(source2[field], `surface.${field}`);
     }
     if (Boolean(surface.npm) !== Boolean(surface.bin)) return fail2("surface npm/bin pair");
     if (surface.kind !== void 0 && !["agent-home", "payload"].includes(surface.kind)) return fail2("surface.kind");
     if (!surface.npm && !surface.kind) return fail2("surface implementation");
     return surface;
   });
-  return { product, gate, doctor, surfaces };
+  if (input.launcher === void 0) return { product, gate, doctor, surfaces };
+  const raw = input.launcher;
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return fail2("launcher");
+  const source = raw;
+  const https = (value2, field) => {
+    const url = text(value2, field).replace(/\/+$/u, "");
+    let parsed;
+    try {
+      parsed = new URL(url);
+    } catch {
+      return fail2(field);
+    }
+    return parsed.protocol === "https:" && !parsed.username && !parsed.password ? url : fail2(field);
+  };
+  const launcher = {
+    product: text(source.product, "launcher.product"),
+    bin: text(source.bin, "launcher.bin"),
+    key: text(source.key, "launcher.key"),
+    host: https(source.host, "launcher.host")
+  };
+  if (source.dl !== void 0) launcher.dl = https(source.dl, "launcher.dl");
+  if (Buffer.from(launcher.key, "base64").length !== 32) return fail2("launcher.key");
+  return { product, gate, doctor, surfaces, launcher };
 }
 var PHASES = {
   preflight: ["Checking prerequisites", "Checked prerequisites"],
@@ -687,13 +724,30 @@ var UPDATE_CHECK_PHASES = /* @__PURE__ */ new Set([
   "sign-in",
   "check"
 ]);
+var SURFACE_WORDS = Object.freeze({
+  updated: "updated",
+  current: "already current",
+  failed: "failed",
+  skipped: "skipped",
+  retry: "retrying",
+  pending: "pending",
+  kept: "kept",
+  /** Read-only report states. */
+  behind: "update available",
+  ahead: "ahead of the release",
+  staged: "next launch",
+  unknown: "unknown",
+  missing: "not installed"
+});
+var AUTO_UPDATE = "auto-update";
+var LAUNCHER_SURFACE = "launcher";
 function createInstallerRun(value, options = {}) {
-  const declaration = validateInstallerProduct(value);
+  const declaration2 = validateInstallerProduct(value);
   const env = options.env ?? process.env;
   const tty = options.tty ?? Boolean(process.stdout.isTTY);
   const face = createFace({
     operation: options.operation,
-    product: declaration.product,
+    product: declaration2.product,
     columns: options.columns,
     env,
     color: tty && options.color !== false && env.NO_COLOR === void 0 && env.TERM !== "dumb"
@@ -814,11 +868,11 @@ function createInstallerRun(value, options = {}) {
     },
     surface(facts) {
       if (finished) throw new Error("installer run already finished");
-      const surface = declaration.surfaces.find((surface2) => surface2.id === facts.id);
+      const surface = declaration2.surfaces.find((surface2) => surface2.id === facts.id) ?? (facts.id === LAUNCHER_SURFACE ? { id: LAUNCHER_SURFACE } : void 0);
       if (!surface) throw new Error("installer run: undeclared surface");
       start();
       const versions = facts.to ? facts.from && facts.from !== facts.to ? ` ${facts.from} ${tty ? "\u2192" : "->"} ${facts.to}` : ` ${facts.to}` : "";
-      const status = { updated: options.dryRun ? "would update" : "updated", current: "already current", failed: "failed", skipped: "skipped", retry: "retrying", pending: "pending", kept: "kept" }[facts.state];
+      const status = facts.state === "updated" && options.dryRun ? "would update" : SURFACE_WORDS[facts.state];
       if (!status) throw new Error("installer run: unknown surface state");
       const separator = tty ? "\xB7" : "-";
       const activation = facts.state === "updated" && surface.activation ? ` ${separator} ${surface.activation}` : "";
@@ -926,14 +980,15 @@ function createInstallerRun(value, options = {}) {
       if (options.quiet && facts.updated === 0 && facts.failed === 0 && !facts.operationFailed) return;
       const changed = !facts.version ? "No release target is available." : facts.dryRun ? `Would update ${facts.updated} of ${facts.total} surfaces to ${facts.version}.` : facts.installed ? `Installed ${facts.version} across ${facts.total} surfaces.` : `Updated ${facts.updated} of ${facts.total} surfaces to ${facts.version}.`;
       const ready = facts.failed === 0 && !facts.dryRun && !facts.deferred && !facts.operationFailed && Boolean(facts.version);
+      const deferred = Boolean(facts.deferred) && facts.failed === 0 && !facts.operationFailed;
       const body = [
-        `${ready ? GLYPH.check : facts.dryRun ? GLYPH.dot : GLYPH.cross}  ${face.identity.name}${ready ? " is ready." : facts.dryRun ? " preview complete." : facts.deferred ? " update deferred." : " is not ready yet."}`,
+        `${ready ? GLYPH.check : facts.dryRun || deferred ? GLYPH.dot : GLYPH.cross}  ${face.identity.name}${ready ? " is ready." : facts.dryRun ? " preview complete." : deferred ? ` ${operation === "install" ? "install" : "update"} deferred.` : " is not ready yet."}`,
         changed,
         ...facts.failed ? [`Failed ${facts.failed} of ${facts.total} surfaces.`] : [],
         ...facts.detail ? [facts.detail] : [],
         ...facts.rollback ? [`Rollback: ${facts.rollback}`] : [],
         ...facts.logPath ? [`Log: ${facts.logPath}`] : facts.logState ? [`Log: ${facts.logState}`] : [],
-        facts.retry && (facts.failed > 0 || facts.operationFailed) ? `Retry:  ${facts.retry}` : `Check health any time:  ${declaration.doctor}`
+        facts.retry && (facts.failed > 0 || facts.operationFailed) ? `Retry:  ${facts.retry}` : `Check health any time:  ${declaration2.doctor}`
       ];
       if (!face.nested || !env.MM_INSTALLER_OUTCOME_FILE && (facts.failed > 0 || facts.operationFailed)) {
         lines(tty ? face.receipt(body, { ready }) : body.map((row) => row.replace(/^[✔✖●]  /u, "")));
@@ -950,6 +1005,89 @@ function createInstallerRun(value, options = {}) {
   return run;
 }
 
+// ../installer/face/src/screens.ts
+function screenLane(render = {}, stream = "stdout") {
+  const env = render.env ?? process.env;
+  const out = stream === "stdout" ? process.stdout : process.stderr;
+  const tty = render.tty ?? Boolean(out.isTTY);
+  const color = tty && render.color !== false && env.NO_COLOR === void 0 && env.TERM !== "dumb";
+  return { tty, color, columns: render.columns ?? out.columns, env };
+}
+var faceFor = (product, lane, operation) => createFace({ product, color: lane.color, columns: lane.columns, env: { ...lane.env, MM_OUTER_CONSOLE: void 0, MM_FACE_CONTINUES: void 0, MM_PROGRESS_FD: void 0, MM_PROGRESS_FILE: void 0 }, operation });
+function renderNotice(product, notice2, render) {
+  const lane = screenLane(render, notice2.state === "fail" ? "stderr" : "stdout");
+  const face = faceFor(product, lane);
+  const width = face.width - 3;
+  const [first, ...rest] = wrapWords(plain(notice2.message, lane), width);
+  if (!lane.tty) {
+    return [`${notice2.state === "fail" ? "Error: " : ""}${[first, ...rest].join(" ")}`, ...notice2.next ? [`Next: ${notice2.next}`] : []];
+  }
+  const glyph = notice2.state === "fail" ? face.paint(face.identity.accent, GLYPH.cross) : notice2.state === "note" ? face.paint(PALETTE.muted, GLYPH.dot) : face.paint(face.identity.accent, GLYPH.check);
+  return [
+    `${glyph}  ${first}`,
+    ...rest.map((line) => `   ${line}`),
+    ...notice2.next ? [`   ${face.paint(PALETTE.muted, "Next:")}  ${notice2.next}`] : []
+  ];
+}
+function renderReport(product, report, render) {
+  const lane = screenLane(render);
+  const face = faceFor(product, lane, "check");
+  const { verdict } = report;
+  const headline = `${face.identity.name} ${verdict.headline}`;
+  if (!lane.tty) {
+    return [
+      `${face.identity.name} - Mutatis Mutandis`,
+      face.identity.checkWarm,
+      ...report.rows.map((row) => `${row.mark === "fail" ? "Failed: " : ""}${plainText(rowTitle(row))}`),
+      ...report.rows.flatMap((row) => row.note ? [`  ${plainText(row.note)}`] : []),
+      `${verdict.state === "fail" ? "Error: " : ""}${plainText(headline)}`,
+      ...(verdict.facts ?? []).map(plainText),
+      `Next: ${verdict.next}`
+    ];
+  }
+  const glyph = verdict.state === "fail" ? GLYPH.cross : verdict.state === "note" ? GLYPH.dot : GLYPH.check;
+  const facts = verdict.facts?.length ? verdict.facts : [verdict.state === "ok" ? "Everything checked passed." : "See the rows above."];
+  return [
+    ...face.welcome(),
+    // A report row IS an update row: glyph, subject, state (#7071). Two layouts for one fact — a
+    // mark mid-row after a subject column here, a leading glyph in `update` — is the drift itself.
+    ...report.rows.flatMap((row) => [face.step(rowTitle(row), null, row.mark ?? "note"), ...row.note ? [face.relay(row.note)] : []]),
+    ...report.rows.length ? [face.paint(PALETTE.muted, GLYPH.bar)] : [],
+    ...face.receipt([`${glyph}  ${headline}`, ...facts, `Next:  ${verdict.next}`], { ready: verdict.state === "ok" }),
+    face.signOff()
+  ].filter((line) => line !== "");
+}
+function renderUsage(product, usage2, render) {
+  const lane = screenLane(render);
+  const face = faceFor(product, lane);
+  const all = [...usage2.commands, ...usage2.options ?? []];
+  const column = Math.min(Math.max(...all.map((entry) => entry.usage.length)), 34);
+  const table = (entries) => entries.flatMap((entry) => {
+    const [first, ...rest] = wrapWords(plain(entry.text, lane), Math.max(20, face.width - column - 6));
+    const head = entry.usage.length > column ? [`  ${entry.usage}`, `  ${" ".repeat(column)}  ${first}`] : [`  ${entry.usage.padEnd(column)}  ${first}`];
+    return [...head, ...rest.map((line) => `  ${" ".repeat(column)}  ${line}`)];
+  });
+  return [
+    `${face.paint(face.identity.accent, usage2.bin)} ${usage2.version} ${lane.tty ? "\xB7" : "-"} ${plain(usage2.summary, lane)}`,
+    "",
+    `Usage:  ${usage2.bin} <command> [options]`,
+    "",
+    "Commands:",
+    ...table(usage2.commands),
+    ...usage2.options?.length ? ["", "Options:", ...table(usage2.options)] : []
+  ];
+}
+function renderVersion(bin, version, launcher) {
+  return `${bin} ${version}${launcher ? ` (launcher ${launcher})` : ""}`;
+}
+function printScreen(lines, stream = "stdout") {
+  const out = stream === "stdout" ? process.stdout : process.stderr;
+  out.write(lines.map((line) => `${line}
+`).join(""));
+}
+var plain = (text, lane) => lane.tty ? String(text) : plainText(stripColor(String(text)));
+var rowTitle = (row) => `${row.surface}${row.aspect ? ` ${row.aspect}` : ""}${row.instance ? ` \xB7 ${row.instance}` : ""} ${row.state}`;
+
 // ../installer/face/src/maintenance.ts
 async function runMaintenance(product, args, dependencies) {
   const json = args.includes("--json");
@@ -1016,11 +1154,13 @@ async function runMaintenance(product, args, dependencies) {
       to: arm.to ?? void 0,
       state: arm.verdict === "fail" ? "failed" : arm.verdict === "defer" ? "retry" : arm.verdict === "skip" ? "kept" : arm.from === arm.to && !arm.launchStaged ? "current" : "updated",
       ...arm.durationMs === void 0 ? {} : { seconds: arm.durationMs / 1e3 },
-      detail: dependencies.diagnose?.(arm)
+      detail: arm.surface === LAUNCHER_SURFACE ? arm.verdict === "ok" ? void 0 : arm.detail || void 0 : dependencies.diagnose?.(arm)
     });
   };
+  let launcherArm = null;
   const writeJson = (summary, schedule) => {
-    process.stdout.write(JSON.stringify(dependencies.jsonResult ? dependencies.jsonResult(summary, schedule) : installed ? { convergence: summary, autoupdate: schedule } : summary, null, 2) + "\n");
+    const result = dependencies.jsonResult ? dependencies.jsonResult(summary, schedule) : installed ? { convergence: summary, autoupdate: schedule } : summary;
+    process.stdout.write(JSON.stringify(launcherArm ? { ...result, launcher: launcherArm } : result, null, 2) + "\n");
   };
   try {
     const summary = await dependencies.engine({
@@ -1076,6 +1216,14 @@ async function runMaintenance(product, args, dependencies) {
       return 0;
     }
     for (const arm of pending) emitArm(arm);
+    if (dependencies.launcher && env.MM_OUTER_CONSOLE !== "1") {
+      const arm = await dependencies.launcher({ dryRun });
+      launcherArm = arm;
+      if (arm) {
+        if (arm.verdict === "fail") armFailed = true;
+        emitArm(arm);
+      }
+    }
     const waiting = summary.surfaces.filter((surface) => surface.present && surface.action === "arm-pending");
     if (!quiet) for (const surface of waiting) run?.surface({ id: surface.id, state: "pending" });
     let schedule = null;
@@ -1125,11 +1273,337 @@ async function runMaintenance(product, args, dependencies) {
   }
 }
 
+// ../installer/launcher/src/refresh.ts
+var import_node_child_process2 = require("node:child_process");
+var import_node_fs6 = require("node:fs");
+var import_node_os2 = require("node:os");
+var import_node_path3 = 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");
+
+// ../installer/launcher/src/download.ts
+async function readDownload(response, onProgress, expectedSize) {
+  const length = expectedSize ?? Number(response.headers.get("content-length"));
+  const total = Number.isSafeInteger(length) && length > 0 ? length : void 0;
+  let done = 0;
+  const report = () => onProgress?.({ done, ...total === void 0 ? {} : { total } });
+  report();
+  const chunks = [];
+  if (response.body) {
+    for await (const chunk of response.body) {
+      chunks.push(chunk);
+      done += chunk.length;
+      report();
+    }
+  }
+  return Buffer.concat(chunks);
+}
+
+// ../installer/launcher/src/store.ts
+var import_node_os = require("node:os");
+var import_node_path = require("node:path");
+function defaultProductDir(product) {
+  if (process.platform === "win32") {
+    const base = process.env.LOCALAPPDATA ?? (0, import_node_path.join)((0, import_node_os.tmpdir)(), "launcher-fallback");
+    return (0, import_node_path.join)(base, product);
+  }
+  const home = process.env.HOME ?? (0, import_node_os.tmpdir)();
+  return (0, import_node_path.join)(home, `.${product}`);
+}
+
+// ../installer/launcher/src/payload.ts
+var import_node_crypto = require("node:crypto");
+
+// ../installer/launcher/src/canonical.ts
+function canonicalJson(value) {
+  return encode(value);
+}
+function encode(value) {
+  if (value === null) return "null";
+  if (typeof value === "string") return JSON.stringify(value);
+  if (typeof value === "boolean") return value ? "true" : "false";
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      throw new TypeError("canonicalJson: cannot encode a non-finite number");
+    }
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map((entry) => encode(entry)).join(",")}]`;
+  }
+  if (typeof value === "object") {
+    const record = value;
+    const keys = Object.keys(record).filter((key) => record[key] !== void 0).sort();
+    return `{${keys.map((key) => `${JSON.stringify(key)}:${encode(record[key])}`).join(",")}}`;
+  }
+  throw new TypeError(`canonicalJson: cannot encode a value of type ${typeof value}`);
+}
+
+// ../installer/launcher/src/config.ts
+var import_node_sea = require("node:sea");
+function publicKeyBytes(config) {
+  const raw = Buffer.from(config.publicKey, "base64");
+  if (raw.length !== 32) {
+    throw new Error(`product config for "${config.product}" has a bad publicKey (want 32 raw bytes)`);
+  }
+  return raw;
+}
+
+// ../installer/launcher/src/payload.ts
+function canonicalManifestBytes(manifest2) {
+  return Buffer.from(
+    canonicalJson({
+      created: manifest2.created,
+      files: manifest2.files.map((file) => ({ path: file.path, sha256: file.sha256, size: file.size })),
+      version: manifest2.version
+    }),
+    "utf8"
+  );
+}
+function ed25519PublicKey(config) {
+  const raw = publicKeyBytes(config);
+  return (0, import_node_crypto.createPublicKey)({
+    key: { kty: "OKP", crv: "Ed25519", x: raw.toString("base64url") },
+    format: "jwk"
+  });
+}
+function verifyManifest(manifest2, signature, config) {
+  try {
+    const signatureBytes = Buffer.from(signature, "base64");
+    if (signatureBytes.length === 0) return false;
+    return (0, import_node_crypto.verify)(null, canonicalManifestBytes(manifest2), ed25519PublicKey(config), signatureBytes);
+  } catch {
+    return false;
+  }
+}
+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();
+}
+function parseManifest(json) {
+  if (typeof json !== "object" || json === null) throw new Error("the release manifest is not an object");
+  const record = json;
+  if (typeof record.version !== "string" || !record.version) throw new Error("the release manifest has no version");
+  if (typeof record.created !== "string" || !record.created) throw new Error("the release manifest has no created stamp");
+  if (!Array.isArray(record.files)) throw new Error("the release manifest has no files list");
+  if (typeof record.signature !== "string" || !record.signature) {
+    throw new Error("the release manifest is unsigned");
+  }
+  const files = record.files.map((entry) => {
+    const file = entry;
+    if (typeof file.path !== "string" || typeof file.sha256 !== "string" || typeof file.size !== "number") {
+      throw new Error("the release manifest lists a malformed file");
+    }
+    const safe = safeManifestPath(file.path);
+    if (safe === null) throw new Error(`the release manifest lists an unsafe path: ${file.path}`);
+    return { path: safe, sha256: file.sha256, size: file.size };
+  });
+  return { version: record.version, created: record.created, files, signature: record.signature };
+}
+function safeManifestPath(rawPath) {
+  if (rawPath.length === 0 || rawPath.includes("\0") || rawPath.includes("\\")) return null;
+  if (rawPath.startsWith("/")) return null;
+  const segments = rawPath.split("/");
+  for (const segment of segments) {
+    if (segment === "" || segment === "." || segment === "..") return null;
+  }
+  return segments.join("/");
+}
+
+// ../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");
+  const owner = `${process.pid}:${(0, import_node_crypto2.randomUUID)()}`;
+  try {
+    (0, import_node_fs5.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 });
+    } catch {
+      throw new Error("installation lock recovery is already pending");
+    }
+    try {
+      const previous = (0, import_node_fs5.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 {
+        process.kill(pid, 0);
+        throw new Error("another installer is running");
+      } 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 });
+    } finally {
+      (0, import_node_fs5.unlinkSync)(recovery);
+    }
+  }
+  let released = false;
+  return () => {
+    if (!released && (0, import_node_fs5.readFileSync)(path, "utf8") === owner) (0, import_node_fs5.unlinkSync)(path);
+    released = true;
+  };
+}
+
+// ../installer/launcher/src/refresh.ts
+var LAUNCHER_RECORD_FILE = "launcher.json";
+var RECORD_TIMEOUT_MS = 1e4;
+function platformKey(platform, arch) {
+  if (platform === "win32") return arch === "x64" || arch === "arm64" ? `win-${arch}` : null;
+  return platform === "darwin" && arch === "arm64" ? "darwin-arm64" : null;
+}
+function verifierFor(target) {
+  return { product: target.product, host: target.host, loginKind: "github", publicKey: target.key, binName: target.bin };
+}
+async function fetchRecord(target, options) {
+  let json;
+  try {
+    const response = await (options.fetch ?? fetch)(
+      `${target.host.replace(/\/+$/u, "")}/release/launcher`,
+      { signal: AbortSignal.timeout(options.timeoutMs ?? RECORD_TIMEOUT_MS) }
+    );
+    if (!response.ok) return null;
+    json = await response.json();
+  } catch {
+    return null;
+  }
+  let record;
+  try {
+    record = parseManifest(json);
+  } catch {
+    return null;
+  }
+  if (!verifyManifest(record, record.signature, verifierFor(target))) return "bad-signature";
+  return { version: record.version, files: record.files };
+}
+function compareVersions(a, b) {
+  const split = (v) => {
+    const [core, pre = ""] = v.split("-", 2);
+    return { nums: core.split(".").map((n) => Number.parseInt(n, 10) || 0), pre };
+  };
+  const x = split(a);
+  const y = split(b);
+  for (let i = 0; i < 3; i++) if ((x.nums[i] ?? 0) !== (y.nums[i] ?? 0)) return (x.nums[i] ?? 0) > (y.nums[i] ?? 0) ? 1 : -1;
+  if (x.pre === y.pre) return 0;
+  if (!x.pre) return 1;
+  if (!y.pre) return -1;
+  return x.pre > y.pre ? 1 : -1;
+}
+function recordedPath(productDir) {
+  try {
+    const saved = JSON.parse((0, import_node_fs6.readFileSync)((0, import_node_path3.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);
+}
+function parseLauncherVersion(stdout, bin) {
+  const text = String(stdout).trim();
+  if (!text.startsWith(`${bin} `)) return null;
+  return text.match(/launcher (\d+\.\d+\.\d+[^\s)]*)/u)?.[1] ?? null;
+}
+function runVersion(path, bin) {
+  return new Promise((resolve2) => {
+    (0, import_node_child_process2.execFile)(path, ["--version"], { timeout: 3e4, windowsHide: true, encoding: "utf8" }, (error, stdout) => {
+      resolve2(error ? null : parseLauncherVersion(stdout, bin));
+    });
+  });
+}
+function removeStale(file) {
+  const prefix = `${(0, import_node_path3.basename)(file)}.old-`;
+  let names;
+  try {
+    names = (0, import_node_fs6.readdirSync)((0, import_node_path3.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 });
+    } catch {
+    }
+  }
+}
+async function refreshLauncher(target, options = {}) {
+  const started = Date.now();
+  const platform = options.platform ?? process.platform;
+  const key = platformKey(platform, options.arch ?? process.arch);
+  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;
+  if (!options.dryRun) removeStale(file);
+  const from = await (options.readVersion ?? ((path) => runVersion(path, target.bin)))(file);
+  if (!from) return null;
+  const arm = (verdict, to, detail) => ({ surface: "launcher", from, to, verdict, detail, durationMs: Date.now() - started });
+  const record = await fetchRecord(target, options);
+  if (record === "bad-signature") return arm("fail", from, "The launcher record failed its signature check.");
+  const entry = record?.files.find((candidate) => candidate.path === key);
+  if (!record || !entry) return arm("skip", from, "No launcher update is offered yet.");
+  if (compareVersions(record.version, from) <= 0) return arm("ok", from, "");
+  if (options.dryRun) return arm("ok", record.version, "");
+  let unlock;
+  if (!options.lockHeld) {
+    try {
+      unlock = lockInstallation(productDir);
+    } catch {
+      return arm("defer", from, "Another install is running; the launcher updates next time.");
+    }
+  }
+  const next = `${file}.new-${process.pid}`;
+  let moved;
+  try {
+    let bytes;
+    try {
+      const response = await (options.fetch ?? fetch)(
+        `${(target.dl ?? target.host).replace(/\/+$/u, "")}/dl/${target.product}/${key}`,
+        { signal: AbortSignal.timeout(3e5) }
+      );
+      if (!response.ok) return arm("defer", from, "The launcher download did not complete; it retries next time.");
+      bytes = await readDownload(response, void 0, entry.size);
+    } catch {
+      return arm("defer", from, "The launcher download did not complete; it retries next time.");
+    }
+    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);
+      if (platform === "win32") {
+        moved = `${file}.old-${process.pid}-${Date.now()}`;
+        (0, import_node_fs6.renameSync)(file, moved);
+      }
+      (0, import_node_fs6.renameSync)(next, file);
+    } catch {
+      try {
+        if (moved && !(0, import_node_fs6.existsSync)(file)) (0, import_node_fs6.renameSync)(moved, file);
+      } catch {
+      }
+      (0, import_node_fs6.rmSync)(next, { force: true });
+      return arm("fail", from, "The launcher could not be replaced.");
+    }
+    return arm("ok", record.version, "");
+  } finally {
+    unlock?.();
+  }
+}
+
 // ../installer.product.json
 var installer_product_default = {
   product: "mmi",
   gate: "https://gate.mutmut.work/mmi",
   doctor: "mmi doctor",
+  launcher: { product: "mmi", bin: "mmi", key: "sFcp6EE2MtSEiDtnrIqwMoQVhvu+69rIy4Pw5QLeosk=", host: "https://get.mutmut.work/mmi" },
   surfaces: [
     { id: "updater", npm: "@mutmutco/hub", bin: "mmi-hub" },
     { id: "cli", npm: "@mutmutco/cli", bin: "mmi-cli" },
@@ -1142,22 +1616,22 @@ var installer_product_default = {
 };
 
 // src/state.ts
-var import_node_fs5 = require("node:fs");
-var import_node_os = require("node:os");
-var import_node_path = require("node:path");
+var import_node_fs7 = require("node:fs");
+var import_node_os3 = require("node:os");
+var import_node_path4 = require("node:path");
 function stateRoot(env = process.env) {
-  return env.MMI_UPDATER_HOME || (0, import_node_path.join)((0, import_node_os.homedir)(), ".mmi", "updater");
+  return env.MMI_UPDATER_HOME || (0, import_node_path4.join)((0, import_node_os3.homedir)(), ".mmi", "updater");
 }
 function statePaths(env = process.env) {
   const root = stateRoot(env);
-  const staging = (0, import_node_path.join)(root, "staging");
-  const gitCache = (0, import_node_path.join)(root, "git-cache", "mmi-hub.git");
-  return { root, staging, gitCache, journalPath: (0, import_node_path.join)(root, "journal.jsonl"), leasePath: (0, import_node_path.join)(root, "lease.lock") };
+  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") };
 }
 function ensureState(env = process.env) {
   const paths = statePaths(env);
-  (0, import_node_fs5.mkdirSync)(paths.staging, { recursive: true });
-  (0, import_node_fs5.mkdirSync)((0, import_node_path.dirname)(paths.gitCache), { recursive: true });
+  (0, import_node_fs7.mkdirSync)(paths.staging, { recursive: true });
+  (0, import_node_fs7.mkdirSync)((0, import_node_path4.dirname)(paths.gitCache), { recursive: true });
   return paths;
 }
 var UpdaterBusy = class extends Error {
@@ -1167,15 +1641,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_fs5.openSync)(path, "wx");
-    (0, import_node_fs5.writeFileSync)(fd, JSON.stringify({ token, pid: process.pid, ts: Date.now() }) + "\n");
-    (0, import_node_fs5.closeSync)(fd);
+    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);
     return {
       token,
       release() {
         try {
           const current2 = readLease(path);
-          if (current2 && current2.token === token) (0, import_node_fs5.unlinkSync)(path);
+          if (current2 && current2.token === token) (0, import_node_fs7.unlinkSync)(path);
         } catch {
         }
       }
@@ -1186,7 +1660,7 @@ function tryAcquire(path) {
   const current = readLease(path);
   if (current && Date.now() - current.ts > LEASE_STALE_MS) {
     try {
-      (0, import_node_fs5.renameSync)(path, `${path}.stale-${Date.now()}`);
+      (0, import_node_fs7.renameSync)(path, `${path}.stale-${Date.now()}`);
       return "stolen-stale";
     } catch {
     }
@@ -1195,7 +1669,7 @@ function tryAcquire(path) {
 }
 function readLease(path) {
   try {
-    return JSON.parse((0, import_node_fs5.readFileSync)(path, "utf8"));
+    return JSON.parse((0, import_node_fs7.readFileSync)(path, "utf8"));
   } catch {
     return null;
   }
@@ -1220,10 +1694,10 @@ function withLease(path, fn, waitMs = LEASE_WAIT_MS) {
 }
 function appendJournal(path, event) {
   try {
-    (0, import_node_fs5.mkdirSync)((0, import_node_path.dirname)(path), { recursive: true });
-    const fd = (0, import_node_fs5.openSync)(path, "a");
-    (0, import_node_fs5.writeFileSync)(fd, JSON.stringify(event) + "\n");
-    (0, import_node_fs5.closeSync)(fd);
+    (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);
     return true;
   } catch {
     return false;
@@ -1242,7 +1716,7 @@ function journalHighWater(path, surface, events) {
 function parseJournal(path) {
   const events = [];
   try {
-    for (const line of (0, import_node_fs5.readFileSync)(path, "utf8").split("\n")) {
+    for (const line of (0, import_node_fs7.readFileSync)(path, "utf8").split("\n")) {
       if (!line.trim()) continue;
       try {
         events.push(JSON.parse(line));
@@ -1256,7 +1730,7 @@ function parseJournal(path) {
 function journalSurfaceRepeatedFail(path, surface, currentRun) {
   let lastVerdict = null;
   try {
-    for (const line of (0, import_node_fs5.readFileSync)(path, "utf8").split("\n")) {
+    for (const line of (0, import_node_fs7.readFileSync)(path, "utf8").split("\n")) {
       if (!line.trim()) continue;
       try {
         const event = JSON.parse(line);
@@ -1299,26 +1773,26 @@ 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_fs5.existsSync)(path);
+  return (0, import_node_fs7.existsSync)(path);
 }
 
 // src/reconcile.ts
 var import_node_perf_hooks2 = require("node:perf_hooks");
 
 // src/npm.ts
-var import_node_child_process2 = require("node:child_process");
-var import_node_fs6 = require("node:fs");
-var import_node_path2 = require("node:path");
+var import_node_child_process3 = require("node:child_process");
+var import_node_fs8 = require("node:fs");
+var import_node_path5 = require("node:path");
 var cachedNpm = null;
 function resolveNpm(env = process.env) {
   if (env.MMI_UPDATER_NPM) return { kind: "command", command: env.MMI_UPDATER_NPM };
   if (cachedNpm) return cachedNpm;
   if (process.platform === "win32") {
-    const where = (0, import_node_child_process2.spawnSync)("where.exe", ["npm.cmd"], { encoding: "utf8", windowsHide: true });
+    const where = (0, import_node_child_process3.spawnSync)("where.exe", ["npm.cmd"], { encoding: "utf8", windowsHide: true });
     const first = where.stdout.split("\n").map((l) => l.trim()).find(Boolean);
     if (where.status === 0 && first) {
-      const script = (0, import_node_path2.join)((0, import_node_path2.dirname)(first), "node_modules", "npm", "bin", "npm-cli.js");
-      if ((0, import_node_fs6.existsSync)(script)) {
+      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)) {
         cachedNpm = { kind: "node-script", script };
         return cachedNpm;
       }
@@ -1326,14 +1800,14 @@ function resolveNpm(env = process.env) {
       return cachedNpm;
     }
   }
-  const bundled = (0, import_node_path2.join)((0, import_node_path2.dirname)(process.execPath), "..", "lib", "node_modules", "npm", "bin", "npm-cli.js");
-  if ((0, import_node_fs6.existsSync)(bundled)) {
+  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)) {
     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 located = (0, import_node_child_process3.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_fs6.existsSync)(resolved)) {
+  if (located.status === 0 && resolved && (0, import_node_fs8.existsSync)(resolved)) {
     cachedNpm = { kind: "command", command: resolved };
     return cachedNpm;
   }
@@ -1342,20 +1816,20 @@ function resolveNpm(env = process.env) {
 }
 function runNpm(args, env = process.env, options = {}) {
   const npm = resolveNpm(env);
-  const result = npm.kind === "node-script" ? (0, import_node_child_process2.spawnSync)(process.execPath, [npm.script, ...args], { encoding: "utf8", env, cwd: options.cwd, windowsHide: true }) : (0, import_node_child_process2.spawnSync)(npm.command, args, { encoding: "utf8", env, cwd: options.cwd, shell: process.platform === "win32", windowsHide: true });
+  const result = npm.kind === "node-script" ? (0, import_node_child_process3.spawnSync)(process.execPath, [npm.script, ...args], { encoding: "utf8", env, cwd: options.cwd, windowsHide: true }) : (0, import_node_child_process3.spawnSync)(npm.command, args, { encoding: "utf8", env, cwd: options.cwd, shell: process.platform === "win32", windowsHide: true });
   return { status: result.status, stdout: result.stdout ?? "", stderr: result.stderr ?? "" };
 }
 function runNpmAsync(args, env = process.env, options = {}) {
   const npm = resolveNpm(env);
   const [file, argv, shell] = npm.kind === "node-script" ? [process.execPath, [npm.script, ...args], false] : [npm.command, args, process.platform === "win32"];
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     let stdout = "";
     let stderr = "";
     let child;
     try {
-      child = (0, import_node_child_process2.spawn)(file, argv, { env, cwd: options.cwd, windowsHide: true, shell });
+      child = (0, import_node_child_process3.spawn)(file, argv, { env, cwd: options.cwd, windowsHide: true, shell });
     } catch (error) {
-      resolve({ status: null, stdout, stderr: String(error?.message ?? error) });
+      resolve2({ status: null, stdout, stderr: String(error?.message ?? error) });
       return;
     }
     child.stdout?.setEncoding("utf8");
@@ -1366,8 +1840,8 @@ function runNpmAsync(args, env = process.env, options = {}) {
     child.stderr?.on("data", (chunk) => {
       stderr += chunk;
     });
-    child.on("error", (error) => resolve({ status: null, stdout, stderr: String(error?.message ?? error) }));
-    child.on("close", (status) => resolve({ status, stdout, stderr }));
+    child.on("error", (error) => resolve2({ status: null, stdout, stderr: String(error?.message ?? error) }));
+    child.on("close", (status) => resolve2({ status, stdout, stderr }));
   });
 }
 var globalRootMemo = /* @__PURE__ */ new WeakMap();
@@ -1414,8 +1888,8 @@ function npmVersions(packageName, env = process.env) {
 }
 
 // src/gate.ts
-var import_node_child_process3 = require("node:child_process");
-var import_node_fs7 = require("node:fs");
+var import_node_child_process4 = require("node:child_process");
+var import_node_fs9 = require("node:fs");
 function parseBom(text) {
   const bom = JSON.parse(text);
   if (typeof bom?.version !== "string" || typeof bom?.sourceCommit !== "string" || !Array.isArray(bom?.artifacts)) {
@@ -1429,16 +1903,16 @@ function npmPackRows(bom) {
 var GateEnvError = class extends Error {
 };
 function git(cachePath, args) {
-  const result = (0, import_node_child_process3.spawnSync)("git", ["-C", cachePath, ...args], { encoding: "utf8", windowsHide: true });
+  const result = (0, import_node_child_process4.spawnSync)("git", ["-C", cachePath, ...args], { encoding: "utf8", windowsHide: true });
   return { status: result.status, stdout: (result.stdout ?? "").trim(), stderr: result.stderr ?? "" };
 }
 function ensureBareCache(cachePath, repoUrl) {
-  const probe = (0, import_node_child_process3.spawnSync)("git", ["--version"], { encoding: "utf8", windowsHide: true });
+  const probe = (0, import_node_child_process4.spawnSync)("git", ["--version"], { encoding: "utf8", windowsHide: true });
   if (probe.status !== 0) {
     throw new GateEnvError("git is not available \u2014 the release gate needs a git client");
   }
-  if (!(0, import_node_fs7.existsSync)(cachePath)) {
-    const init = (0, import_node_child_process3.spawnSync)("git", ["init", "--bare", cachePath], { encoding: "utf8", windowsHide: true });
+  if (!(0, import_node_fs9.existsSync)(cachePath)) {
+    const init = (0, import_node_child_process4.spawnSync)("git", ["init", "--bare", cachePath], { encoding: "utf8", windowsHide: true });
     if (init.status !== 0) throw new GateEnvError(`cannot create bare cache at ${cachePath}: ${init.stderr}`);
   }
 }
@@ -1544,39 +2018,39 @@ async function checkAtomicity(cachePath, tagCommit, bom, candidate, npm) {
 }
 
 // src/surfaces.ts
-var import_node_fs12 = require("node:fs");
-var import_node_os3 = require("node:os");
-var import_node_path7 = require("node:path");
+var import_node_fs14 = require("node:fs");
+var import_node_os5 = require("node:os");
+var import_node_path10 = require("node:path");
 
 // src/arm-host-plugins.ts
-var import_node_child_process6 = require("node:child_process");
-var import_node_fs11 = require("node:fs");
-var import_node_os2 = require("node:os");
-var import_node_path6 = require("node:path");
+var import_node_child_process7 = require("node:child_process");
+var import_node_fs13 = require("node:fs");
+var import_node_os4 = require("node:os");
+var import_node_path9 = require("node:path");
 
 // src/arm-npm-global.ts
-var import_node_fs9 = require("node:fs");
-var import_node_child_process5 = require("node:child_process");
-var import_node_path4 = require("node:path");
+var import_node_fs11 = require("node:fs");
+var import_node_child_process6 = require("node:child_process");
+var import_node_path7 = require("node:path");
 
 // src/pending.ts
-var import_node_child_process4 = require("node:child_process");
-var import_node_fs8 = require("node:fs");
-var import_node_path3 = require("node:path");
+var import_node_child_process5 = require("node:child_process");
+var import_node_fs10 = require("node:fs");
+var import_node_path6 = require("node:path");
 function hubDistPath(env) {
   const root = globalRoot(env);
-  return root ? (0, import_node_path3.join)(root, "@mutmutco", "hub", "dist", "index.cjs") : null;
+  return root ? (0, import_node_path6.join)(root, "@mutmutco", "hub", "dist", "index.cjs") : null;
 }
 var WATCHER_MAX_WAIT_MS = 4 * 60 * 60 * 1e3;
 function pendingPath(paths) {
-  return (0, import_node_path3.join)(paths.root, "pending.json");
+  return (0, import_node_path6.join)(paths.root, "pending.json");
 }
 function watcherLockPath(paths) {
-  return (0, import_node_path3.join)(paths.root, "pending-watcher.lock.d");
+  return (0, import_node_path6.join)(paths.root, "pending-watcher.lock.d");
 }
 function readPending(paths) {
   try {
-    const parsed = JSON.parse((0, import_node_fs8.readFileSync)(pendingPath(paths), "utf8"));
+    const parsed = JSON.parse((0, import_node_fs10.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 {
@@ -1584,12 +2058,12 @@ function readPending(paths) {
   }
 }
 function writePending(paths, records) {
-  (0, import_node_fs8.mkdirSync)(paths.root, { recursive: true });
+  (0, import_node_fs10.mkdirSync)(paths.root, { recursive: true });
   const path = pendingPath(paths);
   const tmp = `${path}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
-  (0, import_node_fs8.writeFileSync)(tmp, `${JSON.stringify(records, null, 2)}
+  (0, import_node_fs10.writeFileSync)(tmp, `${JSON.stringify(records, null, 2)}
 `, "utf8");
-  (0, import_node_fs8.renameSync)(tmp, path);
+  (0, import_node_fs10.renameSync)(tmp, path);
 }
 function clearPending(paths, surface) {
   const records = readPending(paths);
@@ -1641,7 +2115,7 @@ function buildWatcherCommand(opts) {
   return { file: "sh", args: ["-c", `${testBusy}; ${wait}; ${lock}; ${run}`] };
 }
 function defaultDetachSpawn(file, args) {
-  const child = (0, import_node_child_process4.spawn)(file, [...args], {
+  const child = (0, import_node_child_process5.spawn)(file, [...args], {
     detached: process.platform !== "win32",
     stdio: "ignore",
     windowsHide: true,
@@ -1658,14 +2132,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_fs8.existsSync)(hubDist)) return { scheduled: false, reason: "the installed hub bundle is unresolvable \u2014 the hourly tick remains the retry" };
+  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" };
   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_path3.join)(paths.root, "pending-result.code"),
-    logPath: (0, import_node_path3.join)(paths.root, "pending-result.log"),
+    codePath: (0, import_node_path6.join)(paths.root, "pending-result.code"),
+    logPath: (0, import_node_path6.join)(paths.root, "pending-result.log"),
     lockPath: watcherLockPath(paths)
   });
   try {
@@ -1704,11 +2178,11 @@ 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_path4.join)(root, ...packageName.split("/"), ...distRel.split("/")) : null;
+  return root ? (0, import_node_path7.join)(root, ...packageName.split("/"), ...distRel.split("/")) : null;
 }
 function probeVersion(distPath) {
   if (!fileExists(distPath)) return null;
-  const probe = (0, import_node_child_process5.spawnSync)(process.execPath, [distPath, "--version"], { encoding: "utf8", windowsHide: true });
+  const probe = (0, import_node_child_process6.spawnSync)(process.execPath, [distPath, "--version"], { encoding: "utf8", windowsHide: true });
   const version = (probe.stdout || "").trim();
   return probe.status === 0 && /^\d+\.\d+\.\d+/.test(version) ? version : null;
 }
@@ -1718,7 +2192,7 @@ function tail(output) {
 function manifestVersion(packageRoot) {
   if (!packageRoot) return null;
   try {
-    const version = JSON.parse((0, import_node_fs9.readFileSync)((0, import_node_path4.join)(packageRoot, "package.json"), "utf8")).version;
+    const version = JSON.parse((0, import_node_fs11.readFileSync)((0, import_node_path7.join)(packageRoot, "package.json"), "utf8")).version;
     return typeof version === "string" ? version : null;
   } catch {
     return null;
@@ -1726,11 +2200,11 @@ function manifestVersion(packageRoot) {
 }
 function stagePackage(options) {
   const { surface, packageName, target, witness, paths, env } = options;
-  const stageRoot = (0, import_node_path4.join)(paths.staging, surface, target);
-  const packageRoot = (0, import_node_path4.join)(stageRoot, "node_modules", ...packageName.split("/"));
-  if (!fileExists((0, import_node_path4.join)(packageRoot, ...witness.split("/")))) {
-    (0, import_node_fs9.mkdirSync)(stageRoot, { recursive: true });
-    (0, import_node_fs9.writeFileSync)((0, import_node_path4.join)(stageRoot, "package.json"), JSON.stringify({ name: "mmi-updater-stage", private: true }) + "\n");
+  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);
     if (install.status !== 0) {
       return { defer: `staging install failed: ${tail(install.stderr || install.stdout)}` };
@@ -1738,7 +2212,7 @@ function stagePackage(options) {
   }
   let stagedManifestVersion;
   try {
-    stagedManifestVersion = JSON.parse((0, import_node_fs9.readFileSync)((0, import_node_path4.join)(packageRoot, "package.json"), "utf8")).version;
+    stagedManifestVersion = JSON.parse((0, import_node_fs11.readFileSync)((0, import_node_path7.join)(packageRoot, "package.json"), "utf8")).version;
   } catch {
   }
   if (stagedManifestVersion !== target) {
@@ -1753,7 +2227,7 @@ function npmGlobalArm(options) {
   const result = (from, to, verdict, detail) => ({ surface, from, to, verdict, detail });
   const highWater = journalHighWater(paths.journalPath, surface, options.journalEvents);
   const localRoot = globalRoot(env);
-  const localVersion = localRoot ? manifestVersion((0, import_node_path4.join)(localRoot, ...packageName.split("/"))) : null;
+  const localVersion = localRoot ? manifestVersion((0, import_node_path7.join)(localRoot, ...packageName.split("/"))) : null;
   if (localVersion === target && highWater === target) {
     return result(localVersion, target, "ok", `already at target ${target} (installed manifest + journal high-water)`);
   }
@@ -1775,7 +2249,7 @@ function npmGlobalArm(options) {
   if ("defer" in staged) {
     return result(installed, target, "defer", staged.defer);
   }
-  const stageDist = (0, import_node_path4.join)(staged.packageRoot, ...distRel.split("/"));
+  const stageDist = (0, import_node_path7.join)(staged.packageRoot, ...distRel.split("/"));
   const stagedVersion = probeVersion(stageDist);
   if (stagedVersion !== target) {
     return result(installed, target, "defer", `staged binary probed ${stagedVersion ?? "dead"}, expected ${target}`);
@@ -1796,11 +2270,11 @@ function npmGlobalArm(options) {
 }
 
 // src/launch-staging.ts
-var import_node_fs10 = require("node:fs");
-var import_node_path5 = require("node:path");
+var import_node_fs12 = require("node:fs");
+var import_node_path8 = require("node:path");
 function readLaunchTarget(path) {
   try {
-    const parsed = JSON.parse((0, import_node_fs10.readFileSync)(path, "utf8"));
+    const parsed = JSON.parse((0, import_node_fs12.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;
@@ -1810,15 +2284,15 @@ function readLaunchTarget(path) {
   }
 }
 function writeLaunchTarget(path, record) {
-  (0, import_node_fs10.mkdirSync)((0, import_node_path5.join)(path, ".."), { recursive: true });
+  (0, import_node_fs12.mkdirSync)((0, import_node_path8.join)(path, ".."), { recursive: true });
   const tmp = `${path}.tmp-${process.pid}-${Math.random().toString(36).slice(2)}`;
-  (0, import_node_fs10.writeFileSync)(tmp, `${JSON.stringify(record, null, 2)}
+  (0, import_node_fs12.writeFileSync)(tmp, `${JSON.stringify(record, null, 2)}
 `, "utf8");
-  (0, import_node_fs10.renameSync)(tmp, path);
+  (0, import_node_fs12.renameSync)(tmp, path);
 }
 function clearLaunchTarget(path) {
   try {
-    (0, import_node_fs10.rmSync)(path, { force: true });
+    (0, import_node_fs12.rmSync)(path, { force: true });
   } catch {
   }
 }
@@ -1839,7 +2313,7 @@ function noteLaunchStaged(paths, env, options, seam = {}) {
 }
 function probeLaunchTargetVersion(launchTargetPath, versionAt) {
   const record = readLaunchTarget(launchTargetPath);
-  if (!record || !(0, import_node_fs10.existsSync)(record.incoming)) return null;
+  if (!record || !(0, import_node_fs12.existsSync)(record.incoming)) return null;
   const version = versionAt(record.incoming);
   return version === record.target ? record.target : null;
 }
@@ -1854,13 +2328,13 @@ function cmdArg(value) {
   return /^[A-Za-z0-9_@./:\\=+-]+$/.test(value) ? value : `"${value.replaceAll('"', '""')}"`;
 }
 var runHostCommand = (command, args, env) => {
-  const result = process.platform === "win32" ? (0, import_node_child_process6.spawnSync)("cmd.exe", ["/d", "/s", "/c", [command, ...args].map(cmdArg).join(" ")], {
+  const result = process.platform === "win32" ? (0, import_node_child_process7.spawnSync)("cmd.exe", ["/d", "/s", "/c", [command, ...args].map(cmdArg).join(" ")], {
     encoding: "utf8",
     env,
     input: "",
     timeout: 12e4,
     windowsHide: true
-  }) : (0, import_node_child_process6.spawnSync)(command, args, {
+  }) : (0, import_node_child_process7.spawnSync)(command, args, {
     encoding: "utf8",
     env,
     input: "",
@@ -1887,17 +2361,17 @@ function claudeMmi(runner, env) {
   return { row: parsed.find((row) => row.id === "mmi@mutmutco") ?? null };
 }
 function claudeHomeDir(env) {
-  const home = env.HOME?.trim() || env.USERPROFILE?.trim() || (0, import_node_os2.homedir)();
-  return (0, import_node_path6.join)(home, ".claude");
+  const home = env.HOME?.trim() || env.USERPROFILE?.trim() || (0, import_node_os4.homedir)();
+  return (0, import_node_path9.join)(home, ".claude");
 }
 function claudeMarketplacesPath(env) {
-  return env.MMI_UPDATER_CLAUDE_MARKETPLACES || (0, import_node_path6.join)(claudeHomeDir(env), "plugins", "known_marketplaces.json");
+  return env.MMI_UPDATER_CLAUDE_MARKETPLACES || (0, import_node_path9.join)(claudeHomeDir(env), "plugins", "known_marketplaces.json");
 }
 function ensureClaudeMarketplace(env) {
   const path = claudeMarketplacesPath(env);
   let body;
   try {
-    body = JSON.parse((0, import_node_fs11.readFileSync)(path, "utf8"));
+    body = JSON.parse((0, import_node_fs13.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}` };
@@ -1921,18 +2395,18 @@ 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_path6.join)(claudeHomeDir(env), "plugins");
+  return (0, import_node_path9.join)(claudeHomeDir(env), "plugins");
 }
 function claudeMarkerVersion(root) {
   try {
-    const version = JSON.parse((0, import_node_fs11.readFileSync)((0, import_node_path6.join)(root, ...CLAUDE_MANIFEST.split("/")), "utf8")).version;
+    const version = JSON.parse((0, import_node_fs13.readFileSync)((0, import_node_path9.join)(root, ...CLAUDE_MANIFEST.split("/")), "utf8")).version;
     return typeof version === "string" ? version : null;
   } catch {
     return null;
   }
 }
 function claudeTreeHealthy(root) {
-  return CLAUDE_TREE_MARKERS.every((rel) => fileExists((0, import_node_path6.join)(root, ...rel.split("/"))));
+  return CLAUDE_TREE_MARKERS.every((rel) => fileExists((0, import_node_path9.join)(root, ...rel.split("/"))));
 }
 var CLAUDE_PROCESS_SEGMENT = /^claude(-code|-cli)?(\.(exe|cmd|bat|ps1|js|mjs|cjs|py))?$/i;
 var HUB_UPDATE_COMMAND = /(?:\bmmi-hub(?:\.(?:cmd|exe|bat|ps1))?\b|@mutmutco[/\\]hub[/\\]dist[/\\]index\.(?:cjs|mjs|js))[\s'"]+update\b/i;
@@ -1946,7 +2420,7 @@ function claudeProcessToken(line) {
   return null;
 }
 function realClaudeProcessListing() {
-  const result = process.platform === "win32" ? (0, import_node_child_process6.spawnSync)("powershell.exe", ["-NoProfile", "-Command", "Get-CimInstance Win32_Process | ForEach-Object { $_.Name + ' ' + $_.CommandLine }"], { encoding: "utf8", windowsHide: true, timeout: 15e3 }) : (0, import_node_child_process6.spawnSync)("ps", ["-eo", "args="], { encoding: "utf8", windowsHide: true, timeout: 15e3 });
+  const result = process.platform === "win32" ? (0, import_node_child_process7.spawnSync)("powershell.exe", ["-NoProfile", "-Command", "Get-CimInstance Win32_Process | ForEach-Object { $_.Name + ' ' + $_.CommandLine }"], { encoding: "utf8", windowsHide: true, timeout: 15e3 }) : (0, import_node_child_process7.spawnSync)("ps", ["-eo", "args="], { encoding: "utf8", windowsHide: true, timeout: 15e3 });
   return result.status === 0 ? result.stdout ?? "" : null;
 }
 function claudeHostEvidence(env, processListProvider) {
@@ -1962,7 +2436,7 @@ function claudeHostEvidence(env, processListProvider) {
   return null;
 }
 function probeClaudeLaunchStaging(env = process.env) {
-  return probeLaunchTargetVersion((0, import_node_path6.join)(claudePluginsRoot(env), "staging", "launch-target.json"), claudeMarkerVersion);
+  return probeLaunchTargetVersion((0, import_node_path9.join)(claudePluginsRoot(env), "staging", "launch-target.json"), claudeMarkerVersion);
 }
 function claudeArm(options) {
   const env = options.env ?? process.env;
@@ -1997,7 +2471,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_path6.join)(pluginsRoot, "staging", "launch-target.json");
+  const launchTargetPath = (0, import_node_path9.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}`);
   }
@@ -2011,8 +2485,8 @@ function claudeArm(options) {
     clearLaunchTarget(launchTargetPath);
     return result(from, target, "ok", `catalog refreshed; installed+enabled at target ${target}`);
   }
-  const incomingRoot = (0, import_node_path6.join)(pluginsRoot, "staging", "incoming");
-  const incoming = (0, import_node_path6.join)(incomingRoot, target);
+  const incomingRoot = (0, import_node_path9.join)(pluginsRoot, "staging", "incoming");
+  const incoming = (0, import_node_path9.join)(incomingRoot, target);
   const priorLaunch = readLaunchTarget(launchTargetPath);
   const reuseIncoming = priorLaunch?.target === target && priorLaunch.incoming === incoming && claudeMarkerVersion(incoming) === target && claudeTreeHealthy(incoming);
   if (!reuseIncoming) {
@@ -2022,14 +2496,14 @@ function claudeArm(options) {
       return result(from, target, "defer", `staged Claude manifest is ${claudeMarkerVersion(staged.packageRoot) ?? "unreadable"} or its tree is incomplete (expected ${target})`);
     }
     try {
-      (0, import_node_fs11.mkdirSync)((0, import_node_path6.join)(pluginsRoot, "staging"), { recursive: true });
-      (0, import_node_fs11.rmSync)(incomingRoot, { recursive: true, force: true });
-      (0, import_node_fs11.cpSync)(staged.packageRoot, incoming, { recursive: true });
+      (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 });
     } catch (error) {
       return result(from, target, "defer", `cannot place incoming Claude generation: ${error?.message ?? error}`);
     }
     if (claudeMarkerVersion(incoming) !== target || !claudeTreeHealthy(incoming)) {
-      (0, import_node_fs11.rmSync)(incomingRoot, { recursive: true, force: true });
+      (0, import_node_fs13.rmSync)(incomingRoot, { recursive: true, force: true });
       return result(from, target, "defer", "incoming Claude generation did not reproduce the verified payload");
     }
   }
@@ -2059,12 +2533,12 @@ function claudeArm(options) {
     });
     return result(from, target, "ok", `staged ${target} for next launch \u2014 Claude Code started during staging (${started}) \u2014 ${pending}`, true);
   }
-  const cacheTarget = (0, import_node_path6.join)(pluginsRoot, "cache", "mutmutco", "mmi", target);
+  const cacheTarget = (0, import_node_path9.join)(pluginsRoot, "cache", "mutmutco", "mmi", target);
   try {
-    if (!(0, import_node_fs11.existsSync)(cacheTarget) || claudeMarkerVersion(cacheTarget) !== target || !claudeTreeHealthy(cacheTarget)) {
-      (0, import_node_fs11.rmSync)(cacheTarget, { recursive: true, force: true });
-      (0, import_node_fs11.mkdirSync)((0, import_node_path6.join)(cacheTarget, ".."), { recursive: true });
-      (0, import_node_fs11.cpSync)(incoming, cacheTarget, { recursive: true });
+    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 });
     }
   } catch (error) {
     return result(from, target, "defer", `cannot populate Claude plugin cache: ${error?.message ?? error}`);
@@ -2092,7 +2566,7 @@ function claudeArm(options) {
   }
   clearLaunchTarget(launchTargetPath);
   try {
-    (0, import_node_fs11.rmSync)(incomingRoot, { recursive: true, force: true });
+    (0, import_node_fs13.rmSync)(incomingRoot, { recursive: true, force: true });
   } catch {
   }
   return result(from, target, "ok", `catalog refreshed; converged and verified ${from ?? "absent"} -> ${target}`);
@@ -2171,12 +2645,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_path7.join)((0, import_node_os3.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_path10.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_path7.join)(env.LOCALAPPDATA?.trim() || (0, import_node_path7.join)((0, import_node_os3.homedir)(), "AppData", "Local"), "hermes");
-  return (0, import_node_path7.join)((0, import_node_os3.homedir)(), ".hermes");
+  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");
 }
 function hermesHostCommand(env = process.env) {
   return env.MMI_UPDATER_HERMES?.trim() || "hermes";
@@ -2189,37 +2663,37 @@ function surfaceArmPlan(token, managedSurfaces) {
   return managedSurfaces.includes(token) ? "arm" : "retired";
 }
 function enumerateSurfaces(env = process.env) {
-  const home = env.HOME?.trim() || env.USERPROFILE?.trim() || (0, import_node_os3.homedir)();
-  const codexHome = env.CODEX_HOME || (0, import_node_path7.join)(home, ".codex");
+  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");
   return [
-    { id: "claude", marker: (0, import_node_path7.join)(home, ".claude", "plugins", "installed_plugins.json") },
-    { id: "codex", marker: (0, import_node_path7.join)(codexHome, "plugins", "installed_plugins.json") },
+    { 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") },
     // The host, not the payload (#4951, #5356): this marker used to be plugins/local/mmi — the MMI
     // plugin tree itself — so a machine running Cursor WITHOUT the plugin enumerated as "no Cursor"
     // and the arm could never make the first install. The plugin's absence is a converge action, not
     // a skip. The host root mirrors surfaceConfigRoot('cursor') in cli/src/plugin-guard-io.ts.
-    { id: "cursor", marker: (0, import_node_path7.join)(home, ".cursor") },
-    { id: "jervcode", marker: (0, import_node_path7.join)(jervcodeAgentDir(env), "settings.json") },
+    { id: "cursor", marker: (0, import_node_path10.join)(home, ".cursor") },
+    { id: "jervcode", marker: (0, import_node_path10.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_fs12.existsSync)(probe.marker)
+    present: probe.id === "hermes" ? hermesHostPresent(env) : (0, import_node_fs14.existsSync)(probe.marker)
   }));
 }
 
 // src/arm-cursor.ts
-var import_node_fs15 = require("node:fs");
-var import_node_child_process7 = require("node:child_process");
-var import_node_os5 = require("node:os");
-var import_node_path8 = require("node:path");
+var import_node_fs17 = require("node:fs");
+var import_node_child_process8 = require("node:child_process");
+var import_node_os7 = require("node:os");
+var import_node_path11 = require("node:path");
 
 // src/compat.ts
-var import_node_fs13 = require("node:fs");
+var import_node_fs15 = require("node:fs");
 function readManifestCompat(manifestPath) {
   try {
-    const parsed = JSON.parse((0, import_node_fs13.readFileSync)(manifestPath, "utf8"));
+    const parsed = JSON.parse((0, import_node_fs15.readFileSync)(manifestPath, "utf8"));
     return typeof parsed.mmiCompat === "string" ? parsed.mmiCompat : void 0;
   } catch {
     return void 0;
@@ -2227,8 +2701,8 @@ function readManifestCompat(manifestPath) {
 }
 
 // src/host-doc-lock.ts
-var import_node_fs14 = require("node:fs");
-var import_node_os4 = require("node:os");
+var import_node_fs16 = require("node:fs");
+var import_node_os6 = require("node:os");
 var SHARED_DOC_LOCK_STALE_MS = 3e4;
 var SHARED_DOC_LOCK_ATTEMPTS = 50;
 var SHARED_DOC_LOCK_INTERVAL_MS = 100;
@@ -2241,7 +2715,7 @@ function lockContent(options) {
 }
 function readHolder(lockPath) {
   try {
-    const parsed = JSON.parse((0, import_node_fs14.readFileSync)(lockPath, "utf8"));
+    const parsed = JSON.parse((0, import_node_fs16.readFileSync)(lockPath, "utf8"));
     if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return null;
     return parsed;
   } catch {
@@ -2253,7 +2727,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_fs14.statSync)(lockPath).mtimeMs);
+    return Math.max(0, now - (0, import_node_fs16.statSync)(lockPath).mtimeMs);
   } catch {
     return 0;
   }
@@ -2268,7 +2742,7 @@ function acquireSharedDocLock(documentPath, options) {
   const staleAfterMs = options.staleAfterMs ?? SHARED_DOC_LOCK_STALE_MS;
   const attempts = options.attempts ?? SHARED_DOC_LOCK_ATTEMPTS;
   const intervalMs = options.intervalMs ?? SHARED_DOC_LOCK_INTERVAL_MS;
-  const identity = { owner: options.owner, pid: process.pid, host: options.host ?? (0, import_node_os4.hostname)(), acquiredAt: (/* @__PURE__ */ new Date()).toISOString() };
+  const identity = { owner: options.owner, pid: process.pid, host: options.host ?? (0, import_node_os6.hostname)(), acquiredAt: (/* @__PURE__ */ new Date()).toISOString() };
   const content = lockContent(identity);
   const sleep = (ms) => {
     Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
@@ -2276,9 +2750,9 @@ function acquireSharedDocLock(documentPath, options) {
   for (let attempt = 0; attempt < attempts; attempt += 1) {
     let fd;
     try {
-      fd = (0, import_node_fs14.openSync)(lockPath, "wx");
-      (0, import_node_fs14.writeSync)(fd, content);
-      (0, import_node_fs14.closeSync)(fd);
+      fd = (0, import_node_fs16.openSync)(lockPath, "wx");
+      (0, import_node_fs16.writeSync)(fd, content);
+      (0, import_node_fs16.closeSync)(fd);
       return {
         documentPath,
         lockPath,
@@ -2291,11 +2765,11 @@ function acquireSharedDocLock(documentPath, options) {
     } catch (error) {
       if (fd !== void 0) {
         try {
-          (0, import_node_fs14.closeSync)(fd);
+          (0, import_node_fs16.closeSync)(fd);
         } catch {
         }
         try {
-          (0, import_node_fs14.unlinkSync)(lockPath);
+          (0, import_node_fs16.unlinkSync)(lockPath);
         } catch {
         }
       }
@@ -2304,12 +2778,12 @@ function acquireSharedDocLock(documentPath, options) {
     if (lockAgeMs(lockPath, Date.now()) >= staleAfterMs) {
       const aside = `${lockPath}.stale-${Date.now()}`;
       try {
-        (0, import_node_fs14.renameSync)(lockPath, aside);
+        (0, import_node_fs16.renameSync)(lockPath, aside);
       } catch {
         continue;
       }
       try {
-        (0, import_node_fs14.rmSync)(aside, { force: true });
+        (0, import_node_fs16.rmSync)(aside, { force: true });
       } catch {
       }
       continue;
@@ -2322,7 +2796,7 @@ function releaseSharedDocLock(handle) {
   try {
     const holder = readHolder(handle.lockPath);
     if (holder && holder.owner === handle.owner && Number(holder.pid) === handle.pid) {
-      (0, import_node_fs14.unlinkSync)(handle.lockPath);
+      (0, import_node_fs16.unlinkSync)(handle.lockPath);
     }
   } catch {
   }
@@ -2344,14 +2818,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_path8.join)((0, import_node_os5.homedir)(), ".cursor", "plugins");
+  return (0, import_node_path11.join)((0, import_node_os7.homedir)(), ".cursor", "plugins");
 }
 function treeHealthy(root) {
-  return TREE_FILES.every((rel) => (0, import_node_fs15.existsSync)((0, import_node_path8.join)(root, ...rel.split("/"))));
+  return TREE_FILES.every((rel) => (0, import_node_fs17.existsSync)((0, import_node_path11.join)(root, ...rel.split("/"))));
 }
 function readJson(root, rel) {
   try {
-    return JSON.parse((0, import_node_fs15.readFileSync)((0, import_node_path8.join)(root, ...rel.split("/")), "utf8"));
+    return JSON.parse((0, import_node_fs17.readFileSync)((0, import_node_path11.join)(root, ...rel.split("/")), "utf8"));
   } catch {
     return null;
   }
@@ -2360,7 +2834,7 @@ function manifest(root) {
   return readJson(root, MANIFEST);
 }
 function probeCursorInstallation() {
-  const location = (0, import_node_path8.join)(cursorPluginsRoot(), "local", "mmi");
+  const location = (0, import_node_path11.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" };
 }
@@ -2375,7 +2849,7 @@ function message(error) {
 }
 function discard(path) {
   try {
-    (0, import_node_fs15.rmSync)(path, { recursive: true, force: true });
+    (0, import_node_fs17.rmSync)(path, { recursive: true, force: true });
   } catch {
   }
 }
@@ -2394,7 +2868,7 @@ function cursorHostEvidence(env) {
     if (env[marker]?.trim()) return `env marker ${marker}`;
   }
   if (env.CURSOR_AGENT === "1") return "env marker CURSOR_AGENT=1";
-  const result = process.platform === "win32" ? (0, import_node_child_process7.spawnSync)("powershell.exe", ["-NoProfile", "-Command", "Get-CimInstance Win32_Process | ForEach-Object { $_.CommandLine }"], { encoding: "utf8", windowsHide: true, timeout: 15e3 }) : (0, import_node_child_process7.spawnSync)("ps", ["-eo", "args="], { encoding: "utf8", windowsHide: true, timeout: 15e3 });
+  const result = process.platform === "win32" ? (0, import_node_child_process8.spawnSync)("powershell.exe", ["-NoProfile", "-Command", "Get-CimInstance Win32_Process | ForEach-Object { $_.CommandLine }"], { encoding: "utf8", windowsHide: true, timeout: 15e3 }) : (0, import_node_child_process8.spawnSync)("ps", ["-eo", "args="], { encoding: "utf8", windowsHide: true, timeout: 15e3 });
   if (result.status !== 0 || !(result.stdout ?? "").trim()) return "the process table is unreadable (unsafe to write)";
   for (const line of result.stdout.split(/\r?\n/)) {
     const executable = cursorExecutable(line);
@@ -2403,7 +2877,7 @@ function cursorHostEvidence(env) {
   return null;
 }
 function resolvedPluginRoot(root) {
-  return (0, import_node_path8.join)(root).replace(/\\/g, "/");
+  return (0, import_node_path11.join)(root).replace(/\\/g, "/");
 }
 function isMmiEntry(entry, pluginRoot) {
   if (typeof entry !== "object" || entry === null || typeof entry.command !== "string") return false;
@@ -2427,12 +2901,12 @@ function stripUserHooks(existing, pluginRoot) {
 }
 var CURSOR_HOOKS_LOCK_OWNER = "mmi-hub:cursor-hooks";
 function reconcileCursorUserHooks(pluginRoot, homeDir, lock = {}) {
-  const path = (0, import_node_path8.join)(homeDir, ".cursor", USER_HOOKS_FILE);
+  const path = (0, import_node_path11.join)(homeDir, ".cursor", USER_HOOKS_FILE);
   return withSharedDocLock(path, { owner: CURSOR_HOOKS_LOCK_OWNER, ...lock }, () => {
-    if (!(0, import_node_fs15.existsSync)(path)) return "current";
+    if (!(0, import_node_fs17.existsSync)(path)) return "current";
     let existing;
     try {
-      existing = JSON.parse((0, import_node_fs15.readFileSync)(path, "utf8"));
+      existing = JSON.parse((0, import_node_fs17.readFileSync)(path, "utf8"));
     } catch {
       return "user-conflict";
     }
@@ -2440,8 +2914,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_fs15.writeFileSync)(tmp, JSON.stringify(stripped, null, 2) + "\n", "utf8");
-    (0, import_node_fs15.renameSync)(tmp, path);
+    (0, import_node_fs17.writeFileSync)(tmp, JSON.stringify(stripped, null, 2) + "\n", "utf8");
+    (0, import_node_fs17.renameSync)(tmp, path);
     return "updated";
   });
 }
@@ -2456,41 +2930,41 @@ function userHooksDetail(pluginRoot, homeDir) {
     case "updated":
       return "; user hooks legacy entries stripped";
     case "user-conflict":
-      return `; USER HOOKS CONFLICT at ${(0, import_node_path8.join)(homeDir, ".cursor", USER_HOOKS_FILE)} \u2014 legacy entries were not changed`;
+      return `; USER HOOKS CONFLICT at ${(0, import_node_path11.join)(homeDir, ".cursor", USER_HOOKS_FILE)} \u2014 legacy entries were not changed`;
     default:
       return "";
   }
 }
 function writeRollbackPointer(root, entry) {
-  const path = (0, import_node_path8.join)(root, "quarantine", "rollback.json");
+  const path = (0, import_node_path11.join)(root, "quarantine", "rollback.json");
   const tmp = `${path}.tmp-${process.pid}`;
   try {
-    (0, import_node_fs15.writeFileSync)(tmp, JSON.stringify({ surface: "cursor", ts: (/* @__PURE__ */ new Date()).toISOString(), ...entry }, null, 2) + "\n", "utf8");
-    (0, import_node_fs15.renameSync)(tmp, path);
+    (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);
   } catch {
     discard(tmp);
   }
 }
 function mtimeMs(path) {
   try {
-    return (0, import_node_fs15.statSync)(path).mtimeMs;
+    return (0, import_node_fs17.statSync)(path).mtimeMs;
   } catch {
     return 0;
   }
 }
 function pruneQuarantine(root, keep) {
-  const dir = (0, import_node_path8.join)(root, "quarantine");
+  const dir = (0, import_node_path11.join)(root, "quarantine");
   let generations;
   try {
-    generations = (0, import_node_fs15.readdirSync)(dir, { withFileTypes: true }).filter((entry) => entry.isDirectory() && entry.name.startsWith("mmi-")).map((entry) => (0, import_node_path8.join)(dir, entry.name)).sort((a, b) => mtimeMs(b) - mtimeMs(a));
+    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));
   } catch {
     return 0;
   }
   let stranded = 0;
   try {
-    for (const entry of (0, import_node_fs15.readdirSync)(dir, { withFileTypes: true })) {
+    for (const entry of (0, import_node_fs17.readdirSync)(dir, { withFileTypes: true })) {
       if (!entry.isFile() || !/^rollback\.json\.tmp-\d+$/.test(entry.name)) continue;
-      const path = (0, import_node_path8.join)(dir, entry.name);
+      const path = (0, import_node_path11.join)(dir, entry.name);
       if (Date.now() - mtimeMs(path) < STRANDED_TMP_AGE_MS) continue;
       discard(path);
       stranded += 1;
@@ -2508,16 +2982,16 @@ function pruneQuarantine(root, keep) {
 }
 function restorePrevious(live, quarantined, broken) {
   try {
-    (0, import_node_fs15.renameSync)(live, broken);
+    (0, import_node_fs17.renameSync)(live, broken);
   } catch {
     return "kept-broken";
   }
   try {
-    (0, import_node_fs15.renameSync)(quarantined, live);
+    (0, import_node_fs17.renameSync)(quarantined, live);
     return "restored";
   } catch {
     try {
-      (0, import_node_fs15.renameSync)(broken, live);
+      (0, import_node_fs17.renameSync)(broken, live);
       return "kept-broken";
     } catch {
       return "lost";
@@ -2528,7 +3002,7 @@ function cursorArm(options) {
   const env = options.env ?? process.env;
   const { target, dryRun, paths } = options;
   const root = cursorPluginsRoot();
-  const live = (0, import_node_path8.join)(root, "local", "mmi");
+  const live = (0, import_node_path11.join)(root, "local", "mmi");
   const result = (from, to, verdict, detail, launchStaged = false) => ({
     surface: "cursor",
     from,
@@ -2538,7 +3012,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_path8.join)(live, MANIFEST))
+    compat: readManifestCompat((0, import_node_path11.join)(live, MANIFEST))
   });
   const current = manifest(live);
   const installed = current?.version ?? null;
@@ -2550,9 +3024,9 @@ function cursorArm(options) {
     return result(installed, highWater, "skip", `journal high-water ${highWater} is above candidate ${target} (monotonic)`);
   }
   if (installed === target && treeHealthy(live)) {
-    return result(installed, target, "ok", `already at target ${target}${userHooksDetail(live, (0, import_node_os5.homedir)())}`);
+    return result(installed, target, "ok", `already at target ${target}${userHooksDetail(live, (0, import_node_os7.homedir)())}`);
   }
-  if ((0, import_node_fs15.existsSync)(live) && !mmiOwned(live)) {
+  if ((0, import_node_fs17.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) {
@@ -2566,16 +3040,16 @@ function cursorArm(options) {
   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_path8.join)(root, "staging", "launch-target.json");
+  const launchTargetPath = (0, import_node_path11.join)(root, "staging", "launch-target.json");
   const priorLaunch = readLaunchTarget(launchTargetPath);
-  let incoming = priorLaunch?.target === target && priorLaunch.incoming.startsWith((0, import_node_path8.join)(root, "staging")) && manifest(priorLaunch.incoming)?.version === target && treeHealthy(priorLaunch.incoming) ? priorLaunch.incoming : (0, import_node_path8.join)(root, "staging", `mmi-${safeSegment(target)}-${Date.now()}`);
+  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()}`);
   const reuseIncoming = incoming === priorLaunch?.incoming;
-  if (!reuseIncoming || !(0, import_node_fs15.existsSync)(incoming)) {
-    incoming = (0, import_node_path8.join)(root, "staging", `mmi-${safeSegment(target)}-${Date.now()}`);
-    for (const dir of ["local", "staging", "quarantine"]) (0, import_node_fs15.mkdirSync)((0, import_node_path8.join)(root, dir), { recursive: true });
+  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 });
     try {
       discard(incoming);
-      (0, import_node_fs15.cpSync)(staged.packageRoot, incoming, { recursive: true });
+      (0, import_node_fs17.cpSync)(staged.packageRoot, incoming, { recursive: true });
     } catch (error) {
       discard(incoming);
       return result(installed, target, "defer", `copy into ${root} failed: ${message(error)}`);
@@ -2598,8 +3072,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_path8.join)(root, "quarantine", `mmi-${safeSegment(installed ?? "unknown")}-${stamp}`);
-  for (const dir of ["local", "staging", "quarantine"]) (0, import_node_fs15.mkdirSync)((0, import_node_path8.join)(root, dir), { recursive: true });
+  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 started = cursorHostEvidence(env);
   if (started) {
     const pending = noteLaunchStaged(paths, env, {
@@ -2614,15 +3088,15 @@ function cursorArm(options) {
   }
   let displaced = false;
   try {
-    if ((0, import_node_fs15.existsSync)(live)) {
-      (0, import_node_fs15.renameSync)(live, quarantined);
+    if ((0, import_node_fs17.existsSync)(live)) {
+      (0, import_node_fs17.renameSync)(live, quarantined);
       displaced = true;
     }
-    (0, import_node_fs15.renameSync)(incoming, live);
+    (0, import_node_fs17.renameSync)(incoming, live);
   } catch (error) {
-    if (displaced && !(0, import_node_fs15.existsSync)(live)) {
+    if (displaced && !(0, import_node_fs17.existsSync)(live)) {
       try {
-        (0, import_node_fs15.renameSync)(quarantined, live);
+        (0, import_node_fs17.renameSync)(quarantined, live);
       } catch {
       }
     }
@@ -2633,7 +3107,7 @@ function cursorArm(options) {
   }
   const evidence = manifest(live)?.version;
   if (evidence !== target || !treeHealthy(live)) {
-    const broken = `${(0, import_node_path8.join)(root, "quarantine", `mmi-${safeSegment(evidence ?? "broken")}-${stamp}`)}-failed`;
+    const broken = `${(0, import_node_path11.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 });
@@ -2643,15 +3117,15 @@ function cursorArm(options) {
   clearLaunchTarget(launchTargetPath);
   const pruned = pruneQuarantine(root, displaced ? quarantined : null);
   const previous = displaced ? `previous generation quarantined at ${quarantined}` : "no previous generation to quarantine";
-  return result(installed, target, "ok", `switched ${installed ?? "absent"} -> ${target}; ${previous}${pruned ? `; pruned ${pruned} older generation${pruned === 1 ? "" : "s"}` : ""}${userHooksDetail(live, (0, import_node_os5.homedir)())}`);
+  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_path8.join)(cursorPluginsRoot(), "staging", "launch-target.json"), (root) => manifest(root)?.version ?? null);
+  return probeLaunchTargetVersion((0, import_node_path11.join)(cursorPluginsRoot(), "staging", "launch-target.json"), (root) => manifest(root)?.version ?? null);
 }
 
 // src/arm-jervcode.ts
-var import_node_fs16 = require("node:fs");
-var import_node_path9 = require("node:path");
+var import_node_fs18 = require("node:fs");
+var import_node_path12 = require("node:path");
 var PI_PACKAGE = "@mutmutco/pi-plugin";
 function hostEnv(env) {
   const dir = jervcodeAgentDir(env);
@@ -2662,7 +3136,7 @@ function hostCommands(_env) {
 }
 function readPackageSpecs(env) {
   try {
-    const settings = JSON.parse((0, import_node_fs16.readFileSync)((0, import_node_path9.join)(jervcodeAgentDir(env), "settings.json"), "utf8"));
+    const settings = JSON.parse((0, import_node_fs18.readFileSync)((0, import_node_path12.join)(jervcodeAgentDir(env), "settings.json"), "utf8"));
     return Array.isArray(settings.packages) ? settings.packages.filter((entry) => typeof entry === "string") : [];
   } catch {
     return null;
@@ -2670,14 +3144,14 @@ function readPackageSpecs(env) {
 }
 function installedVersion(env) {
   try {
-    const manifest2 = JSON.parse((0, import_node_fs16.readFileSync)((0, import_node_path9.join)(jervcodeAgentDir(env), "npm", "node_modules", ...PI_PACKAGE.split("/"), "package.json"), "utf8"));
+    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"));
     return typeof manifest2.version === "string" ? manifest2.version : null;
   } catch {
     return null;
   }
 }
 function materializedManifestLocation(env) {
-  return (0, import_node_path9.join)(jervcodeAgentDir(env), "npm", "node_modules", ...PI_PACKAGE.split("/"));
+  return (0, import_node_path12.join)(jervcodeAgentDir(env), "npm", "node_modules", ...PI_PACKAGE.split("/"));
 }
 var PI_LIST_SPEC = new RegExp(`npm:${PI_PACKAGE.replace("/", "\\/")}@(\\S+)`);
 function parseListText(stdout) {
@@ -2736,32 +3210,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_path9.join)(jervcodeAgentDir(env), "npm", "node_modules", ...PI_PACKAGE.split("/"), "package.json"))
+    compat: readManifestCompat((0, import_node_path12.join)(jervcodeAgentDir(env), "npm", "node_modules", ...PI_PACKAGE.split("/"), "package.json"))
   });
   const before = readPackageSpecs(env);
-  if (!before) return result(null, options.target, "defer", `cannot read ${(0, import_node_path9.join)(jervcodeAgentDir(env), "settings.json")}`);
+  if (!before) return result(null, options.target, "defer", `cannot read ${(0, import_node_path12.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_path9.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_path12.join)(jervcodeAgentDir(env), "npm", "node_modules", ...PI_PACKAGE.split("/"), "package.json")) };
   }
   const hosted = hostEnv(env);
   const commands = hostCommands(env);
   const command = commands.find((bin) => runner(bin, ["--version"], hosted).status === 0);
-  if (!command) return { surface: "jervcode", from, to: options.target, verdict: "defer", detail: "neither `jervcode` nor `pi` answered --version \u2014 the host CLI is not on PATH", compat: readManifestCompat((0, import_node_path9.join)(jervcodeAgentDir(env), "npm", "node_modules", ...PI_PACKAGE.split("/"), "package.json")) };
+  if (!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 (!floor && (!before.includes(exact) || from !== options.target)) {
     const install = runner(command, ["install", exact], hosted);
     if (install.status !== 0) {
-      return { surface: "jervcode", from, to: options.target, verdict: "defer", detail: `${command} install ${exact} failed: ${failure2(install)}`, compat: readManifestCompat((0, import_node_path9.join)(jervcodeAgentDir(env), "npm", "node_modules", ...PI_PACKAGE.split("/"), "package.json")) };
+      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")) };
     }
   }
   for (const stale of legacy) {
     const removed = runner(command, ["remove", stale], hosted);
     if (removed.status !== 0) {
-      return { surface: "jervcode", from, to: options.target, verdict: "defer", detail: `${command} remove of the legacy registration failed: ${failure2(removed)}`, compat: readManifestCompat((0, import_node_path9.join)(jervcodeAgentDir(env), "npm", "node_modules", ...PI_PACKAGE.split("/"), "package.json")) };
+      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")) };
     }
   }
   const after = readPackageSpecs(env);
@@ -2769,7 +3243,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_path9.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_path12.join)(jervcodeAgentDir(env), "npm", "node_modules", ...PI_PACKAGE.split("/"), "package.json")) };
   }
   if (!after?.includes(exact) || converged !== options.target || legacyAfter.length) {
     return {
@@ -2790,15 +3264,15 @@ function jervcodeArm(options) {
 }
 
 // src/arm-hermes.ts
-var import_node_fs17 = require("node:fs");
-var import_node_child_process8 = require("node:child_process");
-var import_node_path10 = require("node:path");
+var import_node_fs19 = require("node:fs");
+var import_node_child_process9 = require("node:child_process");
+var import_node_path13 = 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_fs17.readFileSync)((0, import_node_path10.join)(root, MANIFEST2), "utf8");
+    const text = (0, import_node_fs19.readFileSync)((0, import_node_path13.join)(root, MANIFEST2), "utf8");
     try {
       const version = JSON.parse(text).version;
       if (typeof version === "string" && version.trim()) return version.trim();
@@ -2812,7 +3286,7 @@ function yamlVersion(root) {
 }
 function packageTreeMarkers(root) {
   try {
-    const files = JSON.parse((0, import_node_fs17.readFileSync)((0, import_node_path10.join)(root, "package.json"), "utf8")).files;
+    const files = JSON.parse((0, import_node_fs19.readFileSync)((0, import_node_path13.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());
     }
@@ -2821,10 +3295,10 @@ function packageTreeMarkers(root) {
   return TREE_MARKERS_FALLBACK;
 }
 function markerPresent(root, rel) {
-  const path = (0, import_node_path10.join)(root, ...rel.split("/"));
-  if (!(0, import_node_fs17.existsSync)(path)) return false;
+  const path = (0, import_node_path13.join)(root, ...rel.split("/"));
+  if (!(0, import_node_fs19.existsSync)(path)) return false;
   try {
-    const stat = (0, import_node_fs17.statSync)(path);
+    const stat = (0, import_node_fs19.statSync)(path);
     return stat.isFile() || stat.isDirectory();
   } catch {
     return false;
@@ -2843,13 +3317,13 @@ function treeIncompleteDetail(root, label) {
 }
 function packageIdentity(root) {
   try {
-    return JSON.parse((0, import_node_fs17.readFileSync)((0, import_node_path10.join)(root, "package.json"), "utf8")).name === PACKAGE2;
+    return JSON.parse((0, import_node_fs19.readFileSync)((0, import_node_path13.join)(root, "package.json"), "utf8")).name === PACKAGE2;
   } catch {
     return false;
   }
 }
 function probeHermesInstallation(env = process.env) {
-  const location = (0, import_node_path10.join)(hermesHome(env), "plugins", "mmi");
+  const location = (0, import_node_path13.join)(hermesHome(env), "plugins", "mmi");
   const version = yamlVersion(location);
   return { version, location, detail: version ? "installed Hermes plugin manifest" : "installed Hermes plugin manifest was unreadable" };
 }
@@ -2858,7 +3332,7 @@ function mmiOwned2(root) {
 }
 function discard2(path) {
   try {
-    (0, import_node_fs17.rmSync)(path, { recursive: true, force: true });
+    (0, import_node_fs19.rmSync)(path, { recursive: true, force: true });
   } catch {
   }
 }
@@ -2877,7 +3351,7 @@ function hermesProcessToken(line, home) {
   return hermesToken(tokens) ?? (home && normalized.toLowerCase().includes(home.toLowerCase()) ? home : null);
 }
 function realProcessListing() {
-  const result = process.platform === "win32" ? (0, import_node_child_process8.spawnSync)("powershell.exe", ["-NoProfile", "-Command", "Get-CimInstance Win32_Process | ForEach-Object { $_.Name + ' ' + $_.CommandLine }"], { encoding: "utf8", windowsHide: true, timeout: 15e3 }) : (0, import_node_child_process8.spawnSync)("ps", ["-eo", "args="], { encoding: "utf8", windowsHide: true, timeout: 15e3 });
+  const result = process.platform === "win32" ? (0, import_node_child_process9.spawnSync)("powershell.exe", ["-NoProfile", "-Command", "Get-CimInstance Win32_Process | ForEach-Object { $_.Name + ' ' + $_.CommandLine }"], { encoding: "utf8", windowsHide: true, timeout: 15e3 }) : (0, import_node_child_process9.spawnSync)("ps", ["-eo", "args="], { encoding: "utf8", windowsHide: true, timeout: 15e3 });
   return result.status === 0 ? result.stdout ?? "" : null;
 }
 function hermesHostEvidence(env, home, processListProvider) {
@@ -2890,19 +3364,19 @@ function hermesHostEvidence(env, home, processListProvider) {
   return null;
 }
 function materializeHermesSkills(home) {
-  const pluginSkills = (0, import_node_path10.join)(home, "plugins", "mmi", "skills");
-  const skillsRoot = (0, import_node_path10.join)(home, "skills");
-  const targetRoot = (0, import_node_path10.join)(skillsRoot, "mmi");
+  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");
   try {
-    if (!(0, import_node_fs17.existsSync)(pluginSkills)) return { ok: false, detail: `plugin skills tree missing at ${pluginSkills}` };
-    const names = (0, import_node_fs17.readdirSync)(pluginSkills, { withFileTypes: true }).filter((entry) => entry.isDirectory() && !entry.name.startsWith("_")).map((entry) => entry.name);
+    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 (!names.length) return { ok: false, detail: `plugin skills tree is empty at ${pluginSkills}` };
-    (0, import_node_fs17.mkdirSync)(skillsRoot, { recursive: true });
-    const incoming = (0, import_node_path10.join)(skillsRoot, ".mmi-incoming");
+    (0, import_node_fs19.mkdirSync)(skillsRoot, { recursive: true });
+    const incoming = (0, import_node_path13.join)(skillsRoot, ".mmi-incoming");
     discard2(incoming);
-    (0, import_node_fs17.cpSync)(pluginSkills, incoming, { recursive: true });
+    (0, import_node_fs19.cpSync)(pluginSkills, incoming, { recursive: true });
     discard2(targetRoot);
-    (0, import_node_fs17.renameSync)(incoming, targetRoot);
+    (0, import_node_fs19.renameSync)(incoming, targetRoot);
     return { ok: true, detail: `provisioned ${names.length} skills to ${targetRoot}` };
   } catch (error) {
     return { ok: false, detail: message2(error) };
@@ -2924,8 +3398,8 @@ function hermesHomes(env = process.env) {
   const root = hermesHome(env);
   const homes = [root];
   try {
-    for (const entry of (0, import_node_fs17.readdirSync)((0, import_node_path10.join)(root, "profiles"), { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
-      if (entry.isDirectory() && !entry.name.startsWith(".")) homes.push((0, import_node_path10.join)(root, "profiles", entry.name));
+    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));
     }
   } catch {
   }
@@ -2951,7 +3425,7 @@ 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_path10.basename)(home)}`}: ${result.detail}`).join(" | ");
+  const detail = results.map(({ home, result }, index) => `${index === 0 ? "home" : `profile ${(0, import_node_path13.basename)(home)}`}: ${result.detail}`).join(" | ");
   return {
     surface: "hermes",
     from: primary.from,
@@ -2962,8 +3436,8 @@ function hermesArm(options) {
   };
 }
 function armHermesHome(home, env, options, primary) {
-  const parent = (0, import_node_path10.join)(home, "plugins");
-  const live = (0, import_node_path10.join)(parent, "mmi");
+  const parent = (0, import_node_path13.join)(home, "plugins");
+  const live = (0, import_node_path13.join)(parent, "mmi");
   const installed = yamlVersion(live);
   const result = (from, to, verdict, detail, launchStaged = false) => ({
     surface: "hermes",
@@ -2973,7 +3447,7 @@ function armHermesHome(home, env, options, primary) {
     detail,
     launchStaged: launchStaged || void 0
   });
-  if ((0, import_node_fs17.existsSync)(live) && !mmiOwned2(live)) {
+  if ((0, import_node_fs19.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)`);
@@ -2987,7 +3461,7 @@ 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_path10.join)(home, "skills", "mmi")}, then enable mmi in plugins.enabled`);
+  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 ("defer" in staged) return result(installed, options.target, "defer", staged.defer);
   const stagedVersion = yamlVersion(staged.packageRoot);
@@ -2996,19 +3470,19 @@ function armHermesHome(home, env, options, primary) {
   }
   const stagedTree = treeIncompleteDetail(staged.packageRoot, "staged Hermes");
   if (stagedTree) return result(installed, options.target, "defer", stagedTree);
-  const scratch = (0, import_node_path10.join)(home, ".mmi-updater");
-  const launchTargetPath = (0, import_node_path10.join)(scratch, "launch-target.json");
-  const incomingRoot = (0, import_node_path10.join)(scratch, "incoming");
-  const incoming = (0, import_node_path10.join)(incomingRoot, options.target);
-  const quarantine = (0, import_node_path10.join)(scratch, "quarantine", `${installed ?? "unknown"}-${Date.now()}`);
+  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 priorLaunch = readLaunchTarget(launchTargetPath);
   const reuseIncoming = priorLaunch?.target === options.target && priorLaunch.incoming === incoming && yamlVersion(incoming) === options.target && treeHealthy2(incoming);
   if (!reuseIncoming) {
     try {
-      (0, import_node_fs17.mkdirSync)(parent, { recursive: true });
-      (0, import_node_fs17.mkdirSync)((0, import_node_path10.join)(scratch, "quarantine"), { recursive: true });
+      (0, import_node_fs19.mkdirSync)(parent, { recursive: true });
+      (0, import_node_fs19.mkdirSync)((0, import_node_path13.join)(scratch, "quarantine"), { recursive: true });
       discard2(incomingRoot);
-      (0, import_node_fs17.cpSync)(staged.packageRoot, incoming, { recursive: true });
+      (0, import_node_fs19.cpSync)(staged.packageRoot, incoming, { recursive: true });
     } catch (error) {
       return result(installed, options.target, "defer", `cannot place incoming Hermes generation: ${message2(error)}`);
     }
@@ -3023,7 +3497,7 @@ function armHermesHome(home, env, options, primary) {
       return result(installed, options.target, "defer", incomingTree);
     }
   }
-  const displaced = (0, import_node_fs17.existsSync)(live);
+  const displaced = (0, import_node_fs19.existsSync)(live);
   const busy = displaced ? hermesHostEvidence(env, home, options.processListProvider) : null;
   if (busy) {
     const pending = noteLaunchStaged(options.paths, env, {
@@ -3038,11 +3512,11 @@ function armHermesHome(home, env, options, primary) {
     return result(installed, options.target, "ok", `staged ${options.target} for next launch while Hermes is running (${busy}) \u2014 ${pending}`, true);
   }
   try {
-    if (displaced) (0, import_node_fs17.renameSync)(live, quarantine);
-    (0, import_node_fs17.renameSync)(incoming, live);
+    if (displaced) (0, import_node_fs19.renameSync)(live, quarantine);
+    (0, import_node_fs19.renameSync)(incoming, live);
   } catch (error) {
-    if (displaced && !(0, import_node_fs17.existsSync)(live)) try {
-      (0, import_node_fs17.renameSync)(quarantine, live);
+    if (displaced && !(0, import_node_fs19.existsSync)(live)) try {
+      (0, import_node_fs19.renameSync)(quarantine, live);
     } catch {
     }
     discard2(incomingRoot);
@@ -3053,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_path10.join)(scratch, "rejected", `${options.target}-${Date.now()}`);
+    const broken = (0, import_node_path13.join)(scratch, "rejected", `${options.target}-${Date.now()}`);
     const verifyDetail = liveVersion !== options.target ? `manifest is ${liveVersion ?? "unreadable"}, expected ${options.target}` : liveTree;
     try {
-      (0, import_node_fs17.mkdirSync)((0, import_node_path10.join)(scratch, "rejected"), { recursive: true });
-      (0, import_node_fs17.renameSync)(live, broken);
-      if (displaced) (0, import_node_fs17.renameSync)(quarantine, live);
+      (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);
     } catch (error) {
       return result(installed, liveVersion ?? "unknown", "fail", `post-switch Hermes verification failed and recovery failed: ${message2(error)}`);
     }
@@ -3073,12 +3547,12 @@ function armHermesHome(home, env, options, primary) {
   return result(installed, options.target, "ok", `converged ${installed ?? "absent"} -> ${options.target} (staged, verified, atomically switched${displaced ? `; previous generation quarantined at ${quarantine}` : ""}); ${skills.detail}; ${enabled.detail}`);
 }
 function probeHermesLaunchStaging(env = process.env) {
-  return probeLaunchTargetVersion((0, import_node_path10.join)(hermesHome(env), ".mmi-updater", "launch-target.json"), yamlVersion);
+  return probeLaunchTargetVersion((0, import_node_path13.join)(hermesHome(env), ".mmi-updater", "launch-target.json"), yamlVersion);
 }
 
 // src/reap.ts
-var import_node_fs18 = require("node:fs");
-var import_node_path11 = require("node:path");
+var import_node_fs20 = require("node:fs");
+var import_node_path14 = 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;
@@ -3087,7 +3561,7 @@ var KEEP_GENERATIONS2 = 2;
 var SCRATCH_AGE_MS = 24 * 60 * 6e4;
 function listDirs(path) {
   try {
-    return (0, import_node_fs18.readdirSync)(path, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+    return (0, import_node_fs20.readdirSync)(path, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
   } catch {
     return [];
   }
@@ -3095,7 +3569,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_path11.join)(root, name)).filter((path) => listDirs(path).some((name) => parseSemver(name)));
+  return children.map((name) => (0, import_node_path14.join)(root, name)).filter((path) => listDirs(path).some((name) => parseSemver(name)));
 }
 function pruneGenerations(root, category, dryRun) {
   let reaped = 0;
@@ -3108,7 +3582,7 @@ function pruneGenerations(root, category, dryRun) {
         continue;
       }
       try {
-        (0, import_node_fs18.rmSync)((0, import_node_path11.join)(set, version), { recursive: true, force: true });
+        (0, import_node_fs20.rmSync)((0, import_node_path14.join)(set, version), { recursive: true, force: true });
         reaped += 1;
       } catch (error) {
         failures.push(`${version}: ${error?.code ?? error?.message ?? error}`);
@@ -3122,8 +3596,8 @@ function pruneGenerations(root, category, dryRun) {
 }
 var LEASE_STEAL_SCRATCH = /^lease\.lock\.stale-\d+$/;
 function atomicWriteScratch(path) {
-  const literal = (0, import_node_path11.basename)(path).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  return { dir: (0, import_node_path11.dirname)(path), pattern: new RegExp(`^${literal}\\.tmp-\\d+$`) };
+  const literal = (0, import_node_path14.basename)(path).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return { dir: (0, import_node_path14.dirname)(path), pattern: new RegExp(`^${literal}\\.tmp-\\d+$`) };
 }
 function reapScratch(context, dryRun) {
   const category = "scratch";
@@ -3141,7 +3615,7 @@ function reapScratch(context, dryRun) {
   for (const [dir, patterns] of scanned) {
     let entries;
     try {
-      entries = (0, import_node_fs18.readdirSync)(dir, { withFileTypes: true });
+      entries = (0, import_node_fs20.readdirSync)(dir, { withFileTypes: true });
     } catch {
       unreadable.push(dir);
       continue;
@@ -3149,10 +3623,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_path11.join)(dir, entry.name);
+      const path = (0, import_node_path14.join)(dir, entry.name);
       let ageMs;
       try {
-        ageMs = now - (0, import_node_fs18.statSync)(path).mtimeMs;
+        ageMs = now - (0, import_node_fs20.statSync)(path).mtimeMs;
       } catch {
         continue;
       }
@@ -3162,7 +3636,7 @@ function reapScratch(context, dryRun) {
         continue;
       }
       try {
-        (0, import_node_fs18.rmSync)(path, { force: true });
+        (0, import_node_fs20.rmSync)(path, { force: true });
         reaped += 1;
       } catch (error) {
         failures.push(`${entry.name}: ${error?.code ?? error?.message ?? error}`);
@@ -3392,10 +3866,10 @@ async function reconcile(options) {
 }
 
 // src/scheduler.ts
-var import_node_child_process9 = require("node:child_process");
-var import_node_fs19 = require("node:fs");
-var import_node_os6 = require("node:os");
-var import_node_path12 = require("node:path");
+var import_node_child_process10 = require("node:child_process");
+var import_node_fs21 = require("node:fs");
+var import_node_os8 = require("node:os");
+var import_node_path15 = require("node:path");
 var TASK_NAME = "MMI Fleet Updater";
 var LAUNCHER_FILE = "reconcile-hidden.vbs";
 var RUN_BOUND = "PT15M";
@@ -3411,15 +3885,15 @@ var SYSTEMD_UNIT = "mmi-hub-updater";
 var SYSTEMD_SERVICE_NAME = `${SYSTEMD_UNIT}.service`;
 var SYSTEMD_TIMER_NAME = `${SYSTEMD_UNIT}.timer`;
 function schtasks(args) {
-  const result = (0, import_node_child_process9.spawnSync)("schtasks.exe", args, { encoding: "utf8", windowsHide: true });
+  const result = (0, import_node_child_process10.spawnSync)("schtasks.exe", args, { encoding: "utf8", windowsHide: true });
   return { status: result.status, stdout: result.stdout ?? "", stderr: result.stderr ?? "" };
 }
 function launchctl(args) {
-  const result = (0, import_node_child_process9.spawnSync)("launchctl", args, { encoding: "utf8", windowsHide: true });
+  const result = (0, import_node_child_process10.spawnSync)("launchctl", args, { encoding: "utf8", windowsHide: true });
   return { status: result.status, stdout: result.stdout ?? "", stderr: result.stderr ?? "" };
 }
 function systemctlUser(args) {
-  const result = (0, import_node_child_process9.spawnSync)("systemctl", ["--user", ...args], { encoding: "utf8", windowsHide: true });
+  const result = (0, import_node_child_process10.spawnSync)("systemctl", ["--user", ...args], { encoding: "utf8", windowsHide: true });
   return { status: result.status, stdout: result.stdout ?? "", stderr: result.stderr ?? "" };
 }
 function uid() {
@@ -3444,7 +3918,7 @@ WScript.Quit code
 `;
 }
 function loginPath(fallback = process.env.PATH ?? "") {
-  const probe = (0, import_node_child_process9.spawnSync)("/bin/sh", ["-lc", 'printf %s "$PATH"'], { encoding: "utf8", windowsHide: true, timeout: 1e4 });
+  const probe = (0, import_node_child_process10.spawnSync)("/bin/sh", ["-lc", 'printf %s "$PATH"'], { encoding: "utf8", windowsHide: true, timeout: 1e4 });
   const captured = (probe.status === 0 ? probe.stdout ?? "" : "").trim();
   const source = captured || fallback;
   const durable = source.split(":").filter((entry) => entry && !/^\/(?:private\/)?(?:tmp|var\/folders)\//.test(entry));
@@ -3553,7 +4027,7 @@ WantedBy=timers.target
 }
 function readFileOrNull(path) {
   try {
-    return (0, import_node_fs19.readFileSync)(path, "utf8");
+    return (0, import_node_fs21.readFileSync)(path, "utf8");
   } catch {
     return null;
   }
@@ -3565,7 +4039,7 @@ function elevatedRelaunch(mode, env) {
   if (env.MMI_UPDATER_ELEVATED_RETRY === "1") return false;
   const self = process.argv[1];
   const command = self ? `"${process.execPath}" "${self}" autoupdate ${mode}` : `mmi-hub autoupdate ${mode}`;
-  const relaunch = (0, import_node_child_process9.spawnSync)(
+  const relaunch = (0, import_node_child_process10.spawnSync)(
     "powershell.exe",
     ["-NoProfile", "-Command", `Start-Process -Verb RunAs -Wait -WindowStyle Hidden -FilePath 'cmd.exe' -ArgumentList '/c',${psQuote(`set MMI_UPDATER_ELEVATED_RETRY=1&& ${command}`)}`],
     { encoding: "utf8", windowsHide: true }
@@ -3576,7 +4050,7 @@ var NEVER_RUN_RESULT = 267011;
 var NEVER_RUN_YEAR = 1999;
 var EMPTY_RUN_INFO = { lastRunTime: null, lastTaskResult: null, nextRunTime: null };
 function taskRunInfo() {
-  const result = (0, import_node_child_process9.spawnSync)(
+  const result = (0, import_node_child_process10.spawnSync)(
     "powershell.exe",
     ["-NoProfile", "-Command", `$stamp = { param($t) if ($t) { $t.ToString('yyyy-MM-dd HH:mm:ss') } }; Get-ScheduledTaskInfo -TaskName '${TASK_NAME}' | Select-Object @{n='LastRunTime';e={& $stamp $_.LastRunTime}},LastTaskResult,@{n='NextRunTime';e={& $stamp $_.NextRunTime}} | ConvertTo-Json -Compress`],
     { encoding: "utf8", windowsHide: true, timeout: 3e4 }
@@ -3602,7 +4076,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_path12.join)(statePaths(env).root, LAUNCHER_FILE);
+  const launcherPath = (0, import_node_path15.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 });
@@ -3627,13 +4101,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_path12.join)((0, import_node_os6.homedir)(), "Library", "LaunchAgents", LAUNCHD_PLIST_NAME);
+  const plistPath = (0, import_node_path15.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_path12.join)(statePaths(env).root, POSIX_LAUNCHER_FILE);
+  const launcherPath = (0, import_node_path15.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\``);
@@ -3653,15 +4127,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_path12.join)((0, import_node_os6.homedir)(), ".config", "systemd", "user");
-  const timerPath = (0, import_node_path12.join)(unitDir, SYSTEMD_TIMER_NAME);
+  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 timer = readFileOrNull(timerPath);
-  const service = readFileOrNull((0, import_node_path12.join)(unitDir, SYSTEMD_SERVICE_NAME));
+  const service = readFileOrNull((0, import_node_path15.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_path12.join)(statePaths(env).root, POSIX_LAUNCHER_FILE);
+  const launcherPath = (0, import_node_path15.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\``);
@@ -3700,18 +4174,18 @@ 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_path12.join)(paths.root, LAUNCHER_FILE);
-  (0, import_node_fs19.writeFileSync)(launcherPath, launcherVbs(process.execPath, hubDist), "utf8");
-  const xmlPath = (0, import_node_path12.join)(paths.root, "task.xml");
-  (0, import_node_fs19.writeFileSync)(xmlPath, "\uFEFF" + taskXml(launcherPath, paths.root, userId, localStartBoundary(/* @__PURE__ */ new Date())), "utf16le");
+  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 create = schtasks(["/create", "/tn", TASK_NAME, "/xml", xmlPath, "/f"]);
   if (create.status !== 0) {
     const denied = /access is denied/i.test(create.stderr + create.stdout);
     if (!denied || !elevatedRelaunch("on", env)) {
       return { ok: false, detail: denied ? "task creation needs elevation and UAC consent was not granted \u2014 run `mmi-hub autoupdate on` from an elevated terminal" : `schtasks /create failed: ${(create.stderr || create.stdout).trim()}` };
     }
-    const verify = windowsSchedulerStatus(env);
-    return verify.ok ? { ok: true, detail: `enabled "${TASK_NAME}" (elevated) \u2014 ${CADENCE}` } : { ok: false, detail: `elevated registration did not take: ${verify.detail}` };
+    const verify2 = windowsSchedulerStatus(env);
+    return verify2.ok ? { ok: true, detail: `enabled "${TASK_NAME}" (elevated) \u2014 ${CADENCE}` } : { ok: false, detail: `elevated registration did not take: ${verify2.detail}` };
   }
   return { ok: true, detail: `enabled "${TASK_NAME}" \u2014 ${CADENCE} \u2192 ${hubDist}` };
 }
@@ -3719,11 +4193,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_path12.join)(paths.root, POSIX_LAUNCHER_FILE);
+  const launcherPath = (0, import_node_path15.join)(paths.root, POSIX_LAUNCHER_FILE);
   const desired = launcherSh(process.execPath, hubDist);
   if (readFileOrNull(launcherPath) === desired) return null;
-  (0, import_node_fs19.writeFileSync)(launcherPath, desired, "utf8");
-  (0, import_node_fs19.chmodSync)(launcherPath, 493);
+  (0, import_node_fs21.writeFileSync)(launcherPath, desired, "utf8");
+  (0, import_node_fs21.chmodSync)(launcherPath, 493);
   return launcherPath;
 }
 function installLaunchd(env) {
@@ -3735,20 +4209,20 @@ 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_path12.join)(paths.root, POSIX_LAUNCHER_FILE);
-  (0, import_node_fs19.writeFileSync)(launcherPath, launcherSh(process.execPath, hubDist), "utf8");
-  (0, import_node_fs19.chmodSync)(launcherPath, 493);
-  const agentsDir = (0, import_node_path12.join)((0, import_node_os6.homedir)(), "Library", "LaunchAgents");
-  (0, import_node_fs19.mkdirSync)(agentsDir, { recursive: true });
-  const plistPath = (0, import_node_path12.join)(agentsDir, LAUNCHD_PLIST_NAME);
-  (0, import_node_fs19.writeFileSync)(plistPath, launchdPlist(launcherPath, paths.root), "utf8");
+  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");
   launchctl(["bootout", `gui/${uid()}/${LAUNCHD_LABEL}`]);
   const load = launchctl(["bootstrap", `gui/${uid()}`, plistPath]);
   if (load.status !== 0) {
     return { ok: false, detail: `launchctl bootstrap failed: ${(load.stderr || load.stdout).trim() || "unknown error"}` };
   }
-  const verify = darwinSchedulerStatus(env);
-  return verify.ok ? { ok: true, detail: `enabled "${LAUNCHD_LABEL}" \u2014 ${POSIX_CADENCE} \u2192 ${hubDist}` } : { ok: false, detail: `registration did not take: ${verify.detail}` };
+  const verify2 = darwinSchedulerStatus(env);
+  return verify2.ok ? { ok: true, detail: `enabled "${LAUNCHD_LABEL}" \u2014 ${POSIX_CADENCE} \u2192 ${hubDist}` } : { ok: false, detail: `registration did not take: ${verify2.detail}` };
 }
 function installSystemdTimer(env) {
   const current = linuxSchedulerStatus(env);
@@ -3759,13 +4233,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_path12.join)(paths.root, POSIX_LAUNCHER_FILE);
-  (0, import_node_fs19.writeFileSync)(launcherPath, launcherSh(process.execPath, hubDist), "utf8");
-  (0, import_node_fs19.chmodSync)(launcherPath, 493);
-  const unitDir = (0, import_node_path12.join)((0, import_node_os6.homedir)(), ".config", "systemd", "user");
-  (0, import_node_fs19.mkdirSync)(unitDir, { recursive: true });
-  (0, import_node_fs19.writeFileSync)((0, import_node_path12.join)(unitDir, SYSTEMD_SERVICE_NAME), systemdServiceUnit(launcherPath, paths.root), "utf8");
-  (0, import_node_fs19.writeFileSync)((0, import_node_path12.join)(unitDir, SYSTEMD_TIMER_NAME), systemdTimerUnit(), "utf8");
+  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 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?"}` };
@@ -3774,8 +4248,8 @@ function installSystemdTimer(env) {
   if (enable.status !== 0) {
     return { ok: false, detail: `systemctl --user enable --now ${SYSTEMD_TIMER_NAME} failed: ${(enable.stderr || enable.stdout).trim() || "unknown error"}` };
   }
-  const verify = linuxSchedulerStatus(env);
-  return verify.ok ? { ok: true, detail: `enabled "${SYSTEMD_TIMER_NAME}" \u2014 ${POSIX_CADENCE} \u2192 ${hubDist}` } : { ok: false, detail: `registration did not take: ${verify.detail}` };
+  const verify2 = linuxSchedulerStatus(env);
+  return verify2.ok ? { ok: true, detail: `enabled "${SYSTEMD_TIMER_NAME}" \u2014 ${POSIX_CADENCE} \u2192 ${hubDist}` } : { ok: false, detail: `registration did not take: ${verify2.detail}` };
 }
 function installTask(env = process.env) {
   if (process.platform === "win32") return installWindowsTask(env);
@@ -3803,28 +4277,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_path12.join)((0, import_node_os6.homedir)(), "Library", "LaunchAgents", LAUNCHD_PLIST_NAME);
+  const plistPath = (0, import_node_path15.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_fs19.existsSync)(plistPath)) {
+  if (boot.status !== 0 && (0, import_node_fs21.existsSync)(plistPath)) {
     return { ok: false, detail: `launchctl bootout failed: ${(boot.stderr || boot.stdout).trim() || "unknown error"}` };
   }
   try {
-    (0, import_node_fs19.rmSync)(plistPath, { force: true });
+    (0, import_node_fs21.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_path12.join)((0, import_node_os6.homedir)(), ".config", "systemd", "user");
-  const timerPath = (0, import_node_path12.join)(unitDir, SYSTEMD_TIMER_NAME);
+  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 disable = systemctlUser(["disable", "--now", SYSTEMD_TIMER_NAME]);
-  if (disable.status !== 0 && (0, import_node_fs19.existsSync)(timerPath)) {
+  if (disable.status !== 0 && (0, import_node_fs21.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_fs19.rmSync)(timerPath, { force: true });
-    (0, import_node_fs19.rmSync)((0, import_node_path12.join)(unitDir, SYSTEMD_SERVICE_NAME), { force: true });
+    (0, import_node_fs21.rmSync)(timerPath, { force: true });
+    (0, import_node_fs21.rmSync)((0, import_node_path15.join)(unitDir, SYSTEMD_SERVICE_NAME), { force: true });
   } catch {
   }
   systemctlUser(["daemon-reload"]);
@@ -3839,16 +4313,16 @@ function uninstallTask(env = process.env) {
 }
 function dropLauncher(env, file) {
   try {
-    (0, import_node_fs19.rmSync)((0, import_node_path12.join)(statePaths(env).root, file), { force: true });
+    (0, import_node_fs21.rmSync)((0, import_node_path15.join)(statePaths(env).root, file), { force: true });
   } catch {
   }
 }
 
 // src/status.ts
-var import_node_fs20 = require("node:fs");
+var import_node_fs22 = require("node:fs");
 function readJournal(path) {
   try {
-    const events = (0, import_node_fs20.readFileSync)(path, "utf8").split("\n").filter((line) => line.trim()).map((line) => {
+    const events = (0, import_node_fs22.readFileSync)(path, "utf8").split("\n").filter((line) => line.trim()).map((line) => {
       try {
         return JSON.parse(line);
       } catch {
@@ -3867,6 +4341,9 @@ function versionState(installed, staged, expected) {
   return relation === 0 ? "current" : relation > 0 ? "ahead" : "behind";
 }
 function hubStatus(hubVersion, env = process.env, invokedPath = process.argv[1]) {
+  return hubStatusReport(hubVersion, env, invokedPath).status;
+}
+function hubStatusReport(hubVersion, env = process.env, invokedPath = process.argv[1]) {
   const paths = statePaths(env);
   const { events, error } = readJournal(paths.journalPath);
   const realEvents = events.filter((event) => !event.dryRun);
@@ -3928,6 +4405,7 @@ function hubStatus(hubVersion, env = process.env, invokedPath = process.argv[1])
     if (!row.installed) failures.push(`${surface}: installed version is unreadable at ${row.location ?? "an unknown location"} \u2014 run \`mmi-hub update\``);
     if (row.state === "behind") failures.push(`${surface}: installed ${row.installed} is behind expected ${row.expected} \u2014 run \`mmi-hub update\``);
   }
+  const lastRunProblems = [];
   for (const event of latestRunEvents) {
     if ((event.kind === "arm" || event.kind === "reconcile") && (event.verdict === "fail" || event.verdict === "defer")) {
       if (event.kind === "arm" && event.surface && event.surface !== "cli" && event.surface !== "updater" && !presentSurfaces.has(event.surface)) {
@@ -3935,10 +4413,11 @@ function hubStatus(hubVersion, env = process.env, invokedPath = process.argv[1])
       }
       const surface = event.surface === "updater" ? "hub" : event.surface ?? event.kind;
       const repeat = event.kind === "arm" && event.verdict === "fail" && event.surface && journalSurfaceRepeatedFail(paths.journalPath, event.surface, latestEvent.run);
+      lastRunProblems.push({ surface: event.surface ?? (event.kind === "reconcile" ? "update run" : event.kind), verdict: event.verdict, detail: event.detail ?? event.verdict, repeat: Boolean(repeat) });
       failures.push(repeat ? `last run ${surface}: ${event.detail ?? event.verdict} \u2014 already failed the previous run too; \`mmi-hub update\` will not clear it, inspect the journal` : `last run ${surface}: ${event.detail ?? event.verdict} \u2014 run \`mmi-hub update\``);
     }
   }
-  return {
+  const status = {
     hubVersion,
     expectedVersion,
     installed,
@@ -3947,27 +4426,60 @@ function hubStatus(hubVersion, env = process.env, invokedPath = process.argv[1])
     journalPath: paths.journalPath,
     failures: [...new Set(failures)]
   };
-}
-function formatHubStatus(status) {
-  const lines = [
-    `mmi-hub ${status.hubVersion} status`,
-    `  expected: ${status.expectedVersion ?? "unknown (no gated target recorded)"}`,
-    "  installed:"
-  ];
-  for (const [surface, row] of Object.entries(status.installed)) {
-    const staged = row.staged ? `; staged ${row.staged} for next launch` : "";
-    lines.push(`    ${surface}: loaded ${row.installed ?? "unknown"}${staged} (expected ${row.expected ?? "unknown"}; ${row.state})`);
-    lines.push(`      ${row.location ?? "location unavailable"} \u2014 ${row.detail}`);
-  }
-  lines.push(`  autoupdate: ${status.schedule.enabled ? "on" : "off"} \u2014 ${status.schedule.detail}`);
-  lines.push(`  last run: ${status.lastRun ? `${status.lastRun.at} (${status.lastRun.id})` : "never recorded"}`);
-  if (status.failures.length) {
-    lines.push("  actionable failures:");
-    for (const failure3 of status.failures) lines.push(`    - ${failure3}`);
-  } else {
-    lines.push("  actionable failures: none");
-  }
-  return lines.join("\n");
+  return { status, journalError: error, lastRunProblems };
+}
+var rowId = (surface) => surface === "hub" ? "updater" : surface;
+var oneLine = (text) => text.split("\n")[0].replaceAll("`", "").trim();
+var when = (ts) => /^\d{4}-\d\d-\d\dT\d\d:\d\d.*Z$/.test(ts) ? `${ts.slice(0, 16).replace("T", " ")} UTC` : ts;
+function versionRow(surface, row) {
+  const id = rowId(surface);
+  const loaded = row.installed ?? "unknown";
+  if (row.state === "retired") return { surface: id, state: SURFACE_WORDS.skipped, mark: "note" };
+  if (!row.installed) return { surface: id, state: SURFACE_WORDS.unknown, mark: "fail", note: "Its version could not be read." };
+  if (row.state === "current") return { surface: id, state: `${loaded} \xB7 ${SURFACE_WORDS.current}`, mark: "ok" };
+  if (row.state === "behind") return { surface: id, state: `${loaded} \u2192 ${row.expected} \xB7 ${SURFACE_WORDS.behind}`, mark: "note" };
+  if (row.state === "staged") return { surface: id, state: `${loaded} \u2192 ${row.staged} \xB7 ${SURFACE_WORDS.staged}`, mark: "note" };
+  return { surface: id, state: `${loaded} \xB7 ${SURFACE_WORDS[row.state]}`, mark: "note" };
+}
+function statusScreen(report, doctor) {
+  const { status } = report;
+  const rows = Object.entries(status.installed).map(([surface, row]) => versionRow(surface, row));
+  const nexts = /* @__PURE__ */ new Set();
+  for (const row of rows) if (row.mark === "fail") nexts.add("mmi-hub update");
+  const schedule = status.schedule;
+  const autoRow = { surface: AUTO_UPDATE, state: schedule.enabled ? "on \xB7 hourly" : "off", mark: schedule.enabled ? "ok" : "note" };
+  if (!schedule.supported) autoRow.note = "Not available on this system.";
+  else if (!schedule.ok) {
+    Object.assign(autoRow, { mark: "fail", note: schedule.enabled ? "Auto-update is not set up correctly." : "Auto-update is not set up." });
+    nexts.add("mmi-hub autoupdate on");
+  } else if (typeof schedule.lastTaskResult === "number" && schedule.lastTaskResult !== 0 && schedule.lastTaskResult !== 267011) {
+    autoRow.note = `The last automatic run ended with an error (code ${schedule.lastTaskResult}).`;
+  }
+  rows.push(autoRow);
+  for (const problem of report.lastRunProblems) {
+    const id = rowId(problem.surface);
+    const note = `${problem.repeat ? "Failed twice in a row" : problem.verdict === "defer" ? "Last update will retry" : "Last update failed"}: ${oneLine(problem.detail)}`;
+    const word = problem.verdict === "defer" ? SURFACE_WORDS.retry : SURFACE_WORDS.failed;
+    const loaded = Object.entries(status.installed).find(([surface]) => rowId(surface) === id)?.[1].installed;
+    const row = rows.find((candidate) => candidate.surface === id);
+    if (row) Object.assign(row, { state: loaded ? `${loaded} \xB7 ${word}` : word, mark: "fail", note });
+    else rows.push({ surface: id, state: word, mark: "fail", note });
+    nexts.add(problem.repeat ? doctor : "mmi-hub update");
+  }
+  const facts = [];
+  if (status.expectedVersion) facts.push(`Latest release: ${status.expectedVersion}.`);
+  if (report.journalError) {
+    facts.push(`The update log could not be read: ${status.journalPath}`);
+    nexts.add(doctor);
+  } else if (!status.lastRun) {
+    facts.push("No update has run on this machine yet.");
+    nexts.add("mmi-hub install");
+  } else facts.push(`Last update: ${when(status.lastRun.at)}.`);
+  const behind = rows.some((row) => row.state.endsWith(SURFACE_WORDS.behind));
+  const next = ["mmi-hub install", "mmi-hub update", "mmi-hub autoupdate on", doctor].find((command) => nexts.has(command));
+  if (next) return { rows, verdict: { state: "fail", headline: "needs attention.", facts, next } };
+  if (behind) return { rows, verdict: { state: "note", headline: "has an update available.", facts, next: "mmi-hub update" } };
+  return { rows, verdict: { state: "ok", headline: "is ready.", facts, next: doctor } };
 }
 
 // src/report.ts
@@ -4019,14 +4531,14 @@ function reportCounts(summary) {
 }
 
 // src/stamp.ts
-var import_node_fs21 = require("node:fs");
+var import_node_fs23 = 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_fs21.readFileSync)(paths.journalPath, "utf8").split("\n").filter((line) => line.trim()).map((line) => {
+    events = (0, import_node_fs23.readFileSync)(paths.journalPath, "utf8").split("\n").filter((line) => line.trim()).map((line) => {
       try {
         return JSON.parse(line);
       } catch {
@@ -4070,34 +4582,46 @@ function fleetStamp(env = process.env) {
   }
   const pendingNote = pending.length ? ` \xB7 ${pending.length} surface${pending.length === 1 ? "" : "s"} pending an arm: ${pending.join(" ")}` : "";
   const retiredNote = retiredPresent.length ? ` \xB7 retired at source: ${retiredPresent.join(" ")}` : "";
-  return `fleet ${target} \u2713 ${healthy.join("\xB7")}${pendingNote}${retiredNote}`;
+  return `fleet ${target} ok ${healthy.join("\xB7")}${pendingNote}${retiredNote}`;
 }
 
 // src/index.ts
 function ownVersion() {
   try {
-    return JSON.parse((0, import_node_fs22.readFileSync)((0, import_node_path13.join)(__dirname, "..", "package.json"), "utf8")).version;
+    return JSON.parse((0, import_node_fs24.readFileSync)((0, import_node_path16.join)(__dirname, "..", "package.json"), "utf8")).version;
   } catch {
     return "0.0.0";
   }
 }
-var HELP = `mmi-hub ${ownVersion()} \u2014 install and maintain MMI tooling
-
-  status [--json]                  read installed/expected versions, hourly schedule, last run,
-                                   and actionable failures (default; never heals)
-  install [--json]                 converge the CLI and every present host surface now, then enable
-                                   hourly automatic updates
-  update [--dry-run] [--json] [--verbose]
-                                   converge immediately to the newest gated release: one line per
-                                   surface, a short reason only when not ok; --verbose traces steps
-  autoupdate on|off                idempotently enable or disable hourly convergence; off keeps tools
-  --version                        print the Hub maintenance package version
-
-State remains under $MMI_UPDATER_HOME (default ~/.mmi/updater), and the Windows task name remains
-"MMI Fleet Updater", so existing installations continue in place.
-Status performs no npm install, host repair, scheduler write, state mkdir, or repository cleanup.`;
+var FACE = "mmi-hub";
+var declaration = validateInstallerProduct(installer_product_default);
+function usage(render) {
+  return renderUsage(FACE, {
+    bin: "mmi-hub",
+    version: ownVersion(),
+    summary: "install and keep MMI tooling up to date",
+    commands: [
+      { usage: "status", text: "Show what is installed, whether auto-update is on, and anything to fix. The default. Changes nothing." },
+      { usage: "install", text: "Update everything now, then turn on hourly auto-update." },
+      { usage: "update", text: "Update everything to the newest release now." },
+      { usage: "autoupdate on|off", text: "Turn hourly auto-update on or off. Off keeps installed tools." }
+    ],
+    options: [
+      { usage: "--json", text: "Print machine-readable JSON instead of the screen." },
+      { usage: "--dry-run", text: "With update: show what would change, change nothing." },
+      { usage: "--verbose", text: "With update or install: show each step as it runs." },
+      { usage: "--quiet", text: "With update or install: skip the progress lines." },
+      { usage: "--no-color", text: "Turn colours off." },
+      { usage: "--version", text: "Print the version." },
+      { usage: "--help", text: "Print this help." }
+    ]
+  }, render);
+}
+function notice(screen, render) {
+  printScreen(renderNotice(FACE, screen, render), screen.state === "fail" ? "stderr" : "stdout");
+}
 function handOff(reexec, args, env) {
-  const child = (0, import_node_child_process10.spawnSync)(process.execPath, [reexec.dist, ...args], {
+  const child = (0, import_node_child_process11.spawnSync)(process.execPath, [reexec.dist, ...args], {
     stdio: "inherit",
     windowsHide: true,
     env: { ...env, MMI_UPDATER_REEXEC: "1" }
@@ -4120,46 +4644,62 @@ function runMaintenance2(args, dependencies = {}) {
     handOff: dependencies.handOff ?? handOff,
     run: dependencies.run,
     shippedTarget: shippedTargetFrom(args),
+    launcher: declaration.launcher ? ({ dryRun }) => (dependencies.refreshLauncher ?? refreshLauncher)(declaration.launcher, { dryRun }) : void 0,
     counts: reportCounts,
     diagnose: (arm) => arm.verdict === "fail" ? [arm.detail, failConsequence(arm), arm.repeatFailure ? "This failure persisted after repair; do not repeat the same remedy. Inspect the updater journal." : retryHint(arm.detail)].join("\n") : arm.verdict === "defer" ? `${arm.detail}
 ${retryHint(arm.detail)}` : void 0
   });
 }
 async function main(args = process.argv.slice(2)) {
+  const render = { color: !args.includes("--no-color") };
   if (args.includes("--version")) {
-    process.stdout.write(ownVersion() + "\n");
+    process.stdout.write(`${process.stdout.isTTY ? renderVersion("mmi-hub", ownVersion()) : ownVersion()}
+`);
     return 0;
   }
   if (args.includes("--help") || args.includes("-h")) {
-    process.stdout.write(HELP + "\n");
+    printScreen(usage(render));
     return 0;
   }
   const command = args.find((arg) => !arg.startsWith("--")) ?? "status";
   const json = args.includes("--json");
   if (command === "status") {
-    const status = hubStatus(ownVersion());
-    process.stdout.write(json ? JSON.stringify(status, null, 2) + "\n" : formatHubStatus(status) + "\n");
-    return status.failures.length ? 1 : 0;
+    const report = hubStatusReport(ownVersion());
+    if (json) process.stdout.write(JSON.stringify(report.status, null, 2) + "\n");
+    else printScreen(renderReport(FACE, statusScreen(report, declaration.doctor), render));
+    return report.status.failures.length ? 1 : 0;
   }
   if (command === "update" || command === "install") return runMaintenance2(args);
   if (command === "autoupdate") {
-    const commandIndex = args.indexOf(command);
-    const mode = args[commandIndex + 1];
+    const mode = args[args.indexOf(command) + 1];
     if (mode !== "on" && mode !== "off") {
-      process.stderr.write("mmi-hub autoupdate requires on or off\n");
+      const message3 = mode === void 0 || mode.startsWith("--") ? "Say on or off: mmi-hub autoupdate on, or mmi-hub autoupdate off." : `Unknown auto-update mode: ${mode}. Say on or off.`;
+      if (json) process.stdout.write(JSON.stringify({ error: message3 }, null, 2) + "\n");
+      else notice({ state: "fail", message: message3, next: "mmi-hub autoupdate on" }, render);
       return 1;
     }
     const result = mode === "on" ? installTask() : uninstallTask();
-    process.stdout.write(json ? JSON.stringify({ mode, ...result }, null, 2) + "\n" : `mmi-hub autoupdate ${mode}: ${result.detail}
-`);
+    if (json) process.stdout.write(JSON.stringify({ mode, ...result }, null, 2) + "\n");
+    else if (!result.ok) notice({ state: "fail", message: `Auto-update could not be turned ${mode}: ${plainDetail(result.detail)}`, next: `mmi-hub autoupdate ${mode}` }, render);
+    else if (mode === "on") notice({ state: "ok", message: "Auto-update is on. mmi-hub checks for updates every hour." }, render);
+    else notice({ state: "ok", message: "Auto-update is off. Installed tools were kept." }, render);
     return result.ok ? 0 : 1;
   }
-  process.stdout.write(HELP + "\n");
+  notice({ state: "fail", message: `Unknown command: ${command}.`, next: "mmi-hub --help" }, render);
   return 1;
 }
+function plainDetail(detail) {
+  const text = detail.split(" \u2014 run `")[0].replaceAll("`", "").trim();
+  return /[.!?]$/.test(text) ? text : `${text}.`;
+}
 if (typeof require !== "undefined" && require.main === module) {
   main().then((code) => process.exit(code)).catch((error) => {
-    process.stderr.write(`mmi-hub: ${error?.stack ?? error}
+    const args = process.argv.slice(2);
+    const first = String(error?.message ?? error).split("\n")[0].replaceAll("`", "").trim();
+    const message3 = first ? /[.!?]$/.test(first) ? first : `${first}.` : "mmi-hub stopped unexpectedly.";
+    if (args.includes("--json")) process.stdout.write(JSON.stringify({ error: message3 }, null, 2) + "\n");
+    else notice({ state: "fail", message: message3, next: declaration.doctor }, { color: !args.includes("--no-color") });
+    if (args.includes("--verbose") && error?.stack) process.stderr.write(`${error.stack}
 `);
     process.exit(1);
   });
@@ -4185,6 +4725,7 @@ if (typeof require !== "undefined" && require.main === module) {
   hermesHostEvidence,
   hermesHostPresent,
   hubStatus,
+  hubStatusReport,
   launchdPlist,
   launcherSh,
   launcherVbs,
@@ -4209,6 +4750,8 @@ if (typeof require !== "undefined" && require.main === module) {
   reconcile,
   reconcileCursorUserHooks,
   releaseSharedDocLock,
+  renderNotice,
+  renderReport,
   reportCounts,
   retiredSurfaces,
   retryHint,
@@ -4219,6 +4762,7 @@ if (typeof require !== "undefined" && require.main === module) {
   sharedDocLockTimeoutReceipt,
   shippedTargetFrom,
   shouldHandOff,
+  statusScreen,
   surfaceArmPlan,
   systemdServiceUnit,
   systemdTimerUnit,