@aragon-agent/cli 0.4.3

package/dist/ui/palettes.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Palettes (spec §4.5) — the raw hex data behind `getTheme()`, split out of
+ * `theme.ts` so the color decisions live in one readable place and can be
+ * contrast-tested without pulling in the degradation machinery.
+ *
+ * `WARM` is the new default. The old Tokyo-Night-derived palette survives under
+ * its accurate name `COOL` and stays reachable via `--theme cool`, so nobody's
+ * screen changes without them being able to change it back (R-4).
+ *
+ * Theme names describe COLOR TEMPERATURE on purpose. Naming a theme after
+ * another company's product would imply an affiliation or an asset licence that
+ * does not exist; `warm` / `cool` are accurate and carry no such claim.
+ */
+import type { ThemeName } from '../config/schema.js';
+export interface Palette {
+    primary: string;
+    accent: string;
+    user: string;
+    assistant: string;
+    thinking: string;
+    toolPending: string;
+    toolRunning: string;
+    toolDone: string;
+    toolError: string;
+    noticeInfo: string;
+    noticeWarn: string;
+    noticeError: string;
+    muted: string;
+    border: string;
+    code: string;
+    focusBorder: string;
+    idleBorder: string;
+    hintFg: string;
+    logoShadow: string;
+    gradient: [string, string, string];
+    gauge: {
+        track: string;
+        low: string;
+        mid: string;
+        high: string;
+    };
+    diff: {
+        add: string;
+        remove: string;
+        meta: string;
+        context: string;
+    };
+    toast: {
+        info: string;
+        warn: string;
+        error: string;
+        success: string;
+    };
+    chip: {
+        fg: string;
+        bg: string;
+    };
+}
+/**
+ * The reference dark background these palettes are contrast-checked against.
+ * `palettes.test.ts` (A-7) pins `assistant` / `muted` / `hintFg` at WCAG AA
+ * (>= 4.5:1) here so a later "just nudging the hue" cannot quietly make body
+ * text unreadable.
+ */
+export declare const DARK_SURFACE = "#1c1917";
+/** Terracotta + amber over warm neutrals — the v0.4.0 default. */
+export declare const WARM: Palette;
+/** The v0.3.0 palette, renamed. Reachable via `--theme cool` / `theme: "dark"`. */
+export declare const COOL: Palette;
+export declare const LIGHT: Palette;
+/**
+ * Resolve a theme name to its palette.
+ *
+ * `auto` never guesses light: terminals cannot reliably report their background
+ * colour, and guessing wrong makes the app unreadable. `dark` is accepted here
+ * as well as in `clampTheme` because a persisted config written by v0.3.0 can
+ * still be sitting on disk when this runs.
+ */
+export declare function resolvePalette(name: ThemeName | 'dark'): Palette;

package/dist/ui/palettes.js

