mixdog 0.8.0 → 0.9.0

package/src/tui/time-format.mjs

@@ -1,5 +1,5 @@
 /**
- * TUI duration formatting, matching Claude Code's formatDuration shape.
+ * TUI duration formatting (compact elapsed-time labels).
  *
  * Examples:
  *   42s

package/src/tui/transcript-tool-failures.mjs

@@ -0,0 +1,67 @@
+/**
+ * Transcript visibility rules for fully-failed tool batches.
+ * Hook / approval denials are user-actionable and must stay visible in the TUI.
+ */
+
+import { parseToolArgs } from '../runtime/shared/tool-surface.mjs';
+
+const HOOK_DENIAL_RE = /denied by hook/i;
+const APPROVAL_UNAVAILABLE_RE = /approval required but no approval UI is available/i;
+
+export function toolItemResultText(item) {
+  if (!item) return '';
+  const chunks = [];
+  if (item.result != null) chunks.push(String(item.result));
+  if (item.rawResult != null && item.rawResult !== item.result) chunks.push(String(item.rawResult));
+  return chunks.join('\n').trim();
+}
+
+export function isHookApprovalDenialToolResult(text) {
+  const value = String(text ?? '').trim();
+  if (!value) return false;
+  if (HOOK_DENIAL_RE.test(value)) return true;
+  if (APPROVAL_UNAVAILABLE_RE.test(value)) return true;
+  return false;
+}
+
+export function isHookApprovalDenialToolItem(item) {
+  if (!item || item.kind !== 'tool') return false;
+  return isHookApprovalDenialToolResult(toolItemResultText(item));
+}
+
+/** Strip the orchestrator's `Error: tool "name"` prefix for a compact TUI line. */
+export function formatHookDenialDetail(text) {
+  const raw = String(text ?? '').trim();
+  if (!raw) return '';
+  const stripped = raw.replace(/^Error:\s*tool\s*"[^"]*"\s*/i, '').trim();
+  return stripped || raw;
+}
+
+export function isFullyFailedToolBatch(item) {
+  if (!item || item.kind !== 'tool') return false;
+  const args = parseToolArgs(item.args);
+  const hasTaskId = Boolean(args.task_id || args.taskId);
+  const status = String(args.status || '').toLowerCase();
+  if (hasTaskId && /^(failed|error|timeout|cancelled|canceled|killed)$/.test(status)) {
+    return false;
+  }
+  const count = Math.max(1, Number(item.count || 1));
+  const done = Math.max(0, Math.min(count, Number(item.completedCount || (item.result == null ? 0 : count))));
+  const explicit = Number(item.errorCount);
+  const failed = Number.isFinite(explicit)
+    ? Math.max(0, Math.min(count, Math.floor(explicit)))
+    : item.isError ? count : 0;
+  return done >= count && failed >= count;
+}
+
+/** Hide noisy all-failed internal tool cards, except hook/approval denials. */
+export function shouldSuppressFullyFailedToolItem(item) {
+  if (!isFullyFailedToolBatch(item)) return false;
+  if (isHookApprovalDenialToolItem(item)) return false;
+  return !hasUsefulFailedToolResultBody(item);
+}
+
+/** Non-empty result/rawResult text the user can expand and inspect in the transcript. */
+export function hasUsefulFailedToolResultBody(item) {
+  return Boolean(toolItemResultText(item));
+}

package/src/tui/transcript-tool-failures.test.mjs

