@doccov/cli 0.25.7 → 0.25.9

package/dist/cli.js

@@ -151,6 +151,995 @@ import * as path10 from "node:path";
 import { fileURLToPath } from "node:url";
 import { Command } from "commander";
 
+// ../cli-utils/dist/index.js
+import chalk from "chalk";
+import chalk2 from "chalk";
+var colors = {
+  success: chalk.green,
+  error: chalk.red,
+  warning: chalk.yellow,
+  info: chalk.cyan,
+  muted: chalk.gray,
+  bold: chalk.bold,
+  dim: chalk.dim,
+  underline: chalk.underline,
+  primary: chalk.cyan,
+  secondary: chalk.magenta,
+  path: chalk.cyan,
+  number: chalk.yellow,
+  code: chalk.gray
+};
+var symbols = {
+  success: "✓",
+  error: "✗",
+  warning: "⚠",
+  info: "ℹ",
+  spinner: ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"],
+  bullet: "•",
+  arrow: "→",
+  arrowRight: "›",
+  line: "─",
+  corner: "└",
+  vertical: "│",
+  horizontalLine: "─"
+};
+var asciiSymbols = {
+  success: "+",
+  error: "x",
+  warning: "!",
+  info: "i",
+  spinner: ["-", "\\", "|", "/"],
+  bullet: "*",
+  arrow: "->",
+  arrowRight: ">",
+  line: "-",
+  corner: "\\",
+  vertical: "|",
+  horizontalLine: "-"
+};
+function getSymbols(unicodeSupport = true) {
+  return unicodeSupport ? symbols : asciiSymbols;
+}
+var prefix = {
+  success: colors.success(symbols.success),
+  error: colors.error(symbols.error),
+  warning: colors.warning(symbols.warning),
+  info: colors.info(symbols.info)
+};
+function isTTY() {
+  return Boolean(process.stdout.isTTY);
+}
+function isCI() {
+  return Boolean(process.env.CI || process.env.GITHUB_ACTIONS || process.env.GITLAB_CI || process.env.CIRCLECI || process.env.TRAVIS || process.env.JENKINS_URL || process.env.BUILDKITE || process.env.TEAMCITY_VERSION || process.env.TF_BUILD || process.env.CODEBUILD_BUILD_ID || process.env.BITBUCKET_BUILD_NUMBER);
+}
+function isInteractive() {
+  return isTTY() && !isCI();
+}
+function supportsUnicode() {
+  if (process.platform === "win32") {
+    return Boolean(process.env.WT_SESSION) || process.env.TERM_PROGRAM === "vscode";
+  }
+  return process.env.TERM !== "linux";
+}
+var MIN_TERMINAL_WIDTH = 40;
+var DEFAULT_TERMINAL_WIDTH = 80;
+function getTerminalWidth() {
+  const width = process.stdout.columns || DEFAULT_TERMINAL_WIDTH;
+  return Math.max(width, MIN_TERMINAL_WIDTH);
+}
+function formatDuration(ms) {
+  if (ms < 1000) {
+    return `${ms}ms`;
+  }
+  const seconds = ms / 1000;
+  if (seconds < 60) {
+    return `${seconds.toFixed(1)}s`;
+  }
+  const minutes = Math.floor(seconds / 60);
+  const remainingSeconds = Math.floor(seconds % 60);
+  return `${minutes}m ${remainingSeconds}s`;
+}
+var cursor = {
+  hide: "\x1B[?25l",
+  show: "\x1B[?25h",
+  up: (n = 1) => `\x1B[${n}A`,
+  down: (n = 1) => `\x1B[${n}B`,
+  forward: (n = 1) => `\x1B[${n}C`,
+  back: (n = 1) => `\x1B[${n}D`,
+  left: "\x1B[G",
+  clearLine: "\x1B[2K",
+  clearDown: "\x1B[J",
+  save: "\x1B[s",
+  restore: "\x1B[u"
+};
+function clearLine() {
+  if (isTTY()) {
+    process.stdout.write(cursor.clearLine + cursor.left);
+  }
+}
+function moveCursorUp(lines = 1) {
+  if (isTTY()) {
+    process.stdout.write(cursor.up(lines));
+  }
+}
+function hideCursor() {
+  if (isTTY()) {
+    process.stdout.write(cursor.hide);
+  }
+}
+function showCursor() {
+  if (isTTY()) {
+    process.stdout.write(cursor.show);
+  }
+}
+function truncate(text, maxLength) {
+  if (text.length <= maxLength)
+    return text;
+  return `${text.slice(0, maxLength - 1)}…`;
+}
+var ANSI_REGEX = /\x1B\[[0-9;]*[a-zA-Z]/g;
+function stripAnsi(text) {
+  return text.replace(ANSI_REGEX, "");
+}
+
+class MultiProgress {
+  bars = new Map;
+  barOrder = [];
+  options;
+  spinnerFrames;
+  spinnerIndex = 0;
+  timer = null;
+  lastRenderedLines = 0;
+  symbols = getSymbols(supportsUnicode());
+  sigintHandler = null;
+  filledChar;
+  emptyChar;
+  constructor(options = {}) {
+    this.options = {
+      barWidth: options.barWidth,
+      showPercent: options.showPercent ?? true,
+      showCount: options.showCount ?? true,
+      spinnerInterval: options.spinnerInterval ?? 80
+    };
+    this.spinnerFrames = supportsUnicode() ? ["◐", "◓", "◑", "◒"] : ["-", "\\", "|", "/"];
+    const unicode = supportsUnicode();
+    this.filledChar = unicode ? "█" : "#";
+    this.emptyChar = unicode ? "░" : "-";
+  }
+  start() {
+    if (!isInteractive())
+      return this;
+    hideCursor();
+    this.setupSignalHandler();
+    this.timer = setInterval(() => {
+      this.spinnerIndex = (this.spinnerIndex + 1) % this.spinnerFrames.length;
+      if (this.bars.size > 0 && [...this.bars.values()].some((b) => b.status === "active")) {
+        this.render();
+      }
+    }, this.options.spinnerInterval);
+    return this;
+  }
+  add(config) {
+    const state = {
+      id: config.id,
+      label: config.label,
+      total: config.total ?? 100,
+      current: config.current ?? 0,
+      status: "active",
+      startTime: Date.now()
+    };
+    this.bars.set(config.id, state);
+    if (!this.barOrder.includes(config.id)) {
+      this.barOrder.push(config.id);
+    }
+    if (!isInteractive()) {
+      console.log(`${this.symbols.bullet} ${config.label}`);
+    } else {
+      this.render();
+    }
+    return this;
+  }
+  update(id, current, label) {
+    const bar = this.bars.get(id);
+    if (!bar)
+      return this;
+    bar.current = Math.min(current, bar.total);
+    if (label !== undefined)
+      bar.label = label;
+    if (isInteractive()) {
+      this.render();
+    }
+    return this;
+  }
+  increment(id, amount = 1) {
+    const bar = this.bars.get(id);
+    if (!bar)
+      return this;
+    return this.update(id, bar.current + amount);
+  }
+  complete(id, label) {
+    const bar = this.bars.get(id);
+    if (!bar)
+      return this;
+    bar.status = "completed";
+    bar.current = bar.total;
+    if (label !== undefined)
+      bar.label = label;
+    if (!isInteractive()) {
+      console.log(`${colors.success(this.symbols.success)} ${bar.label}`);
+    } else {
+      this.render();
+    }
+    return this;
+  }
+  fail(id, label) {
+    const bar = this.bars.get(id);
+    if (!bar)
+      return this;
+    bar.status = "failed";
+    if (label !== undefined)
+      bar.label = label;
+    if (!isInteractive()) {
+      console.log(`${colors.error(this.symbols.error)} ${bar.label}`);
+    } else {
+      this.render();
+    }
+    return this;
+  }
+  remove(id) {
+    this.bars.delete(id);
+    this.barOrder = this.barOrder.filter((i) => i !== id);
+    if (isInteractive()) {
+      this.render();
+    }
+    return this;
+  }
+  get(id) {
+    return this.bars.get(id);
+  }
+  get allDone() {
+    if (this.bars.size === 0)
+      return true;
+    return [...this.bars.values()].every((b) => b.status !== "active");
+  }
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    this.cleanup();
+    return this;
+  }
+  render() {
+    if (!isTTY())
+      return;
+    this.clearOutput();
+    const width = getTerminalWidth();
+    const lines = [];
+    for (const id of this.barOrder) {
+      const bar = this.bars.get(id);
+      if (!bar)
+        continue;
+      const line = this.renderBar(bar, width);
+      lines.push(line);
+    }
+    if (lines.length > 0) {
+      process.stdout.write(lines.join(`
+`));
+      this.lastRenderedLines = lines.length;
+    }
+  }
+  renderBar(bar, termWidth) {
+    const parts = [];
+    let symbol;
+    switch (bar.status) {
+      case "completed":
+        symbol = colors.success(this.symbols.success);
+        break;
+      case "failed":
+        symbol = colors.error(this.symbols.error);
+        break;
+      default:
+        symbol = colors.primary(this.spinnerFrames[this.spinnerIndex]);
+    }
+    parts.push(symbol);
+    parts.push(bar.label);
+    const suffixParts = [];
+    if (this.options.showPercent) {
+      const pct = bar.total === 0 ? 0 : Math.round(bar.current / bar.total * 100);
+      suffixParts.push(`${pct}%`);
+    }
+    if (this.options.showCount) {
+      suffixParts.push(`${bar.current}/${bar.total}`);
+    }
+    const suffix = suffixParts.length > 0 ? ` ${suffixParts.join(" ")}` : "";
+    const labelLen = stripAnsi(parts.join(" ")).length + 1;
+    const bracketLen = 2;
+    const suffixLen = stripAnsi(suffix).length;
+    const minBarWidth = 10;
+    const availableWidth = termWidth - labelLen - bracketLen - suffixLen - 1;
+    const barWidth = this.options.barWidth ?? Math.max(minBarWidth, Math.min(30, availableWidth));
+    const filledWidth = Math.round(bar.current / bar.total * barWidth);
+    const emptyWidth = barWidth - filledWidth;
+    const barViz = `[${this.filledChar.repeat(filledWidth)}${this.emptyChar.repeat(emptyWidth)}]`;
+    parts.push(barViz);
+    return truncate(parts.join(" ") + suffix, termWidth);
+  }
+  clearOutput() {
+    if (!isTTY() || this.lastRenderedLines === 0)
+      return;
+    for (let i = 0;i < this.lastRenderedLines; i++) {
+      if (i > 0)
+        process.stdout.write(cursor.up(1));
+      clearLine();
+    }
+    this.lastRenderedLines = 0;
+  }
+  setupSignalHandler() {
+    this.sigintHandler = () => {
+      this.cleanup();
+      process.exit(130);
+    };
+    process.on("SIGINT", this.sigintHandler);
+  }
+  cleanup() {
+    if (this.sigintHandler) {
+      process.removeListener("SIGINT", this.sigintHandler);
+      this.sigintHandler = null;
+    }
+    showCursor();
+    if (isTTY() && this.lastRenderedLines > 0) {
+      process.stdout.write(`
+`);
+    }
+  }
+}
+class ProgressBar {
+  total;
+  current;
+  label;
+  width;
+  showPercent;
+  showCount;
+  showETA;
+  filledChar;
+  emptyChar;
+  startTime = null;
+  lastRender = "";
+  symbols = getSymbols(supportsUnicode());
+  sigintHandler = null;
+  isComplete = false;
+  constructor(options = {}) {
+    this.total = options.total ?? 100;
+    this.current = options.current ?? 0;
+    this.label = options.label ?? "";
+    this.width = options.width;
+    this.showPercent = options.showPercent ?? true;
+    this.showCount = options.showCount ?? true;
+    this.showETA = options.showETA ?? true;
+    const unicode = supportsUnicode();
+    this.filledChar = options.chars?.filled ?? (unicode ? "█" : "#");
+    this.emptyChar = options.chars?.empty ?? (unicode ? "░" : "-");
+  }
+  start(label) {
+    if (label !== undefined)
+      this.label = label;
+    this.startTime = Date.now();
+    this.current = 0;
+    this.isComplete = false;
+    if (!isInteractive()) {
+      console.log(`${this.symbols.bullet} ${this.label}`);
+      return this;
+    }
+    hideCursor();
+    this.setupSignalHandler();
+    this.render();
+    return this;
+  }
+  update(current) {
+    this.current = Math.min(current, this.total);
+    if (isInteractive()) {
+      this.render();
+    }
+    return this;
+  }
+  increment(amount = 1) {
+    return this.update(this.current + amount);
+  }
+  setLabel(label) {
+    this.label = label;
+    if (isInteractive()) {
+      this.render();
+    }
+    return this;
+  }
+  setTotal(total) {
+    this.total = total;
+    if (isInteractive()) {
+      this.render();
+    }
+    return this;
+  }
+  complete(label) {
+    if (label !== undefined)
+      this.label = label;
+    this.current = this.total;
+    this.isComplete = true;
+    if (!isInteractive()) {
+      console.log(`${colors.success(this.symbols.success)} ${this.label}`);
+    } else {
+      clearLine();
+      process.stdout.write(`${colors.success(this.symbols.success)} ${this.label}
+`);
+    }
+    this.cleanup();
+    return this;
+  }
+  fail(label) {
+    if (label !== undefined)
+      this.label = label;
+    this.isComplete = true;
+    if (!isInteractive()) {
+      console.log(`${colors.error(this.symbols.error)} ${this.label}`);
+    } else {
+      clearLine();
+      process.stdout.write(`${colors.error(this.symbols.error)} ${this.label}
+`);
+    }
+    this.cleanup();
+    return this;
+  }
+  get percentage() {
+    return this.total === 0 ? 0 : Math.round(this.current / this.total * 100);
+  }
+  get isDone() {
+    return this.isComplete || this.current >= this.total;
+  }
+  render() {
+    if (!isTTY())
+      return;
+    const termWidth = getTerminalWidth();
+    const parts = [];
+    if (this.label) {
+      parts.push(this.label);
+    }
+    const suffixParts = [];
+    if (this.showPercent) {
+      suffixParts.push(`${this.percentage}%`);
+    }
+    if (this.showCount) {
+      suffixParts.push(`${this.current}/${this.total}`);
+    }
+    if (this.showETA && this.startTime) {
+      const eta = this.calculateETA();
+      if (eta)
+        suffixParts.push(eta);
+    }
+    const suffix = suffixParts.length > 0 ? ` ${suffixParts.join(" ")}` : "";
+    const labelLen = this.label ? stripAnsi(this.label).length + 1 : 0;
+    const bracketLen = 2;
+    const suffixLen = stripAnsi(suffix).length;
+    const minBarWidth = 10;
+    const availableWidth = termWidth - labelLen - bracketLen - suffixLen - 1;
+    const barWidth = this.width ?? Math.max(minBarWidth, Math.min(40, availableWidth));
+    const filledWidth = Math.round(this.current / this.total * barWidth);
+    const emptyWidth = barWidth - filledWidth;
+    const bar = `[${this.filledChar.repeat(filledWidth)}${this.emptyChar.repeat(emptyWidth)}]`;
+    parts.push(bar);
+    const line = truncate(parts.join(" ") + suffix, termWidth);
+    if (line !== this.lastRender) {
+      clearLine();
+      process.stdout.write(line);
+      this.lastRender = line;
+    }
+  }
+  calculateETA() {
+    if (!this.startTime || this.current === 0)
+      return null;
+    const elapsed = Date.now() - this.startTime;
+    if (elapsed < 1000)
+      return null;
+    const rate = this.current / elapsed;
+    const remaining = this.total - this.current;
+    const etaMs = remaining / rate;
+    return `ETA ${formatDuration(etaMs)}`;
+  }
+  setupSignalHandler() {
+    this.sigintHandler = () => {
+      this.cleanup();
+      process.exit(130);
+    };
+    process.on("SIGINT", this.sigintHandler);
+  }
+  cleanup() {
+    if (this.sigintHandler) {
+      process.removeListener("SIGINT", this.sigintHandler);
+      this.sigintHandler = null;
+    }
+    showCursor();
+  }
+}
+var spinnerColors = {
+  cyan: chalk2.cyan,
+  yellow: chalk2.yellow,
+  green: chalk2.green,
+  red: chalk2.red,
+  magenta: chalk2.magenta,
+  blue: chalk2.blue,
+  white: chalk2.white
+};
+var FRAME_SETS = {
+  dots: ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"],
+  circle: ["◐", "◓", "◑", "◒"]
+};
+var ASCII_FRAME_SET = ["-", "\\", "|", "/"];
+
+class Spinner {
+  label;
+  detail;
+  frames;
+  interval;
+  colorFn;
+  frameIndex = 0;
+  timer = null;
+  state = "stopped";
+  symbols = getSymbols(supportsUnicode());
+  lastRenderedLines = 0;
+  sigintHandler = null;
+  constructor(options = {}) {
+    this.label = options.label ?? "";
+    this.detail = options.detail;
+    this.interval = options.interval ?? 80;
+    this.colorFn = spinnerColors[options.color ?? "cyan"];
+    const style = options.style ?? "circle";
+    this.frames = supportsUnicode() ? FRAME_SETS[style] : ASCII_FRAME_SET;
+  }
+  start(label) {
+    if (label !== undefined)
+      this.label = label;
+    if (this.state === "spinning")
+      return this;
+    this.state = "spinning";
+    this.frameIndex = 0;
+    this.lastRenderedLines = 0;
+    if (!isInteractive()) {
+      console.log(`${this.symbols.bullet} ${this.label}`);
+      return this;
+    }
+    hideCursor();
+    this.setupSignalHandler();
+    this.render();
+    this.timer = setInterval(() => {
+      this.frameIndex = (this.frameIndex + 1) % this.frames.length;
+      this.render();
+    }, this.interval);
+    return this;
+  }
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    this.state = "stopped";
+    this.clearOutput();
+    this.cleanup();
+    return this;
+  }
+  success(label) {
+    if (label !== undefined)
+      this.label = label;
+    this.finish("success");
+    return this;
+  }
+  fail(label) {
+    if (label !== undefined)
+      this.label = label;
+    this.finish("error");
+    return this;
+  }
+  update(label) {
+    this.label = label;
+    if (this.state === "spinning" && isInteractive()) {
+      this.render();
+    }
+    return this;
+  }
+  setDetail(detail) {
+    this.detail = detail;
+    if (this.state === "spinning" && isInteractive()) {
+      this.render();
+    }
+    return this;
+  }
+  get isSpinning() {
+    return this.state === "spinning";
+  }
+  finish(state) {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    this.state = state;
+    if (!isInteractive()) {
+      const symbol = state === "success" ? this.symbols.success : this.symbols.error;
+      const colorFn = state === "success" ? colors.success : colors.error;
+      console.log(`${colorFn(symbol)} ${this.label}`);
+    } else {
+      this.clearOutput();
+      const symbol = state === "success" ? this.symbols.success : this.symbols.error;
+      const colorFn = state === "success" ? colors.success : colors.error;
+      process.stdout.write(`${colorFn(symbol)} ${this.label}
+`);
+    }
+    this.cleanup();
+  }
+  render() {
+    if (!isTTY())
+      return;
+    this.clearOutput();
+    const frame = this.colorFn(this.frames[this.frameIndex]);
+    const width = getTerminalWidth();
+    const mainLine = truncate(`${frame} ${this.label}`, width);
+    process.stdout.write(mainLine);
+    let lines = 1;
+    if (this.detail) {
+      const detailLine = truncate(`  ${colors.muted(this.detail)}`, width);
+      process.stdout.write(`
+${detailLine}`);
+      lines = 2;
+    }
+    this.lastRenderedLines = lines;
+  }
+  clearOutput() {
+    if (!isTTY())
+      return;
+    for (let i = 0;i < this.lastRenderedLines; i++) {
+      if (i > 0)
+        process.stdout.write(cursor.up(1));
+      clearLine();
+    }
+  }
+  setupSignalHandler() {
+    this.sigintHandler = () => {
+      this.cleanup();
+      process.exit(130);
+    };
+    process.on("SIGINT", this.sigintHandler);
+  }
+  cleanup() {
+    if (this.sigintHandler) {
+      process.removeListener("SIGINT", this.sigintHandler);
+      this.sigintHandler = null;
+    }
+    showCursor();
+  }
+}
+function spinner(label, options) {
+  return new Spinner({ ...options, label }).start();
+}
+
+class StepProgress {
+  steps = [];
+  showNumbers;
+  spinnerInterval;
+  spinnerFrames;
+  spinnerIndex = 0;
+  timer = null;
+  symbols = getSymbols(supportsUnicode());
+  lastRenderedLines = 0;
+  sigintHandler = null;
+  constructor(options = {}) {
+    this.showNumbers = options.showNumbers ?? true;
+    this.spinnerInterval = options.spinnerInterval ?? 80;
+    this.spinnerFrames = supportsUnicode() ? ["◐", "◓", "◑", "◒"] : ["-", "\\", "|", "/"];
+    if (options.steps) {
+      this.steps = options.steps.map((label) => ({ label, status: "pending" }));
+    }
+  }
+  start() {
+    if (!isInteractive())
+      return this;
+    hideCursor();
+    this.setupSignalHandler();
+    this.render();
+    this.timer = setInterval(() => {
+      this.spinnerIndex = (this.spinnerIndex + 1) % this.spinnerFrames.length;
+      if (this.steps.some((s) => s.status === "active")) {
+        this.render();
+      }
+    }, this.spinnerInterval);
+    return this;
+  }
+  addStep(label) {
+    this.steps.push({ label, status: "pending" });
+    if (isInteractive())
+      this.render();
+    return this;
+  }
+  startStep(index) {
+    if (index >= 0 && index < this.steps.length) {
+      this.steps[index].status = "active";
+      this.steps[index].startTime = Date.now();
+      if (isInteractive()) {
+        this.render();
+      } else {
+        const step = this.steps[index];
+        const prefix2 = this.showNumbers ? `[${index + 1}/${this.steps.length}] ` : "";
+        console.log(`${this.symbols.bullet} ${prefix2}${step.label}...`);
+      }
+    }
+    return this;
+  }
+  completeStep(index) {
+    if (index >= 0 && index < this.steps.length) {
+      this.steps[index].status = "completed";
+      this.steps[index].endTime = Date.now();
+      if (isInteractive()) {
+        this.render();
+      } else {
+        const step = this.steps[index];
+        const duration = this.getStepDuration(step);
+        const prefix2 = this.showNumbers ? `[${index + 1}/${this.steps.length}] ` : "";
+        console.log(`${colors.success(this.symbols.success)} ${prefix2}${step.label}${duration}`);
+      }
+    }
+    return this;
+  }
+  failStep(index) {
+    if (index >= 0 && index < this.steps.length) {
+      this.steps[index].status = "failed";
+      this.steps[index].endTime = Date.now();
+      if (isInteractive()) {
+        this.render();
+      } else {
+        const step = this.steps[index];
+        const prefix2 = this.showNumbers ? `[${index + 1}/${this.steps.length}] ` : "";
+        console.log(`${colors.error(this.symbols.error)} ${prefix2}${step.label}`);
+      }
+    }
+    return this;
+  }
+  skipStep(index) {
+    if (index >= 0 && index < this.steps.length) {
+      this.steps[index].status = "skipped";
+      if (isInteractive())
+        this.render();
+    }
+    return this;
+  }
+  async run(tasks) {
+    this.steps = tasks.map((t) => ({ label: t.label, status: "pending" }));
+    this.start();
+    const results = [];
+    let failed = false;
+    for (let i = 0;i < tasks.length; i++) {
+      if (failed) {
+        this.skipStep(i);
+        continue;
+      }
+      this.startStep(i);
+      try {
+        results.push(await tasks[i].task());
+        this.completeStep(i);
+      } catch {
+        this.failStep(i);
+        failed = true;
+      }
+    }
+    this.stop();
+    return { results, failed };
+  }
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    this.cleanup();
+    return this;
+  }
+  get currentStepIndex() {
+    const activeIdx = this.steps.findIndex((s) => s.status === "active");
+    if (activeIdx >= 0)
+      return activeIdx;
+    return this.steps.findIndex((s) => s.status === "pending");
+  }
+  render() {
+    if (!isTTY())
+      return;
+    if (this.lastRenderedLines > 0) {
+      moveCursorUp(this.lastRenderedLines - 1);
+      for (let i = 0;i < this.lastRenderedLines; i++) {
+        clearLine();
+        if (i < this.lastRenderedLines - 1) {
+          process.stdout.write(cursor.down(1));
+        }
+      }
+      moveCursorUp(this.lastRenderedLines - 1);
+    }
+    const width = getTerminalWidth();
+    const lines = [];
+    for (let i = 0;i < this.steps.length; i++) {
+      const step = this.steps[i];
+      const prefix2 = this.showNumbers ? `[${i + 1}/${this.steps.length}] ` : "";
+      const duration = this.getStepDuration(step);
+      let symbol;
+      let text;
+      switch (step.status) {
+        case "completed":
+          symbol = colors.success(this.symbols.success);
+          text = `${prefix2}${step.label}${duration}`;
+          break;
+        case "failed":
+          symbol = colors.error(this.symbols.error);
+          text = `${prefix2}${step.label}`;
+          break;
+        case "active":
+          symbol = colors.primary(this.spinnerFrames[this.spinnerIndex]);
+          text = `${prefix2}${step.label}`;
+          break;
+        case "skipped":
+          symbol = colors.muted(this.symbols.bullet);
+          text = colors.muted(`${prefix2}${step.label} (skipped)`);
+          break;
+        default:
+          symbol = colors.muted("○");
+          text = colors.muted(`${prefix2}${step.label}`);
+      }
+      lines.push(truncate(`${symbol} ${text}`, width));
+    }
+    process.stdout.write(lines.join(`
+`));
+    this.lastRenderedLines = lines.length;
+  }
+  getStepDuration(step) {
+    if (step.startTime && step.endTime) {
+      const ms = step.endTime - step.startTime;
+      return colors.muted(` (${formatDuration(ms)})`);
+    }
+    return "";
+  }
+  setupSignalHandler() {
+    this.sigintHandler = () => {
+      this.cleanup();
+      process.exit(130);
+    };
+    process.on("SIGINT", this.sigintHandler);
+  }
+  cleanup() {
+    if (this.sigintHandler) {
+      process.removeListener("SIGINT", this.sigintHandler);
+      this.sigintHandler = null;
+    }
+    showCursor();
+    if (isTTY() && this.lastRenderedLines > 0) {
+      process.stdout.write(`
+`);
+    }
+  }
+}
+class Summary {
+  items = [];
+  title;
+  boxed;
+  keyWidth;
+  symbols = getSymbols(supportsUnicode());
+  constructor(options = {}) {
+    this.title = options.title;
+    this.boxed = options.boxed ?? false;
+    this.keyWidth = options.keyWidth;
+  }
+  add(item) {
+    this.items.push(item);
+    return this;
+  }
+  addKeyValue(key, value, status) {
+    return this.add({ key, value, status });
+  }
+  addWithThreshold(key, value, threshold) {
+    const status = this.evaluateThreshold(value, threshold) ? "pass" : "fail";
+    return this.add({ key, value, status, threshold });
+  }
+  print() {
+    const output = this.render();
+    console.log(output);
+  }
+  render() {
+    if (this.items.length === 0)
+      return "";
+    const lines = [];
+    const termWidth = getTerminalWidth();
+    const calculatedKeyWidth = this.keyWidth ?? Math.max(...this.items.map((i) => i.key.length));
+    if (this.boxed) {
+      return this.renderBoxed(calculatedKeyWidth, termWidth);
+    }
+    if (this.title) {
+      lines.push(colors.bold(this.title));
+      lines.push("");
+    }
+    for (const item of this.items) {
+      lines.push(this.formatItem(item, calculatedKeyWidth));
+    }
+    return lines.join(`
+`);
+  }
+  renderBoxed(keyWidth, termWidth) {
+    const lines = [];
+    const unicode = supportsUnicode();
+    const box = unicode ? { tl: "┌", tr: "┐", bl: "└", br: "┘", h: "─", v: "│" } : { tl: "+", tr: "+", bl: "+", br: "+", h: "-", v: "|" };
+    const contentLines = this.items.map((item) => this.formatItem(item, keyWidth));
+    const maxContentWidth = Math.max(...contentLines.map((l) => stripAnsi(l).length), this.title ? this.title.length : 0);
+    const innerWidth = Math.min(maxContentWidth + 2, termWidth - 4);
+    lines.push(box.tl + box.h.repeat(innerWidth) + box.tr);
+    if (this.title) {
+      const padding = innerWidth - this.title.length;
+      const leftPad = Math.floor(padding / 2);
+      const rightPad = padding - leftPad;
+      lines.push(`${box.v}${" ".repeat(leftPad)}${colors.bold(this.title)}${" ".repeat(rightPad)}${box.v}`);
+      lines.push(`${box.v}${" ".repeat(innerWidth)}${box.v}`);
+    }
+    for (const line of contentLines) {
+      const visibleLen = stripAnsi(line).length;
+      const padding = innerWidth - visibleLen - 1;
+      lines.push(`${box.v} ${line}${" ".repeat(Math.max(0, padding))}${box.v}`);
+    }
+    lines.push(box.bl + box.h.repeat(innerWidth) + box.br);
+    return lines.join(`
+`);
+  }
+  formatItem(item, keyWidth) {
+    const key = item.key.padEnd(keyWidth);
+    const value = String(item.value);
+    let indicator = "";
+    if (item.status) {
+      switch (item.status) {
+        case "pass":
+          indicator = `${colors.success(this.symbols.success)} `;
+          break;
+        case "fail":
+          indicator = `${colors.error(this.symbols.error)} `;
+          break;
+        case "warn":
+          indicator = `${colors.warning(this.symbols.warning)} `;
+          break;
+        case "info":
+          indicator = `${colors.info(this.symbols.info)} `;
+          break;
+      }
+    }
+    let thresholdStr = "";
+    if (item.threshold) {
+      const { operator, value: thresh } = item.threshold;
+      thresholdStr = colors.muted(` (${operator} ${thresh})`);
+    }
+    let coloredValue = value;
+    if (item.status === "pass")
+      coloredValue = colors.success(value);
+    else if (item.status === "fail")
+      coloredValue = colors.error(value);
+    else if (item.status === "warn")
+      coloredValue = colors.warning(value);
+    return `${indicator}${colors.muted(key)}  ${coloredValue}${thresholdStr}`;
+  }
+  evaluateThreshold(value, threshold) {
+    if (!threshold)
+      return true;
+    const { operator, value: thresh } = threshold;
+    switch (operator) {
+      case "<":
+        return value < thresh;
+      case ">":
+        return value > thresh;
+      case "<=":
+        return value <= thresh;
+      case ">=":
+        return value >= thresh;
+    }
+  }
+}
+function summary(options) {
+  return new Summary(options);
+}
+
 // src/commands/check/index.ts
 import {
   buildDocCovSpec,
@@ -159,11 +1148,11 @@ import {
   parseExamplesFlag,
   resolveTarget
 } from "@doccov/sdk";
-import chalk6 from "chalk";
+import chalk7 from "chalk";
 
 // src/utils/filter-options.ts
 import { mergeFilters, parseListFlag } from "@doccov/sdk";
-import chalk from "chalk";
+import chalk3 from "chalk";
 var parseVisibilityFlag = (value) => {
   if (!value)
     return;
@@ -180,7 +1169,7 @@ var parseVisibilityFlag = (value) => {
   }
   return result.length > 0 ? result : undefined;
 };
-var formatList = (label, values) => `${label}: ${values.map((value) => chalk.cyan(value)).join(", ")}`;
+var formatList = (label, values) => `${label}: ${values.map((value) => chalk3.cyan(value)).join(", ")}`;
 var mergeFilterOptions = (config, cliOptions) => {
   const messages = [];
   if (config?.include) {
@@ -212,57 +1201,6 @@ var mergeFilterOptions = (config, cliOptions) => {
   };
 };
 
-// src/utils/progress.ts
-import chalk2 from "chalk";
-class StepProgress {
-  steps;
-  currentStep = 0;
-  startTime;
-  stepStartTime;
-  constructor(steps) {
-    this.steps = steps;
-    this.startTime = Date.now();
-    this.stepStartTime = Date.now();
-  }
-  start(stepIndex) {
-    this.currentStep = stepIndex ?? 0;
-    this.stepStartTime = Date.now();
-    this.render();
-  }
-  next() {
-    this.completeCurrentStep();
-    this.currentStep++;
-    if (this.currentStep < this.steps.length) {
-      this.stepStartTime = Date.now();
-      this.render();
-    }
-  }
-  complete(message) {
-    this.completeCurrentStep();
-    if (message) {
-      const elapsed = ((Date.now() - this.startTime) / 1000).toFixed(1);
-      console.log(`${chalk2.green("✓")} ${message} ${chalk2.dim(`(${elapsed}s)`)}`);
-    }
-  }
-  render() {
-    const step = this.steps[this.currentStep];
-    if (!step)
-      return;
-    const label = step.activeLabel ?? step.label;
-    const prefix = chalk2.dim(`[${this.currentStep + 1}/${this.steps.length}]`);
-    process.stdout.write(`\r${prefix} ${chalk2.cyan(label)}...`);
-  }
-  completeCurrentStep() {
-    const step = this.steps[this.currentStep];
-    if (!step)
-      return;
-    const elapsed = ((Date.now() - this.stepStartTime) / 1000).toFixed(1);
-    const prefix = chalk2.dim(`[${this.currentStep + 1}/${this.steps.length}]`);
-    process.stdout.write(`\r${" ".repeat(80)}\r`);
-    console.log(`${prefix} ${step.label} ${chalk2.green("✓")} ${chalk2.dim(`(${elapsed}s)`)}`);
-  }
-}
-
 // src/utils/validation.ts
 function clampPercentage(value, fallback = 80) {
   if (Number.isNaN(value))
@@ -287,7 +1225,7 @@ import {
   parseJSDocToPatch,
   serializeJSDoc
 } from "@doccov/sdk";
-import chalk3 from "chalk";
+import chalk5 from "chalk";
 
 // src/commands/check/utils.ts
 import * as fs from "node:fs";
@@ -361,13 +1299,13 @@ async function handleFixes(openpkg, doccov, options, deps) {
   }
   const { fixable, nonFixable } = categorizeDrifts(allDrifts.map((d) => d.drift));
   if (fixable.length === 0) {
-    log(chalk3.yellow(`Found ${nonFixable.length} drift issue(s), but none are auto-fixable.`));
+    log(chalk5.yellow(`Found ${nonFixable.length} drift issue(s), but none are auto-fixable.`));
     return { fixedDriftKeys, editsApplied: 0, filesModified: 0 };
   }
   log("");
-  log(chalk3.bold(`Found ${fixable.length} fixable issue(s)`));
+  log(chalk5.bold(`Found ${fixable.length} fixable issue(s)`));
   if (nonFixable.length > 0) {
-    log(chalk3.gray(`(${nonFixable.length} non-fixable issue(s) skipped)`));
+    log(chalk5.gray(`(${nonFixable.length} non-fixable issue(s) skipped)`));
   }
   log("");
   const groupedDrifts = groupByExport(allDrifts.filter((d) => fixable.includes(d.drift)));
@@ -400,16 +1338,16 @@ async function handleFixes(openpkg, doccov, options, deps) {
   const applyResult = await applyEdits(edits);
   if (applyResult.errors.length > 0) {
     for (const err of applyResult.errors) {
-      error(chalk3.red(`  ${err.file}: ${err.error}`));
+      error(chalk5.red(`  ${err.file}: ${err.error}`));
     }
   }
   const totalFixes = Array.from(editsByFile.values()).reduce((sum, fileEdits) => sum + fileEdits.reduce((s, e) => s + e.fixes.length, 0), 0);
   log("");
-  log(chalk3.green(`✓ Applied ${totalFixes} fix(es) to ${applyResult.filesModified} file(s)`));
+  log(chalk5.green(`✓ Applied ${totalFixes} fix(es) to ${applyResult.filesModified} file(s)`));
   for (const [filePath, fileEdits] of editsByFile) {
     const relativePath = path3.relative(targetDir, filePath);
     const fixCount = fileEdits.reduce((s, e) => s + e.fixes.length, 0);
-    log(chalk3.dim(`  ${relativePath} (${fixCount} fixes)`));
+    log(chalk5.dim(`  ${relativePath} (${fixCount} fixes)`));
   }
   return {
     fixedDriftKeys,
@@ -419,22 +1357,22 @@ async function handleFixes(openpkg, doccov, options, deps) {
 }
 function generateEditForExport(exp, drifts, targetDir, log) {
   if (!exp.source?.file) {
-    log(chalk3.gray(`  Skipping ${exp.name}: no source location`));
+    log(chalk5.gray(`  Skipping ${exp.name}: no source location`));
     return null;
   }
   if (exp.source.file.endsWith(".d.ts")) {
-    log(chalk3.gray(`  Skipping ${exp.name}: declaration file`));
+    log(chalk5.gray(`  Skipping ${exp.name}: declaration file`));
     return null;
   }
   const filePath = path3.resolve(targetDir, exp.source.file);
   if (!fs2.existsSync(filePath)) {
-    log(chalk3.gray(`  Skipping ${exp.name}: file not found`));
+    log(chalk5.gray(`  Skipping ${exp.name}: file not found`));
     return null;
   }
   const sourceFile = createSourceFile(filePath);
   const location = findJSDocLocation(sourceFile, exp.name, exp.source.line);
   if (!location) {
-    log(chalk3.gray(`  Skipping ${exp.name}: could not find declaration`));
+    log(chalk5.gray(`  Skipping ${exp.name}: could not find declaration`));
     return null;
   }
   let existingPatch = {};
@@ -459,13 +1397,13 @@ function generateEditForExport(exp, drifts, targetDir, log) {
   return { filePath, edit, fixes, existingPatch };
 }
 function displayPreview(editsByFile, targetDir, log) {
-  log(chalk3.bold("Preview - changes that would be made:"));
+  log(chalk5.bold("Preview - changes that would be made:"));
   log("");
   for (const [filePath, fileEdits] of editsByFile) {
     const relativePath = path3.relative(targetDir, filePath);
     for (const { export: exp, edit, fixes } of fileEdits) {
-      log(chalk3.cyan(`${relativePath}:${edit.startLine + 1}`));
-      log(chalk3.bold(`  ${exp.name}`));
+      log(chalk5.cyan(`${relativePath}:${edit.startLine + 1}`));
+      log(chalk5.bold(`  ${exp.name}`));
       log("");
       if (edit.hasExisting && edit.existingJSDoc) {
         const oldLines = edit.existingJSDoc.split(`
@@ -473,31 +1411,30 @@ function displayPreview(editsByFile, targetDir, log) {
         const newLines = edit.newJSDoc.split(`
 `);
         for (const line of oldLines) {
-          log(chalk3.red(`  - ${line}`));
+          log(chalk5.red(`  - ${line}`));
         }
         for (const line of newLines) {
-          log(chalk3.green(`  + ${line}`));
+          log(chalk5.green(`  + ${line}`));
         }
       } else {
         const newLines = edit.newJSDoc.split(`
 `);
         for (const line of newLines) {
-          log(chalk3.green(`  + ${line}`));
+          log(chalk5.green(`  + ${line}`));
         }
       }
       log("");
-      log(chalk3.dim(`  Fixes: ${fixes.map((f) => f.description).join(", ")}`));
+      log(chalk5.dim(`  Fixes: ${fixes.map((f) => f.description).join(", ")}`));
       log("");
     }
   }
   const totalFixes = Array.from(editsByFile.values()).reduce((sum, fileEdits) => sum + fileEdits.reduce((s, e) => s + e.fixes.length, 0), 0);
-  log(chalk3.yellow(`${totalFixes} fix(es) across ${editsByFile.size} file(s) would be applied.`));
-  log(chalk3.gray("Run with --fix to apply these changes."));
+  log(chalk5.yellow(`${totalFixes} fix(es) across ${editsByFile.size} file(s) would be applied.`));
+  log(chalk5.gray("Run with --fix to apply these changes."));
 }
 
 // src/commands/check/output.ts
 import { generateReportFromDocCov } from "@doccov/sdk";
-import chalk5 from "chalk";
 
 // src/reports/changelog-renderer.ts
 function renderChangelog(data, options = {}) {
@@ -1117,18 +2054,18 @@ function getExportKeyword(kind) {
   }
 }
 function formatExportSignature(exp) {
-  const prefix = `export ${getExportKeyword(exp.kind)}`;
+  const prefix2 = `export ${getExportKeyword(exp.kind)}`;
   if (exp.kind === "function" && exp.signatures?.[0]) {
     const sig = exp.signatures[0];
     const params = sig.parameters?.map((p) => `${p.name}${p.required === false ? "?" : ""}`).join(", ") ?? "";
     const ret = extractReturnType(sig.returns?.schema);
-    return `${prefix} ${exp.name}(${params}): ${ret}`;
+    return `${prefix2} ${exp.name}(${params}): ${ret}`;
   }
   if (exp.kind === "type" || exp.kind === "interface") {
-    return `${prefix} ${exp.name}`;
+    return `${prefix2} ${exp.name}`;
   }
   if (exp.kind === "class") {
-    return `${prefix} ${exp.name}`;
+    return `${prefix2} ${exp.name}`;
   }
   return `export ${exp.kind} ${exp.name}`;
 }
@@ -1322,7 +2259,7 @@ function computeStats(openpkg, doccov) {
 import * as fs3 from "node:fs";
 import * as path5 from "node:path";
 import { DEFAULT_REPORT_DIR, getReportPath } from "@doccov/sdk";
-import chalk4 from "chalk";
+import chalk6 from "chalk";
 function writeReport(options) {
   const { format, content, outputPath, cwd = process.cwd(), silent = false } = options;
   const reportPath = outputPath ? path5.resolve(cwd, outputPath) : path5.resolve(cwd, getReportPath(format));
@@ -1333,7 +2270,7 @@ function writeReport(options) {
   fs3.writeFileSync(reportPath, content);
   const relativePath = path5.relative(cwd, reportPath);
   if (!silent) {
-    console.log(chalk4.green(`✓ Wrote ${format} report to ${relativePath}`));
+    console.log(chalk6.green(`✓ Wrote ${format} report to ${relativePath}`));
   }
   return { path: reportPath, format, relativePath };
 }
@@ -1371,6 +2308,7 @@ function displayTextOutput(options, deps) {
     specInfos
   } = options;
   const { log } = deps;
+  const sym = getSymbols(supportsUnicode());
   const totalExportsForDrift = openpkg.exports?.length ?? 0;
   const exportsWithDrift = new Set(driftExports.map((d) => d.name)).size;
   const driftScore = totalExportsForDrift === 0 ? 0 : Math.round(exportsWithDrift / totalExportsForDrift * 100);
@@ -1380,15 +2318,15 @@ function displayTextOutput(options, deps) {
   if (specWarnings.length > 0 || specInfos.length > 0) {
     log("");
     for (const diag of specWarnings) {
-      log(chalk5.yellow(`⚠ ${diag.message}`));
+      log(colors.warning(`${sym.warning} ${diag.message}`));
       if (diag.suggestion) {
-        log(chalk5.gray(`  ${diag.suggestion}`));
+        log(colors.muted(`  ${diag.suggestion}`));
       }
     }
     for (const diag of specInfos) {
-      log(chalk5.cyan(`ℹ ${diag.message}`));
+      log(colors.info(`${sym.info} ${diag.message}`));
       if (diag.suggestion) {
-        log(chalk5.gray(`  ${diag.suggestion}`));
+        log(colors.muted(`  ${diag.suggestion}`));
       }
     }
   }
@@ -1396,47 +2334,47 @@ function displayTextOutput(options, deps) {
   const pkgVersion = openpkg.meta?.version ?? "";
   const totalExports = openpkg.exports?.length ?? 0;
   log("");
-  log(chalk5.bold(`${pkgName}${pkgVersion ? `@${pkgVersion}` : ""}`));
+  log(colors.bold(`${pkgName}${pkgVersion ? `@${pkgVersion}` : ""}`));
   log("");
-  log(`  Exports:    ${totalExports}`);
-  if (coverageFailed) {
-    log(chalk5.red(`  Coverage:   ✗ ${coverageScore}%`) + chalk5.dim(` (min ${minCoverage}%)`));
-  } else {
-    log(chalk5.green(`  Coverage:   ✓ ${coverageScore}%`) + chalk5.dim(` (min ${minCoverage}%)`));
-  }
+  const summaryBuilder = summary({ keyWidth: 10 });
+  summaryBuilder.addKeyValue("Exports", totalExports);
+  summaryBuilder.addKeyValue("Coverage", `${coverageScore}%`, coverageFailed ? "fail" : "pass");
   if (maxDrift !== undefined) {
-    if (driftFailed) {
-      log(chalk5.red(`  Drift:      ✗ ${driftScore}%`) + chalk5.dim(` (max ${maxDrift}%)`));
-    } else {
-      log(chalk5.green(`  Drift:      ✓ ${driftScore}%`) + chalk5.dim(` (max ${maxDrift}%)`));
-    }
+    summaryBuilder.addKeyValue("Drift", `${driftScore}%`, driftFailed ? "fail" : "pass");
   } else {
-    log(`  Drift:      ${driftScore}%`);
+    summaryBuilder.addKeyValue("Drift", `${driftScore}%`);
   }
   if (exampleResult) {
     const typecheckCount = exampleResult.typecheck?.errors.length ?? 0;
     if (typecheckCount > 0) {
-      log(chalk5.yellow(`  Examples:   ${typecheckCount} type error(s)`));
-      for (const err of typecheckErrors.slice(0, 5)) {
-        const loc = `example[${err.error.exampleIndex}]:${err.error.line}:${err.error.column}`;
-        log(chalk5.dim(`              ${err.exportName} ${loc}`));
-        log(chalk5.red(`                ${err.error.message}`));
-      }
-      if (typecheckErrors.length > 5) {
-        log(chalk5.dim(`              ... and ${typecheckErrors.length - 5} more`));
-      }
+      summaryBuilder.addKeyValue("Examples", `${typecheckCount} type error(s)`, "warn");
     } else {
-      log(chalk5.green(`  Examples:   ✓ validated`));
+      summaryBuilder.addKeyValue("Examples", "validated", "pass");
     }
   }
   const hasStaleRefs = staleRefs.length > 0;
   if (hasStaleRefs) {
-    log(chalk5.yellow(`  Docs:       ${staleRefs.length} stale ref(s)`));
+    summaryBuilder.addKeyValue("Docs", `${staleRefs.length} stale ref(s)`, "warn");
+  }
+  summaryBuilder.print();
+  if (hasTypecheckErrors) {
+    log("");
+    for (const err of typecheckErrors.slice(0, 5)) {
+      const loc = `example[${err.error.exampleIndex}]:${err.error.line}:${err.error.column}`;
+      log(colors.muted(`  ${err.exportName} ${loc}`));
+      log(colors.error(`    ${err.error.message}`));
+    }
+    if (typecheckErrors.length > 5) {
+      log(colors.muted(`  ... and ${typecheckErrors.length - 5} more`));
+    }
+  }
+  if (hasStaleRefs) {
+    log("");
     for (const ref of staleRefs.slice(0, 5)) {
-      log(chalk5.dim(`              ${ref.file}:${ref.line} - "${ref.exportName}"`));
+      log(colors.muted(`  ${ref.file}:${ref.line} - "${ref.exportName}"`));
     }
     if (staleRefs.length > 5) {
-      log(chalk5.dim(`              ... and ${staleRefs.length - 5} more`));
+      log(colors.muted(`  ... and ${staleRefs.length - 5} more`));
     }
   }
   log("");
@@ -1447,17 +2385,23 @@ function displayTextOutput(options, deps) {
     if (maxDrift !== undefined) {
       thresholdParts.push(`drift ${driftScore}% ≤ ${maxDrift}%`);
     }
-    log(chalk5.green(`✓ Check passed (${thresholdParts.join(", ")})`));
+    log(colors.success(`${sym.success} Check passed (${thresholdParts.join(", ")})`));
     return true;
   }
+  if (coverageFailed) {
+    log(colors.error(`${sym.error} Coverage ${coverageScore}% below minimum ${minCoverage}%`));
+  }
+  if (driftFailed) {
+    log(colors.error(`${sym.error} Drift ${driftScore}% exceeds maximum ${maxDrift}%`));
+  }
   if (hasTypecheckErrors) {
-    log(chalk5.red(`✗ ${typecheckErrors.length} example type errors`));
+    log(colors.error(`${sym.error} ${typecheckErrors.length} example type errors`));
   }
   if (hasStaleRefs) {
-    log(chalk5.red(`✗ ${staleRefs.length} stale references in docs`));
+    log(colors.error(`${sym.error} ${staleRefs.length} stale references in docs`));
   }
   log("");
-  log(chalk5.dim("Use --format json or --format markdown for detailed reports"));
+  log(colors.muted("Use --format json or --format markdown for detailed reports"));
   return false;
 }
 function handleNonTextOutput(options, deps) {
@@ -1608,18 +2552,9 @@ function registerCheckCommand(program, dependencies = {}) {
     return n;
   }).option("--no-cache", "Bypass spec cache and force regeneration").option("--visibility <tags>", "Filter by release stage: public,beta,alpha,internal (comma-separated)").action(async (entry, options) => {
     try {
+      const spin = spinner("Analyzing...");
       let validations = parseExamplesFlag(options.examples);
       let hasExamples = validations.length > 0;
-      const stepList = [
-        { label: "Resolved target", activeLabel: "Resolving target" },
-        { label: "Loaded config", activeLabel: "Loading config" },
-        { label: "Generated spec", activeLabel: "Generating spec" },
-        { label: "Enriched spec", activeLabel: "Enriching spec" },
-        ...hasExamples ? [{ label: "Validated examples", activeLabel: "Validating examples" }] : [],
-        { label: "Processed results", activeLabel: "Processing results" }
-      ];
-      const steps = new StepProgress(stepList);
-      steps.start();
       const fileSystem = new NodeFileSystem(options.cwd);
       const resolved = await resolveTarget(fileSystem, {
         cwd: options.cwd,
@@ -1627,7 +2562,6 @@ function registerCheckCommand(program, dependencies = {}) {
         entry
       });
       const { targetDir, entryFile } = resolved;
-      steps.next();
       const config = await loadDocCovConfig(targetDir);
       if (!hasExamples && config?.check?.examples) {
         const configExamples = config.check.examples;
@@ -1650,9 +2584,8 @@ function registerCheckCommand(program, dependencies = {}) {
       };
       const resolvedFilters = mergeFilterOptions(config, cliFilters);
       if (resolvedFilters.visibility) {
-        log(chalk6.dim(`Filtering by visibility: ${resolvedFilters.visibility.join(", ")}`));
+        log(chalk7.dim(`Filtering by visibility: ${resolvedFilters.visibility.join(", ")}`));
       }
-      steps.next();
       const resolveExternalTypes = !options.skipResolve;
       const analyzer = createDocCov({
         resolveExternalTypes,
@@ -1663,9 +2596,9 @@ function registerCheckCommand(program, dependencies = {}) {
       const analyzeOptions = resolvedFilters.visibility ? { filters: { visibility: resolvedFilters.visibility } } : {};
       const specResult = await analyzer.analyzeFileWithDiagnostics(entryFile, analyzeOptions);
       if (!specResult) {
+        spin.fail("Analysis failed");
         throw new Error("Failed to analyze documentation coverage.");
       }
-      steps.next();
       const openpkg = specResult.spec;
       const doccov = buildDocCovSpec({
         openpkg,
@@ -1673,7 +2606,6 @@ function registerCheckCommand(program, dependencies = {}) {
         packagePath: targetDir
       });
       const format = options.format ?? "text";
-      steps.next();
       const specWarnings = specResult.diagnostics.filter((d) => d.severity === "warning");
       const specInfos = specResult.diagnostics.filter((d) => d.severity === "info");
       const isPreview = options.preview;
@@ -1689,7 +2621,6 @@ function registerCheckCommand(program, dependencies = {}) {
         exampleResult = validation.result;
         typecheckErrors = validation.typecheckErrors;
         runtimeDrifts = validation.runtimeDrifts;
-        steps.next();
       }
       let docsPatterns = options.docs;
       if (docsPatterns.length === 0 && config?.docs?.include) {
@@ -1709,7 +2640,7 @@ function registerCheckCommand(program, dependencies = {}) {
           driftExports = driftExports.filter((d) => !fixResult.fixedDriftKeys.has(`${d.name}:${d.issue}`));
         }
       }
-      steps.complete("Check complete");
+      spin.success("Analysis complete");
       if (format !== "text") {
         const passed2 = handleNonTextOutput({
           format,
@@ -1747,7 +2678,7 @@ function registerCheckCommand(program, dependencies = {}) {
         process.exit(1);
       }
     } catch (commandError) {
-      error(chalk6.red("Error:"), commandError instanceof Error ? commandError.message : commandError);
+      error(chalk7.red("Error:"), commandError instanceof Error ? commandError.message : commandError);
       process.exit(1);
     }
   });
@@ -1765,7 +2696,7 @@ import {
   parseMarkdownFiles as parseMarkdownFiles2
 } from "@doccov/sdk";
 import { calculateNextVersion, recommendSemverBump } from "@openpkg-ts/spec";
-import chalk7 from "chalk";
+import chalk8 from "chalk";
 import { glob as glob2 } from "glob";
 var defaultDependencies2 = {
   readFileSync: fs4.readFileSync,
@@ -1800,6 +2731,7 @@ function registerDiffCommand(program, dependencies = {}) {
 ` + `Usage: doccov diff <base> <head>
 ` + "   or: doccov diff --base main.json --head feature.json");
       }
+      const spin = spinner("Comparing specs...");
       const baseSpec = loadSpec(baseFile, readFileSync3);
       const headSpec = loadSpec(headFile, readFileSync3);
       const config = await loadDocCovConfig(options.cwd);
@@ -1823,6 +2755,7 @@ function registerDiffCommand(program, dependencies = {}) {
       const minCoverage = resolveThreshold(options.minCoverage, config?.check?.minCoverage);
       const maxDrift = resolveThreshold(options.maxDrift, config?.check?.maxDrift);
       if (options.recommendVersion) {
+        spin.success("Comparison complete");
         const recommendation = recommendSemverBump(diff);
         const currentVersion = headSpec.meta?.version ?? "0.0.0";
         const nextVersion = calculateNextVersion(currentVersion, recommendation.bump);
@@ -1838,9 +2771,9 @@ function registerDiffCommand(program, dependencies = {}) {
           }, null, 2));
         } else {
           log("");
-          log(chalk7.bold("Semver Recommendation"));
+          log(chalk8.bold("Semver Recommendation"));
           log(`  Current version:    ${currentVersion}`);
-          log(`  Recommended:        ${chalk7.cyan(nextVersion)} (${chalk7.yellow(recommendation.bump.toUpperCase())})`);
+          log(`  Recommended:        ${chalk8.cyan(nextVersion)} (${chalk8.yellow(recommendation.bump.toUpperCase())})`);
           log(`  Reason:             ${recommendation.reason}`);
         }
         return;
@@ -1855,6 +2788,7 @@ function registerDiffCommand(program, dependencies = {}) {
         headName,
         ...diff
       };
+      spin.success("Comparison complete");
       switch (format) {
         case "text":
           printSummary(diff, baseName, headName, fromCache, log);
@@ -1869,8 +2803,8 @@ function registerDiffCommand(program, dependencies = {}) {
                 silent: true
               });
             }
-            const cacheNote = fromCache ? chalk7.cyan(" (cached)") : "";
-            log(chalk7.dim(`Report: ${jsonPath}`) + cacheNote);
+            const cacheNote = fromCache ? chalk8.cyan(" (cached)") : "";
+            log(chalk8.dim(`Report: ${jsonPath}`) + cacheNote);
           }
           break;
         case "json": {
@@ -1965,18 +2899,18 @@ function registerDiffCommand(program, dependencies = {}) {
         checks
       });
       if (failures.length > 0) {
-        log(chalk7.red(`
+        log(chalk8.red(`
 ✗ Check failed`));
         for (const f of failures) {
-          log(chalk7.red(`  - ${f}`));
+          log(chalk8.red(`  - ${f}`));
         }
         process.exitCode = 1;
       } else if (options.strict || minCoverage !== undefined || maxDrift !== undefined) {
-        log(chalk7.green(`
+        log(chalk8.green(`
 ✓ All checks passed`));
       }
     } catch (commandError) {
-      error(chalk7.red("Error:"), commandError instanceof Error ? commandError.message : commandError);
+      error(chalk8.red("Error:"), commandError instanceof Error ? commandError.message : commandError);
       process.exitCode = 1;
     }
   });
@@ -2003,7 +2937,7 @@ async function generateDiff(baseSpec, headSpec, options, config, log) {
   if (!docsPatterns || docsPatterns.length === 0) {
     if (config?.docs?.include) {
       docsPatterns = config.docs.include;
-      log(chalk7.gray(`Using docs patterns from config: ${docsPatterns.join(", ")}`));
+      log(chalk8.gray(`Using docs patterns from config: ${docsPatterns.join(", ")}`));
     }
   }
   if (docsPatterns && docsPatterns.length > 0) {
@@ -2026,37 +2960,37 @@ function loadSpec(filePath, readFileSync3) {
 }
 function printSummary(diff, baseName, headName, fromCache, log) {
   log("");
-  const cacheIndicator = fromCache ? chalk7.cyan(" (cached)") : "";
-  log(chalk7.bold(`Comparing: ${baseName} → ${headName}`) + cacheIndicator);
+  const cacheIndicator = fromCache ? chalk8.cyan(" (cached)") : "";
+  log(chalk8.bold(`Comparing: ${baseName} → ${headName}`) + cacheIndicator);
   log("─".repeat(40));
   log("");
-  const coverageColor = diff.coverageDelta > 0 ? chalk7.green : diff.coverageDelta < 0 ? chalk7.red : chalk7.gray;
+  const coverageColor = diff.coverageDelta > 0 ? chalk8.green : diff.coverageDelta < 0 ? chalk8.red : chalk8.gray;
   const coverageSign = diff.coverageDelta > 0 ? "+" : "";
   log(`  Coverage:   ${diff.oldCoverage}% → ${diff.newCoverage}% ${coverageColor(`(${coverageSign}${diff.coverageDelta}%)`)}`);
   const breakingCount = diff.breaking.length;
   const highSeverity = diff.categorizedBreaking?.filter((c) => c.severity === "high").length ?? 0;
   if (breakingCount > 0) {
-    const severityNote = highSeverity > 0 ? chalk7.red(` (${highSeverity} high severity)`) : "";
-    log(`  Breaking:   ${chalk7.red(breakingCount)} changes${severityNote}`);
+    const severityNote = highSeverity > 0 ? chalk8.red(` (${highSeverity} high severity)`) : "";
+    log(`  Breaking:   ${chalk8.red(breakingCount)} changes${severityNote}`);
   } else {
-    log(`  Breaking:   ${chalk7.green("0")} changes`);
+    log(`  Breaking:   ${chalk8.green("0")} changes`);
   }
   const newCount = diff.nonBreaking.length;
   const undocCount = diff.newUndocumented.length;
   if (newCount > 0) {
-    const undocNote = undocCount > 0 ? chalk7.yellow(` (${undocCount} undocumented)`) : "";
-    log(`  New:        ${chalk7.green(newCount)} exports${undocNote}`);
+    const undocNote = undocCount > 0 ? chalk8.yellow(` (${undocCount} undocumented)`) : "";
+    log(`  New:        ${chalk8.green(newCount)} exports${undocNote}`);
   }
   if (diff.driftIntroduced > 0 || diff.driftResolved > 0) {
     const parts = [];
     if (diff.driftIntroduced > 0)
-      parts.push(chalk7.red(`+${diff.driftIntroduced}`));
+      parts.push(chalk8.red(`+${diff.driftIntroduced}`));
     if (diff.driftResolved > 0)
-      parts.push(chalk7.green(`-${diff.driftResolved}`));
+      parts.push(chalk8.green(`-${diff.driftResolved}`));
     log(`  Drift:      ${parts.join(", ")}`);
   }
   const recommendation = recommendSemverBump(diff);
-  const bumpColor = recommendation.bump === "major" ? chalk7.red : recommendation.bump === "minor" ? chalk7.yellow : chalk7.green;
+  const bumpColor = recommendation.bump === "major" ? chalk8.red : recommendation.bump === "minor" ? chalk8.yellow : chalk8.green;
   log(`  Semver:     ${bumpColor(recommendation.bump.toUpperCase())} (${recommendation.reason})`);
   log("");
 }
@@ -2084,8 +3018,8 @@ function validateDiff(diff, headSpec, options) {
     failures.push(`${diff.newUndocumented.length} undocumented export(s)`);
   }
   if (checks.has("docs-impact") && hasDocsImpact(diff)) {
-    const summary = getDocsImpactSummary(diff);
-    failures.push(`${summary.totalIssues} docs issue(s)`);
+    const summary2 = getDocsImpactSummary(diff);
+    failures.push(`${summary2.totalIssues} docs issue(s)`);
   }
   return failures;
 }
@@ -2138,9 +3072,10 @@ function printGitHubAnnotations(diff, log) {
 
 // src/commands/info.ts
 import { buildDocCovSpec as buildDocCovSpec2, DocCov as DocCov2, NodeFileSystem as NodeFileSystem2, resolveTarget as resolveTarget2 } from "@doccov/sdk";
-import chalk8 from "chalk";
+import chalk9 from "chalk";
 function registerInfoCommand(program) {
   program.command("info [entry]").description("Show brief documentation coverage summary").option("--cwd <dir>", "Working directory", process.cwd()).option("--package <name>", "Target package name (for monorepos)").option("--skip-resolve", "Skip external type resolution from node_modules").action(async (entry, options) => {
+    const spin = spinner("Analyzing documentation coverage");
     try {
       const fileSystem = new NodeFileSystem2(options.cwd);
       const resolved = await resolveTarget2(fileSystem, {
@@ -2155,6 +3090,7 @@ function registerInfoCommand(program) {
       });
       const specResult = await analyzer.analyzeFileWithDiagnostics(entryFile);
       if (!specResult) {
+        spin.fail("Failed to analyze");
         throw new Error("Failed to analyze documentation coverage.");
       }
       const openpkg = specResult.spec;
@@ -2164,15 +3100,17 @@ function registerInfoCommand(program) {
         packagePath: targetDir
       });
       const stats = computeStats(openpkg, doccov);
+      spin.success("Analysis complete");
       console.log("");
-      console.log(chalk8.bold(`${stats.packageName}@${stats.version}`));
+      console.log(chalk9.bold(`${stats.packageName}@${stats.version}`));
       console.log("");
-      console.log(`  Exports:    ${chalk8.bold(stats.totalExports.toString())}`);
-      console.log(`  Coverage:   ${chalk8.bold(`${stats.coverageScore}%`)}`);
-      console.log(`  Drift:      ${chalk8.bold(`${stats.driftScore}%`)}`);
+      console.log(`  Exports:    ${chalk9.bold(stats.totalExports.toString())}`);
+      console.log(`  Coverage:   ${chalk9.bold(`${stats.coverageScore}%`)}`);
+      console.log(`  Drift:      ${chalk9.bold(`${stats.driftScore}%`)}`);
       console.log("");
     } catch (err) {
-      console.error(chalk8.red("Error:"), err instanceof Error ? err.message : err);
+      spin.fail("Analysis failed");
+      console.error(chalk9.red("Error:"), err instanceof Error ? err.message : err);
       process.exit(1);
     }
   });
@@ -2181,7 +3119,7 @@ function registerInfoCommand(program) {
 // src/commands/init.ts
 import * as fs5 from "node:fs";
 import * as path7 from "node:path";
-import chalk9 from "chalk";
+import chalk10 from "chalk";
 var defaultDependencies3 = {
   fileExists: fs5.existsSync,
   writeFileSync: fs5.writeFileSync,
@@ -2199,7 +3137,7 @@ function registerInitCommand(program, dependencies = {}) {
     const cwd = path7.resolve(options.cwd);
     const existing = findExistingConfig(cwd, fileExists2);
     if (existing) {
-      error(chalk9.red(`A DocCov config already exists at ${path7.relative(cwd, existing) || "./doccov.config.*"}.`));
+      error(chalk10.red(`A DocCov config already exists at ${path7.relative(cwd, existing) || "./doccov.config.*"}.`));
       process.exitCode = 1;
       return;
     }
@@ -2208,36 +3146,37 @@ function registerInitCommand(program, dependencies = {}) {
     const fileName = `doccov.config.${targetFormat}`;
     const outputPath = path7.join(cwd, fileName);
     if (fileExists2(outputPath)) {
-      error(chalk9.red(`Cannot create ${fileName}; file already exists.`));
+      error(chalk10.red(`Cannot create ${fileName}; file already exists.`));
       process.exitCode = 1;
       return;
     }
+    const sym = getSymbols(supportsUnicode());
     const template = buildConfigTemplate();
     writeFileSync3(outputPath, template, { encoding: "utf8" });
-    log(chalk9.green(`✓ Created ${fileName}`));
+    log(colors.success(`${sym.success} Created ${fileName}`));
     if (!options.skipAction) {
       const workflowDir = path7.join(cwd, ".github", "workflows");
       const workflowPath = path7.join(workflowDir, "doccov.yml");
       if (!fileExists2(workflowPath)) {
         mkdirSync3(workflowDir, { recursive: true });
         writeFileSync3(workflowPath, buildWorkflowTemplate(), { encoding: "utf8" });
-        log(chalk9.green(`✓ Created .github/workflows/doccov.yml`));
+        log(colors.success(`${sym.success} Created .github/workflows/doccov.yml`));
       } else {
-        log(chalk9.yellow(`  Skipped .github/workflows/doccov.yml (already exists)`));
+        log(colors.warning(`${sym.bullet} Skipped .github/workflows/doccov.yml (already exists)`));
       }
     }
     const repoInfo = detectRepoInfo(cwd, fileExists2, readFileSync4);
     log("");
-    log(chalk9.bold("Add this badge to your README:"));
+    log(chalk10.bold("Add this badge to your README:"));
     log("");
     if (repoInfo) {
-      log(chalk9.cyan(`[![DocCov](https://doccov.dev/badge/${repoInfo.owner}/${repoInfo.repo})](https://doccov.dev/${repoInfo.owner}/${repoInfo.repo})`));
+      log(chalk10.cyan(`[![DocCov](https://doccov.dev/badge/${repoInfo.owner}/${repoInfo.repo})](https://doccov.dev/${repoInfo.owner}/${repoInfo.repo})`));
     } else {
-      log(chalk9.cyan(`[![DocCov](https://doccov.dev/badge/OWNER/REPO)](https://doccov.dev/OWNER/REPO)`));
-      log(chalk9.dim("  Replace OWNER/REPO with your GitHub repo"));
+      log(chalk10.cyan(`[![DocCov](https://doccov.dev/badge/OWNER/REPO)](https://doccov.dev/OWNER/REPO)`));
+      log(chalk10.dim("  Replace OWNER/REPO with your GitHub repo"));
     }
     log("");
-    log(chalk9.dim("Run `doccov check` to verify your documentation coverage"));
+    log(chalk10.dim("Run `doccov check` to verify your documentation coverage"));
   });
 }
 var findExistingConfig = (cwd, fileExists2) => {
@@ -2373,9 +3312,9 @@ import {
 } from "@doccov/sdk";
 import { validateDocCovSpec } from "@doccov/spec";
 import { normalize, validateSpec } from "@openpkg-ts/spec";
-import chalk10 from "chalk";
+import chalk11 from "chalk";
 // package.json
-var version = "0.25.6";
+var version = "0.25.8";
 
 // src/commands/spec.ts
 var defaultDependencies4 = {
@@ -2387,12 +3326,12 @@ var defaultDependencies4 = {
 function getArrayLength(value) {
   return Array.isArray(value) ? value.length : 0;
 }
-function formatDiagnosticOutput(prefix, diagnostic, baseDir) {
+function formatDiagnosticOutput(prefix2, diagnostic, baseDir) {
   const location = diagnostic.location;
   const relativePath = location?.file ? path8.relative(baseDir, location.file) || location.file : undefined;
-  const locationText = location && relativePath ? chalk10.gray(`${relativePath}:${location.line ?? 1}:${location.column ?? 1}`) : null;
+  const locationText = location && relativePath ? chalk11.gray(`${relativePath}:${location.line ?? 1}:${location.column ?? 1}`) : null;
   const locationPrefix = locationText ? `${locationText} ` : "";
-  return `${prefix} ${locationPrefix}${diagnostic.message}`;
+  return `${prefix2} ${locationPrefix}${diagnostic.message}`;
 }
 function registerSpecCommand(program, dependencies = {}) {
   const { createDocCov, writeFileSync: writeFileSync4, log, error } = {
@@ -2401,18 +3340,7 @@ function registerSpecCommand(program, dependencies = {}) {
   };
   program.command("spec [entry]").description("Generate OpenPkg + DocCov specifications").option("--cwd <dir>", "Working directory", process.cwd()).option("-p, --package <name>", "Target package name (for monorepos)").option("-o, --output <dir>", "Output directory", ".doccov").option("-f, --format <format>", "Output format: json (default) or api-surface", "json").option("--openpkg-only", "Only generate openpkg.json (skip coverage analysis)").option("--include <patterns>", "Include exports matching pattern (comma-separated)").option("--exclude <patterns>", "Exclude exports matching pattern (comma-separated)").option("--visibility <tags>", "Filter by release stage: public,beta,alpha,internal (comma-separated)").option("--skip-resolve", "Skip external type resolution from node_modules").option("--max-type-depth <n>", "Maximum depth for type conversion", "20").option("--runtime", "Enable Standard Schema runtime extraction (richer output for Zod, Valibot, etc.)").option("--no-cache", "Bypass spec cache and force regeneration").option("--show-diagnostics", "Show TypeScript compiler diagnostics").option("--verbose", "Show detailed generation metadata").action(async (entry, options) => {
     try {
-      const stepsList = [
-        { label: "Resolved target", activeLabel: "Resolving target" },
-        { label: "Loaded config", activeLabel: "Loading config" },
-        { label: "Generated spec", activeLabel: "Generating spec" },
-        { label: "Validated schema", activeLabel: "Validating schema" }
-      ];
-      if (!options.openpkgOnly) {
-        stepsList.push({ label: "Built coverage analysis", activeLabel: "Building coverage" });
-      }
-      stepsList.push({ label: "Wrote output", activeLabel: "Writing output" });
-      const steps = new StepProgress(stepsList);
-      steps.start();
+      const spin = spinner("Generating spec...");
       const fileSystem = new NodeFileSystem3(options.cwd);
       const resolved = await resolveTarget3(fileSystem, {
         cwd: options.cwd,
@@ -2420,15 +3348,14 @@ function registerSpecCommand(program, dependencies = {}) {
         entry
       });
       const { targetDir, entryFile, packageInfo, entryPointInfo } = resolved;
-      steps.next();
       let config = null;
       try {
         config = await loadDocCovConfig(targetDir);
       } catch (configError) {
-        error(chalk10.red("Failed to load DocCov config:"), configError instanceof Error ? configError.message : configError);
+        spin.fail("Failed to load config");
+        error(chalk11.red("Failed to load DocCov config:"), configError instanceof Error ? configError.message : configError);
         process.exit(1);
       }
-      steps.next();
       const cliFilters = {
         include: parseListFlag(options.include),
         exclude: parseListFlag(options.exclude),
@@ -2463,19 +3390,19 @@ function registerSpecCommand(program, dependencies = {}) {
       } : { generationInput };
       const result = await doccov.analyzeFileWithDiagnostics(entryFile, analyzeOptions);
       if (!result) {
+        spin.fail("Generation failed");
         throw new Error("Failed to produce an OpenPkg spec.");
       }
-      steps.next();
       const normalized = normalize(result.spec);
       const validation = validateSpec(normalized);
       if (!validation.ok) {
-        error(chalk10.red("Spec failed schema validation"));
+        spin.fail("Validation failed");
+        error(chalk11.red("Spec failed schema validation"));
         for (const err of validation.errors) {
-          error(chalk10.red(`schema: ${err.instancePath || "/"} ${err.message}`));
+          error(chalk11.red(`schema: ${err.instancePath || "/"} ${err.message}`));
         }
         process.exit(1);
       }
-      steps.next();
       let doccovSpec = null;
       if (!options.openpkgOnly) {
         doccovSpec = buildDocCovSpec3({
@@ -2485,13 +3412,13 @@ function registerSpecCommand(program, dependencies = {}) {
         });
         const doccovValidation = validateDocCovSpec(doccovSpec);
         if (!doccovValidation.ok) {
-          error(chalk10.red("DocCov spec failed schema validation"));
+          spin.fail("DocCov validation failed");
+          error(chalk11.red("DocCov spec failed schema validation"));
           for (const err of doccovValidation.errors) {
-            error(chalk10.red(`doccov: ${err.instancePath || "/"} ${err.message}`));
+            error(chalk11.red(`doccov: ${err.instancePath || "/"} ${err.message}`));
           }
           process.exit(1);
         }
-        steps.next();
       }
       const format = options.format ?? "json";
       const outputDir = path8.resolve(options.cwd, options.output);
@@ -2500,20 +3427,20 @@ function registerSpecCommand(program, dependencies = {}) {
         const apiSurface = renderApiSurface(normalized);
         const apiSurfacePath = path8.join(outputDir, "api-surface.txt");
         writeFileSync4(apiSurfacePath, apiSurface);
-        steps.complete(`Generated ${options.output}/ (API surface)`);
+        spin.success(`Generated ${options.output}/ (API surface)`);
       } else {
         const openpkgPath = path8.join(outputDir, "openpkg.json");
         writeFileSync4(openpkgPath, JSON.stringify(normalized, null, 2));
         if (doccovSpec) {
           const doccovPath = path8.join(outputDir, "doccov.json");
           writeFileSync4(doccovPath, JSON.stringify(doccovSpec, null, 2));
-          steps.complete(`Generated ${options.output}/`);
-          log(chalk10.gray(`  openpkg.json: ${getArrayLength(normalized.exports)} exports`));
-          log(chalk10.gray(`  doccov.json:  ${doccovSpec.summary.score}% coverage, ${doccovSpec.summary.drift.total} drift issues`));
+          spin.success(`Generated ${options.output}/`);
+          log(chalk11.gray(`  openpkg.json: ${getArrayLength(normalized.exports)} exports`));
+          log(chalk11.gray(`  doccov.json:  ${doccovSpec.summary.score}% coverage, ${doccovSpec.summary.drift.total} drift issues`));
         } else {
-          steps.complete(`Generated ${options.output}/openpkg.json`);
-          log(chalk10.gray(`  ${getArrayLength(normalized.exports)} exports`));
-          log(chalk10.gray(`  ${getArrayLength(normalized.types)} types`));
+          spin.success(`Generated ${options.output}/openpkg.json`);
+          log(chalk11.gray(`  ${getArrayLength(normalized.exports)} exports`));
+          log(chalk11.gray(`  ${getArrayLength(normalized.types)} types`));
         }
       }
       const schemaExtraction = normalized.generation?.analysis?.schemaExtraction;
@@ -2521,63 +3448,63 @@ function registerSpecCommand(program, dependencies = {}) {
         const pm = await detectPackageManager(fileSystem);
         const buildCmd = pm.name === "npm" ? "npm run build" : `${pm.name} run build`;
         log("");
-        log(chalk10.yellow("⚠ Runtime extraction requested but no schemas extracted."));
-        log(chalk10.yellow(`  Ensure project is built (${buildCmd}) and dist/ exists.`));
+        log(chalk11.yellow("⚠ Runtime extraction requested but no schemas extracted."));
+        log(chalk11.yellow(`  Ensure project is built (${buildCmd}) and dist/ exists.`));
       }
       if (options.verbose && normalized.generation) {
         const gen = normalized.generation;
         log("");
-        log(chalk10.bold("Generation Info"));
-        log(chalk10.gray(`  Timestamp:        ${gen.timestamp}`));
-        log(chalk10.gray(`  Generator:        ${gen.generator.name}@${gen.generator.version}`));
-        log(chalk10.gray(`  Entry point:      ${gen.analysis.entryPoint}`));
-        log(chalk10.gray(`  Detected via:     ${gen.analysis.entryPointSource}`));
-        log(chalk10.gray(`  Declaration only: ${gen.analysis.isDeclarationOnly ? "yes" : "no"}`));
-        log(chalk10.gray(`  External types:   ${gen.analysis.resolvedExternalTypes ? "resolved" : "skipped"}`));
+        log(chalk11.bold("Generation Info"));
+        log(chalk11.gray(`  Timestamp:        ${gen.timestamp}`));
+        log(chalk11.gray(`  Generator:        ${gen.generator.name}@${gen.generator.version}`));
+        log(chalk11.gray(`  Entry point:      ${gen.analysis.entryPoint}`));
+        log(chalk11.gray(`  Detected via:     ${gen.analysis.entryPointSource}`));
+        log(chalk11.gray(`  Declaration only: ${gen.analysis.isDeclarationOnly ? "yes" : "no"}`));
+        log(chalk11.gray(`  External types:   ${gen.analysis.resolvedExternalTypes ? "resolved" : "skipped"}`));
         if (gen.analysis.maxTypeDepth) {
-          log(chalk10.gray(`  Max type depth:   ${gen.analysis.maxTypeDepth}`));
+          log(chalk11.gray(`  Max type depth:   ${gen.analysis.maxTypeDepth}`));
         }
         if (gen.analysis.schemaExtraction) {
           const se = gen.analysis.schemaExtraction;
-          log(chalk10.gray(`  Schema extraction: ${se.method}`));
+          log(chalk11.gray(`  Schema extraction: ${se.method}`));
           if (se.runtimeCount) {
-            log(chalk10.gray(`  Runtime schemas:   ${se.runtimeCount} (${se.vendors?.join(", ")})`));
+            log(chalk11.gray(`  Runtime schemas:   ${se.runtimeCount} (${se.vendors?.join(", ")})`));
           }
         }
         log("");
-        log(chalk10.bold("Environment"));
-        log(chalk10.gray(`  node_modules:     ${gen.environment.hasNodeModules ? "found" : "not found"}`));
+        log(chalk11.bold("Environment"));
+        log(chalk11.gray(`  node_modules:     ${gen.environment.hasNodeModules ? "found" : "not found"}`));
         if (gen.environment.packageManager) {
-          log(chalk10.gray(`  Package manager:  ${gen.environment.packageManager}`));
+          log(chalk11.gray(`  Package manager:  ${gen.environment.packageManager}`));
         }
         if (gen.environment.isMonorepo) {
-          log(chalk10.gray(`  Monorepo:         yes`));
+          log(chalk11.gray(`  Monorepo:         yes`));
         }
         if (gen.environment.targetPackage) {
-          log(chalk10.gray(`  Target package:   ${gen.environment.targetPackage}`));
+          log(chalk11.gray(`  Target package:   ${gen.environment.targetPackage}`));
         }
         if (gen.issues.length > 0) {
           log("");
-          log(chalk10.bold("Issues"));
+          log(chalk11.bold("Issues"));
           for (const issue of gen.issues) {
-            const prefix = issue.severity === "error" ? chalk10.red(">") : issue.severity === "warning" ? chalk10.yellow(">") : chalk10.cyan(">");
-            log(`${prefix} [${issue.code}] ${issue.message}`);
+            const prefix2 = issue.severity === "error" ? chalk11.red(">") : issue.severity === "warning" ? chalk11.yellow(">") : chalk11.cyan(">");
+            log(`${prefix2} [${issue.code}] ${issue.message}`);
             if (issue.suggestion) {
-              log(chalk10.gray(`    ${issue.suggestion}`));
+              log(chalk11.gray(`    ${issue.suggestion}`));
             }
           }
         }
       }
       if (options.showDiagnostics && result.diagnostics.length > 0) {
         log("");
-        log(chalk10.bold("Diagnostics"));
+        log(chalk11.bold("Diagnostics"));
         for (const diagnostic of result.diagnostics) {
-          const prefix = diagnostic.severity === "error" ? chalk10.red(">") : diagnostic.severity === "warning" ? chalk10.yellow(">") : chalk10.cyan(">");
-          log(formatDiagnosticOutput(prefix, diagnostic, targetDir));
+          const prefix2 = diagnostic.severity === "error" ? chalk11.red(">") : diagnostic.severity === "warning" ? chalk11.yellow(">") : chalk11.cyan(">");
+          log(formatDiagnosticOutput(prefix2, diagnostic, targetDir));
         }
       }
     } catch (commandError) {
-      error(chalk10.red("Error:"), commandError instanceof Error ? commandError.message : commandError);
+      error(chalk11.red("Error:"), commandError instanceof Error ? commandError.message : commandError);
       process.exit(1);
     }
   });
@@ -2597,7 +3524,7 @@ import {
   renderSparkline,
   saveSnapshot
 } from "@doccov/sdk";
-import chalk11 from "chalk";
+import chalk12 from "chalk";
 function formatDate(timestamp) {
   const date = new Date(timestamp);
   return date.toLocaleDateString("en-US", {
@@ -2610,19 +3537,19 @@ function formatDate(timestamp) {
 }
 function getColorForScore(score) {
   if (score >= 90)
-    return chalk11.green;
+    return chalk12.green;
   if (score >= 70)
-    return chalk11.yellow;
+    return chalk12.yellow;
   if (score >= 50)
-    return chalk11.hex("#FFA500");
-  return chalk11.red;
+    return chalk12.hex("#FFA500");
+  return chalk12.red;
 }
 function formatSnapshot(snapshot) {
   const color = getColorForScore(snapshot.coverageScore);
   const date = formatDate(snapshot.timestamp);
   const version2 = snapshot.version ? ` v${snapshot.version}` : "";
-  const commit = snapshot.commit ? chalk11.gray(` (${snapshot.commit.slice(0, 7)})`) : "";
-  return `${chalk11.gray(date)}  ${color(`${snapshot.coverageScore}%`)}  ${snapshot.documentedExports}/${snapshot.totalExports} exports${version2}${commit}`;
+  const commit = snapshot.commit ? chalk12.gray(` (${snapshot.commit.slice(0, 7)})`) : "";
+  return `${chalk12.gray(date)}  ${color(`${snapshot.coverageScore}%`)}  ${snapshot.documentedExports}/${snapshot.totalExports} exports${version2}${commit}`;
 }
 function formatWeekDate(timestamp) {
   const date = new Date(timestamp);
@@ -2630,10 +3557,10 @@ function formatWeekDate(timestamp) {
 }
 function formatVelocity(velocity) {
   if (velocity > 0)
-    return chalk11.green(`+${velocity}%/day`);
+    return chalk12.green(`+${velocity}%/day`);
   if (velocity < 0)
-    return chalk11.red(`${velocity}%/day`);
-  return chalk11.gray("0%/day");
+    return chalk12.red(`${velocity}%/day`);
+  return chalk12.gray("0%/day");
 }
 function registerTrendsCommand(program) {
   program.command("trends").description("Show coverage trends over time").option("--cwd <dir>", "Working directory", process.cwd()).option("-n, --limit <count>", "Number of snapshots to show", "10").option("--prune <count>", "Prune history to keep only N snapshots").option("--record", "Record current coverage to history").option("--json", "Output as JSON").option("--extended", "Show extended trend analysis (velocity, projections)").option("--tier <tier>", "Retention tier: free (7d), team (30d), pro (90d)", "pro").option("--weekly", "Show weekly summary breakdown").action(async (options) => {
@@ -2643,42 +3570,44 @@ function registerTrendsCommand(program) {
       const keepCount = parseInt(options.prune, 10);
       if (!Number.isNaN(keepCount)) {
         const deleted = pruneHistory(cwd, keepCount);
-        console.log(chalk11.green(`Pruned ${deleted} old snapshots, kept ${keepCount} most recent`));
+        console.log(chalk12.green(`Pruned ${deleted} old snapshots, kept ${keepCount} most recent`));
       } else {
         const deleted = pruneByTier(cwd, tier);
-        console.log(chalk11.green(`Pruned ${deleted} snapshots older than ${RETENTION_DAYS[tier]} days`));
+        console.log(chalk12.green(`Pruned ${deleted} snapshots older than ${RETENTION_DAYS[tier]} days`));
       }
       return;
     }
     if (options.record) {
       const specPath = path9.resolve(cwd, "openpkg.json");
       if (!fs7.existsSync(specPath)) {
-        console.error(chalk11.red("No openpkg.json found. Run `doccov spec` first to generate a spec."));
+        console.error(chalk12.red("No openpkg.json found. Run `doccov spec` first to generate a spec."));
         process.exit(1);
       }
+      const spin = spinner("Recording coverage snapshot");
       try {
         const specContent = fs7.readFileSync(specPath, "utf-8");
         const spec = JSON.parse(specContent);
         const trend = getTrend(spec, cwd);
         saveSnapshot(trend.current, cwd);
-        console.log(chalk11.green("Recorded coverage snapshot:"));
+        spin.success("Recorded coverage snapshot");
         console.log(formatSnapshot(trend.current));
         if (trend.delta !== undefined) {
           const deltaStr = formatDelta2(trend.delta);
-          const deltaColor = trend.delta > 0 ? chalk11.green : trend.delta < 0 ? chalk11.red : chalk11.gray;
-          console.log(chalk11.gray("Change from previous:"), deltaColor(deltaStr));
+          const deltaColor = trend.delta > 0 ? chalk12.green : trend.delta < 0 ? chalk12.red : chalk12.gray;
+          console.log(chalk12.gray("Change from previous:"), deltaColor(deltaStr));
         }
         return;
       } catch (error) {
-        console.error(chalk11.red("Failed to read openpkg.json:"), error instanceof Error ? error.message : error);
+        spin.fail("Failed to record snapshot");
+        console.error(chalk12.red("Failed to read openpkg.json:"), error instanceof Error ? error.message : error);
         process.exit(1);
       }
     }
     const snapshots = loadSnapshots(cwd);
     const limit = parseInt(options.limit ?? "10", 10);
     if (snapshots.length === 0) {
-      console.log(chalk11.yellow("No coverage history found."));
-      console.log(chalk11.gray("Run `doccov trends --record` to save the current coverage."));
+      console.log(chalk12.yellow("No coverage history found."));
+      console.log(chalk12.gray("Run `doccov trends --record` to save the current coverage."));
       return;
     }
     if (options.json) {
@@ -2693,17 +3622,17 @@ function registerTrendsCommand(program) {
     }
     const sparklineData = snapshots.slice(0, 10).map((s) => s.coverageScore).reverse();
     const sparkline = renderSparkline(sparklineData);
-    console.log(chalk11.bold("Coverage Trends"));
-    console.log(chalk11.gray(`Package: ${snapshots[0].package}`));
-    console.log(chalk11.gray(`Sparkline: ${sparkline}`));
+    console.log(chalk12.bold("Coverage Trends"));
+    console.log(chalk12.gray(`Package: ${snapshots[0].package}`));
+    console.log(chalk12.gray(`Sparkline: ${sparkline}`));
     console.log("");
     if (snapshots.length >= 2) {
       const oldest = snapshots[snapshots.length - 1];
       const newest = snapshots[0];
       const overallDelta = newest.coverageScore - oldest.coverageScore;
       const deltaStr = formatDelta2(overallDelta);
-      const deltaColor = overallDelta > 0 ? chalk11.green : overallDelta < 0 ? chalk11.red : chalk11.gray;
-      console.log(chalk11.gray("Overall trend:"), deltaColor(deltaStr), chalk11.gray(`(${snapshots.length} snapshots)`));
+      const deltaColor = overallDelta > 0 ? chalk12.green : overallDelta < 0 ? chalk12.red : chalk12.gray;
+      console.log(chalk12.gray("Overall trend:"), deltaColor(deltaStr), chalk12.gray(`(${snapshots.length} snapshots)`));
       console.log("");
     }
     if (options.extended) {
@@ -2713,8 +3642,8 @@ function registerTrendsCommand(program) {
           const specContent = fs7.readFileSync(specPath, "utf-8");
           const spec = JSON.parse(specContent);
           const extended = getExtendedTrend(spec, cwd, { tier });
-          console.log(chalk11.bold("Extended Analysis"));
-          console.log(chalk11.gray(`Tier: ${tier} (${RETENTION_DAYS[tier]}-day retention)`));
+          console.log(chalk12.bold("Extended Analysis"));
+          console.log(chalk12.gray(`Tier: ${tier} (${RETENTION_DAYS[tier]}-day retention)`));
           console.log("");
           console.log("  Velocity:");
           console.log(`    7-day:   ${formatVelocity(extended.velocity7d)}`);
@@ -2723,47 +3652,47 @@ function registerTrendsCommand(program) {
             console.log(`    90-day:  ${formatVelocity(extended.velocity90d)}`);
           }
           console.log("");
-          const projColor = extended.projected30d >= extended.trend.current.coverageScore ? chalk11.green : chalk11.red;
+          const projColor = extended.projected30d >= extended.trend.current.coverageScore ? chalk12.green : chalk12.red;
           console.log(`  Projected (30d): ${projColor(`${extended.projected30d}%`)}`);
-          console.log(`  All-time high:   ${chalk11.green(`${extended.allTimeHigh}%`)}`);
-          console.log(`  All-time low:    ${chalk11.red(`${extended.allTimeLow}%`)}`);
+          console.log(`  All-time high:   ${chalk12.green(`${extended.allTimeHigh}%`)}`);
+          console.log(`  All-time low:    ${chalk12.red(`${extended.allTimeLow}%`)}`);
           if (extended.dataRange) {
             const startDate = formatWeekDate(extended.dataRange.start);
             const endDate = formatWeekDate(extended.dataRange.end);
-            console.log(chalk11.gray(`  Data range: ${startDate} - ${endDate}`));
+            console.log(chalk12.gray(`  Data range: ${startDate} - ${endDate}`));
           }
           console.log("");
           if (options.weekly && extended.weeklySummaries.length > 0) {
-            console.log(chalk11.bold("Weekly Summary"));
+            console.log(chalk12.bold("Weekly Summary"));
             const weekLimit = Math.min(extended.weeklySummaries.length, 8);
             for (let i = 0;i < weekLimit; i++) {
               const week = extended.weeklySummaries[i];
               const weekStart = formatWeekDate(week.weekStart);
               const weekEnd = formatWeekDate(week.weekEnd);
-              const deltaColor = week.delta > 0 ? chalk11.green : week.delta < 0 ? chalk11.red : chalk11.gray;
+              const deltaColor = week.delta > 0 ? chalk12.green : week.delta < 0 ? chalk12.red : chalk12.gray;
               const deltaStr = week.delta > 0 ? `+${week.delta}%` : `${week.delta}%`;
               console.log(`  ${weekStart} - ${weekEnd}:  ${week.avgCoverage}% avg  ${deltaColor(deltaStr)}  (${week.snapshotCount} snapshots)`);
             }
             if (extended.weeklySummaries.length > weekLimit) {
-              console.log(chalk11.gray(`  ... and ${extended.weeklySummaries.length - weekLimit} more weeks`));
+              console.log(chalk12.gray(`  ... and ${extended.weeklySummaries.length - weekLimit} more weeks`));
             }
             console.log("");
           }
         } catch {
-          console.log(chalk11.yellow("Could not load openpkg.json for extended analysis"));
+          console.log(chalk12.yellow("Could not load openpkg.json for extended analysis"));
           console.log("");
         }
       }
     }
-    console.log(chalk11.bold("History"));
+    console.log(chalk12.bold("History"));
     const displaySnapshots = snapshots.slice(0, limit);
     for (let i = 0;i < displaySnapshots.length; i++) {
       const snapshot = displaySnapshots[i];
-      const prefix = i === 0 ? chalk11.cyan("→") : " ";
-      console.log(`${prefix} ${formatSnapshot(snapshot)}`);
+      const prefix2 = i === 0 ? chalk12.cyan("→") : " ";
+      console.log(`${prefix2} ${formatSnapshot(snapshot)}`);
     }
     if (snapshots.length > limit) {
-      console.log(chalk11.gray(`  ... and ${snapshots.length - limit} more`));
+      console.log(chalk12.gray(`  ... and ${snapshots.length - limit} more`));
     }
   });
 }