@@ -0,0 +1,115 @@
+/**
+ * Palettes (spec §4.5) — the raw hex data behind `getTheme()`, split out of
+ * `theme.ts` so the color decisions live in one readable place and can be
+ * contrast-tested without pulling in the degradation machinery.
+ *
+ * `WARM` is the new default. The old Tokyo-Night-derived palette survives under
+ * its accurate name `COOL` and stays reachable via `--theme cool`, so nobody's
+ * screen changes without them being able to change it back (R-4).
+ *
+ * Theme names describe COLOR TEMPERATURE on purpose. Naming a theme after
+ * another company's product would imply an affiliation or an asset licence that
+ * does not exist; `warm` / `cool` are accurate and carry no such claim.
+ */
+/**
+ * The reference dark background these palettes are contrast-checked against.
+ * `palettes.test.ts` (A-7) pins `assistant` / `muted` / `hintFg` at WCAG AA
+ * (>= 4.5:1) here so a later "just nudging the hue" cannot quietly make body
+ * text unreadable.
+ */
+export const DARK_SURFACE = '#1c1917';
+/** Terracotta + amber over warm neutrals — the v0.4.0 default. */
+export const WARM = {
+    primary: '#d08c60',
+    accent: '#c9a227',
+    user: '#7fb08a',
+    assistant: '#e6ddd1',
+    thinking: '#a2968a',
+    toolPending: '#8a7f74',
+    toolRunning: '#c9a227',
+    toolDone: '#7fb08a',
+    toolError: '#cf6b5c',
+    noticeInfo: '#d08c60',
+    noticeWarn: '#c9a227',
+    noticeError: '#cf6b5c',
+    muted: '#a2968a',
+    border: '#4a423b',
+    code: '#c9a97a',
+    focusBorder: '#d08c60',
+    idleBorder: '#4a423b',
+    hintFg: '#9c9086',
+    logoShadow: '#4a423b',
+    gradient: ['#d08c60', '#c9a227', '#b0916a'],
+    gauge: { track: '#4a423b', low: '#7fb08a', mid: '#c9a227', high: '#cf6b5c' },
+    diff: { add: '#7fb08a', remove: '#cf6b5c', meta: '#d08c60', context: '#a2968a' },
+    toast: { info: '#d08c60', warn: '#c9a227', error: '#cf6b5c', success: '#7fb08a' },
+    chip: { fg: '#1c1917', bg: '#d08c60' },
+};
+/** The v0.3.0 palette, renamed. Reachable via `--theme cool` / `theme: "dark"`. */
+export const COOL = {
+    primary: '#7aa2f7',
+    accent: '#bb9af7',
+    user: '#7dcfff',
+    assistant: '#c0caf5',
+    thinking: '#7a86b8',
+    toolPending: '#565f89',
+    toolRunning: '#e0af68',
+    toolDone: '#9ece6a',
+    toolError: '#f7768e',
+    noticeInfo: '#7aa2f7',
+    noticeWarn: '#e0af68',
+    noticeError: '#f7768e',
+    muted: '#565f89',
+    border: '#3b4261',
+    code: '#9ece6a',
+    focusBorder: '#7aa2f7',
+    idleBorder: '#3b4261',
+    hintFg: '#565f89',
+    logoShadow: '#3b4261',
+    gradient: ['#7aa2f7', '#bb9af7', '#7dcfff'],
+    gauge: { track: '#3b4261', low: '#9ece6a', mid: '#e0af68', high: '#f7768e' },
+    diff: { add: '#9ece6a', remove: '#f7768e', meta: '#7aa2f7', context: '#7a86b8' },
+    toast: { info: '#7aa2f7', warn: '#e0af68', error: '#f7768e', success: '#9ece6a' },
+    chip: { fg: '#1a1b26', bg: '#7aa2f7' },
+};
+export const LIGHT = {
+    primary: '#2959aa',
+    accent: '#8c4bc9',
+    user: '#0f7490',
+    assistant: '#1f2430',
+    thinking: '#6b7280',
+    toolPending: '#9aa0ab',
+    toolRunning: '#b5730f',
+    toolDone: '#2e7d32',
+    toolError: '#c62828',
+    noticeInfo: '#2959aa',
+    noticeWarn: '#b5730f',
+    noticeError: '#c62828',
+    muted: '#6b7280',
+    border: '#c8cdd6',
+    code: '#3f7f2f',
+    focusBorder: '#2959aa',
+    idleBorder: '#c8cdd6',
+    hintFg: '#6b7280',
+    logoShadow: '#c8cdd6',
+    gradient: ['#2959aa', '#8c4bc9', '#0f7490'],
+    gauge: { track: '#c8cdd6', low: '#2e7d32', mid: '#b5730f', high: '#c62828' },
+    diff: { add: '#2e7d32', remove: '#c62828', meta: '#2959aa', context: '#6b7280' },
+    toast: { info: '#2959aa', warn: '#b5730f', error: '#c62828', success: '#2e7d32' },
+    chip: { fg: '#ffffff', bg: '#2959aa' },
+};
+/**
+ * Resolve a theme name to its palette.
+ *
+ * `auto` never guesses light: terminals cannot reliably report their background
+ * colour, and guessing wrong makes the app unreadable. `dark` is accepted here
+ * as well as in `clampTheme` because a persisted config written by v0.3.0 can
+ * still be sitting on disk when this runs.
+ */
+export function resolvePalette(name) {
+    if (name === 'light')
+        return LIGHT;
+    if (name === 'cool' || name === 'dark')
+        return COOL;
+    return WARM;
+}

