@xhulz/nina 0.71.0 → 0.73.0

package/src/office.html

@@ -31,8 +31,15 @@
   #tasks .who { margin-top: 3px; color: #c9cde0; font-size: 12px; overflow-wrap: anywhere; }
   #tasks .now { margin-top: 2px; color: #ffd34d; font-size: 12px; }
   #tasks .now.quiet { color: #8a8fa8; }
+  #tasks ul.agents { list-style: none; margin: 8px 0 0; padding: 0; }
+  #tasks ul.agents li { margin: 0 0 7px; padding: 0 0 0 14px; }
+  #tasks ul.agents li::before { left: 1px; top: 4px; width: 7px; height: 7px; border: 0; background: #ffd34d; animation: beat 1.2s ease-in-out infinite; }
+  #tasks .agent { overflow-wrap: anywhere; font-size: 12px; color: #c9cde0; }
+  #tasks .role { font: 600 12px ui-monospace, SFMono-Regular, Menlo, Consolas, monospace; color: #fff8e8; margin-right: 6px; }
+  #tasks .desc { margin-top: 1px; color: #8a8fa8; font-size: 11px; overflow-wrap: anywhere; }
+  #tasks .took { margin-top: 1px; color: #a9adbf; font: 11px ui-monospace, SFMono-Regular, Menlo, Consolas, monospace; }
   @keyframes beat { 50% { opacity: 0.35; } }