@@ -0,0 +1,111 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  formatHookDenialDetail,
+  hasUsefulFailedToolResultBody,
+  isFullyFailedToolBatch,
+  isHookApprovalDenialToolItem,
+  isHookApprovalDenialToolResult,
+  shouldSuppressFullyFailedToolItem,
+} from './transcript-tool-failures.mjs';
+
+const hookDeniedItem = {
+  kind: 'tool',
+  name: 'shell',
+  args: { command: 'rm -rf /' },
+  result: 'Error: tool "shell" denied by hook: approval required but no approval UI is available (policy)',
+  isError: true,
+  count: 1,
+  completedCount: 1,
+};
+
+const noisyFailedItem = {
+  kind: 'tool',
+  name: 'grep',
+  args: { pattern: 'foo' },
+  result: 'no matches',
+  isError: true,
+  count: 1,
+  completedCount: 1,
+};
+
+const emptyFailedItem = {
+  kind: 'tool',
+  name: 'grep',
+  args: { pattern: 'foo' },
+  result: null,
+  rawResult: null,
+  isError: true,
+  count: 1,
+  completedCount: 1,
+};
+
+const failedTaskJsonStringArgs = {
+  kind: 'tool',
+  name: 'shell',
+  args: '{"task_id":"t1","status":"failed","error":"boom"}',
+  result: null,
+  rawResult: null,
+  isError: true,
+  count: 1,
+  completedCount: 1,
+};
+
+const failedTaskInputWrapperArgs = {
+  kind: 'tool',
+  name: 'shell',
+  args: { input: { task_id: 't2', status: 'timeout' } },
+  result: null,
+  rawResult: null,
+  isError: true,
+  count: 1,
+  completedCount: 1,
+};
+
+test('detects hook denial result text', () => {
+  assert.equal(
+    isHookApprovalDenialToolResult('Error: tool "read" denied by hook: blocked'),
+    true,
+  );
+  assert.equal(
+    isHookApprovalDenialToolResult('Error: tool "shell" denied by hook: approval required but no approval UI is available'),
+    true,
+  );
+  assert.equal(isHookApprovalDenialToolResult('grep: no matches'), false);
+});
+
+test('fully-failed hook denials are not suppressed', () => {
+  assert.equal(isFullyFailedToolBatch(hookDeniedItem), true);
+  assert.equal(isHookApprovalDenialToolItem(hookDeniedItem), true);
+  assert.equal(shouldSuppressFullyFailedToolItem(hookDeniedItem), false);
+});
+
+test('fully-failed non-hook errors with visible body stay visible', () => {
+  assert.equal(isFullyFailedToolBatch(noisyFailedItem), true);
+  assert.equal(hasUsefulFailedToolResultBody(noisyFailedItem), true);
+  assert.equal(shouldSuppressFullyFailedToolItem(noisyFailedItem), false);
+});
+
+test('fully-failed non-hook errors without useful body stay suppressed', () => {
+  assert.equal(isFullyFailedToolBatch(emptyFailedItem), true);
+  assert.equal(hasUsefulFailedToolResultBody(emptyFailedItem), false);
+  assert.equal(shouldSuppressFullyFailedToolItem(emptyFailedItem), true);
+});
+
+test('failed background task with JSON-string args is not suppressed', () => {
+  assert.equal(isFullyFailedToolBatch(failedTaskJsonStringArgs), false);
+  assert.equal(shouldSuppressFullyFailedToolItem(failedTaskJsonStringArgs), false);
+});
+
+test('failed background task with input-wrapped args is not suppressed', () => {
+  assert.equal(isFullyFailedToolBatch(failedTaskInputWrapperArgs), false);
+  assert.equal(shouldSuppressFullyFailedToolItem(failedTaskInputWrapperArgs), false);
+});
+
+test('formatHookDenialDetail strips tool prefix', () => {
+  assert.equal(
+    formatHookDenialDetail(hookDeniedItem.result),
+    'denied by hook: approval required but no approval UI is available (policy)',
+  );
+});
+

package/src/ui/ansi.mjs

@@ -85,8 +85,7 @@ export const bgBlack = sgr('40');
 export const bgBlue = sgr('44');
 
 // --- Truecolor (24-bit) -----------------------------------------------------
-// Claude Code defines its palette as explicit rgb() values (refs/claude-code
-// src/utils/theme.ts darkTheme). 16-color SGR can't reproduce them, so we emit
+// The TUI palette uses explicit rgb() values. 16-color SGR can't reproduce them, so we emit
 // 24-bit SGR. Honors NO_COLOR / TTY exactly like the named helpers above.
 
 /** Foreground truecolor wrapper: `rgb(215,119,87)('x')`. */