package/dist/ui/screen.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Alternate screen buffer take-over (spec §4.4).
+ *
+ * Why the alt-screen and not a clear: `\x1b[3J` destroys the user's scrollback
+ * (their build log, their stack trace) — an unacceptable side effect for a
+ * developer tool. The alt-screen is non-destructive: the main buffer is covered,
+ * not erased, and comes back untouched on exit. It also parks the cursor at
+ * (1,1), which gives the frame accounting in §4.2 a deterministic origin.
+ *
+ * CALL SITE IS LOAD-BEARING: only `cli.tsx::runInteractive()` may call this.
+ * Hoisting it into `buildProgram()` / `parseAsync` would push `\x1b[?1049h`
+ * into `aragon -p "…" > out.txt`, `aragon config set`, and `aragon --version`.
+ */
+export interface ScreenHandle {
+    /** Leave the alternate screen. Idempotent — safe from every exit path. */
+    restore(): void;
+}
+/**
+ * Enter the alternate screen. A non-TTY stdout is a hard no-op (tests, pipes,
+ * CI) — writing screen-control sequences into a redirected file corrupts it.
+ */
+export declare function enterAltScreen(stdout: NodeJS.WriteStream | undefined): ScreenHandle;
+/**
+ * Replay the session summary into the normal buffer after `restore()`, so the
+ * conversation does not evaporate along with the alternate screen.
+ */
+export declare function writeExitTranscript(stdout: NodeJS.WriteStream | undefined, text: string): void;

package/dist/ui/screen.js

@@ -0,0 +1,57 @@
+/**
+ * Alternate screen buffer take-over (spec §4.4).
+ *
+ * Why the alt-screen and not a clear: `\x1b[3J` destroys the user's scrollback
+ * (their build log, their stack trace) — an unacceptable side effect for a
+ * developer tool. The alt-screen is non-destructive: the main buffer is covered,
+ * not erased, and comes back untouched on exit. It also parks the cursor at
+ * (1,1), which gives the frame accounting in §4.2 a deterministic origin.
+ *
+ * CALL SITE IS LOAD-BEARING: only `cli.tsx::runInteractive()` may call this.
+ * Hoisting it into `buildProgram()` / `parseAsync` would push `\x1b[?1049h`
+ * into `aragon -p "…" > out.txt`, `aragon config set`, and `aragon --version`.
+ */
+const ENTER_ALT = '\x1b[?1049h';
+const LEAVE_ALT = '\x1b[?1049l';
+const CURSOR_HOME = '\x1b[H';
+const CLEAR_VISIBLE = '\x1b[2J';
+/** Ink's log-update hides the cursor; a signal kill never gives it back. */
+const SHOW_CURSOR = '\x1b[?25h';
+const NOOP_HANDLE = { restore() { } };
+function safeWrite(stdout, data) {
+    try {
+        stdout.write(data);
+    }
+    catch {
+        // A closed/broken stdout must never turn into a crash on the exit path.
+    }
+}
+/**
+ * Enter the alternate screen. A non-TTY stdout is a hard no-op (tests, pipes,
+ * CI) — writing screen-control sequences into a redirected file corrupts it.
+ */
+export function enterAltScreen(stdout) {
+    if (!stdout || !stdout.isTTY || typeof stdout.write !== 'function')
+        return NOOP_HANDLE;
+    safeWrite(stdout, ENTER_ALT + CLEAR_VISIBLE + CURSOR_HOME);
+    let restored = false;
+    return {
+        restore() {
+            if (restored)
+                return;
+            restored = true;
+            safeWrite(stdout, SHOW_CURSOR + LEAVE_ALT);
+        },
+    };
+}
+/**
+ * Replay the session summary into the normal buffer after `restore()`, so the
+ * conversation does not evaporate along with the alternate screen.
+ */
+export function writeExitTranscript(stdout, text) {
+    if (!stdout || typeof stdout.write !== 'function')
+        return;
+    if (text.length === 0)
+        return;
+    safeWrite(stdout, text.endsWith('\n') ? text : `${text}\n`);
+}

