@aragon-agent/cli 0.6.46 → 0.6.48

package/dist/todo/normalize.js

@@ -22,7 +22,7 @@
  * step" with no null branch and lets a unit test prove the property instead of
  * an operator inferring it from a transcript.
  */
-import { TODO_LIMITS } from './limits.js';
+import { TODO_LIMITS } from '@aragon-agent/tui/model/todo/limits';
 const STATUSES = new Set([
     'pending',
     'in_progress',

package/dist/todo/prompt.d.ts

@@ -21,7 +21,7 @@
  * behaviour report - INCLUDING a change to either `{{VISIBILITY}}` variant, which
  * is part of the block.
  */
-import { TODO_BLOCK_VERSION } from './limits.js';
+import { TODO_BLOCK_VERSION } from '@aragon-agent/tui/model/todo/limits';
 export { TODO_BLOCK_VERSION };
 export interface TodoBlockParams {
     panelVisible: boolean;

package/dist/todo/prompt.js

@@ -21,7 +21,7 @@
  * behaviour report - INCLUDING a change to either `{{VISIBILITY}}` variant, which
  * is part of the block.
  */
-import { TODO_BLOCK_VERSION } from './limits.js';
+import { TODO_BLOCK_VERSION } from '@aragon-agent/tui/model/todo/limits';
 export { TODO_BLOCK_VERSION };
 /**
  * The ONLY sentence in the block that mentions a display at all. Everything else

package/dist/todo/store.d.ts

@@ -22,7 +22,7 @@
  * `TodoCard`'s `React.memo` and the transcript's height cache, and undo the redraw
  * savings `mapEntry` buys with object identity (P1-3).
  */
-import type { AcceptanceItem, TodoClearReason, TodoEventListener, TodoItem, TodoSnapshot } from './types.js';
+import type { AcceptanceItem, TodoClearReason, TodoEventListener, TodoItem, TodoSnapshot } from '@aragon-agent/tui/model/todo/types';
 /**
  * What a `write()` decided.
  *

package/dist/todo/store.js

@@ -23,8 +23,8 @@
  * savings `mapEntry` buys with object identity (P1-3).
  */
 import { getLogger } from '../logging/logger.js';
-import { acceptanceSummary, normalizeAcceptance, planIsResolved } from './acceptance.js';
-import { ACCEPT_LIMITS, TODO_LIMITS } from './limits.js';
+import { acceptanceSummary, normalizeAcceptance, planIsResolved } from '@aragon-agent/tui/model/todo/acceptance';
+import { ACCEPT_LIMITS, TODO_LIMITS } from '@aragon-agent/tui/model/todo/limits';
 import { normalizeTodos } from './normalize.js';
 /** The one model-readable refusal that is about the PLAN, not about the payload. */
 export const FRESH_ACCEPTANCE_REFUSAL = 'A plan needs acceptance criteria: how will you know the work is done? Send the ' +

package/dist/todo/todo-tool.d.ts

@@ -26,7 +26,7 @@
  */
 import { type AgentTool } from '@aragon-agent/core';
 import type { TodoStore } from './store.js';
-import type { AcceptanceItem, TodoItem } from './types.js';
+import type { AcceptanceItem, TodoItem } from '@aragon-agent/tui/model/todo/types';
 export interface TodoToolDeps {
     store: TodoStore;
     /** Read LIVE, never cached: `/todo off` flips this; it cannot unregister (C-1). */

package/dist/todo/todo-tool.js

@@ -25,8 +25,8 @@
  * human wait.
  */
 import { errorResult, textResult } from '@aragon-agent/core';
-import { acceptanceSummary, countUncheckedCriteria, countUnfinishedSteps, derivePlanPhase, planOutstanding, } from './acceptance.js';
-import { ACCEPT_LIMITS, TODO_LIMITS, TODO_RESULT_LIMITS } from './limits.js';
+import { acceptanceSummary, countUncheckedCriteria, countUnfinishedSteps, derivePlanPhase, planOutstanding, } from '@aragon-agent/tui/model/todo/acceptance';
+import { ACCEPT_LIMITS, TODO_LIMITS, TODO_RESULT_LIMITS } from '@aragon-agent/tui/model/todo/limits';
 /**
  * Turned off mid-session. A NON-ERROR result on purpose: the user turned a
  * display off, the model did nothing wrong, and an error result invites a retry.

package/dist/tools/bash-tool.d.ts

@@ -40,7 +40,7 @@
  * `bash` assertions meaningful rather than rewritten.
  */
 import { type AgentTool } from '@aragon-agent/core';
-import { type ProcSupervisorPort } from '../proc/types.js';
+import { type ProcSupervisorPort } from '@aragon-agent/tui/model/proc/types';
 import type { ToolDeps } from './fs-tools.js';
 export interface BashToolOptions {
     /**

package/dist/tools/bash-tool.js

@@ -44,9 +44,9 @@ import process from 'node:process';
 import { defineTool, errorResult, textResult, } from '@aragon-agent/core';
 import { looksLongRunning } from '../proc/classify.js';
 import { killTree } from '../proc/kill-tree.js';
-import { PROC_LIMITS } from '../proc/limits.js';
+import { PROC_LIMITS } from '@aragon-agent/tui/model/proc/limits';
 import { hasOpenOutputStreams } from '../proc/output-streams.js';
-import { isTerminalStatus } from '../proc/types.js';
+import { isTerminalStatus } from '@aragon-agent/tui/model/proc/types';
 /**
  * The two sentences appended to the tool description when background launches
  * are available.

package/dist/tools/diff.d.ts

@@ -18,7 +18,7 @@
  * single-region edit is today's rows plus ONE `@@` header, a multi-region edit is
  * strictly smaller, and a trailing `\r` no longer reaches the prompt.
  */
-import { type FilePatch } from './patch.js';
+import { type FilePatch } from '@aragon-agent/tui/model/tools/patch';
 export interface DiffOptions {
     /** File path shown in the `---`/`+++` header. */
     path?: string;

package/dist/tools/diff.js

@@ -18,7 +18,7 @@
  * single-region edit is today's rows plus ONE `@@` header, a multi-region edit is
  * strictly smaller, and a trailing `\r` no longer reaches the prompt.
  */
-import { PATCH_LIMITS, buildPatch } from './patch.js';
+import { PATCH_LIMITS, buildPatch } from '@aragon-agent/tui/model/tools/patch';
 const CONTEXT_LINES = 2;
 /** Appended when the rendered text hits `PATCH_LIMITS.modelDiffMaxChars`. */
 const DIFF_TRUNCATED_NOTE = '... (diff truncated)';

package/dist/tools/file-change-store.d.ts

@@ -22,7 +22,7 @@
  *    RING, not a leak detector: nothing is retained longer than `cap` writes, so
  *    a patch nobody consumes cannot accumulate.
  */
-import type { FilePatch } from './patch.js';
+import type { FilePatch } from '@aragon-agent/tui/model/tools/patch';
 export interface FileChangeStore {
     record(owner: string, toolCallId: string, patch: FilePatch): void;
     /** Returns and REMOVES the patch. A patch is consumed exactly once. */

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

@@ -7,8 +7,8 @@
  * tools do not re-implement them.
  */
 import { type AgentTool } from '@aragon-agent/core';
-import { type FilePatch } from './patch.js';
-import type { ProcSupervisorPort } from '../proc/types.js';
+import { type FilePatch } from '@aragon-agent/tui/model/tools/patch';
+import type { ProcSupervisorPort } from '@aragon-agent/tui/model/proc/types';
 export interface ToolDeps {
     getCwd: () => string;
     /**

package/dist/tools/fs-tools.js

@@ -10,7 +10,7 @@ import { promises as fs } from 'node:fs';
 import { isAbsolute, join, resolve, dirname } from 'node:path';
 import { defineTool, errorResult, textResult, } from '@aragon-agent/core';
 import { renderUnifiedDiff } from './diff.js';
-import { PATCH_LIMITS, buildPatch } from './patch.js';
+import { PATCH_LIMITS, buildPatch } from '@aragon-agent/tui/model/tools/patch';
 function resolvePath(cwd, p) {
     return isAbsolute(p) ? p : resolve(cwd, p);
 }

package/dist/tools/index.d.ts

@@ -9,10 +9,10 @@
  * before the tool runs.
  */
 import { type AgentTool, type ToolPolicyDecision, type ToolPolicyVerdict } from '@aragon-agent/core';
-import type { AgentMode } from '../agent/agent-mode.js';
+import type { AgentMode } from '@aragon-agent/tui/model/agent/agent-mode';
 import type { ToolPermission } from '../exec/permission.js';
-import type { FilePatch } from './patch.js';
-import type { ProcSupervisorPort } from '../proc/types.js';
+import type { FilePatch } from '@aragon-agent/tui/model/tools/patch';
+import type { ProcSupervisorPort } from '@aragon-agent/tui/model/proc/types';
 import type { JobNotice } from '../proc/notices.js';
 import { type ToolGate } from './tool-gate.js';
 import { type ToolHookRunner } from '../exec/hooks/tool-wrapper.js';

package/dist/tools/index.js

@@ -9,7 +9,7 @@
  * before the tool runs.
  */
 import { errorResult, evaluateToolCall, } from '@aragon-agent/core';
-import { planRefusal, submitPlanRefusal } from '../agent/agent-mode.js';
+import { planRefusal, submitPlanRefusal } from '@aragon-agent/tui/model/agent/agent-mode';
 import { withGovernanceGate } from '../governance/tools/guard.js';
 import { makeReadFile, makeWriteFile, makeEditFile, makeListDir } from './fs-tools.js';
 import { makeGlob, makeGrep } from './search-tools.js';

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

@@ -17,15 +17,15 @@
  */
 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 { JobKind, ProcSupervisorPort, ServiceStatus } from '@aragon-agent/tui/model/proc/types';
+import { type WakeSource } from '../proc/wait.js';
+import { type WaitListener } from '@aragon-agent/tui/model/proc/wait-view';
 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

@@ -16,11 +16,13 @@
  * reason the feature exists.
  */
 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 { formatDuration } from '@aragon-agent/tui/model/agent/usage';
+import { PROC_LIMITS } from '@aragon-agent/tui/model/proc/limits';
 import { renderJobNotices } from '../proc/notices.js';
-import { isTerminalStatus } from '../proc/types.js';
+import { isTerminalStatus } from '@aragon-agent/tui/model/proc/types';
 import { waitForJob } from '../proc/wait.js';
+import { extractEtaText, parseEtaSeconds, suggestWaitSeconds } from '../proc/wait-plan.js';
+import { buildWaitView } from '@aragon-agent/tui/model/proc/wait-view';
 /**
  * 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/tools/plan-tools.d.ts

@@ -17,7 +17,7 @@
  * selected by whether an optional install step succeeded.
  */
 import { type AgentTool } from '@aragon-agent/core';
-import { type HumanInputGate, type NormalizedPlan, type NormalizedQuestion } from './human-input.js';
+import { type HumanInputGate, type NormalizedPlan, type NormalizedQuestion } from '@aragon-agent/tui/model/tools/human-input';
 export interface PlanToolsOptions {
     gate: HumanInputGate;
     /**

package/dist/tools/plan-tools.js

@@ -17,7 +17,7 @@
  * selected by whether an optional install step succeeded.
  */
 import { errorResult, textResult } from '@aragon-agent/core';
-import { formatAnswersResult, normalizePlan, normalizeQuestions, } from './human-input.js';
+import { formatAnswersResult, normalizePlan, normalizeQuestions, } from '@aragon-agent/tui/model/tools/human-input';
 // ---------------------------------------------------------------------------
 // Shared refusal text
 // ---------------------------------------------------------------------------

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

@@ -17,7 +17,7 @@
  * command is still arbitrary.
  */
 import { type AgentTool } from '@aragon-agent/core';
-import { type ProcSupervisorPort } from '../proc/types.js';
+import { type ProcSupervisorPort } from '@aragon-agent/tui/model/proc/types';
 export interface ProcToolDeps {
     supervisor: ProcSupervisorPort;
 }

package/dist/tools/proc-tools.js

@@ -17,8 +17,8 @@
  * command is still arbitrary.
  */
 import { defineTool, errorResult, textResult } from '@aragon-agent/core';
-import { PROC_LIMITS } from '../proc/limits.js';
-import { isTerminalStatus } from '../proc/types.js';
+import { PROC_LIMITS } from '@aragon-agent/tui/model/proc/limits';
+import { isTerminalStatus } from '@aragon-agent/tui/model/proc/types';
 /**
  * One line of status, shared by both tools so the two can never disagree.
  *

package/dist/update/classify-failure.d.ts

@@ -15,7 +15,7 @@
  * advice hits the same held handle and fails identically, so the single visible
  * failure is also a wrong instruction.
  */
-import type { UpdateReason } from './types.js';
+import type { UpdateReason } from '@aragon-agent/tui/model/update/types';
 /**
  * Classify an install failure from the bounded stderr tail `runNpmInstall`
  * already returns.

package/dist/update/install-lock.js

@@ -24,7 +24,7 @@ import { hostname } from 'node:os';
 import process from 'node:process';
 import { getUpdateLockPath } from '../config/app-paths.js';
 import { LOCK_UNREADABLE_CONFIRMATIONS } from '../skills/lock.js';
-import { UPDATE_LIMITS } from './limits.js';
+import { UPDATE_LIMITS } from '@aragon-agent/tui/model/update/limits';
 /**
  * `ESRCH` means gone. `EPERM` means the process EXISTS but belongs to another
  * user - treating that as dead would let one user steal another's lock, so it

package/dist/update/install-source.d.ts

@@ -12,7 +12,7 @@
  * service auto-installs for exactly one classification and degrades everything
  * else to a one-line notice carrying the correct command for THAT manager.
  */
-import type { InstallSource } from './types.js';
+import type { InstallSource } from '@aragon-agent/tui/model/update/types';
 /** The package this CLI publishes as. Read from the manifest, never hardcoded
  *  into the registry URL, so a fork keeps working (U-1). */
 export interface SelfManifest {

package/dist/update/installer.js

@@ -35,9 +35,9 @@ import { closeSync, existsSync, openSync, readFileSync, rmSync, statSync } from
 import { dirname, resolve } from 'node:path';
 import process from 'node:process';
 import { getUpdateInstallLogPath } from '../config/app-paths.js';
-import { UPDATE_LIMITS } from './limits.js';
+import { UPDATE_LIMITS } from '@aragon-agent/tui/model/update/limits';
 import { readSelfManifest } from './install-source.js';
-import { STRICT_VERSION_RE } from './semver.js';
+import { STRICT_VERSION_RE } from '@aragon-agent/tui/model/update/semver';
 /**
  * Where npm's JS entry point lives, or `null`.
  *

package/dist/update/npm-view.d.ts

@@ -22,7 +22,7 @@
  * written nothing, a killed `npm install -g` has left a broken global install.
  */
 import { type ExecFileOptions } from 'node:child_process';
-import type { LatestManifest } from './types.js';
+import type { LatestManifest } from '@aragon-agent/tui/model/update/types';
 /** The `execFile` shape this module needs. Injectable so no test spawns npm. */
 export type ExecFileImpl = (file: string, args: string[], options: ExecFileOptions, callback: (error: Error | null, stdout: string, stderr: string) => void) => unknown;
 export interface NpmViewDeps {

package/dist/update/npm-view.js

@@ -24,7 +24,7 @@
 import { execFile } from 'node:child_process';
 import process from 'node:process';
 import { cleanInstallEnv, resolveNpmCli } from './installer.js';
-import { UPDATE_LIMITS } from './limits.js';
+import { UPDATE_LIMITS } from '@aragon-agent/tui/model/update/limits';
 /**
  * The argv this probe is allowed to build. Exported for AC-47's assertion, on
  * the `buildInstallArgs` precedent.

package/dist/update/registry.d.ts

@@ -14,7 +14,7 @@
  * registry users point `update.registry` at a mirror they can read anonymously,
  * or set `update.mode: off`.
  */
-import type { LatestManifest } from './types.js';
+import type { LatestManifest } from '@aragon-agent/tui/model/update/types';
 export declare const DEFAULT_REGISTRY = "https://registry.npmjs.org";
 export interface RegistryDeps {
     fetchImpl?: typeof fetch;

package/dist/update/registry.js

@@ -15,7 +15,7 @@
  * or set `update.mode: off`.
  */
 import process from 'node:process';
-import { UPDATE_LIMITS } from './limits.js';
+import { UPDATE_LIMITS } from '@aragon-agent/tui/model/update/limits';
 export const DEFAULT_REGISTRY = 'https://registry.npmjs.org';
 /**
  * `config.update.registry` -> `ARAGON_UPDATE_REGISTRY` -> `npm_config_registry`