@aragon-agent/tui 0.0.0-stage → 0.0.1

package/dist/testing/governance-fixtures.js

@@ -0,0 +1,98 @@
+/**
+ * Snapshot / card fixtures for the governance TUI tests. The engine is built by another
+ * agent, so every UI test runs against these hand-built shapes.
+ */
+export const NOW = 1_000_000;
+export function rosterRow(over = {}) {
+    return {
+        id: 'dev1',
+        role: 'DEV',
+        generation: 0,
+        state: 'working',
+        wpId: 'auth-api',
+        activity: 'login endpoint + session',
+        confirmed: 100,
+        provisional: 0,
+        label: 'NORMAL',
+        lastDelta: null,
+        replacedBy: null,
+        ...over,
+    };
+}
+export function pipeline(active = 'review') {
+    const keys = ['intake', 'dev', 'review', 'test', 'settle', 'integrate'];
+    const at = keys.indexOf(active);
+    return keys.map((key, index) => ({
+        key,
+        state: index < at ? 'done' : index === at ? 'active' : 'pending',
+    }));
+}
+/** The six-member roster of the spec's 10.3 sketch. */
+export function sketchRoster() {
+    return [
+        rosterRow({ id: 'dev1', state: 'submitted', confirmed: 100, provisional: 15, activity: '' }),
+        rosterRow({
+            id: 'dev2', wpId: 'ui-form', state: 'submitted', confirmed: 80, label: 'WARNING',
+            activity: 'rework 1/3',
+        }),
+        rosterRow({
+            id: 'rev1', role: 'REV', state: 'working', wpId: 'auth-api',
+            activity: 'grep "sanitize" src/auth',
+        }),
+        rosterRow({
+            id: 'rev2', role: 'REV', state: 'working', wpId: 'ui-form',
+            activity: 'read_file ui/Form.tsx',
+        }),
+        rosterRow({ id: 'tst1', role: 'TEST', state: 'queued', wpId: null, activity: '' }),
+        rosterRow({
+            id: 'insp', role: 'INSP', state: 'idle', wpId: null, activity: '', confirmed: null,
+            label: 'NOT_SCORED',
+        }),
+    ];
+}
+export function snapshot(over = {}) {
+    return {
+        runId: 'gmh3k7f3a',
+        goal: 'ship the login flow',
+        status: 'executing',
+        phase: 2,
+        phaseCount: 3,
+        stage: 'review',
+        stageRunning: true,
+        startedAt: NOW - 842_000,
+        pipeline: pipeline('review'),
+        roster: sketchRoster(),
+        health: 88,
+        recent: [
+            { at: NOW - 3000, agentId: 'rev2', code: 'R2', delta: 10, provisional: false, reason: 'valid finding' },
+            { at: NOW - 2000, agentId: 'dev2', code: 'D5', delta: -20, provisional: false, reason: 'rework' },
+            { at: NOW - 1000, agentId: 'dev1', code: 'D1', delta: 15, provisional: true, reason: 'review pass' },
+        ],
+        usage: { inputTokens: 300_000, outputTokens: 112_000, costUsd: 0.42 },
+        budgetTokens: 0,
+        alerts: [],
+        reworkNote: 'rework 1/3 (ui-form)',
+        rev: 1,
+        ...over,
+    };
+}
+export function manyAgents(count) {
+    return Array.from({ length: count }, (_, i) => rosterRow({ id: `dev${i + 1}`, wpId: `wp-${i + 1}` }));
+}
+export function card(over = {}) {
+    return {
+        variant: 'phase',
+        runId: 'gmh3k7f3a',
+        title: 'phase 2 integrated',
+        headline: 'integration passed (attempt 1)   3 contracts checked   npm test: 214 ok',
+        tone: 'ok',
+        rows: [
+            { id: 'dev1', role: 'DEV', confirmed: 115, deltaText: '+15P->C D1  +10 D12  +5 C1' },
+            { id: 'dev2', role: 'DEV', confirmed: 90, deltaText: '-20 D5  +10 D12  +5 C1' },
+            { id: 'rev1', role: 'REV', confirmed: 110, deltaText: '+10P->C R1  +10 R10' },
+            { id: 'tst1', role: 'TEST', confirmed: 105, deltaText: '+10P->C T1  +5 C1' },
+        ],
+        notes: ['dev2 reworked once', 'no eliminations', 'health 96'],
+        ...over,
+    };
+}