package/src/ui/markdown.mjs

@@ -20,17 +20,29 @@ import {
   bold,
   italic,
   dim,
-  cyan,
-  gray,
-  yellow,
-  green,
   underline,
   strike as strikeStyle,
-  brightWhite,
   colorEnabled,
   visibleWidth,
+  rgb,
+  compose,
 } from './ansi.mjs';
 
+// Default Mixdog dark markdown semantics (mirrors src/tui/theme.mjs mixdogPalette md* keys).
+const PALETTE = {
+  heading1: rgb(215, 119, 87),
+  heading: rgb(240, 198, 116),
+  inlineCode: rgb(138, 190, 183),
+  link: rgb(47, 127, 255),
+  codeBlock: rgb(181, 189, 104),
+  fenceLabel: rgb(138, 190, 183),
+  listBullet: rgb(138, 190, 183),
+  quoteText: rgb(128, 128, 128),
+  diffAdd: rgb(0, 170, 75),
+  diffDel: rgb(220, 70, 88),
+  diffHunk: rgb(204, 157, 44),
+};
+
 /**
  * Render a markdown string to a terminal-styled string.
  * @param {string} src
@@ -54,6 +66,8 @@ function renderUnsafe(src, opts) {
   let inFence = false;
   let fenceLang = '';
   let fenceBuf = [];
+  let fenceMarker = '';
+  let fenceMarkerLen = 0;
 
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i];
@@ -62,16 +76,24 @@ function renderUnsafe(src, opts) {
     if (fenceMatch && !inFence) {
       inFence = true;
       fenceLang = fenceMatch[3].trim();
+      fenceMarker = fenceMatch[2][0];
+      fenceMarkerLen = fenceMatch[2].length;
       fenceBuf = [];
       continue;
     }
     if (inFence) {
-      // A line of only backticks/tildes closes the fence.
-      if (/^(\s*)(`{3,}|~{3,})\s*$/.test(line)) {
+      const closeMatch = /^(\s*)([`~]+)\s*$/.exec(line);
+      const markerRun = closeMatch?.[2] ?? '';
+      const closes =
+        markerRun.length >= fenceMarkerLen &&
+        [...markerRun].every((ch) => ch === fenceMarker);
+      if (closes) {
         out.push(renderCodeBlock(fenceBuf, fenceLang, width));
         inFence = false;
         fenceLang = '';
         fenceBuf = [];
+        fenceMarker = '';
+        fenceMarkerLen = 0;
       } else {
         fenceBuf.push(line);
       }
@@ -98,7 +120,7 @@ function clampWidth(w) {
 function renderLine(line, width) {
   // Horizontal rule.
   if (/^\s*([-*_])(\s*\1){2,}\s*$/.test(line)) {
-    return dim('─'.repeat(Math.min(width, 60)));
+    return dim(rgb(128, 128, 128)('─'.repeat(Math.min(width, 60))));
   }
 
   // ATX heading.
@@ -106,30 +128,30 @@ function renderLine(line, width) {
   if (h) {
     const level = h[1].length;
     const text = renderInline(h[2]);
-    if (level === 1) return '\n' + bold(brightWhite('▌ ' + text));
-    if (level === 2) return '\n' + bold(cyan(text));
-    if (level === 3) return bold(text);
-    return bold(dim(text));
+    if (level === 1) return '\n' + compose(bold, PALETTE.heading1)('▌ ' + text);
+    if (level === 2) return '\n' + compose(bold, PALETTE.heading)(text);
+    if (level === 3) return compose(bold, PALETTE.heading)(text);
+    return compose(bold, dim)(text);
   }
 
   // Blockquote (possibly nested).
   const q = /^(\s*>+)\s?(.*)$/.exec(line);
   if (q) {
-    return dim('│ ') + dim(renderInline(q[2]));
+    return dim(PALETTE.quoteText('│ ')) + italic(PALETTE.quoteText(renderInline(q[2])));
   }
 
   // Bullet list.
   const b = /^(\s*)([-*+])\s+(.*)$/.exec(line);
   if (b) {
     const indent = b[1].replace(/\t/g, '  ');
-    return indent + yellow('•') + ' ' + renderInline(b[3]);
+    return indent + PALETTE.listBullet('•') + ' ' + renderInline(b[3]);
   }
 
   // Numbered list.
   const n = /^(\s*)(\d+)([.)])\s+(.*)$/.exec(line);
   if (n) {
     const indent = n[1].replace(/\t/g, '  ');
-    return indent + yellow(n[2] + '.') + ' ' + renderInline(n[4]);
+    return indent + PALETTE.listBullet(n[2] + '.') + ' ' + renderInline(n[4]);
   }
 
   // Plain paragraph line.
@@ -138,40 +160,77 @@ function renderLine(line, width) {
 
 function renderCodeBlock(bufLines, lang, width) {
   const inner = bufLines.length ? bufLines : [''];
+  const isDiff = isDiffFence(lang, inner);
   const contentWidth = Math.max(
     20,
     Math.min(width, inner.reduce((m, l) => Math.max(m, l.length), 0) + 2),
   );
-  const label = lang ? ` ${lang} ` : '';
-  const top = dim('┌' + (label ? gray(label) : '') + '─'.repeat(Math.max(0, contentWidth - visibleWidth(label) - 1)) + '┐');
+  const labelPlain = lang ? ` ${lang} ` : '';
+  const labelStyled = labelPlain ? PALETTE.fenceLabel(labelPlain) : '';
+  const ruleLen = Math.max(0, contentWidth - visibleWidth(labelPlain));
+  const top = dim('┌') + labelStyled + dim('─'.repeat(ruleLen) + '┐');
   const bottom = dim('└' + '─'.repeat(contentWidth) + '┘');
   const body = inner.map((l) => {
-    const text = colorEnabled() ? green(l) : l;
-    return dim('│ ') + text;
+    const text = colorFenceLine(l, isDiff);
+    const padTarget = Math.max(0, contentWidth - 1);
+    const padded = padVisible(text, padTarget);
+    return dim('│ ') + padded + dim('│');
   });
   return [top, ...body, bottom].join('\n');
 }
 
+function padVisible(text, targetWidth) {
+  const w = visibleWidth(text);
+  if (w >= targetWidth) return text;
+  return String(text ?? '') + ' '.repeat(targetWidth - w);
+}
+
+function isDiffFence(lang, lines) {
+  const tag = String(lang ?? '').trim().toLowerCase();
+  if (/^(diff|patch|udiff)$/.test(tag)) return true;
+  let hunk = false;
+  let delta = false;
+  for (const line of lines) {
+    const s = String(line ?? '');
+    if (/^@@/.test(s)) hunk = true;
+    if (/^\+/.test(s) && !/^\+\+\+/.test(s)) delta = true;
+    if (/^-/.test(s) && !/^---/.test(s)) delta = true;
+  }
+  return hunk && delta;
+}
+
+function colorFenceLine(line, isDiff) {
+  const s = String(line ?? '');
+  if (!colorEnabled()) return s;
+  if (!isDiff) return PALETTE.codeBlock(s);
+  if (/^@@/.test(s)) return PALETTE.diffHunk(s);
+  if (/^(\+\+\+|---)/.test(s)) return PALETTE.diffHunk(s);
+  if (/^\+/.test(s)) return PALETTE.diffAdd(s);
+  if (/^-/.test(s)) return PALETTE.diffDel(s);
+  return PALETTE.codeBlock(s);
+}
+
 // --- Inline ------------------------------------------------------------------
 
 /**
  * Render inline markdown spans. Order matters: we extract code spans first
  * (their contents are literal), then apply emphasis/link transforms to the rest.
  */