package/dist/ui/theme.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Theme — palette + symbols used across the Ink component tree (spec §3.2).
+ *
+ * A real theming engine: distinct `WARM` / `COOL` / `LIGHT` hex palettes, an
+ * `auto` resolution that is deterministic (`auto -> warm`, since terminals
+ * cannot reliably report their background), color degradation across terminal
+ * depth (truecolor -> 256 -> 16 -> monochrome), and an ASCII symbol swap for
+ * terminals without Unicode support.
+ *
+ * Two things used to live here and no longer do (spec §4.1 / §4.5):
+ *  - the three symbol tables moved to `glyphs.ts`, which is now the single
+ *    source of truth for every user-visible character. `symbols` is a VIEW of
+ *    `pickGlyphs(caps)`, so every existing `theme.symbols.x` consumer is
+ *    unchanged;
+ *  - the palette data moved to `palettes.ts`.
+ */
+import type { ThemeName } from '../config/schema.js';
+import type { TermCapabilities } from './capabilities.js';
+import { type Glyphs } from './glyphs.js';
+/** A resolved color: a hex/name string, or `undefined` (Ink renders plain). */
+type Color = string | undefined;
+/**
+ * Retained name for the symbol view on `Theme`. It is exactly `Glyphs`: the
+ * split is by ownership (glyphs.ts owns the data), not by shape.
+ */
+export type ThemeSymbols = Glyphs;
+export interface Theme {
+    name: ThemeName;
+    symbols: ThemeSymbols;
+    primary: Color;
+    accent: Color;
+    user: Color;
+    assistant: Color;
+    thinking: Color;
+    toolPending: Color;
+    toolRunning: Color;
+    toolDone: Color;
+    toolError: Color;
+    noticeInfo: Color;
+    noticeWarn: Color;
+    noticeError: Color;
+    muted: Color;
+    border: Color;
+    code: Color;
+    /** Composer border while the input holds a draft. */
+    focusBorder: Color;
+    /** Composer border while idle and empty (matches the legacy `border`). */
+    idleBorder: Color;
+    /** Hint lines, collapse notices, and the off-bottom indicator. */
+    hintFg: Color;
+    /** Single-color wordmark fallback below ansi-256. */
+    logoShadow: Color;
+    gradient: string[];
+    gauge: {
+        track: Color;
+        low: Color;
+        mid: Color;
+        high: Color;
+    };
+    diff: {
+        add: Color;
+        remove: Color;
+        meta: Color;
+        context: Color;
+    };
+    toast: {
+        info: Color;
+        warn: Color;
+        error: Color;
+        success: Color;
+    };
+    chip: {
+        fg: Color;
+        bg: Color;
+    };
+}
+export declare function getTheme(name: ThemeName, caps: TermCapabilities): Theme;
+export {};

package/dist/ui/theme.js

