@prismatic-io/lux 0.0.1

package/src/cli/render/reporter.ts

@@ -0,0 +1,643 @@
+import {
+  type AssertionProgress,
+  addUsage,
+  createToolOutcomeAccumulator,
+  emptyRunUsage,
+  type GradingAssertionEntry,
+  harnessUsage,
+  isUsageEmpty,
+  type LifecycleStage,
+  type PhaseDurations,
+  type RunEvent,
+  type RunUsage,
+  sumUsage,
+  type TokenUsage,
+  type ToolOutcomeAccumulator,
+  TURN_GLYPHS,
+  type TurnUsage,
+  TurnUsageSchema,
+  totalTokens,
+} from "../../core/index.js";
+import type { CaseObserver, SuiteCaseResult, SuiteObserver } from "../../orchestrator/index.js";
+import {
+  formatAlignedUsage,
+  formatDuration,
+  formatScore,
+  formatTally,
+  formatTokens,
+  formatUsage,
+} from "./format.js";
+import {
+  LiveRegion,
+  makeTheme,
+  shouldColor,
+  spinnerFrame,
+  type Theme,
+  truncate,
+  visibleWidth,
+} from "./tty.js";
+
+type Phase = "loading" | "preparing" | "starting" | "agent" | "collecting" | "grading" | "done";
+
+const PHASE_OF: Record<LifecycleStage, Phase> = {
+  load: "loading",
+  "prepare-answerer": "preparing",
+  "run-loop": "starting",
+  "start-driver": "agent",
+  "collect-start": "collecting",
+  "collect-end": "collecting",
+  "grade-start": "grading",
+  "grade-end": "grading",
+  close: "done",
+};
+
+/**
+ * `errored` never produced a run; `incomplete` produced one that did not exit
+ * cleanly (aborted, idle-timeout, max-interactions). The two are kept apart
+ * from `ungraded` — a case that simply declares no assertions — because a
+ * truncated run must never read like a clean one.
+ */
+type CaseStatus = "running" | "passed" | "failed" | "ungraded" | "incomplete" | "errored";
+
+type CaseView = {
+  caseId: string;
+  status: CaseStatus;
+  startedAt: number;
+  endedAt: number | null;
+  phase: Phase;
+  toolReportedCalls: number;
+  toolCalls: number;
+  toolSucceeded: number;
+  toolFailed: number;
+  toolUnresolved: number;
+  toolUnmatchedResults: number;
+  toolMalformed: number;
+  toolOutcomes: ToolOutcomeAccumulator;
+  interrupts: number;
+  assertionTotal: number;
+  currentAssertion: string | null;
+  assertions: GradingAssertionEntry[];
+  usage: RunUsage;
+  /** Per-API-call agent usage, in order — the split behind `usage.agent`. */
+  agentTurns: TurnUsage[];
+  phaseDurationMs: PhaseDurations | null;
+  runDir: string | null;
+  errorMessage: string | null;
+};
+
+type TreeNode = { head: string; body?: string[]; children?: TreeNode[] };
+
+export type ReporterOptions = {
+  verbose?: boolean;
+  stdout?: NodeJS.WriteStream;
+  env?: NodeJS.ProcessEnv;
+  /** Overrides TTY detection. Tests pass false; `--no-live` would too. */
+  live?: boolean;
+  /** Repaint cadence for live mode; tests shrink it to avoid real sleeps. */
+  frameIntervalMs?: number;
+  now?: () => number;
+};
+
+const NAME_MIN = 14;
+const NAME_MAX = 44;
+const ASSERTION_NAME_MAX = 56;
+const TURN_LABEL_WIDTH = 44;
+const DURATION_COL = 7;
+const TALLY_COL = 6;
+// One wider than "Assertions", the longest label, so the value never abuts it.
+const LABEL_COL = 11;
+
+const statusMark = (status: CaseStatus, theme: Theme): string => {
+  if (status === "passed") return theme.green("✓");
+  if (status === "failed") return theme.red("✗");
+  if (status === "errored" || status === "incomplete") return theme.red("!");
+  if (status === "ungraded") return theme.dim("·");
+  return theme.cyan("·");
+};
+
+const assertionTally = (view: CaseView): string => {
+  const passed = view.assertions.filter((a) => a.passed).length;
+  return view.assertions.length === 0 ? "—" : `${passed}/${view.assertions.length}`;
+};
+
+/**
+ * A crash message on the case's own line, kept short enough to scan. Module
+ * resolution errors in particular run to several hundred characters; the
+ * untruncated text still lands in the case's tree below.
+ */
+const INLINE_ERROR_MAX = 58;
+const inlineError = (message: string): string => {
+  const firstLine = message.split("\n")[0] ?? message;
+  return firstLine.length > INLINE_ERROR_MAX
+    ? `${firstLine.slice(0, INLINE_ERROR_MAX - 1)}…`
+    : firstLine;
+};
+
+/**
+ * Pad to exactly `width`, clipping when the name is longer — a `rubric` names
+ * itself after its whole criteria string, which would otherwise shove every
+ * column to its right off the screen.
+ */
+const cell = (text: string, width: number): string => {
+  // Measure visible cells (like truncate does), not code units — an emoji or
+  // CJK name would otherwise misalign every column after it. A clip that stops
+  // short of a wide glyph lands under `width`, so the result is padded too.
+  const clipped = visibleWidth(text) > width ? truncate(text, width) : text;
+  return clipped + " ".repeat(Math.max(0, width - visibleWidth(clipped)));
+};
+
+/**
+ * Why a failed assertion failed, in one clause. Two traps here: `threshold` is
+ * 0 whenever the case author left it unset — the assertion then applied its own
+ * internal bar, so "55% < 0%" would be a lie — and a deterministic assertion
+ * scores a flat 0, where "score 0%" only restates the ✗. Both stay silent.
+ */
+const scoreNote = (entry: GradingAssertionEntry): string => {
+  if (entry.errorMessage) return entry.errorMessage;
+  if (entry.passed) return "";
+  const score = formatScore(entry.score);
+  if (entry.threshold > 0) return `score ${score} < ${formatScore(entry.threshold)}`;
+  return entry.score > 0 ? `score ${score}` : "";
+};
+
+export class ConsoleReporter implements SuiteObserver {
+  private readonly region: LiveRegion;
+  private readonly theme: Theme;
+  private readonly verbose: boolean;
+  private readonly now: () => number;
+
+  private cases: CaseView[] = [];
+  private nameWidth = NAME_MIN;
+  private startedAt = 0;
+  private total = 0;
+  private loop = 1;
+  private runsRoot = "";
+  private suiteDir = "";
+
+  setSuiteDir(suiteDir: string): void {
+    this.suiteDir = suiteDir;
+  }
+
+  constructor(options: ReporterOptions = {}) {
+    const stdout = options.stdout ?? process.stdout;
+    const env = options.env ?? process.env;
+    this.region = new LiveRegion({
+      stdout,
+      live: options.live,
+      frameIntervalMs: options.frameIntervalMs,
+    });
+    this.theme = makeTheme(shouldColor(stdout, env));
+    this.verbose = options.verbose ?? false;
+    this.now = options.now ?? Date.now;
+  }
+
+  begin(info: {
+    title: string;
+    caseIds: string[];
+    runsRoot: string;
+    /** How many times each matched eval runs (`--loop`); 1 for a single run. */
+    loop?: number | undefined;
+  }): void {
+    this.startedAt = this.now();
+    this.total = info.caseIds.length;
+    this.loop = info.loop && info.loop > 0 ? info.loop : 1;
+    this.runsRoot = info.runsRoot;
+    this.nameWidth = Math.min(
+      NAME_MAX,
+      Math.max(NAME_MIN, ...info.caseIds.map((id) => visibleWidth(id))),
+    );
+
+    const badge = this.theme.inverse(this.theme.bold(" lux "));
+    this.region.staticLine("");
+    this.region.staticLine(` ${badge} ${this.theme.bold(info.title)}`);
+    this.region.staticLine("");
+    this.region.start(this.frame);
+  }
+
+  caseStart(info: { caseId: string; index: number; total: number }): Required<CaseObserver> {
+    const view: CaseView = {
+      caseId: info.caseId,
+      status: "running",
+      startedAt: this.now(),
+      endedAt: null,
+      phase: "loading",
+      toolReportedCalls: 0,
+      toolCalls: 0,
+      toolSucceeded: 0,
+      toolFailed: 0,
+      toolUnresolved: 0,
+      toolUnmatchedResults: 0,
+      toolMalformed: 0,
+      toolOutcomes: createToolOutcomeAccumulator(),
+      interrupts: 0,
+      assertionTotal: 0,
+      currentAssertion: null,
+      assertions: [],
+      usage: emptyRunUsage(),
+      agentTurns: [],
+      phaseDurationMs: null,
+      runDir: null,
+      errorMessage: null,
+    };
+    this.cases.push(view);
+    if (!this.region.live) {
+      this.region.staticLine(this.theme.dim(` ▶ ${info.caseId}`));
+    }
+    return {
+      event: (event) => this.applyEvent(view, event),
+      assertionStart: (assertion) => this.applyAssertionStart(view, assertion),
+      assertionEnd: (_info, entry) => this.applyAssertionEnd(view, entry),
+      end: (result) => this.finishCase(view, result),
+    };
+  }
+
+  private applyEvent(view: CaseView, event: RunEvent): void {
+    if (view.endedAt !== null) return;
+    if (event.type === "lifecycle") view.phase = PHASE_OF[event.stage];
+    else if (
+      event.type === "progress" &&
+      (event.kind === "tool-call" || event.kind === "tool-result")
+    ) {
+      view.toolOutcomes.add(event);
+      const tools = view.toolOutcomes.summary();
+      view.toolReportedCalls = tools.reportedCalls;
+      view.toolCalls = tools.total;
+      view.toolSucceeded = tools.succeeded;
+      view.toolFailed = tools.failed;
+      view.toolUnresolved = tools.unresolved;
+      view.toolUnmatchedResults = tools.unmatchedResults;
+      view.toolMalformed = tools.malformedEvents;
+    } else if (event.type === "progress" && event.kind === "usage") {
+      const turn = TurnUsageSchema.safeParse(event.payload).data;
+      if (turn) view.agentTurns.push(turn);
+    } else if (event.type === "interrupt") view.interrupts++;
+    else if (event.type === "error") view.errorMessage = event.reason;
+  }
+
+  private applyAssertionStart(view: CaseView, info: AssertionProgress): void {
+    if (view.endedAt !== null) return;
+    view.phase = "grading";
+    view.assertionTotal = info.total;
+    view.currentAssertion = info.name;
+  }
+
+  private applyAssertionEnd(view: CaseView, entry: GradingAssertionEntry): void {
+    if (view.endedAt !== null) return;
+    view.assertions.push(entry);
+    view.currentAssertion = null;
+  }
+
+  private finishCase(view: CaseView, result: SuiteCaseResult): void {
+    if (view.endedAt !== null) return;
+    view.endedAt = this.now();
+    view.runDir = result.runDir;
+    if (!result.result) view.status = "errored";
+    else if (result.exitReason !== "done") view.status = "incomplete";
+    else if (result.casePassed === true) view.status = "passed";
+    else if (result.casePassed === false) view.status = "failed";
+    else view.status = "ungraded";
+    if (result.errorMessage) view.errorMessage = result.errorMessage;
+    if (result.result) {
+      view.assertions = result.result.grading.assertions;
+      view.usage = result.result.metadata.usage;
+      view.phaseDurationMs = result.result.metadata.phaseDurationMs ?? null;
+      const tools = result.result.metadata.toolOutcomes;
+      if (tools) {
+        view.toolReportedCalls = tools.reportedCalls;
+        view.toolCalls = tools.total;
+        view.toolSucceeded = tools.succeeded;
+        view.toolFailed = tools.failed;
+        view.toolUnresolved = tools.unresolved;
+        view.toolUnmatchedResults = tools.unmatchedResults;
+        view.toolMalformed = tools.malformedEvents;
+      }
+    } else {
+      // Assertions reported before the run failed to persist are not results
+      // and must not inflate the closing tally of a case that errored.
+      view.assertions = [];
+    }
+
+    this.region.staticLine(this.finishedLine(view));
+    for (const line of this.caseTreeLines(view)) this.region.staticLine(line);
+  }
+
+  /** Tear down the live block and print the closing report. */
+  finish(): void {
+    this.region.stop();
+    this.write("");
+    for (const line of this.summaryLines()) this.write(line);
+    this.write("");
+  }
+
+  private write(text: string): void {
+    this.region.staticLine(text);
+  }
+
+  private readonly frame = (): string[] => {
+    const running = this.cases.filter((c) => c.status === "running");
+    if (running.length === 0 && this.cases.length === 0) return [];
+    const lines = [""];
+    for (const view of running) {
+      lines.push(this.runningLine(view));
+      lines.push(...this.liveTreeLines(view));
+    }
+    if (running.length > 0) lines.push("");
+    lines.push(...this.summaryLines({ live: true }));
+    return lines;
+  };
+
+  // The running case's agent spend as it stands: the aggregate once the run
+  // reports one, else the turns summed so far — so the count ticks up live.
+  private agentUsageOf(view: CaseView): TokenUsage {
+    return isUsageEmpty(view.usage.agent) ? sumUsage(view.agentTurns) : view.usage.agent;
+  }
+
+  private runningLine(view: CaseView): string {
+    const elapsed = this.now() - view.startedAt;
+    const tick = Math.floor((this.now() - this.startedAt) / 80);
+    const spinner = this.theme.cyan(spinnerFrame(tick));
+    const name = cell(view.caseId, this.nameWidth);
+    const duration = formatDuration(elapsed).padStart(DURATION_COL);
+    const agent = this.agentUsageOf(view);
+    const usage = isUsageEmpty(agent) ? "" : `  ${this.theme.dim(formatAlignedUsage(agent))}`;
+    return ` ${spinner} ${name}  ${duration}  ${this.theme.dim(this.activity(view))}${usage}`;
+  }
+
+  private activity(view: CaseView): string {
+    if (view.phase === "grading") {
+      const done = view.assertions.length;
+      const current = view.currentAssertion ? ` · ${view.currentAssertion}` : "";
+      return `grading ${done}/${view.assertionTotal}${current}`;
+    }
+    if (view.phase === "agent") {
+      const bits = [
+        view.toolReportedCalls === view.toolCalls
+          ? `${view.toolCalls} tools`
+          : `${view.toolReportedCalls} reported tools · ${view.toolCalls} valid`,
+      ];
+      if (view.toolSucceeded > 0) bits.push(`${view.toolSucceeded} ok`);
+      if (view.toolFailed > 0) bits.push(`${view.toolFailed} failed`);
+      if (view.toolUnresolved > 0) bits.push(`${view.toolUnresolved} unresolved`);
+      if (view.toolUnmatchedResults > 0) {
+        bits.push(`${view.toolUnmatchedResults} unmatched results`);
+      }
+      if (view.interrupts > 0) bits.push(`${view.interrupts} asks`);
+      return `agent · ${bits.join(" · ")}`;
+    }
+    return view.phase;
+  }
+
+  private finishedLine(view: CaseView): string {
+    const mark = statusMark(view.status, this.theme);
+    const name = cell(view.caseId, this.nameWidth);
+    const elapsed = view.endedAt === null ? 0 : view.endedAt - view.startedAt;
+    const duration = formatDuration(elapsed).padStart(DURATION_COL);
+    if (view.status === "errored") {
+      const reason = view.errorMessage ?? "failed before the run started";
+      return ` ${mark} ${name}  ${duration}  ${this.theme.red(inlineError(reason))}`;
+    }
+    const tally = assertionTally(view).padStart(TALLY_COL);
+    if (view.status === "incomplete") {
+      const reason = view.errorMessage ?? "did not finish";
+      return ` ${mark} ${name}  ${duration}  ${tally}  ${this.theme.red(inlineError(reason))}`;
+    }
+    const agent = view.usage.agent;
+    const usage = isUsageEmpty(agent) ? "" : `  ${this.theme.dim(formatAlignedUsage(agent))}`;
+    return ` ${mark} ${name}  ${duration}  ${tally}${usage}`;
+  }
+
+  // A finished case expands into its assertions; a non-passing case also
+  // gets a `→ runDir` leaf, and `--verbose` adds timings and the run dir.
+  private caseTreeLines(view: CaseView): string[] {
+    const nodes = this.contentNodes(view);
+
+    // The headline truncates a long crash message; surface it in full here.
+    if (view.errorMessage && view.errorMessage.length > INLINE_ERROR_MAX) {
+      nodes.push({ head: this.theme.red(view.errorMessage) });
+    }
+
+    if (this.verbose && view.phaseDurationMs) {
+      const p = view.phaseDurationMs;
+      const parts = [
+        `agent ${formatDuration(p.agent)}`,
+        `collect ${formatDuration(p.collect)}`,
+        `grading ${formatDuration(p.grading)}`,
+      ];
+      nodes.push({ head: this.theme.dim(parts.join(" · ")) });
+    }
+
+    const failed = view.status !== "passed" && view.status !== "ungraded";
+    if (view.runDir && (failed || this.verbose)) {
+      nodes.push({ head: this.theme.dim(`→ ${view.runDir}`) });
+    }
+
+    return this.renderTree(nodes);
+  }
+
+  // The assertions and turns as they stand — shared by the finished tree and
+  // the live one, so a case looks the same mid-flight as it does when it lands.
+  private contentNodes(view: CaseView): TreeNode[] {
+    const nodes: TreeNode[] = [];
+    const width = Math.min(
+      ASSERTION_NAME_MAX,
+      Math.max(NAME_MIN, ...view.assertions.map((a) => a.name.length)),
+    );
+    for (const entry of view.assertions) {
+      const mark = entry.passed ? this.theme.green("✓") : this.theme.red("✗");
+      const duration = formatDuration(entry.durationMs).padStart(DURATION_COL);
+      const note = scoreNote(entry);
+      const suffix = note ? `  ${this.theme.red(note)}` : "";
+      nodes.push({
+        head: `${mark} ${cell(entry.name, width)}  ${this.theme.dim(duration)}${suffix}`,
+        body: !entry.passed && entry.comment ? [this.theme.dim(entry.comment)] : [],
+      });
+    }
+
+    if (view.toolCalls > 0 || view.toolUnmatchedResults > 0 || view.toolMalformed > 0) {
+      const parts = [
+        ...(view.toolReportedCalls === view.toolCalls
+          ? [`${view.toolCalls} total`]
+          : [`${view.toolReportedCalls} reported`, `${view.toolCalls} valid`]),
+        this.theme.green(`${view.toolSucceeded} succeeded`),
+        ...(view.toolFailed > 0
+          ? [this.theme.red(`${view.toolFailed} failed`)]
+          : [`${view.toolFailed} failed`]),
+        `${view.toolUnresolved} unresolved`,
+      ];
+      if (view.toolUnmatchedResults > 0) {
+        parts.push(this.theme.red(`${view.toolUnmatchedResults} unmatched results`));
+      }
+      if (view.toolMalformed > 0) {
+        parts.push(this.theme.red(`${view.toolMalformed} malformed events`));
+      }
+      nodes.push({
+        head: `${this.theme.dim("tools")}  ${parts.join(" · ")}`,
+      });
+    }
+
+    // The per-call split behind the headline's aggregate. One turn is just the
+    // aggregate restated, so the group only earns its space at two or more.
+    if (view.agentTurns.length >= 2) {
+      nodes.push({
+        head: this.theme.dim(`turns  (${view.agentTurns.length})`),
+        children: view.agentTurns.map((turn, i) => {
+          const number = String(i + 1).padStart(String(view.agentTurns.length).length);
+          return {
+            head: `${this.theme.dim(number)}  ${cell(turn.label ?? "", TURN_LABEL_WIDTH)}  ${this.theme.dim(formatAlignedUsage(turn))}`,
+          };
+        }),
+      });
+    }
+    return nodes;
+  }
+
+  // The tree under a still-running case. Elide old assertions before they can
+  // crowd recent activity and the summary out of the live region.
+  private liveTreeLines(view: CaseView): string[] {
+    const nodes = this.contentNodes(view);
+    const hasTurns = view.agentTurns.length >= 2;
+    const assertionNodes = hasTurns ? nodes.slice(0, -1) : nodes;
+    const trailing = hasTurns ? nodes.slice(-1) : [];
+    const MAX_ASSERTIONS = 8;
+    const shown =
+      assertionNodes.length > MAX_ASSERTIONS
+        ? [
+            { head: this.theme.dim(`… ${assertionNodes.length - MAX_ASSERTIONS} earlier`) },
+            ...assertionNodes.slice(-MAX_ASSERTIONS),
+          ]
+        : assertionNodes;
+    return this.renderTree([...shown, ...trailing]);
+  }
+
+  private renderTree(nodes: TreeNode[], prefix = "   "): string[] {
+    const lines: string[] = [];
+    nodes.forEach((node, i) => {
+      const last = i === nodes.length - 1;
+      lines.push(`${prefix}${this.theme.dim(last ? "└─ " : "├─ ")}${node.head}`);
+      const childPrefix = `${prefix}${this.theme.dim(last ? "   " : "│  ")}`;
+      for (const line of node.body ?? []) lines.push(`${childPrefix}${line}`);
+      if (node.children?.length) lines.push(...this.renderTree(node.children, childPrefix));
+    });
+    return lines;
+  }
+
+  private summaryLines(opts: { live?: boolean } = {}): string[] {
+    const label = (text: string): string => this.theme.dim(text.padEnd(LABEL_COL));
+    const lines: string[] = [];
+
+    const count = (status: CaseStatus): number =>
+      this.cases.filter((c) => c.status === status).length;
+    const queued = Math.max(0, this.total - this.cases.length);
+
+    if (this.total > 1 || opts.live) {
+      const tally = formatTally(
+        [
+          [count("passed"), this.theme.green("passed")],
+          [count("failed"), this.theme.red("failed")],
+          [count("incomplete"), this.theme.red("incomplete")],
+          [count("errored"), this.theme.red("errored")],
+          [count("ungraded"), "ungraded"],
+          [count("running"), this.theme.cyan("running")],
+          [queued, this.theme.dim("queued")],
+        ],
+        this.total,
+      );
+      lines.push(` ${label("Cases")}${tally}`);
+    }
+
+    if (this.loop > 1) {
+      lines.push(` ${label("Loop")}${this.theme.dim(`${this.loop} runs per eval`)}`);
+    }
+
+    const assertions = this.cases.flatMap((c) => c.assertions);
+    if (assertions.length > 0) {
+      const ok = assertions.filter((a) => a.passed).length;
+      const bad = assertions.length - ok;
+      const tally = formatTally(
+        [
+          [ok, this.theme.green("passed")],
+          [bad, this.theme.red("failed")],
+        ],
+        assertions.length,
+      );
+      lines.push(` ${label("Assertions")}${tally}`);
+    }
+
+    const done = this.cases.filter((c) => c.endedAt !== null);
+    const elapsed = this.now() - this.startedAt;
+    // An average over one case is just that case's duration, restated.
+    const average =
+      done.length > 0
+        ? done.reduce((sum, c) => sum + ((c.endedAt ?? 0) - c.startedAt), 0) / done.length
+        : 0;
+    const avgText =
+      this.total > 1 && done.length > 0
+        ? `  ${this.theme.dim(`avg ${formatDuration(average)}/case`)}`
+        : "";
+    lines.push(` ${label("Duration")}${formatDuration(elapsed)}${avgText}`);
+
+    lines.push(...this.usageLines(label, Boolean(opts.live)));
+
+    if (!opts.live && this.runsRoot) {
+      lines.push(` ${label("Runs")}${this.theme.dim(this.runsRoot)}`);
+    }
+    if (!opts.live && this.suiteDir) {
+      lines.push(` ${label("Suite")}${this.theme.dim(this.suiteDir)}`);
+    }
+    if (!opts.live) lines.push(` ${label("Legend")}${this.legend()}`);
+    return lines;
+  }
+
+  private legend(): string {
+    const dim = this.theme.dim;
+    const g = TURN_GLYPHS;
+    const entries = [
+      `${this.theme.green("✓")} ${dim("pass")}`,
+      `${this.theme.red("✗")} ${dim("fail")}`,
+      dim(`${g.thinking} thought`),
+      dim(`${g.tool} tool`),
+      dim(`${g.reply} reply`),
+      dim(`${g.ask} ask`),
+      dim("↑ input"),
+      dim("↓ output"),
+      dim("⚡ cache hit · ◇ cache write"),
+    ];
+    return entries.join(dim("  ·  "));
+  }
+
+  private usageLines(label: (t: string) => string, live: boolean): string[] {
+    const total = this.cases.reduce<RunUsage>(
+      (acc, c) => ({
+        agent: addUsage(acc.agent, this.agentUsageOf(c)),
+        answerer: addUsage(acc.answerer, c.usage.answerer),
+        grading: addUsage(acc.grading, c.usage.grading),
+      }),
+      emptyRunUsage(),
+    );
+    const harness = harnessUsage(total);
+    if (isUsageEmpty(total.agent) && isUsageEmpty(harness)) {
+      return live ? [] : [` ${label("Tokens")}${this.theme.dim("none reported")}`];
+    }
+
+    const agentText = isUsageEmpty(total.agent) ? this.theme.dim("none") : formatUsage(total.agent);
+    if (live) {
+      const harnessText = isUsageEmpty(harness)
+        ? ""
+        : `   harness ${formatTokens(totalTokens(harness))}`;
+      return [` ${label("Tokens")}agent ${agentText}${this.theme.dim(harnessText)}`];
+    }
+
+    const lines = [` ${label("Tokens")}agent ${agentText}`];
+    if (!isUsageEmpty(harness)) {
+      const split = [
+        `answerer ${formatTokens(totalTokens(total.answerer))}`,
+        `judge ${formatTokens(totalTokens(total.grading))}`,
+      ].join(", ");
+      lines.push(` ${label("")}${this.theme.dim(`harness ${formatUsage(harness)}  (${split})`)}`);
+    }
+    return lines;
+  }
+}
+
+// Internal exports for testing
+export { cell, scoreNote };