@aibridge/cli 0.0.1

package/src/commands/quota/impl.ts

@@ -0,0 +1,109 @@
+import { type AgyQuotaSnapshot, fetchAgyQuota } from '@aibridge/agy';
+import { type ClaudeQuotaSnapshot, fetchClaudeQuota } from '@aibridge/claude';
+import { type CodexQuotaSnapshot, fetchCodexQuota } from '@aibridge/codex';
+import type { LocalContext } from '../../context.ts';
+
+export interface QuotaFlags {
+  readonly json: boolean;
+}
+
+function formatReset(resetTime: string | undefined): string {
+  if (!resetTime) return '-';
+  const ms = new Date(resetTime).getTime() - Date.now();
+  if (Number.isNaN(ms)) return resetTime;
+  if (ms <= 0) return 'now';
+  const mins = Math.round(ms / 60_000);
+  const rel = mins < 60 ? `${mins}m` : `${Math.floor(mins / 60)}h${mins % 60}m`;
+  return `${new Date(resetTime).toLocaleTimeString()} (in ${rel})`;
+}
+
+function renderAgy(ctx: LocalContext, snapshot: AgyQuotaSnapshot): void {
+  ctx.process.stdout.write('=== agy (Antigravity) — remaining per model group ===\n');
+  for (const group of snapshot.groups) {
+    ctx.process.stdout.write(`${group.displayName}\n`);
+    for (const b of group.buckets) {
+      const pct =
+        b.remainingFraction === 0 ? 'EXHAUSTED' : `${Math.round(b.remainingFraction * 100)}%`;
+      ctx.process.stdout.write(
+        `  ${b.displayName.padEnd(18)} ${pct.padEnd(10)} ${formatReset(b.resetTime)}\n`,
+      );
+    }
+  }
+  const exhausted = snapshot.models.filter(m => m.exhausted);
+  if (exhausted.length > 0) {
+    ctx.process.stdout.write(
+      `Exhausted models: ${[...new Set(exhausted.map(m => m.label))].join(', ')}\n`,
+    );
+  }
+}
+
+function renderCodex(ctx: LocalContext, snapshot: CodexQuotaSnapshot): void {
+  const plan = snapshot.planType ? ` — plan: ${snapshot.planType}` : '';
+  const reached = snapshot.limitReached ? ' [LIMIT REACHED]' : '';
+  ctx.process.stdout.write(`=== codex (ChatGPT)${plan}${reached} — used per window ===\n`);
+  ctx.process.stdout.write(`${'WINDOW'.padEnd(10)} ${'USED'.padEnd(10)} RESET\n`);
+  for (const w of snapshot.windows) {
+    ctx.process.stdout.write(
+      `${w.window.padEnd(10)} ${`${w.usedPercent}%`.padEnd(10)} ${formatReset(w.resetAt)}\n`,
+    );
+  }
+}
+
+function renderClaude(ctx: LocalContext, snapshot: ClaudeQuotaSnapshot): void {
+  ctx.process.stdout.write('=== claude (Claude Code subscription) — used per window ===\n');
+  ctx.process.stdout.write(`${'WINDOW'.padEnd(20)} ${'USED'.padEnd(10)} RESET\n`);
+  for (const w of snapshot.windows) {
+    ctx.process.stdout.write(
+      `${w.window.padEnd(20)} ${`${w.usedPercent}%`.padEnd(10)} ${w.resetsText || '-'}\n`,
+    );
+  }
+}
+
+function renderSection<T>(
+  ctx: LocalContext,
+  result: PromiseSettledResult<T>,
+  title: string,
+  render: (ctx: LocalContext, snapshot: T) => void,
+): void {
+  if (result.status === 'fulfilled') {
+    render(ctx, result.value);
+  } else {
+    ctx.process.stdout.write(
+      `=== ${title} ===\nunavailable: ${(result.reason as Error).message}\n`,
+    );
+  }
+}
+
+export default async function quotaImpl(this: LocalContext, flags: QuotaFlags): Promise<void> {
+  const [agy, codex, claude] = await Promise.allSettled([
+    fetchAgyQuota(),
+    fetchCodexQuota(),
+    fetchClaudeQuota(),
+  ]);
+
+  const allFailed =
+    agy.status === 'rejected' && codex.status === 'rejected' && claude.status === 'rejected';
+
+  if (flags.json) {
+    this.process.stdout.write(
+      `${JSON.stringify(
+        {
+          agy: agy.status === 'fulfilled' ? agy.value : { error: String(agy.reason) },
+          codex: codex.status === 'fulfilled' ? codex.value : { error: String(codex.reason) },
+          claude: claude.status === 'fulfilled' ? claude.value : { error: String(claude.reason) },
+        },
+        null,
+        2,
+      )}\n`,
+    );
+    if (allFailed) this.process.exitCode = 1;
+    return;
+  }
+
+  renderSection(this, agy, 'agy (Antigravity)', renderAgy);
+  this.process.stdout.write('\n');
+  renderSection(this, codex, 'codex (ChatGPT)', renderCodex);
+  this.process.stdout.write('\n');
+  renderSection(this, claude, 'claude (Claude Code subscription)', renderClaude);
+  if (allFailed) this.process.exitCode = 1;
+}