@@ -0,0 +1,127 @@
+/**
+ * Theme — palette + symbols used across the Ink component tree (spec §3.2).
+ *
+ * A real theming engine: distinct `WARM` / `COOL` / `LIGHT` hex palettes, an
+ * `auto` resolution that is deterministic (`auto -> warm`, since terminals
+ * cannot reliably report their background), color degradation across terminal
+ * depth (truecolor -> 256 -> 16 -> monochrome), and an ASCII symbol swap for
+ * terminals without Unicode support.
+ *
+ * Two things used to live here and no longer do (spec §4.1 / §4.5):
+ *  - the three symbol tables moved to `glyphs.ts`, which is now the single
+ *    source of truth for every user-visible character. `symbols` is a VIEW of
+ *    `pickGlyphs(caps)`, so every existing `theme.symbols.x` consumer is
+ *    unchanged;
+ *  - the palette data moved to `palettes.ts`.
+ */
+import { pickGlyphs } from './glyphs.js';
+import { resolvePalette } from './palettes.js';
+// ---------------------------------------------------------------------------
+// Color degradation (truecolor -> 256 -> 16 -> monochrome)
+// ---------------------------------------------------------------------------
+/** The 16 standard ANSI colours as chalk names + representative RGB. */
+const ANSI16 = [
+    ['black', [0, 0, 0]],
+    ['red', [205, 49, 49]],
+    ['green', [13, 188, 121]],
+    ['yellow', [229, 229, 16]],
+    ['blue', [36, 114, 200]],
+    ['magenta', [188, 63, 188]],
+    ['cyan', [17, 168, 205]],
+    ['white', [229, 229, 229]],
+    ['gray', [102, 102, 102]],
+    ['redBright', [241, 76, 76]],
+    ['greenBright', [35, 209, 139]],
+    ['yellowBright', [245, 245, 67]],
+    ['blueBright', [59, 142, 234]],
+    ['magentaBright', [214, 112, 214]],
+    ['cyanBright', [41, 184, 219]],
+    ['whiteBright', [255, 255, 255]],
+];
+function hexToRgb(hex) {
+    let h = hex.replace('#', '').trim();
+    if (h.length === 3)
+        h = h[0] + h[0] + h[1] + h[1] + h[2] + h[2];
+    const n = Number.parseInt(h, 16);
+    return [(n >> 16) & 0xff, (n >> 8) & 0xff, n & 0xff];
+}
+/** Nearest of the 16 ANSI colours (chalk name) to an arbitrary hex. */
+function nearestAnsi16(hex) {
+    const [r, g, b] = hexToRgb(hex);
+    let best = ANSI16[0][0];
+    let bestDist = Infinity;
+    for (const [name, [cr, cg, cb]] of ANSI16) {
+        const d = (r - cr) ** 2 + (g - cg) ** 2 + (b - cb) ** 2;
+        if (d < bestDist) {
+            bestDist = d;
+            best = name;
+        }
+    }
+    return best;
+}
+/** Degrade a hex colour to the terminal's depth; `undefined` at level 0. */
+function degrade(hex, level) {
+    if (level === 0)
+        return undefined;
+    if (level === 1)
+        return nearestAnsi16(hex);
+    return hex; // level 2/3: Ink/chalk downsamples the hex as needed
+}
+// ---------------------------------------------------------------------------
+// getTheme (memoized)
+// ---------------------------------------------------------------------------
+const cache = new Map();
+export function getTheme(name, caps) {
+    const key = `${name}|${caps.colorLevel}|${caps.unicode}`;
+    const hit = cache.get(key);
+    if (hit)
+        return hit;
+    const palette = resolvePalette(name);
+    const level = caps.colorLevel;
+    const d = (hex) => degrade(hex, level);
+    const theme = {
+        name,
+        symbols: pickGlyphs(caps),
+        primary: d(palette.primary),
+        accent: d(palette.accent),
+        user: d(palette.user),
+        assistant: d(palette.assistant),
+        thinking: d(palette.thinking),
+        toolPending: d(palette.toolPending),
+        toolRunning: d(palette.toolRunning),
+        toolDone: d(palette.toolDone),
+        toolError: d(palette.toolError),
+        noticeInfo: d(palette.noticeInfo),
+        noticeWarn: d(palette.noticeWarn),
+        noticeError: d(palette.noticeError),
+        muted: d(palette.muted),
+        border: d(palette.border),
+        code: d(palette.code),
+        focusBorder: d(palette.focusBorder),
+        idleBorder: d(palette.idleBorder),
+        hintFg: d(palette.hintFg),
+        logoShadow: d(palette.logoShadow),
+        gradient: level >= 2 ? [...palette.gradient] : [],
+        gauge: {
+            track: d(palette.gauge.track),
+            low: d(palette.gauge.low),
+            mid: d(palette.gauge.mid),
+            high: d(palette.gauge.high),
+        },
+        diff: {
+            add: d(palette.diff.add),
+            remove: d(palette.diff.remove),
+            meta: d(palette.diff.meta),
+            context: d(palette.diff.context),
+        },
+        toast: {
+            info: d(palette.toast.info),
+            warn: d(palette.toast.warn),
+            error: d(palette.toast.error),
+            success: d(palette.toast.success),
+        },
+        chip: { fg: d(palette.chip.fg), bg: d(palette.chip.bg) },
+    };
+    cache.set(key, theme);
+    return theme;
+}

package/dist/ui/transcript-text.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Plain-text session rendering (spec §4.4). Pure, colorless, ANSI-free, so the
+ * exit replay can be piped, diffed, or pasted into an issue.
+ *
+ * Used only by the full-screen exit replay: inline mode already left the real
+ * transcript in the terminal's native scrollback, and replaying there would
+ * simply print everything twice.
+ */
+import type { Entry, UsageTotal } from '../agent/reducer.js';
+import type { Glyphs } from './glyphs.js';
+export interface TranscriptTextOptions {
+    /**
+     * Glyph set for the terminal being replayed into. The exit replay lands in
+     * the SAME terminal the TUI just left, so it degrades by the same rule; it
+     * used to spell 11 Unicode literals of its own and wrote mojibake straight
+     * into the user's normal buffer on a legacy console.
+     */
+    glyphs: Glyphs;
+    usageTotal: UsageTotal;
+    model: string;
+    provider: string;
+    elapsedMs: number;
+    /** Entries beyond this count collapse into a single "… N omitted" line. */
+    maxEntries?: number;
+}
+/** Render the whole session (summary line + entries) as plain text. */
+export declare function renderTranscriptText(entries: Entry[], opts: TranscriptTextOptions): string;

package/dist/ui/transcript-text.js

