@mutmutco/hub 4.4.10 → 4.4.12

package/dist/index.cjs

@@ -21,27 +21,18 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  ACCENT: () => ACCENT,
-  FACE_PRODUCT: () => FACE_PRODUCT,
-  MM_GREEN: () => MM_GREEN,
-  RESET: () => RESET,
-  accent: () => accent,
   acquireSharedDocLock: () => acquireSharedDocLock,
-  attentionRows: () => attentionRows,
-  autoupdateLine: () => autoupdateLine,
-  brandLine: () => brandLine,
+  assertFaceConformance: () => assertFaceConformance,
   buildWatcherCommand: () => buildWatcherCommand,
   checkAtomicity: () => checkAtomicity,
-  checklistLine: () => checklistLine,
   claudeArm: () => claudeArm,
   claudeHostEvidence: () => claudeHostEvidence,
   clearLaunchTarget: () => clearLaunchTarget,
   clearPending: () => clearPending,
+  createInstallerRun: () => createInstallerRun,
   enumerateSurfaces: () => enumerateSurfaces,
   failConsequence: () => failConsequence,
   fleetStamp: () => fleetStamp,
-  formatReconcileReport: () => formatReconcileReport,
-  heldOutput: () => heldOutput,
   hermesArm: () => hermesArm,
   hermesHome: () => hermesHome,
   hermesHomes: () => hermesHomes,