-function renderInline(text) {
+function renderInline(text, state) {
+  const st = state ?? { codeSpans: [] };
   let s = String(text ?? '');
 
   // Protect inline code spans from further formatting.
-  const codeSpans = [];
   s = s.replace(/`([^`]+)`/g, (_m, code) => {
-    const token = `\u0000C${codeSpans.length}\u0000`;
-    codeSpans.push(code);
+    const token = `\u0000C${st.codeSpans.length}\u0000`;
+    st.codeSpans.push(code);
     return token;
   });
 
   // Links: [text](url) -> text (url)
   s = s.replace(/\[([^\]]+)\]\(([^)\s]+)(?:\s+"[^"]*")?\)/g, (_m, label, url) => {
-    return underline(label) + ' ' + dim('(' + url + ')');
+    const linkLabel = compose(underline, PALETTE.link)(renderInline(label, st));
+    return linkLabel + ' ' + dim('(' + url + ')');
   });
 
   // Bold: **x** or __x__
@@ -187,8 +246,8 @@ function renderInline(text) {
 
   // Restore code spans, styled.
   s = s.replace(/\u0000C(\d+)\u0000/g, (_m, idx) => {
-    const code = codeSpans[Number(idx)] ?? '';
-    return colorEnabled() ? cyan(code) : '`' + code + '`';
+    const code = st.codeSpans[Number(idx)] ?? '';
+    return colorEnabled() ? PALETTE.inlineCode(code) : '`' + code + '`';
   });
 
   return s;

package/src/ui/markdown.test.mjs

@@ -0,0 +1,70 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { env } from 'node:process';
+import { renderMarkdown } from './markdown.mjs';
+import { refreshColorSupport, stripAnsi } from './ansi.mjs';
+
+test.before(() => {
+  env.FORCE_COLOR = '1';
+  refreshColorSupport();
+});
+
+test('renderMarkdown never throws on garbage input', () => {
+  assert.doesNotThrow(() => renderMarkdown('**unclosed `fence\n> quote\n'));
+  assert.equal(renderMarkdown(null), '');
+});
+
+test('diff fenced blocks color hunks and +/- lines', () => {
+  const src = [
+    '```diff',
+    '--- a/file.mjs',
+    '+++ b/file.mjs',
+    '@@ -1,2 +1,2 @@',
+    '-old',
+    '+new',
+    '```',
+  ].join('\n');
+  const out = renderMarkdown(src);
+  assert.match(out, /\x1b\[38;2;204;157;44/);
+  assert.match(out, /\x1b\[38;2;0;170;75/);
+  assert.match(out, /\x1b\[38;2;220;70;88/);
+  assert.ok(stripAnsi(out).includes('diff'));
+});
+
+test('inline code and headings use Mixdog accent colors', () => {
+  const out = renderMarkdown('# Title\nUse `code` here.');
+  assert.match(out, /\x1b\[38;2;215;119;87/);
+  assert.match(out, /\x1b\[38;2;138;190;183/);
+});
+
+test('longer fence opener does not close on shorter backtick line inside block', () => {
+  const src = ['````', '```', 'still inside', '````'].join('\n');
+  const plain = stripAnsi(renderMarkdown(src));
+  assert.ok(plain.includes('still inside'));
+  assert.ok(!plain.includes('```\nstill'));
+});
+
+test('mixed backtick-tilde closer does not end backtick fence', () => {
+  const src = ['```', '``~', 'still inside', '```'].join('\n');
+  const plain = stripAnsi(renderMarkdown(src));
+  assert.ok(plain.includes('still inside'));
+  assert.ok(plain.includes('``~'));
+});
+
+test('fenced code block body rows include right border', () => {
+  const out = stripAnsi(renderMarkdown('```js\nx\n```'));
+  const rows = out.split('\n').filter((line) => line.startsWith('│ '));
+  assert.ok(rows.length >= 1);
+  for (const row of rows) {
+    assert.match(row, /│\s*$/);
+  }
+});
+
+test('inline code inside link labels is preserved', () => {
+  const out = renderMarkdown('[see `foo`](https://example.com)');
+  const plain = stripAnsi(out);
+  assert.ok(plain.includes('foo'));
+  assert.ok(plain.includes('https://example.com'));
+  assert.match(out, /\x1b\[38;2;138;190;183/);
+});
+

package/src/ui/model-display.mjs

@@ -0,0 +1,121 @@
+/**
+ * Pure model display-name helpers shared by the TUI snap path and statusline.
+ * No I/O, catalog, or gateway imports — safe for static TUI bundling.
+ */
+
+export function titleModelPart(part) {
+  const text = String(part || '').trim();
+  if (!text) return '';
+  const lower = text.toLowerCase();
+  if (lower === 'gpt') return 'GPT';
+  if (lower === 'api') return 'API';
+  if (lower === 'v4') return 'V4';
+  return lower.charAt(0).toUpperCase() + lower.slice(1);
+}
+
+function stripModelId(model) {
+  const text = String(model || '').trim();
+  if (!text) return '';
+  return text.includes('/') ? (text.split('/').filter(Boolean).at(-1) || text) : text;
+}
+
+function normalizeDisplayHint(displayHint) {
+  if (displayHint == null || displayHint === '') return '';
+  if (typeof displayHint === 'object') {
+    return String(displayHint.displayName || displayHint.display || displayHint.name || '').trim();
+  }
+  return String(displayHint).trim();
+}
+
+export function canonicalModelDisplay(model, provider) {
+  void provider;
+  const raw = String(model || '')
+    .trim()
+    .replace(/-\d{4}-\d{2}-\d{2}$/, '')
+    .replace(/-\d{8}$/, '');
+  if (!raw) return '';
+
+  const gpt = raw.match(/^gpt-(\d+(?:\.\d+)?)(?:-(.+))?$/i);
+  if (gpt) {
+    const suffix = gpt[2]
+      ? '-' + gpt[2].split('-').map(titleModelPart).filter(Boolean).join('-')
+      : '';
+    return `GPT-${gpt[1]}${suffix}`;
+  }
+
+  if (/^gpt-/i.test(raw)) {
+    return raw
+      .split('-')
+      .map((part, index) => (index === 0 ? part.toUpperCase() : titleModelPart(part)))
+      .filter(Boolean)
+      .join('-');
+  }
+
+  const openaiO = raw.match(/^o(\d+(?:\.\d+)?)(?:-(.+))?$/i);
+  if (openaiO) {
+    const tail = openaiO[2]
+      ? ' ' + openaiO[2].split('-').map(titleModelPart).filter(Boolean).join(' ')
+      : '';
+    return `O${openaiO[1]}${tail}`;
+  }
+
+  const codex = raw.match(/^codex-(.+)$/i);
+  if (codex) {
+    return `Codex ${codex[1].split('-').map(titleModelPart).filter(Boolean).join(' ')}`;
+  }
+
+  const deepseek = raw.match(/^deepseek-(.+)$/i);
+  if (deepseek) {
+    return `DeepSeek ${deepseek[1].split('-').map(titleModelPart).filter(Boolean).join(' ')}`;
+  }
+
+  const grok = raw.match(/^grok-(.+)$/i);
+  if (grok) {
+    return `Grok ${grok[1].split('-').map(titleModelPart).filter(Boolean).join(' ')}`;
+  }
+
+  const claudeLegacy = raw.match(/^claude-(\d+)(?:-(\d+))?-(opus|sonnet|haiku)(?:-|$)/i);
+  if (claudeLegacy) {
+    const version = `${claudeLegacy[1]}${claudeLegacy[2] ? `.${claudeLegacy[2]}` : ''}`;
+    return `Claude ${titleModelPart(claudeLegacy[3])} ${version}`;
+  }
+
+  const claude = raw.match(/^claude-(opus|sonnet|haiku)-(.+)$/i);
+  if (claude) {
+    return `Claude ${titleModelPart(claude[1])} ${claude[2].replace(/-/g, '.')}`;
+  }
+
+  const gemini = raw.match(/^gemini-(\d+(?:\.\d+)?)-(.+)$/i);
+  if (gemini) {
+    return `Gemini ${gemini[1]} ${gemini[2].split('-').map(titleModelPart).filter(Boolean).join(' ')}`;
+  }
+
+  const geminiLoose = raw.match(/^gemini-(.+)$/i);
+  if (geminiLoose) {
+    return `Gemini ${geminiLoose[1].split('-').map(titleModelPart).filter(Boolean).join(' ')}`;
+  }
+
+  return raw;
+}
+
+export function displayModelName(model, provider = '', displayHint = '') {
+  const id = stripModelId(model);
+  const hint = normalizeDisplayHint(displayHint);
+
+  if (id) {
+    const canonical = canonicalModelDisplay(id, provider);
+    if (canonical && canonical !== id) return canonical;
+  }
+  if (hint) return hint;
+  if (id) return canonicalModelDisplay(id, provider) || id;
+  return '';
+}
+
+export function shortenModelName(name, cols) {
+  let out = String(name || 'model').replace(/\s*\(1M context\)/i, ' (1M)');
+  out = out.replace(/^Claude\s+/i, '');
+  out = out.replace(/^OpenAI\s+/i, '');
+  if (cols < 80 && out.length > 18) return out.slice(0, 17) + '…';
+  if (cols < 120 && out.length > 28) return out.slice(0, 27) + '…';
+  return out;
+}

package/src/ui/session-stats.mjs

@@ -0,0 +1,44 @@
+/** Create a mutable session-usage accumulator. */
+export function createSessionStats() {
+  return {
+    inputTokens: 0,
+    outputTokens: 0,
+    cachedTokens: 0,
+    cacheWriteTokens: 0,
+    promptTokens: 0,
+    latestInputTokens: 0,
+    latestOutputTokens: 0,
+    latestCachedTokens: 0,
+    latestCacheWriteTokens: 0,
+    latestPromptTokens: 0,
+    costUsd: 0,
+    turns: 0,
+  };
+}
+
+/**
+ * Fold one `onUsageDelta` event into the accumulator.
+ * @param {object} stats — from createSessionStats()
+ * @param {object} delta — { deltaInput, deltaOutput, deltaCachedRead, deltaCacheWrite, costUsd }
+ */
+export function applyUsageDelta(stats, delta = {}) {
+  if (!stats || !delta) return stats;
+  stats.inputTokens += num(delta.deltaInput);
+  stats.outputTokens += num(delta.deltaOutput);
+  stats.cachedTokens += num(delta.deltaCachedRead);
+  stats.cacheWriteTokens += num(delta.deltaCacheWrite);
+  stats.promptTokens += num(delta.deltaPrompt);
+  stats.latestInputTokens = num(delta.deltaInput);
+  stats.latestOutputTokens = num(delta.deltaOutput);
+  stats.latestCachedTokens = num(delta.deltaCachedRead);
+  stats.latestCacheWriteTokens = num(delta.deltaCacheWrite);
+  stats.latestPromptTokens = num(delta.deltaPrompt);
+  // costUsd from the engine is cumulative-per-call; we sum the per-turn deltas.
+  stats.costUsd += num(delta.costUsd);
+  return stats;
+}
+
+function num(v) {
+  const n = Number(v);
+  return Number.isFinite(n) ? n : 0;
+}

package/src/ui/statusline-context-label.test.mjs

@@ -0,0 +1,15 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { contextPctDisplayLabel } from './statusline.mjs';
+
+test('contextPctDisplayLabel clamps displayed percent at 100', () => {
+  assert.equal(contextPctDisplayLabel(105), '100');
+  assert.equal(contextPctDisplayLabel(100.9), '100');
+  assert.equal(contextPctDisplayLabel(99.2), '99');
+});
+
+test('contextPctDisplayLabel keeps sub-1% decimal display', () => {
+  assert.equal(contextPctDisplayLabel(0.45), '0.5');
+  assert.equal(contextPctDisplayLabel(0.04), '0');
+});
+