@aragon-agent/cli 0.6.46 → 0.6.47

package/dist/proc/wait.js

@@ -23,6 +23,20 @@
  *     nothing at all (the supervisor now emits `stopped` from it), and
  *     `dispose()` clears its listener set without emitting; the self-timeout is
  *     therefore a real second path, not belt-and-braces.
+ *  5. THE HEARTBEAT RE-CHECKS THE DEADLINE AGAINST `now()`, NOT AGAINST THE
+ *     TIMER (extended-job-wait). A 20-minute wait spans a laptop lid: Node's
+ *     monotonic `setTimeout` does not count the sleep, so a "10 minute" wait can
+ *     run 40 minutes of wall clock. Each beat compares `now() - startedAt` with
+ *     the budget and settles on the first beat after resume.
+ *
+ * THE WAKE SOURCE IS EDGE-TRIGGERED ONLY - there is no "is something pending"
+ * probe. The engine drains steering before EVERY tool execution
+ * (`core/src/engine/agent-loop.ts`), so input that arrived before this wait began
+ * has already been accepted; only input that arrives AFTER `subscribe()` needs to
+ * end the wait. Between the engine's decision to run `job_wait` and the
+ * `subscribe()` below there is no `await`, so no notification can fall into the
+ * gap. A level-triggered probe would add a stale-state hot loop (every wait
+ * returning at once) for no reachable gain.
  */
 import { isTerminalStatus } from './types.js';
 /** Read one bounded page per target; `read()` returns `undefined` for a vanished id. */
@@ -49,24 +63,41 @@ function allSettled(port, targets) {
         return snapshot === undefined || isTerminalStatus(snapshot.status);
     });
 }
+/** Has any target ended? Same unknown-id rule as `allSettled`. */
+function anySettled(port, targets) {
+    return targets.some((id) => {
+        const snapshot = port.get(id);
+        return snapshot === undefined || isTerminalStatus(snapshot.status);
+    });
+}
 /**
- * Wait up to `timeoutMs` for every target to reach a terminal status.
+ * THE ONE PREDICATE for "is this wait over", shared by the entry fast path and the
+ * `finish` funnel. Using it in only one of them makes `mode: 'any'` subscribe and
+ * burn the whole timeout when a target had already ended.
+ */
+function isDone(port, targets, mode) {
+    return mode === 'any' ? anySettled(port, targets) : allSettled(port, targets);
+}
+/**
+ * Wait up to `timeoutMs` for the targets to reach a terminal status.
  *
  * Resolves - never rejects - and always after at most `timeoutMs`. `now` is
  * injectable so a test can assert `waitedMs` without depending on wall clock.
  */
 export async function waitForJob(port, req, now = Date.now) {
     const { targets, signal } = req;
+    const mode = req.mode ?? 'all';
     const startedAt = now();
     // RULE 1. Nothing to wait for at all, or everything already ended: no
     // subscription, no timer, `waitedMs: 0`.
-    if (targets.length === 0 || allSettled(port, targets)) {
+    if (targets.length === 0 || isDone(port, targets, mode)) {
         return {
             jobs: collect(port, targets),
             terminal: true,
             waitedMs: 0,
             timedOut: false,
             aborted: false,
+            woken: false,
             pages: readPages(port, targets, req.since),
         };
     }
@@ -79,6 +110,8 @@ export async function waitForJob(port, req, now = Date.now) {
         // from inside the listener instead of resolving the wait.
         let unsubscribe = () => { };
         let timer;
+        let beat;
+        let unwake = () => { };
         /** Assigned below; declared here so `finish` never reads an uninitialised binding. */
         let onAbort = () => { };
         // RULE 3: the one funnel. Idempotent, and it releases every reference before
@@ -88,15 +121,19 @@ export async function waitForJob(port, req, now = Date.now) {
                 return;
             done = true;
             unsubscribe();
+            unwake();
             if (timer !== undefined)
                 clearTimeout(timer);
+            if (beat !== undefined)
+                clearInterval(beat);
             signal?.removeEventListener('abort', onAbort);
             resolve({
                 jobs: collect(port, targets),
-                terminal: reason === 'terminal' || allSettled(port, targets),
+                terminal: reason === 'terminal' || isDone(port, targets, mode),
                 waitedMs: now() - startedAt,
                 timedOut: reason === 'timeout',
                 aborted: reason === 'abort',
+                woken: reason === 'wake',
                 pages: readPages(port, targets, req.since),
             });
         };
@@ -105,12 +142,38 @@ export async function waitForJob(port, req, now = Date.now) {
                 return;
             if (!targets.includes(event.service.id))
                 return;
-            if (allSettled(port, targets))
+            if (isDone(port, targets, mode))
                 finish('terminal');
         });
+        // The user spoke. Edge-triggered: only a notification after this line counts.
+        unwake = req.wakeOn?.subscribe(() => finish('wake')) ?? (() => { });
+        if (done) {
+            // A source that notifies synchronously inside `subscribe` already settled us.
+            unwake();
+            return;
+        }
         // RULE 2: `unref`, so a pending wait never keeps a quitting process alive.
         timer = setTimeout(() => finish('timeout'), Math.max(0, req.timeoutMs));
         timer.unref?.();
+        // RULE 5. Also the view's 1 Hz clock. A throwing `onBeat` is a renderer bug and
+        // must never kill a 20-minute wait.
+        if (req.heartbeat) {
+            const { everyMs, onBeat } = req.heartbeat;
+            beat = setInterval(() => {
+                const current = now();
+                if (current - startedAt >= req.timeoutMs) {
+                    finish('timeout');
+                    return;
+                }
+                try {
+                    onBeat(current);
+                }
+                catch {
+                    // Deliberately swallowed: see above.
+                }
+            }, Math.max(1, everyMs));
+            beat.unref?.();
+        }
         onAbort = () => finish('abort');
         // `{ once: true }` AND the explicit removal in `finish`: the option alone
         // leaves the listener registered on a signal that outlives this wait.

package/dist/session/checkpoint.js

@@ -101,6 +101,8 @@ export function settleRunningToolCards(entries) {
             live: undefined,
             liveSeq: undefined,
             lastOutputAt: undefined,
+            wait: undefined,
+            waitSeq: undefined,
         };
     });
     return { entries: out, settled };

