@aragon-agent/cli 0.6.45 → 0.6.47

package/dist/ui/entries/WaitCard.js

@@ -0,0 +1,92 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+/**
+ * WaitCard - the five-row card a running `job_wait` is drawn as
+ * (extended-job-wait §3.8.2).
+ *
+ * ASCII ONLY: every non-ASCII cell is a `pickGlyphs` result and every sentence the
+ * user did not get from the job itself is in `interactionCopy`.
+ *
+ * FIVE ROWS, IN EVERY STATE (I-10). A branch may change what a row SAYS, never how
+ * many rows there are: `estimateEntryRows` charges exactly `separation + 5`, and a
+ * card that is one row short makes the viewport jump while one row long makes the
+ * height estimate an under-count - the direction `virtual-window.ts` names unsafe.
+ * Every row is `wrap="truncate"` for the same reason.
+ *
+ * ONE CLOCK. Every number is a subtraction between an epoch stamped by
+ * `buildWaitView` and the `nowSec` the transcript already ticks at 1 Hz; there is
+ * no timer in this file, and the spinner is the app's shared factory, which this
+ * card REPLACES `ToolCard`'s badge with rather than adding to.
+ */
+import React from 'react';
+import { Box, Text, useStdout } from 'ink';
+import { pickGlyphs } from '../glyphs.js';
+import { liveSpinner } from '../ActivityLine.js';
+import { railBorderProps } from '../layout/Gutter.js';
+import { interactionCopy } from '../interaction-copy.js';
+import { WAIT_BAR_MIN_COLS, barCellsFor, formatWaitClock, percentOf, renderBar, } from '../layout/wait-bar.js';
+/** Empty `<Text>` measures zero rows in Ink, so a blank row is drawn as a space. */
+function filled(text) {
+    return text.length > 0 ? text : ' ';
+}
+function WaitCardImpl(props) {
+    const { view, reducedMotion, theme, caps } = props;
+    const glyphs = pickGlyphs(caps);
+    const { stdout } = useStdout();
+    const cols = stdout?.columns ?? 80;
+    // Before the first tick the clock reads the instant the wait began.
+    const nowMs = Math.max(view.waitStartedAt, props.nowSec !== undefined ? props.nowSec * 1000 : view.waitStartedAt);
+    const waited = nowMs - view.waitStartedAt;
+    const remaining = Math.max(0, view.upToMs - waited);
+    const upTo = formatWaitClock(view.upToMs);
+    const dot = ` ${glyphs.midDot} `;
+    // ROW 1 - what, and the clock.
+    const spinner = liveSpinner(reducedMotion ?? false, caps);
+    const title = `Waiting for ${view.jobLabel}`;
+    const clock = `${formatWaitClock(waited)} of ${upTo}`;
+    // ROW 2 - the bar. THE JOB'S OWN PROGRESS WINS; with none, the bar shows the wait
+    // window itself and the words say so (D-10), so the two meanings never share a
+    // bar silently.
+    const jobFraction = view.progress?.fraction ?? null;
+    const windowFraction = view.upToMs > 0 ? waited / view.upToMs : 0;
+    const barFraction = jobFraction ?? windowFraction;
+    const showBar = cols >= WAIT_BAR_MIN_COLS;
+    const bar = showBar
+        ? `${renderBar(barFraction, barCellsFor(cols), glyphs)}  `
+        : '';
+    let barText;
+    if (jobFraction !== null && view.progress) {
+        barText =
+            view.progress.kind === 'percent'
+                ? view.progress.text
+                : `${percentOf(jobFraction)}%  ${view.progress.text}`;
+    }
+    else {
+        barText = `${percentOf(windowFraction)}%  of this ${upTo} wait`;
+        if (view.progress)
+            barText += `  ${view.progress.text}`;
+    }
+    // ROW 3 - the two clocks.
+    let clocks;
+    if (view.jobLabel.endsWith(' jobs')) {
+        const rule = view.mode === 'any' ? 'ANY finishes' : 'ALL finish';
+        clocks = `${view.liveJobs} ${view.liveJobs === 1 ? 'job' : 'jobs'} live${dot}this wait ends when ${rule}`;
+    }
+    else {
+        clocks =
+            `job ${view.status} ${formatWaitClock(Math.max(0, nowMs - view.jobStartedAt))}${dot}` +
+                `this wait ends in ${formatWaitClock(remaining)}, or sooner if the job finishes`;
+    }
+    // ROW 4 - what the job last said, or a calm note that silence is not failure (D-11).
+    const quietMs = Math.max(0, nowMs - view.lastOutputAt);
+    const quiet = view.lastRow !== undefined && quietMs > view.stallSeconds * 1000;
+    const lastRowText = quiet
+        ? `quiet for ${formatWaitClock(quietMs)} - the job is still alive; this is not a failure`
+        : (view.lastRow ?? 'no output yet');
+    const ago = view.lastRow !== undefined && !quiet ? `${formatWaitClock(quietMs)} ago` : '';
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { flexDirection: "row", children: [spinner ? _jsxs(Text, { color: theme.toolRunning, children: [spinner, " "] }) : (_jsxs(Text, { color: theme.toolRunning, children: [glyphs.spinnerStill, " "] })), _jsx(Text, { color: theme.accent, bold: true, children: title }), _jsx(Box, { flexGrow: 1, flexShrink: 1, minWidth: 0, children: _jsx(Text, { color: theme.muted, wrap: "truncate", children: view.command.length > 0 ? `  ${view.command}` : ' ' }) }), _jsx(Box, { flexShrink: 0, children: _jsxs(Text, { color: theme.muted, children: [" ", clock] }) })] }), _jsxs(Box, { flexDirection: "column", flexShrink: 0, paddingLeft: 1, ...railBorderProps(glyphs.railVertical, theme.border), children: [_jsxs(Text, { wrap: "truncate", children: [_jsx(Text, { color: theme.toolRunning, children: bar }), _jsx(Text, { color: theme.primary, children: filled(barText) })] }), _jsx(Text, { color: theme.muted, wrap: "truncate", children: filled(clocks) }), _jsxs(Box, { flexDirection: "row", children: [_jsx(Box, { flexGrow: 1, flexShrink: 1, minWidth: 0, children: _jsx(Text, { color: quiet ? theme.noticeWarn : theme.muted, wrap: "truncate", children: filled(lastRowText) }) }), _jsx(Box, { flexShrink: 0, children: _jsx(Text, { color: theme.muted, children: ago.length > 0 ? ` ${ago}` : ' ' }) })] }), _jsxs(Text, { color: theme.muted, wrap: "truncate", children: [interactionCopy.waitHintSend, dot, interactionCopy.waitHintStop] })] })] }));
+}
+/**
+ * `React.memo` with the DEFAULT comparator: the reducer writes a fresh `view`
+ * object once a second, which is exactly the one change that must re-render.
+ */
+export const WaitCard = React.memo(WaitCardImpl);

