codemax-cli 0.0.0-stage → 0.1.3

package/src/core/pty.ts

@@ -0,0 +1,99 @@
+import { termSize } from "./terminal.ts";
+import { IS_WINDOWS } from "./spawn.ts";
+
+const NESTED_SESSION_ENV = /^(CLAUDECODE|CLAUDE_CODE_|CLAUDE_PID|CLAUDE_EFFORT|CODEX_SANDBOX|CODEX_THREAD_ID|CURSOR_AGENT_SESSION)/;
+
+export interface AgentProcessOptions {
+  cmd: string[];
+  cwd: string;
+  env?: Record<string, string>;
+  /** Env vars removed from the child's environment. */
+  dropEnv?: string[];
+  /** Initial PTY size. Defaults to the host terminal size. */
+  cols?: number;
+  rows?: number;
+  onData: (chunk: Uint8Array) => void;
+  onExit: (code: number | null) => void;
+}
+
+/** One agent TUI running inside a Bun PTY. */
+export class AgentProcess {
+  private term: Bun.Terminal;
+  private proc: Bun.Subprocess;
+  private closed = false;
+  readonly startedAt = Date.now();
+
+  constructor(private opts: AgentProcessOptions) {
+    if (IS_WINDOWS) throw new Error("The --tui and --raw modes need a Unix terminal. On Windows, run codemax without them.");
+    const { cols, rows } = opts.cols && opts.rows ? { cols: opts.cols, rows: opts.rows } : termSize();
+    this.term = new Bun.Terminal({
+      cols,
+      rows,
+      data: (_t, chunk) => {
+        if (!this.closed) opts.onData(chunk);
+      },
+    });
+    const env: Record<string, string | undefined> = { ...process.env, TERM: process.env.TERM ?? "xterm-256color", CODEMAX: "1", ...(opts.env ?? {}) };
+    for (const k of opts.dropEnv ?? []) delete env[k];
+    // Never let an agent think it is a child of another agent session
+    // (e.g. codemax started from inside Claude Code).
+    for (const k of Object.keys(env)) if (NESTED_SESSION_ENV.test(k)) delete env[k];
+    this.proc = Bun.spawn(opts.cmd, { cwd: opts.cwd, terminal: this.term, env });
+    this.proc.exited.then((code) => {
+      this.closed = true;
+      try {
+        this.term.close();
+      } catch {
+        /* already closed */
+      }
+      opts.onExit(code);
+    });
+  }
+
+  get pid() {
+    return this.proc.pid;
+  }
+
+  get exited() {
+    return this.closed;
+  }
+
+  write(data: string | Uint8Array) {
+    if (this.closed) return;
+    this.term.write(data);
+  }
+
+  resize(cols: number, rows: number) {
+    if (this.closed) return;
+    try {
+      this.term.resize(cols, rows);
+    } catch {
+      /* ignore */
+    }
+  }
+
+  /** Force a full repaint: most TUIs redraw on SIGWINCH. */
+  jiggle() {
+    const { cols, rows } = termSize();
+    this.resize(Math.max(20, cols - 1), rows);
+    setTimeout(() => this.resize(cols, rows), 30);
+  }
+
+  async kill(graceMs = 1500): Promise<void> {
+    if (this.closed) return;
+    try {
+      this.proc.kill("SIGTERM");
+    } catch {
+      return;
+    }
+    const timer = setTimeout(() => {
+      try {
+        if (!this.closed) this.proc.kill("SIGKILL");
+      } catch {
+        /* ignore */
+      }
+    }, graceMs);
+    await this.proc.exited;
+    clearTimeout(timer);
+  }
+}

package/src/core/quota.ts