package/src/commands/review/command.ts

@@ -0,0 +1,58 @@
+import { buildCommand } from '@stricli/core';
+import { DEFAULT_MODEL, listModelHelpLines } from '../../models.ts';
+import { positiveIntSeconds } from '../../parsers.ts';
+import reviewImpl from './impl.ts';
+
+const fullDescription = [
+  'Inspects code diffs or plan contracts and writes a review report.',
+  '',
+  'Available models (canonical slug):',
+  ...listModelHelpLines(),
+].join('\n');
+
+export const review = buildCommand({
+  func: reviewImpl,
+  parameters: {
+    flags: {
+      model: {
+        kind: 'parsed',
+        parse: String,
+        optional: true,
+        brief: `Model slug (default: ${DEFAULT_MODEL})`,
+      },
+      plan: {
+        kind: 'parsed',
+        parse: String,
+        optional: true,
+        brief: 'Plan file for contract / over-reach check',
+      },
+      base: {
+        kind: 'parsed',
+        parse: String,
+        optional: true,
+        brief: 'Base git ref to diff against (default: HEAD)',
+      },
+      out: {
+        kind: 'parsed',
+        parse: String,
+        optional: true,
+        brief: 'Where to write the review report (default: <run.dir>/review.md)',
+      },
+      timeout: {
+        kind: 'parsed',
+        parse: positiveIntSeconds,
+        optional: true,
+        brief: 'Max seconds for review (default: 1200)',
+      },
+      preflight: {
+        kind: 'boolean',
+        default: true,
+        brief: 'Check model quota before running (use --no-preflight to skip)',
+      },
+    },
+  },
+  docs: {
+    brief: 'Review working tree diff or plan contract',
+    fullDescription,
+  },
+});

package/src/commands/review/impl.ts

