@mutmutco/hub 3.139.10 → 3.139.12

package/README.md

@@ -24,6 +24,21 @@ mmi-hub autoupdate on|off         idempotently enable or disable scheduling; off
 
 `status` and the no-argument command are read-only. They never install, heal, create state, change the schedule, or clean a repository.
 
+`update`/`install` print a lean, human report (glyphs and color only on an interactive terminal, `NO_COLOR` respected; no line ever exceeds the terminal width):
+
+```
+MMI Hub — updating to 3.139.11 (verified)
+
+  cli       3.139.10 → 3.139.11   updated
+  claude    3.139.10 → 3.139.11   updated next session
+  codex     3.139.10 → 3.139.11   retry   rerun update — host race
+  hub       3.139.10 → 3.139.11   updated next run
+
+  3/4 updated · 1 will retry
+```
+
+Failures close with an action block — consequence, fix command, journal path — never a raw host error. An up-to-date run prints a single line.
+
 State remains under `~/.mmi/updater` (override with `$MMI_UPDATER_HOME`) so existing journals and the **MMI Fleet Updater** Windows task continue in place.
 
 `@mutmutco/updater@3.137.0` was the final historical compatibility release and remains installable for existing lockfiles. Its `mmi-updater` wrapper delegates to the exact-version `@mutmutco/hub`: old `reconcile`/`run`, `install`, `uninstall`, and `verify`/`stamp` calls map to `mmi-hub update`, `install`, `autoupdate off`, and `status` respectively. New installs and all releases after 3.137.0 use only `@mutmutco/hub` / `mmi-hub`.

package/dist/index.cjs

@@ -22,6 +22,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   enumerateSurfaces: () => enumerateSurfaces,
+  failConsequence: () => failConsequence,
+  formatReconcileReport: () => formatReconcileReport,
   hermesArm: () => hermesArm,
   hermesHome: () => hermesHome,
   hubStatus: () => hubStatus,
@@ -30,8 +32,14 @@ __export(index_exports, {
   main: () => main,
   ownVersion: () => ownVersion,
   probeHermesInstallation: () => probeHermesInstallation,
+  progressiveRow: () => progressiveRow,
+  reportFooterLines: () => reportFooterLines,
+  retryHint: () => retryHint,
   schedulerStatus: () => schedulerStatus,
-  taskXml: () => taskXml
+  startSpinner: () => startSpinner,
+  taskXml: () => taskXml,
+  updateHeader: () => updateHeader,
+  wrapWords: () => wrapWords
 });
 module.exports = __toCommonJS(index_exports);
 var import_node_fs16 = require("node:fs");
@@ -643,6 +651,7 @@ function claudeArm(options) {
   }
   return { surface: "claude", from, to: options.target, verdict: "ok", detail: `catalog refreshed; converged and verified ${from ?? "absent"} -> ${options.target}` };
 }