@@ -0,0 +1,55 @@
+import type { AgentId, QuotaStatus } from "../adapters/types.ts";
+import { stripAnsi } from "./terminal.ts";
+
+/**
+ * Vendor-neutral phrases. Deliberately narrow: "rate limit" or "429" alone
+ * show up constantly in normal coding work and must not trip the detector.
+ */
+export const GENERIC_QUOTA_PATTERNS = [/usage limit (reached|exceeded)/i, /you['’]ve (hit|reached) your (usage |weekly |session |daily )?limit/i, /insufficient[_ ]quota/i];
+
+/** How long an output-text detection counts before it is forgotten. */
+export const OUTPUT_DETECTION_TTL_MS = 30 * 60_000;
+
+export function isExhausted(q?: QuotaStatus, now = Date.now()): boolean {
+  if (!q?.exhausted) return false;
+  return !q.expiresAt || q.expiresAt > now;
+}
+
+/**
+ * Scans the ANSI-stripped PTY output of one agent for quota exhaustion text.
+ * Keeps a small rolling buffer so matches spanning chunks are still found.
+ */
+export class OutputScanner {
+  private buf = "";
+  private lastHit = 0;
+  constructor(
+    private agent: AgentId,
+    private patterns: RegExp[],
+    private onHit: (q: QuotaStatus) => void,
+    private debounceMs = 60_000,
+  ) {}
+
+  feed(chunk: string) {
+    this.buf = (this.buf + stripAnsi(chunk)).slice(-4096);
+    if (Date.now() - this.lastHit < this.debounceMs) return;
+    for (const re of [...this.patterns, ...GENERIC_QUOTA_PATTERNS]) {
+      const m = this.buf.match(re);
+      if (m) {
+        this.lastHit = Date.now();
+        this.onHit({ agent: this.agent, exhausted: true, source: "output", detail: `text match: "${m[0].slice(0, 80)}"`, at: Date.now(), expiresAt: Date.now() + OUTPUT_DETECTION_TTL_MS });
+        this.buf = "";
+        return;
+      }
+    }
+  }
+}
+
+export function quotaLabel(q?: QuotaStatus): string {
+  if (!q) return "";
+  if (isExhausted(q)) {
+    const reset = q.resetsAt ? ` until ${new Date(q.resetsAt).toLocaleTimeString()}` : "";
+    return q.source === "output" ? `exhausted? (text match)${reset}` : `EXHAUSTED${reset}`;
+  }
+  if (typeof q.usedPercent === "number") return `${Math.round(q.usedPercent)}% used`;
+  return "";
+}

package/src/core/review.ts

@@ -0,0 +1,67 @@
+import type { AgentId } from "../adapters/types.ts";
+import type { Step, StepOf } from "./journal.ts";
+import { formatStep } from "./brief.ts";
+
+/**
+ * The side agent: a second agent (any harness) that reviews the main agent's
+ * work after each turn and speaks up only when something deserves the user's
+ * attention: drift from the request or plan, claims without evidence, risky
+ * assumptions, missing tests. Its notes can be forwarded to the main agent so
+ * it stays aligned with the plan, whichever harness it runs on.
+ */
+export const NO_NOTE = "NO_NOTE";
+
+export function reviewInstructions(mainAgent: string): string {
+  return [
+    `You are a side agent reviewing the work of another coding agent (${mainAgent}) for the user. You do not do the work yourself.`,
+    "Do not use any tools and do not change any files. Read only what is below.",
+    "Check the latest work against the user's request and the plan. Look for: drift from what the user asked; conclusions or claims the steps do not actually support; decisions resting on thin evidence (one run, one sample, a check that barely passed); risky assumptions; tests or edge cases that were skipped; work that will be wasted if an untested assumption is wrong.",
+    `If nothing is worth interrupting the user for, reply with exactly ${NO_NOTE} and nothing else. Most turns deserve ${NO_NOTE}; do not nitpick style.`,
+    "Otherwise reply with one note in exactly this shape, under 130 words, plain language, concrete facts from the work:",
+    "",
+    "Heads up · <one sentence: what could go wrong>",
+    "",
+    "**<short title>**",
+    "- <fact from the work>",
+    "- <why it matters for the user's goal>",
+    "- **Consider <one concrete, cheap action>.**",
+  ].join("\n");
+}
+
+/** What the reviewer sees: the request, the plan, and the main agent's steps since its last review. */
+export function buildReviewPrompt(o: { steps: Step[]; since: number; mainAgent: string; reviewer: AgentId; context?: string }): string | null {
+  // The reviewer's own turns are never journaled, so every step here is the main agent's,
+  // even when both run on the same harness (Claude reviewing Claude).
+  const recent = o.steps.filter((s) => s.ts > o.since && s.kind !== "handoff" && s.kind !== "thought");
+  const work = recent.filter((s) => s.kind === "tool" || s.kind === "text" || s.kind === "plan");
+  if (!work.length) return null;
+  const users = o.steps.filter((s): s is StepOf<"user"> => s.kind === "user");
+  const request = users.at(-1);
+  const plan = [...o.steps].reverse().find((s): s is StepOf<"plan"> => s.kind === "plan");
+  const out: string[] = [reviewInstructions(o.mainAgent), ""];
+  if (o.context) out.push("## Context (the task so far, recorded by codemax)", o.context, "");
+  if (request) out.push("## The user's latest request", request.text.trim().split("\n").map((l) => `> ${l}`).join("\n"), "");
+  if (plan) out.push("## Plan", ...plan.entries.map((e) => `${e.status === "completed" ? "[x]" : e.status === "in_progress" ? "[~]" : "[ ]"} ${e.content}`), "");
+  out.push("## Latest work to review (oldest first)", ...recent.map((s) => formatStep(s)).filter((l): l is string => !!l));
+  return out.join("\n");
+}
+
+/** The note, or null when the reviewer had nothing to say. */
+export function parseNote(reply: string): string | null {
+  const t = reply.trim();
+  if (!t || t.includes(NO_NOTE) || t.length < 40) return null;
+  const at = t.indexOf("Heads up");
+  return (at > 0 ? t.slice(at) : t).trim();
+}
+
+/** Forwarded notes start with this; they are follow-ups, never a new task, and never reviewed. */
+export const NOTE_PREFIX = "A side agent (";
+
+export function isForwardedNote(text: string): boolean {
+  return text.startsWith(NOTE_PREFIX);
+}
+
+/** The message that hands a note to the main agent. */
+export function forwardMessage(note: string, reviewerName: string): string {
+  return `${NOTE_PREFIX}${reviewerName}) reviewing your work left this note. Weigh it against the user's request and plan: say in a sentence whether you agree, and adjust your work if it is right.\n\n${note}`;
+}

package/src/core/spawn.ts

@@ -0,0 +1,20 @@
+/*
+ * Cross-platform process arguments. On macOS and Linux these return argv
+ * unchanged. On Windows, CLIs installed through npm are `.cmd` shims that
+ * cannot be started directly, so they are resolved through PATH/PATHEXT and
+ * run via cmd.exe; shell commands go to cmd.exe instead of sh.
+ */
+export const IS_WINDOWS = process.platform === "win32";
+
+/** argv ready for Bun.spawn on this platform. */
+export function platformArgv(argv: string[]): string[] {
+  if (!IS_WINDOWS || argv.length === 0) return argv;
+  const [bin, ...rest] = argv as [string, ...string[]];
+  const path = Bun.which(bin) ?? bin;
+  return /\.(cmd|bat)$/i.test(path) ? ["cmd.exe", "/d", "/s", "/c", path, ...rest] : [path, ...rest];
+}
+
+/** argv that runs one shell command line (`!cmd` in the chat). */
+export function shellArgv(cmd: string): string[] {
+  return IS_WINDOWS ? ["cmd.exe", "/d", "/s", "/c", cmd] : ["sh", "-c", cmd];
+}

package/src/core/terminal.ts

@@ -0,0 +1,51 @@
+export const ESC = "\x1b";
+export const CSI = `${ESC}[`;
+
+/**
+ * Put the host terminal back into a sane state after an agent TUI dies.
+ * Agents killed mid-run do not restore anything, so undo every mode a modern
+ * TUI may have switched on: alt screen, mouse, bracketed paste, focus events,
+ * synchronized output, the kitty keyboard protocol and xterm modifyOtherKeys.
+ */
+export const RESET_SEQ = [
+  `${CSI}?2004l`, // bracketed paste off
+  `${CSI}?1000l${CSI}?1002l${CSI}?1003l${CSI}?1005l${CSI}?1006l${CSI}?1015l`, // mouse tracking off
+  `${CSI}?1004l`, // focus events off
+  `${CSI}?2026l`, // synchronized output off
+  `${CSI}<u${CSI}<u${CSI}<u${CSI}<u`, // pop kitty keyboard flags (no-op where unsupported)
+  `${CSI}=0;1u`, // kitty keyboard flags = 0
+  `${CSI}>4;0m`, // xterm modifyOtherKeys off
+  `${CSI}?1l`, // normal cursor keys
+  `${ESC}>`, // numeric keypad
+  `${CSI}?1049l`, // leave alt screen
+  `${CSI}!p`, // DECSTR soft reset (scroll region, origin mode, SGR, cursor visible)
+  `${CSI}r`, // scroll region = full screen
+  `${CSI}?25h`, // show cursor
+  `${CSI}?7h`, // autowrap on
+  `${CSI}0m`, // reset attrs
+].join("");
+
+/** Clear the screen and home the cursor; used before a new agent draws. */
+export const CLEAR_SEQ = `${CSI}2J${CSI}H`;
+
+export const ALT_ON = `${CSI}?1049h${CSI}?25l${CSI}H${CSI}2J`;
+export const ALT_OFF = `${CSI}?25h${CSI}?1049l`;
+
+export const PASTE_START = `${CSI}200~`;
+export const PASTE_END = `${CSI}201~`;
+
+export function stripAnsi(s: string): string {
+  // CSI, OSC, and single-char escapes.
+  return s
+    .replace(/\x1b\][^\x07\x1b]*(\x07|\x1b\\)/g, "")
+    .replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "")
+    .replace(/\x1b[@-Z\\-_]/g, "");
+}
+
+export function termSize(): { cols: number; rows: number } {
+  return { cols: process.stdout.columns || 80, rows: process.stdout.rows || 24 };
+}
+
+export const out = (s: string) => {
+  process.stdout.write(s);
+};