package/dist/ui/interaction-copy.d.ts

@@ -77,6 +77,8 @@ export declare const interactionCopy: {
     readonly shiftNewline: "Shift+Enter newline needs terminal support";
     readonly mode: "Shift+Tab switch mode";
     readonly update: "/update";
+    readonly waitHintSend: "Send a message to end the wait early";
+    readonly waitHintStop: "Esc x2 stops the whole run";
     readonly idlePlaceholder: "Ask a question or describe a task...";
     readonly runningPlaceholder: "Add a follow-up...";
 };

package/dist/ui/interaction-copy.js

@@ -34,5 +34,8 @@ export const interactionCopy = {
     governPausePending: 'pause pending: /gov pause cancel',
     help: '/help', shiftNewline: 'Shift+Enter newline needs terminal support',
     mode: 'Shift+Tab switch mode', update: '/update',
+    // The wait card's hint row (extended-job-wait): a user staring at a 20-minute
+    // wait needs to know they are not trapped in it.
+    waitHintSend: 'Send a message to end the wait early', waitHintStop: 'Esc x2 stops the whole run',
     idlePlaceholder: 'Ask a question or describe a task...', runningPlaceholder: 'Add a follow-up...',
 };

package/dist/ui/layout/invocation-card.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Invocation card layout (tui-invocation-cards section 3.7): what a `user` entry that
+ * carries an `invocation` says, as pure data. No Ink, no React. ASCII ONLY.
+ *
+ * THE CARD'S HEIGHT IS A FUNCTION OF ITS DATA AND THE USABLE WIDTH (I-4).
+ * `InvocationCard.tsx` renders exactly the rows `invocationCardRows` counts, and both
+ * read `INVOCATION_LIMITS` plus the one `invocationInputText` below - an estimate that
+ * disagrees with the painter is permanent, because an over-estimated entry is never
+ * mounted and so never measured (see `virtual-window.ts`).
+ */
+import type { InvocationCard } from '../../agent/invocation-card.js';
+import type { Glyphs } from '../glyphs.js';
+/** Colour slots the component maps onto the theme; kept local so this file needs no `Theme`. */
+export type InvocationTone = 'label' | 'name' | 'muted';
+export interface InvocationSegment {
+    text: string;
+    tone: InvocationTone;
+    bold: boolean;
+}
+/**
+ * The header row, already fitted to `usable` columns (RV-10). Narrow terminals drop
+ * facts from the right WHOLE before anything else is cut; only when the identity alone
+ * is too wide is the name shortened. Ink's `wrap="truncate"` stays on the row as a
+ * backstop, but it is never what produces the visible ellipsis.
+ */
+export declare function invocationHeaderSegments(card: InvocationCard, glyphs: Glyphs, usable: number): InvocationSegment[];
+/** The text painted for `input`: tabs expanded per line, the same rule `UserEntry` follows. */
+export declare function invocationInputText(card: InvocationCard): string;
+/** Singular/plural for the hidden-characters tail. */
+export declare function invocationHiddenText(card: InvocationCard, glyphs: Glyphs): string;
+/**
+ * Rows the card occupies at `usable` columns. `wrappedRows` is injected by the caller
+ * (`virtual-window.ts` owns the one wrapping rule) so this file stays import-cycle free.
+ */
+export declare function invocationCardRows(card: InvocationCard, usable: number, wrappedRows: (text: string, usable: number) => number): number;
+/**
+ * The lines the exit replay / export prints UNDER the command line (section 2.4):
+ * a bracketed fact line, and the disclosure note when there is one. Plain ASCII
+ * separators - the replay is pasted into issues and must survive any terminal.
+ */
+export declare function invocationCardLines(card: InvocationCard): string[];

