catherd-cli 0.2.1 → 1.1.0

package/src/domain/state.ts

@@ -0,0 +1,49 @@
+const PARKED = /^parked: [^;]*; /;
+
+/**
+ * Spec 1.1 §8: `next` with the parked milestones in front of it, once ("parked: M2 waits on the owner;
+ * <next>"), whoever wrote the step: a milestone stays parked in state.md until it is answered.
+ */
+export function withParked(next: string, parked: string[]): string {
+  const base = next.replace(PARKED, "");
+  if (parked.length === 0) return base;
+  return `parked: ${parked.join(", ")} ${parked.length > 1 ? "wait" : "waits"} on the owner; ${base}`;
+}
+
+export interface StateView {
+  title: string;
+  head: string;
+  dirty: { path: string; owner: string | null }[];
+  running: { name: string; rung: string; thread: string | null; since: string; brief: string }[];
+  lastCheck: string | null;
+  next: string;
+  /** spec 1.1 §10: the protocol's next step, derived from the run's files; always the last line */
+  protocol: string;
+}
+
+/** state.md: enough for a fresh session to resume from alone; the protocol's next step is always the last line. */
+export function renderState(s: StateView): string {
+  const waiting = s.running.map((r) => r.name);
+  return [
+    `# ${s.title}`,
+    "",
+    `HEAD ${s.head}`,
+    "",
+    "Dirty:",
+    ...(s.dirty.length ? s.dirty.map((d) => `- ${d.path}${d.owner ? ` (${d.owner})` : ""}`) : ["- none"]),
+    "",
+    "Running:",
+    ...(s.running.length
+      ? s.running.map(
+          (r) => `- ${r.name} · ${r.rung} · thread ${r.thread ?? "new"} · since ${r.since} · ${r.brief}`,
+        )
+      : ["- none"]),
+    "",
+    `Last check: ${s.lastCheck ?? "none"}`,
+    "",
+    // 1.1: no tool waits; each running role's record arrives as a catherd message
+    `Next: ${waiting.length ? `running ${waiting.join(", ")} (results arrive as catherd messages; peek to check); then ${s.next}` : s.next}`,
+    `Protocol next: ${s.protocol}`,
+    "",
+  ].join("\n");
+}

package/src/domain/util.ts

@@ -0,0 +1,18 @@
+/** Lower-case letters and digits, every other run of characters one `-`, no `-` at either end. */
+export const slug = (s: string): string =>
+  s
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-|-$/g, "");
+
+/** The middle value, or the mean of the two middle values for an even count; null when there are none. */
+export function median(xs: readonly number[]): number | null {
+  if (xs.length === 0) return null;
+  const s = [...xs].sort((a, b) => a - b);
+  const m = s.length >> 1;
+  return s.length % 2 ? (s[m] as number) : ((s[m - 1] as number) + (s[m] as number)) / 2;
+}
+
+/** A plain object: not null and not an array. */
+export const isPlain = (v: unknown): v is Record<string, unknown> =>
+  typeof v === "object" && v !== null && !Array.isArray(v);

package/src/entry/capture-fixtures-command.ts