package/dist/testing/mini-vt.d.ts

@@ -0,0 +1,28 @@
+/**
+ * A minimal VT screen with a SCROLLBACK, for native-scroll tests
+ * (tui-native-terminal-scroll §9.1).
+ *
+ * `vt-screen.ts` models only a fixed alternate screen. Native mode is about what
+ * the host terminal does when output runs past the bottom: the top row moves into
+ * scrollback. This model supports exactly the whitelist the writer may emit (SGR,
+ * CUU, CUD, CHA, CR, LF, ED0, EL0, DEC private modes) and RECORDS every sequence on
+ * the blacklist instead of acting on it, so a test can assert both the resulting
+ * screen and that nothing forbidden was ever written (I-S5 / I-S6).
+ */
+export type MiniVtWrapModel = 'at-last-column' | 'virtual-column';
+export interface MiniVt {
+    write(data: string): void;
+    /** Visible rows, right-trimmed. */
+    screen(): string[];
+    /** Rows that scrolled off the top, oldest first, right-trimmed. */
+    readonly scrollback: string[];
+    /** scrollback + screen, with trailing blank screen rows removed. */
+    history(): string[];
+    cursor(): {
+        row: number;
+        col: number;
+    };
+    /** Blacklisted sequences seen (`ESC[?1049h`, `ESC[3J`, a CUP, ...). */
+    readonly forbidden: string[];
+}
+export declare function createMiniVt(rows: number, cols: number, model?: MiniVtWrapModel): MiniVt;

package/dist/testing/mini-vt.js

