codemax-cli 0.1.3 → 0.1.5

package/src/chat/models.ts

@@ -0,0 +1,58 @@
+/**
+ * Model menus list exactly what the agent offers, newest first: "Default" /
+ * "Auto" stay on top, then models by the version in their name ("Opus 5.5"
+ * before "Opus 4.6", "GPT-6.1" before "GPT-5.6"); equal versions keep the
+ * agent's own order.
+ */
+export interface ModelEntry {
+  id: string;
+  name: string;
+}
+
+const PINNED = /^(default|auto)\b/i;
+
+/** "Opus 5.5" → 5.5, "GPT-6.1-Sol" → 6.1, "claude-opus-4-7" → 4.7, "Sonnet 5" → 5; none → undefined. */
+export function modelVersion(m: ModelEntry): number | undefined {
+  for (const s of [m.name, m.id]) {
+    // Skip date stamps like 20251001; a version is a small major with an optional minor.
+    const hit = s.match(/(?:^|[^\d])(\d{1,2})(?:[.-](\d{1,2}))?(?=$|[^\d])/);
+    if (hit) return Number(hit[1]) + (hit[2] ? Number(hit[2]) / 100 : 0);
+  }
+  return undefined;
+}
+
+export function sortModels<T extends ModelEntry>(models: T[]): T[] {
+  return models
+    .map((m, i) => ({ m, i, pinned: PINNED.test(m.name) || PINNED.test(m.id), v: modelVersion(m) }))
+    .sort((a, b) => {
+      if (a.pinned !== b.pinned) return a.pinned ? -1 : 1;
+      if (a.v !== b.v) return (b.v ?? -1) - (a.v ?? -1);
+      return a.i - b.i;
+    })
+    .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

@@ -37,6 +37,8 @@ export class Palette {
   private rows: TextRenderable[] = [];
   private titleRow: TextRenderable;
   private cursor = 0;
+  /** First visible row: the window scrolls so every item can be reached with the arrows. */
+  private offset = 0;
   private filter: string;
   private matches: PaletteItem[] = [];
   private maxRows: number;
@@ -60,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
@@ -90,11 +97,16 @@ export class Palette {
 
   render() {
     const { top, width } = this.anchor();
-    const visible = this.matches.slice(0, this.maxRows);
+    // Keep the highlighted row inside the visible window.
+    if (this.cursor < this.offset) this.offset = this.cursor;
+    if (this.cursor >= this.offset + this.maxRows) this.offset = this.cursor - this.maxRows + 1;
+    this.offset = Math.max(0, Math.min(this.offset, this.matches.length - this.maxRows));
+    const visible = this.matches.slice(this.offset, this.offset + this.maxRows);
     const shown = visible.length;
-    const titleLines = this.opts.title ? 1 : 0;
-    this.titleRow.visible = !!this.opts.title;
-    this.titleRow.content = this.opts.title ?? "";
+    const more = this.matches.length > this.maxRows;
+    const titleLines = this.opts.title || more ? 1 : 0;
+    this.titleRow.visible = titleLines > 0;
+    this.titleRow.content = `${this.opts.title ?? ""}${more ? `${this.opts.title ? " · " : ""}${this.cursor + 1}/${this.matches.length} · ↑↓ to scroll` : ""}`;
     this.box.height = shown + titleLines + (shown === 0 ? 1 : 0);
     this.box.top = Math.max(0, top - this.box.height);
     const labelW = Math.min(Math.max(28, Math.floor(width * 0.35)), Math.max(10, ...visible.map((v) => v.label.length + 2)));
@@ -112,7 +124,7 @@ export class Palette {
         return;
       }
       row.visible = true;
-      const sel = i === this.cursor;
+      const sel = this.offset + i === this.cursor;
       const label = pad(it.label, labelW);
       const desc = it.description ?? "";
       const hint = it.hint ? `  ${it.hint}` : "";
@@ -150,7 +162,8 @@ export class Palette {
   }
 
   private move(d: number): boolean {
-    const n = Math.min(this.matches.length, this.maxRows);
+    // Every match is reachable; the window in render() scrolls to follow.
+    const n = this.matches.length;
     if (!n) return true;
     this.cursor = (this.cursor + d + n) % n;
     this.render();
@@ -171,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/chat/theme.ts

@@ -1,3 +1,4 @@
+import { fmtTime12 } from "../core/time.ts";
 /**
  * Glyphs and colours. The codemax brand theme: pink is the accent and nothing
  * else, plum is the one dark ink, and warnings, errors and success keep their
@@ -153,6 +154,7 @@ export function fmtDuration(ms: number): string {
   return `${m}m ${s - m * 60}s`;
 }
 
+/** 12-hour, always ("7:25 PM"). */
 export function fmtTime(ts: number): string {
-  return new Date(ts).toLocaleTimeString([], { hour: "numeric", minute: "2-digit" });
+  return fmtTime12(ts);
 }

package/src/chat/transcript.ts

@@ -1,6 +1,7 @@
 import { BoxRenderable, ScrollBoxRenderable, StyledText, TextRenderable, fg, italic, strikethrough, stringToStyledText, type CliRenderer, type TextChunk } from "@opentui/core";
 import { C, G } from "./theme.ts";
 import { styleMarkdown, styleToolOutput } from "./markdown.ts";
+import { fmtTime12 } from "../core/time.ts";
 
 export interface PlanEntry {
   content: string;
@@ -109,9 +110,11 @@ export class Transcript {
     this.scrollToEnd();
   }
 
-  user(text: string) {
+  /** Your message, with the time it was sent ("· 7:25 PM", 12-hour). */
+  user(text: string, ts = Date.now()) {
     this.gap();
-    this.line(`${G.prompt} `, text, { fg: undefined, glyphFg: C.accent });
+    const node = this.line(`${G.prompt} `, text, { fg: undefined, glyphFg: C.accent });
+    node.content = new StyledText([...stringToStyledText(text).chunks, fg(C.dimmer)(`  · ${fmtTime12(ts)}`)]);
   }
 
   note(text: string, fg_: string = C.dim) {

package/src/cli.ts

@@ -18,6 +18,7 @@ import { diagnose } from "./core/doctor.ts";
 import { renderUsageTable, sumCost } from "./core/usage.ts";
 import { fmtUsd, priceFor, priceProvenance, resetPriceCache } from "./core/pricing.ts";
 import { fetchLivePrices, loadLivePrices, LIVE_PRICES_PATH } from "./core/prices-live.ts";
+import { fmtDateTime12 } from "./core/time.ts";
 
 const HELP = `codemax — one terminal for all your coding agents
 
@@ -73,9 +74,9 @@ async function main(argv: string[]) {
         const orch = new Orchestrator(config, ledger, cwd);
         await orch.start(agent, args.includes("--fresh"));
       } else if (args.includes("--tui") || !hasEngine(agent)) {
-        await runApp(config, ledger, cwd, agent, args.includes("--fresh"));
+        await runApp(config, ledger, cwd, agent, args.includes("--fresh"), !!agentFlag);
       } else {
-        await runChat(config, ledger, cwd, agent, args.includes("--fresh"), !agentFlag);
+        await runChat(config, ledger, cwd, agent, args.includes("--fresh"), !agentFlag, !!agentFlag);
       }
       process.exit(0);
     }
@@ -88,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;
     }
@@ -105,7 +107,7 @@ async function main(argv: string[]) {
       const last = events.slice(-5);
       if (last.length) {
         console.log("recent events:");
-        for (const e of last) console.log(`  ${new Date(e.ts).toLocaleString()}  ${e.kind}  ${e.agent ?? ""}${e.to ? ` → ${e.to}` : ""}  ${e.detail ?? ""}`);
+        for (const e of last) console.log(`  ${fmtDateTime12(e.ts)}  ${e.kind}  ${e.agent ?? ""}${e.to ? ` → ${e.to}` : ""}  ${e.detail ?? ""}`);
       }
       return;
     }
@@ -114,7 +116,7 @@ async function main(argv: string[]) {
       const turns = new Ledger(cwd).turns().slice(-n);
       for (const t of turns) {
         const who = t.role === "user" ? "USER" : `${t.agent.toUpperCase()}`;
-        console.log(`\n[${new Date(t.ts).toLocaleTimeString()}] ${who}${t.tools?.length ? ` (tools: ${t.tools.join(", ")})` : ""}\n${t.text.slice(0, 600)}`);
+        console.log(`\n[${fmtDateTime12(t.ts)}] ${who}${t.tools?.length ? ` (tools: ${t.tools.join(", ")})` : ""}\n${t.text.slice(0, 600)}`);
       }
       return;
     }
@@ -218,7 +220,7 @@ async function main(argv: string[]) {
       }
       const all = ledger.quota();
       if (!Object.keys(all).length) return console.log("no quota state recorded");
-      for (const q of Object.values(all)) console.log(`${q.agent.padEnd(9)} ${quotaLabel(q) || "ok"}  (${q.source}, ${new Date(q.at).toLocaleString()}${q.detail ? `, ${q.detail}` : ""})`);
+      for (const q of Object.values(all)) console.log(`${q.agent.padEnd(9)} ${quotaLabel(q) || "ok"}  (${q.source}, ${fmtDateTime12(q.at)}${q.detail ? `, ${q.detail}` : ""})`);
       return;
     }
     case "keys": {