omp-conductor 0.16.2 → 0.17.1

package/src/clack-ui.ts

@@ -0,0 +1,83 @@
+// @clack/prompts is ESM-only and currently imports node:process in a shape
+// that blocks a future `bun build`; this CLI intentionally executes TS in Bun.
+import * as p from "@clack/prompts";
+import { stdin, stdout } from "node:process";
+import type { Readable, Writable } from "node:stream";
+
+import type { TerminalUi } from "./wizard-ui.ts";
+
+interface ClackIo {
+  input?: Readable;
+  output?: Writable;
+}
+
+/** Interactive WizardUi driver. Callers gate this on TTY input and output. */
+export function clackUi(io: ClackIo = {}): TerminalUi {
+  const input = io.input ?? stdin;
+  const output = io.output ?? stdout;
+  const promptIo = { input, output };
+  let closed = false;
+  let started = false;
+  const start = (): void => {
+    if (started) return;
+    started = true;
+    p.intro("omp-conductor setup", { output });
+  };
+
+  return {
+    close: (message) => {
+      if (closed) return;
+      closed = true;
+      if (started) p.outro(message ?? "Setup finished.", { output });
+    },
+    notify: (message, type = "info") => {
+      start();
+      if (message.includes("\n")) {
+        const title = type === "warning" ? "Warning" : type === "error" ? "Error" : undefined;
+        p.note(message, title, { output });
+        return;
+      }
+      if (type === "warning") p.log.warning(message, { output });
+      else if (type === "error") p.log.error(message, { output });
+      else p.log.info(message, { output });
+    },
+    confirm: async (title, message) => {
+      start();
+      const result = await p.confirm({
+        ...promptIo,
+        message: `${title}\n${message}`,
+        initialValue: false,
+      });
+      return p.isCancel(result) ? undefined : result;
+    },
+    input: async (title, placeholder) => {
+      start();
+      const result = await p.text({
+        ...promptIo,
+        message: title,
+        placeholder,
+        defaultValue: placeholder,
+      });
+      return p.isCancel(result) ? undefined : result;
+    },
+    select: async (title, options, dialogOptions) => {
+      start();
+      const index = Math.max(
+        0,
+        Math.min(dialogOptions?.initialIndex ?? 0, options.length - 1),
+      );
+      const initialValue = options[index]?.label;
+      const result = await p.select({
+        ...promptIo,
+        message: title,
+        options: options.map((option) => ({
+          value: option.label,
+          label: option.label,
+          hint: option.description,
+        })),
+        initialValue,
+      });
+      return p.isCancel(result) ? undefined : result;
+    },
+  };
+}

package/src/command-manifest.ts