+var SNAPSHOT_MISSING = /marketplace snapshot|marketplace root does not contain/i;
 function codexMmi(runner, env) {
   const result = runner("codex", ["plugin", "list", "--json"], env);
   const parsed = parseJson(result);
@@ -652,7 +661,14 @@ function codexMmi(runner, env) {
 function codexArm(options) {
   const env = options.env ?? process.env;
   const runner = options.runner ?? runHostCommand;
-  const before = codexMmi(runner, env);
+  let before = codexMmi(runner, env);
+  if (before.error && SNAPSHOT_MISSING.test(before.error) && !options.dryRun) {
+    const restore = runner("codex", ["plugin", "marketplace", "upgrade"], env);
+    if (restore.status !== 0) {
+      return { surface: "codex", from: null, to: options.target, verdict: "defer", detail: `marketplace snapshots missing and refresh failed: ${failure(restore)}` };
+    }
+    before = codexMmi(runner, env);
+  }
   if (before.error) return { surface: "codex", from: null, to: options.target, verdict: "defer", detail: before.error };
   const from = before.row?.version ?? null;
   if (options.dryRun) {
@@ -1352,6 +1368,25 @@ function discard2(path) {
 function message2(error) {
   return String(error?.message ?? error).replace(/\s+/g, " ").slice(0, 200);
 }
+function materializeHermesSkills(home) {
+  const pluginSkills = (0, import_node_path10.join)(home, "plugins", "mmi", "skills");
+  const skillsRoot = (0, import_node_path10.join)(home, "skills");
+  const targetRoot = (0, import_node_path10.join)(skillsRoot, "mmi");
+  try {
+    if (!(0, import_node_fs12.existsSync)(pluginSkills)) return { ok: false, detail: `plugin skills tree missing at ${pluginSkills}` };
+    const names = (0, import_node_fs12.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_fs12.mkdirSync)(skillsRoot, { recursive: true });
+    const incoming = (0, import_node_path10.join)(skillsRoot, ".mmi-incoming");
+    discard2(incoming);
+    (0, import_node_fs12.cpSync)(pluginSkills, incoming, { recursive: true });
+    discard2(targetRoot);
+    (0, import_node_fs12.renameSync)(incoming, targetRoot);
+    return { ok: true, detail: `provisioned ${names.length} skills to ${targetRoot}` };
+  } catch (error) {
+    return { ok: false, detail: message2(error) };
+  }
+}
 function hermesArm(options) {
   const env = options.env ?? process.env;
   const home = hermesHome(env);
@@ -1372,8 +1407,12 @@ function hermesArm(options) {
   if (installed && compareSemver(installed, options.target) > 0) return result(installed, installed, "skip", `installed ${installed} is above candidate ${options.target} (monotonic)`);
   const highWater = journalHighWater(options.paths.journalPath, "hermes");
   if (highWater && compareSemver(highWater, options.target) > 0) return result(installed, highWater, "skip", `journal high-water ${highWater} is above candidate ${options.target} (monotonic)`);
-  if (installed === options.target && treeHealthy3(live)) return result(installed, options.target, "ok", `already at target ${options.target}`);
-  if (options.dryRun) return result(installed, options.target, "ok", `dry-run: would stage ${PACKAGE2}@${options.target} and atomically switch ${installed ?? "absent"} -> ${options.target}`);
+  if (installed === options.target && treeHealthy3(live)) {
+    const skills2 = materializeHermesSkills(home);
+    if (!skills2.ok) return result(installed, options.target, "fail", `plugin at target ${options.target}, but skills provisioning failed: ${skills2.detail}`);
+    return result(installed, options.target, "ok", `already at target ${options.target}; ${skills2.detail}`);
+  }
+  if (options.dryRun) return result(installed, options.target, "ok", `dry-run: would stage ${PACKAGE2}@${options.target}, atomically switch ${installed ?? "absent"} -> ${options.target}, then provision skills into ${(0, import_node_path10.join)(home, "skills", "mmi")}`);
   const staged = stagePackage({ surface: "hermes", packageName: PACKAGE2, target: options.target, witness: MANIFEST2, paths: options.paths, env });
   if ("defer" in staged) return result(installed, options.target, "defer", staged.defer);
   if (yamlVersion(staged.packageRoot) !== options.target || !treeHealthy3(staged.packageRoot)) {
@@ -1419,7 +1458,9 @@ function hermesArm(options) {
     return result(installed, displaced ? installed ?? "unknown" : "none", "fail", `post-switch Hermes verification failed; rejected generation parked at ${broken}${displaced ? "; previous generation restored" : ""}`);
   }
   discard2(incomingRoot);
-  return result(installed, options.target, "ok", `converged ${installed ?? "absent"} -> ${options.target} (staged, verified, atomically switched${displaced ? `; previous generation quarantined at ${quarantine}` : ""})`);
+  const skills = materializeHermesSkills(home);
+  if (!skills.ok) return result(installed, options.target, "fail", `plugin converged to ${options.target}, but skills provisioning failed: ${skills.detail}`);
+  return result(installed, options.target, "ok", `converged ${installed ?? "absent"} -> ${options.target} (staged, verified, atomically switched${displaced ? `; previous generation quarantined at ${quarantine}` : ""}); ${skills.detail}`);
 }
 
 // src/reap.ts
@@ -1732,7 +1773,10 @@ var REPO_URL_DEFAULT = "https://github.com/mutmutco/MMI-Hub.git";
 var CANDIDATE_BOUND_DEFAULT = 12;
 function reconcile(options) {
   const env = options.env ?? process.env;
-  const say = (line) => options.narrate?.(line);
+  const say = (line) => {
+    options.narrate?.(line);
+    options.onPhase?.(line);
+  };
   const run = `${(/* @__PURE__ */ new Date()).toISOString()}-${process.pid}`;
   const paths = ensureState(env);
   const repoUrl = env.MMI_UPDATER_REPO || REPO_URL_DEFAULT;
@@ -1744,6 +1788,7 @@ function reconcile(options) {
   const summary = { run, target: null, gate: null, atomicity: null, cli: null, updater: null, plugins: [], reap: [], surfaces: [], journalOk: true, exit: 0 };
   const recordArm = (arm) => {
     journal({ kind: "arm", surface: arm.surface, from: arm.from, to: arm.to, verdict: arm.verdict, detail: arm.detail, compat: arm.compat });
+    options.onArm?.(arm);
     if (arm.verdict === "defer") summary.exit = Math.max(summary.exit, 2);
     if (arm.verdict === "fail") summary.exit = Math.max(summary.exit, 3);
   };
@@ -1798,6 +1843,7 @@ function reconcile(options) {
         return summary;
       }
       say(`target v${summary.target} (${summary.gate})`);
+      options.onTargetResolved?.(summary.target, summary.gate);
       say(`cli: converging to v${summary.target}`);
       const cli = cliArm({ target: summary.target, dryRun: options.dryRun, paths, env });
       summary.cli = cli;
@@ -2145,6 +2191,276 @@ function formatHubStatus(status) {
   return lines.join("\n");
 }
 
+// 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",
+  kimi: "next session",
+  jervcode: "next launch",
+  cursor: "on reload",
+  kilo: "after restart",
+  hermes: "after restart",
+  updater: "next run"
+};
+var GREEN = "\x1B[32m";
+var YELLOW = "\x1B[33m";
+var RED = "\x1B[31m";
+var RESET = "\x1B[0m";
+var RETRY_HINTS = [
+  [/in flight|changed while/, "rerun update \u2014 host race"],
+  [/is running|live process|inside a .* hook/, "close app, rerun update"],
+  [/staging install failed|etarget|e404|network|fetch failed/, "check network/login, rerun"],
+  [/not on npm|no green|registry not ready/, "release still publishing"],
+  [/elevat|access is denied/, "run from elevated terminal"]
+];
+var FAIL_CONSEQUENCE = [
+  [/post-switch probe|post-update evidence|post-install evidence|expected .*\/true/, "not verified \u2014 previous version restored, safe to use"],
+  [/rollback|did not restore/, "rollback incomplete \u2014 run doctor now"]
+];
+function matchFirst(patterns, detail) {
+  const haystack = (detail ?? "").toLowerCase();
+  for (const [pattern, text] of patterns) if (pattern.test(haystack)) return text;
+  return null;
+}
+function retryHint(detail) {
+  return matchFirst(RETRY_HINTS, detail) ?? "retries next hourly run";
+}
+function failConsequence(detail) {
+  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 ? "current" : "updated" : arm.verdict === "skip" ? "keep" : arm.verdict === "defer" ? "retry" : "failed";
+  const note = kind === "updated" ? 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 };
+}
+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;
+}
+function wrapWords(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 = wrapWords(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.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: "" });
+    }
+  }
+  if (summary.updater) rows.push(classify(summary.updater));
+  return rows;
+}
+function headline(detail, width) {
+  const first = (detail ?? "").split(/(?<=[.;:])\s/)[0]?.replace(/\s+/g, " ").trim() ?? "";
+  return wrapWords(first || "blocked", Math.max(10, width - 4))[0];
+}
+function updateHeader(target, dryRun = false) {
+  return dryRun ? `MMI Hub \u2014 update plan to ${target} (dry run)` : `MMI Hub \u2014 updating to ${target} (verified)`;
+}
+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) + (row.kind === "updated" || row.kind === "retry" ? "" : " ") : "";
+  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 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 = {
+    updated: rows.filter((row) => row.kind === "updated").length,
+    retry: rows.filter((row) => row.kind === "retry").length,
+    failed: rows.filter((row) => row.kind === "failed").length,
+    total: rows.length
+  };
+  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 (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.detail), width));
+      out.push(...noteLines("     fix: ", `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 = {
+    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
+  };
+  if (!summary.target) {
+    if (summary.exit >= 1 && 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";
+  }
+  out.push(updateHeader(summary.target, dryRun));
+  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";
+}
+
+// src/spinner.ts
+var import_node_worker_threads = require("node:worker_threads");
+var FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+var WORKER_SRC = `
+const { parentPort, workerData } = require('node:worker_threads');
+const frames = ${JSON.stringify(FRAMES)};
+const control = new Int32Array(workerData.sab);
+let frame = 0, label = '', timer = null;
+function tick() {
+  if (Atomics.load(control, 0) === 1) return; // paused by the main thread
+  if (!label) return;
+  process.stderr.write('\\r' + frames[frame++ % frames.length] + ' ' + label + '\\x1b[K');
+}
+parentPort.on('message', (message) => {
+  if (message && message.type === 'label') { label = message.label; if (!timer) timer = setInterval(tick, 80); }
+  else if (message === 'stop') { if (timer) clearInterval(timer); process.stderr.write('\\r\\x1b[K'); process.exit(0); }
+});
+`;
+var NOOP = { label() {
+}, persist() {
+}, stop() {
+}, active: false };
+function startSpinner(enabled) {
+  if (!enabled) return NOOP;
+  let worker;
+  let control;
+  try {
+    const sab = new SharedArrayBuffer(4);
+    control = new Int32Array(sab);
+    worker = new import_node_worker_threads.Worker(WORKER_SRC, { eval: true, workerData: { sab } });
+    worker.unref();
+    worker.on("error", () => {
+    });
+  } catch {
+    return NOOP;
+  }
+  let stopped = false;
+  return {
+    active: true,
+    label: (text) => {
+      if (!stopped) worker.postMessage({ type: "label", label: text });
+    },
+    persist: (line) => {
+      Atomics.store(control, 0, 1);
+      process.stderr.write("\r\x1B[K");
+      process.stdout.write(line + "\n");
+      Atomics.store(control, 0, 0);
+    },
+    stop: () => {
+      if (stopped) return;
+      stopped = true;
+      worker.postMessage("stop");
+    }
+  };
+}
+
 // src/index.ts
 function ownVersion() {
   try {
@@ -2159,43 +2475,66 @@ var HELP = `mmi-hub ${ownVersion()} \u2014 install and maintain MMI tooling
                                    and actionable failures (default; never heals)
   install [--json]                 converge the CLI and every present host surface now, then enable
                                    hourly automatic updates
-  update [--dry-run] [--json]      converge immediately to the newest gated release
+  update [--dry-run] [--json] [--verbose]
+                                   converge immediately to the newest gated release: one line per
+                                   surface, a short reason only when not ok; --verbose traces steps
   autoupdate on|off                idempotently enable or disable hourly convergence; off keeps tools
   --version                        print the Hub maintenance package version
 
 State remains under $MMI_UPDATER_HOME (default ~/.mmi/updater), and the Windows task name remains
 "MMI Fleet Updater", so existing installations continue in place.
 Status performs no npm install, host repair, scheduler write, state mkdir, or repository cleanup.`;
-function printReconcile(summary, json) {
+function printReconcile(summary, json, dryRun = false) {
   if (json) {
     process.stdout.write(JSON.stringify(summary, null, 2) + "\n");
     return;
   }
-  const target = summary.target ?? "none (deferred)";
-  process.stdout.write(`mmi-hub: target ${target}
-`);
-  if (summary.cli) process.stdout.write(`  cli: ${summary.cli.verdict} \u2014 ${summary.cli.detail}
-`);
-  for (const arm of summary.plugins) process.stdout.write(`  ${arm.surface}: ${arm.verdict} \u2014 ${arm.detail}
-`);
-  if (summary.updater) process.stdout.write(`  hub: ${summary.updater.verdict} \u2014 ${summary.updater.detail}
-`);
-  for (const row of summary.reap.filter((entry) => entry.verdict !== "skip")) {
-    process.stdout.write(`  maintenance ${row.category}: ${row.verdict} \u2014 ${row.detail}
-`);
-  }
-  const armed = new Set(summary.plugins.map((arm) => arm.surface));
-  for (const surface of summary.surfaces.filter((surface2) => !armed.has(surface2.id))) {
-    process.stdout.write(`  ${surface.id}: ${surface.present ? "present" : "absent"} (${surface.action})
-`);
-  }
-}
-function runUpdate(args) {
+  process.stdout.write(formatReconcileReport(summary, {
+    tty: Boolean(process.stdout.isTTY),
+    color: !process.env.NO_COLOR,
+    width: process.stdout.columns ?? 100,
+    dryRun,
+    journalPath: statePaths(process.env).journalPath
+  }));
+}
+function runUpdate(args, json) {
+  const dryRun = args.includes("--dry-run");
+  const verbose = args.includes("--verbose");
   const narrate = (line) => {
     process.stderr.write(`mmi-hub: ${line}
 `);
   };
-  return reconcile({ dryRun: args.includes("--dry-run"), narrate });
+  const progressive = !json && !verbose && Boolean(process.stderr.isTTY);
+  if (!progressive) {
+    return { summary: reconcile({ dryRun, narrate: verbose ? narrate : void 0 }), rendered: false };
+  }
+  const reportOptions = {
+    tty: Boolean(process.stdout.isTTY),
+    color: !process.env.NO_COLOR,
+    width: process.stdout.columns ?? 100,
+    dryRun,
+    journalPath: statePaths(process.env).journalPath
+  };
+  const spinner = startSpinner(true);
+  let headerEmitted = false;
+  let summary;
+  try {
+    summary = reconcile({
+      dryRun,
+      onPhase: (line) => spinner.label(line),
+      onTargetResolved: (target) => {
+        spinner.persist(updateHeader(target, dryRun));
+        spinner.persist("");
+        headerEmitted = true;
+      },
+      onArm: (arm) => spinner.persist(progressiveRow(arm, reportOptions))
+    });
+  } finally {
+    spinner.stop();
+  }
+  if (headerEmitted) process.stdout.write(reportFooterLines(summary, reportOptions).join("\n") + "\n");
+  else process.stdout.write(formatReconcileReport(summary, reportOptions));
+  return { summary, rendered: true };
 }
 function main(args = process.argv.slice(2)) {
   if (args.includes("--version")) {
@@ -2214,18 +2553,19 @@ function main(args = process.argv.slice(2)) {
     return status.failures.length ? 1 : 0;
   }
   if (command === "update") {
-    const summary = runUpdate(args);
-    printReconcile(summary, json);
+    const { summary, rendered } = runUpdate(args, json);
+    if (!rendered) printReconcile(summary, json, args.includes("--dry-run"));
     return summary.exit;
   }
   if (command === "install") {
-    const summary = runUpdate(args);
+    const { summary, rendered } = runUpdate(args, json);
     const schedule = installTask();
     if (json) {
       process.stdout.write(JSON.stringify({ convergence: summary, autoupdate: schedule }, null, 2) + "\n");
     } else {
-      printReconcile(summary, false);
-      process.stdout.write(`mmi-hub install: ${schedule.detail}
+      if (!rendered) printReconcile(summary, false, args.includes("--dry-run"));
+      process.stdout.write(schedule.ok ? `  Auto-update on \u2014 hourly task "MMI Fleet Updater".
+` : `  Auto-update NOT enabled \u2014 ${schedule.detail}
 `);
     }
     return Math.max(summary.exit, schedule.ok ? 0 : 1);
@@ -2251,6 +2591,8 @@ if (typeof require !== "undefined" && require.main === module) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   enumerateSurfaces,
+  failConsequence,
+  formatReconcileReport,
   hermesArm,
   hermesHome,
   hubStatus,
@@ -2259,6 +2601,12 @@ if (typeof require !== "undefined" && require.main === module) {
   main,
   ownVersion,
   probeHermesInstallation,
+  progressiveRow,
+  reportFooterLines,
+  retryHint,
   schedulerStatus,
-  taskXml
+  startSpinner,
+  taskXml,
+  updateHeader,
+  wrapWords
 });

package/package.json

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