jaitus 0.3.14 → 0.3.17

package/src/index.js

@@ -17,6 +17,7 @@ import {
   endpoints, version, HOME, HISTORY,
 } from './config.js';
 import { runAgent, repairToolPairs, streamTurn } from './agent/loop.js';
+import { estimateTokens, summarise, compactInPlace, dropOldImages, SIZE_FAULTS } from './compact.js';
 import { createPermissions, MODES as PERMISSION_MODES } from './agent/permissions.js';
 import { DEFAULT_DENY } from './agent/rules.js';
 import { forgetIgnoreCache, imageBlock, IMAGE_MIME } from './agent/tools.js';
@@ -46,6 +47,7 @@ import logout from './commands/logout.js';
 import doctor from './commands/doctor.js';
 import update, { updateNotice, autoUpdate } from './commands/update.js';
 import { startupNotice } from './serviceNotice.js';
+import { warmMachineHeader } from './machine.js';
 import init from './commands/init.js';
 import research from './commands/research.js';
 import explain from './commands/explain.js';
@@ -241,21 +243,6 @@ async function resolveModel(client, preferred) {
   return available[0];
 }
 
-/** Rough token estimate for /context and /status — ~4 characters per token of English. */
-function estimateTokens(messages) {
-  let chars = 0;
-  for (const m of messages) {
-    if (typeof m.content === 'string') chars += m.content.length;
-    else if (Array.isArray(m.content)) {
-      for (const b of m.content) {
-        if (b.type === 'text') chars += (b.text || '').length;
-        else if (b.type === 'tool_use') chars += JSON.stringify(b.input || {}).length;
-        else if (b.type === 'tool_result') chars += (b.content || '').length;
-      }
-    }
-  }
-  return Math.ceil(chars / 4);
-}
 
 /** Clipboard write that degrades honestly: returns false when no path exists. */
 async function copyToClipboard(text) {
@@ -383,82 +370,8 @@ const compactThreshold = () => CONTEXT_BUDGET * AUTO_COMPACT_AT;
 // someone typed `@package-lock.json` would blow the context it is meant to save.
 const MENTION_MAX_BYTES = 48_000;
 
-/**
- * One summarisation call. Shared by /compact and auto-compaction so the two cannot
- * drift into producing different kinds of summary from the same conversation.
- */
-/**
- * The conversation as plain text, for summarising. Sending the raw history broke in
- * three ways: every image was sent again (past the gateway's size limit once there were
- * a few), tool calls went without a tools list (which some providers reject), and a long
- * session was larger than the window being compacted. Tool calls and results become
- * short lines, images a note, and the middle of a very long session is trimmed.
- */
-function transcriptForSummary(messages, maxChars = 360_000) {
-  const clip = (s, n) => (s.length > n ? `${s.slice(0, n)}…` : s);
-  const lines = [];
-  for (const m of messages) {
-    const who = m.role === 'assistant' ? 'ASSISTANT' : 'USER';
-    if (typeof m.content === 'string') { lines.push(`${who}: ${m.content}`); continue; }
-    for (const b of Array.isArray(m.content) ? m.content : []) {
-      if (b?.type === 'text' && b.text) lines.push(`${who}: ${b.text}`);
-      else if (b?.type === 'tool_use') lines.push(`${who} ran ${b.name}: ${clip(JSON.stringify(b.input ?? {}), 400)}`);
-      else if (b?.type === 'tool_result') {
-        const t = typeof b.content === 'string' ? b.content : Array.isArray(b.content) ? b.content.map((c) => c?.text || '').join('\n') : '';
-        lines.push(`RESULT${b.is_error ? ' (error)' : ''}: ${clip(t, 1500)}`);
-      } else if (b?.type === 'image') lines.push(`${who}: [an image]`);
-    }
-  }
-  let text = lines.join('\n');
-  if (text.length > maxChars) {
-    const head = text.slice(0, Math.floor(maxChars * 0.25));
-    const tail = text.slice(-Math.floor(maxChars * 0.7));
-    text = `${head}\n\n[… the middle of the session is left out …]\n\n${tail}`;
-  }
-  return text;
-}
-
-export async function summarise(client, model, messages, focus) {
-  // Streamed, like every other turn. Sent as one non-streamed request, nothing came
-  // back until the whole summary was written — and the proxy in front of the gateway
-  // cuts a response that is silent for 100 s, so a long session's summary failed with
-  // the proxy's own error page ("Compact failed: Something went wrong"). A stream
-  // carries the gateway's heartbeat the whole time.
-  const turn = await streamTurn({
-    client,
-    model,
-    // Room for the model to reason before it writes; at 2048 the reasoning could use
-    // it all and the summary came back empty.
-    maxTokens: 6000,
-    system: 'You write precise working summaries of coding sessions.',
-    messages: [
-      {
-        role: 'user',
-        // Sections a successor needs to carry on without re-asking or re-reading — the
-        // same structure agent tools use for their own compaction. Losing the user's
-        // exact instructions or where the work stopped is what makes a compacted session
-        // feel worse; everything else can be re-read from disk.
-        content: 'Summarize this conversation for a successor agent that will continue the work with no other memory of it. '
-          + 'Use these headings, and be specific (paths, names, numbers) rather than general:\n'
-          + '1. Request — what the user asked for, with their exact words for any instruction, constraint or preference.\n'
-          + '2. Corrections — anything the user rejected, corrected or asked to do differently, verbatim where short.\n'
-          + '3. Files — every file read or changed: path, what changed or what matters in it.\n'
-          + '4. Commands and results — what was run and what it showed (test/build results, errors and how each was fixed).\n'
-          + '5. Decisions — what was chosen and why.\n'
-          + '6. Current state — exactly what was being done when this summary was made, and what is unfinished.\n'
-          + '7. Next step — the single next action, if the work was mid-way.\n'
-          + 'Omit headings that have nothing. No preamble.'
-          + (focus ? ` Focus on: ${focus}.` : '')
-          + `\n\n<conversation>\n${transcriptForSummary(messages)}\n</conversation>`,
-      },
-    ],
-  });
-  // Half a summary would silently become the whole memory of the session.
-  if (turn.stopReason === 'cut') throw new JaitusError({ code: 'interrupted', message: 'The summary was cut off on the way. Try /compact again.' });
-  const text = (turn.content || []).filter((b) => b.type === 'text').map((b) => b.text).join('\n').trim();
-  if (!text) throw new Error('the summary came back empty');
-  return text;
-}
+// Summarising lives in compact.js; re-exported for the callers and tests that import it here.
+export { summarise };
 
 /**
  * `@path` in a message → the file's contents as a content block.
@@ -1052,7 +965,7 @@ async function session({ flags }) {
   };
 
   /** One agent run with abort wiring, error accounting, and queue draining after. */
-  const runManaged = async (messages) => {
+  const runManaged = async (messages, { recovered = false } = {}) => {
     const ctrl = new AbortController();
     activeAbort = ctrl;
     const turnStarted = Date.now();
@@ -1067,6 +980,9 @@ async function session({ flags }) {
       const result = await runAgent({
         client, messages, model, cwd: flags.cwd, permissions, signal: ctrl.signal, tui, journal,
         onContext: (n) => { lastContext = n; sessionState.lastContext = n; showContext(); },
+        // Between the steps of one task: a long task used to grow past the window on its
+        // own, because the check only ran before a new prompt.
+        beforeStep: () => autoCompactIfNeeded({ signal: ctrl.signal }),
         // `jaitus config trimToolResults off` keeps every old tool output in context.
         trimContext: loadSettings().trimToolResults !== false,
         // What happened since the model's last turn (a failed request, an interrupt, a
@@ -1104,7 +1020,30 @@ async function session({ flags }) {
         else out(meta);
       }
     } catch (e) {
+      // Too big to send: compact (keeping the newest exchange whole) and drop old images,
+      // then try once more — what the user would have done by hand, and what /compact
+      // could not do while its own request was too big too.
+      if (!recovered && SIZE_FAULTS.has(e?.code) && !ctrl.signal.aborted && messages.length > 1) {
+        repairToolPairs(messages);
+        const images = dropOldImages(messages);
+        const compacted = await compactNow({ keepTail: true, why: `That request was too ${e.code === 'request_too_large' ? 'large to send' : 'long for the model'}${images ? ` (${images} old image${images === 1 ? '' : 's'} removed)` : ''}` });
+        if (compacted || images) {
+          activeAbort = null;
+          return runManaged(messages, { recovered: true });
+        }
+      }
       reportAgentError(e);
+      // After a recovery the newest message carries the summary of everything before it:
+      // removing it would remove the whole memory of the session with it.
+      if (recovered && MESSAGE_FAULTS.has(e?.code)) {
+        const last = messages[messages.length - 1];
+        const first = Array.isArray(last?.content) ? last.content[0] : null;
+        if (last?.role === 'user' && first?.type === 'text' && String(first.text).startsWith('[Earlier conversation, summarized:]')) {
+          last.content = [first];
+          ledger.note('turn-failed', 'The user\'s newest message was too large to send even after the conversation was summarised, so it was removed. Ask them to send it in smaller parts (fewer or smaller images, a shorter paste).');
+          return;
+        }
+      }
       // The failed turn is dropped so the next message is not sent on top of a broken
       // conversation the API will reject — but the model is told it happened. Without
       // that, its next turn begins as though nothing went wrong and it re-attempts the
@@ -1172,30 +1111,51 @@ async function session({ flags }) {
    * thing to talk to, and finding that out by noticing the agent forgot something is
    * worse than being told.
    */
-  const autoCompactIfNeeded = async () => {
-    if (loadSettings().autoCompact === false) return;
-    const used = estimateTokens(messages);
-    if (used < compactThreshold()) return;
-    if (messages.length < 4) return;
+  // How full the context is. The provider's own count of the last prompt is exact and
+  // includes what the character estimate cannot see (system prompt, tool schemas, the
+  // gateway's prompt); the estimate covers what was added since. The larger wins — the
+  // estimate alone missed both and let sessions run into the wall.
+  const contextUsed = () => Math.max(lastContext || 0, estimateTokens(messages) + 6_000);
 
-    tui.setStatus?.(`Compacting — ${format(used)} of ${format(CONTEXT_BUDGET)} context used`);
+  /**
+   * Summarise in place. `keepTail` keeps the newest exchange word for word (the person's
+   * new message, or the last tool calls and their results mid-task). `why` is for the
+   * notice. Returns true when the history was rewritten.
+   */
+  const compactNow = async ({ keepTail = true, why = '', signal } = {}) => {
+    const used = contextUsed();
+    tui.setStatus?.(`${c.brand(glyph('◆', '*'))} Compacting — ${format(used)} of ${format(CONTEXT_BUDGET)} context used`);
     try {
-      const summary = await summarise(client, model, messages, '');
-      const dropped = messages.length;
-      messages.length = 0;
-      messages.push({ role: 'user', content: `[Earlier conversation, summarized:]\n${summary}\n\n[Continue from here.]` });
-      tui.notice?.(`Context was ${format(used)}; ${dropped} messages summarised into one. /rewind still has the originals.`, 'info');
-      ledger.note('compacted', `The conversation was automatically summarised to free context: ${dropped} messages became one summary. Detail you are not shown above is genuinely gone — ask or re-read rather than assuming.`);
+      const r = await compactInPlace(client, model, messages, {
+        contextTokens: CONTEXT_BUDGET, keepTail, signal,
+        onProgress: (i, n) => tui.setStatus?.(`${c.brand(glyph('◆', '*'))} Compacting a long session — part ${i} of ${n}`),
+      });
+      if (!r) return false;
+      lastContext = 0;
+      sessionState.lastContext = 0;
+      sessionState.messages = messages;
+      saveSession(sessionState);
+      showContext({ estimate: true });
+      tui.notice?.(`${why || `Context was ${format(used)}`}; ${r.dropped} messages summarised into one. /rewind still has the originals.`, 'info');
+      ledger.note('compacted', `The conversation was automatically summarised to free context: ${r.dropped} messages became one summary. Detail you are not shown above is genuinely gone — ask or re-read rather than assuming.`);
+      return true;
     } catch (error) {
-      // Not fatal: the turn can still run, it just runs closer to the ceiling.
       const id = isJaitusError(error) && error.requestId ? ` (request id ${error.requestId})` : '';
       tui.notice?.(`Auto-compaction failed (${error.message}${id}) — continuing without it. /compact retries.`, 'warn');
       ledger.note('compact-failed', `Automatic context compaction failed (${error.message}); the conversation is close to the context limit.`);
+      return false;
     } finally {
       tui.clearStatus?.();
     }
   };
 
+  const autoCompactIfNeeded = async ({ signal } = {}) => {
+    if (loadSettings().autoCompact === false) return false;
+    if (contextUsed() < compactThreshold()) return false;
+    if (messages.length < 3) return false;
+    return compactNow({ keepTail: true, signal });
+  };
+
   const handleLineInner = async (rawLine) => {
     const input = rawLine.trim();
     if (!input) return;
@@ -1229,7 +1189,7 @@ async function session({ flags }) {
       tui.setBusy(true);
       try {
         result = await slashCommand(verb, args, {
-          client, messages, permissions, flags, spent, resetContext,
+          client, messages, permissions, flags, spent, resetContext, lastContextUsed: () => contextUsed(),
           model, setModel: (m) => {
             model = m;
             sessionState.model = m;
@@ -1440,6 +1400,9 @@ async function session({ flags }) {
     // An outage or maintenance on the Jaitus service, said once a day at most; the
     // status page has the rest. Background, short timeout, silent on failure.
     void startupNotice().then((line) => { if (line) tui.notice(line, 'warn'); }).catch(() => {});
+    // The slow identifier probe (Windows hardware id) starts now, in the background, so
+    // the first request already carries it (machine.js).
+    warmMachineHeader();
     // A project's .mcp.json runs programs on this machine. Nothing in it starts until the
     // exact command is approved here — asked once, remembered per project and command.
     void (async () => {
@@ -1801,6 +1764,21 @@ async function slashCommand(verb, args, ctx) {
 
     case '/status': {
       const creds = loadCredentials();
+      if (ctx.tui?.showMeters) {
+        const used = ctx.lastContextUsed?.() || estimateTokens(ctx.messages);
+        void ctx.tui.showMeters('Status', [
+          { label: 'Model', value: ctx.model },
+          { label: 'Mode', value: ctx.permissions.mode },
+          { label: 'Account', value: creds?.user?.email || 'not signed in' },
+          { label: 'Directory', value: ctx.flags.cwd },
+          { gap: true },
+          { meter: 'Context', used, total: CONTEXT_BUDGET, detail: `~${format(used)} of ${format(CONTEXT_BUDGET)} tokens · ${ctx.messages.length} messages`, note: used / CONTEXT_BUDGET > 0.6 ? 'compacts by itself at 78%' : '' },
+          { label: 'This session', value: `${ctx.spent.turns} turns · ${ctx.spent.tools} tool calls${ctx.spent.credits ? ` · ${fmtCredits(ctx.spent.credits)} credits` : ''}` },
+          { gap: true },
+          { label: '', value: '/usage for your plan' },
+        ]);
+        return null;
+      }
       table([
         [`  ${c.dim('model')}`, ctx.model],
         [`  ${c.dim('mode')}`, ctx.permissions.mode],
@@ -1814,6 +1792,21 @@ async function slashCommand(verb, args, ctx) {
 
     case '/context': {
       const tokens = estimateTokens(ctx.messages);
+      if (ctx.tui?.showMeters) {
+        const used = ctx.lastContextUsed?.() || tokens;
+        const count = (pred) => ctx.messages.reduce((n, m) => n + (Array.isArray(m.content) ? m.content.filter(pred).length : 0), 0);
+        void ctx.tui.showMeters('Context', [
+          { meter: 'Used', used, total: CONTEXT_BUDGET, detail: `~${format(used)} of ${format(CONTEXT_BUDGET)} tokens`, note: 'compacts by itself at 78%' },
+          { gap: true },
+          { label: 'Messages', value: String(ctx.messages.length) },
+          { label: 'Tool results', value: String(count((b) => b.type === 'tool_result')) },
+          { label: 'Images', value: String(count((b) => b.type === 'image')) },
+          ...(loadContext(ctx.flags.cwd) ? [{ label: 'Project notes', value: `${CONTEXT_FILE} (loaded)` }] : []),
+          { gap: true },
+          { label: '', value: '/compact summarises it now' },
+        ]);
+        return null;
+      }
       table([
         [`  ${c.dim('messages')}`, String(ctx.messages.length)],
         [`  ${c.dim('user messages')}`, String(ctx.messages.filter((m) => m.role === 'user' && typeof m.content === 'string').length)],
@@ -1835,10 +1828,17 @@ async function slashCommand(verb, args, ctx) {
         : (await import('./ui.js')).spinner('Summarizing…');
       if (ctx.tui) ctx.tui.setStatus(`${c.brand(glyph('◆', '*'))} ${c.brand(glyph('Summarizing…', 'Summarizing...'))}`);
       try {
-        const text = await summarise(ctx.client, ctx.model, ctx.messages, args.join(' '));
-        ctx.messages.length = 0;
-        ctx.messages.push({ role: 'user', content: `[Earlier conversation, summarized:]\n${text}\n\n[Continue from here.]` });
-        ok('Conversation compacted. Context freed.');
+        const before = estimateTokens(ctx.messages);
+        // Images are the usual reason a request is too large in bytes; the summary keeps
+        // a note of each, so nothing is lost by dropping them here.
+        dropOldImages(ctx.messages);
+        const r = await compactInPlace(ctx.client, ctx.model, ctx.messages, {
+          focus: args.join(' '), contextTokens: CONTEXT_BUDGET, keepTail: false,
+          onProgress: (i, n) => ctx.tui?.setStatus?.(`${c.brand(glyph('◆', '*'))} Summarizing a long session — part ${i} of ${n}`),
+        });
+        // Saved now: a crash before the next turn used to bring the whole history back.
+        if (ctx.sessionState) { ctx.sessionState.messages = ctx.messages; ctx.sessionState.lastContext = 0; saveSession(ctx.sessionState); }
+        ok(`Conversation compacted — about ${format(before)} tokens down to ${format(r?.after ?? estimateTokens(ctx.messages))}.`);
         try { ctx.resetContext?.(); } catch { /* header keeps last value */ }
       } catch (e) {
         // The request id is the only thing that ties this failure to a backend log
@@ -2571,7 +2571,7 @@ async function slashCommand(verb, args, ctx) {
       return null;
 
     case '/usage':
-      await commands.usage.run([], {});
+      await commands.usage.run([], { tui: ctx.tui, spent });
       return null;
 
     case '/init':
@@ -2659,6 +2659,10 @@ async function slashCommand(verb, args, ctx) {
     }
 
     case '/cost':
+      if (ctx.tui?.showMeters) {
+        void ctx.tui.showMeters('This session', costSections(spent));
+        return null;
+      }
       table([
         ['  Turns', String(spent.turns)],
         ['  Tool calls', String(spent.tools)],
@@ -2696,6 +2700,90 @@ function fmtTokens(n) {
   if (v >= 1e3) return `${Math.round(v / 1e3)}K`;
   return String(Math.round(v));
 }
+/** Credits as people read them: whole numbers in the thousands, one decimal below. */
+function fmtCredits(n) {
+  const v = Number(n) || 0;
+  return v >= 1000 ? Math.round(v).toLocaleString('en-IN') : String(Math.round(v * 10) / 10);
+}
+
+const clock = (d) => new Date(d).toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' });
+const dayAndClock = (d) => new Date(d).toLocaleString([], { weekday: 'short', day: 'numeric', month: 'short', hour: '2-digit', minute: '2-digit' });
+
+/**
+ * The plan as meters: the 5-hour window, the week and the month each fill at their own
+ * rate from the same requests, so each gets its own bar and its own refill time. Extra
+ * credits and the free tier follow. Used by /usage (popup) and `jaitus usage` (text).
+ */
+function planSections(u) {
+  const st = u?.planStatus || null;
+  const out = [];
+  if (!u?.isPaid) {
+    out.push({ heading: 'Free plan' });
+    if (st?.freeTierStatus === 'locked') {
+      out.push({ label: 'Free prompts', value: 'not available — this computer already has its free accounts', tone: 'bad' });
+    } else {
+      out.push({ meter: 'Free prompts', used: u?.freeRequestsUsed ?? 0, total: u?.freeRequestLimit || 0, detail: `${u?.freeRequestsUsed ?? 0} of ${u?.freeRequestLimit ?? '?'} used` });
+    }
+  } else {
+    out.push({ heading: st?.name || 'Your plan' });
+    if (st?.windowCredits) {
+      out.push({
+        meter: `${st.windowHours || 5}-hour window`, used: st.windowUsed, total: st.windowCredits,
+        detail: `${fmtCredits(st.windowUsed)} of ${fmtCredits(st.windowCredits)} credits`,
+        note: st.windowResetsAt ? `refills at ${clock(st.windowResetsAt)}` : 'starts with your next request',
+      });
+    }
+    if (st?.weeklyCredits) {
+      out.push({
+        meter: 'This week', used: st.weekUsed, total: st.weeklyCredits,
+        detail: `${fmtCredits(st.weekUsed)} of ${fmtCredits(st.weeklyCredits)} credits`,
+        note: st.weekResetsAt ? `refills ${dayAndClock(st.weekResetsAt)}` : 'starts with your next request',
+      });
+    }
+    if (st?.monthlyCredits) {
+      out.push({
+        meter: 'This month', used: st.periodCredits, total: st.monthlyCredits,
+        detail: `${fmtCredits(st.periodCredits)} of ${fmtCredits(st.monthlyCredits)} credits`,
+        note: st.periodResetsAt ? `resets ${new Date(st.periodResetsAt).toLocaleDateString([], { day: 'numeric', month: 'short' })}` : '',
+      });
+    }
+    if (u.planExpiresAt) out.push({ label: 'Renews by', value: new Date(u.planExpiresAt).toLocaleDateString([], { day: 'numeric', month: 'short', year: 'numeric' }) });
+  }
+  if (st?.bonusCredits > 0) {
+    out.push({ label: 'Extra credits', value: `${fmtCredits(st.bonusCredits)} left — used once a limit above runs out${st.bonusExpiresAt ? ` · until ${new Date(st.bonusExpiresAt).toLocaleDateString()}` : ''}`, tone: 'good' });
+  }
+  return out;
+}
+
+/** The session's spend, for /cost and the foot of /usage. */
+function costSections(spent) {
+  return [
+    { label: 'Credits', value: spent.credits ? `${fmtCredits(spent.credits)}` : '—', tone: 'good' },
+    { label: 'Turns', value: String(spent.turns) },
+    { label: 'Tool calls', value: String(spent.tools) },
+    { gap: true },
+    { label: 'Fresh input', value: `${(spent.input || 0).toLocaleString()} tokens` },
+    { label: 'Cached input', value: `${(spent.cached || 0).toLocaleString()} tokens (billed at the lower cached price)` },
+    { label: 'Output', value: `${(spent.output || 0).toLocaleString()} tokens` },
+    { gap: true },
+    { label: '', value: '/usage for your plan' },
+  ];
+}
+
+/** A meters list as plain text, for `jaitus usage` outside the app view. */
+function sectionsAsTable(sections) {
+  const rows = [];
+  for (const s of sections) {
+    if (s.gap || s.heading) { if (s.heading) rows.push(['Plan', s.heading]); continue; }
+    if (s.meter !== undefined) {
+      const pct = s.total > 0 ? Math.min(100, Math.round((100 * (Number(s.used) || 0)) / s.total)) : 0;
+      const bar = `${glyph('█', '#').repeat(Math.round(pct / 5))}${glyph('░', '.').repeat(20 - Math.round(pct / 5))}`;
+      rows.push([s.meter, `${bar} ${pct}%  ${[s.detail, s.note].filter(Boolean).join(' · ')}`]);
+    } else if (s.label) rows.push([s.label, s.value]);
+  }
+  return rows;
+}
+
 function planRows(u) {
   const st = u.planStatus || null;
   if (!u.isPaid) return [['Plan', 'Free'], ['Free prompts', `${u.freeRequestsUsed ?? 0} of ${u.freeRequestLimit ?? '?'} used`]];
@@ -2761,18 +2849,31 @@ const commands = {
   usage: {
     summary: 'your usage and remaining free prompts',
     usage: ['jaitus usage [--json]'],
-    run: async (argv, { json }) => {
+    run: async (argv, { json, tui = null, spent = null } = {}) => {
       const client = requireAuth();
-      const [{ ok: good, body }, me] = await Promise.all([client.api('/usage/summary'), client.api('/auth/me').catch(() => ({}))]);
+      if (tui?.setStatus) tui.setStatus(`${c.brand(glyph('◆', '*'))} Loading your usage…`);
+      let good; let body; let me;
+      try {
+        [{ ok: good, body }, me] = await Promise.all([client.api('/usage/summary'), client.api('/auth/me').catch(() => ({}))]);
+      } finally { tui?.clearStatus?.(); }
       if (!good) { fail(body?.message || 'Could not load usage.'); return 1; }
       const d = body.data || {};
       const u = me?.body?.user || me?.body?.data || null;
-      present(json, { ...d, planStatus: u?.planStatus || null }, () => table([
-        ...(u ? planRows(u) : []),
-        ['Today', `${d.today?.requests ?? 0} requests`],
-        ['This month', `${d.month?.requests ?? 0} requests`],
-        ['Tokens used', `${(d.totalTokensConsumed ?? 0).toLocaleString()}`],
-      ]));
+      const activity = [
+        { gap: true },
+        { heading: 'Requests' },
+        { label: 'Today', value: `${(d.today?.requests ?? 0).toLocaleString()} requests` },
+        { label: 'This month', value: `${(d.month?.requests ?? 0).toLocaleString()} requests · ${fmtTokens(d.totalTokensConsumed ?? 0)} tokens in total` },
+      ];
+      const session = spent ? [{ gap: true }, { heading: 'This session' }, { label: 'Credits', value: `${fmtCredits(spent.credits || 0)} · ${spent.turns} turns · ${spent.tools} tool calls` }] : [];
+      const sections = [...(u ? planSections(u) : []), ...activity, ...session];
+      // In the app view: a popup over the conversation that Esc closes, not rows that
+      // stay in the transcript for good.
+      if (tui?.showMeters && !json) {
+        void tui.showMeters('Usage', sections);
+        return 0;
+      }
+      present(json, { ...d, planStatus: u?.planStatus || null }, () => table(sectionsAsTable(sections)));
       return 0;
     },
   },