@@ -59,7 +59,7 @@ export const COMMAND_MANIFEST: readonly CommandManifestEntry[] = [
     description: "interview, configure the fleet, or install host and graph surfaces",
     scope: "project",
     usage: [
-      "setup [area] [--no-ai] [--project NAME]",
+      "setup [area] [--no-ai] [--answers FILE] [--save-answers FILE] [--project NAME]",
       "setup host [NAME] [--project NAME]",
       "setup graph [--no-seed] [--print] [--project NAME]",
     ],
@@ -71,6 +71,8 @@ export const COMMAND_MANIFEST: readonly CommandManifestEntry[] = [
     flags: [
       project(),
       toggle("--no-ai", "ask every question without AI repository probes"),
+      value("--answers", "answer every prompt from a JSON file"),
+      value("--save-answers", "save successful prompt answers as JSON"),
       toggle("--no-seed", "enable graph indexing without the initial seed"),
       toggle("--print", "print the graph install plan without changing anything"),
     ],
@@ -151,8 +153,8 @@ export const COMMAND_MANIFEST: readonly CommandManifestEntry[] = [
     name: "status",
     description: "print layered fleet and deployment status",
     scope: "fleet",
-    usage: ["status [--project NAME]"],
-    flags: [project()],
+    usage: ["status [--project NAME] [--json]"],
+    flags: [project(), toggle("--json", "print the stable status JSON shape")],
   },
   {
     name: "stats",
@@ -188,8 +190,13 @@ export const COMMAND_MANIFEST: readonly CommandManifestEntry[] = [
     name: "ledger",
     description: "print conductor verb and daemon decision history",
     scope: "project",
-    usage: ["ledger [--issue N] [--limit N] [--project NAME]"],
-    flags: [value("--issue", "filter by issue number"), value("--limit", "maximum rows"), project()],
+    usage: ["ledger [--issue N] [--limit N] [--project NAME] [--json]"],
+    flags: [
+      value("--issue", "filter by issue number"),
+      value("--limit", "maximum rows"),
+      project(),
+      toggle("--json", "print the stable ledger JSON shape"),
+    ],
   },
   {
     name: "hold",
@@ -362,7 +369,7 @@ export const COMMAND_MANIFEST: readonly CommandManifestEntry[] = [
       "decision open --question TEXT [--blocks TEXT] [--resolves-when COND] [--project NAME]",
       "decision resolve <id> --answer TEXT [--project NAME]",
       "decision withdraw <id> [--reason TEXT] [--project NAME]",
-      "decision list [--project NAME]",
+      "decision list [--project NAME] [--json]",
     ],
     subcommands: [
       { name: "open", description: "record a question for the operator" },
@@ -376,6 +383,7 @@ export const COMMAND_MANIFEST: readonly CommandManifestEntry[] = [
       value("--resolves-when", "automatic resolution condition"),
       value("--answer", "operator answer"),
       value("--reason", "withdrawal reason"),
+      toggle("--json", "print decision list as stable JSON"),
       project(),
     ],
     positionals: [{ name: "action" }, { name: "id" }],
@@ -386,7 +394,7 @@ export const COMMAND_MANIFEST: readonly CommandManifestEntry[] = [
     scope: "project",
     usage: [
       "watch add --note TEXT [--blocks TEXT] [--resolves-when COND] [--project NAME]",
-      "watch list [--project NAME]",
+      "watch list [--project NAME] [--json]",
     ],
     subcommands: [
       { name: "add", description: "record a watch" },
@@ -396,6 +404,7 @@ export const COMMAND_MANIFEST: readonly CommandManifestEntry[] = [
       value("--note", "note carried when the watch resolves"),
       value("--blocks", "what the watch blocks"),
       value("--resolves-when", "automatic resolution condition"),
+      toggle("--json", "print watch list as stable JSON"),
       project(),
     ],
     positionals: [{ name: "action" }],

package/src/commands/arm.ts

@@ -8,13 +8,21 @@
 
 import type { CommandContext } from "./context.ts";
 import { armTicks } from "../fleet.ts";
+import { withProgress } from "../ui/progress.ts";
 
 export async function armCommand(ctx: CommandContext): Promise<void> {
 for (const project of ctx.targetProjects()) {
-  process.stdout.write("arm: sending inbound Telegram challenge…\n");
-  const r = await armTicks(project.name);
+  // Proof-neutral wording: `claim-only` performs no Telegram send, so the
+  // progress line cannot promise a challenge that never goes out (#613). The
+  // result line names the proof that actually armed it.
+  const r = await withProgress(
+    "arm: verifying the arming proof…",
+    "Arming proof verified",
+    () => armTicks(project.name),
+    { plainMessage: true },
+  );
   process.stdout.write(
-    `ARMED — inbound round-trip proved with owner ${r.owner}; ticks are now live.\n` +
+    `ARMED — ${r.proof === "claim-only" ? "claim-only plumbing verdict proved" : `inbound round-trip proved with owner ${r.owner}`}; ticks are now live.\n` +
       `marker ${r.path}${r.alreadyArmed ? " (replaced previous marker)" : ""}\n`,
   );
 }

package/src/commands/decision.ts

@@ -86,17 +86,27 @@ try {
     // were the whole reason an operator read the orchestrator's own reminder as
     // a question aimed at them (#459) — `watch list` shows those.
     const open = store.openDecisions(project.name).filter((d) => d.kind !== "watch");
-    if (open.length === 0) {
+    const json = ctx.argv.includes("--json");
+    const now = Date.now();
+    const decisions = open.map((d) => ({
+      id: d.id,
+      ageHours: Math.max(0, Math.round((now - d.askedAt) / 3_600_000)),
+      blocks: d.blocks ?? null,
+      condition: d.condition === undefined ? null : d.conditionMetAt === undefined ? "pending" : "met",
+      question: d.question,
+    }));
+    if (json) {
+      process.stdout.write(`${JSON.stringify({ project: project.name, decisions }, null, 2)}\n`);
+      return;
+    }
+    if (decisions.length === 0) {
       process.stdout.write("no open decisions\n");
       return;
     }
-    const now = Date.now();
-    for (const d of open) {
-      const condition =
-        d.condition === undefined ? "-" : d.conditionMetAt === undefined ? "pending" : "met";
-      const hours = Math.max(0, Math.round((now - d.askedAt) / 3_600_000));
+    for (const decision of decisions) {
       process.stdout.write(
-        `${d.id}  ${hours}h  blocks:${d.blocks ?? "-"}  condition:${condition}  ${d.question}\n`,
+        `${decision.id}  ${decision.ageHours}h  blocks:${decision.blocks ?? "-"}  ` +
+          `condition:${decision.condition ?? "-"}  ${decision.question}\n`,
       );
     }
     return;

package/src/commands/doctor.ts

@@ -10,6 +10,7 @@
 
 import type { CommandContext } from "./context.ts";
 import { runDoctor, type DoctorReport, type FindingStatus } from "../doctor.ts";
+import { dim, fail, heading, ok, warn } from "../ui/style.ts";
 
 const DOCTOR_USAGE = `omp-conductor doctor — check the deployment faults that have already cost
 debugging sessions, mechanically and read-only.
@@ -69,6 +70,22 @@ export function renderDoctorReport(report: DoctorReport): string {
   return `${lines.join("\n")}\n`;
 }
 
+function styleDoctorReport(report: DoctorReport, text: string): string {
+  return text
+    .split("\n")
+    .map((line, index) => {
+      if (index === 0) return heading(line);
+      if (index === 1)
+        return report.status === "fail" ? fail(line) : report.status === "warn" ? warn(line) : ok(line);
+      if (line.startsWith("  FAIL ")) return fail(line);
+      if (line.startsWith("  WARN ")) return warn(line);
+      if (line.startsWith("  PASS ")) return ok(line);
+      if (line.includes("  fix: ")) return dim(line);
+      return line;
+    })
+    .join("\n");
+}
+
 export async function doctorCommand(ctx: CommandContext): Promise<void> {
   // Help first: parsing stops before any probe, config read, or side effect.
   if (ctx.argv[1] === "--help" || ctx.argv[1] === "-h") {
@@ -96,7 +113,7 @@ export async function doctorCommand(ctx: CommandContext): Promise<void> {
     probeTelegram: ctx.argv.includes("--probe-telegram"),
   });
   if (ctx.argv.includes("--json")) process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
-  else process.stdout.write(renderDoctorReport(report));
+  else process.stdout.write(styleDoctorReport(report, renderDoctorReport(report)));
   // The one contract CI reads: nonzero iff something failed. Warnings pass.
   if (report.status === "fail") process.exitCode = 1;
 }

package/src/commands/hold.ts

@@ -8,19 +8,21 @@
 
 import type { CommandContext } from "./context.ts";
 import { hold } from "../fleet.ts";
+import { dim, ok } from "../ui/style.ts";
 
 export async function holdCommand(ctx: CommandContext): Promise<void> {
 const keepTicks = ctx.argv.includes("--keep-ticks");
 for (const project of ctx.targetProjects()) {
   const r = hold(project.name, "hold", keepTicks ? { keepTicks: true } : {});
   process.stdout.write(
-    `held — claiming paused` +
-      `${r.wasPaused ? " (already paused)" : ""}` +
-      (r.disarmed === undefined
-        ? "; ticks left armed — resume restores the fleet with no new arm challenge"
-        : `; ticks disarmed at ${r.disarmed.path}` +
-          `${r.disarmed.wasArmed ? "" : " (was already disarmed)"}`) +
-      `\ndaemon and pane left running; stop to stop the daemon too\n`,
+    ok(
+      `held — claiming paused` +
+        `${r.wasPaused ? " (already paused)" : ""}` +
+        (r.disarmed === undefined
+          ? "; ticks left armed — resume restores the fleet with no new arm challenge"
+          : `; ticks disarmed at ${r.disarmed.path}` +
+            `${r.disarmed.wasArmed ? "" : " (was already disarmed)"}`),
+    ) + `\n${dim("daemon and pane left running; stop to stop the daemon too")}\n`,
   );
 }
 }

package/src/commands/ledger.ts

@@ -10,6 +10,7 @@ import type { CommandContext } from "./context.ts";
 import { findProject, loadConfig } from "../config.ts";
 import { dbPath, openStore } from "../store.ts";
 import { formatVerbLedgerEntry } from "../verbs/ledger.ts";
+import { dim, heading } from "../ui/style.ts";
 
 export async function ledgerCommand(ctx: CommandContext): Promise<void> {
 const cfg = loadConfig();
@@ -35,10 +36,28 @@ try {
     ...(issue === undefined ? {} : { issue }),
     limit,
   });
+  if (ctx.argv.includes("--json")) {
+    process.stdout.write(
+      `${JSON.stringify(
+        {
+          project: p.name,
+          ...(issue === undefined ? {} : { issue }),
+          entries,
+          refused: entries.filter((entry) => entry.decision === "refused").length,
+          turnOverrides: overrides,
+        },
+        null,
+        2,
+      )}\n`,
+    );
+    return;
+  }
   if (entries.length === 0 && overrides.length === 0) {
     process.stdout.write(
-      `no conductor actions recorded for ${p.name}` +
-        `${issue === undefined ? "" : ` on #${String(issue)}`}\n`,
+      dim(
+        `no conductor actions recorded for ${p.name}` +
+          `${issue === undefined ? "" : ` on #${String(issue)}`}`,
+      ) + "\n",
     );
     return;
   }
@@ -46,13 +65,15 @@ try {
   if (entries.length > 0) {
     const refused = entries.filter((e) => e.decision === "refused").length;
     blocks.push(
-      `${p.name} — ${entries.length} verb call(s), ${refused} refused (newest first)\n` +
+      heading(`${p.name} — ${entries.length} verb call(s), ${refused} refused (newest first)`) +
+        "\n" +
         entries.flatMap(formatVerbLedgerEntry).join("\n"),
     );
   }
   if (overrides.length > 0) {
     blocks.push(
-      `${p.name} — ${overrides.length} turn override(s) (newest first)\n` +
+      heading(`${p.name} — ${overrides.length} turn override(s) (newest first)`) +
+        "\n" +
         overrides
           .map(
             (entry) =>

package/src/commands/message.ts

@@ -15,10 +15,11 @@
 
 import type { CommandContext } from "./context.ts";
 import { randomUUID } from "node:crypto";
+import { availabilityState, formatNextWindowOpening } from "../availability.ts";
 import { findProject, loadConfig } from "../config.ts";
 import { deliverOperatorMessage, operatorMessageCategory, type OperatorMessageOutcome } from "../reports.ts";
 import { dbPath, openStore } from "../store.ts";
-import { INTERRUPT_CATEGORIES, type DecisionRecord, type InterruptCategory } from "../types.ts";
+import { INTERRUPT_CATEGORIES, type DecisionRecord, type InterruptCategory, type ProjectConfig } from "../types.ts";
 import { validateQuestionShape } from "../ask.ts";
 
 /** The floor's "this needs an answer" marker, as every other classifier reads it. */
@@ -96,8 +97,35 @@ export async function messageCommand(ctx: CommandContext): Promise<void> {
       ? // Not "into the topic": a stale topic degrades to the flat chat with
         // its own warning on stderr, and this line must not contradict it.
         `message delivered to ${project.name}'s configured Telegram target (${outcome.category})\n`
-      : `held notice ${outcome.noticeId} queued for ${project.name} (${outcome.category}; ` +
-          `${outcome.reason === "availability" ? "outside the availability window" : "a digest-only category"})\n` +
-          "nothing was sent; the daemon releases it with the next digest or working-hours catch-up\n",
+      : heldLine(project, outcome),
+  );
+}
+
+/** The held-notice line names the future that releases it, in words an
+ *  operator can act on: the working-hours window opening, or the daily digest.
+ *  The earlier spelling — "the next digest or working-hours catch-up" — read
+ *  the same for both and hid exactly the 23-hour hold that #596 is about. */
+function heldLine(
+  project: ProjectConfig,
+  outcome: Extract<OperatorMessageOutcome, { kind: "held" }>,
+): string {
+  if (outcome.reason === "availability") {
+    const state = availabilityState(project.reporting, Date.now());
+    const opening =
+      state.mode === "quiet" && state.nextTransitionAt !== undefined && state.timezone !== undefined
+        ? ` at ${formatNextWindowOpening(state.nextTransitionAt, state.timezone)}`
+        : "";
+    return (
+      `held notice ${outcome.noticeId} queued for ${project.name} (${outcome.category}; ` +
+      `held until the working-hours window opens${opening})\n` +
+      "nothing was sent; the daemon releases it with the working-hours catch-up when your window opens\n"
+    );
+  }
+  const digestAt = project.reporting?.digest.at;
+  const when = digestAt === undefined ? "the next digest" : `the ${digestAt} digest`;
+  return (
+    `held notice ${outcome.noticeId} queued for ${project.name} (${outcome.category}; ` +
+    `digest-only — held until ${when})\n` +
+    `nothing was sent; the daemon releases it with ${when}\n`
   );
 }

package/src/commands/setup.ts

@@ -17,7 +17,16 @@ import { AMEND_AREA_IDS, type AmendAreaId } from "../setup.ts";
 import { runGraphInstall, runHostInstall, type InstallOutcome } from "../setup-install.ts";
 import { DEFAULT_PROBES, NO_PROBES, setup } from "../setup-wizard.ts";
 import { telegramStateDir } from "../fleet.ts";
+import {
+  answersUi,
+  guardNonInteractiveUi,
+  loadAnswersFile,
+  recordingAnswersUi,
+  saveAnswersFile,
+  type RecordedAnswersUi,
+} from "../setup-answers.ts";
 import { terminalUi, type WizardUi } from "../wizard-ui.ts";
+import { interactiveUi } from "../ui/progress.ts";
 import type { ConductorConfig, ProjectConfig } from "../types.ts";
 
 /**
@@ -30,7 +39,7 @@ const SETUP_USAGE = `omp-conductor setup — interview, then write config.json,
 and the staged host files behind one confirm.
 
 usage:
-  omp-conductor setup [area] [--no-ai] [--project NAME]
+  omp-conductor setup [area] [--no-ai] [--answers FILE] [--save-answers FILE] [--project NAME]
   omp-conductor setup host [NAME] [--project NAME]
   omp-conductor setup graph [--no-seed] [--print] [--project NAME]
 
@@ -44,9 +53,11 @@ amend areas:
   ${AMEND_AREA_IDS.join(", ")}
 
 flags:
-  --project NAME   the project to configure or amend (or NAME positionally
-                   for \`setup host\`)
-  --no-ai          ask every question, propose nothing (no AI repo reads)`;
+  --project NAME       the project to configure or amend (or NAME positionally
+                       for \`setup host\`)
+  --no-ai              ask every question, propose nothing (no AI repo reads)
+  --answers FILE       answer every prompt from JSON; never opens a prompt
+  --save-answers FILE  save successful prompt answers as replayable JSON`;
 
 /**
  * Resolve the project an install subcommand (`setup host`, `setup graph`)
@@ -97,6 +108,7 @@ async function offerCompletionInstall(ui: WizardUi): Promise<void> {
   const install = await ui.confirm(
     "Install shell completions?",
     "Writes a generated completion script and one idempotent source line to your shell rc file.",
+    { key: "install-shell-completions" },
   );
   if (install !== true) return;
 
@@ -107,13 +119,26 @@ async function offerCompletionInstall(ui: WizardUi): Promise<void> {
       { label: "zsh", description: "Install through ~/.zshrc" },
       { label: "bash", description: "Install through ~/.bashrc" },
     ],
-    { initialIndex: detected === "bash" ? 1 : 0 },
+    { key: "completion-shell", initialIndex: detected === "bash" ? 1 : 0 },
   );
   if (selected !== "zsh" && selected !== "bash") return;
   const installed = await installShellCompletions(selected);
   ui.notify(`Installed completions at ${installed.scriptPath}; sourced from ${installed.rcPath}.`);
 }
 
+function setupValueFlag(argv: readonly string[], name: "--answers" | "--save-answers"): string | undefined {
+  const inline = argv.find((arg) => arg.startsWith(`${name}=`));
+  const at = argv.indexOf(name);
+  if (inline !== undefined && at !== -1) throw new Error(`${name} may be passed only once`);
+  const value = inline?.slice(name.length + 1) ?? (at === -1 ? undefined : argv[at + 1]);
+  if (value === undefined) {
+    if (at !== -1) throw new Error(`${name} requires a file path`);
+    return undefined;
+  }
+  if (value.length === 0 || value.startsWith("--")) throw new Error(`${name} requires a file path`);
+  return value;
+}
+
 export async function setupCommand(ctx: CommandContext): Promise<void> {
 // Help first, and only in the first trailing position: a help request
 // must never open a UI, read config, probe GitHub or pause dispatch.
@@ -125,10 +150,22 @@ if (ctx.argv[1] === "--help" || ctx.argv[1] === "-h") {
 }
 const sub = ctx.argv[1];
 const positional = sub !== undefined && !sub.startsWith("--") ? sub : undefined;
-// The terminal surface owns stdin for whichever path runs, and is released
-// in a finally: a throw with readline still attached leaves the operator's
-// shell without an echo.
-const ui = terminalUi();
+// Clack owns an interactive terminal. Pipes retain the byte-pinned readline
+// protocol, while --answers installs a prompt-free driver.
+const answersPath = setupValueFlag(ctx.argv, "--answers");
+const saveAnswersPath = setupValueFlag(ctx.argv, "--save-answers");
+const useClack = answersPath === undefined && interactiveUi();
+const baseUi = answersPath
+  ? answersUi(loadAnswersFile(answersPath))
+  : useClack
+    ? (await import("../clack-ui.ts")).clackUi()
+    : terminalUi();
+const guardedUi = answersPath === undefined && !process.stdin.isTTY ? guardNonInteractiveUi(baseUi) : baseUi;
+const recording: RecordedAnswersUi | undefined =
+  saveAnswersPath === undefined ? undefined : recordingAnswersUi(guardedUi);
+const ui = recording?.ui ?? guardedUi;
+let saveCompletedAnswers = false;
+let closeMessage = "Setup failed.";
 try {
   // `host` and `graph` are install subcommands, checked BEFORE the amend
   // areas. They are not areas — routing them through the area validation
@@ -170,6 +207,8 @@ try {
     // `staged` is a success on a host that has no systemd: the files are
     // real, only the enable step is impossible.
     if (outcome.kind === "refused" || outcome.kind === "failed") process.exit(1);
+    saveCompletedAnswers = outcome.kind !== "declined";
+    closeMessage = outcome.kind === "declined" ? "Setup incomplete." : "Setup complete.";
     return;
   }
   let area: AmendAreaId | undefined;
@@ -203,7 +242,19 @@ try {
       );
     }
   }
+  saveCompletedAnswers = completed;
+  closeMessage = completed ? "Setup complete." : "Setup incomplete.";
 } finally {
-  ui.close();
+  try {
+    if (saveCompletedAnswers && saveAnswersPath !== undefined && recording !== undefined) {
+      saveAnswersFile(saveAnswersPath, recording.answers);
+      ui.notify(`Saved setup answers to ${saveAnswersPath}.`);
+    }
+  } catch (err) {
+    closeMessage = "Setup failed.";
+    throw err;
+  } finally {
+    ui.close(closeMessage);
+  }
 }
 }

package/src/commands/stats.ts

@@ -13,6 +13,7 @@ import type { CommandContext } from "./context.ts";
 import { findProject, loadConfig } from "../config.ts";
 import { dbPath, openStore, utcDay } from "../store.ts";
 import { computeStats, renderStatsHuman, type StatsWindow } from "../stats.ts";
+import { heading } from "../ui/style.ts";
 
 const DAY_MS = 24 * 60 * 60 * 1_000;
 const DATE_FORM = /^\d{4}-\d{2}-\d{2}$/;
@@ -120,11 +121,14 @@ export async function statsCommand(ctx: CommandContext): Promise<void> {
       ghCalls: store.ghCallsBetween(window.sinceDay, window.untilDay),
       runs: store.statsRuns(project.name, window.sinceEpochMs),
     });
-    process.stdout.write(
-      ctx.argv.includes("--json")
-        ? `${JSON.stringify(report, null, 2)}\n`
-        : renderStatsHuman(report),
-    );
+    if (ctx.argv.includes("--json")) process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+    else {
+      const human = renderStatsHuman(report);
+      const newline = human.indexOf("\n");
+      process.stdout.write(
+        newline < 0 ? heading(human) : `${heading(human.slice(0, newline))}${human.slice(newline)}`,
+      );
+    }
   } finally {
     store.close();
   }

package/src/commands/status.ts

@@ -10,8 +10,9 @@ import type { CommandContext } from "./context.ts";
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
 import { stateDir } from "../config.ts";
-import { renderStatus } from "../fleet.ts";
+import { collectFleetStatus, renderFleetStatusReport } from "../fleet.ts";
 import { STALL_MARKER_FILE } from "../orchestrator-tick.ts";
+import { fail, heading, ok, warn } from "../ui/style.ts";
 
 /**
  * The orchestrator half, and the one thing `status` has ever known about the
@@ -40,9 +41,35 @@ function stallLine(): string | undefined {
   return `orchestrator   STALLED since ${since === "" ? "an unrecorded time" : since}${diagnosis}`;
 }
 
+function styleStatus(text: string): string {
+  return text
+    .split("\n")
+    .map((line) => {
+      if (
+        line === "caps" ||
+        line === "daemon" ||
+        line === "active runs" ||
+        line === "active runs  (none)" ||
+        line.startsWith("project   ")
+      )
+        return heading(line);
+      if (line.includes("STALLED")) return fail(line);
+      if (/^(dispatch|ticks|pane|herdr|telegram|  healthz)\s+.*\b(running|healthy|ok)\b/.test(line))
+        return ok(line);
+      if (/^(dispatch|ticks|daemon)\s+.*\b(paused|stopped|not running|overdue)\b/.test(line))
+        return warn(line);
+      return line;
+    })
+    .join("\n");
+}
+
 export async function statusCommand(ctx: CommandContext): Promise<void> {
-const project = ctx.projectFlag;
-const text = await renderStatus(project);
-const stalled = stallLine();
-process.stdout.write(`${text}${stalled === undefined ? "\n" : `\n\n${stalled}\n`}`);
+  const report = await collectFleetStatus(ctx.projectFlag);
+  const stalled = stallLine();
+  if (ctx.argv.includes("--json")) {
+    process.stdout.write(`${JSON.stringify({ ...report, orchestratorStall: stalled }, null, 2)}\n`);
+    return;
+  }
+  const text = styleStatus(renderFleetStatusReport(report));
+  process.stdout.write(`${text}${stalled === undefined ? "\n" : `\n\n${fail(stalled)}\n`}`);
 }

package/src/commands/tail.ts

@@ -13,6 +13,7 @@ import { findProject, loadConfig } from "../config.ts";
 import { dbPath, LIVE_STATES, openStore } from "../store.ts";
 import { formatTranscriptLine, prop } from "../transcript.ts";
 import type { Store } from "../types.ts";
+import { dim, fail, ok, warn } from "../ui/style.ts";
 
 /** How often `tail` re-stats the transcripts it is following. */
 const TAIL_POLL_MS = 1_000;
@@ -142,6 +143,16 @@ export function renderAdvisorLine(line: string): string | undefined {
   return out.length === 0 ? undefined : `[advisor] ${out.join("\n")}`;
 }
 
+function styleTailLine(line: string): string {
+  if (line.startsWith("[advisor] blocker:")) return fail(line);
+  if (line.startsWith("[advisor] warning:")) return warn(line);
+  if (line.startsWith("[advisor] nit:")) return dim(line);
+  if (line === "run ended: merged" || line === "run ended: pushed-green") return ok(line);
+  if (/^run ended: (?:failed|killed|orphaned)$/.test(line)) return fail(line);
+  if (line.startsWith("run ended:")) return warn(line);
+  return line;
+}
+
 /**
  * Follow one run's transcripts the way `tail -f` follows a log: the worker's
  * own transcript plus any `__advisor*.jsonl` sitting beside it (the mid-run
@@ -173,7 +184,8 @@ export async function tailRun(
   } = {},
 ): Promise<void> {
   const store = deps.store ?? openStore(dbPath());
-  const write = deps.write ?? ((line: string) => process.stdout.write(`${line}\n`));
+  const write =
+    deps.write ?? ((line: string) => process.stdout.write(`${styleTailLine(line)}\n`));
   const pollMs = deps.pollMs ?? TAIL_POLL_MS;
   const quietMs = deps.quietMs ?? TAIL_QUIET_MS;
   try {