codemax-cli 0.1.4 → 0.1.5

package/src/chat/models.ts

@@ -31,3 +31,28 @@ export function sortModels<T extends ModelEntry>(models: T[]): T[] {
     })
     .map((x) => x.m);
 }
+
+/**
+ * The one way a model is shown anywhere in codemax: the agent's own display name
+ * ("Opus 5.5"), never its id ("opus", "claude-opus-5-5"). When the agent's list
+ * does not have the id (a model reported in usage, a saved side-agent model), a
+ * Claude id is spelled out the same way ("claude-opus-5-5" → "Opus 5.5").
+ */
+export function displayModelName(id: string | undefined, models: ModelEntry[] = []): string {
+  if (!id) return "Default";
+  // Cursor appends settings in brackets: "claude-opus-5-5[context=300k,effort=medium]".
+  const bare = id.replace(/\[.*\]$/, "").replace(/^(anthropic|openai|xai|google|opencode)\//, "");
+  const listed = models.find((m) => m.id === id) ?? models.find((m) => m.id === bare);
+  const tidy = (n: string) => n.replace(/\s*\((recommended|default)\)\s*$/i, "");
+  if (listed && listed.name && listed.name !== listed.id) return tidy(listed.name);
+  if (!bare || /^(default|auto)$/i.test(bare)) return bare.toLowerCase() === "auto" ? "Auto" : "Default";
+  const claude = bare.match(/^(?:claude-)?(opus|sonnet|haiku|fable)(?:-(\d{1,2})(?:[-.](\d{1,2}))?)?(?:-\d{8})?$/i);
+  if (claude) {
+    const family = claude[1]![0]!.toUpperCase() + claude[1]!.slice(1).toLowerCase();
+    if (claude[2]) return `${family} ${claude[2]}${claude[3] ? `.${claude[3]}` : ""}`;
+    // A bare alias ("opus"): the listed model of that family names its version.
+    const sameFamily = sortModels(models).find((m) => new RegExp(`^${family}\\b`, "i").test(m.name));
+    return sameFamily ? tidy(sameFamily.name) : family;
+  }
+  return listed?.name ?? bare;
+}

package/src/chat/notes.ts

@@ -0,0 +1,101 @@
+import { BoxRenderable, TextRenderable, type CliRenderer } from "@opentui/core";
+import { styleMarkdown } from "./markdown.ts";
+import { C } from "./theme.ts";
+
+export interface PendingNote {
+  name: string;
+  text: string;
+}
+
+/**
+ * Side-agent notes wait here, pinned above the prompt (with the queue), until
+ * you act on one:
+ *
+ *   ╭──────────────────────────────────────────────────────────╮
+ *   │ ⚑ Heads up from Codex · 1 of 2                           │
+ *   │ The tests only ran once, so a flaky pass would ship.      │
+ *   │ 1 expand · 2 discuss with Claude Code · 0 dismiss (type the number and pause) │
+ *   ╰──────────────────────────────────────────────────────────╯
+ *
+ * A digit is always typed into the prompt first. Only when the prompt holds just
+ * that digit and you pause does it act on the note, so "2 more tests please"
+ * is a message, never a forwarded note.
+ */
+export class NotePanel {
+  readonly box: BoxRenderable;
+  private notes: PendingNote[] = [];
+  private expanded = false;
+  /** The main agent just asked you something: a lone digit is your answer, so the keys pause. */
+  private paused = false;
+
+  constructor(
+    private renderer: CliRenderer,
+    private mainName: () => string,
+  ) {
+    this.box = new BoxRenderable(renderer, { id: "notes", width: "100%", flexShrink: 0, flexDirection: "column", border: true, borderStyle: "rounded", borderColor: C.warn, paddingX: 1 });
+    this.box.visible = false;
+  }
+
+  get count() {
+    return this.notes.length;
+  }
+
+  get current(): PendingNote | undefined {
+    return this.notes[0];
+  }
+
+  push(n: PendingNote) {
+    this.notes.push(n);
+    this.render();
+  }
+
+  /** Remove the note on show (after it was sent or dismissed); the next one shows. */
+  take(): PendingNote | undefined {
+    const n = this.notes.shift();
+    this.expanded = false;
+    this.render();
+    return n;
+  }
+
+  setPaused(p: boolean) {
+    if (this.paused === p) return;
+    this.paused = p;
+    this.render();
+  }
+
+  get isPaused() {
+    return this.paused;
+  }
+
+  toggle() {
+    this.expanded = !this.expanded;
+    this.render();
+  }
+
+  render() {
+    for (const c of [...this.box.getChildren()]) c.destroyRecursively();
+    const n = this.notes[0];
+    this.box.visible = !!n;
+    if (!n) return;
+    const { headline, body } = splitNote(n.text);
+    const more = this.notes.length > 1 ? ` · 1 of ${this.notes.length}` : "";
+    this.box.borderColor = C.warn;
+    this.box.add(new TextRenderable(this.renderer, { content: `⚑ Heads up from ${n.name}${more}`, fg: C.warn, attributes: 1, wrapMode: "none", truncate: true, width: "100%" } as any));
+    this.box.add(new TextRenderable(this.renderer, { content: headline, wrapMode: "word", width: "100%" }));
+    if (this.expanded && body) {
+      // At most half the screen; the rest of a very long note is cut (it is in the ledger).
+      const room = Math.max(3, Math.floor(this.renderer.height / 2) - 4);
+      this.box.add(new TextRenderable(this.renderer, { content: styleMarkdown(body), wrapMode: "word", width: "100%", height: Math.min(room, body.split("\n").length + Math.ceil(body.length / Math.max(20, this.renderer.width - 6))), truncate: true } as any));
+    }
+    const expand = body ? (this.expanded ? "1 collapse" : "1 expand") : null;
+    if (this.paused) this.box.add(new TextRenderable(this.renderer, { content: `${this.mainName()} asked you something, so 1 · 2 · 0 are your answer for now; the note keys come back after you reply`, fg: C.dim, wrapMode: "word", width: "100%" }));
+    else this.box.add(new TextRenderable(this.renderer, { content: [expand, `2 discuss with ${this.mainName()}`, "0 dismiss"].filter(Boolean).join(" · ") + " (type the number and pause)", fg: C.dim, wrapMode: "word", width: "100%" }));
+  }
+}
+
+/** "Heads up · <one line>" then a body: the line for the collapsed panel, the rest for expand. */
+export function splitNote(text: string): { headline: string; body: string } {
+  const lines = text.trim().split("\n");
+  const first = (lines.shift() ?? "").replace(/^\s*(⚑\s*)?heads up\s*[·:-]\s*/i, "").trim();
+  return { headline: first || "The side agent left a note", body: lines.join("\n").trim() };
+}

package/src/chat/palette.ts

@@ -62,6 +62,11 @@ export class Palette {
   }
 
   setFilter(text: string) {
+    // New text: the best match is highlighted again, so Enter picks it without arrow keys.
+    if (text !== this.filter) {
+      this.cursor = 0;
+      this.offset = 0;
+    }
     this.filter = text;
     const q = text.trim().toLowerCase();
     const scored = this.opts.items
@@ -179,7 +184,15 @@ function score(it: PaletteItem, q: string): number {
   if (label.split(/[:_\-/. ]/).some((w) => w.startsWith(needle))) return 2;
   if (label.includes(needle)) return 1.5;
   if ((it.description ?? "").toLowerCase().includes(needle)) return 1;
-  return 0;
+  // Letters in order ("mdl" → model) still find it, ranked last.
+  return isSubsequence(needle, label) ? 0.5 : 0;
+}
+
+function isSubsequence(needle: string, hay: string): boolean {
+  let i = 0;
+  for (const ch of hay) if (ch === needle[i]) i++;
+  // At least 3 letters, starting with the first: short queries stay exact ("st" is not "switch").
+  return needle.length >= 3 && hay[0] === needle[0] && i === needle.length;
 }
 
 function pad(s: string, n: number): string {

package/src/chat/question.ts

@@ -0,0 +1,192 @@
+import { BoxRenderable, TextRenderable, type CliRenderer, type KeyEvent } from "@opentui/core";
+import type { QuestionAnswer, QuestionField, QuestionRequest } from "../engines/types.ts";
+import { C, G } from "./theme.ts";
+
+/**
+ * An agent's question (Claude's AskUserQuestion, an MCP form), one field at a time:
+ *
+ *   Claude Code has a question · 1 of 2
+ *   [Database] Which database should we use?
+ *   ❯ 1. Postgres         relational, the default
+ *     2. SQLite
+ *     3. Type something else…
+ *
+ * Digits pick (or toggle, in a multi-select); typing goes into the
+ * "something else" box, so a stray letter never picks an option. Esc skips
+ * the question (the agent is told you skipped and carries on).
+ */
+export class QuestionDialog {
+  readonly box: BoxRenderable;
+  private header: TextRenderable;
+  private prompt: TextRenderable;
+  private list: BoxRenderable;
+  private hint: TextRenderable;
+  private index = 0;
+  private cursor = 0;
+  private picked = new Set<string>();
+  private typed = "";
+  private error = "";
+  private content: Record<string, string | number | boolean | string[]> = {};
+
+  constructor(
+    private renderer: CliRenderer,
+    readonly request: QuestionRequest,
+    private agentName: string,
+    private onDone: (a: QuestionAnswer) => void,
+  ) {
+    this.box = new BoxRenderable(renderer, { id: `ask-${request.id}`, width: "100%", flexShrink: 0, border: true, borderStyle: "rounded", borderColor: C.accent, paddingX: 1, flexDirection: "column" });
+    this.header = new TextRenderable(renderer, { content: "", fg: C.accent });
+    this.prompt = new TextRenderable(renderer, { content: "", wrapMode: "word", width: "100%" });
+    this.list = new BoxRenderable(renderer, { width: "100%", flexDirection: "column", flexShrink: 0 });
+    this.hint = new TextRenderable(renderer, { content: "", fg: C.dim, wrapMode: "word", width: "100%" });
+    this.box.add(this.header);
+    this.box.add(this.prompt);
+    this.box.add(new TextRenderable(renderer, { content: "" }));
+    this.box.add(this.list);
+    this.box.add(this.hint);
+    this.render();
+  }
+
+  private get field(): QuestionField {
+    return this.request.fields[this.index]!;
+  }
+
+  /** Rows: the options, then a free-text row when the field takes text. */
+  private get rows(): ({ kind: "option"; value: string; label: string; description?: string } | { kind: "text" })[] {
+    const f = this.field;
+    const text = f.kind === "text" || f.kind === "number" || !!f.otherKey;
+    return [...f.options.map((o) => ({ kind: "option" as const, ...o })), ...(text ? [{ kind: "text" as const }] : [])];
+  }
+
+  private render() {
+    const f = this.field;
+    const n = this.request.fields.length;
+    this.header.content = `${this.agentName} has a question${n > 1 ? ` · ${this.index + 1} of ${n}` : ""}`;
+    this.prompt.content = `${f.title && f.title !== f.question ? `[${f.title}] ` : ""}${f.question || this.request.message}`;
+    for (const c of [...this.list.getChildren()]) c.destroyRecursively();
+    this.rows.forEach((r, i) => {
+      const sel = i === this.cursor;
+      const mark = sel ? G.prompt : " ";
+      if (r.kind === "option") {
+        const box = f.kind === "multi" ? (this.picked.has(r.value) ? "[x] " : "[ ] ") : "";
+        this.list.add(new TextRenderable(this.renderer, { content: ` ${mark} ${i + 1}. ${box}${r.label}`, fg: sel ? C.accent : undefined, wrapMode: "word", width: "100%" }));
+        if (r.description) this.list.add(new TextRenderable(this.renderer, { content: `       ${r.description}`, fg: C.dim, wrapMode: "word", width: "100%" }));
+      } else {
+        const label = f.kind === "text" || f.kind === "number" ? "" : f.kind === "multi" ? "Add your own: " : "Type something else: ";
+        const caret = sel ? "▏" : "";
+        const shown = this.typed ? this.typed + caret : caret || (f.kind === "text" || f.kind === "number" ? "(type your answer)" : "…");
+        this.list.add(new TextRenderable(this.renderer, { content: ` ${mark} ${f.options.length ? `${i + 1}. ` : ""}${label}${shown}`, fg: sel ? C.accent : undefined, wrapMode: "word", width: "100%" }));
+      }
+    });
+    const keys = f.kind === "multi" ? "1-9 or space to tick · Enter when done" : this.rows.length > 1 ? "1-9 or ↑/↓ then Enter" : "Enter to send";
+    this.hint.content = `${this.error ? this.error + " · " : ""}${keys} · Esc to skip${n > 1 && this.index > 0 ? " · shift+tab back" : ""}`;
+    this.hint.fg = this.error ? C.warn : C.dim;
+  }
+
+  /** Always consumes the key (the dialog owns the keyboard while open). */
+  handleKey(key: KeyEvent): boolean {
+    const rows = this.rows;
+    const onText = rows[this.cursor]?.kind === "text";
+    const n = key.name;
+    this.error = "";
+    if (n === "escape") return this.finish({ action: "decline" });
+    if (n === "up") this.cursor = (this.cursor - 1 + rows.length) % rows.length;
+    else if (n === "down" || (n === "tab" && !key.shift)) this.cursor = (this.cursor + 1) % rows.length;
+    else if (n === "tab" && key.shift) this.back();
+    else if (n === "return") return this.enter();
+    else if (n === "backspace" && onText) this.typed = this.typed.slice(0, -1);
+    else if (n === "space" && !onText && this.field.kind === "multi") this.toggle(this.cursor);
+    // Digits pick unless you are typing an answer (an empty answer box still takes digits as picks).
+    else if ((!onText || !this.typed) && /^[1-9]$/.test(n) && rows[Number(n) - 1]?.kind === "option") {
+      const i = Number(n) - 1;
+      this.cursor = i;
+      if (rows[i]!.kind === "option") {
+        if (this.field.kind === "multi") this.toggle(i);
+        else return this.enter();
+      }
+    } else {
+      const ch = key.sequence ?? "";
+      // Typing never picks an option: it goes into the free-text row.
+      if (ch.length >= 1 && !key.ctrl && !key.meta && !/[\x00-\x1f\x7f]/.test(ch)) {
+        const t = rows.findIndex((r) => r.kind === "text");
+        if (t >= 0) {
+          this.cursor = t;
+          this.typed += ch;
+        }
+      }
+    }
+    this.render();
+    return false;
+  }
+
+  private toggle(i: number) {
+    const r = this.rows[i];
+    if (r?.kind !== "option") return;
+    if (this.picked.has(r.value)) this.picked.delete(r.value);
+    else this.picked.add(r.value);
+  }
+
+  private back() {
+    if (this.index === 0) return;
+    this.index--;
+    // Going back re-asks the question, so its earlier answer is dropped.
+    delete this.content[this.field.key];
+    if (this.field.otherKey) delete this.content[this.field.otherKey];
+    this.resetField();
+  }
+
+  private enter(): boolean {
+    const f = this.field;
+    const row = this.rows[this.cursor];
+    const text = this.typed.trim();
+    if (f.kind === "multi") {
+      const picks = [...this.picked];
+      if (picks.length) this.content[f.key] = picks;
+      if (text && f.otherKey) this.content[f.otherKey] = text;
+      if (!picks.length && !text && f.required) return this.complain("pick at least one");
+    } else if (f.kind === "text" || f.kind === "number") {
+      if (!text && f.required) return this.complain("type an answer");
+      if (text && f.kind === "number") {
+        const v = Number(text);
+        if (!Number.isFinite(v) || (f.integer && !Number.isInteger(v))) return this.complain(f.integer ? "type a whole number" : "type a number");
+        this.content[f.key] = v;
+      } else if (text) this.content[f.key] = text;
+    } else if (row?.kind === "option") {
+      this.content[f.key] = f.kind === "boolean" ? row.value === "true" : row.value;
+      // A note typed in "something else" travels with the pick (the agent reads it as a note).
+      if (text && f.otherKey) this.content[f.otherKey] = text;
+    } else {
+      if (!text) return this.complain("type something, or pick an option");
+      if (f.otherKey) this.content[f.otherKey] = text;
+      else this.content[f.key] = text;
+    }
+    if (this.index + 1 < this.request.fields.length) {
+      this.index++;
+      this.resetField();
+      return false;
+    }
+    return this.finish({ action: "accept", content: this.content });
+  }
+
+  private resetField() {
+    this.cursor = 0;
+    this.picked.clear();
+    this.typed = "";
+    this.render();
+  }
+
+  private complain(msg: string): boolean {
+    this.error = msg;
+    this.render();
+    return false;
+  }
+
+  private finish(a: QuestionAnswer): boolean {
+    this.onDone(a);
+    return true;
+  }
+
+  destroy() {
+    this.box.destroyRecursively();
+  }
+}

package/src/chat/subagents.ts

@@ -0,0 +1,107 @@
+import { BoxRenderable, TextRenderable, type CliRenderer } from "@opentui/core";
+import type { SubagentEvent } from "../engines/types.ts";
+import { C, G } from "./theme.ts";
+
+interface Row {
+  id: string;
+  name: string;
+  task?: string;
+  activity?: string;
+  status: "running" | "done" | "failed";
+  startedAt: number;
+  endedAt?: number;
+}
+
+/** Finished agents stay visible this long, then leave the list. */
+const LINGER_MS = 4000;
+const MAX_ROWS = 4;
+
+/**
+ * The agents the main agent spawned (Claude's Task/Agent tool, OpenCode's
+ * task tool…), listed under the prompt the way Claude Code lists them:
+ *
+ *   ⏺ 2 agents running
+ *     ⎿ Explore · find where auth is checked · Grep(requireAuth) · 12s
+ *     ⎿ general-purpose · update the tests · Edit(test/auth.test.ts) · 4s
+ *
+ * Each row shows the agent's type, its task and its latest step. A finished
+ * agent shows ✓ (or ✗) for a few seconds and then leaves the list.
+ */
+export class SubagentPanel {
+  readonly box: BoxRenderable;
+  private rows = new Map<string, Row>();
+  private timer: ReturnType<typeof setInterval> | null = null;
+
+  constructor(private renderer: CliRenderer) {
+    this.box = new BoxRenderable(renderer, { id: "subagents", width: "100%", flexShrink: 0, flexDirection: "column", paddingX: 1 });
+    this.box.visible = false;
+  }
+
+  get running(): number {
+    return [...this.rows.values()].filter((r) => r.status === "running").length;
+  }
+
+  update(e: SubagentEvent) {
+    const prev = this.rows.get(e.id);
+    const row: Row = prev ?? { id: e.id, name: e.name || "agent", status: "running", startedAt: Date.now() };
+    if (e.name) row.name = e.name;
+    if (e.task) row.task = e.task;
+    if (e.activity) row.activity = e.activity;
+    if (e.status) {
+      if (e.status !== "running" && row.status === "running") row.endedAt = Date.now();
+      row.status = e.status;
+    }
+    this.rows.set(e.id, row);
+    this.render();
+  }
+
+  /** The turn ended: anything still marked running is over too. */
+  endAll() {
+    for (const r of this.rows.values()) if (r.status === "running") {
+      r.status = "done";
+      r.endedAt = Date.now();
+    }
+    this.render();
+  }
+
+  clear() {
+    this.rows.clear();
+    this.render();
+  }
+
+  render() {
+    const now = Date.now();
+    for (const [id, r] of this.rows) if (r.endedAt && now - r.endedAt > LINGER_MS) this.rows.delete(id);
+    for (const c of [...this.box.getChildren()]) c.destroyRecursively();
+    const list = [...this.rows.values()];
+    this.box.visible = list.length > 0;
+    if (!list.length) {
+      if (this.timer) clearInterval(this.timer);
+      this.timer = null;
+      return;
+    }
+    // Tick once a second for the elapsed times and to let finished rows leave.
+    this.timer ??= setInterval(() => {
+      try {
+        this.render();
+      } catch {
+        /* never break the screen */
+      }
+    }, 1000);
+    const running = this.running;
+    this.box.add(new TextRenderable(this.renderer, { content: `${G.bullet} ${running ? `${running} agent${running === 1 ? "" : "s"} running` : `${list.length} agent${list.length === 1 ? "" : "s"} finished`}`, fg: running ? C.accent : C.dim, wrapMode: "none", truncate: true, width: "100%" } as any));
+    const shown = [...list.filter((r) => r.status === "running"), ...list.filter((r) => r.status !== "running")].slice(0, MAX_ROWS);
+    for (const r of shown) {
+      const mark = r.status === "done" ? "✓ " : r.status === "failed" ? "✗ " : "";
+      const secs = Math.round(((r.endedAt ?? now) - r.startedAt) / 1000);
+      const parts = [r.name, r.task, r.status === "running" ? r.activity : undefined, `${secs}s`].filter(Boolean).map((p) => String(p).replace(/\s+/g, " ").trim());
+      this.box.add(new TextRenderable(this.renderer, { content: `  ${G.nest} ${mark}${parts.join(" · ")}`, fg: r.status === "failed" ? C.error : r.status === "done" ? C.dim : undefined, wrapMode: "none", truncate: true, width: "100%" } as any));
+    }
+    if (list.length > shown.length) this.box.add(new TextRenderable(this.renderer, { content: `    + ${list.length - shown.length} more`, fg: C.dimmer, wrapMode: "none" } as any));
+  }
+
+  destroy() {
+    if (this.timer) clearInterval(this.timer);
+    this.timer = null;
+  }
+}

package/src/cli.ts

@@ -89,9 +89,10 @@ async function main(argv: string[]) {
         const s = sessions[a.id];
         const q = quota[a.id];
         console.log(
-          `${a.id.padEnd(9)} ${a.name.padEnd(13)} ${d.installed ? `✓ ${d.version ?? ""}`.padEnd(14) : "✗ not found".padEnd(14)} ` +
+          `${a.id.padEnd(12)} ${a.name.padEnd(16)} ${d.installed ? `✓ ${d.version ?? ""}`.padEnd(14) : (d.problem ? "✗ broken" : "✗ not found").padEnd(14)} ` +
             `${s ? `session ${s.id.slice(0, 8)}…` : "no session".padEnd(16)} ${q ? quotaLabel(q) : ""}`,
         );
+        if (d.problem) console.log(`          ${d.problem}`);
       }
       return;
     }

package/src/config.ts

@@ -36,12 +36,22 @@ export interface Config {
   /**
    * Side agent: another agent that reviews the main agent's work after each turn and
    * leaves a note when something needs attention. `forward: "auto"` sends notes to the
-   * main agent by itself; "ask" waits for /forward.
+   * main agent by itself; "ask" shows them above the prompt (1 expand · 2 discuss · 0 dismiss).
    */
-  /** `every`: review every Nth working turn (1 = each turn, 0 = only on /review). Each review is a request on the side agent's plan. */
-  sideAgent: { agent: AgentId | null; forward: "ask" | "auto"; model?: string; every?: number };
+  /** `every`: review every Nth working turn (1 = each turn, 0 = paused). Each review is a request on the side agent's plan. */
+  /** `samePlan`: the user chose to let the side agent review on the main agent's own plan (off unless picked explicitly). */
+  sideAgent: { agent: AgentId | null; forward: "ask" | "auto"; model?: string; every?: number; samePlan?: boolean };
   /** Check npm for a newer codemax at most every 12 hours and offer /update. */
   updateCheck: boolean;
+  /**
+   * Agent questions (Claude's AskUserQuestion, MCP forms): "ask" shows them and waits,
+   * "timeout" skips one left unanswered for 5 minutes (unattended runs), "off" never lets agents ask.
+   */
+  questions?: "ask" | "timeout" | "off";
+  /** Tell the terminal what codemax is doing: Warp's agent badge and status, OSC 7501 elsewhere. */
+  terminalStatus?: boolean;
+  /** Desktop notification when an agent waits for you, or a turn longer than bellAfterSeconds ends, while the terminal is not focused. */
+  notifications?: boolean;
   /** Colour theme: "auto" follows the terminal's background, or force "dark" / "light". */
   theme: "auto" | "dark" | "light";
   /**
@@ -52,7 +62,7 @@ export interface Config {
 }
 
 export const DEFAULT_CONFIG: Config = {
-  order: ["claude", "codex", "opencode", "cursor", "grok", "gemini", "copilot"],
+  order: ["claude", "codex", "opencode", "cursor", "grok", "antigravity", "copilot"],
   hotkeys: ["ctrl+/", "ctrl+^"],
   autoSwitch: true,
   agentArgs: {},
@@ -65,6 +75,9 @@ export const DEFAULT_CONFIG: Config = {
   theme: "auto",
   awake: "off",
   updateCheck: true,
+  questions: "ask",
+  terminalStatus: true,
+  notifications: true,
   sideAgent: { agent: null, forward: "ask" },
   brief: { turns: 10, maxChars: 8000, turnChars: 1200, resumeChars: 24000 },
 };

package/src/core/termstatus.ts

@@ -0,0 +1,124 @@
+import { basename } from "node:path";
+import type { AgentId } from "../adapters/types.ts";
+
+/**
+ * What the terminal around codemax shows about it: the tab's agent badge and
+ * running / waiting / done status, and a notification when you are needed.
+ *
+ * - Warp: its "cli-agent" channel (OSC 777 with the title `warp://cli-agent`
+ *   and a JSON body). Warp only has built-in logos, so the tab shows the agent
+ *   codemax is driving (Claude Code, Codex, OpenCode, Cursor, Copilot, and
+ *   Antigravity under Warp's Gemini badge, Google's closest logo there);
+ *   other agents get status without a badge. Warp raises its own notifications
+ *   from these events, so codemax sends none of its own there.
+ * - Other terminals: OSC 7501 program status (working / blocked / done), which
+ *   terminals that lack it ignore, and a desktop notification when an agent
+ *   waits for you or a long turn ends while the terminal is not focused.
+ *
+ * Every write goes through the renderer (`TerminalSink`), never straight to
+ * stdout, so it can never land inside a frame.
+ */
+export interface TerminalSink {
+  status(s: { state: "idle" | "working" | "blocked" | "done" | "error" | "clear" }): void;
+  notify(message: string, title?: string): void;
+}
+
+/** Agent names Warp has a logo for (checked against Warp 2026.09). */
+export const WARP_AGENTS: Partial<Record<AgentId, string>> = { claude: "claude", codex: "codex", antigravity: "gemini", opencode: "opencode", cursor: "cursor", copilot: "copilot" };
+
+// Warp builds that advertise the protocol but drop it (from Warp's own adapters).
+const WARP_BROKEN: Record<string, string> = { stable: "v0.2026.03.25.08.24.stable_05", preview: "v0.2026.03.25.08.24.preview_05" };
+
+export function warpSupported(env: Record<string, string | undefined> = process.env): boolean {
+  if (!env.WARP_CLI_AGENT_PROTOCOL_VERSION || !env.WARP_CLIENT_VERSION) return false;
+  const channel = Object.keys(WARP_BROKEN).find((c) => env.WARP_CLIENT_VERSION!.includes(c));
+  return !channel || env.WARP_CLIENT_VERSION > WARP_BROKEN[channel]!;
+}
+
+const cut = (s: string, n: number) => (s.length > n ? s.slice(0, n - 3) + "..." : s);
+
+export class TerminalStatus {
+  private agent: { id: AgentId; name: string; session: string } | null = null;
+  private lastQuery = "";
+  private readonly warp: boolean;
+  /** True/false once the terminal reports focus; null when it never has. */
+  focused: boolean | null = null;
+
+  constructor(
+    private sink: TerminalSink,
+    private o: { cwd: string; env?: Record<string, string | undefined>; enabled: () => boolean; notify: () => boolean },
+  ) {
+    this.warp = warpSupported(o.env ?? process.env);
+  }
+
+  /** An agent's session is ready (start, switch, handoff). */
+  started(id: AgentId, name: string, session = "") {
+    this.agent = { id, name, session };
+    this.warpEvent("session_start");
+    this.status("idle");
+  }
+
+  prompt(text: string) {
+    this.lastQuery = text;
+    this.warpEvent("prompt_submit", { query: cut(text, 200) });
+    this.status("working");
+  }
+
+  toolDone(tool: string) {
+    this.warpEvent("tool_complete", { tool_name: tool });
+  }
+
+  /** The agent waits for you: a permission prompt or a question. */
+  waiting(kind: "permission" | "question", summary: string, tool?: string, input?: unknown) {
+    if (kind === "question") this.warpEvent("question_asked", { tool_name: tool ?? "question", summary: cut(summary, 200) });
+    else this.warpEvent("permission_request", { summary: cut(summary, 200), tool_name: tool ?? "tool", tool_input: input ?? {} });
+    this.status("blocked");
+    this.desktop(`${this.agent?.name ?? "The agent"} ${kind === "question" ? "has a question" : "needs your approval"}: ${cut(summary, 120)}`);
+  }
+
+  answered(allowed: boolean) {
+    if (allowed) this.warpEvent("permission_replied");
+    this.status("working");
+  }
+
+  turnEnded(o: { reply: string; ms: number; error?: boolean; longMs: number }) {
+    this.warpEvent("stop", { query: cut(this.lastQuery, 200), response: cut(o.reply, 200), transcript_path: "" });
+    this.status(o.error ? "error" : "done");
+    if (o.ms >= o.longMs) this.desktop(`${this.agent?.name ?? "The agent"} finished: ${cut(o.reply.replace(/\s+/g, " ").trim() || "done", 120)}`);
+  }
+
+  close() {
+    this.status("clear");
+  }
+
+  private status(state: Parameters<TerminalSink["status"]>[0]["state"]) {
+    if (!this.o.enabled()) return;
+    try {
+      this.sink.status({ state });
+    } catch {
+      /* a terminal that refuses it must never break codemax */
+    }
+  }
+
+  private warpEvent(event: string, extra: Record<string, unknown> = {}) {
+    const slug = this.agent && WARP_AGENTS[this.agent.id];
+    if (!this.warp || !slug || !this.o.enabled()) return;
+    const body = { v: 1, agent: slug, event, session_id: this.agent!.session, cwd: this.o.cwd, project: basename(this.o.cwd), ...extra };
+    try {
+      this.sink.notify(JSON.stringify(body), "warp://cli-agent");
+    } catch {
+      /* ignore */
+    }
+  }
+
+  /** A plain desktop notification, only when you are not looking (Warp sends its own). */
+  private desktop(message: string) {
+    if (this.focused === true || !this.o.notify()) return;
+    if (this.warp && this.agent && WARP_AGENTS[this.agent.id] && this.o.enabled()) return;
+    try {
+      this.sink.notify(message, "codemax");
+    } catch {
+      /* ignore */
+    }
+  }
+}

package/src/core/usage.ts

@@ -1,5 +1,6 @@
 import type { AgentId } from "../adapters/types.ts";
 import { estimateCost, fmtTokens, fmtUsd, priceFor, priceProvenance } from "./pricing.ts";
+import { displayModelName } from "../chat/models.ts";
 
 /** One usage sample: a model call, a turn, or a delta reported by the agent. */
 export interface UsageRecord {
@@ -89,7 +90,7 @@ export function renderUsageTable(records: UsageRecord[], opts: { title: string;
   }
   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(", ")})` : ""),
+    t.agent + (t.models.size ? ` (${[...new Set([...t.models].map(shortModel))].join(", ")})` : ""),
     String(t.calls),
     fmtTokens(t.input),
     fmtTokens(t.output),
@@ -111,6 +112,7 @@ export function renderUsageTable(records: UsageRecord[], opts: { title: string;
   return lines;
 }
 
+/** Display name for a recorded model id ("claude-opus-5-5" → "Opus 5.5"), as everywhere else. */
 export function shortModel(m: string): string {
-  return m.replace(/^claude-/, "").replace(/^(anthropic|openai|xai|google|opencode)\//, "");
+  return displayModelName(m);
 }