@@ -0,0 +1,158 @@
+/**
+ * A minimal VT screen with a SCROLLBACK, for native-scroll tests
+ * (tui-native-terminal-scroll §9.1).
+ *
+ * `vt-screen.ts` models only a fixed alternate screen. Native mode is about what
+ * the host terminal does when output runs past the bottom: the top row moves into
+ * scrollback. This model supports exactly the whitelist the writer may emit (SGR,
+ * CUU, CUD, CHA, CR, LF, ED0, EL0, DEC private modes) and RECORDS every sequence on
+ * the blacklist instead of acting on it, so a test can assert both the resulting
+ * screen and that nothing forbidden was ever written (I-S5 / I-S6).
+ */
+import stringWidth from 'string-width';
+const FORBIDDEN_PRIVATE = new Set([1049, 1047, 47, 1000, 1002, 1003, 1006, 1007]);
+export function createMiniVt(rows, cols, model = 'virtual-column') {
+    const blank = () => new Array(cols).fill(' ');
+    const grid = Array.from({ length: rows }, blank);
+    const scrollback = [];
+    const forbidden = [];
+    let r = 0;
+    let c = 0;
+    let pending = false;
+    const text = (cells) => cells.join('').replace(/\s+$/, '');
+    const clamp = (v, max) => Math.max(0, Math.min(max, v));
+    const lineFeed = () => {
+        if (r === rows - 1) {
+            scrollback.push(text(grid.shift()));
+            grid.push(blank());
+        }
+        else
+            r += 1;
+    };
+    const print = (glyph) => {
+        const width = Math.max(1, stringWidth(glyph));
+        if (pending) {
+            c = 0;
+            pending = false;
+            lineFeed();
+        }
+        if (c + width > cols) {
+            c = 0;
+            lineFeed();
+        }
+        grid[r][c] = glyph;
+        for (let k = 1; k < width; k += 1)
+            grid[r][c + k] = '';
+        c += width;
+        if (c >= cols) {
+            pending = true;
+            c = model === 'at-last-column' ? cols - 1 : cols;
+        }
+    };
+    const eraseToEol = () => {
+        const from = model === 'virtual-column' && pending ? cols : c;
+        for (let k = from; k < cols; k += 1)
+            grid[r][k] = ' ';
+    };
+    const csi = (params, final, raw) => {
+        if (params.startsWith('?')) {
+            const modes = params.slice(1).split(';').map(Number);
+            if (modes.some((mode) => FORBIDDEN_PRIVATE.has(mode)))
+                forbidden.push(raw);
+            return; // 2026 / 25 / 2004: no visible effect
+        }
+        const first = params === '' ? undefined : Number(params.split(';')[0]);
+        switch (final) {
+            case 'A':
+                r = clamp(r - (first ?? 1), rows - 1);
+                break;
+            case 'B':
+                r = clamp(r + (first ?? 1), rows - 1);
+                break;
+            case 'G':
+                c = clamp((first ?? 1) - 1, cols - 1);
+                pending = false;
+                break;
+            case 'K':
+                if (first === 2)
+                    grid[r].fill(' ');
+                else
+                    eraseToEol();
+                break;
+            case 'J':
+                if (first === 2 || first === 3) {
+                    forbidden.push(raw);
+                    break;
+                }
+                eraseToEol();
+                for (let row = r + 1; row < rows; row += 1)
+                    grid[row].fill(' ');
+                break;
+            case 'H':
+            case 'f':
+            case 'r':
+            case 'S':
+            case 'T':
+                forbidden.push(raw);
+                break;
+            default: break; // SGR and the rest: no cell effect
+        }
+    };
+    const write = (data) => {
+        const chars = Array.from(data);
+        for (let i = 0; i < chars.length; i += 1) {
+            const ch = chars[i];
+            if (ch === '\x1b') {
+                const next = chars[i + 1];
+                if (next === '[') {
+                    let j = i + 2;
+                    let params = '';
+                    while (j < chars.length && /[0-?]/.test(chars[j]))
+                        params += chars[j++];
+                    while (j < chars.length && /[ -/]/.test(chars[j]))
+                        j += 1;
+                    const final = chars[j] ?? '';
+                    csi(params, final, chars.slice(i, j + 1).join(''));
+                    i = j;
+                }
+                else if (next === ']') {
+                    let j = i + 2;
+                    while (j < chars.length && chars[j] !== '\x07' && !(chars[j] === '\x1b' && chars[j + 1] === '\\'))
+                        j += 1;
+                    i = chars[j] === '\x07' ? j : j + 1;
+                }
+                else if (next === 'c') {
+                    forbidden.push('\x1bc');
+                    i += 1;
+                }
+                else
+                    i += 1;
+            }
+            else if (ch === '\r') {
+                c = 0;
+                pending = false;
+            }
+            else if (ch === '\n') {
+                c = 0; // ONLCR, like a real tty
+                pending = false;
+                lineFeed();
+            }
+            else if (ch >= ' ')
+                print(ch);
+        }
+    };
+    const screen = () => grid.map(text);
+    return {
+        write,
+        screen,
+        scrollback,
+        history: () => {
+            const rowsOut = screen();
+            while (rowsOut.length > 0 && rowsOut[rowsOut.length - 1] === '')
+                rowsOut.pop();
+            return [...scrollback, ...rowsOut];
+        },
+        cursor: () => ({ row: r, col: c }),
+        forbidden,
+    };
+}