@@ -0,0 +1,57 @@
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+import { defineCommand } from "citty";
+import { CatherdError } from "../domain/errors.ts";
+import { assetPath } from "../infra/assets.ts";
+import { CAPTURE_BACKENDS, type Captured, captureFixtures } from "../services/capture.ts";
+import { exitCodeOf, mark, printError } from "./cli-kit.ts";
+
+/**
+ * Spec §11.8: fixtures go to the catherd checkout's test/fixtures/adapters, next to the contract fixtures
+ * they feed, wherever the command runs; null for an installed package, which has no tests to feed.
+ */
+export function defaultOut(): string | null {
+  const dir = assetPath("test/fixtures/adapters");
+  return existsSync(dir) ? dir : null;
+}
+
+export function formatCaptured(r: Captured): string {
+  return r.status === "captured"
+    ? `${mark("ok")} ${r.backend} ${r.cliVersion} ${r.name} → ${r.dir}/${r.name}.jsonl (exit ${r.exitCode})`
+    : `${mark("skip")} ${r.backend} ${r.name} skipped: ${r.reason}`;
+}
+
+export const captureFixturesCommand = defineCommand({
+  meta: {
+    name: "capture-fixtures",
+    description: "Record one cheap real run per ready backend as sanitized test fixtures",
+  },
+  args: {
+    backend: { type: "string", description: `only this backend (${CAPTURE_BACKENDS.join(", ")})` },
+    out: { type: "string", description: "fixture root (default: this checkout's test/fixtures/adapters)" },
+  },
+  async run({ args }) {
+    const refuse = (message: string, fix: string): void => {
+      const e = new CatherdError("E_INPUT_INVALID", message, { fix });
+      printError(e);
+      process.exitCode = exitCodeOf(e);
+    };
+    const out = args.out ? resolve(args.out) : defaultOut();
+    if (!out)
+      return refuse(
+        "no --out, and this catherd is not a source checkout",
+        "catherd capture-fixtures --out <dir>",
+      );
+    if (args.backend && !CAPTURE_BACKENDS.includes(args.backend))
+      return refuse(
+        `no capture cases for backend "${args.backend}"`,
+        `catherd capture-fixtures --backend ${CAPTURE_BACKENDS.join("|")}`,
+      );
+    const results = await captureFixtures({
+      outDir: out,
+      backends: args.backend ? [args.backend] : undefined,
+    });
+    for (const r of results) console.log(formatCaptured(r));
+    process.exitCode = results.some((r) => r.status === "captured") ? 0 : 1;
+  },
+});

package/src/entry/catalog-command.ts

@@ -0,0 +1,106 @@
+import { defineCommand } from "citty";
+import { CatherdError, isCatherdError } from "../domain/errors.ts";
+import { ROLES, type Role } from "../domain/roles.ts";
+import { gitToplevel } from "../infra/git.ts";
+import {
+  type CatalogModel,
+  catalogQuery,
+  type Refreshed,
+  refreshDiscovery,
+  saveTreatLike,
+} from "../services/catalog-service.ts";
+import { exitCodeOf, JSON_ARG, mark, printError } from "./cli-kit.ts";
+
+/** One backend's refresh: its model count, else why it listed none, then its fix on a line of its own. */
+export function formatRefreshed(r: Refreshed, plain = false): string {
+  if (!r.error) return `${mark("ok", plain)} ${r.backend}: ${r.models} models`;
+  return [
+    `${mark("warn", plain)} ${r.backend}: ${r.error}${r.fetchedAt ? ` (last listed ${r.fetchedAt})` : ""}`,
+    ...(r.fix ? [`    fix: ${r.fix}`] : []),
+  ].join("\n");
+}
+
+export function formatModel(m: CatalogModel): string {
+  const scored = m.rungs.filter((r) => r.enabled).length;
+  const listed = m.listed === false ? "  not offered by this account" : "";
+  return `${m.backend}:${m.model}  ${scored}/${m.rungs.length} rungs scored  roles ${m.roles.join(",") || "none"}${listed}`;
+}
+
+/** The repository the command runs in, for per-repository listings; none outside one (global). */
+const hereRepo = async (): Promise<string | undefined> => (await gitToplevel(process.cwd())) ?? undefined;
+
+function fail(e: unknown): void {
+  if (!isCatherdError(e)) throw e;
+  printError(e);
+  process.exitCode = exitCodeOf(e);
+}
+
+const refresh = defineCommand({
+  meta: { name: "refresh", description: "List every backend's models now" },
+  args: JSON_ARG,
+  async run({ args }) {
+    const r = await refreshDiscovery({ repo: await hereRepo() });
+    if (args.json) console.log(JSON.stringify(r, null, 2));
+    else for (const x of r) console.log(formatRefreshed(x));
+    process.exitCode = r.some((x) => !x.error) ? 0 : 1;
+  },
+});
+
+const list = defineCommand({
+  meta: { name: "list", description: "The models catherd can place, with their scored rungs" },
+  args: {
+    backend: { type: "string", description: "only this backend or billing key" },
+    role: { type: "string", description: `only models for this role (${ROLES.join(", ")})` },
+    text: { type: "string", description: "only ids containing this" },
+    scored: { type: "boolean", description: "only models with a scored rung" },
+    ...JSON_ARG,
+  },
+  async run({ args }) {
+    if (args.role && !(ROLES as readonly string[]).includes(args.role))
+      return fail(
+        new CatherdError("E_INPUT_INVALID", `no role "${args.role}"`, {
+          fix: `pass --role ${ROLES.join("|")}`,
+        }),
+      );
+    try {
+      const r = catalogQuery({
+        backend: args.backend,
+        role: args.role as Role | undefined,
+        text: args.text,
+        scoredOnly: args.scored === true,
+        limit: 10_000,
+        repo: await hereRepo(),
+      });
+      if (args.json) console.log(JSON.stringify(r, null, 2));
+      else for (const m of r.models) console.log(formatModel(m));
+    } catch (e) {
+      fail(e);
+    }
+  },
+});
+
+const treatLike = defineCommand({
+  meta: { name: "treat-like", description: "Score an unscored rung as a scored one" },
+  args: {
+    rung: {
+      type: "positional",
+      required: true,
+      description: "the unscored rung, backend:model#effort or model#effort",
+    },
+    like: { type: "positional", required: true, description: "the scored rung whose scores it borrows" },
+  },
+  async run({ args }) {
+    try {
+      const r = await saveTreatLike(args.rung, args.like);
+      console.log(`✓ ${r.rung} is treated like ${r.like}`);
+    } catch (e) {
+      fail(e);
+    }
+  },
+});
+
+/** Spec §8: `catherd catalog refresh|list|treat-like <rung> <like>`. */
+export const catalogCommand = defineCommand({
+  meta: { name: "catalog", description: "The model catalog" },
+  subCommands: { refresh, list, "treat-like": treatLike },
+});