@@ -0,0 +1,110 @@
+/**
+ * Plain-text session rendering (spec §4.4). Pure, colorless, ANSI-free, so the
+ * exit replay can be piped, diffed, or pasted into an issue.
+ *
+ * Used only by the full-screen exit replay: inline mode already left the real
+ * transcript in the terminal's native scrollback, and replaying there would
+ * simply print everything twice.
+ */
+import { formatCost, formatDuration, formatTokens } from '../agent/usage.js';
+const DEFAULT_MAX_ENTRIES = 200;
+const CONTINUATION_INDENT = '  ';
+const TOOL_INDENT = '  ';
+const MAX_ARG_CHARS = 60;
+/** Prefix the first line with `marker`, indent the rest to line up under it. */
+function block(marker, text) {
+    const lines = text.replace(/\r\n/g, '\n').split('\n');
+    const head = `${marker} ${lines[0] ?? ''}`.trimEnd();
+    const rest = lines.slice(1).map((l) => `${CONTINUATION_INDENT}${l}`.trimEnd());
+    return [head, ...rest];
+}
+/** A short, single-line rendering of the tool's arguments. */
+function argSummary(entry, glyphs) {
+    const source = entry.args ?? safeParse(entry.argsRaw);
+    if (!source)
+        return '';
+    const parts = [];
+    for (const value of Object.values(source)) {
+        if (typeof value === 'string')
+            parts.push(value);
+        else if (typeof value === 'number' || typeof value === 'boolean')
+            parts.push(String(value));
+        if (parts.length >= 2)
+            break;
+    }
+    const joined = parts.join(' ').replace(/\s+/g, ' ').trim();
+    if (joined.length === 0)
+        return '';
+    return joined.length > MAX_ARG_CHARS
+        ? `${joined.slice(0, MAX_ARG_CHARS - 1)}${glyphs.ellipsis}`
+        : joined;
+}
+function safeParse(raw) {
+    if (!raw || raw.trim().length === 0)
+        return null;
+    try {
+        const parsed = JSON.parse(raw);
+        return parsed && typeof parsed === 'object' ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function renderEntry(entry, glyphs) {
+    switch (entry.kind) {
+        case 'user':
+            return block(glyphs.user, entry.text);
+        case 'assistant': {
+            const suffix = entry.aborted ? ' (aborted)' : '';
+            return block(glyphs.assistant, `${entry.text}${suffix}`);
+        }
+        case 'tool': {
+            const glyph = entry.isError || entry.status === 'error' ? glyphs.toolError : glyphs.toolDone;
+            const args = argSummary(entry, glyphs);
+            const duration = entry.durationMs === undefined ? '' : ` (${entry.durationMs}ms)`;
+            return [`${TOOL_INDENT}${glyph} ${entry.label || entry.name}${args ? ` ${args}` : ''}${duration}`];
+        }
+        case 'notice': {
+            const glyph = entry.level === 'error'
+                ? glyphs.error
+                : entry.level === 'warn'
+                    ? glyphs.warn
+                    : glyphs.info;
+            return block(`${TOOL_INDENT}${glyph}`, entry.text);
+        }
+        default:
+            return [];
+    }
+}
+/** Render the whole session (summary line + entries) as plain text. */
+export function renderTranscriptText(entries, opts) {
+    const turns = entries.filter((e) => e.kind === 'user').length;
+    const g = opts.glyphs;
+    const tokens = `${formatTokens(opts.usageTotal.inputTokens)}${g.arrowUp} ${formatTokens(opts.usageTotal.outputTokens)}${g.arrowDown}`;
+    const summary = [
+        'aragon',
+        `${opts.provider}:${opts.model}`,
+        `${turns} ${turns === 1 ? 'turn' : 'turns'}`,
+        tokens,
+        formatCost(opts.usageTotal.costUsd),
+        formatDuration(Math.max(0, opts.elapsedMs)),
+    ].join(` ${g.midDot} `);
+    const max = opts.maxEntries ?? DEFAULT_MAX_ENTRIES;
+    const lines = [summary];
+    if (entries.length > max && max > 1) {
+        const head = Math.ceil(max / 2);
+        const tail = max - head;
+        const omitted = entries.length - max;
+        for (const entry of entries.slice(0, head))
+            lines.push(...renderEntry(entry, g));
+        lines.push(`${g.ellipsis} ${omitted} entries omitted ${g.midDot} use /save before exiting`);
+        for (const entry of entries.slice(entries.length - tail)) {
+            lines.push(...renderEntry(entry, g));
+        }
+    }
+    else {
+        for (const entry of entries)
+            lines.push(...renderEntry(entry, g));
+    }
+    return `${lines.join('\n')}\n`;
+}