@@ -0,0 +1,211 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { isAbsolute, resolve } from 'node:path';
+import { runCaptured } from '@aibridge/proc';
+import type { LocalContext } from '../../context.ts';
+import { delegate } from '../../delegate.ts';
+import { DEFAULT_MODEL, formatUnknownModelError, resolveModel } from '../../models.ts';
+import { preflightModel, renderPreflightRefusal } from '../../quotaPreflight.ts';
+import { startRun } from '../../runlog.ts';
+
+export interface ReviewFlags {
+  readonly model?: string;
+  readonly plan?: string;
+  readonly base?: string;
+  readonly out?: string;
+  readonly timeout?: number;
+  readonly preflight: boolean;
+}
+
+export type ReviewVerdictResult =
+  | { readonly kind: 'pass' }
+  | {
+      readonly kind: 'findings';
+      readonly critical: number;
+      readonly major: number;
+      readonly minor: number;
+      readonly formattedLine: string;
+    }
+  | { readonly kind: 'unparseable'; readonly rawLine: string };
+
+function matchVerdictLine(line: string): ReviewVerdictResult | null {
+  if (/^PASS\b/i.test(line)) {
+    return { kind: 'pass' };
+  }
+  const match = line.match(
+    /^FINDINGS:\s*(?:(\d+)\s*critical,?\s*)?(?:(\d+)\s*major,?\s*)?(?:(\d+)\s*minor)?/i,
+  );
+  if (match) {
+    const critical = match[1] ? Number.parseInt(match[1], 10) : 0;
+    const major = match[2] ? Number.parseInt(match[2], 10) : 0;
+    const minor = match[3] ? Number.parseInt(match[3], 10) : 0;
+    const formattedLine = `FINDINGS: ${critical} critical, ${major} major, ${minor} minor`;
+    return { kind: 'findings', critical, major, minor, formattedLine };
+  }
+  return null;
+}
+
+export function parseReviewVerdict(response: string): ReviewVerdictResult {
+  const lines = response
+    .split(/\r?\n/)
+    .map(l => l.trim())
+    .filter(l => l.length > 0);
+  if (lines.length === 0) {
+    return { kind: 'unparseable', rawLine: '' };
+  }
+
+  const first = matchVerdictLine(lines[0] as string);
+  if (first) return first;
+  const last = matchVerdictLine(lines[lines.length - 1] as string);
+  if (last) return last;
+
+  const embedded = [
+    ...response.matchAll(/FINDINGS:\s*(\d+)\s*critical,?\s*(\d+)\s*major,?\s*(\d+)\s*minor/gi),
+  ].at(-1);
+  if (embedded) {
+    const critical = Number.parseInt(embedded[1] as string, 10);
+    const major = Number.parseInt(embedded[2] as string, 10);
+    const minor = Number.parseInt(embedded[3] as string, 10);
+    return {
+      kind: 'findings',
+      critical,
+      major,
+      minor,
+      formattedLine: `FINDINGS: ${critical} critical, ${major} major, ${minor} minor`,
+    };
+  }
+
+  return { kind: 'unparseable', rawLine: lines[0] as string };
+}
+
+export default async function review(this: LocalContext, flags: ReviewFlags): Promise<void> {
+  const inputSlug = flags.model ?? DEFAULT_MODEL;
+  const model = resolveModel(inputSlug);
+  if (!model) {
+    this.process.stderr.write(`${formatUnknownModelError(inputSlug)}\n`);
+    this.process.exitCode = 2;
+    return;
+  }
+
+  const cwd = this.process.cwd();
+  const baseRef = flags.base ?? 'HEAD';
+
+  let absPlanPath: string | undefined;
+  if (flags.plan) {
+    absPlanPath = isAbsolute(flags.plan) ? flags.plan : resolve(cwd, flags.plan);
+    if (!existsSync(absPlanPath)) {
+      this.process.stderr.write(`aibridge review: plan file "${absPlanPath}" not found\n`);
+      this.process.exitCode = 2;
+      return;
+    }
+  }
+
+  const diffRes = await runCaptured('git', ['diff', '--quiet', baseRef], { cwd });
+  if (diffRes.code !== 0 && diffRes.code !== 1) {
+    const detail = diffRes.stderr.trim().split('\n')[0] ?? `exit code ${diffRes.code}`;
+    this.process.stderr.write(
+      `aibridge review: git diff failed for base "${baseRef}": ${detail}\n`,
+    );
+    this.process.exitCode = 2;
+    return;
+  }
+  const hasDiff = diffRes.code === 1;
+
+  const statusRes = await runCaptured('git', ['status', '--porcelain'], { cwd });
+  const hasPorcelain = statusRes.code === 0 && statusRes.stdout.trim().length > 0;
+
+  const isDirty = hasDiff || hasPorcelain;
+
+  if (!isDirty && !absPlanPath) {
+    this.process.stderr.write(`aibridge review: nothing to review\n`);
+    this.process.exitCode = 2;
+    return;
+  }
+
+  if (flags.preflight) {
+    const verdict = await preflightModel(model);
+    if (!verdict.ok) {
+      this.process.stderr.write(`${renderPreflightRefusal('review', verdict)}\n`);
+      this.process.exitCode = 3;
+      return;
+    }
+    if (verdict.warning) this.process.stderr.write(`aibridge review: ${verdict.warning}\n`);
+  }
+
+  const timeoutSec = flags.timeout ?? 1200;
+  const modeDetail = isDirty
+    ? absPlanPath
+      ? `diff + plan (${absPlanPath})`
+      : `diff (${baseRef})`
+    : `plan-only (${absPlanPath})`;
+
+  const run = startRun('review', `${model.spec.slug}: ${modeDetail}`);
+
+  const absOutPath = flags.out
+    ? isAbsolute(flags.out)
+      ? flags.out
+      : resolve(cwd, flags.out)
+    : resolve(run.dir, 'review.md');
+
+  let reviewPrompt: string;
+  if (isDirty) {
+    reviewPrompt =
+      `You are an expert code reviewer. Inspect the working tree diff against base '${baseRef}' and untracked files at ${cwd}.\n` +
+      (absPlanPath
+        ? `Compare the implementation against the plan contract at ${absPlanPath}. Any file modified or feature added outside the plan contract counts as over-reach (severity: major unless harmful, then critical).\n`
+        : '') +
+      `Write your detailed review report to the file ${absOutPath}. For each finding, include file:line, severity (critical|major|minor), and rationale.\n` +
+      `Your final answer (last message) must consist of EXACTLY ONE VERDICT LINE:\n` +
+      `Either: "PASS"\n` +
+      `Or: "FINDINGS: <c> critical, <m> major, <n> minor"`;
+  } else {
+    reviewPrompt =
+      `You are an expert architecture reviewer. Inspect the plan contract file at ${absPlanPath}.\n` +
+      `Review the plan for soundness, missing edge cases, safety, and feasibility.\n` +
+      `Write your detailed review report to the file ${absOutPath}. For each finding, include severity (critical|major|minor) and rationale.\n` +
+      `Your final answer (last message) must consist of EXACTLY ONE VERDICT LINE:\n` +
+      `Either: "PASS"\n` +
+      `Or: "FINDINGS: <c> critical, <m> major, <n> minor"`;
+  }
+
+  const outcome = await delegate({
+    model,
+    prompt: reviewPrompt,
+    tools: true,
+    timeoutSec,
+    cwd,
+    run,
+  });
+
+  if (!outcome.ok) {
+    this.process.stderr.write(`${outcome.message}\n`);
+    this.process.exitCode = 1;
+    return;
+  }
+
+  if (!existsSync(absOutPath) || readFileSync(absOutPath, 'utf8').trim().length === 0) {
+    this.process.stderr.write(`aibridge review: review file was not written to ${absOutPath}\n`);
+    this.process.exitCode = 1;
+    return;
+  }
+
+  const verdictResult = parseReviewVerdict(outcome.response);
+
+  if (verdictResult.kind === 'unparseable') {
+    this.process.stderr.write(`aibridge review: could not parse a verdict line from the answer.\n`);
+    this.process.stdout.write(`${outcome.response}\nreview: ${absOutPath}\nrun: ${run.id}\n`);
+    this.process.exitCode = 1;
+    return;
+  }
+
+  if (verdictResult.kind === 'pass') {
+    this.process.stdout.write(`PASS\nreview: ${absOutPath}\nrun: ${run.id}\n`);
+    this.process.exitCode = 0;
+    return;
+  }
+
+  this.process.stdout.write(
+    `${verdictResult.formattedLine}\nreview: ${absOutPath}\nrun: ${run.id}\n`,
+  );
+  const isPassing = verdictResult.critical === 0 && verdictResult.major === 0;
+  this.process.exitCode = isPassing ? 0 : 1;
+}

