@aragon-agent/cli 0.6.45 → 0.6.47

package/dist/tools/job-tools.js

@@ -17,10 +17,12 @@
  */
 import { defineTool, errorResult, textResult } from '@aragon-agent/core';
 import { formatDuration } from '../agent/usage.js';
-import { JOB_WAIT_MARGIN_MS, PROC_LIMITS } from '../proc/limits.js';
+import { PROC_LIMITS } from '../proc/limits.js';
 import { renderJobNotices } from '../proc/notices.js';
 import { isTerminalStatus } from '../proc/types.js';
 import { waitForJob } from '../proc/wait.js';
+import { extractEtaText, parseEtaSeconds, suggestWaitSeconds } from '../proc/wait-plan.js';
+import { buildWaitView } from '../proc/wait-view.js';
 /**
  * Split a page into "completed rows" and "the carry line".
  *
@@ -38,26 +40,36 @@ function splitCarry(page) {
     return last === carry ? { rows: rows.slice(0, -1), carry } : { rows, carry };
 }
 /**
- * Clamp `timeoutSeconds` into `[jobs.waitSeconds, 60]` and then into the tool
- * ceiling (I-4).
+ * Clamp `timeoutSeconds` into `[waitMinSeconds, waitMaxSeconds]`.
  *
- * TWO CONVERGENCES, BOTH REQUIRED. The first honours `WAIT_SECONDS_RANGE`; the
- * second is what makes it impossible for a wait to outlive the tool that is
- * hosting it, which is the difference between "a bounded wait" and "another
- * `Command timed out after 180000ms`".
+ * NOT CONVERGED AGAINST `toolTimeoutMs` (extended-job-wait I-4'): the executor
+ * gives `job_wait` its own ceiling and the idle watchdog is paused for the wait.
+ * Re-introducing a `toolTimeoutMs` term here silently pins every wait to
+ * `toolTimeoutMs - 30s` (150 s by default) with no error.
+ *
+ * A request over the ceiling is REPORTED (`clampedFrom`) rather than clamped in
+ * silence: a model that asked for an hour and is not told otherwise believes it
+ * waited one.
  */
 function clampWaitSeconds(deps, requested) {
     const configured = deps.waitSeconds();
     const asked = requested === undefined || !Number.isFinite(requested) || requested < PROC_LIMITS.waitMinSeconds
         ? configured
         : requested;
-    const bounded = Math.max(PROC_LIMITS.waitMinSeconds, Math.min(Math.floor(asked), PROC_LIMITS.waitMaxSeconds));
-    const ceiling = Math.floor((deps.toolTimeoutMs() - JOB_WAIT_MARGIN_MS) / 1000);
-    // `Math.max(1, ...)` rather than `Math.max(waitMinSeconds, ...)`: when an
-    // operator sets a tool ceiling below the margin, "the wait fits inside the
-    // ceiling" is the invariant that must win. Nothing here ever silently produces
-    // a wait longer than the tool call that hosts it.
-    return Math.max(1, Math.min(bounded, ceiling));
+    const floored = Math.floor(asked);
+    // The floor stays: a fixture or a hand-edited config can hand back < 5, and a
+    // sub-5-second "wait" is a poll.
+    const seconds = Math.max(PROC_LIMITS.waitMinSeconds, Math.min(floored, PROC_LIMITS.waitMaxSeconds));
+    return floored > seconds ? { seconds, clampedFrom: floored } : { seconds };
+}
+/** `45s`, `4m12s`, `10m`: whole seconds, no fractions, for prose lines. */
+function spanText(seconds) {
+    const whole = Math.max(0, Math.round(seconds));
+    if (whole < 60)
+        return `${whole}s`;
+    const minutes = Math.floor(whole / 60);
+    const rest = whole % 60;
+    return rest === 0 ? `${minutes}m` : `${minutes}m${String(rest).padStart(2, '0')}s`;
 }
 /** `JOB t3  task  running  12m34s` - the one header grammar for every outcome. */
 function headerLine(job, nowMs) {
@@ -100,6 +112,7 @@ function renderJobBlock(args) {
         fixed.push(stalled);
     if (args.truncatedNote !== undefined)
         fixed.push(args.truncatedNote);
+    fixed.push(...args.extraNotes);
     const tail = [`[cursor ${cursor}]`];
     if (terminal) {
         tail.push(`[done] the job finished. Read more with bash_output({ service: "${job.id}" }) if you need it.`);
@@ -107,8 +120,14 @@ function renderJobBlock(args) {
     else {
         const quiet = formatDuration(Math.max(0, nowMs - job.lastOutputAt));
         tail.push(`[wait ${args.waitSeconds}s] still running. No output for ${quiet}.`);
-        tail.push(`[next] job_wait({ job: "${job.id}", since: ${cursor} }) to keep waiting, ` +
-            'or continue with other work.');
+        // THE SUGGESTION RIDES ONLY WHEN IT DIFFERS FROM THE DEFAULT, so a short job on
+        // the default config gets the byte-identical line it always got (AC-20).
+        const timeoutClause = args.suggestedSeconds !== undefined ? `, timeoutSeconds: ${args.suggestedSeconds}` : '';
+        const etaClause = args.suggestedSeconds !== undefined && args.etaText !== undefined
+            ? ` (ETA about ${args.etaText})`
+            : '';
+        tail.push(`[next] job_wait({ job: "${job.id}", since: ${cursor}${timeoutClause} }) ` +
+            `to keep waiting${etaClause}, or continue with other work.`);
     }
     // TWELVE LINES, AND THE ROW BLOCK IS THE ONLY ELASTIC PART. Its header costs a
     // line of its own, so the budget is computed with it already deducted; a stalled
@@ -157,15 +176,21 @@ export function makeJobWait(deps) {
         label: 'Wait for job',
         description: 'Wait a bounded time for a background job (service or task) and return its ' +
             'status, one line of progress, and only the output since `since`. Returns ' +
-            'immediately when the job is already finished. Waiting is bounded (5-60s), ' +
-            'so call it again only after deciding what to do.',
+            'immediately when the job is already finished. Waiting is bounded ' +
+            `(${PROC_LIMITS.waitMinSeconds}-${PROC_LIMITS.waitMaxSeconds}s). The wait ends early ` +
+            'when the job finishes or when the user sends a message, so prefer ONE long wait ' +
+            'over several short ones.',
         parameters: {
             type: 'object',
             properties: {
-                job: { type: 'string', description: '"t3", "s1", or "all".' },
+                job: {
+                    type: 'string',
+                    description: '"t3", "s1", "all" (until every live job ends) or "any" (until the first ends).',
+                },
                 timeoutSeconds: {
                     type: 'number',
-                    description: '5-60. Omit for the configured default.',
+                    description: `${PROC_LIMITS.waitMinSeconds}-${PROC_LIMITS.waitMaxSeconds}. Omit for the ` +
+                        'configured default. Use the [next] suggestion or the job\'s ETA for long jobs.',
                 },
                 since: {
                     type: 'number',
@@ -174,35 +199,113 @@ export function makeJobWait(deps) {
             },
             required: ['job'],
         },
-        async execute(_id, rawParams, ctx) {
+        async execute(toolCallId, rawParams, ctx) {
             const params = rawParams;
             const requested = String(params.job);
-            const targets = requested === 'all'
+            const mode = requested === 'any' ? 'any' : 'all';
+            const targets = requested === 'all' || requested === 'any'
                 ? deps.supervisor.list().filter(isLive).map((job) => job.id)
                 : [requested];
-            if (requested !== 'all' && !deps.supervisor.get(requested)) {
+            if (requested !== 'all' && requested !== 'any' && !deps.supervisor.get(requested)) {
                 return unknownJobMessage(deps, requested);
             }
             if (targets.length === 0) {
                 return textResult('No background jobs are running. Start one with ' +
                     'bash({ command, background: true }).');
             }
-            const waitSeconds = clampWaitSeconds(deps, params.timeoutSeconds);
-            const outcome = await waitForJob(deps.supervisor, {
-                targets,
-                timeoutMs: waitSeconds * 1000,
-                ...(ctx.signal ? { signal: ctx.signal } : {}),
-                ...(params.since !== undefined ? { since: params.since } : {}),
+            const now = deps.now ?? Date.now;
+            const { seconds: waitSeconds, clampedFrom } = clampWaitSeconds(deps, params.timeoutSeconds);
+            const waitStartedAt = now();
+            const stallSeconds = deps.stallSeconds();
+            const snapshotsOf = () => targets.flatMap((id) => deps.supervisor.get(id) ?? []);
+            const viewAt = (nowMs) => buildWaitView({
+                toolCallId,
+                snapshots: snapshotsOf(),
+                mode,
+                waitStartedAt,
+                upToMs: waitSeconds * 1000,
+                nowMs,
+                stallSeconds,
             });
+            const emit = (type, nowMs) => {
+                const view = viewAt(nowMs);
+                if (view === undefined || deps.onWait === undefined)
+                    return;
+                try {
+                    deps.onWait({ type, toolCallId, view });
+                }
+                catch {
+                    // A broken view must never break (or even slow) a 20-minute wait (I-6).
+                }
+            };
+            // `begin` ONLY WHEN THERE IS SOMETHING TO WATCH: a wait whose targets have all
+            // ended already returns synchronously, and a card that flashes for zero
+            // frames is noise (RV-4). `any` needs only ONE ended target to be over.
+            const live = snapshotsOf().filter(isLive);
+            const alreadyDone = mode === 'any' ? live.length < targets.length : live.length === 0;
+            const announce = deps.onWait !== undefined && live.length > 0 && !alreadyDone;
+            if (announce)
+                emit('begin', waitStartedAt);
+            const hold = deps.holdWatchdog ?? ((fn) => fn());
+            let endReason = 'abort';
+            let outcome;
+            try {
+                outcome = await hold(() => waitForJob(deps.supervisor, {
+                    targets,
+                    timeoutMs: waitSeconds * 1000,
+                    mode,
+                    ...(ctx.signal ? { signal: ctx.signal } : {}),
+                    ...(params.since !== undefined ? { since: params.since } : {}),
+                    ...(deps.attention ? { wakeOn: deps.attention } : {}),
+                    // ALWAYS INSTALLED, announced or not: the beat is also the wall-clock
+                    // deadline re-check (proc/wait.ts rule 5), which a headless run needs
+                    // after a laptop sleep just as much as the TUI does.
+                    heartbeat: {
+                        everyMs: PROC_LIMITS.waitHeartbeatMs,
+                        onBeat: (nowMs) => {
+                            if (announce)
+                                emit('update', nowMs);
+                        },
+                    },
+                }, now));
+                endReason = outcome.aborted
+                    ? 'abort'
+                    : outcome.woken
+                        ? 'wake'
+                        : outcome.timedOut
+                            ? 'timeout'
+                            : 'terminal';
+            }
+            finally {
+                // EVERY EXIT, INCLUDING A THROW (I-5): a missed `end` leaves a card that says
+                // "waiting" for a wait that is over, forever.
+                if (announce && deps.onWait) {
+                    try {
+                        deps.onWait({ type: 'end', toolCallId, reason: endReason });
+                    }
+                    catch {
+                        // see above
+                    }
+                }
+            }
             if (outcome.aborted) {
                 return errorResult(`The wait on ${targets.join(', ')} was aborted after ` +
                     `${formatDuration(outcome.waitedMs)}. The job was not stopped; ` +
                     'call job_wait again when you want to keep waiting.');
             }
-            const nowMs = Date.now();
-            const stallSeconds = deps.stallSeconds();
+            // `[woke]` and `[note]` describe the WAIT, not a job: one of each per result.
+            const waitNotes = [];
+            if (outcome.woken) {
+                waitNotes.push(`[woke] you sent a message; the wait ended after ${spanText(outcome.waitedMs / 1000)} ` +
+                    `of ${spanText(waitSeconds)}. The job is still running. Queued input is delivered next.`);
+            }
+            if (clampedFrom !== undefined) {
+                waitNotes.push(`[note] timeoutSeconds ${clampedFrom} exceeds the ${PROC_LIMITS.waitMaxSeconds}s ` +
+                    `ceiling; waited up to ${PROC_LIMITS.waitMaxSeconds}s.`);
+            }
+            const nowMs = now();
             const blocks = [];
-            for (const job of outcome.jobs) {
+            for (const [blockIndex, job] of outcome.jobs.entries()) {
                 const page = outcome.pages.get(job.id);
                 // THE CARRY LINE IS NOT AN INCREMENT WHEN IT HAS NOT MOVED (RV-P1-5). A
                 // carriage-return-rewritten progress bar completes no rows, so the ring
@@ -227,12 +330,29 @@ export function makeJobWait(deps) {
                 const progressUnchanged = hasBaseline && current === previous;
                 const newRows = shownRows.length;
                 const advanced = !hasBaseline || newRows > 0 || !progressUnchanged;
-                memoryForJob.noChange = advanced ? 0 : memoryForJob.noChange + 1;
+                // A wait the USER cut short says nothing about the job: it neither advances
+                // nor extends the silence count.
+                memoryForJob.noChange = advanced
+                    ? 0
+                    : outcome.woken
+                        ? memoryForJob.noChange
+                        : memoryForJob.noChange + 1;
                 if (current !== undefined)
                     memoryForJob.lastProgress = current;
                 if (carry.length > 0)
                     memoryForJob.lastCarry = carry;
+                memoryForJob.lastWaitSeconds = waitSeconds;
                 memory.set(job.id, memoryForJob);
+                // ADVICE, NEVER ENFORCED (I-13): shown only when it differs from the default.
+                const suggested = suggestWaitSeconds({
+                    jobAgeMs: nowMs - job.startedAt,
+                    lastWaitSeconds: waitSeconds,
+                    quietWaits: memoryForJob.noChange,
+                    etaSeconds: parseEtaSeconds(current),
+                    configuredSeconds: deps.waitSeconds(),
+                    minSeconds: PROC_LIMITS.waitMinSeconds,
+                    maxSeconds: PROC_LIMITS.waitMaxSeconds,
+                });
                 // THE SPIN GUARD (R-3): counted per job, reset by ANY change. It never
                 // refuses the wait; it prepends one line naming four ways out.
                 const guard = memoryForJob.noChange >= deps.maxConsecutiveWaits
@@ -252,6 +372,9 @@ export function makeJobWait(deps) {
                         stalledSeconds: stallSeconds,
                         waitSeconds,
                         progressUnchanged,
+                        extraNotes: blockIndex === 0 ? waitNotes : [],
+                        suggestedSeconds: suggested !== deps.waitSeconds() ? suggested : undefined,
+                        etaText: extractEtaText(current),
                         truncatedNote: page?.truncated === true
                             ? '[note] older rows were dropped - the tail keeps the last ' +
                                 `${PROC_LIMITS.serviceTailRows} rows` +

package/dist/ui/ActivityLine.js

@@ -3,7 +3,7 @@ import { Box, Text } from 'ink';
 import Spinner from 'ink-spinner';
 import { pickGlyphs } from './glyphs.js';
 import { pickActivityPhrase } from './activity-phrases.js';
-import { phaseLabels } from './layout/status-layout.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;
@@ -15,7 +15,10 @@ export function resolveActivityLabel(activity, glyphs) {
     // 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) {
-        return `Waiting on ${activity.wait.jobId} (up to ${activity.wait.upToSeconds}s)`;
+        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({

package/dist/ui/App.js

@@ -92,7 +92,8 @@ import { SettingsScreen, compactionSettingsFrom, fastSettingsFrom, } from './ove
 import { ConfirmDialog } from './overlays/ConfirmDialog.js';
 import { QuestionOverlay } from './overlays/QuestionOverlay.js';
 import { PlanReviewOverlay } from './overlays/PlanReviewOverlay.js';
-import { CommandRegistry, runSlashInput } from '../commands/registry.js';
+import { CommandRegistry, parseSlashInput, runSlashInput, } from '../commands/registry.js';
+import { buildInvocationCard, invocationCardsEnabled } from '../agent/invocation-card.js';
 import { registerBuiltinCommands } from '../commands/builtins.js';
 import { makeSkillsCommand, registerSkillCommands } from '../commands/skills.js';
 import { MODE_TOGGLE_KEYS } from '../agent/agent-mode.js';
@@ -1225,6 +1226,30 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
             }
         });
     }, [controller, flushPending, governorInterval]);
+    // --- The long wait's live view (extended-job-wait §3.8.1). --------------
+    //
+    // THROUGH THE COALESCER, like the tool tail above and for the same reason: a
+    // 1 Hz producer is cheap, but two updates landing in one frame should commit
+    // once. `begin` and `update` are the same action (the reducer only writes onto a
+    // RUNNING matching entry); `end` needs no action of its own - `toolExecEnd` and
+    // every idle path clear the view (I-5 / RV-2), and a second clear here would be
+    // a third copy of that rule.
+    useEffect(() => {
+        // OPTIONAL CALL: a duck-typed controller (a test double, a headless shim) predates
+        // this channel and has nothing to subscribe to - exactly as `subscribeTeam?` is.
+        return controller.subscribeWait?.((event) => {
+            if (event.type === 'end')
+                return;
+            pending.current.push({
+                type: 'waitUpdate',
+                toolCallId: event.toolCallId,
+                view: event.view,
+            });
+            if (!flushTimer.current) {
+                flushTimer.current = setTimeout(() => flushPending(), governorInterval.current);
+            }
+        });
+    }, [controller, flushPending, governorInterval]);
     // Event boundaries own start/end; ticks only refresh the live projection.
     useEffect(() => {
         if (state.status !== 'running')
@@ -1942,8 +1967,10 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
             dispatch({ type: 'taskSummaryReady', view: outcome.view });
         });
     };
+    const invocationCardsOn = invocationCardsEnabled();
     const makeCtx = (args) => ({
         args,
+        invocationCards: invocationCardsOn,
         requestCopy: copyCoordinator.requestCopy,
         controller,
         state: stateRef.current,
@@ -2121,10 +2148,17 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
         // must be the one that runs, whichever branch it takes.
         cancelFollowThrough();
         cancelConfirmation();
+        // THE ONE PLACE A CARD IS BUILT (tui-invocation-cards I-3 / I-6): redact -> normalise ->
+        // limit, with the same redactor the `Command:` echo uses. `message` below is the model's
+        // input and is never touched; the card only replaces what the TRANSCRIPT shows.
+        const card = invocationCardsOn && opts.invocation
+            ? buildInvocationCard(opts.invocation, (text) => redactText(text, getSecrets()))
+            : undefined;
+        const shown = card?.commandLine ?? message;
         if (interactionPhase.current === 'running' || controller.isCompactionBusy?.()) {
             try {
                 const queueId = controller.queueUserMessage(message);
-                dispatch({ type: 'steerQueued', queueId, text: message });
+                dispatch({ type: 'steerQueued', queueId, text: shown, ...(card ? { invocation: card } : {}) });
                 return { accepted: true };
             }
             catch (error) {
@@ -2143,7 +2177,10 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
         // the user has learned, so suppressing the fade is correct rather than
         // incidental — which is why the parameter is named for the CAUSE (P2-8).
         if (opts.userInitiated !== false) {
-            recordPrompt(message);
+            // A card's command line was already recorded by `executeSlashInput`; the payload
+            // behind it must never reach the up-arrow history (I-9: the gate is unchanged).
+            if (!card)
+                recordPrompt(message);
             // THE ONE PLACE THE NUDGE BUDGET IS REFILLED (P0-2 / I-10). Same predicate
             // as `recordPrompt`, and for the same reason: the question is "did a human
             // ask for this?", and only a human may hand the gate another attempt. A
@@ -2154,7 +2191,7 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
         // Mirrors where the reducer clears its own copies, in the same action
         // (C-11): a new turn's end reason must not inherit the previous one's.
         endReasonRef.current = { aborted: false, errored: false };
-        dispatch({ type: 'submit', text: message });
+        dispatch({ type: 'submit', text: shown, ...(card ? { invocation: card } : {}) });
         const pre = controller.preflight();
         if (!pre.ok) {
             dispatch({ type: 'runError' });
@@ -2174,7 +2211,7 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
         // model call that describes a turn nobody ran; and below, in the queueing
         // branch, the message is steering rather than a new task.
         if (opts.userInitiated !== false)
-            ensureTaskSummary(message);
+            ensureTaskSummary(shown);
         void controller.prompt(message, { todoPolicy: opts.todoPolicy ?? 'new-task' }).then((outcome) => {
             if (!mounted.current || sequence !== submissionSequence.current)
                 return;
@@ -2213,7 +2250,13 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
         // Retain a recoverable command before any asynchronous handler can fail.
         const safe = redactText(raw, getSecrets());
         recordPrompt(safe);
-        notify('info', `Command: ${safe}`);
+        // The echo is suppressed BEFORE the command runs and never deleted afterwards: printed
+        // scrollback rows cannot be rewritten (I-5). The predicate is the command's own (I-8).
+        const parsed = parseSlashInput(raw);
+        const rendersCard = invocationCardsOn && parsed !== null
+            && registry.get(parsed.name)?.rendersInvocationCard?.(parsed.args) === true;
+        if (!rendersCard)
+            notify('info', `Command: ${safe}`);
         try {
             await runSlashInput(registry, raw, makeCtx);
         }
@@ -3005,6 +3048,16 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
                         jobId: typeof args.job === 'string' ? args.job : 'job',
                         upToSeconds: Math.max(0, Math.round(requested)),
                     };
+                    // Once the tool has announced itself (`begin`), its own view is the better
+                    // source - the clamped budget and the start stamp - and adds the running
+                    // clock. Before that one frame the args-only sentence stands.
+                    if (e.wait) {
+                        wait = {
+                            jobId: wait.jobId,
+                            upToSeconds: Math.max(0, Math.round(e.wait.upToMs / 1000)),
+                            elapsedSeconds: Math.max(0, Math.floor(Date.now() / 1000) - Math.floor(e.wait.waitStartedAt / 1000)),
+                        };
+                    }
                 }
                 break;
             }

package/dist/ui/StatusBar.d.ts

@@ -25,6 +25,7 @@ export interface StatusBarProps {
     wait?: {
         jobId: string;
         upToSeconds: number;
+        elapsedSeconds?: number;
     };
     runOutcome?: "none" | "ended" | "interrupted" | "failed";
     reducedMotion?: boolean;

package/dist/ui/Transcript.js

@@ -8,9 +8,11 @@ import { pickGlyphs, toolGlyph } from './glyphs.js';
 import { separationRows } from './density.js';
 import { EntryFrame } from './entries/EntryFrame.js';
 import { UserEntry } from './entries/UserEntry.js';
+import { InvocationCard } from './entries/InvocationCard.js';
 import { QueuedEntry } from './entries/QueuedEntry.js';
 import { AssistantEntry } from './entries/AssistantEntry.js';
 import { ToolCard, statusColor, toolEntryGlyph } from './entries/ToolCard.js';
+import { WaitCard } from './entries/WaitCard.js';
 import { TeamCard, teamCardColor } from './entries/TeamCard.js';
 import { GovernanceCard, governanceCardColor } from './entries/GovernanceCard.js';
 import { isLiveTeamCard, rosterCounts } from './team-status.js';
@@ -78,7 +80,9 @@ function EntryViewImpl({ entry, prev, expanded, thinkingVisible, reducedMotion,
     const frame = (glyph, color, children) => (_jsx(EntryFrame, { glyph: glyph, color: color, continuation: glyphs.railVertical, separation: separation, spacerColor: theme.border, children: children }));
     switch (entry.kind) {
         case 'user':
-            return frame(glyphs.user, theme.user, _jsx(UserEntry, { text: entry.text, theme: theme, caps: caps }));
+            return frame(glyphs.user, theme.user, entry.invocation
+                ? _jsx(InvocationCard, { card: entry.invocation, theme: theme, caps: caps })
+                : _jsx(UserEntry, { text: entry.text, theme: theme, caps: caps }));
         case 'queued':
             // `theme.muted`: quieter than a user message, louder than a notice --
             // the row exists to be noticed UNTIL it is accepted, then rewritten in
@@ -99,6 +103,12 @@ function EntryViewImpl({ entry, prev, expanded, thinkingVisible, reducedMotion,
                 thinkingMs: entry.thinkingMs, theme: theme, caps: caps }));
         }
         case 'tool':
+            // THE CARD IS CHOSEN FROM THE ENTRY ITSELF, with no extra prop (extended-job-wait
+            // RV-3): `LiveTail` mounts this same component for native-scroll mode, and a
+            // value only `Transcript` passed would leave that mode on the one-line card.
+            if (entry.name === 'job_wait' && entry.status === 'running' && entry.wait) {
+                return frame(toolEntryGlyph(entry.name, caps), statusColor(entry.status, theme), _jsx(WaitCard, { view: entry.wait, nowSec: nowSec, reducedMotion: reducedMotion, theme: theme, caps: caps }));
+            }
             return frame(toolEntryGlyph(entry.name, caps), statusColor(entry.status, theme), _jsx(ToolCard, { name: entry.name, label: entry.label, argsRaw: entry.argsRaw, args: entry.args, status: entry.status, preview: entry.preview, patch: entry.patch, durationMs: entry.durationMs, isError: entry.isError, expanded: expanded, reducedMotion: reducedMotion, 
                 // `entry.live` AND NOT `entry.live ?? []` (P2-4): `ToolCard`'s default
                 // comparator sees a fresh `[]` as a changed prop, which is why that

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

@@ -0,0 +1,20 @@
+/**
+ * Render a `user` entry that carries an invocation card (tui-invocation-cards).
+ *
+ * Like `UserEntry`, this renders CONTENT only: the role glyph, rail and spacing belong
+ * to `EntryFrame`, so the card stays "the user's turn" for density, turn counting and
+ * the settled boundary. The header text comes from `invocationHeaderSegments` and is
+ * never assembled here (RV-10); the row count it implies is `invocationCardRows`.
+ */
+import React from 'react';
+import type { Theme } from '../theme.js';
+import type { TermCapabilities } from '../capabilities.js';
+import type { InvocationCard as InvocationCardData } from '../../agent/invocation-card.js';
+declare function InvocationCardImpl({ card, theme, caps, }: {
+    card: InvocationCardData;
+    theme: Theme;
+    caps: TermCapabilities;
+}): React.ReactElement;
+/** Default comparator: `mapEntry` preserves identity for untouched entries (L2 / R3). */
+export declare const InvocationCard: React.MemoExoticComponent<typeof InvocationCardImpl>;
+export {};

package/dist/ui/entries/InvocationCard.js

@@ -0,0 +1,32 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Render a `user` entry that carries an invocation card (tui-invocation-cards).
+ *
+ * Like `UserEntry`, this renders CONTENT only: the role glyph, rail and spacing belong
+ * to `EntryFrame`, so the card stays "the user's turn" for density, turn counting and
+ * the settled boundary. The header text comes from `invocationHeaderSegments` and is
+ * never assembled here (RV-10); the row count it implies is `invocationCardRows`.
+ */
+import React from 'react';
+import { Box, Text } from 'ink';
+import { pickGlyphs } from '../glyphs.js';
+import { invocationHeaderSegments, invocationHiddenText, invocationInputText, } from '../layout/invocation-card.js';
+import { GUTTER_WIDTH } from '../layout/Gutter.js';
+import { useTerminalSize } from '../layout/useTerminalSize.js';
+import { fitCells } from '../layout/cells.js';
+function toneColor(tone, theme) {
+    if (tone === 'label')
+        return theme.accent;
+    if (tone === 'name')
+        return theme.user;
+    return theme.muted;
+}
+function InvocationCardImpl({ card, theme, caps, }) {
+    const glyphs = pickGlyphs(caps);
+    const { cols } = useTerminalSize();
+    const usable = Math.max(1, cols - GUTTER_WIDTH);
+    const header = invocationHeaderSegments(card, glyphs, usable);
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { wrap: "truncate", children: header.map((part, index) => (_jsx(Text, { color: toneColor(part.tone, theme), bold: part.bold, children: part.text }, index))) }), card.input !== '' && _jsx(Text, { color: theme.user, children: invocationInputText(card) }), card.inputHidden > 0 && (_jsx(Text, { color: theme.muted, wrap: "truncate", children: invocationHiddenText(card, glyphs) })), card.note !== undefined && card.note !== '' && (_jsx(Text, { color: theme.muted, wrap: "truncate", children: fitCells(card.note, usable, glyphs.ellipsis) }))] }));
+}
+/** Default comparator: `mapEntry` preserves identity for untouched entries (L2 / R3). */
+export const InvocationCard = React.memo(InvocationCardImpl);

package/dist/ui/entries/ToolCard.js

@@ -24,6 +24,7 @@ import { formatDuration } from '../../agent/usage.js';
 import { ToolPreview, bashBadge } from './ToolPreview.js';
 import { DiffView } from './DiffView.js';
 import { STALL_AFTER_MS } from '../../tools/tool-output-store.js';
+import { shortDuration } from '../layout/status-layout.js';
 /** Number of preview lines shown before collapse. */
 const COLLAPSED_LINES = 8;
 /** Shared empty slice, so an argument-less card allocates nothing per frame. */
@@ -41,8 +42,16 @@ export function statusColor(status, theme) {
     }
 }
 /** One-line summary of the tool arguments for the card header. */
-function summarizeArgs(name, ellipsis, args, argsRaw) {
+function summarizeArgs(name, ellipsis, args, argsRaw, midDot = '-') {
     if (args) {
+        // `t3 - up to 10m00s` reads better in the settled history row than
+        // `job=t3 timeoutSeconds=600` (extended-job-wait P2). Needs both fields.
+        if (name === 'job_wait' && typeof args.job === 'string') {
+            const seconds = args.timeoutSeconds;
+            return typeof seconds === 'number' && Number.isFinite(seconds) && seconds > 0
+                ? `${args.job} ${midDot} up to ${shortDuration(seconds * 1000)}`
+                : args.job;
+        }
         if (name === 'bash' && typeof args.command === 'string')
             return args.command;
         if (typeof args.path === 'string')
@@ -125,7 +134,7 @@ function ToolCardImpl(props) {
         ? `no output for ${Math.floor(stalledFor / 1000)}s`
         : '(running)';
     const badge = status === 'running' && !reducedMotion && caps.unicode ? (_jsxs(Text, { color: color, children: [_jsx(Spinner, { type: "dots" }), " running"] })) : (_jsxs(Text, { color: color, children: [status === 'running' ? `${glyphs.spinnerStill} ` : '', badgeLabel(name, status, previewText)] }));
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { flexDirection: "row", children: [_jsx(Text, { color: theme.accent, bold: true, children: name }), _jsxs(Text, { color: theme.muted, children: [" ", summarizeArgs(name, glyphs.ellipsis, args, argsRaw), "  "] }), badge, durationMs !== undefined && (_jsxs(Text, { color: theme.muted, children: [" (", formatDuration(durationMs), ")"] }))] }), showBody && (_jsx(Box, { flexDirection: "column", flexShrink: 0, paddingLeft: 1, ...railBorderProps(glyphs.railVertical, isError ? theme.toolError : theme.border), children: showLive ? (_jsxs(_Fragment, { children: [visibleLive.map((row, i) => (
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { flexDirection: "row", children: [_jsx(Text, { color: theme.accent, bold: true, children: name }), _jsxs(Text, { color: theme.muted, children: [" ", summarizeArgs(name, glyphs.ellipsis, args, argsRaw, glyphs.midDot), "  "] }), badge, durationMs !== undefined && (_jsxs(Text, { color: theme.muted, children: [" (", formatDuration(durationMs), ")"] }))] }), showBody && (_jsx(Box, { flexDirection: "column", flexShrink: 0, paddingLeft: 1, ...railBorderProps(glyphs.railVertical, isError ? theme.toolError : theme.border), children: showLive ? (_jsxs(_Fragment, { children: [visibleLive.map((row, i) => (
                         // The row is already terminal-safe and clipped at
                         // `LIVE_ROW_MAX_CHARS` by `sanitizeChunk`, so `wrap="truncate"`
                         // is an exact height rather than a hope — which is the coupling

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 {};