package/src/entry/cli-kit.ts

@@ -0,0 +1,36 @@
+import { type CatherdError, isCatherdError } from "../domain/errors.ts";
+import { RUN_NOT_FOUND_FIX } from "../services/run-store.ts";
+import { glyph, type State } from "./glyphs.ts";
+
+/** Spec §8: 0 ok, 1 error, 2 usage, 3 not ready (doctor), 130 interrupted. */
+export const EXIT = { ok: 0, error: 1, usage: 2, notReady: 3, interrupted: 130 } as const;
+
+// oxlint-disable-next-line no-control-regex -- citty colours its messages; the one-line error must not
+const ANSI = /\x1b\[[0-9;]*m/g;
+
+/** `text` without colour codes: for output that is piped, or under NO_COLOR. */
+export const stripAnsi = (text: string): string => text.replace(ANSI, "");
+
+/** A service's fix worded for the MCP tools, as the CLI says it. */
+const CLI_FIX: Record<string, string> = { [RUN_NOT_FOUND_FIX]: "catherd runs list" };
+
+/** Spec §8: one line `error E_CODE: message`, then `fix: …` when there is one. */
+export function printError(e: Pick<CatherdError, "code" | "message" | "fix">): void {
+  console.error(`error ${e.code}: ${stripAnsi(e.message).split("\n").join(" ")}`);
+  if (e.fix) console.error(`fix: ${CLI_FIX[e.fix] ?? e.fix}`);
+}
+
+/** Bad input from the command line is a usage error; any other catherd error is an error. */
+export const exitCodeOf = (e: unknown): number =>
+  isCatherdError(e) && e.code === "E_INPUT_INVALID" ? EXIT.usage : EXIT.error;
+
+export const printJson = (v: unknown): void => console.log(JSON.stringify(v, null, 2));
+
+/** The `--json` flag every read command takes. */
+export const JSON_ARG = { json: { type: "boolean", description: "print JSON" } } as const;
+
+/**
+ * The glyph for a state, as in `✓ ready`: the dashboard's own (spec §9.3), ASCII with `--plain` only;
+ * NO_COLOR drops colour, never glyphs. The caller adds the word.
+ */
+export const mark = (state: State, plain = false): string => glyph(state, plain);

package/src/entry/deps.ts

@@ -0,0 +1,17 @@
+import { readSessionEnv } from "../infra/claude-session.ts";
+import { VERSION } from "../infra/version.ts";
+import type { Deps } from "../services/ports.ts";
+import { profileService } from "../services/profile-service.ts";
+import { routingService } from "../services/routing-service.ts";
+
+/** The services every entry point (MCP server, CLI commands) runs on. */
+export function defaultDeps(): Deps {
+  return {
+    profiles: profileService(),
+    routing: routingService(),
+    version: VERSION,
+    pollMs: 250,
+    session: readSessionEnv(process.env),
+    now: Date.now,
+  };
+}

package/src/entry/doctor-command.ts

@@ -0,0 +1,51 @@
+import { defineCommand } from "citty";
+import { VERSION } from "../infra/version.ts";
+import { type DoctorReport, doctor } from "../services/doctor.ts";
+import { probePush } from "../services/doctor-push.ts";
+import type { Check } from "../services/doctor-checks.ts";
+import { EXIT, JSON_ARG, mark, printJson } from "./cli-kit.ts";
+import { mcpHandshake } from "./mcp/handshake.ts";
+
+/**
+ * One row per check: `✓ ready  Bun — 1.4.2`, then the full fix on its own line; a fix of several lines
+ * (one command each) keeps them under the first.
+ */
+export function formatCheck(c: Check, plain = false): string[] {
+  return [
+    `${mark(c.state, plain)} ${c.word.padEnd(18)} ${c.label}${c.detail ? ` — ${c.detail}` : ""}`,
+    ...(c.fix ? c.fix.split("\n").map((l, i) => `${i ? "         " : "    fix: "}${l}`) : []),
+  ];
+}
+
+export function formatReport(r: DoctorReport, plain = false): string[] {
+  return [
+    ...r.checks.flatMap((c) => formatCheck(c, plain)),
+    "",
+    r.ready
+      ? `${mark("ok", plain)} ready`
+      : `${mark("fail", plain)} not ready: fix the rows marked ${mark("fail", plain)} above`,
+  ];
+}
+
+/** Spec §8, §10.3: `catherd doctor [--json]`, exit 3 when not ready. */
+export const doctorCommand = defineCommand({
+  meta: {
+    name: "doctor",
+    description: "Readiness report: Bun, backends, Jev, the plugin, agents, the MCP server, locks",
+  },
+  args: {
+    ...JSON_ARG,
+    plain: { type: "boolean", description: "ASCII glyphs (NO_COLOR drops only colour)" },
+  },
+  async run({ args }) {
+    const r = await doctor({
+      bunVersion: Bun.version,
+      version: VERSION,
+      handshake: () => mcpHandshake(),
+      push: () => probePush(),
+    });
+    if (args.json) printJson(r);
+    else for (const l of formatReport(r, args.plain === true)) console.log(l);
+    process.exitCode = r.ready ? EXIT.ok : EXIT.notReady;
+  },
+});

package/src/entry/glyphs.ts

@@ -0,0 +1,34 @@
+/**
+ * Spec §9.3's glyphs, each with its ASCII twin for `--plain`: the dashboard and every CLI command draw
+ * state with these. Free of OpenTUI, so `mcp`, `lock` and `_supervise` can load it (spec §3.1).
+ */
+const GLYPHS = {
+  ok: ["✓", "+"],
+  warn: ["!", "!"],
+  fail: ["✗", "x"],
+  skip: ["-", "-"],
+  info: ["i", "i"],
+  live: ["●", "*"],
+  waiting: ["◌", "."],
+  on: ["[x]", "[x]"],
+  off: ["[ ]", "[ ]"],
+  open: ["▾", "v"],
+  shut: ["▸", ">"],
+  arrow: ["→", "->"],
+  dot: ["·", "-"],
+  more: ["…", "..."],
+  up: ["↑", "^"],
+  down: ["↓", "v"],
+  bar: ["┃", "|"],
+  rule: ["─", "-"],
+  current: ["●", "*"],
+  full: ["█", "#"],
+  empty: ["░", "."],
+} as const;
+export type Glyph = keyof typeof GLYPHS;
+export const GLYPH_NAMES = Object.keys(GLYPHS) as Glyph[];
+
+export const glyph = (g: Glyph, plain: boolean): string => GLYPHS[g][plain ? 1 : 0];
+
+/** The words state always travels with (spec §9.3: green/amber/red only for state, always with a word). */
+export type State = "ok" | "warn" | "fail" | "skip" | "info";

package/src/entry/init-command.ts

@@ -0,0 +1,182 @@
+import { defineCommand } from "citty";
+import { assertProfileName } from "../domain/profile.ts";
+import { errorMessage, isCatherdError } from "../domain/errors.ts";
+import { configDir } from "../infra/paths.ts";
+import { VERSION } from "../infra/version.ts";
+import { doctor } from "../services/doctor.ts";
+import { jevKey, saveJevKey, testJevKey } from "../services/jev-service.ts";
+import { reinstallCommand } from "../services/doctor-checks.ts";
+import { ensureGlobal, type GlobalInstallDeps, realGlobalInstall } from "../services/global-install.ts";
+import { hasProfileFile, type InitResult, initSetup, moveLegacy } from "../services/setup.ts";
+import { formatRefreshed } from "./catalog-command.ts";
+import { mark as markOf } from "./cli-kit.ts";
+import { formatReport } from "./doctor-command.ts";
+import { mcpHandshake } from "./mcp/handshake.ts";
+import type { State } from "./glyphs.ts";
+import { mascot } from "./tui/theme.ts";
+import { type Prompter, prompter } from "./prompt.ts";
+
+/** What `init` prints last (spec §9.1): the plugin install commands, to paste into a terminal. */
+export const PLUGIN_STEPS = [
+  "Install the Claude Code plugin:",
+  "  claude plugin marketplace add 47vigen/catherd",
+  "  claude plugin install catherd@catherd",
+  "Then start a new Claude Code session, so it loads the plugin and the catherd agents.",
+];
+
+/** Spec §9.3: the full mascot greets `init` (and the TUI's empty states), nowhere else. */
+export function welcomeLines(version: string): string[] {
+  const [ears, face, paws] = mascot("good");
+  return [ears, `${face}  catherd ${version}`, `${paws}  herds your coding agents`, ""];
+}
+
+/**
+ * The Jev key step. It never stops `init` (Ruling 11): a key that cannot be saved, say because
+ * credentials.json is unparsable, is reported with its fix and setup goes on.
+ */
+export async function jevStep(
+  ask: Prompter | null,
+  d: { testJevKey?: (key: string) => Promise<boolean>; saveJevKey?: (key: string) => void } = {},
+  plain = false,
+): Promise<void> {
+  const mark = (state: State) => markOf(state, plain);
+  if (process.env.TYPESAFE_API_KEY?.trim()) {
+    ask?.skip?.();
+    return console.log(`${mark("ok")} Jev: using TYPESAFE_API_KEY`);
+  }
+  if (jevKey()) {
+    ask?.skip?.();
+    return console.log(`${mark("ok")} Jev: using the saved key`);
+  }
+  const key = ask ? await ask.secret("TypeSafe API key for Jev (optional; Enter skips): ") : "";
+  if (!key)
+    return console.log(
+      `- Jev: no key; routing uses each lane's Kind and Difficulty (add one later with catherd init)`,
+    );
+  if (!(await (d.testJevKey ?? testJevKey)(key).catch(() => false)))
+    return console.log(`${mark("warn")} Jev: the key did not answer, so it was not saved`);
+  try {
+    (d.saveJevKey ?? saveJevKey)(key);
+    console.log(`${mark("ok")} Jev: the key answers; saved with mode 600`);
+  } catch (e) {
+    const message = errorMessage(e).split("\n").join(" ");
+    console.log(`${mark("warn")} Jev: could not save the key: ${message}`);
+    if (isCatherdError(e) && e.fix) console.log(`    fix: ${e.fix}`);
+  }
+}
+
+/**
+ * Spec 1.1 §12: installs the global CLI at this version (the plugin's launcher then needs no bunx), and
+ * says "installing catherd…" before the resolve. It never stops `init`: a failure is a `!` line and its fix.
+ */
+export async function globalStep(
+  version: string,
+  o: { skip: boolean; deps?: GlobalInstallDeps; plain?: boolean },
+): Promise<void> {
+  const mark = (state: State) => markOf(state, o.plain === true);
+  if (o.skip)
+    return console.log(`- catherd: not installed globally (--no-global); the plugin starts it with bunx`);
+  const r = await ensureGlobal(version, o.deps ?? realGlobalInstall, () =>
+    console.log(`installing catherd… (${reinstallCommand(version)})`),
+  );
+  if (r.state === "current") return console.log(`${mark("ok")} catherd ${version} is installed globally`);
+  if (r.state === "installed")
+    return console.log(
+      `${mark("ok")} catherd ${version} installed globally; the plugin starts it without bunx`,
+    );
+  if (r.state === "shadowed") {
+    const found = r.onPath === null ? "no catherd is on PATH" : `the catherd first on PATH is ${r.onPath}`;
+    console.log(
+      `${mark("warn")} catherd ${version} installed globally, but ${found}, so the plugin starts it with bunx`,
+    );
+    return console.log(
+      `    fix: put bun's global bin folder (bun pm bin -g) first on PATH, then run catherd init again`,
+    );
+  }
+  console.log(`${mark("warn")} could not install catherd globally: ${r.reason}`);
+  console.log(`    fix: ${reinstallCommand(version)}`);
+}
+
+/** What happened to the profile: written, kept, or (when the defaults do not validate here) why not. */
+export function profileLines(r: InitResult, plain = false): string[] {
+  const mark = (state: State) => markOf(state, plain);
+  const out: string[] = [];
+  if (r.errors.length) {
+    out.push(
+      `${mark("warn")} profile ${r.profile}: the default profile does not validate here, so it was not written`,
+    );
+    for (const e of r.errors) {
+      out.push(`${mark("warn")} ${e.path}: ${e.message}`);
+      if (e.fix) out.push(`    fix: ${e.fix}`);
+    }
+  }
+  if (!r.active)
+    out.push(`${mark("warn")} no profile was made active: fix the rows above, then run catherd init again`);
+  else
+    out.push(
+      `${mark("ok")} profile ${r.profile} ${r.created ? "written from the defaults" : "kept as it was"}, and active`,
+    );
+  return out;
+}
+
+/** Spec §8 `catherd init [--no-input]`: first-run setup without the TUI (plan 6 adds the TUI wizard). */
+export const initCommand = defineCommand({
+  meta: {
+    name: "init",
+    description:
+      "First run: the global catherd command, the Jev key, the default profile, its agents, and a readiness report. Piped, it reads the answers from stdin one per line, a line per question even when this machine skips it (the Jev key, the profile, whether to replace it), and waits for stdin to close; --no-input asks nothing",
+  },
+  args: {
+    // citty reads --no-input as input: false, whatever the flag is named; naming it no-input shows it as is
+    "no-input": { type: "boolean", description: "ask nothing: keep what exists, else write the defaults" },
+    // read as global: false, like no-input above
+    "no-global": {
+      type: "boolean",
+      description: "do not install the global catherd command (bun add -g catherd-cli@<this version>)",
+    },
+    profile: { type: "string", description: "the profile to set up and make active (default: default)" },
+    plain: { type: "boolean", description: "ASCII glyphs (NO_COLOR drops only colour)" },
+  },
+  async run({ args }) {
+    // a bad --profile is refused before any question is asked
+    if (args.profile !== undefined) assertProfileName(args.profile);
+    const ask = (args as { input?: boolean }).input === false ? null : await prompter();
+    const plain = args.plain === true;
+    const mark = (state: State) => markOf(state, plain);
+    try {
+      if (process.stdout.isTTY) for (const line of welcomeLines(VERSION)) console.log(line);
+      console.log(`catherd ${VERSION}: setting up in ${configDir()}`);
+      await globalStep(VERSION, { skip: (args as { global?: boolean }).global === false, plain });
+      await jevStep(ask, {}, plain);
+      if (args.profile !== undefined) ask?.skip?.();
+      const name = assertProfileName(
+        args.profile ?? (ask ? (await ask.ask("Profile to set up [default]: ")) || "default" : "default"),
+      );
+      // 0.x files go first, so a legacy profile about to be moved aside is never asked about
+      const moved = moveLegacy();
+      const exists = hasProfileFile(name);
+      if (!exists) ask?.skip?.();
+      const overwrite =
+        ask !== null &&
+        exists &&
+        /^y(es)?$/i.test(await ask.ask(`Replace profile ${name} with the default profile? [y/N] `));
+      const r = await initSetup({ profile: name, overwrite });
+      for (const f of [...moved, ...r.moved]) console.log(`${mark("ok")} moved a 0.x file aside: ${f}`);
+      for (const l of profileLines(r, plain)) console.log(l);
+      if (r.synced?.linked.length)
+        console.log(`${mark("ok")} Claude agents linked: ${r.synced.linked.join(", ")}`);
+      for (const x of r.refreshed) console.log(formatRefreshed(x, plain));
+      console.log("");
+      const report = await doctor({
+        bunVersion: Bun.version,
+        version: VERSION,
+        handshake: () => mcpHandshake(),
+      });
+      for (const l of formatReport(report, plain)) console.log(l);
+      console.log("");
+      for (const l of PLUGIN_STEPS) console.log(l);
+    } finally {
+      ask?.close();
+    }
+  },
+});