package/src/commands/review/review.test.ts

@@ -0,0 +1,54 @@
+import { describe, expect, it } from 'vitest';
+import { parseReviewVerdict } from './impl.ts';
+
+describe('parseReviewVerdict', () => {
+  it('parses PASS verdict', () => {
+    const res = parseReviewVerdict('PASS\nFull report below...');
+    expect(res.kind).toBe('pass');
+  });
+
+  it('parses FINDINGS verdict line', () => {
+    const res = parseReviewVerdict('FINDINGS: 0 critical, 1 major, 2 minor');
+    expect(res).toEqual({
+      kind: 'findings',
+      critical: 0,
+      major: 1,
+      minor: 2,
+      formattedLine: 'FINDINGS: 0 critical, 1 major, 2 minor',
+    });
+  });
+
+  it('parses FINDINGS verdict line with minor only', () => {
+    const res = parseReviewVerdict('FINDINGS: 3 minor');
+    expect(res).toEqual({
+      kind: 'findings',
+      critical: 0,
+      major: 0,
+      minor: 3,
+      formattedLine: 'FINDINGS: 0 critical, 0 major, 3 minor',
+    });
+  });
+
+  it('handles unparseable text', () => {
+    const res = parseReviewVerdict('The code looks mostly fine but has issues.');
+    expect(res.kind).toBe('unparseable');
+  });
+
+  it('parses a verdict on the last line after narration', () => {
+    const res = parseReviewVerdict('Reading the diff now.\nWriting the report.\nPASS');
+    expect(res.kind).toBe('pass');
+  });
+
+  it('parses a verdict embedded in a newline-free narration blob (observed grok behavior)', () => {
+    const res = parseReviewVerdict(
+      'Inspecting the diff and plan contract.Checking contract edges, then writing the report.FINDINGS: 0 critical, 5 major, 4 minor',
+    );
+    expect(res).toEqual({
+      kind: 'findings',
+      critical: 0,
+      major: 5,
+      minor: 4,
+      formattedLine: 'FINDINGS: 0 critical, 5 major, 4 minor',
+    });
+  });
+});