package/dist/ui/layout/invocation-card.js

@@ -0,0 +1,91 @@
+/**
+ * Invocation card layout (tui-invocation-cards section 3.7): what a `user` entry that
+ * carries an `invocation` says, as pure data. No Ink, no React. ASCII ONLY.
+ *
+ * THE CARD'S HEIGHT IS A FUNCTION OF ITS DATA AND THE USABLE WIDTH (I-4).
+ * `InvocationCard.tsx` renders exactly the rows `invocationCardRows` counts, and both
+ * read `INVOCATION_LIMITS` plus the one `invocationInputText` below - an estimate that
+ * disagrees with the painter is permanent, because an over-estimated entry is never
+ * mounted and so never measured (see `virtual-window.ts`).
+ */
+import { expandTabs } from '../display-tab.js';
+import { cellWidth, fitCells } from './cells.js';
+/** Two spaces between the identity (`skill . pdf-forms`) and the facts. */
+const FACT_GAP = '  ';
+function seg(text, tone, bold = false) {
+    return { text, tone, bold };
+}
+function segmentsWidth(segments) {
+    return segments.reduce((sum, part) => sum + cellWidth(part.text), 0);
+}
+function identitySegments(card, glyphs, name) {
+    const parts = [seg(card.variant, 'label', true)];
+    if (name !== '')
+        parts.push(seg(` ${glyphs.midDot} `, 'muted'), seg(name, 'name', true));
+    return parts;
+}
+function factSegments(facts, glyphs) {
+    if (facts.length === 0)
+        return [];
+    const parts = [seg(FACT_GAP, 'muted')];
+    facts.forEach((fact, index) => {
+        if (index > 0)
+            parts.push(seg(` ${glyphs.midDot} `, 'muted'));
+        parts.push(seg(fact, 'muted'));
+    });
+    return parts;
+}
+/**
+ * The header row, already fitted to `usable` columns (RV-10). Narrow terminals drop
+ * facts from the right WHOLE before anything else is cut; only when the identity alone
+ * is too wide is the name shortened. Ink's `wrap="truncate"` stays on the row as a
+ * backstop, but it is never what produces the visible ellipsis.
+ */
+export function invocationHeaderSegments(card, glyphs, usable) {
+    const width = Math.max(1, Math.floor(usable));
+    for (let kept = card.facts.length; kept >= 0; kept -= 1) {
+        const candidate = [
+            ...identitySegments(card, glyphs, card.name),
+            ...factSegments(card.facts.slice(0, kept), glyphs),
+        ];
+        if (segmentsWidth(candidate) <= width)
+            return candidate;
+    }
+    const head = identitySegments(card, glyphs, '');
+    const room = width - segmentsWidth(head) - cellWidth(` ${glyphs.midDot} `);
+    if (card.name !== '' && room > 1) {
+        return identitySegments(card, glyphs, fitCells(card.name, room, glyphs.ellipsis));
+    }
+    return [seg(fitCells(card.variant, width, glyphs.ellipsis), 'label', true)];
+}
+/** The text painted for `input`: tabs expanded per line, the same rule `UserEntry` follows. */
+export function invocationInputText(card) {
+    return card.input.split('\n').map((line) => expandTabs(line)).join('\n');
+}
+/** Singular/plural for the hidden-characters tail. */
+export function invocationHiddenText(card, glyphs) {
+    const unit = card.inputHidden === 1 ? 'char' : 'chars';
+    return `${glyphs.ellipsis} +${card.inputHidden} ${unit} not shown`;
+}
+/**
+ * Rows the card occupies at `usable` columns. `wrappedRows` is injected by the caller
+ * (`virtual-window.ts` owns the one wrapping rule) so this file stays import-cycle free.
+ */
+export function invocationCardRows(card, usable, wrappedRows) {
+    const inputRows = card.input === '' ? 0 : wrappedRows(invocationInputText(card), usable);
+    return 1 + inputRows + (card.inputHidden > 0 ? 1 : 0) + (card.note ? 1 : 0);
+}
+const REPLAY_INDENT = '    ';
+/**
+ * The lines the exit replay / export prints UNDER the command line (section 2.4):
+ * a bracketed fact line, and the disclosure note when there is one. Plain ASCII
+ * separators - the replay is pasted into issues and must survive any terminal.
+ */
+export function invocationCardLines(card) {
+    const identity = card.name === '' ? card.variant : `${card.variant} ${card.name}`;
+    const detail = card.facts.length === 0 ? identity : `${identity} ${card.facts.join(' - ')}`;
+    const lines = [`${REPLAY_INDENT}[${detail}]`];
+    if (card.note)
+        lines.push(`${REPLAY_INDENT}${card.note}`);
+    return lines;
+}