package/src/core/update.ts

@@ -0,0 +1,90 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join, resolve, sep } from "node:path";
+import { CODEMAX_HOME, ensureDir } from "./paths.ts";
+
+/**
+ * Update checks and self-update. At most every 12 hours (3 s timeout, never
+ * blocking startup) codemax asks for the newest version from the place its own
+ * update comes from: npm for npm installs, GitHub releases for the installer,
+ * source checkouts and standalone builds. So a release is only offered where
+ * `/update` can actually fetch it. `/update` / `codemax update` then updates
+ * the way codemax was installed.
+ */
+const REGISTRY = "https://registry.npmjs.org/codemax-cli/latest";
+const RELEASES = "https://api.github.com/repos/SkidGod4444/codemax-cli/releases/latest";
+const CHECK_EVERY_MS = 12 * 60 * 60 * 1000;
+const CACHE = () => join(CODEMAX_HOME, "update-check.json");
+
+export type InstallKind = "npm" | "script" | "source" | "binary";
+
+/** How this codemax was installed, judged from where its code lives. */
+export function installKind(root = resolve(import.meta.dir, "..", "..")): { kind: InstallKind; root: string } {
+  if (root.includes("$bunfs") || root.startsWith("/$bunfs") || root.startsWith("B:\\~BUN")) return { kind: "binary", root };
+  if (root.includes(`${sep}node_modules${sep}codemax-cli`) || root.includes("/node_modules/codemax-cli")) return { kind: "npm", root };
+  if (existsSync(join(root, ".git")) && /[\\/]\.codemax[\\/]cli$/.test(root)) return { kind: "script", root };
+  if (existsSync(join(root, ".git"))) return { kind: "source", root };
+  return { kind: "npm", root };
+}
+
+/** a > b for x.y.z versions (pre-release suffixes ignored). */
+export function isNewer(a: string, b: string): boolean {
+  const p = (v: string) => v.replace(/^v/, "").split("-")[0]!.split(".").map((n) => Number(n) || 0);
+  const [x, y] = [p(a), p(b)];
+  for (let i = 0; i < 3; i++) if ((x[i] ?? 0) !== (y[i] ?? 0)) return (x[i] ?? 0) > (y[i] ?? 0);
+  return false;
+}
+
+export async function latestVersion(source: "npm" | "github" = "npm", fetchImpl: typeof fetch = fetch, timeoutMs = 3000): Promise<string | null> {
+  try {
+    const res = await fetchImpl(source === "npm" ? REGISTRY : RELEASES, { signal: AbortSignal.timeout(timeoutMs), headers: { accept: source === "npm" ? "application/json" : "application/vnd.github+json" } });
+    if (!res.ok) return null;
+    const body = (await res.json()) as { version?: unknown; tag_name?: unknown };
+    const v = String((source === "npm" ? body.version : body.tag_name) ?? "").replace(/^v/, "");
+    return /^\d+\.\d+\.\d+/.test(v) ? v : null;
+  } catch {
+    return null;
+  }
+}
+
+/** Where this install's updates come from. */
+export function updateSource(kind: InstallKind = installKind().kind): "npm" | "github" {
+  return kind === "npm" ? "npm" : "github";
+}
+
+/** The latest version when it is newer than `current`; null otherwise. Cached for 12 hours. */
+export async function checkForUpdate(current: string, o: { force?: boolean; fetchImpl?: typeof fetch; source?: "npm" | "github" } = {}): Promise<string | null> {
+  const source = o.source ?? updateSource();
+  let cached: { at: number; latest: string | null; source?: string } | null = null;
+  try {
+    cached = existsSync(CACHE()) ? JSON.parse(readFileSync(CACHE(), "utf8")) : null;
+  } catch {
+    cached = null;
+  }
+  let latest = cached?.latest ?? null;
+  if (o.force || !cached || cached.source !== source || Date.now() - cached.at > CHECK_EVERY_MS) {
+    latest = await latestVersion(source, o.fetchImpl);
+    try {
+      ensureDir(CODEMAX_HOME);
+      writeFileSync(CACHE(), JSON.stringify({ at: Date.now(), latest, source }) + "\n");
+    } catch {
+      /* read-only home: check again next time */
+    }
+  }
+  return latest && isNewer(latest, current) ? latest : null;
+}
+
+/** The command that updates this install, or null with an explanation when it cannot update itself. */
+export function updatePlan(install = installKind(), platform = process.platform): { cmd: string[][]; env?: Record<string, string>; manual?: string; label: string } {
+  switch (install.kind) {
+    case "npm":
+      return { cmd: [["npm", "install", "-g", "codemax-cli@latest"]], label: "npm install -g codemax-cli@latest" };
+    case "script":
+      return platform === "win32"
+        ? { cmd: [["powershell", "-NoProfile", "-ExecutionPolicy", "Bypass", "-File", join(install.root, "install.ps1")]], env: { CODEMAX_DIR: install.root }, label: "the codemax installer (newest release)" }
+        : { cmd: [["bash", join(install.root, "install.sh")]], env: { CODEMAX_DIR: install.root }, label: "the codemax installer (newest release)" };
+    case "source":
+      return { cmd: [["git", "-C", install.root, "pull", "--ff-only"], ["bun", "install", "--cwd", install.root]], label: `git pull in ${install.root}` };
+    case "binary":
+      return { cmd: [], manual: "This is a standalone build; download the new release from https://github.com/SkidGod4444/codemax-cli/releases or switch to `npm install -g codemax-cli`.", label: "manual download" };
+  }
+}

