@aragon-agent/cli 0.6.46 → 0.6.47

package/dist/ui/entries/WaitCard.d.ts

@@ -0,0 +1,37 @@
+/**
+ * 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 type { Theme } from '../theme.js';
+import type { TermCapabilities } from '../capabilities.js';
+import type { WaitView } from '../../proc/wait-view.js';
+export interface WaitCardProps {
+    view: WaitView;
+    /** Wall-clock seconds from the transcript's 1 Hz clock; absent before the first tick. */
+    nowSec?: number | undefined;
+    reducedMotion?: boolean | undefined;
+    theme: Theme;
+    caps: TermCapabilities;
+}
+declare function WaitCardImpl(props: WaitCardProps): React.ReactElement;
+/**
+ * `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 declare const WaitCard: React.MemoExoticComponent<typeof WaitCardImpl>;
+export {};

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/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,6 +34,7 @@
  */
 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';
@@ -96,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])
@@ -320,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aragon-agent/cli",
-  "version": "0.6.46",
+  "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.58",
+    "@aragon-agent/core": "^0.2.59",
     "chalk": "^5.6.2",
     "cli-highlight": "^2.0.0",
     "commander": "^12.1.0",