package/dist/testing/render-at-width.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Render an Ink tree at a CHOSEN terminal width.
+ *
+ * `ink-testing-library`'s `render` takes the tree and nothing else, and its
+ * stdout stub hard-codes `get columns() { return 100 }` — so a second argument
+ * spelling `{ columns: 40 }` is silently ignored and any assertion built on it
+ * is VACUOUS while looking exactly like a real one. (`budget.test.ts` records the
+ * same stub's missing `rows` for the same reason.)
+ *
+ * This is that library's `render`, verbatim, with the one number made a
+ * parameter. Nothing else about the harness changes: `debug: true` is what makes
+ * every frame arrive whole rather than as cursor movements.
+ */
+import type { ReactElement } from 'react';
+/** The stripped rows of one frame rendered at `columns`, then unmounted. */
+export declare function renderRowsAtWidth(tree: ReactElement, columns: number): string[];

package/dist/testing/render-at-width.js

@@ -0,0 +1,57 @@
+/**
+ * Render an Ink tree at a CHOSEN terminal width.
+ *
+ * `ink-testing-library`'s `render` takes the tree and nothing else, and its
+ * stdout stub hard-codes `get columns() { return 100 }` — so a second argument
+ * spelling `{ columns: 40 }` is silently ignored and any assertion built on it
+ * is VACUOUS while looking exactly like a real one. (`budget.test.ts` records the
+ * same stub's missing `rows` for the same reason.)
+ *
+ * This is that library's `render`, verbatim, with the one number made a
+ * parameter. Nothing else about the harness changes: `debug: true` is what makes
+ * every frame arrive whole rather than as cursor movements.
+ */
+import { EventEmitter } from 'node:events';
+import { render as inkRender } from 'ink';
+import stripAnsi from 'strip-ansi';
+class WidthStdout extends EventEmitter {
+    columns;
+    frames = [];
+    last;
+    constructor(columns) {
+        super();
+        this.columns = columns;
+    }
+    write = (frame) => {
+        this.frames.push(frame);
+        this.last = frame;
+    };
+    lastFrame = () => this.last;
+}
+class NullStream extends EventEmitter {
+    write = () => { };
+    isTTY = true;
+    setEncoding() { }
+    setRawMode() { }
+    resume() { }
+    pause() { }
+    ref() { }
+    unref() { }
+    read = () => null;
+}
+/** The stripped rows of one frame rendered at `columns`, then unmounted. */
+export function renderRowsAtWidth(tree, columns) {
+    const stdout = new WidthStdout(columns);
+    const instance = inkRender(tree, {
+        stdout: stdout,
+        stderr: new NullStream(),
+        stdin: new NullStream(),
+        debug: true,
+        exitOnCtrlC: false,
+        patchConsole: false,
+    });
+    const frame = stripAnsi(stdout.lastFrame() ?? '');
+    instance.unmount();
+    instance.cleanup();
+    return frame.split('\n');
+}

package/dist/testing/terminal-harness.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+/** Real Yoga sizing and input streams, independent of the host terminal dimensions. */
+export declare function createTerminalHarness(columns?: number, rows?: number, debug?: boolean): {
+    stdout: NodeJS.WriteStream;
+    stdin: NodeJS.ReadStream;
+    frames: string[];
+    layoutFrames: string[];
+    mount(node: React.ReactElement): void;
+    rerender(node: React.ReactElement): void;
+    resize(nextCols: number, nextRows: number): void;
+    lastFrame: () => string;
+    input(text: string): void;
+    dispose(): void;
+};
+export declare const settleTerminal: () => Promise<void>;

package/dist/testing/terminal-harness.js

@@ -0,0 +1,40 @@
+import { PassThrough } from 'node:stream';
+import { render } from 'ink';
+import stripAnsi from 'strip-ansi';
+/** Real Yoga sizing and input streams, independent of the host terminal dimensions. */
+export function createTerminalHarness(columns = 80, rows = 24, debug = true) {
+    const output = new PassThrough();
+    const stdout = Object.assign(output, { columns, rows, isTTY: true,
+        getColorDepth: () => 1 });
+    const stdin = Object.assign(new PassThrough(), {
+        isTTY: true, setRawMode: () => stdin, ref: () => stdin, unref: () => stdin,
+    });
+    const frames = [];
+    const layoutFrames = [];
+    output.on('data', (chunk) => {
+        const raw = chunk.toString();
+        frames.push(raw);
+        // Ink debug emits each complete layout in one write. PassThrough preserves
+        // these writes; cursor-only control writes are not layout boundaries.
+        // Never filter by height: an undersized layout is a regression to expose.
+        const text = stripAnsi(raw);
+        if (debug && text.trim().length > 0)
+            layoutFrames.push(text);
+    });
+    let instance;
+    return { stdout, stdin, frames, layoutFrames,
+        mount(node) {
+            instance = render(node, { stdout, stdin, stderr: stdout, debug,
+                exitOnCtrlC: false, patchConsole: false });
+        },
+        rerender(node) { instance.rerender(node); },
+        resize(nextCols, nextRows) {
+            stdout.columns = nextCols;
+            stdout.rows = nextRows;
+            stdout.emit('resize');
+        },
+        lastFrame: () => stripAnsi(frames.at(-1) ?? ''),
+        input(text) { stdin.write(text); },
+        dispose() { instance?.unmount(); instance?.cleanup(); output.destroy(); stdin.destroy(); }, };
+}
+export const settleTerminal = () => new Promise((resolve) => setTimeout(resolve, 70));

package/dist/testing/vt-screen.d.ts

@@ -0,0 +1,28 @@
+/**
+ * A minimal VT screen model — just the subset the frame differ and Ink emit.
+ *
+ * It exists to turn one belief about real terminals into a regression guard
+ * (tui-scrollbar-edge-and-run-row §3.1.4). Writing the LAST column leaves the
+ * cursor in a "pending wrap" state, and terminals disagree on what a following
+ * `CSI K` (erase cursor → end of line) does there:
+ *
+ *  - `virtual-column`: the cursor is logically at column N+1, so EL erases an
+ *    empty range (xterm.js and friends);
+ *  - `at-last-column`: the cursor still sits on column N with a wrap flag, so EL
+ *    erases the cell that was JUST written (Windows console hosts).
+ *
+ * The differ must leave the last column intact under BOTH.
+ */
+export type PendingWrapModel = 'at-last-column' | 'virtual-column';
+export interface VtScreen {
+    /** The visible text of row `row` (0-based), cells joined, wide-char tails dropped. */
+    line(row: number): string;
+    /** The cell at (`row`, `col`), 0-based; `' '` when blank. */
+    cell(row: number, col: number): string;
+    /** 0-based cursor row. */
+    cursorRow(): number;
+    write(data: string): void;
+    touchedRows(): number[];
+    resetTouchedRows(): void;
+}
+export declare function createVtScreen(rows: number, cols: number, model: PendingWrapModel): VtScreen;

package/dist/testing/vt-screen.js

@@ -0,0 +1,139 @@
+/**
+ * A minimal VT screen model — just the subset the frame differ and Ink emit.
+ *
+ * It exists to turn one belief about real terminals into a regression guard
+ * (tui-scrollbar-edge-and-run-row §3.1.4). Writing the LAST column leaves the
+ * cursor in a "pending wrap" state, and terminals disagree on what a following
+ * `CSI K` (erase cursor → end of line) does there:
+ *
+ *  - `virtual-column`: the cursor is logically at column N+1, so EL erases an
+ *    empty range (xterm.js and friends);
+ *  - `at-last-column`: the cursor still sits on column N with a wrap flag, so EL
+ *    erases the cell that was JUST written (Windows console hosts).
+ *
+ * The differ must leave the last column intact under BOTH.
+ */
+import stringWidth from 'string-width';
+export function createVtScreen(rows, cols, model) {
+    const grid = Array.from({ length: rows }, () => new Array(cols).fill(' '));
+    let r = 0;
+    let c = 0;
+    let pending = false;
+    const touched = new Set();
+    const scrollUp = () => {
+        for (let row = 0; row < rows; row++)
+            touched.add(row);
+        grid.shift();
+        grid.push(new Array(cols).fill(' '));
+    };
+    const lineFeed = () => {
+        if (r === rows - 1)
+            scrollUp();
+        else
+            r += 1;
+    };
+    const clamp = (value, max) => Math.max(0, Math.min(max, value));
+    const print = (glyph) => {
+        const width = Math.max(1, stringWidth(glyph));
+        if (pending) {
+            c = 0;
+            pending = false;
+            lineFeed();
+        }
+        if (c + width > cols) {
+            c = 0;
+            lineFeed();
+        }
+        touched.add(r);
+        grid[r][c] = glyph;
+        for (let k = 1; k < width; k += 1)
+            grid[r][c + k] = '';
+        c += width;
+        if (c >= cols) {
+            pending = true;
+            // The two models differ ONLY here and in `eraseToEol`.
+            c = model === 'at-last-column' ? cols - 1 : cols;
+        }
+    };
+    const eraseToEol = () => {
+        const from = model === 'virtual-column' && pending ? cols : c;
+        if (from < cols)
+            touched.add(r);
+        for (let k = from; k < cols; k += 1)
+            grid[r][k] = ' ';
+    };
+    const csi = (params, final) => {
+        if (params.startsWith('?'))
+            return; // DEC private modes (2026, 25, ...) — no visible effect
+        const nums = params.split(';').map((part) => (part === '' ? NaN : Number(part)));
+        const first = Number.isNaN(nums[0]) ? undefined : nums[0];
+        switch (final) {
+            case 'H':
+            case 'f':
+                r = clamp((first ?? 1) - 1, rows - 1);
+                c = clamp((Number.isNaN(nums[1] ?? NaN) ? 1 : nums[1]) - 1, cols - 1);
+                pending = false;
+                break;
+            case 'G':
+                c = clamp((first ?? 1) - 1, cols - 1);
+                pending = false;
+                break;
+            case 'A':
+                r = clamp(r - (first ?? 1), rows - 1);
+                break;
+            case 'K':
+                if (first === 2) {
+                    touched.add(r);
+                    grid[r].fill(' ');
+                }
+                else
+                    eraseToEol();
+                break;
+            case 'J':
+                eraseToEol();
+                for (let row = r + 1; row < rows; row += 1) {
+                    touched.add(row);
+                    grid[row].fill(' ');
+                }
+                break;
+            default:
+                break; // SGR ('m') and anything else: no cell effect
+        }
+    };
+    const write = (data) => {
+        const chars = Array.from(data);
+        for (let i = 0; i < chars.length; i += 1) {
+            const ch = chars[i];
+            if (ch === '\x1b' && chars[i + 1] === '[') {
+                let j = i + 2;
+                let params = '';
+                while (j < chars.length && /[0-?]/.test(chars[j]))
+                    params += chars[j++];
+                const final = chars[j] ?? '';
+                csi(params, final);
+                i = j;
+            }
+            else if (ch === '\r') {
+                c = 0;
+                pending = false;
+            }
+            else if (ch === '\n') {
+                // TTY output translates LF to CRLF (ONLCR), including Ink's first full frame.
+                c = 0;
+                lineFeed();
+                pending = false;
+            }
+            else if (ch >= ' ') {
+                print(ch);
+            }
+        }
+    };
+    return {
+        line: (row) => grid[row].join(''),
+        cell: (row, col) => grid[row][col] ?? ' ',
+        cursorRow: () => r,
+        write,
+        touchedRows: () => [...touched].sort((a, b) => a - b),
+        resetTouchedRows: () => touched.clear(),
+    };
+}

package/dist/ui/ActivityLine.d.ts

@@ -0,0 +1,26 @@
+/** Legacy activity presentation. Explicit facts share the global status label mapping.
+ * StatusBar owns the application's sole live spinner via the factory below.
+ */
+import React from 'react';
+import type { Theme } from './theme.js';
+import type { TermCapabilities } from './capabilities.js';
+import { pickGlyphs } from './glyphs.js';
+import type { RunActivity } from './run-status-row.js';
+/** Shared animation factory; returns null for ASCII or reduced-motion terminals. */
+export declare function liveSpinner(reducedMotion: boolean, caps: TermCapabilities): React.ReactElement | null;
+/** Explicit execution facts outrank compatibility tool names and rotating phrases. */
+export declare function resolveActivityLabel(activity: RunActivity, glyphs: ReturnType<typeof pickGlyphs>): string;
+export interface ActivityLabelProps extends RunActivity {
+    /**
+     * False forces a static glyph. Compatibility phrases still follow reducedMotion.
+     */
+    spinnerLive?: boolean;
+    /** Prefix one space for compatibility line consumers. */
+    leadingSpace?: boolean;
+    theme: Theme;
+    caps: TermCapabilities;
+}
+/** `<spinner> <label>` as ONE truncating `<Text>`; the only place that composes them. */
+export declare function ActivityLabel({ spinnerLive, leadingSpace, theme, caps, ...activity }: ActivityLabelProps): React.ReactElement;
+export type ActivityLineProps = Omit<ActivityLabelProps, 'spinnerLive' | 'leadingSpace'>;
+export declare function ActivityLine(props: ActivityLineProps): React.ReactElement;

package/dist/ui/ActivityLine.js

@@ -0,0 +1,51 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import Spinner from 'ink-spinner';
+import { pickGlyphs } from './glyphs.js';
+import { pickActivityPhrase } from './activity-phrases.js';
+import { phaseLabels, shortDuration } from './layout/status-layout.js';
+/** Shared animation factory; returns null for ASCII or reduced-motion terminals. */
+export function liveSpinner(reducedMotion, caps) {
+    return caps.unicode && !reducedMotion ? _jsx(Spinner, { type: "dots" }) : null;
+}
+/** Explicit execution facts outrank compatibility tool names and rotating phrases. */
+export function resolveActivityLabel(activity, glyphs) {
+    // A WAIT OUTRANKS EVERYTHING BELOW IT, and sits ABOVE `runningTool` on purpose:
+    // "Running job_wait" names the tool, "Waiting on t3 (up to 30s)" names the
+    // situation. It is placed after the phase/outcome branch because a settled run
+    // must never claim to be waiting for anything.
+    if (activity.phase === undefined && activity.outcome === undefined && activity.wait) {
+        const { jobId, upToSeconds, elapsedSeconds } = activity.wait;
+        return elapsedSeconds !== undefined
+            ? `Waiting on ${jobId} ${shortDuration(elapsedSeconds * 1000)}/${shortDuration(upToSeconds * 1000)}`
+            : `Waiting on ${jobId} (up to ${upToSeconds}s)`;
+    }
+    if (activity.phase !== undefined || activity.activeTool !== undefined || activity.outcome !== undefined) {
+        return phaseLabels({
+            phase: activity.phase ?? (activity.activeTool ? 'tool' : 'idle'),
+            activeTool: activity.activeTool, runOutcome: activity.outcome, compacting: activity.compacting,
+        })[1];
+    }
+    if (activity.compacting)
+        return `Compacting context${glyphs.ellipsis}`;
+    if (activity.runningTool)
+        return `Running ${activity.runningTool}`;
+    // PURE AND DERIVED FROM `(startedAt, now)`, so the sequence does not need to
+    // keep rotating underneath the tool label: when the tool settles the phrase
+    // resumes at the position the clock implies, with no state anywhere.
+    const phrase = pickActivityPhrase(activity.startedAt, activity.startedAt + activity.elapsedMs, !activity.reducedMotion);
+    return `${phrase}${glyphs.ellipsis}`;
+}
+/** `<spinner> <label>` as ONE truncating `<Text>`; the only place that composes them. */
+export function ActivityLabel({ spinnerLive = true, leadingSpace = false, theme, caps, ...activity }) {
+    const glyphs = pickGlyphs(caps);
+    const label = resolveActivityLabel(activity, glyphs);
+    const settled = activity.phase === 'idle' || (activity.phase === undefined
+        && activity.outcome !== undefined && activity.outcome !== 'none' && !activity.activeTool);
+    const spinner = (spinnerLive && (!settled || activity.compacting) ? liveSpinner(activity.reducedMotion, caps) : null) ??
+        glyphs.spinnerStill;
+    return (_jsxs(Text, { wrap: "truncate", color: theme.thinking, children: [leadingSpace ? ' ' : '', spinner, " ", label] }));
+}
+export function ActivityLine(props) {
+    return (_jsx(Box, { flexShrink: 0, children: _jsx(ActivityLabel, { ...props, leadingSpace: true }) }));
+}