codemax-cli 0.1.3 → 0.1.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codemax-cli",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "One terminal for every coding agent you pay for: drive Claude Code, Codex, OpenCode, Grok and Gemini CLI from one chat, on your subscriptions, with context that survives switching agents.",
   "keywords": [
     "acp",

package/src/adapters/index.ts

@@ -3,19 +3,25 @@ import { claude } from "./claude.ts";
 import { codex } from "./codex.ts";
 import { opencode, cursor, grok, gemini, copilot, fake } from "./simple.ts";
 
-const all: Adapter[] = [claude, codex, opencode, cursor, grok, gemini, copilot];
-if (process.env.CODEMAX_FAKE_AGENT) all.push(fake);
+const real: Adapter[] = [claude, codex, opencode, cursor, grok, gemini, copilot];
 
-export const adapters: Record<string, Adapter> = Object.fromEntries(all.map((a) => [a.id, a]));
+/**
+ * The adapters, read at call time: tests set CODEMAX_FAKE_AGENT after another
+ * test file may already have imported this module (bun runs all files in one
+ * process), so the fake agent must not be decided once at import.
+ */
+function all(): Adapter[] {
+  return process.env.CODEMAX_FAKE_AGENT ? [...real, fake] : real;
+}
 
 export function getAdapter(id: string): Adapter {
-  const a = adapters[id];
-  if (!a) throw new Error(`unknown agent "${id}". Known: ${Object.keys(adapters).join(", ")}`);
+  const a = all().find((x) => x.id === id);
+  if (!a) throw new Error(`unknown agent "${id}". Known: ${all().map((x) => x.id).join(", ")}`);
   return a;
 }
 
 export function listAdapters(order: AgentId[]): Adapter[] {
-  const ranked = order.map((id) => adapters[id]).filter((a): a is Adapter => !!a);
-  const rest = all.filter((a) => !ranked.includes(a));
-  return [...ranked, ...rest];
+  const list = all();
+  const ranked = order.map((id) => list.find((a) => a.id === id)).filter((a): a is Adapter => !!a);
+  return [...ranked, ...list.filter((a) => !ranked.includes(a))];
 }

package/src/chat/app.ts

@@ -31,6 +31,8 @@ import { Awake, defaultAwakeDeps, recoverAwake } from "../core/awake.ts";
 import { buildReviewPrompt, forwardMessage, isForwardedNote, parseNote } from "../core/review.ts";
 import { logoLines } from "./logo.ts";
 import { checkForUpdate, updatePlan } from "../core/update.ts";
+import { sortModels } from "./models.ts";
+import { fmtDateTime12 } from "../core/time.ts";
 
 const HOTKEY_NAMES: Record<string, string[]> = { "/": ["/", "_", "?"], "^": ["^", "6"] };
 const VERSION = pkg.version;
@@ -42,7 +44,8 @@ interface Active {
   agent: AgentId;
   name: string;
   engine: Engine;
-  turn: { block: AgentBlock; tools: Set<string>; startedAt: number; tokens: number; chars: number; verb: string; rec?: TurnRecorder } | null;
+  /** `model`: the model the agent reported for this turn (usage), when it does. */
+  turn: { block: AgentBlock; tools: Set<string>; startedAt: number; tokens: number; chars: number; verb: string; rec?: TurnRecorder; model?: string } | null;
   replay: AgentBlock | null;
   unsubscribe: () => void;
   mode?: string;
@@ -74,6 +77,7 @@ export class ChatApp {
   private input: TextareaRenderable;
   private inputWrap: BoxRenderable;
   private dialogHost: BoxRenderable;
+  private queueBox!: BoxRenderable;
   private footerText: TextRenderable;
   private shortcuts: BoxRenderable;
   private flash = "";
@@ -99,6 +103,8 @@ export class ChatApp {
   /** Side agent (/side): reviews the main agent's work after each turn. */
   private reviewer: { agent: AgentId; name: string; engine: Engine; busy: boolean; pending: boolean; since: number; primed: boolean } | null = null;
   private notes: { ts: number; agent: AgentId; name: string; text: string }[] = [];
+  /** Plan limits each agent reported, by window ("five_hour", "seven_day"…). */
+  private planLimits = new Map<AgentId, Map<string, { usedPercent?: number; resetsAt?: number; status?: string; at: number }>>();
   /** Working turns since the side agent last reviewed (for `sideAgent.every`). */
   private turnsSinceReview = 0;
   /** Notes sent automatically per task (auto mode is capped so the two agents cannot loop). */
@@ -135,6 +141,10 @@ export class ChatApp {
     root.add(this.working);
     this.dialogHost = new BoxRenderable(renderer, { id: "dialog-host", width: "100%", flexShrink: 0, flexDirection: "column" });
     root.add(this.dialogHost);
+    // Queued messages wait here, pinned just above the prompt, until they are sent.
+    this.queueBox = new BoxRenderable(renderer, { id: "queue", width: "100%", flexShrink: 0, flexDirection: "column", paddingX: 1 });
+    this.queueBox.visible = false;
+    root.add(this.queueBox);
     this.inputWrap = new BoxRenderable(renderer, { id: "input-wrap", width: "100%", flexShrink: 0, flexDirection: "column", border: ["top", "bottom"], borderStyle: "single", borderColor: C.accent });
     const inputRow = new BoxRenderable(renderer, { id: "input-row", width: "100%", flexDirection: "row" });
     inputRow.add(new TextRenderable(renderer, { id: "input-prompt", content: `${G.prompt} `, width: 2, fg: C.accent }));
@@ -188,7 +198,8 @@ export class ChatApp {
     this.renderFooter();
   }
 
-  async start(agent: AgentId, fresh: boolean, o: { pick?: boolean } = {}) {
+  /** `explicit`: the user named this agent (--agent), so never start a different one. */
+  async start(agent: AgentId, fresh: boolean, o: { pick?: boolean; explicit?: boolean } = {}) {
     try {
       this.today = spendToday();
     } catch {
@@ -196,6 +207,7 @@ export class ChatApp {
     }
     await this.refreshDetect();
     const ok = (a: AgentId) => this.detect.get(a)?.installed && this.detect.get(a)?.engine;
+    if (!ok(agent) && o.explicit) throw new Error(`${agent} is ${this.detect.get(agent)?.installed ? "installed but has no protocol engine (try codemax --tui --agent " + agent + ")" : "not installed"}. Available: ${listAdapters(this.config.order).filter((a) => ok(a.id)).map((a) => a.id).join(", ") || "none"}`);
     const first = ok(agent) ? agent : listAdapters(this.config.order).find((a) => ok(a.id))?.id;
     if (!first) throw new Error("no agent with a protocol engine found (need claude, codex, opencode, grok or gemini on PATH)");
     const notes: string[] = [];
@@ -393,9 +405,7 @@ export class ChatApp {
     const busy = !!this.active?.turn;
     const immediate = /^\/(quit|exit|q|help|status|usage|cost|diff|clear|switch|agents)\b/.test(text);
     if (busy && !immediate && (text.startsWith("/") || text.startsWith("!"))) {
-      this.queue.push(text);
-      this.transcript.note(`queued until the turn ends: ${text.slice(0, 60)}`, C.dim);
-      this.renderFooter();
+      this.enqueue(text);
       return;
     }
     if (text.startsWith("/")) return this.command(text);
@@ -407,8 +417,7 @@ export class ChatApp {
     const route = this.routeFor(text);
     if (route && route !== this.active.agent && !this.active.turn) return this.askAgent(route, text, `routed to ${route} by rule`);
     if (this.active.turn) {
-      this.queue.push(text);
-      this.transcript.note(`queued: ${text.slice(0, 80)}${text.length > 80 ? "…" : ""}`, C.dim);
+      this.enqueue(text);
       return;
     }
     await this.send(this.active, text);
@@ -650,6 +659,26 @@ export class ChatApp {
     return true;
   }
 
+  /** Queue a message (or command) until the agent's turn ends; it shows above the prompt. */
+  private enqueue(text: string) {
+    this.queue.push(text);
+    this.renderQueue();
+    this.renderFooter();
+  }
+
+  private renderQueue() {
+    this.safely("queue", () => {
+      for (const child of this.queueBox.getChildren()) child.destroyRecursively();
+      const show = this.queue.slice(0, 3);
+      for (const [i, q] of show.entries()) {
+        const line = q.startsWith("A side agent (") ? "side-agent note for the main agent" : q.replace(/\s+/g, " ");
+        this.queueBox.add(new TextRenderable(this.renderer, { id: `queue-${Date.now()}-${i}`, content: `${G.prompt} ${line}`, fg: C.dim, wrapMode: "none", truncate: true, width: "100%" } as any));
+      }
+      if (this.queue.length > show.length) this.queueBox.add(new TextRenderable(this.renderer, { id: `queue-more-${Date.now()}`, content: `  + ${this.queue.length - show.length} more queued`, fg: C.dimmer }));
+      this.queueBox.visible = this.queue.length > 0;
+    });
+  }
+
   /** Run one queued entry the same way as if it had just been typed. */
   private async dispatch(active: Active, text: string) {
     if (text.startsWith("!")) return this.shell(text.slice(1).trim());
@@ -658,7 +687,11 @@ export class ChatApp {
   }
 
   private async drainQueue(active: Active) {
-    while (this.queue.length && this.active === active && !active.turn) await this.dispatch(active, this.queue.shift()!);
+    while (this.queue.length && this.active === active && !active.turn) {
+      const next = this.queue.shift()!;
+      this.renderQueue();
+      await this.dispatch(active, next);
+    }
     this.renderFooter();
   }
 
@@ -772,11 +805,17 @@ export class ChatApp {
     const name = raw!.toLowerCase();
     const b = this.builtins().find((x) => x.name === name || x.name === name.replace(/^\/(exit|q)$/, "/quit"));
     if (b) return b.run(rest.join(" "));
+    // /<agent>:<cmd> runs the active agent's own command even when codemax has one of that name.
+    const ns = name.match(/^\/([a-z]+):(.+)$/);
+    if (ns && this.active && ns[1] === this.active.agent && this.active.commands.some((c) => c.name === ns[2])) {
+      const forward = `/${ns[2]}${rest.length ? " " + rest.join(" ") : ""}`;
+      if (this.active.turn) return this.enqueue(forward);
+      return this.send(this.active, forward);
+    }
     if (name === "/exit" || name === "/q") return this.quit();
     if (this.active?.commands.some((c) => `/${c.name}` === name)) {
       if (this.active.turn) {
-        this.queue.push(line);
-        this.transcript.note(`queued ${name} until the turn ends`, C.dim);
+        this.enqueue(line);
         return;
       }
       return this.send(this.active, line);
@@ -786,7 +825,12 @@ export class ChatApp {
 
   private runCommandValue(value: string, args: string) {
     if (value.startsWith("builtin:")) return this.builtins().find((b) => b.name === value.slice(8))?.run(args);
-    if (value.startsWith("agentcmd:")) return this.command(`/${value.slice(9)}${args ? " " + args : ""}`);
+    if (value.startsWith("agentcmd:")) {
+      const name = value.slice(9);
+      // A name codemax also uses goes through /<agent>:<name> so the agent's own command runs.
+      const clash = this.builtins().some((b) => b.name === `/${name}`) && this.active;
+      return this.command(`/${clash ? `${this.active!.agent}:` : ""}${name}${args ? " " + args : ""}`);
+    }
   }
 
   private pendingShell: string[] = [];
@@ -834,7 +878,8 @@ export class ChatApp {
     this.paletteKind = "modes";
     this.palette = new Palette(this.renderer, {
       title: `Model for ${a.name}`,
-      items: models.map((m) => ({ label: m.id, description: `${m.name !== m.id ? m.name : ""}${m.id === a.engine.info?.currentModel ? "  (current)" : ""}`, value: m.id })),
+      // The agent's own list, newest first, by its display name (e.g. "Opus 5.5" for the id "opus").
+      items: sortModels(models).map((m, i) => ({ label: m.name, description: `${m.name !== m.id ? m.id : ""}${m.id === a.engine.info?.currentModel ? "  (current)" : ""}`, value: m.id, weight: 100 - i })),
       onPick: (it) => {
         this.closePalette();
         void apply(it.value);
@@ -944,6 +989,13 @@ export class ChatApp {
     const all = this.ledger.usage();
     for (const l of renderUsageTable(all, { title: "Usage for this project" })) this.transcript.note(l);
     this.transcript.note(`this codemax session: ${fmtUsd(this.sessionCost)} · all time here: ${fmtUsd(sumCost(all))} · prices in ~/.codemax/prices.json`);
+    // Plan limits, as the agents report them (Claude Code's own /usage is terminal-only, so this is where it shows).
+    const label: Record<string, string> = { five_hour: "5-hour", seven_day: "weekly", seven_day_opus: "weekly Opus", seven_day_sonnet: "weekly Sonnet", overage: "extra usage", seven_day_overage_included: "weekly incl. extra" };
+    for (const [agent, m] of this.planLimits) {
+      const parts = [...m].map(([w, v]) => `${label[w] ?? w} ${typeof v.usedPercent === "number" ? `${Math.round(v.usedPercent)}%` : v.status ?? "?"}${v.status === "rejected" ? " (used up)" : ""}${v.resetsAt ? ` · resets ${fmtDateTime12(v.resetsAt)}` : ""}`);
+      this.transcript.note(`${getAdapter(agent).name} plan: ${parts.join("; ")}`, C.accent);
+    }
+    if (!this.planLimits.size) this.transcript.note("plan limits appear here once an agent reports them (Claude Code does after a turn)");
   }
 
   private showStatus() {
@@ -978,9 +1030,12 @@ export class ChatApp {
     const builtinNames = new Set(this.builtins().map((b) => b.name));
     const items: PaletteItem[] = [
       ...this.builtins().map((b) => ({ label: b.name, description: b.description, value: `builtin:${b.name}`, weight: 1 })),
-      ...(this.active?.commands ?? [])
-        .filter((c) => !builtinNames.has(`/${c.name}`))
-        .map((c) => ({ label: `/${c.name}`, description: c.description ?? `${this.active!.name} command`, value: `agentcmd:${c.name}` })),
+      // An agent command that shares a built-in's name stays reachable as /<agent>:<name>.
+      ...(this.active?.commands ?? []).map((c) => {
+        const clash = builtinNames.has(`/${c.name}`);
+        const label = clash ? `/${this.active!.agent}:${c.name}` : `/${c.name}`;
+        return { label, description: `${c.description ?? `${this.active!.name} command`}${clash ? ` (${this.active!.name}'s own /${c.name})` : ""}`, value: `agentcmd:${c.name}` };
+      }),
     ];
     this.paletteKind = "commands";
     this.palette = new Palette(this.renderer, {
@@ -1169,7 +1224,8 @@ export class ChatApp {
     if (turn && this.config.bellAfterSeconds > 0 && Date.now() - turn.startedAt > this.config.bellAfterSeconds * 1000) process.stdout.write("\x07");
     if (turn) {
       const dur = fmtDuration(Date.now() - turn.startedAt);
-      block.footer(stop === "cancelled" ? `Interrupted after ${dur}` : `${pick(DONE_VERBS, turn.startedAt)} for ${dur} · done ${fmtTime(Date.now())}`);
+      const who = `${active.name} · ${this.modelName(active, turn.model)}`;
+      block.footer(stop === "cancelled" ? `Interrupted after ${dur} · ${who}` : `${pick(DONE_VERBS, turn.startedAt)} for ${dur} · done ${fmtTime(Date.now())} · ${who}`);
       const reply = block.text().trim();
       if (isLimitNotice(reply)) turn.rec?.markLimit(reply);
       turn.rec?.end(stop);
@@ -1247,10 +1303,18 @@ export class ChatApp {
         break;
       case "usage": {
         if (active.turn && typeof e.outputTokens === "number") active.turn.tokens += e.outputTokens;
+        if (active.turn && e.model && !/default model$/.test(e.model)) active.turn.model = e.model;
         if (typeof e.contextUsed === "number" && typeof e.contextSize === "number" && e.contextSize > 0) {
           active.context = { used: e.contextUsed, size: e.contextSize };
           this.renderFooter();
         }
+        for (const pl of e.planLimits ?? []) {
+          const m = this.planLimits.get(active.agent) ?? new Map();
+          m.set(pl.window, { usedPercent: pl.usedPercent, resetsAt: pl.resetsAt, status: pl.status, at: Date.now() });
+          this.planLimits.set(active.agent, m);
+          // A refused window is the plan running out: the handoff offer follows from onQuota.
+          if (pl.status === "rejected" || pl.window === "five_hour") this.onQuota({ agent: active.agent, usedPercent: pl.usedPercent, exhausted: pl.status === "rejected", resetsAt: pl.resetsAt, source: "probe", at: Date.now() });
+        }
         if (typeof e.usedPercent === "number") this.onQuota({ agent: active.agent, usedPercent: e.usedPercent, exhausted: e.usedPercent >= 100, source: "probe", at: Date.now() });
         this.recordUsage(active.agent, active.engine, e);
         break;
@@ -1392,7 +1456,7 @@ export class ChatApp {
     this.paletteKind = "modes";
     this.palette = new Palette(this.renderer, {
       title: `Model for the side agent (${name}) · Esc keeps ${shortModelName(r.engine.info?.currentModel ?? "default")}`,
-      items: models.map((m) => ({ label: m.id, description: `${m.name !== m.id ? m.name : ""}${m.id === r.engine.info?.currentModel ? "  (current)" : ""}`, value: m.id })),
+      items: sortModels(models).map((m, i) => ({ label: m.name, description: `${m.name !== m.id ? m.id : ""}${m.id === r.engine.info?.currentModel ? "  (current)" : ""}`, value: m.id, weight: 100 - i })),
       onPick: (it) => {
         this.closePalette();
         void this.setSideModel(it.value);
@@ -1644,14 +1708,20 @@ export class ChatApp {
     if (!a) return this.transcript.note("no main agent to forward to", C.warn);
     const msg = forwardMessage(n.text, n.name);
     if (a.turn || this.switching) {
-      this.queue.push(msg);
-      this.transcript.note(`note queued for ${a.name} until its turn ends`);
-      this.renderFooter();
+      this.enqueue(msg);
       return;
     }
     void this.send(a, msg);
   }
 
+  /** The model's display name as the agent lists it ("Opus 5.5"), else a short id. */
+  private modelName(a: Active, id?: string): string {
+    const mid = id ?? a.engine.info?.currentModel;
+    if (!mid) return "default model";
+    const listed = a.engine.info?.models?.find((m) => m.id === mid);
+    return listed && listed.name !== listed.id ? listed.name : shortModelName(mid);
+  }
+
   private announceUpdate(version: string) {
     if (this.closed) return;
     this.updateAvailable = version;
@@ -1714,7 +1784,7 @@ export class ChatApp {
       else {
         const elapsed = Date.now() - t.startedAt;
         const tip = elapsed > 8000 ? `  ⎿  tip: ${pick(TIPS, Math.floor(t.startedAt / 1000))}` : "";
-        this.setWorking(`${glyph} ${t.verb}… (${secs}${tok}) · esc to interrupt${tip}`);
+        this.setWorking(`${glyph} ${t.verb}… (${secs}${tok}) · ${active.name} · ${this.modelName(active, t.model)} · esc to interrupt${tip}`);
       }
     }, 120);
   }
@@ -1883,14 +1953,14 @@ function ago(ts: number): string {
   return h < 48 ? `${h}h ago` : `${Math.round(h / 24)}d ago`;
 }
 
-export async function runChat(config: Config, ledger: Ledger, cwd: string, agent: AgentId, fresh: boolean, pick = false) {
+export async function runChat(config: Config, ledger: Ledger, cwd: string, agent: AgentId, fresh: boolean, pick = false, explicit = false) {
   const renderer = await createCliRenderer({ exitOnCtrlC: false, exitSignals: ["SIGTERM", "SIGHUP"], useMouse: true, targetFps: 60 });
   const pref = config.theme ?? "auto";
   applyTheme(pref === "auto" ? ((await renderer.waitForThemeMode(250).catch(() => null)) ?? "dark") : pref);
   const app = new ChatApp(renderer, config, ledger, cwd);
   process.once("exit", () => app.awake.releaseSync());
   try {
-    await app.start(agent, fresh, { pick });
+    await app.start(agent, fresh, { pick, explicit });
   } finally {
     renderer.destroy();
     try {

package/src/chat/models.ts

@@ -0,0 +1,33 @@
+/**
+ * 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);
+}

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;
@@ -90,11 +92,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 +119,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 +157,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();

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);
     }
@@ -105,7 +106,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 +115,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 +219,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": {

package/src/core/brief.ts

@@ -4,6 +4,7 @@ import { diffStat, headLine, recentCommits } from "./git.ts";
 import { checkpointDiff } from "./checkpoint.ts";
 import { BRIEF_MARKER, type Ledger } from "./ledger.ts";
 import type { Step, StepOf } from "./journal.ts";
+import { fmtTime12 } from "./time.ts";
 
 export interface BriefInput {
   ledger: Ledger;
@@ -161,7 +162,7 @@ export async function buildCatchup(input: BriefInput): Promise<string | null> {
 function whereItStopped(steps: Step[], end: StepOf<"end"> | undefined): string[] {
   const out: string[] = [];
   if (!end) return ["The last agent had not finished its first turn."];
-  const when = new Date(end.ts).toLocaleTimeString([], { hour: "numeric", minute: "2-digit" });
+  const when = fmtTime12(end.ts);
   const why =
     end.outcome === "limit" ? `ran out of its usage limit${end.detail ? ` ("${oneLine(end.detail, 140)}")` : ""}`
     : end.outcome === "cancelled" ? "was interrupted by the user"

package/src/core/quota.ts

@@ -1,5 +1,6 @@
 import type { AgentId, QuotaStatus } from "../adapters/types.ts";
 import { stripAnsi } from "./terminal.ts";
+import { fmtTime12 } from "./time.ts";
 
 /**
  * Vendor-neutral phrases. Deliberately narrow: "rate limit" or "429" alone
@@ -47,7 +48,7 @@ export class OutputScanner {
 export function quotaLabel(q?: QuotaStatus): string {
   if (!q) return "";
   if (isExhausted(q)) {
-    const reset = q.resetsAt ? ` until ${new Date(q.resetsAt).toLocaleTimeString()}` : "";
+    const reset = q.resetsAt ? ` until ${fmtTime12(q.resetsAt)}` : "";
     return q.source === "output" ? `exhausted? (text match)${reset}` : `EXHAUSTED${reset}`;
   }
   if (typeof q.usedPercent === "number") return `${Math.round(q.usedPercent)}% used`;

package/src/core/time.ts

@@ -0,0 +1,9 @@
+/** Every time codemax shows is 12-hour, whatever the system locale: "7:25 PM", "Oct 18, 7:25 PM". */
+export function fmtTime12(ts: number): string {
+  return new Date(ts).toLocaleTimeString("en-US", { hour: "numeric", minute: "2-digit", hour12: true });
+}
+
+export function fmtDateTime12(ts: number): string {
+  const d = new Date(ts);
+  return `${d.toLocaleDateString("en-US", { month: "short", day: "numeric" })}, ${fmtTime12(ts)}`;
+}

package/src/engines/acp.ts

@@ -1,6 +1,6 @@
 import { ClientSideConnection, ndJsonStream, type Client, type Stream } from "@agentclientprotocol/sdk";
 import type { AgentId } from "../adapters/types.ts";
-import type { Engine, EngineEvent, EngineInfo, EngineOption, EngineSessionRef, EngineStartOptions, PermissionRequest, StopReason } from "./types.ts";
+import type { Engine, EngineEvent, EngineInfo, EngineOption, EngineSessionRef, EngineStartOptions, PermissionRequest, PlanLimit, StopReason } from "./types.ts";
 import { agentEnv } from "./env.ts";
 import { platformArgv } from "../core/spawn.ts";
 import { classifyError } from "./errors.ts";
@@ -204,7 +204,7 @@ export class AcpEngine implements Engine {
         // `used` is how full the context window is, not tokens spent: it feeds the context meter.
         // Token counts come from the prompt response (or session files) at turn end.
         if (typeof u.used === "number") this.turnContext = u.used;
-        this.emit({ type: "usage", contextUsed: u.used, contextSize: u.size, costUsd: delta, model: this.currentModelName() });
+        this.emit({ type: "usage", contextUsed: u.used, contextSize: u.size, costUsd: delta, model: this.currentModelName(), planLimits: planLimitsOf(u) });
         break;
       }
       default:
@@ -339,6 +339,15 @@ function extraOptions(config: unknown): EngineOption[] {
     }));
 }
 
+/** Claude's plan limits ride on usage updates as `_meta["_claude/rateLimit"]` (SDKRateLimitInfo). */
+function planLimitsOf(u: any): PlanLimit[] | undefined {
+  const rl = u?._meta?.["_claude/rateLimit"];
+  if (!rl || typeof rl !== "object") return undefined;
+  const util = typeof rl.utilization === "number" ? (rl.utilization <= 1 ? rl.utilization * 100 : rl.utilization) : undefined;
+  const reset = typeof rl.resetsAt === "number" ? (rl.resetsAt < 1e12 ? rl.resetsAt * 1000 : rl.resetsAt) : undefined;
+  return [{ window: String(rl.rateLimitType ?? "plan"), usedPercent: util, resetsAt: reset, status: rl.status }];
+}
+
 function mapStatus(s: string | undefined): "pending" | "in_progress" | "completed" | "failed" {
   if (s === "in_progress" || s === "completed" || s === "failed") return s;
   return "pending";

package/src/engines/codex.ts

@@ -1,8 +1,9 @@
 import type { AgentId } from "../adapters/types.ts";
-import type { Engine, EngineEvent, EngineInfo, EngineSessionRef, EngineStartOptions, PermissionRequest, StopReason, ToolStatus } from "./types.ts";
+import type { Engine, EngineEvent, EngineInfo, EngineOption, EngineSessionRef, EngineStartOptions, PermissionRequest, StopReason, ToolStatus } from "./types.ts";
 import { agentEnv } from "./env.ts";
 import { platformArgv } from "../core/spawn.ts";
 import { classifyError } from "./errors.ts";
+import pkg from "../../package.json" with { type: "json" };
 
 export interface CodexEngineOptions {
   /** Command for the app server. Default: codex app-server. */
@@ -18,6 +19,10 @@ export interface CodexEngineOptions {
  * `answerPermission`.
  */
 export class CodexEngine implements Engine {
+  /** Models this account can use, from `model/list`. */
+  private catalog: { id: string; name: string; efforts: string[]; defaultEffort?: string }[] = [];
+  /** Reasoning effort chosen with /effort (sent with each turn); undefined = the model's default. */
+  private effort: string | undefined;
   readonly agent: AgentId = "codex";
   info: EngineInfo | null = null;
   session: EngineSessionRef | null = null;
@@ -49,7 +54,7 @@ export class CodexEngine implements Engine {
     this.cwd = o.cwd;
     this.transport = this.opts.transport ?? this.spawn(o.cwd);
     this.transport.onLine((line) => this.onLine(line));
-    const init = await this.request("initialize", { clientInfo: { name: "codemax", version: "0.3.0" }, capabilities: {} });
+    const init = await this.request("initialize", { clientInfo: { name: "codemax", version: pkg.version }, capabilities: {} });
     this.notify("initialized", {});
 
     let thread: any;
@@ -65,6 +70,9 @@ export class CodexEngine implements Engine {
     this.model = thread.model ?? undefined;
     this.session = { agent: "codex", id: thread.id, cwd: o.cwd, startedAt: Date.now(), lastUsedAt: Date.now() };
     const account: any = await this.request("account/read", {}).catch(() => null);
+    // The models this account can use, straight from Codex: never a list of our own.
+    // An older Codex without model/list must not hold up startup: give it a few seconds.
+    this.catalog = await Promise.race([this.listModels(), Bun.sleep(4000).then(() => [])]).catch(() => []);
     this.info = {
       agent: "codex",
       name: "Codex",
@@ -74,8 +82,9 @@ export class CodexEngine implements Engine {
         { id: "never", name: "full auto (no approvals)" },
       ],
       currentMode: "on-request",
-      models: [...new Set([this.model, "gpt-5.6-sol", "gpt-5.6-terra", "gpt-5.6-luna", "gpt-5.5"].filter(Boolean))].map((id) => ({ id: id!, name: id! })),
+      models: this.catalog.length ? this.catalog.map((m) => ({ id: m.id, name: m.name })) : this.model ? [{ id: this.model, name: this.model }] : [],
       currentModel: this.model,
+      options: this.effortOptions(),
       plan: account?.account?.planType ? `chatgpt ${account.account.planType}` : undefined,
     };
     this.emit({ type: "session", ref: this.session });
@@ -281,7 +290,7 @@ export class CodexEngine implements Engine {
     const done = new Promise<StopReason>((resolve) => (this.turn = { resolve }));
     try {
       const approvalPolicy = this.info?.currentMode === "never" ? "never" : "on-request";
-      const res = await this.request("turn/start", { threadId: this.threadId, cwd: this.cwd, input: [{ type: "text", text }], model: this.model, approvalPolicy });
+      const res = await this.request("turn/start", { threadId: this.threadId, cwd: this.cwd, input: [{ type: "text", text }], model: this.model, approvalPolicy, ...(this.effort ? { effort: this.effort } : {}) });
       if (this.turn) this.turn.id = res?.turn?.id;
     } catch (e: any) {
       const msg = `${e?.message ?? e} ${JSON.stringify(e?.data ?? "")}`.trim();
@@ -314,6 +323,46 @@ export class CodexEngine implements Engine {
   async setModel(modelId: string) {
     this.model = modelId;
     if (this.info) this.info.currentModel = modelId;
+    // Reasoning efforts differ per model: keep the chosen one only if the new model has it.
+    const efforts = this.catalog.find((m) => m.id === modelId)?.efforts ?? [];
+    if (this.effort && !efforts.includes(this.effort)) this.effort = undefined;
+    if (this.info) this.info.options = this.effortOptions();
+  }
+
+  async setOption(optionId: string, value: string) {
+    if (optionId !== "effort") return;
+    this.effort = value;
+    if (this.info) this.info.options = this.effortOptions();
+  }
+
+  /** `model/list`, all pages, hidden models left out. */
+  private async listModels(): Promise<{ id: string; name: string; efforts: string[]; defaultEffort?: string }[]> {
+    const out: { id: string; name: string; efforts: string[]; defaultEffort?: string }[] = [];
+    let cursor: string | undefined;
+    for (let page = 0; page < 10; page++) {
+      const r: any = await this.request("model/list", cursor ? { cursor } : {});
+      for (const m of r?.data ?? []) {
+        if (m?.hidden) continue;
+        const id = String(m.model ?? m.id ?? "");
+        if (!id) continue;
+        out.push({
+          id,
+          name: String(m.displayName ?? id),
+          efforts: (m.supportedReasoningEfforts ?? []).map((e: any) => String(e?.reasoningEffort ?? e)).filter(Boolean),
+          defaultEffort: m.defaultReasoningEffort ? String(m.defaultReasoningEffort) : undefined,
+        });
+      }
+      cursor = r?.nextCursor ?? undefined;
+      if (!cursor) break;
+    }
+    return out;
+  }
+
+  /** The current model's reasoning efforts, as Codex lists them. */
+  private effortOptions(): EngineOption[] {
+    const m = this.catalog.find((x) => x.id === this.model);
+    if (!m?.efforts.length) return [];
+    return [{ id: "effort", name: "Reasoning effort", category: "thought_level", current: this.effort ?? m.defaultEffort ?? "default", values: m.efforts.map((e) => ({ value: e, name: e })) }];
   }
 
   async close() {

package/src/engines/types.ts

@@ -27,6 +27,8 @@ export type EngineEvent =
       costUsd?: number;
       /** Rate-limit window consumption, when the agent exposes it. */
       usedPercent?: number;
+      /** Subscription plan limits the agent reported (Claude: 5-hour, weekly…), one entry per window. */
+      planLimits?: PlanLimit[];
       /** Context window fill, when reported (tokens used / size). */
       contextUsed?: number;
       contextSize?: number;
@@ -36,6 +38,15 @@ export type EngineEvent =
   | { type: "error"; kind: ErrorKind; message: string }
   | { type: "log"; level: "info" | "warn" | "error"; message: string };
 
+export interface PlanLimit {
+  /** e.g. "five_hour", "seven_day", "seven_day_opus". */
+  window: string;
+  usedPercent?: number;
+  resetsAt?: number;
+  /** "allowed" | "allowed_warning" | "rejected" (out of this window's quota). */
+  status?: string;
+}
+
 export type ToolStatus = "pending" | "in_progress" | "completed" | "failed";
 export type StopReason = "end_turn" | "max_tokens" | "cancelled" | "refusal" | "error" | "other";
 export type ErrorKind = "quota" | "auth" | "protocol" | "crashed" | "other";

package/src/tui/app.ts

@@ -68,10 +68,15 @@ export class App {
     this.setStatus("");
   }
 
-  async start(agent: AgentId, fresh: boolean) {
+  /** `explicit`: the user named this agent (--agent), so never start a different one. */
+  async start(agent: AgentId, fresh: boolean, o: { explicit?: boolean } = {}) {
     await this.refreshDetect();
-    const first = this.detect.get(agent)?.installed ? agent : this.firstInstalled();
+    const installed = this.detect.get(agent)?.installed;
+    if (!installed && o.explicit) throw new Error(`${agent} is not installed. Installed: ${this.installedList() || "none"}`);
+    const first = installed ? agent : this.firstInstalled();
     if (!first) throw new Error("no supported agent CLI found on PATH");
+    // Under tests a fallback must never reach a real agent (no logins, no quota).
+    if (first !== agent && process.env.NODE_ENV === "test") throw new Error(`test asked for ${agent}, which is not available; refusing to fall back to ${first}`);
     if (first !== agent) this.setStatus(`${agent} not found, starting ${first}`);
     await this.launch(getAdapter(first), { fresh });
     return this.done;
@@ -282,6 +287,10 @@ export class App {
     );
   }
 
+  private installedList(): string {
+    return [...this.detect.entries()].filter(([, d]) => d.installed).map(([id]) => id).join(", ");
+  }
+
   private firstInstalled(): AgentId | undefined {
     return listAdapters(this.config.order).find((a) => this.detect.get(a.id)?.installed)?.id;
   }
@@ -360,11 +369,11 @@ export class App {
 }
 
 /** Run codemax on the real terminal until the user quits. */
-export async function runApp(config: Config, ledger: Ledger, cwd: string, agent: AgentId, fresh: boolean) {
+export async function runApp(config: Config, ledger: Ledger, cwd: string, agent: AgentId, fresh: boolean, explicit = false) {
   const renderer = await createCliRenderer({ exitOnCtrlC: false, exitSignals: ["SIGTERM", "SIGHUP"], useMouse: true, targetFps: 60 });
   const app = new App(renderer, config, ledger, cwd);
   try {
-    await app.start(agent, fresh);
+    await app.start(agent, fresh, { explicit });
   } finally {
     renderer.destroy();
     try {