@@ -68,17 +59,15 @@ __export(index_exports, {
   probeHermesLaunchStaging: () => probeHermesLaunchStaging,
   probeJervcodeInstallation: () => probeJervcodeInstallation,
   probeLaunchTargetVersion: () => probeLaunchTargetVersion,
-  progressiveRow: () => progressiveRow,
   readLaunchTarget: () => readLaunchTarget,
   readPending: () => readPending,
-  receiptText: () => receiptText,
   reconcile: () => reconcile,
   reconcileCursorUserHooks: () => reconcileCursorUserHooks,
   releaseSharedDocLock: () => releaseSharedDocLock,
   reportCounts: () => reportCounts,
-  reportFooterLines: () => reportFooterLines,
   retiredSurfaces: () => retiredSurfaces,
   retryHint: () => retryHint,
+  runMaintenance: () => runMaintenance2,
   schedulePendingWatcher: () => schedulePendingWatcher,
   schedulerStatus: () => schedulerStatus,
   sharedDocLockPath: () => sharedDocLockPath,
@@ -89,40 +78,48 @@ __export(index_exports, {
   systemdServiceUnit: () => systemdServiceUnit,
   systemdTimerUnit: () => systemdTimerUnit,
   taskXml: () => taskXml,
-  updateHeader: () => updateHeader,
-  updaterFace: () => updaterFace,
   watcherLockPath: () => watcherLockPath,
   withSharedDocLock: () => withSharedDocLock,
-  wrapWords: () => wrapWords2,
   writeLaunchTarget: () => writeLaunchTarget,
   writePending: () => writePending
 });
 module.exports = __toCommonJS(index_exports);
 var import_node_child_process9 = require("node:child_process");
-var import_node_fs18 = require("node:fs");
+var import_node_fs22 = require("node:fs");
 var import_node_path13 = require("node:path");
 
-// node_modules/@mutmutco/installer-face/dist/index.js
+// ../installer/face/src/face.ts
+var import_node_fs = require("node:fs");
+
+// ../installer/face/src/products.ts
 var PRODUCTS = Object.freeze({
   "mm-strategy": Object.freeze({
     name: "MM Strategy",
+    installWarm: "Welcome. Let's get you ready.",
     accent: "38;2;249;115;22",
-    warm: "Welcome. Let's set up MM Strategy \u2014 about a minute."
+    warm: "Welcome back. Checking for updates...",
+    doctor: "mm-strategy doctor"
   }),
   "mmi-hub": Object.freeze({
     name: "mmi-hub",
+    installWarm: "Welcome. Let's get you ready.",
     accent: "38;2;125;211;252",
-    warm: "Welcome back. Checking your surfaces\u2026"
+    warm: "Welcome back. Checking for updates...",
+    doctor: "mmi doctor"
   }),
   "jerv-hub": Object.freeze({
     name: "jerv-hub",
+    installWarm: "Welcome. Let's get you ready.",
     accent: "38;2;248;113;113",
-    warm: "Welcome back. Checking your surfaces\u2026"
+    warm: "Welcome back. Checking for updates...",
+    doctor: "jerv doctor"
   }),
   jervcode: Object.freeze({
     name: "JervCode",
+    installWarm: "Welcome. Let's get you ready.",
     accent: "38;2;192;132;252",
-    warm: "Welcome back. Keeping JervCode current\u2026"
+    warm: "Welcome back. Checking for updates...",
+    doctor: "jervcode doctor"
   })
 });
 function identityFor(product) {
@@ -132,7 +129,10 @@ function identityFor(product) {
   }
   return identity;
 }
+
+// ../installer/face/src/face.ts
 var GLYPH = Object.freeze({
+  clock: "\u23F0",
   diamond: "\u25C6",
   hollow: "\u25C7",
   bar: "\u2502",
@@ -156,6 +156,9 @@ var ANSI = /\u001b\[[0-9;]*m/g;
 function visibleWidth(text) {
   return [...String(text).replace(ANSI, "")].length;
 }
+function stripColor(text) {
+  return String(text).replace(ANSI, "");
+}
 function faceWidth(columns) {
   const raw = Number(columns);
   return Math.max(40, Math.min(100, Number.isFinite(raw) && raw > 0 ? raw : 100));
@@ -184,7 +187,14 @@ function wrapWords(text, width) {
   if (line) lines.push(line);
   return lines.length ? lines : [""];
 }
-function createFace({ product, color = false, columns, env = process.env }) {
+var PROGRESS_PROTOCOL = 1;
+function readProgressFd(env) {
+  const fd = Number.parseInt(String(env.MM_PROGRESS_FD ?? ""), 10);
+  if (!Number.isInteger(fd) || fd <= 0) return null;
+  const protocol = Number.parseInt(String(env.MM_PROGRESS_PROTOCOL ?? PROGRESS_PROTOCOL), 10);
+  return protocol === PROGRESS_PROTOCOL ? fd : null;
+}
+function createFace({ product, color = false, columns, env = process.env, operation }) {
   const identity = identityFor(product);
   const width = faceWidth(columns);
   const paint = (sgr, text) => color ? `\x1B[${sgr}m${text}\x1B[0m` : String(text);
@@ -192,28 +202,49 @@ function createFace({ product, color = false, columns, env = process.env }) {
   const indent = " ".repeat(TITLE_COLUMN - 1);
   const continuedPhases = new Set((env.MM_FACE_CONTINUES ?? "").split(",").map((phase) => phase.trim()).filter(Boolean));
   const continuesFace = continuedPhases.size > 0;
-  const welcome = () => continuesFace ? [] : [
+  const nested = env.MM_OUTER_CONSOLE === "1";
+  const progressFd = readProgressFd(env);
+  const progressFile = env.MM_PROGRESS_PROTOCOL === "1" ? env.MM_PROGRESS_FILE : void 0;
+  const emitMilestone = (title, measure, kind) => {
+    if (progressFd === null && !progressFile) return false;
+    const record = { v: PROGRESS_PROTOCOL, step: stripColor(title), state: kind };
+    if (typeof measure === "number") record.ms = Math.max(0, Math.round(measure * 1e3));
+    if (kind === "running" && typeof measure === "string") record.measure = measure;
+    try {
+      if (progressFile) (0, import_node_fs.appendFileSync)(progressFile, `${JSON.stringify(record)}
+`);
+      else (0, import_node_fs.writeSync)(progressFd, `${JSON.stringify(record)}
+`);
+      return true;
+    } catch {
+      return false;
+    }
+  };
+  const welcome = () => continuesFace || nested ? [] : [
     `${paint(identity.accent, GLYPH.diamond)}  ${paint(identity.accent, identity.name)} \u2014 Mutatis Mutandis`,
     bar(),
-    `${bar()}  ${identity.warm}`,
+    `${bar()}  ${operation === "install" ? identity.installWarm : identity.warm}`,
     bar()
   ];
   const continues = (phase, kind = "ok") => {
     const inherited = continuedPhases.delete(String(phase).trim());
     return kind === "fail" ? false : inherited;
   };
-  const step = (title, seconds = null, kind = "ok") => {
-    const glyph = kind === "fail" ? paint(identity.accent, GLYPH.cross) : kind === "note" ? paint(PALETTE.muted, GLYPH.dot) : paint(PALETTE.green, GLYPH.check);
-    const time = seconds === null || seconds === void 0 ? "" : paint(PALETTE.muted, `${Math.max(0, Math.round(seconds))}s`);
+  const step = (title, measure = null, kind = "ok") => {
+    if (emitMilestone(title, measure, kind)) return "";
+    const glyph = title === "Armed hourly updates" && kind === "ok" ? GLYPH.clock : kind === "fail" ? paint(identity.accent, GLYPH.cross) : kind === "note" ? paint(PALETTE.muted, GLYPH.dot) : paint(PALETTE.green, GLYPH.check);
+    const measured = measure === null || measure === void 0 ? "" : paint(PALETTE.muted, typeof measure === "number" ? `${Math.max(0, Math.round(measure))}s` : String(measure).trim());
+    const time = measured;
     const column = Math.min(44, Math.max(0, width - 8));
-    const reserved = time ? 6 : 0;
+    const reserved = time ? Math.max(6, visibleWidth(time) + 2) : 0;
     const [first, ...rest] = wrapWords(title, width - TITLE_COLUMN - reserved);
     const head = `${bar()}  ${glyph}  ${first}`;
     const pad = Math.max(1, column - visibleWidth(head));
     return [time ? `${head}${" ".repeat(pad)}${time}` : head, ...rest.map((line) => `${bar()}${indent}${line}`)].join("\n");
   };
-  const relay = (text) => String(text).split("\n").map((line) => line.trim() === "" ? bar() : `${bar()}${indent}${line}`).join("\n");
-  const receipt = (lines) => {
+  const relay = (text) => String(text).replace(/\r?\n$/, "").split(/\r?\n/).flatMap((line) => line.trim() === "" ? [bar()] : (visibleWidth(line) <= width - TITLE_COLUMN ? [line] : wrapWords(line, width - TITLE_COLUMN)).map((part) => `${bar()}${indent}${part}`)).join("\n");
+  const receipt = (lines, { ready = true } = {}) => {
+    if (ready && nested) return [];
     const body = (Array.isArray(lines) ? lines : String(lines).split("\n")).flatMap((raw) => {
       const line = String(raw);
       if (visibleWidth(line) <= width - 6) return [line];
@@ -229,87 +260,800 @@ function createFace({ product, color = false, columns, env = process.env }) {
       frame(GLYPH.boxBottom, GLYPH.boxBottomEnd)
     ];
   };
-  const signOff = () => `${paint(identity.accent, GLYPH.diamond)}  ${paint(identity.accent, `${identity.name} \xB7 Mutatis Mutandis`)}`;
+  const outcome = (changed, options = {}) => {
+    const fact = String(changed ?? "").trim();
+    if (!fact) {
+      throw new Error(`installer face: the receipt must say what changed \u2014 pass the one measured fact this run produced, such as "Updated 2 of 7 surfaces to 4.4.10." (${identity.name})`);
+    }
+    return receipt([
+      `${GLYPH.check}  ${identity.name} is ready.`,
+      fact,
+      `Check health any time:  ${identity.doctor}`
+    ], options);
+  };
+  const signOff = () => nested ? "" : `${paint(identity.accent, GLYPH.diamond)}  ${paint(identity.accent, `${identity.name} \xB7 Mutatis Mutandis`)}`;
   const refusal = (message3) => `${bar()}  ${paint(identity.accent, GLYPH.cross)}  ${message3}`;
-  return { identity, width, welcome, continues, step, relay, receipt, signOff, refusal, paint };
+  return { identity, width, nested, emitsProgress: progressFd !== null || Boolean(progressFile), welcome, continues, step, progress: (title, measure = null) => emitMilestone(title, measure, "running"), relay, receipt, outcome, signOff, refusal, paint };
 }
+
+// ../installer/face/src/shell.ts
 var RELAY_INDENT = " ".repeat(TITLE_COLUMN - 1);
-var SEPARATOR = "\xB7";
-var subjectOf = (row) => row.aspect ? `${row.surface} ${row.aspect}` : row.surface;
-var groupKey = (row) => `${subjectOf(row)}\0${row.state}\0${row.mark ?? ""}\0${row.note ?? ""}`;
-function renderRows(face, rows) {
-  if (rows.length === 0) return [];
-  const groups = /* @__PURE__ */ new Map();
-  for (const row of rows) {
-    const key = groupKey(row);
-    const found = groups.get(key);
-    if (found) {
-      if (row.instance) found.instances.push(row.instance);
-    } else {
-      groups.set(key, { row, instances: row.instance ? [row.instance] : [] });
-    }
-  }
-  const subjects = [...groups.values()].map(({ row, instances }) => instances.length > 1 ? subjectOf(row) : [subjectOf(row), instances[0]].filter(Boolean).join(` ${SEPARATOR} `));
-  const column = Math.min(Math.max(...subjects.map(visibleWidth)), Math.max(12, face.width - 24));
-  const lines = [];
-  for (const [index, { row, instances }] of [...groups.values()].entries()) {
-    const subject = subjects[index];
-    const tail2 = instances.length > 1 ? `${row.state} ${SEPARATOR} ${instances.join(", ")}` : row.state;
-    const body = `${clip(subject, column).padEnd(column)}  ${row.mark ? `${markGlyph(face, row.mark)}  ` : ""}${tail2}`;
-    lines.push(...face.relay(body).split("\n"));
-    if (row.note) {
-      for (const part of wrapWords(row.note, Math.max(16, face.width - TITLE_COLUMN))) {
-        lines.push(...face.relay(part).split("\n"));
-      }
-    }
+
+// ../installer/face/src/spinner.ts
+var import_node_fs2 = require("node:fs");
+var import_node_worker_threads = require("node:worker_threads");
+var FRAMES = ["\u25D2", "\u25D0", "\u25D3", "\u25D1"];
+var WORKER_SOURCE = `
+const { parentPort, workerData } = require('node:worker_threads');
+const { writeSync, appendFileSync } = require('node:fs');
+const control = new Int32Array(workerData.control);
+let frames = workerData.frames, frame = workerData.frame;
+function draw() {
+  if (Atomics.compareExchange(control, 1, 0, 1) !== 0) return;
+  try {
+    if (Atomics.load(control, 0) || Atomics.load(control, 2) || !frames.length) return;
+    const text = frames[frame++ % frames.length].replace('__elapsed__', Math.floor((Date.now() - workerData.started) / 1000) + 's');
+    writeSync(2, text);
+    if (workerData.transcriptPath) appendFileSync(workerData.transcriptPath, JSON.stringify({ channel: 'spinner', text }) + '\\n');
+  } finally {
+    Atomics.store(control, 1, 0);
+    Atomics.notify(control, 1);
   }
-  return lines;
-}
-function markGlyph(face, kind) {
-  const glyph = kind === "fail" ? GLYPH.cross : kind === "note" ? GLYPH.hollow : GLYPH.check;
-  return face.paint(kind === "fail" ? face.identity.accent : kind === "note" ? "38;2;150;150;150" : "38;2;31;209;138", glyph);
-}
-function clip(text, width) {
-  if (visibleWidth(text) <= width) return text;
-  return `\u2026${[...text].slice(-(width - 1)).join("")}`;
 }
-var FRAMES = ["\u25D2", "\u25D0", "\u25D3", "\u25D1"];
-function createSpinner(face, { animate, stream = process.stderr, intervalMs = 90 }) {
+parentPort.on('message', (next) => {
+  if (Atomics.load(control, 2)) return;
+  frames = next.frames;
+  frame = next.frame;
+});
+setInterval(draw, workerData.intervalMs);
+`;
+function createSpinner(face, { animate, stream, intervalMs = 90, transcriptPath }) {
+  animate = animate && !face.nested && !face.emitsProgress;
   let timer = null;
-  let text = "";
+  let worker = null;
+  let control = null;
+  let frames = [];
   let frame = 0;
-  const clear = () => {
-    if (animate) stream.write("\r\x1B[2K");
+  let started = 0;
+  let suspended = false;
+  const write = (text) => {
+    if (stream) stream.write(text);
+    else {
+      (0, import_node_fs2.writeSync)(2, text);
+      if (transcriptPath) (0, import_node_fs2.appendFileSync)(transcriptPath, `${JSON.stringify({ channel: "spinner", text })}
+`);
+    }
+  };
+  const render = (text, measure) => {
+    const line = face.step(text, measure ?? "__elapsed__", "note").split("\n")[0];
+    frames = line ? FRAMES.map((glyph) => `\r\x1B[2K${line.replace(GLYPH.dot, glyph)}`) : [];
   };
   const draw = () => {
-    if (!animate) return;
-    const line = face.step(text, null, "note").split("\n")[0].replace(GLYPH.dot, FRAMES[frame % FRAMES.length]);
-    stream.write(`\r\x1B[2K${line}`);
-    frame += 1;
+    if (animate && !suspended && frames.length) write(frames[frame++ % frames.length].replace("__elapsed__", `${Math.floor((Date.now() - started) / 1e3)}s`));
+  };
+  const pause = () => {
+    if (!control) return;
+    Atomics.store(control, 0, 1);
+    while (Atomics.load(control, 1)) Atomics.wait(control, 1, 1);
+  };
+  const halt = () => {
+    if (timer) clearInterval(timer);
+    timer = null;
+    if (control) Atomics.store(control, 2, 1);
+    pause();
+    if (worker) void worker.terminate();
+    worker = null;
+    control = null;
   };
   return {
-    start(next) {
-      text = next;
+    start(text, measure = null) {
+      if (!animate) return;
+      halt();
+      suspended = false;
+      started = Date.now();
+      render(text, measure);
       frame = 0;
       draw();
-      if (animate && !timer) timer = setInterval(draw, intervalMs).unref();
+      if (!frames.length) return;
+      if (stream) timer = setInterval(draw, intervalMs).unref();
+      else {
+        control = new Int32Array(new SharedArrayBuffer(12));
+        try {
+          worker = new import_node_worker_threads.Worker(WORKER_SOURCE, { eval: true, workerData: {
+            control: control.buffer,
+            frames,
+            frame,
+            intervalMs,
+            transcriptPath,
+            started
+          } });
+          const active = worker;
+          worker.on("error", () => {
+            if (worker === active) halt();
+          });
+          worker.unref();
+        } catch {
+          halt();
+        }
+      }
     },
-    say(next) {
-      text = next;
+    say(text, measure = null) {
+      if (!animate) return;
+      pause();
+      render(text, measure);
       draw();
+      worker?.postMessage({ frames, frame });
+      if (control && !suspended) Atomics.store(control, 0, 0);
+    },
+    pause() {
+      if (suspended) return;
+      suspended = true;
+      pause();
+      if (animate && frames.length) write("\r\x1B[2K");
+    },
+    resume() {
+      suspended = false;
+      if (control) Atomics.store(control, 0, 0);
+      if (timer || worker) draw();
     },
     stop() {
-      if (timer) clearInterval(timer);
-      timer = null;
-      clear();
+      halt();
+      frames = [];
+      if (animate) write("\r\x1B[2K");
     }
   };
 }
 var SPINNER_FRAMES = Object.freeze([...FRAMES]);
+
+// ../installer/face/src/conformance.ts
 var ALLOWED = new Set(Object.values(GLYPH));
+var FORBIDDEN = /* @__PURE__ */ new Map([
+  ["\u2713", "U+2713 is not in the guidebook glyph set; the check is U+2714"],
+  ["\u2717", "U+2717 is not in the guidebook glyph set; the cross is U+2716"],
+  ["\u21BB", "U+21BB is not in the guidebook glyph set; a retry uses the dot U+25CF"],
+  ["\u250C", "U+250C is clack's intro corner; the welcome opens with the branded diamond"],
+  ["\u251C", "U+251C is clack's note frame; a receipt box pairs U+256D/U+256E over U+2570/U+256F"],
+  ["\u2514", "U+2514 is clack's outro corner; the sign-off carries the diamond"]
+]);
+var EMOJI = /[\u{1f300}-\u{1faff}\u{2600}-\u{27bf}]/u;
+function fail(rule, detail) {
+  throw new Error(`installer face: ${rule} \u2014 ${detail}`);
+}
+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 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;
+    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) {
+      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`)));
+  if (greetings.length > 1) fail("R8 one welcome per run", "duplicate product greeting");
+  if (plain.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);
+    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));
+    if (boxAt !== -1) {
+      const headline = plain.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) {
+      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)}`);
+    }
+    for (const line of rendered) {
+      if (line.includes("\x1B[")) fail("non-TTY lane is plain", `a piped run emitted colour in ${JSON.stringify(line)}`);
+    }
+    return;
+  }
+  for (const line of plain) {
+    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) {
+    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 [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));
+  if (top !== -1) {
+    const bottom = plain.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 (widths.size !== 1) fail("R5 receipt frame", `the box is ragged: widths ${[...widths].join(", ")}`);
+    const rows = plain.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()))}`);
+      }
+      const changed = rows[1].replace(GLYPH.bar, "").trim();
+      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 welcomeEnd = opensWithWelcome ? 4 : 0;
+  for (const [index, line] of plain.entries()) {
+    if (index < welcomeEnd || inReceipt(index)) continue;
+    if (!line.startsWith(GLYPH.bar) || line.trim() === GLYPH.bar) continue;
+    const after = [...line.slice(1)];
+    const at = after.findIndex((char) => char !== " ");
+    const edge = at + 2;
+    if (edge === 4 && ALLOWED.has(after[at])) continue;
+    if (edge !== TITLE_COLUMN + 1) {
+      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) {
+    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)) {
+    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) {
+    if (visibleWidth(line) > width) {
+      fail("width cap", `a line is ${visibleWidth(line)} columns wide, cap ${width}: ${JSON.stringify(line)}`);
+    }
+  }
+  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));
+    if (!warm) fail("welcome is the product table's", `the warm line for ${options.product} is missing or reworded`);
+  }
+  const painted = rendered.join("\n");
+  if (painted.includes("\x1B[")) {
+    if (!painted.includes(identity.accent) && !painted.includes(PALETTE.muted)) {
+      fail("accent", `${options.product} rendered colour that is neither its accent nor a neutral token`);
+    }
+  }
+}
+
+// ../installer/face/src/run.ts
+var import_node_fs4 = require("node:fs");
+
+// ../installer/face/src/outcome.ts
+var import_node_fs3 = require("node:fs");
+var counts = ["total", "updated", "failed"];
+var strings = ["version", "retry", "detail", "logPath"];
+var flags = ["dryRun", "installed", "deferred", "operationFailed"];
+function validateInstallerOutcome(value) {
+  const invalid = () => {
+    throw new Error("installer outcome: invalid child result");
+  };
+  if (!value || typeof value !== "object" || Array.isArray(value)) return invalid();
+  const facts = value;
+  const allowed = [...counts, ...strings, ...flags, "rollback", "logState"];
+  if (Object.keys(facts).some((key) => !allowed.includes(key))) return invalid();
+  for (const key of counts) if (!Number.isSafeInteger(facts[key]) || facts[key] < 0) return invalid();
+  if (facts.updated + facts.failed > facts.total) return invalid();
+  for (const key of strings) if (facts[key] !== void 0 && (typeof facts[key] !== "string" || facts[key].length > 4096)) return invalid();
+  for (const key of flags) if (facts[key] !== void 0 && typeof facts[key] !== "boolean") return invalid();
+  if (facts.rollback !== void 0 && !["completed", "partial", "not-needed", "unknown"].includes(facts.rollback)) return invalid();
+  if (facts.logState !== void 0 && !["unavailable", "omitted"].includes(facts.logState)) return invalid();
+  if (facts.logPath !== void 0 && (!facts.logPath.trim() || /[\x00-\x1f\x7f]/u.test(facts.logPath))) return invalid();
+  return { ...facts };
+}
+function writeInstallerOutcome(path, value) {
+  (0, import_node_fs3.writeFileSync)(path, JSON.stringify(validateInstallerOutcome(value)), { encoding: "utf8", mode: 384 });
+}
+
+// ../installer/face/src/run.ts
+function validateInstallerProduct(value) {
+  const fail2 = (field) => {
+    throw new Error(`installer product: invalid ${field}`);
+  };
+  if (!value || typeof value !== "object" || Array.isArray(value)) return fail2("declaration");
+  const input = value;
+  const text = (value2, field) => typeof value2 === "string" && value2.trim() && !/[\r\n\x00-\x1f]/u.test(value2) ? value2 : fail2(field);
+  const key = text(input.product, "product");
+  const product = { mmi: "mmi-hub", jerv: "jerv-hub" }[key] ?? key;
+  const identity = identityFor(product);
+  const gate = text(input.gate, "gate");
+  let gateUrl;
+  try {
+    gateUrl = new URL(gate);
+  } catch {
+    return fail2("gate");
+  }
+  if (!["https:", "http:"].includes(gateUrl.protocol) || gateUrl.username || gateUrl.password) return fail2("gate");
+  const doctor = text(input.doctor, "doctor");
+  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");
+    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 (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 };
+}
+var PHASES = {
+  preflight: ["Checking prerequisites", "Checked prerequisites"],
+  resolve: ["Resolving the release", "Resolved the release"],
+  download: ["Downloading the payload", "Downloaded the payload"],
+  "sign-in": ["Signing in", "Signed in"],
+  check: ["Checking surfaces", "Checked surfaces"],
+  arm: ["Scheduling updates", "Armed hourly updates"],
+  "verify-release": ["Checking the release version", "Verified the release version"],
+  verify: ["Verifying the payload", "Verified the payload"],
+  install: ["Installing the product", "Installed the product"],
+  configure: ["Configuring the product", "Configured the product"],
+  activate: ["Activating surfaces", "Activated surfaces"],
+  doctor: ["Checking health", "Checked health"],
+  rollback: ["Restoring the previous version", "Restored the previous version"]
+};
+function createInstallerRun(value, options = {}) {
+  const declaration = 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,
+    columns: options.columns,
+    env,
+    color: tty && options.color !== false && env.NO_COLOR === void 0 && env.TERM !== "dumb"
+  });
+  const errors = [];
+  const write = options.write ? (text, channel) => {
+    try {
+      options.write(text, channel);
+    } catch (error) {
+      errors.push(`installer output observer: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  } : (text, channel) => {
+    (channel === "stdout" ? process.stdout : process.stderr).write(text);
+  };
+  const emit = (text, channel = "stdout", recorded = text) => {
+    if (!text) return;
+    write(text, channel);
+    if (env.MM_FACE_TRANSCRIPT) {
+      (0, import_node_fs4.appendFileSync)(env.MM_FACE_TRANSCRIPT, `${JSON.stringify({ channel, text: recorded })}
+`, "utf8");
+    }
+  };
+  const lines = (rows, channel = "stdout") => {
+    for (const row of rows.flatMap((row2) => row2.split("\n"))) if (row) emit(`${row}
+`, channel);
+  };
+  const spinner = createSpinner(face, {
+    animate: tty && env.TERM !== "dumb" && (options.animate ?? Boolean(process.stderr.isTTY)),
+    ...options.write ? { stream: { write: (text) => {
+      emit(String(text), "spinner");
+      return true;
+    } } } : { transcriptPath: env.MM_FACE_TRANSCRIPT }
+  });
+  let activeTitle;
+  let chunkOpen = false;
+  let chunkChannel = "stdout";
+  let chunkColumn = 0;
+  const trailingCR = /* @__PURE__ */ new Set();
+  let deferredActivity;
+  const closeChunk = () => {
+    if (chunkOpen) emit("\n", chunkChannel);
+    chunkOpen = false;
+    chunkColumn = 0;
+  };
+  let started = false;
+  let finished = false;
+  const start = () => {
+    if (started || finished) return;
+    started = true;
+    if (options.quiet) return;
+    const welcome = face.welcome();
+    if (tty) lines(welcome);
+    else if (welcome.length) {
+      const warm = options.operation === "install" ? face.identity.installWarm : face.identity.warm;
+      lines([`${face.identity.name} - Mutatis Mutandis`, warm.replaceAll("\u2014", "-").replaceAll("\u2026", "...")]);
+    }
+  };
+  const durable = (title, measure, kind) => {
+    closeChunk();
+    activeTitle = void 0;
+    deferredActivity = void 0;
+    spinner.stop();
+    const rendered = face.step(title, measure, kind);
+    if (rendered) lines([tty ? rendered : `${kind === "fail" ? "Failed: " : ""}${title}${measure === null ? "" : ` (${typeof measure === "number" ? `${Math.max(0, Math.round(measure))}s` : measure})`}`]);
+  };
+  const run = {
+    get errors() {
+      return [...errors];
+    },
+    start,
+    phase(id, facts = {}) {
+      if (finished) throw new Error("installer run already finished");
+      if (!Object.hasOwn(PHASES, id)) throw new Error("installer run: unknown phase");
+      start();
+      const state = facts.state ?? "ok";
+      const title = PHASES[id][state === "ok" ? 1 : 0];
+      if (state === "running") {
+        if (face.progress(title, facts.measure ?? null)) return;
+        if (activeTitle === title) spinner.say(title, facts.measure ?? null);
+        else {
+          activeTitle = title;
+          spinner.start(title, facts.measure ?? null);
+        }
+        return;
+      }
+      if (!face.continues(id, state)) durable(title, facts.seconds ?? facts.measure ?? null, state);
+      if (facts.detail) run.relay(facts.detail);
+    },
+    surface(facts) {
+      if (finished) throw new Error("installer run already finished");
+      const surface = declaration.surfaces.find((surface2) => surface2.id === facts.id);
+      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];
+      if (!status) throw new Error("installer run: unknown surface state");
+      const separator = tty ? "\xB7" : "-";
+      const activation = facts.state === "updated" && surface.activation ? ` ${separator} ${surface.activation}` : "";
+      const completed = ["updated", "current", "kept", "skipped"].includes(facts.state);
+      durable(`${facts.id}${versions} ${separator} ${status}${activation}`, completed ? facts.seconds ?? null : null, facts.state === "failed" ? "fail" : facts.state === "updated" ? "ok" : "note");
+      if (facts.detail) run.relay(facts.detail);
+    },
+    milestone({ step, state, ms, measure }) {
+      start();
+      if (state === "running") {
+        if (chunkOpen) {
+          deferredActivity = { title: step, measure: measure ?? null };
+          return;
+        }
+        if (activeTitle === step) spinner.say(step, measure ?? null);
+        else {
+          activeTitle = step;
+          spinner.start(step, measure ?? null);
+        }
+        return;
+      }
+      durable(step, ms === void 0 ? null : ms / 1e3, state);
+    },
+    signIn({ url, code }) {
+      start();
+      spinner.stop();
+      for (const text of [`Open ${url}`, `Enter code: ${code}`]) {
+        const rendered = `${tty ? face.relay(text) : text}
+`;
+        emit(rendered, "stdout", rendered.replace(code, "[redacted]"));
+      }
+    },
+    // Only pass safe diagnostic text, never authentication output or credentials.
+    relay(text, channel = "stdout", record = true) {
+      closeChunk();
+      spinner.pause();
+      const rendered = tty ? face.relay(text) : stripColor(text);
+      for (const row of rendered.split("\n")) if (row) {
+        emit(`${row}
+`, channel, record ? `${row}
+` : `${tty ? face.relay("[external output omitted]") : "[external output omitted]"}
+`);
+      }
+      spinner.resume();
+    },
+    relayChunk(text, channel = "stdout") {
+      spinner.pause();
+      if (chunkOpen && chunkChannel !== channel) closeChunk();
+      chunkChannel = channel;
+      if (trailingCR.delete(channel) && text.startsWith("\n")) text = text.slice(1);
+      if (text.endsWith("\r")) trailingCR.add(channel);
+      const parts = text.replace(/\r\n|\r/g, "\n").split("\n");
+      for (let i = 0; i < parts.length; i++) {
+        const characters = [...stripColor(parts[i])];
+        while (characters.length) {
+          if (tty && chunkColumn >= face.width - 6) closeChunk();
+          const part = characters.splice(0, tty ? face.width - 6 - chunkColumn : characters.length).join("");
+          emit(tty && !chunkOpen ? face.relay(part) : part, channel, chunkOpen ? "" : tty ? face.relay("[external output omitted]") : "[external output omitted]");
+          chunkColumn += [...part].length;
+          chunkOpen = true;
+        }
+        if (i < parts.length - 1) {
+          emit("\n", channel);
+          chunkOpen = false;
+          chunkColumn = 0;
+        }
+      }
+      if (!chunkOpen) {
+        if (deferredActivity) {
+          activeTitle = deferredActivity.title;
+          spinner.start(deferredActivity.title, deferredActivity.measure);
+          deferredActivity = void 0;
+        } else spinner.resume();
+      }
+    },
+    cancel() {
+      if (finished) return;
+      if (env.MM_INSTALLER_OUTCOME_FILE) writeInstallerOutcome(
+        env.MM_INSTALLER_OUTCOME_FILE,
+        { total: 0, updated: 0, failed: 0, deferred: true, detail: "Operation cancelled." }
+      );
+      start();
+      closeChunk();
+      activeTitle = void 0;
+      spinner.stop();
+      finished = true;
+      if (!face.nested || !env.MM_INSTALLER_OUTCOME_FILE) {
+        lines(tty ? face.receipt(["Operation cancelled."], { ready: false }) : ["Operation cancelled."]);
+      }
+      if (tty) lines([face.signOff()]);
+    },
+    finish(facts) {
+      if (finished) return;
+      validateInstallerOutcome(facts);
+      if (env.MM_INSTALLER_OUTCOME_FILE) writeInstallerOutcome(env.MM_INSTALLER_OUTCOME_FILE, facts);
+      start();
+      closeChunk();
+      activeTitle = void 0;
+      spinner.stop();
+      finished = true;
+      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 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."}`,
+        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}`
+      ];
+      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, "")));
+      }
+      if (tty) lines([face.signOff()]);
+    },
+    stop() {
+      closeChunk();
+      activeTitle = void 0;
+      spinner.stop();
+    }
+  };
+  return run;
+}
+
+// ../installer/face/src/maintenance.ts
+async function runMaintenance(product, args, dependencies) {
+  const json = args.includes("--json");
+  const quiet = args.includes("--quiet");
+  const dryRun = args.includes("--dry-run");
+  const installed = args.includes("install");
+  const render = dependencies.render;
+  const env = render?.env ?? process.env;
+  const tty = render?.tty ?? Boolean(process.stdout.isTTY);
+  const run = json ? null : dependencies.run ?? createInstallerRun(product, {
+    ...render,
+    tty,
+    env,
+    color: tty && render?.color !== false && !args.includes("--no-color") && env.TERM !== "dumb",
+    columns: render?.columns ?? process.stdout.columns,
+    dryRun,
+    quiet,
+    operation: installed ? "install" : "update"
+  });
+  if (!quiet) run?.start();
+  let active;
+  let activeFacts;
+  let handedOff;
+  const shown = new Set((env.MM_FACE_CONTINUES ?? "").split(",").map((value) => value.trim()).filter(Boolean));
+  if (!quiet && !json) shown.add("welcome");
+  let phaseFailed = false;
+  let armFailed = false;
+  let knownFailure;
+  const phaseStarted = /* @__PURE__ */ new Map();
+  const phase = (event) => {
+    if (handedOff !== void 0) return;
+    if (event.state === "fail") phaseFailed = true;
+    const started = phaseStarted.get(event.id);
+    if (event.state === "running") {
+      if (started === void 0) phaseStarted.set(event.id, Date.now());
+      active = event.id;
+    } else {
+      phaseStarted.delete(event.id);
+      if (active === event.id) active = void 0;
+    }
+    if (!quiet && event.state === "running" && event.detail) run?.relay(event.detail);
+    const measured = event.measured;
+    const measure = measured?.kind === "percent" ? `${Math.max(0, Math.min(100, Math.round(measured.percent)))}%` : measured?.kind === "bytes" ? `${measured.done}/${measured.total} B` : measured?.kind === "count" ? `${measured.done}${measured.total === void 0 ? "" : `/${measured.total}`}` : event.measure;
+    const facts = {
+      state: event.state,
+      detail: event.detail,
+      measure,
+      ...event.state !== "running" && started !== void 0 ? { seconds: (Date.now() - started) / 1e3 } : {}
+    };
+    if (event.state === "running") activeFacts = facts;
+    if (!quiet) {
+      run?.phase(event.id, facts);
+      if (event.state === "ok" && run) shown.add(event.id);
+    }
+  };
+  const pending = [];
+  let streaming = false;
+  const emitArm = (arm) => {
+    if (quiet) return;
+    run?.surface({
+      id: arm.surface,
+      from: arm.from ?? void 0,
+      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)
+    });
+  };
+  const writeJson = (summary, schedule) => {
+    process.stdout.write(JSON.stringify(dependencies.jsonResult ? dependencies.jsonResult(summary, schedule) : installed ? { convergence: summary, autoupdate: schedule } : summary, null, 2) + "\n");
+  };
+  try {
+    const summary = await dependencies.engine({
+      dryRun,
+      withCustody: async (operation) => {
+        if (handedOff !== void 0) throw new Error("installer terminal ownership already transferred");
+        run?.stop();
+        const result = await operation({ faceContinues: [...shown] });
+        if (result.kind === "reexec") {
+          if (!Number.isSafeInteger(result.code) || result.code < 0) throw new Error("invalid handoff exit code");
+          handedOff = result.code;
+        } else if (result.kind === "resume") {
+          if (!quiet && active) run?.phase(active, activeFacts);
+        } else throw new Error("invalid terminal custody result");
+        return result;
+      },
+      shippedTarget: installed ? dependencies.shippedTarget : void 0,
+      narrate: !quiet && !json && args.includes("--verbose") ? (text) => {
+        if (handedOff === void 0) run?.relay(text, "stderr", false);
+      } : void 0,
+      relay: (text, channel = "stdout", record = false) => {
+        if (handedOff === void 0) run?.relay(text, channel, record);
+      },
+      onTargetResolved: (target) => phase({ id: "verify-release", detail: target, state: "ok" }),
+      onPhase: () => {
+        if (!quiet && handedOff === void 0) run?.phase("check", { state: "running" });
+      },
+      onPhaseEvent: phase,
+      onArm: (arm) => {
+        if (handedOff !== void 0) return;
+        if (arm.verdict === "fail") armFailed = true;
+        pending.push(arm);
+        if (pending.length > 1) streaming = true;
+        if (streaming) for (const result of pending.splice(0)) emitArm(result);
+      }
+    });
+    if (handedOff !== void 0) return handedOff;
+    if (summary.reexec) {
+      if (!dependencies.handOff) {
+        knownFailure = "The updated version needs a handoff, but no handoff is configured.";
+        throw new Error(knownFailure);
+      }
+      run?.stop();
+      knownFailure = "The updated updater could not launch.";
+      return await dependencies.handOff(summary.reexec, args, { ...process.env, MM_FACE_CONTINUES: "welcome" });
+    }
+    const counts2 = dependencies.counts(summary);
+    validateInstallerOutcome({ total: counts2.total, updated: counts2.updated, failed: counts2.failed });
+    if (!Number.isSafeInteger(counts2.retry) || counts2.retry < 0 || counts2.retry > counts2.total) throw new Error("invalid retry count");
+    if (summary.cancelled && summary.exit === 0 && !phaseFailed && !armFailed && counts2.failed === 0 && counts2.updated === 0) {
+      if (json) writeJson(summary, null);
+      else run?.cancel();
+      return 0;
+    }
+    for (const arm of pending) 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;
+    if (installed && !dryRun && dependencies.schedule) {
+      phase({ id: "arm", state: "running" });
+      schedule = dependencies.schedule();
+      if (schedule) phase({ id: "arm", state: schedule.ok ? "ok" : "fail", detail: schedule.ok ? void 0 : schedule.detail });
+    }
+    const failed = phaseFailed || armFailed || counts2.failed > 0 || Boolean(schedule && !schedule.ok);
+    const exit = Math.max(summary.exit, failed ? 1 : 0);
+    if (json) {
+      writeJson({ ...summary, exit }, schedule);
+    } else {
+      run.finish({
+        version: summary.target ?? void 0,
+        total: counts2.total,
+        updated: counts2.updated,
+        failed: counts2.failed,
+        operationFailed: exit !== 0,
+        deferred: !failed && Boolean(counts2.retry || waiting.length || summary.deferred || summary.cancelled || !summary.target),
+        dryRun,
+        installed,
+        detail: schedule && !schedule.ok ? schedule.detail : summary.detail ?? (summary.cancelled ? "Operation cancelled." : void 0),
+        retry: summary.retry,
+        rollback: summary.rollback,
+        logPath: summary.logPath,
+        logState: summary.logState
+      });
+    }
+    return exit;
+  } catch (error) {
+    if (handedOff !== void 0) throw error;
+    let detail = knownFailure ?? (active === "sign-in" ? "Sign-in did not complete." : installed ? "Installation did not complete." : "Update did not complete.");
+    if (!knownFailure && dependencies.safeErrorDetail) {
+      try {
+        detail = dependencies.safeErrorDetail(error);
+      } catch {
+      }
+    }
+    if (active) phase({ id: active, state: "fail" });
+    run?.relay(detail, "stderr");
+    run?.finish({ total: 0, updated: 0, failed: 0, operationFailed: true, detail });
+    if (json) process.stdout.write(JSON.stringify({ error: detail }) + "\n");
+    return 1;
+  } finally {
+    run?.stop();
+  }
+}
+
+// ../installer.product.json
+var installer_product_default = {
+  product: "mmi",
+  gate: "https://gate.mutmut.work/mmi",
+  doctor: "mmi doctor",
+  surfaces: [
+    { id: "updater", npm: "@mutmutco/hub", bin: "mmi-hub" },
+    { id: "cli", npm: "@mutmutco/cli", bin: "mmi-cli" },
+    { id: "claude", kind: "agent-home", activation: "next launch" },
+    { id: "codex", kind: "agent-home", activation: "next launch" },
+    { id: "cursor", kind: "agent-home", activation: "next launch" },
+    { id: "hermes", kind: "agent-home", activation: "next launch" },
+    { id: "jervcode", kind: "agent-home", activation: "next launch" }
+  ]
+};
 
 // src/state.ts
-var import_node_fs = require("node:fs");
+var import_node_fs5 = require("node:fs");
 var import_node_os = require("node:os");
 var import_node_path = require("node:path");
 function stateRoot(env = process.env) {
@@ -323,8 +1067,8 @@ function statePaths(env = process.env) {
 }
 function ensureState(env = process.env) {
   const paths = statePaths(env);
-  (0, import_node_fs.mkdirSync)(paths.staging, { recursive: true });
-  (0, import_node_fs.mkdirSync)((0, import_node_path.dirname)(paths.gitCache), { recursive: true });
+  (0, import_node_fs5.mkdirSync)(paths.staging, { recursive: true });
+  (0, import_node_fs5.mkdirSync)((0, import_node_path.dirname)(paths.gitCache), { recursive: true });
   return paths;
 }
 var UpdaterBusy = class extends Error {
@@ -334,15 +1078,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_fs.openSync)(path, "wx");
-    (0, import_node_fs.writeFileSync)(fd, JSON.stringify({ token, pid: process.pid, ts: Date.now() }) + "\n");
-    (0, import_node_fs.closeSync)(fd);
+    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);
     return {
       token,
       release() {
         try {
           const current2 = readLease(path);
-          if (current2 && current2.token === token) (0, import_node_fs.unlinkSync)(path);
+          if (current2 && current2.token === token) (0, import_node_fs5.unlinkSync)(path);
         } catch {
         }
       }
@@ -353,7 +1097,7 @@ function tryAcquire(path) {
   const current = readLease(path);
   if (current && Date.now() - current.ts > LEASE_STALE_MS) {
     try {
-      (0, import_node_fs.renameSync)(path, `${path}.stale-${Date.now()}`);
+      (0, import_node_fs5.renameSync)(path, `${path}.stale-${Date.now()}`);
       return "stolen-stale";
     } catch {
     }
@@ -362,7 +1106,7 @@ function tryAcquire(path) {
 }
 function readLease(path) {
   try {
-    return JSON.parse((0, import_node_fs.readFileSync)(path, "utf8"));
+    return JSON.parse((0, import_node_fs5.readFileSync)(path, "utf8"));
   } catch {
     return null;
   }
@@ -387,10 +1131,10 @@ function withLease(path, fn, waitMs = LEASE_WAIT_MS) {
 }
 function appendJournal(path, event) {
   try {
-    (0, import_node_fs.mkdirSync)((0, import_node_path.dirname)(path), { recursive: true });
-    const fd = (0, import_node_fs.openSync)(path, "a");
-    (0, import_node_fs.writeFileSync)(fd, JSON.stringify(event) + "\n");
-    (0, import_node_fs.closeSync)(fd);
+    (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);
     return true;
   } catch {
     return false;
@@ -409,7 +1153,7 @@ function journalHighWater(path, surface, events) {
 function parseJournal(path) {
   const events = [];
   try {
-    for (const line of (0, import_node_fs.readFileSync)(path, "utf8").split("\n")) {
+    for (const line of (0, import_node_fs5.readFileSync)(path, "utf8").split("\n")) {
       if (!line.trim()) continue;
       try {
         events.push(JSON.parse(line));
@@ -423,7 +1167,7 @@ function parseJournal(path) {
 function journalSurfaceRepeatedFail(path, surface, currentRun) {
   let lastVerdict = null;
   try {
-    for (const line of (0, import_node_fs.readFileSync)(path, "utf8").split("\n")) {
+    for (const line of (0, import_node_fs5.readFileSync)(path, "utf8").split("\n")) {
       if (!line.trim()) continue;
       try {
         const event = JSON.parse(line);
@@ -466,7 +1210,7 @@ function compareSemver(a, b) {
   return va.pre.join(".") < vb.pre.join(".") ? -1 : va.pre.join(".") > vb.pre.join(".") ? 1 : 0;
 }
 function fileExists(path) {
-  return (0, import_node_fs.existsSync)(path);
+  return (0, import_node_fs5.existsSync)(path);
 }
 
 // src/reconcile.ts
@@ -474,7 +1218,7 @@ var import_node_perf_hooks2 = require("node:perf_hooks");
 
 // src/npm.ts
 var import_node_child_process = require("node:child_process");
-var import_node_fs2 = require("node:fs");
+var import_node_fs6 = require("node:fs");
 var import_node_path2 = require("node:path");
 var cachedNpm = null;
 function resolveNpm(env = process.env) {
@@ -485,7 +1229,7 @@ function resolveNpm(env = process.env) {
     const first = where.stdout.split("\n").map((l) => l.trim()).find(Boolean);
     if (where.status === 0 && first) {
       const script = (0, import_node_path2.join)((0, import_node_path2.dirname)(first), "node_modules", "npm", "bin", "npm-cli.js");
-      if ((0, import_node_fs2.existsSync)(script)) {
+      if ((0, import_node_fs6.existsSync)(script)) {
         cachedNpm = { kind: "node-script", script };
         return cachedNpm;
       }
@@ -494,13 +1238,13 @@ function resolveNpm(env = process.env) {
     }
   }
   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_fs2.existsSync)(bundled)) {
+  if ((0, import_node_fs6.existsSync)(bundled)) {
     cachedNpm = { kind: "node-script", script: bundled };
     return cachedNpm;
   }
   const located = (0, import_node_child_process.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_fs2.existsSync)(resolved)) {
+  if (located.status === 0 && resolved && (0, import_node_fs6.existsSync)(resolved)) {
     cachedNpm = { kind: "command", command: resolved };
     return cachedNpm;
   }
@@ -582,7 +1326,7 @@ function npmVersions(packageName, env = process.env) {
 
 // src/gate.ts
 var import_node_child_process2 = require("node:child_process");
-var import_node_fs3 = require("node:fs");
+var import_node_fs7 = require("node:fs");
 function parseBom(text) {
   const bom = JSON.parse(text);
   if (typeof bom?.version !== "string" || typeof bom?.sourceCommit !== "string" || !Array.isArray(bom?.artifacts)) {
@@ -604,7 +1348,7 @@ function ensureBareCache(cachePath, repoUrl) {
   if (probe.status !== 0) {
     throw new GateEnvError("git is not available \u2014 the release gate needs a git client");
   }
-  if (!(0, import_node_fs3.existsSync)(cachePath)) {
+  if (!(0, import_node_fs7.existsSync)(cachePath)) {
     const init = (0, import_node_child_process2.spawnSync)("git", ["init", "--bare", cachePath], { encoding: "utf8", windowsHide: true });
     if (init.status !== 0) throw new GateEnvError(`cannot create bare cache at ${cachePath}: ${init.stderr}`);
   }
@@ -711,24 +1455,24 @@ async function checkAtomicity(cachePath, tagCommit, bom, candidate, npm) {
 }
 
 // src/surfaces.ts
-var import_node_fs8 = require("node:fs");
+var import_node_fs12 = require("node:fs");
 var import_node_os3 = require("node:os");
 var import_node_path7 = require("node:path");
 
 // src/arm-host-plugins.ts
 var import_node_child_process5 = require("node:child_process");
-var import_node_fs7 = require("node:fs");
+var import_node_fs11 = require("node:fs");
 var import_node_os2 = require("node:os");
 var import_node_path6 = require("node:path");
 
 // src/arm-npm-global.ts
-var import_node_fs5 = require("node:fs");
+var import_node_fs9 = require("node:fs");
 var import_node_child_process4 = require("node:child_process");
 var import_node_path4 = require("node:path");
 
 // src/pending.ts
 var import_node_child_process3 = require("node:child_process");
-var import_node_fs4 = require("node:fs");
+var import_node_fs8 = require("node:fs");
 var import_node_path3 = require("node:path");
 function hubDistPath(env) {
   const root = globalRoot(env);
@@ -743,7 +1487,7 @@ function watcherLockPath(paths) {
 }
 function readPending(paths) {
   try {
-    const parsed = JSON.parse((0, import_node_fs4.readFileSync)(pendingPath(paths), "utf8"));
+    const parsed = JSON.parse((0, import_node_fs8.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 {
@@ -751,12 +1495,12 @@ function readPending(paths) {
   }
 }
 function writePending(paths, records) {
-  (0, import_node_fs4.mkdirSync)(paths.root, { recursive: true });
+  (0, import_node_fs8.mkdirSync)(paths.root, { recursive: true });
   const path = pendingPath(paths);
   const tmp = `${path}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
-  (0, import_node_fs4.writeFileSync)(tmp, `${JSON.stringify(records, null, 2)}
+  (0, import_node_fs8.writeFileSync)(tmp, `${JSON.stringify(records, null, 2)}
 `, "utf8");
-  (0, import_node_fs4.renameSync)(tmp, path);
+  (0, import_node_fs8.renameSync)(tmp, path);
 }
 function clearPending(paths, surface) {
   const records = readPending(paths);
@@ -825,7 +1569,7 @@ 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_fs4.existsSync)(hubDist)) return { scheduled: false, reason: "the installed hub bundle is unresolvable \u2014 the hourly tick remains the retry" };
+  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" };
   const command = buildWatcherCommand({
     images: [...new Set(records.flatMap((row) => row.images))],
     dirs: [...new Set(records.flatMap((row) => row.dirs))],
@@ -885,7 +1629,7 @@ function tail(output) {
 function manifestVersion(packageRoot) {
   if (!packageRoot) return null;
   try {
-    const version = JSON.parse((0, import_node_fs5.readFileSync)((0, import_node_path4.join)(packageRoot, "package.json"), "utf8")).version;
+    const version = JSON.parse((0, import_node_fs9.readFileSync)((0, import_node_path4.join)(packageRoot, "package.json"), "utf8")).version;
     return typeof version === "string" ? version : null;
   } catch {
     return null;
@@ -896,8 +1640,8 @@ function stagePackage(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_fs5.mkdirSync)(stageRoot, { recursive: true });
-    (0, import_node_fs5.writeFileSync)((0, import_node_path4.join)(stageRoot, "package.json"), JSON.stringify({ name: "mmi-updater-stage", private: true }) + "\n");
+    (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 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)}` };
@@ -905,7 +1649,7 @@ function stagePackage(options) {
   }
   let stagedManifestVersion;
   try {
-    stagedManifestVersion = JSON.parse((0, import_node_fs5.readFileSync)((0, import_node_path4.join)(packageRoot, "package.json"), "utf8")).version;
+    stagedManifestVersion = JSON.parse((0, import_node_fs9.readFileSync)((0, import_node_path4.join)(packageRoot, "package.json"), "utf8")).version;
   } catch {
   }
   if (stagedManifestVersion !== target) {
@@ -963,11 +1707,11 @@ function npmGlobalArm(options) {
 }
 
 // src/launch-staging.ts
-var import_node_fs6 = require("node:fs");
+var import_node_fs10 = require("node:fs");
 var import_node_path5 = require("node:path");
 function readLaunchTarget(path) {
   try {
-    const parsed = JSON.parse((0, import_node_fs6.readFileSync)(path, "utf8"));
+    const parsed = JSON.parse((0, import_node_fs10.readFileSync)(path, "utf8"));
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
     const row = parsed;
     if (typeof row.surface !== "string" || typeof row.target !== "string" || typeof row.since !== "string" || typeof row.incoming !== "string") return null;
@@ -977,15 +1721,15 @@ function readLaunchTarget(path) {
   }
 }
 function writeLaunchTarget(path, record) {
-  (0, import_node_fs6.mkdirSync)((0, import_node_path5.join)(path, ".."), { recursive: true });
+  (0, import_node_fs10.mkdirSync)((0, import_node_path5.join)(path, ".."), { recursive: true });
   const tmp = `${path}.tmp-${process.pid}-${Math.random().toString(36).slice(2)}`;
-  (0, import_node_fs6.writeFileSync)(tmp, `${JSON.stringify(record, null, 2)}
+  (0, import_node_fs10.writeFileSync)(tmp, `${JSON.stringify(record, null, 2)}
 `, "utf8");
-  (0, import_node_fs6.renameSync)(tmp, path);
+  (0, import_node_fs10.renameSync)(tmp, path);
 }
 function clearLaunchTarget(path) {
   try {
-    (0, import_node_fs6.rmSync)(path, { force: true });
+    (0, import_node_fs10.rmSync)(path, { force: true });
   } catch {
   }
 }
@@ -1006,7 +1750,7 @@ function noteLaunchStaged(paths, env, options, seam = {}) {
 }
 function probeLaunchTargetVersion(launchTargetPath, versionAt) {
   const record = readLaunchTarget(launchTargetPath);
-  if (!record || !(0, import_node_fs6.existsSync)(record.incoming)) return null;
+  if (!record || !(0, import_node_fs10.existsSync)(record.incoming)) return null;
   const version = versionAt(record.incoming);
   return version === record.target ? record.target : null;
 }
@@ -1064,7 +1808,7 @@ function ensureClaudeMarketplace(env) {
   const path = claudeMarketplacesPath(env);
   let body;
   try {
-    body = JSON.parse((0, import_node_fs7.readFileSync)(path, "utf8"));
+    body = JSON.parse((0, import_node_fs11.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}` };
@@ -1092,7 +1836,7 @@ function claudePluginsRoot(env) {
 }
 function claudeMarkerVersion(root) {
   try {
-    const version = JSON.parse((0, import_node_fs7.readFileSync)((0, import_node_path6.join)(root, ...CLAUDE_MANIFEST.split("/")), "utf8")).version;
+    const version = JSON.parse((0, import_node_fs11.readFileSync)((0, import_node_path6.join)(root, ...CLAUDE_MANIFEST.split("/")), "utf8")).version;
     return typeof version === "string" ? version : null;
   } catch {
     return null;
@@ -1189,14 +1933,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_fs7.mkdirSync)((0, import_node_path6.join)(pluginsRoot, "staging"), { recursive: true });
-      (0, import_node_fs7.rmSync)(incomingRoot, { recursive: true, force: true });
-      (0, import_node_fs7.cpSync)(staged.packageRoot, incoming, { recursive: true });
+      (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 });
     } catch (error) {
       return result(from, target, "defer", `cannot place incoming Claude generation: ${error?.message ?? error}`);
     }
     if (claudeMarkerVersion(incoming) !== target || !claudeTreeHealthy(incoming)) {
-      (0, import_node_fs7.rmSync)(incomingRoot, { recursive: true, force: true });
+      (0, import_node_fs11.rmSync)(incomingRoot, { recursive: true, force: true });
       return result(from, target, "defer", "incoming Claude generation did not reproduce the verified payload");
     }
   }
@@ -1228,10 +1972,10 @@ function claudeArm(options) {
   }
   const cacheTarget = (0, import_node_path6.join)(pluginsRoot, "cache", "mutmutco", "mmi", target);
   try {
-    if (!(0, import_node_fs7.existsSync)(cacheTarget) || claudeMarkerVersion(cacheTarget) !== target || !claudeTreeHealthy(cacheTarget)) {
-      (0, import_node_fs7.rmSync)(cacheTarget, { recursive: true, force: true });
-      (0, import_node_fs7.mkdirSync)((0, import_node_path6.join)(cacheTarget, ".."), { recursive: true });
-      (0, import_node_fs7.cpSync)(incoming, cacheTarget, { recursive: true });
+    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 });
     }
   } catch (error) {
     return result(from, target, "defer", `cannot populate Claude plugin cache: ${error?.message ?? error}`);
@@ -1259,7 +2003,7 @@ function claudeArm(options) {
   }
   clearLaunchTarget(launchTargetPath);
   try {
-    (0, import_node_fs7.rmSync)(incomingRoot, { recursive: true, force: true });
+    (0, import_node_fs11.rmSync)(incomingRoot, { recursive: true, force: true });
   } catch {
   }
   return result(from, target, "ok", `catalog refreshed; converged and verified ${from ?? "absent"} -> ${target}`);
@@ -1372,21 +2116,21 @@ function enumerateSurfaces(env = process.env) {
     { id: "hermes", marker: `${hermesHostCommand(env)} --version` }
   ].map((probe) => ({
     ...probe,
-    present: probe.id === "hermes" ? hermesHostPresent(env) : (0, import_node_fs8.existsSync)(probe.marker)
+    present: probe.id === "hermes" ? hermesHostPresent(env) : (0, import_node_fs12.existsSync)(probe.marker)
   }));
 }
 
 // src/arm-cursor.ts
-var import_node_fs11 = require("node:fs");
+var import_node_fs15 = require("node:fs");
 var import_node_child_process6 = require("node:child_process");
 var import_node_os5 = require("node:os");
 var import_node_path8 = require("node:path");
 
 // src/compat.ts
-var import_node_fs9 = require("node:fs");
+var import_node_fs13 = require("node:fs");
 function readManifestCompat(manifestPath) {
   try {
-    const parsed = JSON.parse((0, import_node_fs9.readFileSync)(manifestPath, "utf8"));
+    const parsed = JSON.parse((0, import_node_fs13.readFileSync)(manifestPath, "utf8"));
     return typeof parsed.mmiCompat === "string" ? parsed.mmiCompat : void 0;
   } catch {
     return void 0;
@@ -1394,7 +2138,7 @@ function readManifestCompat(manifestPath) {
 }
 
 // src/host-doc-lock.ts
-var import_node_fs10 = require("node:fs");
+var import_node_fs14 = require("node:fs");
 var import_node_os4 = require("node:os");
 var SHARED_DOC_LOCK_STALE_MS = 3e4;
 var SHARED_DOC_LOCK_ATTEMPTS = 50;
@@ -1408,7 +2152,7 @@ function lockContent(options) {
 }
 function readHolder(lockPath) {
   try {
-    const parsed = JSON.parse((0, import_node_fs10.readFileSync)(lockPath, "utf8"));
+    const parsed = JSON.parse((0, import_node_fs14.readFileSync)(lockPath, "utf8"));
     if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return null;
     return parsed;
   } catch {
@@ -1420,7 +2164,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_fs10.statSync)(lockPath).mtimeMs);
+    return Math.max(0, now - (0, import_node_fs14.statSync)(lockPath).mtimeMs);
   } catch {
     return 0;
   }
@@ -1443,9 +2187,9 @@ function acquireSharedDocLock(documentPath, options) {
   for (let attempt = 0; attempt < attempts; attempt += 1) {
     let fd;
     try {
-      fd = (0, import_node_fs10.openSync)(lockPath, "wx");
-      (0, import_node_fs10.writeSync)(fd, content);
-      (0, import_node_fs10.closeSync)(fd);
+      fd = (0, import_node_fs14.openSync)(lockPath, "wx");
+      (0, import_node_fs14.writeSync)(fd, content);
+      (0, import_node_fs14.closeSync)(fd);
       return {
         documentPath,
         lockPath,
@@ -1458,11 +2202,11 @@ function acquireSharedDocLock(documentPath, options) {
     } catch (error) {
       if (fd !== void 0) {
         try {
-          (0, import_node_fs10.closeSync)(fd);
+          (0, import_node_fs14.closeSync)(fd);
         } catch {
         }
         try {
-          (0, import_node_fs10.unlinkSync)(lockPath);
+          (0, import_node_fs14.unlinkSync)(lockPath);
         } catch {
         }
       }
@@ -1471,12 +2215,12 @@ function acquireSharedDocLock(documentPath, options) {
     if (lockAgeMs(lockPath, Date.now()) >= staleAfterMs) {
       const aside = `${lockPath}.stale-${Date.now()}`;
       try {
-        (0, import_node_fs10.renameSync)(lockPath, aside);
+        (0, import_node_fs14.renameSync)(lockPath, aside);
       } catch {
         continue;
       }
       try {
-        (0, import_node_fs10.rmSync)(aside, { force: true });
+        (0, import_node_fs14.rmSync)(aside, { force: true });
       } catch {
       }
       continue;
@@ -1489,7 +2233,7 @@ function releaseSharedDocLock(handle) {
   try {
     const holder = readHolder(handle.lockPath);
     if (holder && holder.owner === handle.owner && Number(holder.pid) === handle.pid) {
-      (0, import_node_fs10.unlinkSync)(handle.lockPath);
+      (0, import_node_fs14.unlinkSync)(handle.lockPath);
     }
   } catch {
   }
@@ -1514,11 +2258,11 @@ function cursorPluginsRoot() {
   return (0, import_node_path8.join)((0, import_node_os5.homedir)(), ".cursor", "plugins");
 }
 function treeHealthy(root) {
-  return TREE_FILES.every((rel) => (0, import_node_fs11.existsSync)((0, import_node_path8.join)(root, ...rel.split("/"))));
+  return TREE_FILES.every((rel) => (0, import_node_fs15.existsSync)((0, import_node_path8.join)(root, ...rel.split("/"))));
 }
 function readJson(root, rel) {
   try {
-    return JSON.parse((0, import_node_fs11.readFileSync)((0, import_node_path8.join)(root, ...rel.split("/")), "utf8"));
+    return JSON.parse((0, import_node_fs15.readFileSync)((0, import_node_path8.join)(root, ...rel.split("/")), "utf8"));
   } catch {
     return null;
   }
@@ -1542,7 +2286,7 @@ function message(error) {
 }
 function discard(path) {
   try {
-    (0, import_node_fs11.rmSync)(path, { recursive: true, force: true });
+    (0, import_node_fs15.rmSync)(path, { recursive: true, force: true });
   } catch {
   }
 }
@@ -1596,10 +2340,10 @@ 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);
   return withSharedDocLock(path, { owner: CURSOR_HOOKS_LOCK_OWNER, ...lock }, () => {
-    if (!(0, import_node_fs11.existsSync)(path)) return "current";
+    if (!(0, import_node_fs15.existsSync)(path)) return "current";
     let existing;
     try {
-      existing = JSON.parse((0, import_node_fs11.readFileSync)(path, "utf8"));
+      existing = JSON.parse((0, import_node_fs15.readFileSync)(path, "utf8"));
     } catch {
       return "user-conflict";
     }
@@ -1607,8 +2351,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_fs11.writeFileSync)(tmp, JSON.stringify(stripped, null, 2) + "\n", "utf8");
-    (0, import_node_fs11.renameSync)(tmp, path);
+    (0, import_node_fs15.writeFileSync)(tmp, JSON.stringify(stripped, null, 2) + "\n", "utf8");
+    (0, import_node_fs15.renameSync)(tmp, path);
     return "updated";
   });
 }
@@ -1632,15 +2376,15 @@ function writeRollbackPointer(root, entry) {
   const path = (0, import_node_path8.join)(root, "quarantine", "rollback.json");
   const tmp = `${path}.tmp-${process.pid}`;
   try {
-    (0, import_node_fs11.writeFileSync)(tmp, JSON.stringify({ surface: "cursor", ts: (/* @__PURE__ */ new Date()).toISOString(), ...entry }, null, 2) + "\n", "utf8");
-    (0, import_node_fs11.renameSync)(tmp, path);
+    (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);
   } catch {
     discard(tmp);
   }
 }
 function mtimeMs(path) {
   try {
-    return (0, import_node_fs11.statSync)(path).mtimeMs;
+    return (0, import_node_fs15.statSync)(path).mtimeMs;
   } catch {
     return 0;
   }
@@ -1649,13 +2393,13 @@ function pruneQuarantine(root, keep) {
   const dir = (0, import_node_path8.join)(root, "quarantine");
   let generations;
   try {
-    generations = (0, import_node_fs11.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_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));
   } catch {
     return 0;
   }
   let stranded = 0;
   try {
-    for (const entry of (0, import_node_fs11.readdirSync)(dir, { withFileTypes: true })) {
+    for (const entry of (0, import_node_fs15.readdirSync)(dir, { withFileTypes: true })) {
       if (!entry.isFile() || !/^rollback\.json\.tmp-\d+$/.test(entry.name)) continue;
       const path = (0, import_node_path8.join)(dir, entry.name);
       if (Date.now() - mtimeMs(path) < STRANDED_TMP_AGE_MS) continue;
@@ -1675,16 +2419,16 @@ function pruneQuarantine(root, keep) {
 }
 function restorePrevious(live, quarantined, broken) {
   try {
-    (0, import_node_fs11.renameSync)(live, broken);
+    (0, import_node_fs15.renameSync)(live, broken);
   } catch {
     return "kept-broken";
   }
   try {
-    (0, import_node_fs11.renameSync)(quarantined, live);
+    (0, import_node_fs15.renameSync)(quarantined, live);
     return "restored";
   } catch {
     try {
-      (0, import_node_fs11.renameSync)(broken, live);
+      (0, import_node_fs15.renameSync)(broken, live);
       return "kept-broken";
     } catch {
       return "lost";
@@ -1719,7 +2463,7 @@ function cursorArm(options) {
   if (installed === target && treeHealthy(live)) {
     return result(installed, target, "ok", `already at target ${target}${userHooksDetail(live, (0, import_node_os5.homedir)())}`);
   }
-  if ((0, import_node_fs11.existsSync)(live) && !mmiOwned(live)) {
+  if ((0, import_node_fs15.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) {
@@ -1737,12 +2481,12 @@ function cursorArm(options) {
   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()}`);
   const reuseIncoming = incoming === priorLaunch?.incoming;
-  if (!reuseIncoming || !(0, import_node_fs11.existsSync)(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_fs11.mkdirSync)((0, import_node_path8.join)(root, dir), { recursive: true });
+    for (const dir of ["local", "staging", "quarantine"]) (0, import_node_fs15.mkdirSync)((0, import_node_path8.join)(root, dir), { recursive: true });
     try {
       discard(incoming);
-      (0, import_node_fs11.cpSync)(staged.packageRoot, incoming, { recursive: true });
+      (0, import_node_fs15.cpSync)(staged.packageRoot, incoming, { recursive: true });
     } catch (error) {
       discard(incoming);
       return result(installed, target, "defer", `copy into ${root} failed: ${message(error)}`);
@@ -1766,7 +2510,7 @@ function cursorArm(options) {
   }
   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_fs11.mkdirSync)((0, import_node_path8.join)(root, dir), { recursive: true });
+  for (const dir of ["local", "staging", "quarantine"]) (0, import_node_fs15.mkdirSync)((0, import_node_path8.join)(root, dir), { recursive: true });
   const started = cursorHostEvidence(env);
   if (started) {
     const pending = noteLaunchStaged(paths, env, {
@@ -1781,15 +2525,15 @@ function cursorArm(options) {
   }
   let displaced = false;
   try {
-    if ((0, import_node_fs11.existsSync)(live)) {
-      (0, import_node_fs11.renameSync)(live, quarantined);
+    if ((0, import_node_fs15.existsSync)(live)) {
+      (0, import_node_fs15.renameSync)(live, quarantined);
       displaced = true;
     }
-    (0, import_node_fs11.renameSync)(incoming, live);
+    (0, import_node_fs15.renameSync)(incoming, live);
   } catch (error) {
-    if (displaced && !(0, import_node_fs11.existsSync)(live)) {
+    if (displaced && !(0, import_node_fs15.existsSync)(live)) {
       try {
-        (0, import_node_fs11.renameSync)(quarantined, live);
+        (0, import_node_fs15.renameSync)(quarantined, live);
       } catch {
       }
     }
@@ -1817,7 +2561,7 @@ function probeCursorLaunchStaging() {
 }
 
 // src/arm-jervcode.ts
-var import_node_fs12 = require("node:fs");
+var import_node_fs16 = require("node:fs");
 var import_node_path9 = require("node:path");
 var PI_PACKAGE = "@mutmutco/pi-plugin";
 function hostEnv(env) {
@@ -1829,7 +2573,7 @@ function hostCommands(_env) {
 }
 function readPackageSpecs(env) {
   try {
-    const settings = JSON.parse((0, import_node_fs12.readFileSync)((0, import_node_path9.join)(jervcodeAgentDir(env), "settings.json"), "utf8"));
+    const settings = JSON.parse((0, import_node_fs16.readFileSync)((0, import_node_path9.join)(jervcodeAgentDir(env), "settings.json"), "utf8"));
     return Array.isArray(settings.packages) ? settings.packages.filter((entry) => typeof entry === "string") : [];
   } catch {
     return null;
@@ -1837,7 +2581,7 @@ function readPackageSpecs(env) {
 }
 function installedVersion(env) {
   try {
-    const manifest2 = JSON.parse((0, import_node_fs12.readFileSync)((0, import_node_path9.join)(jervcodeAgentDir(env), "npm", "node_modules", ...PI_PACKAGE.split("/"), "package.json"), "utf8"));
+    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"));
     return typeof manifest2.version === "string" ? manifest2.version : null;
   } catch {
     return null;
@@ -1957,7 +2701,7 @@ function jervcodeArm(options) {
 }
 
 // src/arm-hermes.ts
-var import_node_fs13 = require("node:fs");
+var import_node_fs17 = require("node:fs");
 var import_node_child_process7 = require("node:child_process");
 var import_node_path10 = require("node:path");
 var PACKAGE2 = "@mutmutco/hermes-plugin";
@@ -1965,7 +2709,7 @@ var MANIFEST2 = "plugin.yaml";
 var TREE_MARKERS_FALLBACK = [MANIFEST2, "__init__.py", "skills"];
 function yamlVersion(root) {
   try {
-    const text = (0, import_node_fs13.readFileSync)((0, import_node_path10.join)(root, MANIFEST2), "utf8");
+    const text = (0, import_node_fs17.readFileSync)((0, import_node_path10.join)(root, MANIFEST2), "utf8");
     try {
       const version = JSON.parse(text).version;
       if (typeof version === "string" && version.trim()) return version.trim();
@@ -1979,7 +2723,7 @@ function yamlVersion(root) {
 }
 function packageTreeMarkers(root) {
   try {
-    const files = JSON.parse((0, import_node_fs13.readFileSync)((0, import_node_path10.join)(root, "package.json"), "utf8")).files;
+    const files = JSON.parse((0, import_node_fs17.readFileSync)((0, import_node_path10.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());
     }
@@ -1989,9 +2733,9 @@ function packageTreeMarkers(root) {
 }
 function markerPresent(root, rel) {
   const path = (0, import_node_path10.join)(root, ...rel.split("/"));
-  if (!(0, import_node_fs13.existsSync)(path)) return false;
+  if (!(0, import_node_fs17.existsSync)(path)) return false;
   try {
-    const stat = (0, import_node_fs13.statSync)(path);
+    const stat = (0, import_node_fs17.statSync)(path);
     return stat.isFile() || stat.isDirectory();
   } catch {
     return false;
@@ -2010,7 +2754,7 @@ function treeIncompleteDetail(root, label) {
 }
 function packageIdentity(root) {
   try {
-    return JSON.parse((0, import_node_fs13.readFileSync)((0, import_node_path10.join)(root, "package.json"), "utf8")).name === PACKAGE2;
+    return JSON.parse((0, import_node_fs17.readFileSync)((0, import_node_path10.join)(root, "package.json"), "utf8")).name === PACKAGE2;
   } catch {
     return false;
   }
@@ -2025,7 +2769,7 @@ function mmiOwned2(root) {
 }
 function discard2(path) {
   try {
-    (0, import_node_fs13.rmSync)(path, { recursive: true, force: true });
+    (0, import_node_fs17.rmSync)(path, { recursive: true, force: true });
   } catch {
   }
 }
@@ -2061,15 +2805,15 @@ function materializeHermesSkills(home) {
   const skillsRoot = (0, import_node_path10.join)(home, "skills");
   const targetRoot = (0, import_node_path10.join)(skillsRoot, "mmi");
   try {
-    if (!(0, import_node_fs13.existsSync)(pluginSkills)) return { ok: false, detail: `plugin skills tree missing at ${pluginSkills}` };
-    const names = (0, import_node_fs13.readdirSync)(pluginSkills, { withFileTypes: true }).filter((entry) => entry.isDirectory() && !entry.name.startsWith("_")).map((entry) => entry.name);
+    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 (!names.length) return { ok: false, detail: `plugin skills tree is empty at ${pluginSkills}` };
-    (0, import_node_fs13.mkdirSync)(skillsRoot, { recursive: true });
+    (0, import_node_fs17.mkdirSync)(skillsRoot, { recursive: true });
     const incoming = (0, import_node_path10.join)(skillsRoot, ".mmi-incoming");
     discard2(incoming);
-    (0, import_node_fs13.cpSync)(pluginSkills, incoming, { recursive: true });
+    (0, import_node_fs17.cpSync)(pluginSkills, incoming, { recursive: true });
     discard2(targetRoot);
-    (0, import_node_fs13.renameSync)(incoming, targetRoot);
+    (0, import_node_fs17.renameSync)(incoming, targetRoot);
     return { ok: true, detail: `provisioned ${names.length} skills to ${targetRoot}` };
   } catch (error) {
     return { ok: false, detail: message2(error) };
@@ -2091,7 +2835,7 @@ function hermesHomes(env = process.env) {
   const root = hermesHome(env);
   const homes = [root];
   try {
-    for (const entry of (0, import_node_fs13.readdirSync)((0, import_node_path10.join)(root, "profiles"), { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+    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));
     }
   } catch {
@@ -2140,7 +2884,7 @@ function armHermesHome(home, env, options, primary) {
     detail,
     launchStaged: launchStaged || void 0
   });
-  if ((0, import_node_fs13.existsSync)(live) && !mmiOwned2(live)) {
+  if ((0, import_node_fs17.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)`);
@@ -2172,10 +2916,10 @@ function armHermesHome(home, env, options, primary) {
   const reuseIncoming = priorLaunch?.target === options.target && priorLaunch.incoming === incoming && yamlVersion(incoming) === options.target && treeHealthy2(incoming);
   if (!reuseIncoming) {
     try {
-      (0, import_node_fs13.mkdirSync)(parent, { recursive: true });
-      (0, import_node_fs13.mkdirSync)((0, import_node_path10.join)(scratch, "quarantine"), { recursive: true });
+      (0, import_node_fs17.mkdirSync)(parent, { recursive: true });
+      (0, import_node_fs17.mkdirSync)((0, import_node_path10.join)(scratch, "quarantine"), { recursive: true });
       discard2(incomingRoot);
-      (0, import_node_fs13.cpSync)(staged.packageRoot, incoming, { recursive: true });
+      (0, import_node_fs17.cpSync)(staged.packageRoot, incoming, { recursive: true });
     } catch (error) {
       return result(installed, options.target, "defer", `cannot place incoming Hermes generation: ${message2(error)}`);
     }
@@ -2190,7 +2934,7 @@ function armHermesHome(home, env, options, primary) {
       return result(installed, options.target, "defer", incomingTree);
     }
   }
-  const displaced = (0, import_node_fs13.existsSync)(live);
+  const displaced = (0, import_node_fs17.existsSync)(live);
   const busy = displaced ? hermesHostEvidence(env, home, options.processListProvider) : null;
   if (busy) {
     const pending = noteLaunchStaged(options.paths, env, {
@@ -2205,11 +2949,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_fs13.renameSync)(live, quarantine);
-    (0, import_node_fs13.renameSync)(incoming, live);
+    if (displaced) (0, import_node_fs17.renameSync)(live, quarantine);
+    (0, import_node_fs17.renameSync)(incoming, live);
   } catch (error) {
-    if (displaced && !(0, import_node_fs13.existsSync)(live)) try {
-      (0, import_node_fs13.renameSync)(quarantine, live);
+    if (displaced && !(0, import_node_fs17.existsSync)(live)) try {
+      (0, import_node_fs17.renameSync)(quarantine, live);
     } catch {
     }
     discard2(incomingRoot);
@@ -2223,9 +2967,9 @@ function armHermesHome(home, env, options, primary) {
     const broken = (0, import_node_path10.join)(scratch, "rejected", `${options.target}-${Date.now()}`);
     const verifyDetail = liveVersion !== options.target ? `manifest is ${liveVersion ?? "unreadable"}, expected ${options.target}` : liveTree;
     try {
-      (0, import_node_fs13.mkdirSync)((0, import_node_path10.join)(scratch, "rejected"), { recursive: true });
-      (0, import_node_fs13.renameSync)(live, broken);
-      if (displaced) (0, import_node_fs13.renameSync)(quarantine, live);
+      (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);
     } catch (error) {
       return result(installed, liveVersion ?? "unknown", "fail", `post-switch Hermes verification failed and recovery failed: ${message2(error)}`);
     }
@@ -2244,7 +2988,7 @@ function probeHermesLaunchStaging(env = process.env) {
 }
 
 // src/reap.ts
-var import_node_fs14 = require("node:fs");
+var import_node_fs18 = require("node:fs");
 var import_node_path11 = require("node:path");
 var import_node_perf_hooks = require("node:perf_hooks");
 function elapsedMs(startedAt) {
@@ -2254,7 +2998,7 @@ var KEEP_GENERATIONS2 = 2;
 var SCRATCH_AGE_MS = 24 * 60 * 6e4;
 function listDirs(path) {
   try {
-    return (0, import_node_fs14.readdirSync)(path, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+    return (0, import_node_fs18.readdirSync)(path, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
   } catch {
     return [];
   }
@@ -2275,7 +3019,7 @@ function pruneGenerations(root, category, dryRun) {
         continue;
       }
       try {
-        (0, import_node_fs14.rmSync)((0, import_node_path11.join)(set, version), { recursive: true, force: true });
+        (0, import_node_fs18.rmSync)((0, import_node_path11.join)(set, version), { recursive: true, force: true });
         reaped += 1;
       } catch (error) {
         failures.push(`${version}: ${error?.code ?? error?.message ?? error}`);
@@ -2308,7 +3052,7 @@ function reapScratch(context, dryRun) {
   for (const [dir, patterns] of scanned) {
     let entries;
     try {
-      entries = (0, import_node_fs14.readdirSync)(dir, { withFileTypes: true });
+      entries = (0, import_node_fs18.readdirSync)(dir, { withFileTypes: true });
     } catch {
       unreadable.push(dir);
       continue;
@@ -2319,7 +3063,7 @@ function reapScratch(context, dryRun) {
       const path = (0, import_node_path11.join)(dir, entry.name);
       let ageMs;
       try {
-        ageMs = now - (0, import_node_fs14.statSync)(path).mtimeMs;
+        ageMs = now - (0, import_node_fs18.statSync)(path).mtimeMs;
       } catch {
         continue;
       }
@@ -2329,7 +3073,7 @@ function reapScratch(context, dryRun) {
         continue;
       }
       try {
-        (0, import_node_fs14.rmSync)(path, { force: true });
+        (0, import_node_fs18.rmSync)(path, { force: true });
         reaped += 1;
       } catch (error) {
         failures.push(`${entry.name}: ${error?.code ?? error?.message ?? error}`);
@@ -2386,7 +3130,7 @@ async function reconcile(options) {
   const recordArm = (arm, durationMs) => {
     if (arm.verdict === "fail") arm.repeatFailure = journalSurfaceRepeatedFail(paths.journalPath, arm.surface, run);
     journal({ kind: "arm", surface: arm.surface, from: arm.from, to: arm.to, verdict: arm.verdict, detail: arm.detail, compat: arm.compat, durationMs });
-    options.onArm?.(arm);
+    options.onArm?.({ ...arm, ...durationMs === void 0 ? {} : { durationMs } });
     if (arm.verdict === "ok" && !options.dryRun && !arm.launchStaged) clearPending(paths, arm.surface);
     if (arm.verdict === "defer") summary.exit = Math.max(summary.exit, 2);
     if (arm.verdict === "fail") summary.exit = Math.max(summary.exit, 3);
@@ -2551,7 +3295,7 @@ async function reconcile(options) {
 
 // src/scheduler.ts
 var import_node_child_process8 = require("node:child_process");
-var import_node_fs15 = require("node:fs");
+var import_node_fs19 = require("node:fs");
 var import_node_os6 = require("node:os");
 var import_node_path12 = require("node:path");
 var TASK_NAME = "MMI Fleet Updater";
@@ -2711,7 +3455,7 @@ WantedBy=timers.target
 }
 function readFileOrNull(path) {
   try {
-    return (0, import_node_fs15.readFileSync)(path, "utf8");
+    return (0, import_node_fs19.readFileSync)(path, "utf8");
   } catch {
     return null;
   }
@@ -2763,22 +3507,22 @@ function windowsSchedulerStatus(env) {
   const launcherPath = (0, import_node_path12.join)(statePaths(env).root, LAUNCHER_FILE);
   const info = taskRunInfo();
   const runInfo = info ?? EMPTY_RUN_INFO;
-  const fail = (detail) => ({ ok: false, supported: true, enabled: true, ...runInfo, detail });
+  const fail2 = (detail) => ({ ok: false, supported: true, enabled: true, ...runInfo, detail });
   if (!query.stdout.includes(launcherPath)) {
-    return fail(`"${TASK_NAME}" action does not run the hidden launcher ${launcherPath} \u2014 run \`mmi-hub autoupdate on\``);
+    return fail2(`"${TASK_NAME}" action does not run the hidden launcher ${launcherPath} \u2014 run \`mmi-hub autoupdate on\``);
   }
   const launcher = readFileOrNull(launcherPath);
   if (hubDist && !launcher?.includes(hubDist)) {
-    return fail(`"${TASK_NAME}" launcher does not point at the current @mutmutco/hub dist ${hubDist} \u2014 run \`mmi-hub autoupdate on\``);
+    return fail2(`"${TASK_NAME}" launcher does not point at the current @mutmutco/hub dist ${hubDist} \u2014 run \`mmi-hub autoupdate on\``);
   }
   if (query.stdout.includes("<LogonTrigger>")) {
-    return fail(`"${TASK_NAME}" still carries the dormant logon-only trigger \u2014 run \`mmi-hub autoupdate on\``);
+    return fail2(`"${TASK_NAME}" still carries the dormant logon-only trigger \u2014 run \`mmi-hub autoupdate on\``);
   }
   if (!query.stdout.includes("<TimeTrigger>") || !query.stdout.includes(`<Interval>${REPEAT_INTERVAL}</Interval>`)) {
-    return fail(`"${TASK_NAME}" has no ${REPEAT_INTERVAL}-repeating TimeTrigger \u2014 run \`mmi-hub autoupdate on\``);
+    return fail2(`"${TASK_NAME}" has no ${REPEAT_INTERVAL}-repeating TimeTrigger \u2014 run \`mmi-hub autoupdate on\``);
   }
   if (info && neverRan(info) && !info.nextRunTime) {
-    return fail(`"${TASK_NAME}" has never run and has no next run time \u2014 run \`mmi-hub autoupdate on\``);
+    return fail2(`"${TASK_NAME}" has never run and has no next run time \u2014 run \`mmi-hub autoupdate on\``);
   }
   const points = `points at ${hubDist ?? "the registered Hub dist"}`;
   const ran = !info ? "run history unreadable" : neverRan(info) ? "never run yet" : `last run ${info.lastRunTime} \u2192 exit ${info.lastTaskResult ?? "unknown"}`;
@@ -2792,20 +3536,20 @@ function darwinSchedulerStatus(env) {
   }
   const hubDist = globalDist(env, "@mutmutco/hub", "dist/index.cjs");
   const launcherPath = (0, import_node_path12.join)(statePaths(env).root, POSIX_LAUNCHER_FILE);
-  const fail = (detail) => ({ ok: false, supported: true, enabled: true, ...EMPTY_RUN_INFO, detail });
+  const fail2 = (detail) => ({ ok: false, supported: true, enabled: true, ...EMPTY_RUN_INFO, detail });
   if (!plist.includes(launcherPath)) {
-    return fail(`"${LAUNCHD_LABEL}" does not run the reconcile launcher ${launcherPath} \u2014 run \`mmi-hub autoupdate on\``);
+    return fail2(`"${LAUNCHD_LABEL}" does not run the reconcile launcher ${launcherPath} \u2014 run \`mmi-hub autoupdate on\``);
   }
   const launcher = readFileOrNull(launcherPath);
   if (hubDist && !launcher?.includes(hubDist)) {
-    return fail(`"${LAUNCHD_LABEL}" launcher does not point at the current @mutmutco/hub dist ${hubDist} \u2014 run \`mmi-hub autoupdate on\``);
+    return fail2(`"${LAUNCHD_LABEL}" launcher does not point at the current @mutmutco/hub dist ${hubDist} \u2014 run \`mmi-hub autoupdate on\``);
   }
   if (!plist.includes(`<integer>${STARTINTERVAL_SECONDS}</integer>`)) {
-    return fail(`"${LAUNCHD_LABEL}" has no ${STARTINTERVAL_SECONDS}s StartInterval \u2014 run \`mmi-hub autoupdate on\``);
+    return fail2(`"${LAUNCHD_LABEL}" has no ${STARTINTERVAL_SECONDS}s StartInterval \u2014 run \`mmi-hub autoupdate on\``);
   }
   const loaded = launchctl(["print", `gui/${uid()}/${LAUNCHD_LABEL}`]);
   if (loaded.status !== 0) {
-    return fail(`"${LAUNCHD_LABEL}" is registered but not loaded \u2014 run \`mmi-hub autoupdate on\``);
+    return fail2(`"${LAUNCHD_LABEL}" is registered but not loaded \u2014 run \`mmi-hub autoupdate on\``);
   }
   const points = `points at ${hubDist ?? "the registered Hub dist"}`;
   return { ok: true, supported: true, enabled: true, ...EMPTY_RUN_INFO, detail: `"${LAUNCHD_LABEL}" registered ${POSIX_CADENCE}; ${points}` };
@@ -2820,20 +3564,20 @@ function linuxSchedulerStatus(env) {
   }
   const hubDist = globalDist(env, "@mutmutco/hub", "dist/index.cjs");
   const launcherPath = (0, import_node_path12.join)(statePaths(env).root, POSIX_LAUNCHER_FILE);
-  const fail = (detail) => ({ ok: false, supported: true, enabled: true, ...EMPTY_RUN_INFO, detail });
+  const fail2 = (detail) => ({ ok: false, supported: true, enabled: true, ...EMPTY_RUN_INFO, detail });
   if (!service.includes(launcherPath)) {
-    return fail(`"${SYSTEMD_SERVICE_NAME}" does not run the reconcile launcher ${launcherPath} \u2014 run \`mmi-hub autoupdate on\``);
+    return fail2(`"${SYSTEMD_SERVICE_NAME}" does not run the reconcile launcher ${launcherPath} \u2014 run \`mmi-hub autoupdate on\``);
   }
   const launcher = readFileOrNull(launcherPath);
   if (hubDist && !launcher?.includes(hubDist)) {
-    return fail(`"${SYSTEMD_SERVICE_NAME}" launcher does not point at the current @mutmutco/hub dist ${hubDist} \u2014 run \`mmi-hub autoupdate on\``);
+    return fail2(`"${SYSTEMD_SERVICE_NAME}" launcher does not point at the current @mutmutco/hub dist ${hubDist} \u2014 run \`mmi-hub autoupdate on\``);
   }
   if (!timer.includes(`OnUnitActiveSec=${STARTINTERVAL_SECONDS}`)) {
-    return fail(`"${SYSTEMD_TIMER_NAME}" has no ${STARTINTERVAL_SECONDS}s OnUnitActiveSec \u2014 run \`mmi-hub autoupdate on\``);
+    return fail2(`"${SYSTEMD_TIMER_NAME}" has no ${STARTINTERVAL_SECONDS}s OnUnitActiveSec \u2014 run \`mmi-hub autoupdate on\``);
   }
   const enabled = systemctlUser(["is-enabled", SYSTEMD_TIMER_NAME]);
   if (enabled.status !== 0) {
-    return fail(`"${SYSTEMD_TIMER_NAME}" is registered but not enabled \u2014 run \`mmi-hub autoupdate on\``);
+    return fail2(`"${SYSTEMD_TIMER_NAME}" is registered but not enabled \u2014 run \`mmi-hub autoupdate on\``);
   }
   const points = `points at ${hubDist ?? "the registered Hub dist"}`;
   return { ok: true, supported: true, enabled: true, ...EMPTY_RUN_INFO, detail: `"${SYSTEMD_TIMER_NAME}" registered ${POSIX_CADENCE}, ${RUN_BOUND_SECONDS}s bound; ${points}` };
@@ -2859,9 +3603,9 @@ function installWindowsTask(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_fs15.writeFileSync)(launcherPath, launcherVbs(process.execPath, hubDist), "utf8");
+  (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_fs15.writeFileSync)(xmlPath, "\uFEFF" + taskXml(launcherPath, paths.root, userId, localStartBoundary(/* @__PURE__ */ new Date())), "utf16le");
+  (0, import_node_fs19.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);
@@ -2880,8 +3624,8 @@ function refreshPosixLauncher(env) {
   const launcherPath = (0, import_node_path12.join)(paths.root, POSIX_LAUNCHER_FILE);
   const desired = launcherSh(process.execPath, hubDist);
   if (readFileOrNull(launcherPath) === desired) return null;
-  (0, import_node_fs15.writeFileSync)(launcherPath, desired, "utf8");
-  (0, import_node_fs15.chmodSync)(launcherPath, 493);
+  (0, import_node_fs19.writeFileSync)(launcherPath, desired, "utf8");
+  (0, import_node_fs19.chmodSync)(launcherPath, 493);
   return launcherPath;
 }
 function installLaunchd(env) {
@@ -2894,12 +3638,12 @@ function installLaunchd(env) {
   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_fs15.writeFileSync)(launcherPath, launcherSh(process.execPath, hubDist), "utf8");
-  (0, import_node_fs15.chmodSync)(launcherPath, 493);
+  (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_fs15.mkdirSync)(agentsDir, { recursive: true });
+  (0, import_node_fs19.mkdirSync)(agentsDir, { recursive: true });
   const plistPath = (0, import_node_path12.join)(agentsDir, LAUNCHD_PLIST_NAME);
-  (0, import_node_fs15.writeFileSync)(plistPath, launchdPlist(launcherPath, paths.root), "utf8");
+  (0, import_node_fs19.writeFileSync)(plistPath, launchdPlist(launcherPath, paths.root), "utf8");
   launchctl(["bootout", `gui/${uid()}/${LAUNCHD_LABEL}`]);
   const load = launchctl(["bootstrap", `gui/${uid()}`, plistPath]);
   if (load.status !== 0) {
@@ -2918,12 +3662,12 @@ function installSystemdTimer(env) {
   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_fs15.writeFileSync)(launcherPath, launcherSh(process.execPath, hubDist), "utf8");
-  (0, import_node_fs15.chmodSync)(launcherPath, 493);
+  (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_fs15.mkdirSync)(unitDir, { recursive: true });
-  (0, import_node_fs15.writeFileSync)((0, import_node_path12.join)(unitDir, SYSTEMD_SERVICE_NAME), systemdServiceUnit(launcherPath, paths.root), "utf8");
-  (0, import_node_fs15.writeFileSync)((0, import_node_path12.join)(unitDir, SYSTEMD_TIMER_NAME), systemdTimerUnit(), "utf8");
+  (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 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?"}` };
@@ -2963,11 +3707,11 @@ function uninstallWindowsTask(env) {
 function uninstallLaunchd(env) {
   const plistPath = (0, import_node_path12.join)((0, import_node_os6.homedir)(), "Library", "LaunchAgents", LAUNCHD_PLIST_NAME);
   const boot = launchctl(["bootout", `gui/${uid()}/${LAUNCHD_LABEL}`]);
-  if (boot.status !== 0 && (0, import_node_fs15.existsSync)(plistPath)) {
+  if (boot.status !== 0 && (0, import_node_fs19.existsSync)(plistPath)) {
     return { ok: false, detail: `launchctl bootout failed: ${(boot.stderr || boot.stdout).trim() || "unknown error"}` };
   }
   try {
-    (0, import_node_fs15.rmSync)(plistPath, { force: true });
+    (0, import_node_fs19.rmSync)(plistPath, { force: true });
   } catch {
   }
   dropLauncher(env, POSIX_LAUNCHER_FILE);
@@ -2977,12 +3721,12 @@ 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 disable = systemctlUser(["disable", "--now", SYSTEMD_TIMER_NAME]);
-  if (disable.status !== 0 && (0, import_node_fs15.existsSync)(timerPath)) {
+  if (disable.status !== 0 && (0, import_node_fs19.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_fs15.rmSync)(timerPath, { force: true });
-    (0, import_node_fs15.rmSync)((0, import_node_path12.join)(unitDir, SYSTEMD_SERVICE_NAME), { force: true });
+    (0, import_node_fs19.rmSync)(timerPath, { force: true });
+    (0, import_node_fs19.rmSync)((0, import_node_path12.join)(unitDir, SYSTEMD_SERVICE_NAME), { force: true });
   } catch {
   }
   systemctlUser(["daemon-reload"]);
@@ -2997,16 +3741,16 @@ function uninstallTask(env = process.env) {
 }
 function dropLauncher(env, file) {
   try {
-    (0, import_node_fs15.rmSync)((0, import_node_path12.join)(statePaths(env).root, file), { force: true });
+    (0, import_node_fs19.rmSync)((0, import_node_path12.join)(statePaths(env).root, file), { force: true });
   } catch {
   }
 }
 
 // src/status.ts
-var import_node_fs16 = require("node:fs");
+var import_node_fs20 = require("node:fs");
 function readJournal(path) {
   try {
-    const events = (0, import_node_fs16.readFileSync)(path, "utf8").split("\n").filter((line) => line.trim()).map((line) => {
+    const events = (0, import_node_fs20.readFileSync)(path, "utf8").split("\n").filter((line) => line.trim()).map((line) => {
       try {
         return JSON.parse(line);
       } catch {
@@ -3129,31 +3873,6 @@ function formatHubStatus(status) {
 }
 
 // src/report.ts
-var NAME_WIDTH = 8;
-var VERSION_WIDTH = 15;
-var DEFAULT_WIDTH = 100;
-var MIN_NOTE_SPACE = 8;
-var ACTIVATION_NOTE = {
-  claude: "next session",
-  codex: "next session",
-  jervcode: "next launch",
-  cursor: "on reload",
-  hermes: "after restart",
-  updater: "next run"
-};
-var GREEN = "\x1B[32m";
-var YELLOW = "\x1B[33m";
-var RED = "\x1B[31m";
-var RESET = "\x1B[0m";
-var ACCENT = "\x1B[38;2;125;211;252m";
-var MUTED = "\x1B[38;2;150;150;150m";
-var MM_GREEN = "\x1B[38;2;31;209;138m";
-function accent(text, color) {
-  return color ? ACCENT + text + RESET : text;
-}
-function brandLine(rest, color = false) {
-  return `${accent("mmi-hub", color)} \xB7 Mutatis Mutandis \u2014 ${rest}`;
-}
 var RETRY_HINTS = [
   [/applies when the host exits|applies on a quiet tick/, "installs when the app closes"],
   [/in flight|changed while/, "rerun update \u2014 host race"],
@@ -3182,257 +3901,34 @@ function failConsequence(row) {
   }
   return matchFirst(FAIL_CONSEQUENCE, detail) ?? "update failed \u2014 previous version kept";
 }
-function classify(arm) {
-  const kind = arm.verdict === "ok" ? arm.from !== null && arm.from === arm.to && !arm.launchStaged ? "current" : "updated" : arm.verdict === "skip" ? "keep" : arm.verdict === "defer" ? "retry" : "failed";
-  const note = kind === "updated" ? arm.launchStaged ? "next launch" : ACTIVATION_NOTE[arm.surface] ?? null : kind === "keep" ? "above target" : kind === "retry" ? retryHint(arm.detail) : null;
-  return { name: arm.surface === "updater" ? "hub" : arm.surface, from: arm.from, to: arm.to, kind, note, detail: arm.detail, repeatFailure: arm.repeatFailure === true };
-}
-function statusText(kind, dryRun) {
-  if (dryRun && kind === "updated") return "would update";
-  switch (kind) {
-    case "updated":
-      return "updated";
-    case "current":
-      return "current";
-    case "keep":
-      return "keep";
-    case "retry":
-      return "retry";
-    case "failed":
-      return "failed";
-    case "pending":
-      return "pending";
-  }
-}
-function glyphFor(kind) {
-  switch (kind) {
-    case "updated":
-      return "\u2713";
-    case "current":
-      return "\u2713";
-    case "keep":
-      return "\u2713";
-    case "retry":
-      return "\u21BB";
-    case "failed":
-      return "\u2717";
-    case "pending":
-      return "\xB7";
-  }
-}
-function colorFor(kind) {
-  return kind === "failed" ? RED : kind === "retry" ? YELLOW : GREEN;
-}
-var ARM_TITLE = {
-  updater: "Updating mmi-hub",
-  cli: "Installing mmi-cli",
-  claude: "Arming Claude Code",
-  codex: "Arming Codex",
-  cursor: "Arming Cursor",
-  hermes: "Arming Hermes",
-  jervcode: "Arming JervCode"
-};
-var FACE_PRODUCT = "mmi-hub";
-function updaterFace(options = {}) {
-  return createFace({ product: FACE_PRODUCT, color: options.color ?? false, columns: options.width });
-}
-var STATE_WORD = {
-  updated: "updated",
-  current: "current",
-  keep: "kept",
-  retry: "will retry",
-  failed: "failed",
-  pending: "pending"
-};
-function stepKindFor(kind) {
-  return kind === "failed" ? "fail" : kind === "retry" ? "note" : "ok";
-}
-function checklistLine(arm, seconds, face, options = {}) {
-  const { kind } = classify(arm);
-  const state = options.dryRun && kind === "updated" ? "would update" : STATE_WORD[kind];
-  const title = `${ARM_TITLE[arm.surface] ?? `Arming ${arm.surface}`} \u2014 ${state}`;
-  const truthful = kind === "failed" || kind === "retry" ? null : seconds;
-  return face.step(title, truthful, stepKindFor(kind));
-}
-function receiptText(summary, autoupdate, options = {}) {
-  const dry = options.dryRun ?? false;
-  const counts = reportCounts(summary);
-  const health = "Check health any time:  mmi-hub status";
-  if (!summary.target) {
-    return [`${summary.exit >= 1 ? "\u2716" : "\u25CF"}  mmi-hub is not ready \u2014 no green release yet (hourly retry)`, "", health];
-  }
-  const ready = counts.failed === 0;
-  const glyph = counts.failed > 0 ? "\u2716" : counts.retry > 0 ? "\u25CF" : dry ? "\u25CF" : "\u2714";
-  const state = counts.failed > 0 ? `${counts.failed} of ${counts.total} surfaces failed` : counts.retry > 0 ? `${counts.retry} of ${counts.total} surfaces will retry` : counts.updated > 0 ? `${counts.updated}/${counts.total} surfaces ${dry ? "would update" : "updated"}` : `all ${counts.total} surfaces current`;
-  const tail2 = autoupdate ? ` \xB7 ${autoupdate.ok ? "auto-update on" : `auto-update NOT enabled \u2014 ${autoupdate.detail}`}` : ` \xB7 ${summary.target}${dry ? " (planned)" : " (verified)"}`;
-  return [`${glyph}  mmi-hub is ${ready ? "ready" : "not ready"} \u2014 ${state}${tail2}`, "", health];
-}
-function autoupdateLine(state) {
-  return state.ok ? 'Auto-update on \u2014 hourly task "MMI Fleet Updater".' : `Auto-update NOT enabled \u2014 ${state.detail}`;
-}
-function attentionRows(summary) {
-  return collectRows(summary).filter((row) => row.kind === "failed" || row.kind === "retry" || row.kind === "pending").map((row) => ({
-    surface: row.name,
-    state: statusText(row.kind, false),
-    mark: row.kind === "failed" ? "fail" : "note",
-    note: row.kind === "failed" ? failConsequence(row) : row.kind === "retry" ? retryHint(row.detail) : "arm not landed"
-  }));
-}
-function wrapWords2(text, available) {
-  if (available < 1) return [text];
-  const lines = [];
-  let current = "";
-  for (const word of text.split(/\s+/).filter(Boolean)) {
-    const piece = word.length > available ? word.slice(0, Math.max(1, available - 1)) + "\u2026" : word;
-    if (!current) current = piece;
-    else if (current.length + 1 + piece.length <= available) current += " " + piece;
-    else {
-      lines.push(current);
-      current = piece;
-    }
-  }
-  if (current) lines.push(current);
-  return lines.length ? lines : [""];
-}
-function noteLines(prefix, note, width) {
-  const used = stripAnsi(prefix).length;
-  const available = width - used - 1;
-  const indent = available >= MIN_NOTE_SPACE ? " ".repeat(used + 1) : " ".repeat(Math.min(used + 1, Math.max(2, width - MIN_NOTE_SPACE)));
-  const room = available >= MIN_NOTE_SPACE ? available : width - indent.length;
-  const parts = wrapWords2(note, room);
-  const first = available >= MIN_NOTE_SPACE ? prefix + " " + parts[0] : prefix.replace(/\s+$/, "");
-  const lines = [first];
-  for (const part of parts.slice(available >= MIN_NOTE_SPACE ? 1 : 0)) lines.push(indent + part);
-  return lines;
-}
-function stripAnsi(text) {
-  return text.replace(/\x1b\[[0-9;]*m/g, "");
-}
-function collectRows(summary) {
-  const rows = [];
-  if (summary.updater) rows.push(classify(summary.updater));
-  if (summary.cli) rows.push(classify(summary.cli));
-  for (const arm of summary.plugins) rows.push(classify(arm));
-  for (const surface of summary.surfaces) {
-    if (surface.present && surface.action === "arm-pending") {
-      rows.push({ name: surface.id, from: null, to: summary.target ?? "?", kind: "pending", note: "arm not landed", detail: "", repeatFailure: false });
-    }
-  }
-  return rows;
-}
-function headline(detail, width) {
-  const first = (detail ?? "").split(/(?<=[.;:])\s/)[0]?.replace(/\s+/g, " ").trim() ?? "";
-  return wrapWords2(first || "blocked", Math.max(10, width - 4))[0];
-}
-function updateHeader(target, dryRun = false, options) {
-  return brandLine(
-    dryRun ? `update plan to ${target} (dry run)` : `updating to ${target} (verified)`,
-    Boolean(options?.color)
-  );
-}
-function renderRowLines(row, ctx) {
-  const paint = (kind, text) => ctx.color ? colorFor(kind) + text + RESET : text;
-  const versions = row.from !== null && row.from !== row.to ? `${row.from} \u2192 ${row.to}` : `${row.to}`;
-  const glyph = ctx.tty ? glyphFor(row.kind) + " " : "";
-  const status = statusText(row.kind, ctx.dryRun).padEnd(ctx.statusWidth);
-  const prefix = "  " + row.name.padEnd(NAME_WIDTH) + "  " + versions.padEnd(VERSION_WIDTH) + "  " + paint(row.kind, glyph + status);
-  return row.note ? noteLines(prefix, row.note, ctx.width) : [prefix.replace(/\s+$/, "")];
-}
-function progressiveStatusWidth(dryRun) {
-  return Math.max((dryRun ? "would update" : "updated").length, 7);
-}
-function progressiveRow(arm, options = {}) {
-  const width = Math.max(40, options.width ?? DEFAULT_WIDTH);
-  const tty = options.tty ?? false;
-  const color = tty && (options.color ?? true);
-  const dryRun = options.dryRun ?? false;
-  return renderRowLines(classify(arm), { tty, color, dryRun, width, statusWidth: progressiveStatusWidth(dryRun) }).join("\n");
-}
 function reportCounts(summary) {
-  const rows = collectRows(summary);
-  return {
-    updated: rows.filter((row) => row.kind === "updated").length,
-    current: rows.filter((row) => row.kind === "current" || row.kind === "keep").length,
-    retry: rows.filter((row) => row.kind === "retry").length,
-    failed: rows.filter((row) => row.kind === "failed").length,
-    total: rows.length
+  const counts2 = {
+    updated: 0,
+    current: 0,
+    retry: 0,
+    failed: 0,
+    total: summary.surfaces.filter((surface) => surface.present && surface.action === "arm-pending").length
   };
-}
-function reportFooterLines(summary, options = {}) {
-  const width = Math.max(40, options.width ?? DEFAULT_WIDTH);
-  const tty = options.tty ?? false;
-  const color = tty && (options.color ?? true);
-  const dryRun = options.dryRun ?? false;
-  const journalPath = options.journalPath ?? "~/.mmi/updater/journal.jsonl";
-  const paint = (kind, text) => color ? colorFor(kind) + text + RESET : text;
-  const rows = collectRows(summary);
-  const counts = reportCounts(summary);
-  const footer = dryRun ? `${counts.updated}/${counts.total} would update` : `${counts.updated}/${counts.total} updated` + (counts.retry ? ` \xB7 ${counts.retry} will retry` : "") + (counts.failed ? ` \xB7 ${counts.failed} failed` : "");
-  const out = ["", "  " + footer];
-  if (tty && !dryRun && counts.failed === 0) {
-    out.push("  " + (color ? MUTED + "Suggested next: mmi-cli doctor" + RESET : "Suggested next: mmi-cli doctor"));
-  }
-  const self = summary.updater;
-  if (!dryRun && self && self.from && self.to && self.from !== self.to && self.verdict !== "fail") {
-    out.push("");
-    out.push(...noteLines(
-      "  note: ",
-      `hub moved ${self.from} \u2192 ${self.to} while the surfaces above were converging, so they used ${self.from} logic \u2014 rerun \`mmi-hub update\` to bring them to ${self.to}`,
-      width
-    ));
-  }
-  if (counts.failed) {
-    out.push("");
-    for (const row of rows.filter((row2) => row2.kind === "failed")) {
-      const mark = tty ? paint("failed", "\u2717 ") : "";
-      out.push(...noteLines("  " + mark + row.name, failConsequence(row), width));
-      out.push(...noteLines("     fix: ", row.repeatFailure ? "doctor + update already tried and did not clear this \u2014 see log, do not repeat" : "mmi-cli doctor, then mmi-hub update", width));
-      out.push(...noteLines("     log: ", journalPath, width));
-    }
-  }
-  return out;
-}
-function formatReconcileReport(summary, options = {}) {
-  const width = Math.max(40, options.width ?? DEFAULT_WIDTH);
-  const tty = options.tty ?? false;
-  const color = tty && (options.color ?? true);
-  const dryRun = options.dryRun ?? false;
-  const out = [];
-  const paint = (kind, text) => color ? colorFor(kind) + text + RESET : text;
-  const rows = collectRows(summary);
-  const counts = reportCounts(summary);
-  if (!summary.target) {
-    if ((summary.exit >= 1 || summary.deferred) && summary.detail) {
-      out.push("MMI Hub \u2014 cannot update now");
-      out.push(...noteLines("  " + paint("failed", "blocked"), headline(summary.detail, width), width));
-      out.push(...noteLines("  fix:", retryHint(summary.detail), width));
-    } else {
-      out.push("MMI Hub \u2014 release still publishing, nothing changed (hourly retry)");
-    }
-    return out.join("\n") + "\n";
-  }
-  const allCurrent = rows.length > 0 && counts.updated === 0 && counts.retry === 0 && counts.failed === 0 && rows.every((row) => row.kind === "current" || row.kind === "keep");
-  if (allCurrent && !dryRun) {
-    out.push(`MMI Hub \u2014 MMI is up to date (${summary.target} \xB7 verified)`);
-    return out.join("\n") + "\n";
+  for (const arm of [summary.updater, summary.cli, ...summary.plugins]) {
+    if (!arm) continue;
+    counts2.total++;
+    if (arm.verdict === "fail") counts2.failed++;
+    else if (arm.verdict === "defer") counts2.retry++;
+    else if (arm.verdict === "skip" || arm.from !== null && arm.from === arm.to && !arm.launchStaged) counts2.current++;
+    else counts2.updated++;
   }
-  out.push(updateHeader(summary.target, dryRun, { color }));
-  out.push("");
-  const statusWidth = Math.max(...rows.map((row) => statusText(row.kind, dryRun).length), 7);
-  for (const row of rows) out.push(...renderRowLines(row, { tty, color, dryRun, width, statusWidth }));
-  out.push(...reportFooterLines(summary, options));
-  return out.join("\n") + "\n";
+  return counts2;
 }
 
 // src/stamp.ts
-var import_node_fs17 = require("node:fs");
+var import_node_fs21 = 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_fs17.readFileSync)(paths.journalPath, "utf8").split("\n").filter((line) => line.trim()).map((line) => {
+    events = (0, import_node_fs21.readFileSync)(paths.journalPath, "utf8").split("\n").filter((line) => line.trim()).map((line) => {
       try {
         return JSON.parse(line);
       } catch {
@@ -3482,7 +3978,7 @@ function fleetStamp(env = process.env) {
 // src/index.ts
 function ownVersion() {
   try {
-    return JSON.parse((0, import_node_fs18.readFileSync)((0, import_node_path13.join)(__dirname, "..", "package.json"), "utf8")).version;
+    return JSON.parse((0, import_node_fs22.readFileSync)((0, import_node_path13.join)(__dirname, "..", "package.json"), "utf8")).version;
   } catch {
     return "0.0.0";
   }
@@ -3502,147 +3998,34 @@ var HELP = `mmi-hub ${ownVersion()} \u2014 install and maintain MMI tooling
 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.`;
-function humanOptions(dryRun) {
-  return {
-    tty: Boolean(process.stdout.isTTY),
-    color: !process.env.NO_COLOR,
-    width: process.stdout.columns ?? 100,
-    dryRun,
-    journalPath: statePaths(process.env).journalPath
-  };
-}
-function printReconcile(summary, json, dryRun = false) {
-  if (json) {
-    process.stdout.write(JSON.stringify(summary, null, 2) + "\n");
-    return;
-  }
-  process.stdout.write(formatReconcileReport(summary, humanOptions(dryRun)));
-}
-function faceEnabled(args, json) {
-  return !json && !args.includes("--verbose") && !process.env.NO_COLOR && process.env.TERM !== "dumb" && Boolean(process.stdout.isTTY) && Boolean(process.stderr.isTTY);
-}
-function openFace(args, json, dryRun) {
-  if (!faceEnabled(args, json)) return null;
-  const face = updaterFace(humanOptions(dryRun));
-  if (!process.env.MMI_UPDATER_REEXEC) for (const line of face.welcome()) process.stdout.write(line + "\n");
-  return face;
-}
-function finishFace(face, summary, autoupdate, dryRun) {
-  const options = humanOptions(dryRun);
-  const write = (line) => {
-    process.stdout.write(line + "\n");
-  };
-  if (!summary.target) {
-    process.stdout.write(formatReconcileReport(summary, { ...options, tty: false }));
-  } else {
-    for (const line of renderRows(face, attentionRows(summary))) write(line);
-  }
-  const body = receiptText(summary, autoupdate, { dryRun });
-  const counts = reportCounts(summary);
-  if (counts.failed > 0) {
-    body.push("", "Fix: mmi-cli doctor, then mmi-hub update", `Log: ${options.journalPath}`);
-  }
-  const self = summary.updater;
-  if (!dryRun && self && self.from && self.to && self.from !== self.to && self.verdict !== "fail") {
-    body.push("", `Note: hub moved ${self.from} \u2192 ${self.to} while the surfaces above were converging, so they used ${self.from} logic \u2014 rerun \`mmi-hub update\` to bring them to ${self.to}`);
-  }
-  for (const line of face.receipt(body)) write(line);
-  write(face.signOff());
-}
-function handOff(reexec, args) {
+function handOff(reexec, args, env) {
   const child = (0, import_node_child_process9.spawnSync)(process.execPath, [reexec.dist, ...args], {
     stdio: "inherit",
     windowsHide: true,
-    env: { ...process.env, MMI_UPDATER_REEXEC: "1" }
+    env: { ...env, MMI_UPDATER_REEXEC: "1" }
   });
   if (child.error || typeof child.status !== "number") {
-    process.stderr.write(`mmi-hub: could not run the updated updater at ${reexec.dist} \u2014 ${child.error?.message ?? "no exit status"}; rerun \`mmi-hub update\`
-`);
-    return 1;
+    throw new Error(`could not run the updated updater at ${reexec.dist} \u2014 ${child.error?.message ?? "no exit status"}; rerun mmi-hub update`);
   }
   return child.status;
 }
-function heldOutput(write) {
-  const held = [];
-  let streaming = false;
-  return {
-    emit: (line) => {
-      if (streaming) write(line);
-      else held.push(line);
-    },
-    stream: () => {
-      if (streaming) return;
-      streaming = true;
-      for (const line of held) write(line);
-      held.length = 0;
-    }
-  };
-}
 function shippedTargetFrom(args) {
   const index = args.indexOf("--shipped");
   if (index < 0) return void 0;
   const value = (args[index + 1] ?? "").trim();
   return value && !value.startsWith("--") ? value : void 0;
 }
-async function runUpdate(args, json, face = null, shippedTarget) {
-  const dryRun = args.includes("--dry-run");
-  const verbose = args.includes("--verbose");
-  const narrate = (line) => {
-    process.stderr.write(`mmi-hub: ${line}
-`);
-  };
-  const progressive = !json && !verbose && Boolean(process.stderr.isTTY);
-  if (!progressive) {
-    return reconcile({ dryRun, narrate: verbose ? narrate : void 0, shippedTarget }).then((summary2) => ({ summary: summary2, rendered: false }));
-  }
-  const reportOptions = humanOptions(dryRun);
-  const spinner = createSpinner(face ?? updaterFace(reportOptions), { animate: true, stream: process.stderr });
-  let spinning = false;
-  const phase = (line) => {
-    if (spinning) spinner.say(line);
-    else {
-      spinner.start(line);
-      spinning = true;
-    }
-  };
-  const persist = (line) => {
-    if (spinning) {
-      spinner.stop();
-      spinning = false;
-    }
-    process.stdout.write(line + "\n");
-  };
-  let headerEmitted = false;
-  let summary;
-  const { emit, stream } = heldOutput(persist);
-  let arms = 0;
-  let mark = Date.now();
-  try {
-    summary = await reconcile({
-      dryRun,
-      shippedTarget,
-      onPhase: (line) => phase(line),
-      onTargetResolved: face ? void 0 : (target) => {
-        emit(updateHeader(target, dryRun, reportOptions));
-        emit("");
-        headerEmitted = true;
-      },
-      onArm: (arm) => {
-        const seconds = (Date.now() - mark) / 1e3;
-        mark = Date.now();
-        if (arms++) stream();
-        emit(face ? checklistLine(arm, seconds, face, reportOptions) : progressiveRow(arm, reportOptions));
-      }
-    });
-  } finally {
-    spinner.stop();
-  }
-  if (summary.reexec) return { summary, rendered: true };
-  stream();
-  if (face) return { summary, rendered: true };
-  if (headerEmitted) process.stdout.write(reportFooterLines(summary, reportOptions).join("\n") + "\n");
-  else process.stdout.write(formatReconcileReport(summary, reportOptions));
-  return { summary, rendered: true };
+function runMaintenance2(args, dependencies = {}) {
+  return runMaintenance(installer_product_default, args, {
+    engine: dependencies.reconcile ?? reconcile,
+    schedule: dependencies.schedule ?? installTask,
+    handOff: dependencies.handOff ?? handOff,
+    run: dependencies.run,
+    shippedTarget: shippedTargetFrom(args),
+    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)) {
   if (args.includes("--version")) {
@@ -3660,41 +4043,7 @@ async function main(args = process.argv.slice(2)) {
     process.stdout.write(json ? JSON.stringify(status, null, 2) + "\n" : formatHubStatus(status) + "\n");
     return status.failures.length ? 1 : 0;
   }
-  if (command === "update") {
-    const dryRun = args.includes("--dry-run");
-    const face = openFace(args, json, dryRun);
-    const { summary, rendered } = await runUpdate(args, json, face);
-    if (summary.reexec) return handOff(summary.reexec, args);
-    if (face) finishFace(face, summary, null, dryRun);
-    else if (!rendered) printReconcile(summary, json, dryRun);
-    return summary.exit;
-  }
-  if (command === "install") {
-    const dryRun = args.includes("--dry-run");
-    const face = openFace(args, json, dryRun);
-    const shippedTarget = shippedTargetFrom(args);
-    const { summary, rendered } = await runUpdate(args, json, face, shippedTarget);
-    if (summary.reexec) {
-      const handedOff = handOff(summary.reexec, ["update", ...args.filter((arg) => arg !== "install" && arg !== "--shipped" && arg !== shippedTarget)]);
-      const scheduled = installTask();
-      if (!json) {
-        process.stdout.write(autoupdateLine(scheduled) + "\n");
-      } else {
-        process.stdout.write(JSON.stringify({ convergence: summary, autoupdate: scheduled }, null, 2) + "\n");
-      }
-      return Math.max(handedOff, scheduled.ok ? 0 : 1);
-    }
-    const schedule = installTask();
-    if (json) {
-      process.stdout.write(JSON.stringify({ convergence: summary, autoupdate: schedule }, null, 2) + "\n");
-    } else if (face) {
-      finishFace(face, summary, schedule, dryRun);
-    } else {
-      if (!rendered) printReconcile(summary, false, dryRun);
-      process.stdout.write(autoupdateLine(schedule) + "\n");
-    }
-    return Math.max(summary.exit, schedule.ok ? 0 : 1);
-  }
+  if (command === "update" || command === "install") return runMaintenance2(args);
   if (command === "autoupdate") {
     const commandIndex = args.indexOf(command);
     const mode = args[commandIndex + 1];
@@ -3719,27 +4068,18 @@ if (typeof require !== "undefined" && require.main === module) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  ACCENT,
-  FACE_PRODUCT,
-  MM_GREEN,
-  RESET,
-  accent,
   acquireSharedDocLock,
-  attentionRows,
-  autoupdateLine,
-  brandLine,
+  assertFaceConformance,
   buildWatcherCommand,
   checkAtomicity,
-  checklistLine,
   claudeArm,
   claudeHostEvidence,
   clearLaunchTarget,
   clearPending,
+  createInstallerRun,
   enumerateSurfaces,
   failConsequence,
   fleetStamp,
-  formatReconcileReport,
-  heldOutput,
   hermesArm,
   hermesHome,
   hermesHomes,
@@ -3766,17 +4106,15 @@ if (typeof require !== "undefined" && require.main === module) {
   probeHermesLaunchStaging,
   probeJervcodeInstallation,
   probeLaunchTargetVersion,
-  progressiveRow,
   readLaunchTarget,
   readPending,
-  receiptText,
   reconcile,
   reconcileCursorUserHooks,
   releaseSharedDocLock,
   reportCounts,
-  reportFooterLines,
   retiredSurfaces,
   retryHint,
+  runMaintenance,
   schedulePendingWatcher,
   schedulerStatus,
   sharedDocLockPath,
@@ -3787,11 +4125,8 @@ if (typeof require !== "undefined" && require.main === module) {
   systemdServiceUnit,
   systemdTimerUnit,
   taskXml,
-  updateHeader,
-  updaterFace,
   watcherLockPath,
   withSharedDocLock,
-  wrapWords,
   writeLaunchTarget,
   writePending
 });