package/src/commands/runs/command.ts

@@ -0,0 +1,53 @@
+import { buildCommand } from '@stricli/core';
+import type { LocalContext } from '../../context.ts';
+import runsImpl, { type RunsFlags } from './impl.ts';
+
+const fullDescription =
+  'Lists recent runs, watches active runs, or displays logs for a specific run.';
+
+async function runsCommand(this: LocalContext, flags: RunsFlags, idPrefix?: string): Promise<void> {
+  if (flags.watch && idPrefix !== undefined) {
+    this.process.stderr.write('aibridge runs: cannot specify <id> when using --watch\n');
+    this.process.exitCode = 2;
+    return;
+  }
+  if (flags.watch && flags.json) {
+    this.process.stderr.write('aibridge runs: cannot specify --json when using --watch\n');
+    this.process.exitCode = 2;
+    return;
+  }
+  await runsImpl.call(this, flags, idPrefix);
+}
+
+export const runs = buildCommand({
+  func: runsCommand,
+  parameters: {
+    flags: {
+      watch: {
+        kind: 'boolean',
+        withNegated: false,
+        brief: 'Watch running runs in real time (refresh every 2s)',
+      },
+      json: {
+        kind: 'boolean',
+        withNegated: false,
+        brief: 'Emit output in JSON Lines format (list mode only)',
+      },
+    },
+    positional: {
+      kind: 'tuple',
+      parameters: [
+        {
+          brief: 'Run id prefix to inspect (defaults to listing recent runs)',
+          parse: String,
+          placeholder: 'id-prefix',
+          optional: true,
+        },
+      ],
+    },
+  },
+  docs: {
+    brief: 'Monitor and inspect execution runs',
+    fullDescription,
+  },
+});

package/src/commands/runs/impl.ts