package/src/core/usage.ts

@@ -0,0 +1,116 @@
+import type { AgentId } from "../adapters/types.ts";
+import { estimateCost, fmtTokens, fmtUsd, priceFor, priceProvenance } from "./pricing.ts";
+
+/** One usage sample: a model call, a turn, or a delta reported by the agent. */
+export interface UsageRecord {
+  ts: number;
+  agent: AgentId;
+  sessionId: string;
+  model?: string;
+  input: number;
+  output: number;
+  cacheRead: number;
+  cacheWrite: number;
+  /** Cost the agent itself reported (OpenCode, Grok do). */
+  agentCostUsd?: number;
+  /** USD frozen at record time so later price changes do not rewrite history. */
+  costUsd?: number;
+  /** Where that figure came from: "agent", "user", "openrouter@2026-10-18", "builtin@…", or "none". */
+  priceSource?: string;
+}
+
+/** Price a fresh record now and freeze the result on it. */
+export function priceRecord(r: UsageRecord): UsageRecord {
+  if (typeof r.agentCostUsd === "number") return { ...r, costUsd: r.agentCostUsd, priceSource: "agent" };
+  const hit = priceFor(r.model);
+  const est = estimateCost(r.model, r);
+  if (hit && est !== null) {
+    const prov = priceProvenance();
+    return { ...r, costUsd: est, priceSource: hit.source === "user" ? "user" : hit.source === "builtin" ? `builtin@${prov.source === "builtin" ? prov.asOf : "2026-10-18"}` : `${hit.source}@${prov.asOf}` };
+  }
+  return { ...r, costUsd: undefined, priceSource: "none" };
+}
+
+export interface UsageTotals {
+  agent: AgentId;
+  models: Set<string>;
+  calls: number;
+  input: number;
+  output: number;
+  cacheRead: number;
+  cacheWrite: number;
+  /** API-equivalent USD: agent-reported where available, else estimated from list prices. */
+  costUsd: number;
+  /** True when some records had no price and were counted at $0. */
+  partial: boolean;
+}
+
+export function recordCost(r: UsageRecord): { usd: number; known: boolean } {
+  if (typeof r.agentCostUsd === "number") return { usd: r.agentCostUsd, known: true };
+  if (typeof r.costUsd === "number") return { usd: r.costUsd, known: true };
+  if (r.priceSource === "none") return { usd: 0, known: false };
+  const est = estimateCost(r.model, r); // legacy records without a frozen cost
+  return est === null ? { usd: 0, known: !(r.input || r.output || r.cacheRead || r.cacheWrite) } : { usd: est, known: true };
+}
+
+export function totalsByAgent(records: UsageRecord[]): UsageTotals[] {
+  const map = new Map<AgentId, UsageTotals>();
+  for (const r of records) {
+    let t = map.get(r.agent);
+    if (!t) {
+      t = { agent: r.agent, models: new Set(), calls: 0, input: 0, output: 0, cacheRead: 0, cacheWrite: 0, costUsd: 0, partial: false };
+      map.set(r.agent, t);
+    }
+    if (r.model) t.models.add(r.model);
+    t.calls++;
+    t.input += r.input;
+    t.output += r.output;
+    t.cacheRead += r.cacheRead;
+    t.cacheWrite += r.cacheWrite;
+    const c = recordCost(r);
+    t.costUsd += c.usd;
+    if (!c.known) t.partial = true;
+  }
+  return [...map.values()].sort((a, b) => b.costUsd - a.costUsd);
+}
+
+export function sumCost(records: UsageRecord[]): number {
+  return records.reduce((s, r) => s + recordCost(r).usd, 0);
+}
+
+/** Plain-text table for /usage and `codemax usage`. */
+export function renderUsageTable(records: UsageRecord[], opts: { title: string; sessionId?: string }): string[] {
+  const rows = totalsByAgent(records);
+  const lines: string[] = [];
+  lines.push(`${opts.title} · API-equivalent value at list prices (your subscriptions covered this)`);
+  if (!rows.length) {
+    lines.push("  no usage recorded yet");
+    return lines;
+  }
+  const head = ["agent", "calls", "input", "output", "cache read", "cache write", "est. cost"];
+  const data = rows.map((t) => [
+    t.agent + (t.models.size ? ` (${[...t.models].map(shortModel).join(", ")})` : ""),
+    String(t.calls),
+    fmtTokens(t.input),
+    fmtTokens(t.output),
+    fmtTokens(t.cacheRead),
+    fmtTokens(t.cacheWrite),
+    fmtUsd(t.costUsd) + (t.partial ? "*" : ""),
+  ]);
+  const total = ["total", String(rows.reduce((s, t) => s + t.calls, 0)), fmtTokens(rows.reduce((s, t) => s + t.input, 0)), fmtTokens(rows.reduce((s, t) => s + t.output, 0)), fmtTokens(rows.reduce((s, t) => s + t.cacheRead, 0)), fmtTokens(rows.reduce((s, t) => s + t.cacheWrite, 0)), fmtUsd(rows.reduce((s, t) => s + t.costUsd, 0))];
+  const all = [head, ...data, total];
+  const w = head.map((_, i) => Math.max(...all.map((r) => r[i]!.length)));
+  const fmt = (r: string[]) => "  " + r.map((c, i) => (i === 0 ? c.padEnd(w[i]!) : c.padStart(w[i]!))).join("  ");
+  lines.push(fmt(head));
+  for (const r of data) lines.push(fmt(r));
+  lines.push(fmt(total));
+  if (rows.some((t) => t.partial)) lines.push("  * includes calls on a model with no known price; set it in ~/.codemax/prices.json");
+  const prov = priceProvenance();
+  const agentPriced = records.filter((r) => typeof r.agentCostUsd === "number").length;
+  lines.push(`  prices: ${prov.source} list as of ${prov.asOf}${agentPriced ? ` · ${agentPriced} calls priced by the agent itself` : ""} · each call keeps the rate it was recorded at`);
+  return lines;
+}
+
+export function shortModel(m: string): string {
+  return m.replace(/^claude-/, "").replace(/^(anthropic|openai|xai|google|opencode)\//, "");
+}