-  @media (prefers-reduced-motion: reduce) { #tasks li.running::before { animation: none; } }
+  @media (prefers-reduced-motion: reduce) { #tasks li.running::before, #tasks ul.agents li::before { animation: none; } }
 </style>
 </head>
 <body>
@@ -805,6 +812,14 @@ function onBeat(b) {
     }
     return;
   }
+  if (b.type === 'home') {
+    // Reported, and nobody came for the work in time: it goes home, unless it was sent back to work meanwhile.
+    const p = b.agent ? people.get(b.agent) : null;
+    if (!p || !(p.reported || p.reporting) || p.leaving) return;
+    if (b.instant) leave(p, true);
+    else act(p, () => p.reported && !p.typing && !p.leaving && leave(p));
+    return;
+  }
   if (b.type === 'refused' || b.type === 'stale') {
     // A dispatch the owner refused never ran; a run that never reported has stopped. Either way, whoever sat down
     // for it gets up — and a refusal answers the gate's call.
@@ -975,14 +990,16 @@ function syncButtons() {
  * The session's work, task by task, as the server cuts it — the way `nina runs` does: each named by the words the
  * orchestrator gave its first dispatch, with the stages that worked on it, from when that went out to the verdict
  * that closed it. The server sends the whole list whenever it changes, and it replaces what is here. A task still
- * open counts up while anyone is at work on it, and stops at the last thing that happened while nobody is.
+ * open counts up while anyone is at work on it, and stops at the last of its runs to start or end while nobody is;
+ * under it, each of its agents at work, as Claude Code lists its own: the stage, what it is doing now, the words of
+ * its dispatch, how long it has been at work and the context it holds.
  */
 const SIDE = 300;
 /** Narrower than this, the timeline is drawn over the room, and starts hidden. */
 const NARROW = 760;
 const TASKS_KEY = 'nina-office-tasks';
 let tasks = [];
-/** The newest dispatch or verdict: a replay's clock, and where an idle task's count stops. */
+/** The newest dispatch or verdict: a replay's clock. */
 let lastActivity = 0;
 let tasksOpen = (() => {
   try {
@@ -998,6 +1015,15 @@ let tasksOpen = (() => {
 const atWork = () => [...new Set([...people.values()].filter((p) => p.work && !p.reported && !p.leaving).map((p) => p.role))];
 
 const two = (n) => String(n).padStart(2, '0');
+/** How long an agent has been at work, as Claude Code says it: 28s, 7m 19s, 1h 4m. */
+function took(ms) {
+  const s = Math.max(0, Math.floor(ms / 1000));
+  if (s < 60) return `${s}s`;
+  if (s < 3600) return `${Math.floor(s / 60)}m ${s % 60}s`;
+  return `${Math.floor(s / 3600)}h ${Math.floor((s % 3600) / 60)}m`;
+}
+/** A count of tokens: 850, 49.8k, 1.2M — a count that rounds to a thousand thousands is a million. */
+const tokens = (n) => (n >= 999_950 ? `${(n / 1e6).toFixed(1)}M` : n >= 1000 ? `${(n / 1000).toFixed(1)}k` : String(n));
 /** A moment as the hour, with the day when it is not the day of `beside` — now, or the moment it follows. */
 function stamp(at, beside) {
   const t = new Date(at);
@@ -1021,26 +1047,43 @@ function counter(ms) {
 function drawTasks() {
   if (!tasksOpen) return;
   const clock = status.startsWith('replay') ? lastActivity : Date.now();
-  const working = atWork();
-  const line = (cls, text) => {
-    const el = document.createElement('div');
+  const line = (cls, text, tag = 'div') => {
+    const el = document.createElement(tag);
     el.className = cls;
     el.textContent = text;
     return el;
   };
+  // What it is doing now, as Claude Code's list leads with, and under it the words its dispatch was given.
+  const agentRow = (a) => {
+    const li = document.createElement('li');
+    const what = line('agent', '');
+    what.append(line('role', a.role, 'span'), a.doing ?? a.desc ?? '');
+    li.append(what);
+    if (a.doing && a.desc) li.append(line('desc', a.desc));
+    li.append(line('took', a.tokens === null ? took(clock - a.start) : `${took(clock - a.start)} · ${tokens(a.tokens)} tokens`));
+    return li;
+  };
   const shown = [...tasks].sort((a, b) => b.start - a.start);
   document.getElementById('task-list').replaceChildren(
     ...shown.map((t) => {
       const li = document.createElement('li');
       const running = t.end === null;
-      const idle = running && working.length === 0;
+      const agents = t.agents ?? [];
+      const idle = running && agents.length === 0;
       li.className = running ? (idle ? 'idle' : 'running') : t.how === 'closed' ? 'done' : 'ended';
       li.append(line('name', t.name || '(no description)'));
       if (t.who?.length > 0) li.append(line('who', t.who.map(([role, n]) => (n > 1 ? `${role} ×${n}` : role)).join(' · ')));
       if (running) {
-        const upTo = idle ? Math.max(t.start, lastActivity) : Math.max(t.start, clock);
+        // Idle, it stops at the last of its own runs to start or end, whatever another task is doing.
+        const upTo = idle ? Math.max(t.start, t.last ?? t.start) : Math.max(t.start, clock);
         li.append(line('when', `${stamp(t.start, clock)} → now · ${counter(upTo - t.start)}`));
-        li.append(line('now', idle ? `idle since ${stamp(lastActivity, clock)}` : `at work: ${working.join(', ')}`));
+        if (idle) li.append(line('now', `idle since ${stamp(t.last ?? t.start, clock)}`));
+        else {
+          const list = document.createElement('ul');
+          list.className = 'agents';
+          list.append(...agents.map(agentRow));
+          li.append(list);
+        }
       } else {
         li.append(line('when', `${stamp(t.start, clock)} → ${stamp(t.end, t.start)} · ${span(t.end - t.start)}`));
         // A task that waited — overnight, on the owner — says how much of it anyone was at work.

package/src/office.mjs

@@ -4,11 +4,14 @@
  * Each stage of the project's composed graph has a desk, and each agent the loop gate saw launched is someone
  * sitting at one. The gate's ledger is what is read, and it holds metadata only, so the office shows who worked,
  * what they answered, the ids of the issues they named and the few words the orchestrator gave each dispatch —
- * never what an agent wrote or reported. Beside the room, a timeline of the session's tasks (`officeTimeline`), cut
- * and named as `nina runs` cuts and names them:
+ * never what an agent reported. Of a run's own transcript it reads when it was last written, how much context it
+ * holds and what it is doing — the description it gave its shell command, or a tool and a file's name (`actionOf`).
+ * Beside the room, a timeline of the session's tasks (`officeTimeline`), cut and named as `nina runs` cuts and names
+ * them, each open one with its agents at work:
  *
  *   a dispatch                        someone sits down to work, the folder carried over by whoever handed it on
  *   a verdict                         a check over their head, or a cross when it sends work back
+ *   a report nothing follows          after `HANDOFF_MS`, its agent goes home
  *   a verdict the graph sends to the  a question mark over the one who asked, until the owner speaks
  *   owner, or the orchestrator asking
  *   the gate asking at a cap          the phone on the reception's counter rings, the owner's line
@@ -31,7 +34,8 @@ import { readLedger, sessionLedgers } from './gate.mjs';
 import { readProfile, slugFor } from './paths.mjs';
 import { projectStoreFile, readStoreFile } from './store.mjs';
 import { CYCLE_ENDS, IN_FLIGHT, cyclesOf } from './commands/stats.mjs';
-import { isLoopBack, transcriptsOf } from './transcripts.mjs';
+import { contextSize, isLoopBack, transcriptsOf } from './transcripts.mjs';
+import { gained } from './cost.mjs';
 import { shapeOf } from './commands/pipeline.mjs';
 import { listenHere, openInBrowser, refuseElsewhere, untilStopped } from './serve.mjs';
 
@@ -48,6 +52,14 @@ export const OFFICE_PORT = 6462;
  */
 export const PARTY_QUIET_MS = 20_000;
 
+/**
+ * How long one whose report is in waits at its desk to hand its work on before it goes home. Any dispatch moves the
+ * reported on, but with tasks side by side the next could be a long while coming: of two projects' 1,266 reports, 346
+ * sat on past two minutes and 149 past ten, done and with nothing in hand, while Claude Code had already let them go.
+ * Of 544 hand-offs, 92.8% went out within two minutes, and 93.9% within three.
+ */
+export const HANDOFF_MS = 2 * 60 * 1000;
+
 /** How far back, when a live client moves to a session already running, beats still play rather than set the room. */
 const SWITCH_GRACE_MS = 10_000;
 
@@ -77,14 +89,13 @@ export const SILENT_MS = 45 * 60 * 1000;
 const staleAt = (start, heard) => (heard === null ? start.at + STALE_MS : Math.max(start.at, heard) + SILENT_MS);
 
 /**
- * When each run of a session last wrote its own transcript, so that a run still writing is at work however long it
- * takes. A run is found by its agent's id once the gate knows it, and before that — a foreground run still going — by
- * the tool_use id that launched it, which its transcript's `.meta.json` keeps.
+ * Each run's own transcript in a session. A run is found by its agent's id once the gate knows it, and before that — a
+ * foreground run still going — by the tool_use id that launched it, which its transcript's `.meta.json` keeps.
  *
  * @param {string} target - The project directory.
- * @returns {(session: string|null) => (start: {agent: string|null, id: string|null}) => number|null}
+ * @returns {(session: string|null) => (start: {agent: string|null, id: string|null}) => string|null}
  */
-export function runClock(target) {
+export function runFiles(target) {
   // Named as the gate names the project's ledgers, by where it really is: reached through a link, it is the same one.
   let real = target;
   try {
@@ -121,9 +132,23 @@ export function runClock(target) {
       }
       if (launchedBy.has(meta)) byLaunch.set(launchedBy.get(meta), file);
     }
+    return (start) => (start.agent && byAgent.get(start.agent)) || (start.id && byLaunch.get(start.id)) || null;
+  };
+}
+
+/**
+ * When each run of a session last wrote its own transcript, so that a run still writing is at work however long it
+ * takes.
+ *
+ * @param {(session: string|null) => (start: object) => string|null} files - Each run's transcript (`runFiles`).
+ * @returns {(session: string|null) => (start: {agent: string|null, id: string|null}) => number|null}
+ */
+export function runClock(files) {
+  return (session) => {
+    const fileOf = files(session);
     const written = new Map();
     return (start) => {
-      const file = (start.agent && byAgent.get(start.agent)) || (start.id && byLaunch.get(start.id)) || null;
+      const file = fileOf(start);
       if (!file) return null;
       if (!written.has(file)) {
         try {
@@ -137,6 +162,89 @@ export function runClock(target) {
   };
 }
 
+/** The most of a run's own words the timeline shows for what it is doing. */
+const ACTION_MAX = 120;
+
+/**
+ * What a tool call is doing, in the few words a list beside the room has: the description the run gave a shell
+ * command, which the run writes for a person to read, or the tool and the name of the file it works on. Never the
+ * command, a path, a pattern, another tool's input or what came back.
+ *
+ * @param {object} block - A `tool_use` block of an assistant message.
+ * @returns {string|null}
+ */
+export function actionOf(block) {
+  if (block?.type !== 'tool_use' || typeof block.name !== 'string') return null;
+  const input = block.input && typeof block.input === 'object' ? block.input : {};
+  // An MCP tool is named by its server too: the tool's own name says what it does.
+  const name = block.name.startsWith('mcp__') ? (block.name.split('__').filter(Boolean).at(-1) ?? block.name) : block.name;
+  const said = block.name === 'Bash' && typeof input.description === 'string' ? input.description.replace(/\s+/g, ' ').trim() : '';
+  if (said) return said.length > ACTION_MAX ? `${said.slice(0, ACTION_MAX - 1)}…` : said;
+  const path = [input.file_path, input.notebook_path].find((x) => typeof x === 'string' && x.trim());
+  // A transcript written on Windows names its files with backslashes, which a path read here does not split on.
+  return path ? `${name} ${basename(path.trim().replace(/\\/g, '/'))}` : name;
+}
+
+/**
+ * Each run of a session as its own transcript tells it now: how much context it holds (`contextSize` of its newest
+ * message) and what it is doing (`actionOf` its newest tool call) — what Claude Code shows beside each of its running
+ * agents, but for a line it writes as it watches, which it keeps nowhere. Read once a look and only what the
+ * transcript gained since the last, keeping those and nothing else the run wrote; each with when its message was
+ * written, so a replay is told the run as it stood at a beat.
+ *
+ * @param {(session: string|null) => (start: object) => string|null} files - Each run's transcript (`runFiles`).
+ * @returns {(session: string|null) => (start: {agent: string|null, id: string|null}, moment?: number) => {tokens: number|null, doing: string|null}|null}
+ */
+export function runState(files) {
+  /** By transcript, in the session last looked at: how far it was read, its last message, the counts and actions by when. */
+  let read = new Map();
+  let looking = null;
+  return (session) => {
+    // The office follows one session at a time: one it moved away from is read again if it comes back.
+    if (session !== looking) read = new Map();
+    looking = session;
+    const fileOf = files(session);
+    const looked = new Set();
+    return (start, moment = Number.POSITIVE_INFINITY) => {
+      const file = fileOf(start);
+      if (!file) return null;
+      if (!read.has(file)) read.set(file, { offset: 0, last: null, counts: [], actions: [] });
+      const kept = read.get(file);
+      if (!looked.has(file)) {
+        looked.add(file);
+        try {
+          const { text, to } = gained(file, kept.offset);
+          // A transcript shorter than what was read of it is another one: read again from its start.
+          if (to < kept.offset) Object.assign(kept, { last: null, counts: [], actions: [] });
+          kept.offset = to;
+          for (const line of text.split('\n')) {
+            if (!line.includes('"cache_read_input_tokens"')) continue;
+            try {
+              const row = JSON.parse(line);
+              const at = Date.parse(row?.timestamp);
+              if (!row?.message?.usage || !row.message.id || !Number.isFinite(at)) continue;
+              // A message is written once for each of its blocks, with the same usage: its first is counted, and
+              // each of its tool calls is a step.
+              if (row.message.id !== kept.last) kept.counts.push([at, contextSize(row.message.usage)]);
+              kept.last = row.message.id;
+              for (const block of Array.isArray(row.message.content) ? row.message.content : []) {
+                const action = actionOf(block);
+                if (action) kept.actions.push([at, action]);
+              }
+            } catch {
+              // A torn line loses one message's count; the next one has its own.
+            }
+          }
+        } catch {
+          // A transcript gone between the listing and the read tells what it had.
+        }
+      }
+      const by = (list) => list.findLast(([at]) => at <= moment)?.[1] ?? null;
+      return { tokens: by(kept.counts), doing: by(kept.actions) };
+    };
+  };
+}
+
 /** A wait between two of the office's looks this much longer than it asks for is the machine having slept. */
 const SLEPT_MS = 60_000;
 
@@ -256,11 +364,12 @@ function readStarts(ledger) {
  * verdict that ends a cycle of the timeline, qa's `PASS` — is a party at once, whoever else is at work. Any other pass
  * ends the work — a party — when nothing since the last dispatch was sent back, something since then could route to
  * `done`, nobody is still at work, and no dispatch follows within `PARTY_QUIET_MS`; at once when the pass routes only
- * to a terminal. A party that waits on the quiet is only beaten once `now` has passed it.
+ * to a terminal. A party that waits on the quiet is only beaten once `now` has passed it. So is the beat that sends one
+ * whose report is in home (`home`): `HANDOFF_MS` after its verdict, when no dispatch and no party came between.
  *
  * @param {object[]} entries - The ledger, oldest first.
  * @param {{edges: {from: string, to: string, token: string}[]}} graph - The project's parsed graph.
- * @param {number} [now] - The time a waiting party is judged against; `Infinity` for a session that has ended.
+ * @param {number} [now] - The time a waiting party or a going home is judged against; `Infinity` for a session that has ended.
  * @param {(start: object) => number|null} [heard] - When a run last wrote its transcript (`runClock`), or null.
  * @returns {object[]} Beats, each `{id, at, type, ...}`; the id is stable as the ledger grows.
  */
@@ -345,6 +454,19 @@ export function officeBeats(ledger, graph, now = Date.now(), heard = () => null)
     // A reset written for the model's own question, by ledgers older than the `question` entry, is not the owner.
     else if (e.k === 'reset' && e.why !== 'ask') beats.push({ id, at, type: 'owner' });
   });
+  // One whose report is in goes home once `HANDOFF_MS` passes with no dispatch and no party, either of which sends the
+  // reported on anyway. Its work, handed on later, the orchestrator carries. One that asked the owner stays with its
+  // question until the work moves on. "After" is the ledger's order, which the beats keep until they are sorted: a
+  // qa's party falls at its verdict's own moment.
+  const moves = beats.flatMap((b, i) => ((b.type === 'work' && !b.message) || b.type === 'party' ? [{ i, at: b.at }] : []));
+  const home = [];
+  beats.forEach((v, i) => {
+    if (v.type !== 'verdict' || v.asks) return;
+    const moment = v.at + HANDOFF_MS;
+    if (now < moment || moves.some((m) => m.i > i && m.at <= moment)) return;
+    home.push({ id: `home:${v.id}`, at: moment, type: 'home', role: v.role, agent: v.agent });
+  });
+  beats.push(...home);
   // Stable: beats of one moment keep the ledger's order. A beat that waited — a party, a refusal — sorts where it fell.
   return beats.sort((a, b) => a.at - b.at);
 }
@@ -359,13 +481,18 @@ export function officeBeats(ledger, graph, now = Date.now(), heard = () => null)
  * grows — a run still at work lets nothing through until its verdict, a dispatch is known refused only seconds later
  * — and sent piece by piece, a task that a later fact merged away stayed on the page for good.
  *
+ * A task still open lists its agents at work, oldest first, each with its stage, the words its own dispatch was given,
+ * when it started, how much context it holds and what it is doing (`runState`) — the detail Claude Code shows of its
+ * own running agents. Every task says when the last of its runs started or ended, which an idle one counts up to.
+ *
  * @param {object[]} ledger - The ledger, oldest first.
  * @param {number} [now] - The moment it is read at: a run with no verdict that has not gone quiet is still at work.
  * @param {Map<string, string>} [names] - Descriptions by dispatch id, for entries that carry none.
  * @param {(start: object) => number|null} [heard] - When a run last wrote its transcript (`runClock`), or null.
- * @returns {{key: string, name: string|null, start: number, end: number|null, how: string|null, busy: number|null, who: [string, number][]}[]}
+ * @param {(start: object) => {tokens: number|null, doing: string|null}|null} [state] - A run as its transcript tells it (`runState`).
+ * @returns {{key: string, name: string|null, start: number, end: number|null, last: number, how: string|null, busy: number|null, who: [string, number][], agents: {role: string, desc: string|null, start: number, tokens: number|null, doing: string|null}[]}[]}
  */
-export function officeTimeline(ledger, now = Date.now(), names = new Map(), heard = () => null) {
+export function officeTimeline(ledger, now = Date.now(), names = new Map(), heard = () => null, state = () => null) {
   const { entries, starts, verdictOf } = readStarts(ledger);
   // A run a message started — an agent resumed after it had reported — is named by the message's summary, or, in a
   // ledger from before the gate kept one, by the words the agent was launched with: it goes on with that work.
@@ -385,15 +512,22 @@ export function officeTimeline(ledger, now = Date.now(), names = new Map(), hear
     // A task its closing verdict ended while one of its runs is still at work stays open until that run reports: work
     // planned side by side — three architects sent together, one of whose specs went on to qa — fell inside the task
     // the first one's qa closed, and the room showed two architects at work beside a list with no task open.
-    const open = cycle.end === 'open' || cycle.runs.some((r) => r.verdict === IN_FLIGHT && r.start.end == null);
+    const atWork = cycle.runs.filter((r) => r.verdict === IN_FLIGHT && r.start.end == null);
+    const open = cycle.end === 'open' || atWork.length > 0;
+    const last = Math.max(...cycle.runs.map((r) => r.start.end ?? r.start.at));
     return {
       key: first.key,
       name: first.desc ? String(first.desc) : null,
       start: first.start.at,
-      end: open ? null : Math.max(...cycle.runs.map((r) => r.start.end ?? r.start.at)),
+      end: open ? null : last,
+      last,
       how: open ? null : cycle.end,
       busy: open ? null : busyFor(cycle.runs.map((r) => r.start)),
       who: [...who],
+      agents: atWork.map((r) => {
+        const told = state(r.start);
+        return { role: r.role, desc: r.desc ? String(r.desc) : null, start: r.start.at, tokens: told?.tokens ?? null, doing: told?.doing ?? null };
+      }),
     };
   });
 }
@@ -505,7 +639,9 @@ export function officeRoutes({ target, wanted, replay = false }) {
   const timers = new Set();
 
   const names = storeNames(target);
-  const clock = runClock(target);
+  const files = runFiles(target);
+  const clock = runClock(files);
+  const looks = runState(files);
   const wake = wakeClock();
 
   /** The session to show, and its entries; read again only when its ledger changed. */
@@ -559,7 +695,7 @@ export function officeRoutes({ target, wanted, replay = false }) {
       return at === null ? null : Math.max(at, woke);
     };
     const beats = officeBeats(state.entries, graph, now, heard);
-    const tasks = officeTimeline(state.entries, now, names(state.entries), heard);
+    const tasks = officeTimeline(state.entries, now, names(state.entries), heard, looks(state.session));
     for (const client of clients) {
       if (client.replay) continue;
       if (client.session !== state.session) greet(client, state);
@@ -580,7 +716,8 @@ export function officeRoutes({ target, wanted, replay = false }) {
     const beats = officeBeats(state.entries, graph, Number.POSITIVE_INFINITY, heard);
     // The timeline as it stood at each beat: cut from the ledger up to that moment, so a replay tells nothing early.
     const known = names(state.entries);
-    const tasksAt = (moment) => officeTimeline(state.entries.filter((e) => Date.parse(e?.at) <= moment), moment, known, heard);
+    const look = looks(state.session);
+    const tasksAt = (moment) => officeTimeline(state.entries.filter((e) => Date.parse(e?.at) <= moment), moment, known, heard, (start) => look(start, moment));
     // What came before the first dispatch sets the room, at once: a session often opens on many of the owner's
     // messages, and played out they kept the office empty for a minute.
     let i = Math.max(0, beats.findIndex((b) => b.type === 'work'));

package/src/transcripts.mjs

@@ -1114,7 +1114,7 @@ const REWRITE_FLOOR = 30_000;
  */
 export function contextOf(usage) {
   const n = (v) => (typeof v === 'number' ? v : 0);
-  const turns = [...usage.values()].map(({ usage: u }) => ({ size: n(u.input_tokens) + n(u.cache_read_input_tokens) + n(u.cache_creation_input_tokens), written: n(u.cache_creation_input_tokens) }));
+  const turns = [...usage.values()].map(({ usage: u }) => ({ size: contextSize(u), written: n(u.cache_creation_input_tokens) }));
   const sizes = turns.map((t) => t.size);
   let rewrites = 0;
   let rewritten = 0;
@@ -1127,6 +1127,18 @@ export function contextOf(usage) {
   return { turns: sizes.length, start: sizes[0] ?? null, peak: sizes.length > 0 ? Math.max(...sizes) : null, rewrites, rewritten };
 }
 
+/**
+ * The context a turn held: everything it read, from the cache or not. What `stats` measures a round's context by, the
+ * cost watch a run's, and the office an agent at work.
+ *
+ * @param {object} usage - A message's usage.
+ * @returns {number} Tokens.
+ */
+export function contextSize(usage) {
+  const n = (v) => (typeof v === 'number' ? v : 0);
+  return n(usage?.input_tokens) + n(usage?.cache_read_input_tokens) + n(usage?.cache_creation_input_tokens);
+}
+
 /** How the cost watch opens an output it clipped (`src/cost.mjs`), which is how a snapshot counts them. */
 export const CLIP_MARK = '[NINA clipped this output';