package/dist/ui/layout/status-layout.d.ts

@@ -26,6 +26,7 @@ export interface StatusLayoutInput {
     wait?: {
         jobId: string;
         upToSeconds: number;
+        elapsedSeconds?: number;
     };
     runOutcome?: 'none' | 'ended' | 'interrupted' | 'failed';
     spinner?: string;

package/dist/ui/layout/status-layout.js

@@ -31,7 +31,16 @@ export function phaseLabels(input) {
     // quiet terminal actually has. Both forms carry it - the short rung is
     // truncated by width, not reworded.
     if (input.wait) {
-        const label = `Waiting on ${cleanStatusText(input.wait.jobId)} ` +
+        const id = cleanStatusText(input.wait.jobId);
+        // WITH A CLOCK (extended-job-wait): `Waiting on t3 4m12s/10m00s`, and a shorter
+        // rung that keeps the id and the elapsed time. Without one the original
+        // sentence is byte-identical, which the older assertions rely on.
+        if (input.wait.elapsedSeconds !== undefined) {
+            const elapsed = shortDuration(Math.max(0, input.wait.elapsedSeconds) * 1000);
+            const upTo = shortDuration(Math.max(0, input.wait.upToSeconds) * 1000);
+            return [`Wait ${id} ${elapsed}`, `Waiting on ${id} ${elapsed}/${upTo}`];
+        }
+        const label = `Waiting on ${id} ` +
             `(up to ${Math.max(0, Math.round(input.wait.upToSeconds))}s)`;
         return [label, label];
     }

package/dist/ui/layout/virtual-window.js

@@ -34,12 +34,14 @@
  */
 import stringWidth from 'string-width';
 import { governanceCardRows } from './governance-card.js';
+import { WAIT_CARD_ROWS } from './wait-bar.js';
 import { FAST_LIMITS } from '../../fast/limits.js';
 import { COMPACTION_LIMITS } from '../../compaction/limits.js';
 import { GUTTER_WIDTH } from './Gutter.js';
 import { expandTabs } from '../display-tab.js';
 import { USER_ENTRY_MAX_ROWS } from '../composer-limits.js';
 import { isLiveTeamCard } from '../team-status.js';
+import { invocationCardRows } from './invocation-card.js';
 export const VIRTUAL_LIMITS = {
     /**
      * Entries kept mounted on each side of the visible band.
@@ -68,8 +70,12 @@ export const VIRTUAL_LIMITS = {
  */
 export function entryRevision(entry) {
     switch (entry.kind) {
+        // A card's shape is fixed at creation; the suffix only tells "card" from "plain" (and
+        // the three row-bearing parts), which is what makes a `queued -> user` rewrite re-measure.
         case 'user':
-            return 'u';
+            return entry.invocation
+                ? `i${entry.invocation.input.length}.${entry.invocation.inputHidden > 0 ? 1 : 0}.${entry.invocation.note ? 1 : 0}`
+                : 'u';
         case 'notice':
             return 'n';
         // `thinkingMs` is O(1) and it CHANGES THE ROW: sealing the clock turns
@@ -91,7 +97,7 @@ export function entryRevision(entry) {
         // field makes it seven, and a term that is not O(1) would put the cost this
         // module exists to remove back on every frame.
         case 'tool':
-            return `t${entry.status}.${entry.argsRaw.length}.${entry.preview?.length ?? 0}.${entry.durationMs ?? -1}.${entry.patch?.lineCount ?? -1}.${entry.liveSeq ?? -1}`;
+            return `t${entry.status}.${entry.argsRaw.length}.${entry.preview?.length ?? 0}.${entry.durationMs ?? -1}.${entry.patch?.lineCount ?? -1}.${entry.liveSeq ?? -1}.w${entry.waitSeq ?? -1}`;
         case 'team':
             return `m${entry.active ? 1 : 0}.${entry.runs.length}.${entry.runs
                 .map((r) => r.phase[0])
@@ -259,6 +265,11 @@ export function estimateEntryRows(entry, cols, density, expanded, thinkingVisibl
     const separation = density === 'comfortable' ? 1 : 0;
     switch (entry.kind) {
         case 'user':
+            // A CARD HAS ITS OWN, BOUNDED HEIGHT (tui-invocation-cards I-4): the same
+            // `invocationCardRows` the painter is built from, never the command line's wrapped rows.
+            if (entry.invocation) {
+                return separation + invocationCardRows(entry.invocation, usable, wrappedRows);
+            }
             // MIRRORS `UserEntry`'s RENDER CAP (+1 for the `... +N more lines` tail).
             // THESE TWO NUMBERS ARE ONE NUMBER (I-13). Capping the renderer alone
             // would leave this function believing a 5 000-line message is 5 000 rows
@@ -310,6 +321,11 @@ export function estimateEntryRows(entry, cols, density, expanded, thinkingVisibl
             // string). A `!settled` block alone would drop the second into
             // `wrappedRows(entry.preview, usable)` with `undefined`.
             if (!settled) {
+                // A RUNNING `job_wait` WITH A VIEW IS THE FIVE-ROW WAIT CARD, EXACTLY
+                // (extended-job-wait I-10): constant height is what lets this be an
+                // equality rather than an upper bound. Keep in step with `WAIT_CARD_ROWS`.
+                if (entry.name === 'job_wait' && entry.wait)
+                    return separation + WAIT_CARD_ROWS;
                 const live = entry.live?.length ?? 0;
                 if (live === 0)
                     return separation + 1;

package/dist/ui/layout/wait-bar.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Pure pieces of the wait card (extended-job-wait §3.8.2).
+ *
+ * ASCII ONLY: `src/ui/**` is inside the glyph scanner's scope, so every
+ * non-ASCII cell arrives as an argument from `pickGlyphs`.
+ */
+/**
+ * Rows the wait card occupies, header included, in every state (I-10).
+ * Here rather than beside the component so `virtual-window.ts` can import it
+ * without pulling React into a pure layout module.
+ */
+export declare const WAIT_CARD_ROWS = 5;
+/** The two glyphs a bar is made of; a subset of the `pickGlyphs` result. */
+export interface BarGlyphs {
+    gaugeFull: string;
+    gaugeEmpty: string;
+}
+/** Narrowest terminal that still gets a bar; below it the row is text only. */
+export declare const WAIT_BAR_MIN_COLS = 40;
+/** Bar width for a terminal `cols` wide: about a third of the row, 8..28 cells. */
+export declare function barCellsFor(cols: number): number;
+/**
+ * A `cells`-wide bar for `fraction` in 0..1.
+ *
+ * AN UNFINISHED BAR IS NEVER FULL (I-8): anything strictly between 0 and 1 shows
+ * at least one filled and at least one empty cell, so a 99.9% job does not read
+ * as done. `NaN`, negatives and non-finite values are an empty bar rather than a
+ * throw - this runs inside a render.
+ */
+export declare function renderBar(fraction: number, cells: number, glyphs: BarGlyphs): string;
+/** `4m12s`, `10m00s`, `45s` - the one clock format of the card and the status bar. */
+export declare function formatWaitClock(ms: number): string;
+/** Whole percent for a 0..1 fraction, clamped. */
+export declare function percentOf(fraction: number): number;

package/dist/ui/layout/wait-bar.js

@@ -0,0 +1,48 @@
+/**
+ * Pure pieces of the wait card (extended-job-wait §3.8.2).
+ *
+ * ASCII ONLY: `src/ui/**` is inside the glyph scanner's scope, so every
+ * non-ASCII cell arrives as an argument from `pickGlyphs`.
+ */
+import { shortDuration } from './status-layout.js';
+/**
+ * Rows the wait card occupies, header included, in every state (I-10).
+ * Here rather than beside the component so `virtual-window.ts` can import it
+ * without pulling React into a pure layout module.
+ */
+export const WAIT_CARD_ROWS = 5;
+/** Narrowest terminal that still gets a bar; below it the row is text only. */
+export const WAIT_BAR_MIN_COLS = 40;
+/** Bar width for a terminal `cols` wide: about a third of the row, 8..28 cells. */
+export function barCellsFor(cols) {
+    if (!Number.isFinite(cols))
+        return 8;
+    return Math.max(8, Math.min(28, Math.floor((cols - 4) * 0.35)));
+}
+/**
+ * A `cells`-wide bar for `fraction` in 0..1.
+ *
+ * AN UNFINISHED BAR IS NEVER FULL (I-8): anything strictly between 0 and 1 shows
+ * at least one filled and at least one empty cell, so a 99.9% job does not read
+ * as done. `NaN`, negatives and non-finite values are an empty bar rather than a
+ * throw - this runs inside a render.
+ */
+export function renderBar(fraction, cells, glyphs) {
+    const width = Math.max(1, Math.floor(cells));
+    if (!Number.isFinite(fraction) || fraction <= 0)
+        return glyphs.gaugeEmpty.repeat(width);
+    if (fraction >= 1)
+        return glyphs.gaugeFull.repeat(width);
+    const filled = Math.min(width - 1, Math.max(1, Math.round(fraction * width)));
+    return glyphs.gaugeFull.repeat(filled) + glyphs.gaugeEmpty.repeat(width - filled);
+}
+/** `4m12s`, `10m00s`, `45s` - the one clock format of the card and the status bar. */
+export function formatWaitClock(ms) {
+    return shortDuration(ms);
+}
+/** Whole percent for a 0..1 fraction, clamped. */
+export function percentOf(fraction) {
+    if (!Number.isFinite(fraction))
+        return 0;
+    return Math.max(0, Math.min(100, Math.floor(fraction * 100)));
+}

package/dist/ui/run-status-row.d.ts

@@ -22,12 +22,14 @@ export interface RunActivity {
      *
      * `Running job_wait` is a TOOL NAME; `Waiting on t3 (up to 30s)` is a STATE, and
      * the state is what answers the user's two questions - what is it waiting for,
-     * and how long may that take. No countdown: a ticking number would need its own
-     * re-render, and the sentence is already complete.
+     * and how long may that take. `elapsedSeconds`, when present (extended-job-wait),
+     * turns the sentence into a running clock - the 1 Hz transcript tick already
+     * causes that render, so no timer is added.
      */
     wait?: {
         jobId: string;
         upToSeconds: number;
+        elapsedSeconds?: number;
     };
 }
 export interface RunRowPlanInput {

package/dist/ui/scrollback/live-preview.js

@@ -22,6 +22,7 @@ import { wrapToRows } from '../layout/wrap-rows.js';
 import { isExcluded } from './settled-boundary.js';
 import { isLiveTeamCard, outcomePhrase, rosterCounts } from '../team-status.js';
 import { clipLine } from './writer-shapes.js';
+import { formatWaitClock } from '../layout/wait-bar.js';
 const MAX_TEAM_RUN_ROWS = 3;
 const TOOL_LIVE_ROWS = 6;
 function firstLine(text) {
@@ -49,6 +50,17 @@ function assistantRows(entry, cols, rows, thinkingVisible) {
     return out;
 }
 function toolRows(entry, cols) {
+    // A RUNNING WAIT IS ONE LINE HERE, not a miniature of the five-row card
+    // (extended-job-wait RV-3). `job_wait` never streams, so `live` is empty and the
+    // generic row would say only `> job_wait`; the clock comes from the view's own
+    // epoch stamps (`beatAt` is the view's last beat), keeping this function pure.
+    if (entry.name === 'job_wait' && entry.status === 'running' && entry.wait) {
+        const { wait } = entry;
+        const waited = Math.max(0, wait.beatAt - wait.waitStartedAt);
+        return [
+            fit(`> Waiting for ${wait.jobLabel}  ${formatWaitClock(waited)} of ${formatWaitClock(wait.upToMs)}`, cols),
+        ];
+    }
     const head = entry.label && entry.label.length > 0 ? entry.label : entry.name;
     const out = [fit(`${entry.status === 'running' ? '>' : '.'} ${head}`, cols)];
     const live = (entry.live ?? []).slice(-TOOL_LIVE_ROWS);

package/dist/ui/transcript-text.js

@@ -3,6 +3,7 @@ import { formatRetryLine } from '../agent/retry-view.js';
 import { childStatus, outcomePhrase, rosterCounts, statusMarkerCell } from './team-status.js';
 import { expandTabs } from './display-tab.js';
 import { governanceCardLines } from './layout/governance-card.js';
+import { invocationCardLines } from './layout/invocation-card.js';
 const DEFAULT_MAX_ENTRIES = 200;
 const CONTINUATION_INDENT = '  ';
 const TOOL_INDENT = '  ';
@@ -87,7 +88,9 @@ function renderEntry(entry, glyphs) {
         case 'queued':
             return block('Queued but never sent:', entry.text);
         case 'user':
-            return block(glyphs.user, entry.text);
+            return entry.invocation
+                ? [...block(glyphs.user, entry.text), ...invocationCardLines(entry.invocation)]
+                : block(glyphs.user, entry.text);
         case 'assistant': {
             const suffix = entry.aborted ? ' (aborted)' : '';
             return block(glyphs.assistant, `${entry.text}${suffix}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aragon-agent/cli",
-  "version": "0.6.45",
+  "version": "0.6.47",
   "description": "AragonAgent CLI — a Claude-Code / Codex-style interactive terminal UI (TUI) on top of the @aragon-agent/core engine. Installable and runnable via npm / npx.",
   "license": "MIT",
   "author": "AragonAgent contributors",
@@ -56,7 +56,7 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@aragon-agent/core": "^0.2.57",
+    "@aragon-agent/core": "^0.2.59",
     "chalk": "^5.6.2",
     "cli-highlight": "^2.0.0",
     "commander": "^12.1.0",