package/dist/session/persist.js

@@ -60,8 +60,20 @@ function defaultStamp() {
  */
 function stripLiveToolOutput(entries) {
     return entries.map((e) => e.kind === 'tool' &&
-        (e.live !== undefined || e.liveSeq !== undefined || e.lastOutputAt !== undefined)
-        ? { ...e, live: undefined, liveSeq: undefined, lastOutputAt: undefined }
+        (e.live !== undefined ||
+            e.liveSeq !== undefined ||
+            e.lastOutputAt !== undefined ||
+            e.wait !== undefined ||
+            e.waitSeq !== undefined)
+        ? {
+            ...e,
+            live: undefined,
+            liveSeq: undefined,
+            lastOutputAt: undefined,
+            // `wait` / `waitSeq` die with `live` (extended-job-wait I-9).
+            wait: undefined,
+            waitSeq: undefined,
+        }
         : e);
 }
 /**
@@ -146,6 +158,11 @@ export function saveSession(filePath, data) {
  */
 export function normalizeLoadedEntries(entries) {
     return entries.map((entry) => {
+        // A runtime-only wait view that reached disk anyway (an older or hand-edited
+        // file) describes a wait that died with the session: drop it (I-9).
+        if (entry.kind === 'tool' && (entry.wait !== undefined || entry.waitSeq !== undefined)) {
+            return { ...entry, wait: undefined, waitSeq: undefined };
+        }
         if (entry.kind === 'team' && entry.active) {
             return { ...entry, active: false, aborted: true };
         }

package/dist/session/validate-session.js

@@ -166,6 +166,9 @@ const ENTRY_FIELDS = {
         status: enumeration('pending', 'running', 'done', 'error'), preview: optional(string),
         durationMs: optional(number), isError: optional(boolean), patch: optional(patch),
         live: optional(array(string)), liveSeq: optional(number), lastOutputAt: optional(number),
+        // Runtime-only (extended-job-wait I-9): never written, but tolerated on read so a
+        // session saved mid-wait by any path still resumes; `normalizeLoadedEntries` drops it.
+        wait: optional(object), waitSeq: optional(number),
     },
     team: { dispatchId: string, requested: number, runs: array(subagent), aborted: boolean,
         durationMs: optional(number), active: boolean },

package/dist/tools/job-tools.d.ts

@@ -18,14 +18,14 @@
 import { type AgentTool } from '@aragon-agent/core';
 import { type JobNotice } from '../proc/notices.js';
 import type { JobKind, ProcSupervisorPort, ServiceStatus } from '../proc/types.js';
+import { type WakeSource } from '../proc/wait.js';
+import { type WaitListener } from '../proc/wait-view.js';
 export interface JobToolDeps {
     supervisor: ProcSupervisorPort;
     /** `cfg.jobs.waitSeconds`, read LIVE (same rule as `startupSettleMs`). */
     waitSeconds: () => number;
     /** `cfg.jobs.stallSeconds`, read LIVE; only the `[stalled]` sentence uses it. */
     stallSeconds: () => number;
-    /** `cfg.toolTimeoutMs`, read LIVE: I-4's second convergence. */
-    toolTimeoutMs: () => number;
     /** `PROC_LIMITS.maxConsecutiveWaits`. */
     maxConsecutiveWaits: number;
     /**
@@ -40,6 +40,17 @@ export interface JobToolDeps {
         kind: JobKind;
         status: ServiceStatus;
     } | undefined;
+    /** Live view of the wait (`begin` / 1 Hz `update` / `end`); absent for a sub-agent. */
+    onWait?: WaitListener;
+    /**
+     * Runs the whole wait with the idle watchdog paused (`controller.withPausedWatchdog`).
+     * Absent in a sub-agent or a fixture: the wait then runs unwrapped, as before.
+     */
+    holdWatchdog?: <T>(fn: () => Promise<T>) => Promise<T>;
+    /** Ends a wait when the user sends a message (edge-triggered; see `proc/wait.ts`). */
+    attention?: WakeSource;
+    /** Test seam; defaults to `Date.now`. */
+    now?: () => number;
 }
 export declare function makeJobWait(deps: JobToolDeps): AgentTool;
 export declare function makeJobList(deps: JobToolDeps): AgentTool;

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

@@ -1226,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')
@@ -3024,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

@@ -12,6 +12,7 @@ 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';
@@ -102,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/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