@@ -0,0 +1,171 @@
+import type { LocalContext } from '../../context.ts';
+import { listRuns, type RunMeta, readRunLogs } from '../../runlog.ts';
+
+export interface RunsFlags {
+  readonly watch: boolean;
+  readonly json: boolean;
+}
+
+function formatElapsed(startedAtStr: string, endedAtStr: string | null): string {
+  const start = new Date(startedAtStr).getTime();
+  const end = endedAtStr ? new Date(endedAtStr).getTime() : Date.now();
+  const diffSec = Math.max(0, Math.floor((end - start) / 1000));
+  if (diffSec < 60) {
+    return `${diffSec}s`;
+  }
+  const min = Math.floor(diffSec / 60);
+  const sec = diffSec % 60;
+  return `${min}m${sec}s`;
+}
+
+function getStatus(run: RunMeta): string {
+  if (run.status === 'running' && run.pid !== null) {
+    try {
+      process.kill(run.pid, 0);
+    } catch {
+      return 'stale';
+    }
+  }
+  return run.status;
+}
+
+export default async function runs(
+  this: LocalContext,
+  flags: RunsFlags,
+  idPrefix?: string,
+): Promise<void> {
+  if (idPrefix !== undefined) {
+    const all = listRuns();
+    const matches = all.filter(r => r.id.startsWith(idPrefix));
+    if (matches.length === 0) {
+      this.process.stderr.write(`aibridge runs: no run matches prefix "${idPrefix}"\n`);
+      this.process.exitCode = 1;
+      return;
+    }
+    if (matches.length > 1) {
+      this.process.stderr.write(
+        `aibridge runs: ambiguous prefix "${idPrefix}" matches:\n${matches.map(m => `  ${m.id}`).join('\n')}\n`,
+      );
+      this.process.exitCode = 1;
+      return;
+    }
+    const target = matches[0];
+    if (target === undefined) return;
+    const logs = readRunLogs(target.id);
+    if (!logs) {
+      this.process.stderr.write(`aibridge runs: failed to read logs for run "${target.id}"\n`);
+      this.process.exitCode = 1;
+      return;
+    }
+
+    const status = getStatus(logs.meta).toUpperCase();
+    const elapsed = formatElapsed(logs.meta.startedAt, logs.meta.endedAt);
+    const summaryLines = [
+      `ID:      ${logs.meta.id}`,
+      `COMMAND: ${logs.meta.command}`,
+      `STATUS:  ${status}`,
+      `ELAPSED: ${elapsed}`,
+      `DETAIL:  ${logs.meta.detail}`,
+    ];
+    if (logs.meta.pid !== null) {
+      summaryLines.push(`PID:     ${logs.meta.pid}`);
+    }
+    if (logs.meta.exitCode !== null) {
+      summaryLines.push(`EXIT:    ${logs.meta.exitCode}`);
+    }
+    this.process.stdout.write(`${summaryLines.join('\n')}\n\n`);
+
+    const stdoutLines = logs.stdout.split('\n');
+    if (stdoutLines.length > 1 && stdoutLines[stdoutLines.length - 1] === '') {
+      stdoutLines.pop();
+    }
+    const lastStdout = stdoutLines.slice(-40).join('\n');
+    this.process.stdout.write(`${lastStdout}\n`);
+
+    if (logs.stderr.trim().length > 0) {
+      const stderrLines = logs.stderr.split('\n');
+      if (stderrLines.length > 1 && stderrLines[stderrLines.length - 1] === '') {
+        stderrLines.pop();
+      }
+      const lastStderr = stderrLines.slice(-10).join('\n');
+      this.process.stdout.write(`\n--- stderr (last 10 lines) ---\n${lastStderr}\n`);
+    }
+    return;
+  }
+
+  if (flags.watch) {
+    const update = () => {
+      this.process.stdout.write('\x1b[2J\x1b[H');
+      const timeStr = new Date().toLocaleTimeString();
+      this.process.stdout.write(`aibridge runs — ${timeStr} (ctrl-c to quit)\n\n`);
+
+      const runs = listRuns();
+      if (runs.length === 0) {
+        this.process.stdout.write('no runs yet\n');
+        return;
+      }
+
+      const limit = runs.slice(0, 10);
+      this.process.stdout.write(
+        `${'STATUS'.padEnd(10)} ${'ID'.padEnd(35)} ${'ELAPSED'.padEnd(10)} DETAIL\n`,
+      );
+      for (const r of limit) {
+        const status = getStatus(r).toUpperCase();
+        const elapsed = formatElapsed(r.startedAt, r.endedAt);
+        const detail = r.detail.replace(/\r?\n/g, ' ');
+        const truncatedDetail = detail.length > 60 ? `${detail.slice(0, 57)}...` : detail;
+        this.process.stdout.write(
+          `${status.padEnd(10)} ${r.id.padEnd(35)} ${elapsed.padEnd(10)} ${truncatedDetail}\n`,
+        );
+      }
+
+      const runningRuns = runs.filter(r => getStatus(r) === 'running');
+      for (const r of runningRuns) {
+        const logs = readRunLogs(r.id);
+        if (logs) {
+          this.process.stdout.write(`\n--- stdout: ${r.id} ---\n`);
+          const lines = logs.stdout.split('\n');
+          if (lines.length > 1 && lines[lines.length - 1] === '') {
+            lines.pop();
+          }
+          const lastSix = lines.slice(-6).join('\n');
+          this.process.stdout.write(`${lastSix}\n`);
+        }
+      }
+    };
+
+    update();
+    setInterval(update, 2000);
+    return new Promise<void>(() => {});
+  }
+
+  const runs = listRuns();
+  if (runs.length === 0) {
+    this.process.stdout.write('no runs yet\n');
+    return;
+  }
+
+  if (flags.json) {
+    const limit = runs.slice(0, 20);
+    for (const r of limit) {
+      const status = getStatus(r);
+      const withStatus = { ...r, status };
+      this.process.stdout.write(`${JSON.stringify(withStatus)}\n`);
+    }
+    return;
+  }
+
+  const limit = runs.slice(0, 20);
+  this.process.stdout.write(
+    `${'STATUS'.padEnd(10)} ${'ID'.padEnd(35)} ${'ELAPSED'.padEnd(10)} DETAIL\n`,
+  );
+  for (const r of limit) {
+    const status = getStatus(r).toUpperCase();
+    const elapsed = formatElapsed(r.startedAt, r.endedAt);
+    const detail = r.detail.replace(/\r?\n/g, ' ');
+    const truncatedDetail = detail.length > 60 ? `${detail.slice(0, 57)}...` : detail;
+    this.process.stdout.write(
+      `${status.padEnd(10)} ${r.id.padEnd(35)} ${elapsed.padEnd(10)} ${truncatedDetail}\n`,
+    );
+  }
+}