@aragon-agent/cli 0.6.46 → 0.6.48

package/CHANGELOG.md

@@ -7,7 +7,35 @@ were written.
 
 ## Unreleased
 
+### Changed
+- **Internal: the terminal interface moved to its own package, `@aragon-agent/tui`.** The Ink
+  components, terminal input handling, the scrollback renderer and the view model that `aragon`
+  draws from are no longer part of this package's source; they are published as
+  `@aragon-agent/tui`, which this package depends on at an exact version. **Nothing you can see or
+  type changed**: no command, flag, key, config key, file format, colour or layout differs, and
+  `aragon info` / `aragon doctor` print the same fields. Installing `@aragon-agent/cli` installs the
+  new package for you; `npx @aragon-agent/cli` and the self-updater need no change. One new
+  runtime download (`@aragon-agent/tui`) accompanies this release, and the three packages
+  (`core`, `tui`, `cli`) are now released together, in that order. If you import this package's
+  internals (they were never a supported API), imports of the moved modules must now name
+  `@aragon-agent/tui/<subpath>` instead.
+
 ### Added
+- **Long waits: `job_wait` now waits up to 20 minutes, and the wait looks like it.**
+  `timeoutSeconds` takes any integer from 5 to 1200 (it used to stop at 60, and at 150 with the
+  default `toolTimeoutMs`, because the tool ceiling silently pulled it down). `job_wait` gets its own
+  executor ceiling (1230 s) and pauses the idle watchdog for the whole wait, so `toolTimeoutMs` no
+  longer limits it and `jobs.waitSeconds` accepts 5-1200. **Typing a message ends the wait at once**
+  (result line `[woke] ...`, the job keeps running, no `Esc` needed); reviewer notes and completion
+  notices do not. While waiting, the tool card is replaced by a fixed five-row card - a progress bar
+  (the job's own progress when it prints any, otherwise the wait window), both clocks, the job's
+  newest output with "N s ago", a calm "not a failure" note after `jobs.stallSeconds` of silence, and
+  a hint that a message ends the wait - and the status bar reads `Waiting on t3 4m12s/10m00s`. New:
+  `job: "any"` (return on the first job to end), a `[next]` suggestion with a `timeoutSeconds` (and the
+  job's ETA) so the model prefers one long wait to many short ones, and `[note]` when a request is
+  clamped to the ceiling. No new config keys; `jobs.enabled=false` is byte-identical to before.
+  Honest limit: while a wait runs the idle check is off, so a stuck wait is ended by its own 20-minute
+  bound, the executor backstop, or you.
 - **Governance mode - a multi-agent "legion" collaboration posture.** `Shift+Tab` (and `Ctrl+N`)
   now cycle `BUILD -> PLAN -> GOVERN -> PLAN+GOVERN -> BUILD`; `/gov` goes to any of them
   directly. In `GOVERN` the main agent becomes an **Orchestrator** that cannot write files or run

package/README.md

@@ -57,10 +57,15 @@ aragon
 npx @aragon-agent/cli
 ```
 
-> **Release note (R3):** `npx @aragon-agent/cli` resolves `@aragon-agent/core`
-> from the npm registry, so `@aragon-agent/core@^0.1.0` must be published first
-> (or bundled into the CLI `dist`). During local development inside this
-> monorepo, npm workspaces link the local `packages/core` automatically.
+> **Release note (R3):** `npx @aragon-agent/cli` resolves `@aragon-agent/core` and
+> `@aragon-agent/tui` from the npm registry, so both must be published first (the
+> release script publishes `core`, then `tui`, then `cli`). During local development
+> inside this monorepo, npm workspaces link the local `packages/core` and
+> `packages/tui` automatically.
+
+The terminal interface itself lives in its own package,
+[`@aragon-agent/tui`](../tui), which this package depends on at an **exact**
+version; you never install it by hand. Installing `@aragon-agent/cli` installs all three.
 
 ## Quick start
 
@@ -2068,13 +2073,60 @@ longer reads "not ready yet, still coming up" for its first minute.
 Two tools manage them:
 
 - `job_wait({ job, timeoutSeconds?, since? })` — block up to a bound (default 30s,
-  at most 60s) and return one status line, one progress line, at most six new
-  output rows and a cursor. It returns immediately if the job already finished.
-  This is the point of the feature: waiting 30 seconds used to cost six
-  `bash_output` calls, six model turns and six 200-row tails; it now costs one
-  call and about 150 tokens.
+  **at most 20 minutes**: `timeoutSeconds` takes any integer from 5 to 1200) and
+  return one status line, one progress line, at most six new output rows and a
+  cursor. It returns immediately if the job already finished, and it also ends
+  the moment **you send a message** (see below). `job` is an id, `"all"` (until
+  every live job ends) or `"any"` (until the first one ends). This is the point
+  of the feature: waiting 30 seconds used to cost six `bash_output` calls, six
+  model turns and six 200-row tails; it now costs one call and about 150 tokens,
+  and a 40-minute training run costs a handful of calls instead of dozens.
 - `job_list()` — one line per job: id, kind, status, elapsed, progress.
 
+### Long waits
+
+A wait can now last up to 20 minutes, so three things keep it safe and visible:
+
+- **You can always interrupt it by typing.** Send a message while the agent is
+  waiting and the wait ends at once; the result says `[woke] you sent a message...`,
+  your message is delivered next, and the job keeps running. You do not need
+  `Esc`, which would stop the whole run. (Automatic notes, such as a reviewer's
+  or a completion notice, do not end a wait. If the agent had queued more tool
+  calls in the same step, the engine skips them when your message arrives, as it
+  does for any message sent mid-step.)
+- **The wait is drawn as a five-row card** instead of a bare "running":
+
+  ```
+  ⠹ Waiting for t3  python train.py --epochs 10                 4m12s of 10m00s
+    │ ████████░░░░░░░░░░░░░░░░░░░░  30%  epoch 3/10  ETA 13m
+    │ job running 42m04s · this wait ends in 5m48s, or sooner if the job finishes
+    │ step 912/1000  loss 0.4098                                           3s ago
+    │ Send a message to end the wait early · Esc x2 stops the whole run
+  ```
+
+  The bar shows the job's own progress when it prints any, and otherwise the
+  wait window itself (the words say which). After `jobs.stallSeconds` of silence
+  the output row becomes a calm
+  `quiet for 6m02s - the job is still alive; this is not a failure`. The status
+  bar and activity line carry the same clock (`Waiting on t3 4m12s/10m00s`).
+  The card is always five rows, uses ASCII glyphs on terminals without Unicode,
+  and keeps its numbers moving under reduced motion. It disappears when the wait
+  ends and leaves the usual one-line history row.
+- **The idle watchdog is paused for the length of the wait**, and `toolTimeoutMs`
+  no longer limits it: `job_wait` gets its own executor ceiling (20 minutes plus
+  30 seconds). The honest cost is that a wait which is itself stuck is only
+  caught by that ceiling and by you (`Esc x2`), not by the 3.5-minute idle check.
+
+Results suggest the next wait: when the job reports an ETA or has been running for
+a while, the `[next]` line carries a `timeoutSeconds` worth using (for example
+`timeoutSeconds: 900 ... (ETA about 13m)`) so the agent prefers one long wait to
+many short ones. It is advice, never enforced. A request over 1200 seconds is
+clamped and says so (`[note] timeoutSeconds 3600 exceeds the 1200s ceiling`).
+
+Cost note: a wait longer than your provider's prompt-cache lifetime (often five
+minutes) means the next request re-reads the context uncached. That is still far
+cheaper than the dozens of model turns short polling would have spent.
+
 Nothing else tells the model a job finished. When one ends while it is busy, a
 `<job_notices>` block appears at the end of the next tool result:
 
@@ -2114,7 +2166,7 @@ to use it — `grep` and `read_file` already exist.
 | Key | Default | Meaning |
 |---|---|---|
 | `jobs.enabled` | `true` | Register `job_wait`/`job_list`, splice the prompt block. `false` restores the pre-feature build byte for byte. |
-| `jobs.waitSeconds` | `30` | Default bound for one wait, 5–60. Also lowered automatically so a wait always fits inside the tool ceiling. |
+| `jobs.waitSeconds` | `30` | Default bound for one wait, 5–1200. No longer lowered by `toolTimeoutMs`. |
 | `jobs.stallSeconds` | `300` | Silence before `[stalled]`, 30–3600. |
 | `jobs.persistLog` | `true` | Mirror each job's output to disk. `false` creates no directory at all. |
 | `jobs.noticeSteer` | `true` | Whether a completion notice may interrupt a running turn. `false` keeps the notice for the next tool result or the next user turn — it is **not** a notification off switch. |
@@ -3686,11 +3738,27 @@ merge. Raise both `--tool-timeout` / `--idle-timeout` for genuinely long jobs.
 ## Development
 
 ```bash
-npm run build -w packages/cli   # tsc + shebang → dist/cli.js
-npm test    -w packages/cli     # vitest
+npm run build -w packages/cli   # tsc + shebang → dist/cli.js (builds core and tui first via the root: npm run build)
+npm test    -w packages/cli     # vitest (rebuilds a stale core / tui first)
 node packages/cli/dist/cli.js --version
 ```
 
+### Project structure
+
+This package is the session container and the executable; the terminal runtime is
+[`@aragon-agent/tui`](../tui).
+
+| Here (`packages/cli/src`) | In `@aragon-agent/tui` |
+| --- | --- |
+| `cli.tsx`, `launcher.ts`, `boot/` — the `aragon` binary and its boot guard | `ui/` — Ink components, layout, scrollback, selection, frame differ, overlays, theme |
+| `app/` — `App.tsx`, the startup notices hook and the session bridge: the one place that wires a live agent to the screen | `input/` — stdin filter, keyboard / mouse / paste protocols |
+| `agent/` (controller, headless), `commands/`, `config/` (load / store), `session/`, `skills/`, `team/`, `governance/engine`, `exec/`, `tools/`, `update/`, `logging/` | `model/` — the view model (`Entry`, `ViewState`, the reducer) and the pure helpers it draws on (`config/schema`, `todo/`, `team/` row models, `tools/patch`, `update/semver`, ...) |
+
+Some directory names exist in both (`team/`, `todo/`, `config/`): the CLI side is the runtime,
+the TUI side (`model/<dir>`) is its representation on screen. A CLI module imports a TUI one
+as `@aragon-agent/tui/<subpath>` — no file extension, never a relative path. Rules and the
+checks that enforce them: `CLAUDE.md` ("Package layering") and `npm run verify:layering`.
+
 ### Manual smoke checklist
 
 - `npm run build -w packages/cli` produces an executable `dist/cli.js` with a

package/dist/agent/coalesce.d.ts

@@ -16,12 +16,16 @@
  * concatenating, and a differing id starts a new pending action because merging
  * across ids would paint one command's output onto another's card.
  *
+ * A FOURTH ARRIVED WITH THE LONG WAIT (extended-job-wait RV-6): `waitUpdate`
+ * carries the WHOLE view, so it merges exactly like the tool tail - same
+ * `toolCallId` keeps the last, a different id or any other action flushes first.
+ *
  * ONE PENDING SLOT, DISCRIMINATED, NEVER TWO (P1-5). A second, independent slot
  * for the object-shaped payload would let a chunk overtake a token and reorder
  * the two streams — exactly what I-L4-1 (`ui/render-governor.ts:14-19`) forbids:
  * "the governor changes only HOW OFTEN the view updates. Never what is
  * dispatched, never the order."
  */
-import type { ViewAction } from './reducer.js';
+import type { ViewAction } from '@aragon-agent/tui/model/agent/reducer';
 /** Merge consecutive same-kind deltas; flush on kind change or a non-delta. */
 export declare function mergeDeltas(actions: ViewAction[]): ViewAction[];

package/dist/agent/coalesce.js

@@ -16,6 +16,10 @@
  * concatenating, and a differing id starts a new pending action because merging
  * across ids would paint one command's output onto another's card.
  *
+ * A FOURTH ARRIVED WITH THE LONG WAIT (extended-job-wait RV-6): `waitUpdate`
+ * carries the WHOLE view, so it merges exactly like the tool tail - same
+ * `toolCallId` keeps the last, a different id or any other action flushes first.
+ *
  * ONE PENDING SLOT, DISCRIMINATED, NEVER TWO (P1-5). A second, independent slot
  * for the object-shaped payload would let a chunk overtake a token and reorder
  * the two streams — exactly what I-L4-1 (`ui/render-governor.ts:14-19`) forbids:
@@ -28,6 +32,9 @@ function isTextDelta(action) {
 function isToolOutputDelta(action) {
     return action.type === 'toolOutputDelta';
 }
+function isWaitUpdate(action) {
+    return action.type === 'waitUpdate';
+}
 /** Merge consecutive same-kind deltas; flush on kind change or a non-delta. */
 export function mergeDeltas(actions) {
     const out = [];
@@ -70,6 +77,12 @@ export function mergeDeltas(actions) {
             // increment, so merging means replacing (D-30).
             pending = { kind: 'tool', action };
         }
+        else if (isWaitUpdate(action)) {
+            const merges = prev !== null && prev.kind === 'wait' && prev.action.toolCallId === action.toolCallId;
+            if (!merges)
+                flush();
+            pending = { kind: 'wait', action };
+        }
         else {
             flush();
             out.push(action);

package/dist/agent/controller.d.ts

@@ -1,6 +1,6 @@
 import { type ModelSettingsSnapshot } from './model-profile-settings.js';
-import { type ActiveKit } from '../config/kit-resolution.js';
-import type { KitApplyResult } from '../config/model-kits.js';
+import { type ActiveKit } from '@aragon-agent/tui/model/config/kit-resolution';
+import type { KitApplyResult } from '@aragon-agent/tui/model/config/model-kits';
 import type { ModelSettingsDraft, ModelSettingsPatch, ModelSettingsSaveResult } from '../config/model-profile-store.js';
 import { type CompactionIdentity } from '../compaction/memory-identity.js';
 /**
@@ -15,38 +15,39 @@ import { type CompactionIdentity } from '../compaction/memory-identity.js';
  */
 import type { PromptOptions, PromptOutcome } from './prompt-options.js';
 import { ModelRegistry, type AgentEvent, type AgentTool, type Message, type ModelInfo, type ModelRef, type ProviderRegistry, type ThinkingLevel } from '@aragon-agent/core';
-import type { CliConfig, CompactionConfig, FastConfig, RetryConfig, TeamConfig, ThemeName, TodoConfig } from '../config/schema.js';
-import type { ModelRole } from '../config/model-profiles.js';
+import type { CliConfig, CompactionConfig, FastConfig, RetryConfig, TeamConfig, ThemeName, TodoConfig } from '@aragon-agent/tui/model/config/schema';
+import type { ModelRole } from '@aragon-agent/tui/model/config/model-profiles';
 import { ModelWindows } from '../config/model-windows.js';
 import { type ConfirmRequest } from '../tools/index.js';
 import type { ToolGate } from '../tools/tool-gate.js';
 import type { ToolHookRunner } from '../exec/hooks/tool-wrapper.js';
 import type { ToolPermission } from '../exec/permission.js';
-import { type ToolOutputListener } from '../tools/tool-output-store.js';
-import type { FilePatch } from '../tools/patch.js';
-import type { SubagentModelResolution } from '../team/model.js';
+import { type ToolOutputListener } from '@aragon-agent/tui/model/tools/tool-output-store';
+import type { FilePatch } from '@aragon-agent/tui/model/tools/patch';
+import type { SubagentModelResolution } from '@aragon-agent/tui/model/team/model';
 import type { ForcedTeamState } from '../team/forced-mode.js';
-import type { TeamEvent, TeamSnapshot } from '../team/types.js';
+import type { TeamEvent, TeamSnapshot } from '@aragon-agent/tui/model/team/types';
 import { ProcSupervisor } from '../proc/supervisor.js';
-import type { ProcEventListener, ServiceSnapshot } from '../proc/types.js';
+import type { WaitEvent } from '@aragon-agent/tui/model/proc/wait-view';
+import type { ProcEventListener, ServiceSnapshot } from '@aragon-agent/tui/model/proc/types';
 import { type FastStatus } from '../fast/wiring.js';
-import type { FastEventListener, FastSnapshot } from '../fast/types.js';
-import type { TaskSummaryOutcome } from '../fast/task-summary-types.js';
-import { ContextMeter, type ContextUsageListener } from '../compaction/meter.js';
-import type { CompactionEventListener, CompactionSnapshot, ContextUsageSnapshot } from '../compaction/types.js';
-import type { AcceptanceItem, TodoEventListener, TodoSnapshot } from '../todo/types.js';
+import type { FastEventListener, FastSnapshot } from '@aragon-agent/tui/model/fast/types';
+import type { TaskSummaryOutcome } from '@aragon-agent/tui/model/fast/task-summary-types';
+import { ContextMeter, type ContextUsageListener } from '@aragon-agent/tui/model/compaction/meter';
+import type { CompactionEventListener, CompactionSnapshot, ContextUsageSnapshot } from '@aragon-agent/tui/model/compaction/types';
+import type { AcceptanceItem, TodoEventListener, TodoSnapshot } from '@aragon-agent/tui/model/todo/types';
 import { GovernanceWiring } from './governance-wiring.js';
-import { type GovernanceConfig } from '../config/governance-config.js';
-import { type Posture } from '../governance/posture.js';
+import { type GovernanceConfig } from '@aragon-agent/tui/model/config/governance-config';
+import { type Posture } from '@aragon-agent/tui/model/governance/posture';
 import type { GovernanceAvailability } from '../governance/copy.js';
 import type { PauseOutcome } from '../governance/engine/pause.js';
-import type { GovernanceEventListener, GovernanceSnapshot } from '../governance/types.js';
-import { type HumanInputGate } from '../tools/human-input.js';
+import type { GovernanceEventListener, GovernanceSnapshot } from '@aragon-agent/tui/model/governance/types';
+import { type HumanInputGate } from '@aragon-agent/tui/model/tools/human-input';
 import { SkillService, type ApprovalGate } from '../skills/service.js';
 import type { SkillRoutingReport } from '../skills/triage.js';
 import { type ConversationResetOptions, type ConversationResetResult } from './conversation-reset.js';
-import type { AgentMode } from './agent-mode.js';
-import type { NoticeLevel } from './reducer.js';
+import type { AgentMode } from '@aragon-agent/tui/model/agent/agent-mode';
+import type { NoticeLevel } from '@aragon-agent/tui/model/agent/reducer';
 /** Approval gate used whenever there is provably no human to ask (headless). */
 export declare const DENY_ALL_APPROVAL: ApprovalGate;
 export interface ControllerDeps {
@@ -350,6 +351,10 @@ export declare class AgentController {
      */
     private readonly toolOutputs;
     private readonly outputListeners;
+    /** `job_wait` live-view listeners (extended-job-wait); see `subscribeWait`. */
+    private readonly waitListeners;
+    /** "The user just spoke": ends a running `job_wait` early. */
+    private readonly userAttention;
     private readonly fast;
     private readonly compaction;
     private settingsRevision;
@@ -768,6 +773,12 @@ export declare class AgentController {
      * rather than a counter, so a nested call's `finally` re-arms the watchdog
      * while the outer wait is still going. That is why a child's `--confirm`
      * dialog does NOT route through this (see the constructor's `humanQueue`).
+     *
+     * `job_wait` ALSO DEPENDS ON THAT (extended-job-wait I-3): it holds the pause for
+     * up to 20 minutes and is safe only because the engine runs a batch's tools
+     * one at a time. If tool execution ever becomes parallel, make this a COUNTER
+     * first - otherwise the first tool to finish re-arms the watchdog under a
+     * still-waiting sibling, which then kills the run at the idle timeout.
      */
     withPausedWatchdog<T>(fn: () => Promise<T>): Promise<T>;
     /** @see withPausedWatchdog — the name the plan tools and `--confirm` use. */
@@ -1026,6 +1037,16 @@ export declare class AgentController {
      * `warn` because a listener that throws once throws on every chunk.
      */
     private emitToolOutput;
+    /**
+     * Subscribe to `job_wait`'s live view (`begin` / 1 Hz `update` / `end`).
+     *
+     * NOT GATED ON `liveToolOutput` (extended-job-wait D-9): that switch bounds a
+     * high-frequency byte stream; this channel is capped at 1 Hz, and switching it
+     * off would bring back the 20-minute black box.
+     */
+    subscribeWait(listener: (event: WaitEvent) => void): () => void;
+    /** Fan out one wait event; a throwing listener is logged and skipped (I-6). */
+    private emitWait;
     /**
      * Subscribe to the CLI-local live tool-output stream (§3.1.3).
      *

package/dist/agent/controller.js

@@ -1,25 +1,25 @@
 import { createModelSettingsDraft, previewModelSettings, saveModelSettings, reloadModelSettings, } from './model-profile-settings.js';
 import { applySessionKit as applySessionKitPort, clearSessionKit as clearSessionKitPort } from './kit-apply.js';
-import { resolveActiveKit } from '../config/kit-resolution.js';
+import { resolveActiveKit } from '@aragon-agent/tui/model/config/kit-resolution';
 import { randomUUID } from 'node:crypto';
 import { join } from 'node:path';
 import { verifyCompactionIdentity } from '../compaction/memory-identity.js';
-import { COMPACTION_LIMITS } from '../compaction/limits.js';
+import { COMPACTION_LIMITS } from '@aragon-agent/tui/model/compaction/limits';
 import { Agent, initProviders, ModelRegistry, } from '@aragon-agent/core';
-import { clampCompactionConfig, clampFastConfig, clampRetryConfig, clampTeamConfig, clampTodoConfig, isAdapterProvider, toRetryPolicy, } from '../config/schema.js';
-import { resolveModelProfileState } from '../config/model-profile-resolution.js';
+import { clampCompactionConfig, clampFastConfig, clampRetryConfig, clampTeamConfig, clampTodoConfig, isAdapterProvider, toRetryPolicy, } from '@aragon-agent/tui/model/config/schema';
+import { resolveModelProfileState } from '@aragon-agent/tui/model/config/model-profile-resolution';
 import { makeGetApiKey } from '../config/load.js';
 import { updatePersistedConfig } from '../config/store.js';
 import { ModelWindows } from '../config/model-windows.js';
 import { createBuiltinTools, gatedToolTimeouts, } from '../tools/index.js';
 import { createFileChangeStore } from '../tools/file-change-store.js';
-import { createToolOutputStore, } from '../tools/tool-output-store.js';
+import { createToolOutputStore, } from '@aragon-agent/tui/model/tools/tool-output-store';
 import { TeamRuntime } from '../team/runtime.js';
 import { createChildReviewer } from '../team/child-reviewer.js';
 import { TeamHumanQueue } from '../team/human-queue.js';
 import { createFastOverseerProvider } from '../team/overseer.js';
 import { createTaskTool } from '../team/task-tool.js';
-import { resolveSubagentModel } from '../team/model.js';
+import { resolveSubagentModel } from '@aragon-agent/tui/model/team/model';
 import { buildTeamBlock } from '../team/prompt.js';
 // THE THIRD LAYER's prompt half (team-command-forced-dispatch §3.6): spliced
 // after `<team_mode>` and before the subagent block, only while armed.
@@ -27,7 +27,8 @@ import { buildForcedTeamBlock } from '../team/forced-prompt.js';
 import { buildFastBlock } from '../fast/prompt.js';
 import { ProcSupervisor } from '../proc/supervisor.js';
 import { buildBackgroundJobsBlock, buildBackgroundServicesBlock } from '../proc/prompt.js';
-import { PROC_LIMITS } from '../proc/limits.js';
+import { JOB_WAIT_TOOL_CEILING_MS, PROC_LIMITS } from '@aragon-agent/tui/model/proc/limits';
+import { createUserAttention } from './user-attention.js';
 import { JobLogMirror } from '../proc/log-mirror.js';
 import { JobNoticeQueue } from '../proc/notices.js';
 import { makeBashKill, makeBashOutput } from '../tools/proc-tools.js';
@@ -35,7 +36,7 @@ import { makeJobList, makeJobWait } from '../tools/job-tools.js';
 import { JobNoticeRelay } from './job-notices.js';
 import { getHomeRoot } from '../config/app-paths.js';
 import { addSignalHook } from '../logging/install.js';
-import { describeFastTierProblem, fastProviderOf, resolveFastTier } from '../fast/resolve.js';
+import { describeFastTierProblem, fastProviderOf, resolveFastTier } from '@aragon-agent/tui/model/fast/resolve';
 import { FastWiring, offFastStatus } from '../fast/wiring.js';
 // ONE-SHOT FAST CALLS (tui-shortcut-drawer-and-task-summary §6.1). The TYPES come
 // from `fast/task-summary-types.ts` and only `fast/` produces them, so this module
@@ -43,18 +44,18 @@ import { FastWiring, offFastStatus } from '../fast/wiring.js';
 // is the pair `runTaskSummaryCall` is forbidden to own (see its header).
 import { createTaskSummaryDeps, runTaskSummaryCall } from '../fast/summary-call.js';
 import { CompactionWiring, offCompactionSnapshot } from '../compaction/wiring.js';
-import { ContextMeter } from '../compaction/meter.js';
+import { ContextMeter } from '@aragon-agent/tui/model/compaction/meter';
 import { TodoStore } from '../todo/store.js';
 import { createTodoTool } from '../todo/todo-tool.js';
 import { buildTodoBlock } from '../todo/prompt.js';
 import { createPlanTools } from '../tools/plan-tools.js';
 import { GovernanceWiring } from './governance-wiring.js';
-import { clampGovernanceConfig } from '../config/governance-config.js';
+import { clampGovernanceConfig } from '@aragon-agent/tui/model/config/governance-config';
 import { decidePostureTransition } from '../governance/posture-transition.js';
-import { composePosture, splitPosture } from '../governance/posture.js';
+import { composePosture, splitPosture } from '@aragon-agent/tui/model/governance/posture';
 import { APPROVED_GOVERN_RESULT } from '../governance/prompts/refusals.js';
-import { GOV_LEAD_TOOL_NAMES } from '../governance/limits.js';
-import { ASK_GUARD_LIMITS, DENY_ALL_HUMAN_INPUT, questionFingerprint, } from '../tools/human-input.js';
+import { GOV_LEAD_TOOL_NAMES } from '@aragon-agent/tui/model/governance/limits';
+import { ASK_GUARD_LIMITS, DENY_ALL_HUMAN_INPUT, questionFingerprint, } from '@aragon-agent/tui/model/tools/human-input';
 import { getLogger } from '../logging/logger.js';
 import { createNodeSkillHost } from '../skills/node-host.js';
 import { SkillService } from '../skills/service.js';
@@ -261,6 +262,10 @@ export class AgentController {
      */
     toolOutputs;
     outputListeners = new Set();
+    /** `job_wait` live-view listeners (extended-job-wait); see `subscribeWait`. */
+    waitListeners = new Set();
+    /** "The user just spoke": ends a running `job_wait` early. */
+    userAttention = createUserAttention();
     // -----------------------------------------------------------------------
     // Fast model tier (fast-model-tier §3.1 / §3.3)
     //
@@ -735,15 +740,19 @@ export class AgentController {
                         supervisor: this.procs,
                         waitSeconds: () => this.config.jobs.waitSeconds,
                         stallSeconds: () => this.config.jobs.stallSeconds,
-                        toolTimeoutMs: () => this.config.toolTimeoutMs,
                         maxConsecutiveWaits: PROC_LIMITS.maxConsecutiveWaits,
                         terminalRecord: (id) => this.jobRelay?.terminalRecord(id),
+                        // THE THREE LONG-WAIT PORTS (extended-job-wait). `holdWatchdog` wraps the
+                        // WHOLE wait because tools run one at a time (I-3); `attention` is
+                        // subscribe-only (RV-1); the view listener never throws back (I-6).
+                        onWait: (event) => this.emitWait(event),
+                        holdWatchdog: (fn) => this.withPausedWatchdog(fn),
+                        attention: { subscribe: (listener) => this.userAttention.subscribe(listener) },
                     }),
                     makeJobList({
                         supervisor: this.procs,
                         waitSeconds: () => this.config.jobs.waitSeconds,
                         stallSeconds: () => this.config.jobs.stallSeconds,
-                        toolTimeoutMs: () => this.config.toolTimeoutMs,
                         maxConsecutiveWaits: PROC_LIMITS.maxConsecutiveWaits,
                         terminalRecord: (id) => this.jobRelay?.terminalRecord(id),
                     }),
@@ -961,6 +970,13 @@ export class AgentController {
                     // outlived a mid-session `Settings > Team` switch to the supervisor
                     // and killed the dispatch the supervisor was meant to look after.
                     ...(this.teamRegistered ? { task: 0 } : {}),
+                    // THE EXECUTOR'S OWN CLOCK FOR A LONG WAIT (extended-job-wait I-2 / I-4').
+                    // Without it `job_wait` falls onto `toolTimeoutMs` (180 s) and a 20-minute
+                    // wait dies at three; with `0` the wait would have no independent backstop
+                    // while the watchdog is paused. A finite value derived from the one
+                    // authority, `PROC_LIMITS.waitMaxSeconds`, is both. `jobsRegistered` is
+                    // assigned in the constructor before this table is built.
+                    ...(this.jobsRegistered ? { job_wait: JOB_WAIT_TOOL_CEILING_MS } : {}),
                     // P0 (governance-mode D-21 / RV-0): `gov_dispatch` runs a whole governed stage,
                     // routinely longer than `toolTimeoutMs`, and it listens to `ctx.signal` (it hands
                     // it to `TeamRuntime.dispatch`), which is what makes `0` safe. Registered in the SAME
@@ -1587,6 +1603,10 @@ export class AgentController {
                 this.pendingUserSteering.delete(id);
             throw error;
         }
+        // AFTER a successful steer, and ONLY for user input (I-7): a reviewer or a job
+        // notice must not cut short the wait the user chose.
+        if (user)
+            this.userAttention.notify();
         return id;
     }
     followUp(text) {
@@ -1948,6 +1968,12 @@ export class AgentController {
      * rather than a counter, so a nested call's `finally` re-arms the watchdog
      * while the outer wait is still going. That is why a child's `--confirm`
      * dialog does NOT route through this (see the constructor's `humanQueue`).
+     *
+     * `job_wait` ALSO DEPENDS ON THAT (extended-job-wait I-3): it holds the pause for
+     * up to 20 minutes and is safe only because the engine runs a batch's tools
+     * one at a time. If tool execution ever becomes parallel, make this a COUNTER
+     * first - otherwise the first tool to finish re-arms the watchdog under a
+     * still-waiting sibling, which then kills the run at the idle timeout.
      */
     async withPausedWatchdog(fn) {
         this.agent.pauseIdleWatchdog();
@@ -2501,6 +2527,33 @@ export class AgentController {
             }
         }
     }
+    /**
+     * Subscribe to `job_wait`'s live view (`begin` / 1 Hz `update` / `end`).
+     *
+     * NOT GATED ON `liveToolOutput` (extended-job-wait D-9): that switch bounds a
+     * high-frequency byte stream; this channel is capped at 1 Hz, and switching it
+     * off would bring back the 20-minute black box.
+     */
+    subscribeWait(listener) {
+        this.waitListeners.add(listener);
+        return () => {
+            this.waitListeners.delete(listener);
+        };
+    }
+    /** Fan out one wait event; a throwing listener is logged and skipped (I-6). */
+    emitWait(event) {
+        for (const listener of this.waitListeners) {
+            try {
+                listener(event);
+            }
+            catch (err) {
+                getLogger().debug('tool', 'wait_listener_threw', {
+                    toolCallId: event.toolCallId,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            }
+        }
+    }
     /**
      * Subscribe to the CLI-local live tool-output stream (§3.1.3).
      *

package/dist/agent/conversation-reset.d.ts

@@ -22,7 +22,7 @@
  * more than the existing `abort()` would be the exact kind of misleading name
  * this feature exists to remove.
  */
-import type { Entry } from './reducer.js';
+import type { Entry } from '@aragon-agent/tui/model/agent/reducer';
 /** The minimal host surface a reset needs. Supplied by `AgentController` alone. */
 export interface ConversationResetPort {
     /** Whether a run is in flight right now. */

package/dist/agent/governance-wiring.d.ts

@@ -21,17 +21,17 @@
  *    `doctor` and the key cycle ask.
  */
 import type { AgentTool, ModelCost } from '@aragon-agent/core';
-import type { CliConfig } from '../config/schema.js';
+import type { CliConfig } from '@aragon-agent/tui/model/config/schema';
 import { type GovernanceAvailability } from '../governance/copy.js';
 import type { TeamRuntimeLike } from '../governance/engine/engine-core.js';
 import type { PauseOutcome } from '../governance/engine/pause.js';
-import { type Posture } from '../governance/posture.js';
+import { type Posture } from '@aragon-agent/tui/model/governance/posture';
 import { type RunReportResult } from '../governance/report-reader.js';
 import { type IndexEntry } from '../governance/store/run-store.js';
-import type { GovernanceEventListener, GovernanceSnapshot, LedgerState, RunState } from '../governance/types.js';
-import type { SubagentSpec } from '../team/types.js';
-import type { HumanInputGate, NormalizedPlan, NormalizedQuestion } from '../tools/human-input.js';
-import type { AgentMode } from './agent-mode.js';
+import type { GovernanceEventListener, GovernanceSnapshot, LedgerState, RunState } from '@aragon-agent/tui/model/governance/types';
+import type { SubagentSpec } from '@aragon-agent/tui/model/team/types';
+import type { HumanInputGate, NormalizedPlan, NormalizedQuestion } from '@aragon-agent/tui/model/tools/human-input';
+import type { AgentMode } from '@aragon-agent/tui/model/agent/agent-mode';
 export interface WiringDeps {
     /** `config.team.enabled` at construction: whether `task` (and a TeamRuntime) exist. */
     teamRegistered: boolean;

package/dist/agent/governance-wiring.js

@@ -21,14 +21,14 @@
  *    `doctor` and the key cycle ask.
  */
 import { join } from 'node:path';
-import { clampGovernanceConfig, isGovernanceEnvDisabled, } from '../config/governance-config.js';
+import { clampGovernanceConfig, isGovernanceEnvDisabled, } from '@aragon-agent/tui/model/config/governance-config';
 import { getGovernanceDir } from '../config/app-paths.js';
 import { RESTART_REQUIRED_TEXT, unavailableReasonText, } from '../governance/copy.js';
 import { createGovernanceEngine } from '../governance/engine/engine.js';
 import { estimateForRun } from '../governance/engine/estimate.js';
 import { formatDispatchEstimate } from '../governance/copy.js';
-import { GOV_CHILD_TOOL_NAMES, GOV_LEAD_TOOL_NAMES, GOV_LIMITS } from '../governance/limits.js';
-import { composePosture, isGovernancePosture, POSTURES_CLASSIC, POSTURES_FULL, } from '../governance/posture.js';
+import { GOV_CHILD_TOOL_NAMES, GOV_LEAD_TOOL_NAMES, GOV_LIMITS } from '@aragon-agent/tui/model/governance/limits';
+import { composePosture, isGovernancePosture, POSTURES_CLASSIC, POSTURES_FULL, } from '@aragon-agent/tui/model/governance/posture';
 import { buildPlanGovernAddendum } from '../governance/prompts/plan-addendum.js';
 import { buildOrchestratorBlock } from '../governance/prompts/orchestrator-block.js';
 import { PLAN_INTERVIEW_TOPICS, govAskRoundsRefusal } from '../governance/prompts/refusals.js';
@@ -39,7 +39,7 @@ import { RunStore } from '../governance/store/run-store.js';
 import { buildChildTools } from '../governance/tools/child-tools.js';
 import { applyInspectorToolPolicy, withGovernanceReadGuard } from '../governance/tools/guard.js';
 import { makeGovDispatchTool, makeGovRunTool } from '../governance/tools/lead-tools.js';
-import { TEAM_LIMITS } from '../team/limits.js';
+import { TEAM_LIMITS } from '@aragon-agent/tui/model/team/limits';
 /** Keyword probes that map an answered question onto the fixed interview topics. */
 const TOPIC_PROBES = [
     /goal|success|outcome|objective|criteria/i,

package/dist/agent/headless.d.ts

@@ -7,11 +7,11 @@
 import type { PromptOutcome } from './prompt-options.js';
 import type { AgentEvent, ModelInfo } from '@aragon-agent/core';
 import type { PreflightResult } from './controller.js';
-import type { TeamEvent } from '../team/types.js';
-import type { TodoEvent, TodoSnapshot } from '../todo/types.js';
-import type { FastEvent } from '../fast/types.js';
-import type { CompactionEvent } from '../compaction/types.js';
-import { type FollowThroughMode } from '../todo/follow-through.js';
+import type { TeamEvent } from '@aragon-agent/tui/model/team/types';
+import type { TodoEvent, TodoSnapshot } from '@aragon-agent/tui/model/todo/types';
+import type { FastEvent } from '@aragon-agent/tui/model/fast/types';
+import type { CompactionEvent } from '@aragon-agent/tui/model/compaction/types';
+import { type FollowThroughMode } from '@aragon-agent/tui/model/todo/follow-through';
 /** The minimal controller surface headless mode needs (real or stubbed). */
 export interface HeadlessController {
     preflight(): PreflightResult;

package/dist/agent/headless.js

@@ -4,11 +4,11 @@
  * derived from the event stream (R2), not from the resolved promise:
  *   0 = success, 1 = agent error (incl. a silently-swallowed throw), 2 = config.
  */
-import { formatCost, formatTokens, formatDuration, computeCost } from './usage.js';
-import { formatStreamError } from './reducer.js';
+import { formatCost, formatTokens, formatDuration, computeCost } from '@aragon-agent/tui/model/agent/usage';
+import { formatStreamError } from '@aragon-agent/tui/model/agent/reducer';
 import { runDurationMs } from '../team/report.js';
-import { derivePlanPhase } from '../todo/acceptance.js';
-import { advanceBudget, decideFollowThrough, emptyBudget, } from '../todo/follow-through.js';
+import { derivePlanPhase } from '@aragon-agent/tui/model/todo/acceptance';
+import { advanceBudget, decideFollowThrough, emptyBudget, } from '@aragon-agent/tui/model/todo/follow-through';
 /** Run a single prompt headlessly and resolve with the process exit code. */
 export async function runHeadless(controller, prompt, options = {}) {
     const out = options.stdout ?? process.stdout;

package/dist/agent/job-notices.d.ts

@@ -28,7 +28,7 @@
  * re-checks the same condition so a future call site cannot forget it (I-5).
  */
 import { type JobNotice, type JobNoticeQueue } from '../proc/notices.js';
-import { type JobKind, type ProcEvent, type ServiceStatus } from '../proc/types.js';
+import { type JobKind, type ProcEvent, type ServiceStatus } from '@aragon-agent/tui/model/proc/types';
 export interface JobNoticeRelayDeps {
     queue: JobNoticeQueue;
     /** `enqueueSteering(text, false)` - the existing receipt-less path (§4.6). */

package/dist/agent/job-notices.js

@@ -28,7 +28,7 @@
  * re-checks the same condition so a future call site cannot forget it (I-5).
  */
 import { renderJobNotices } from '../proc/notices.js';
-import { isTerminalStatus } from '../proc/types.js';
+import { isTerminalStatus } from '@aragon-agent/tui/model/proc/types';
 export class JobNoticeRelay {
     deps;
     /**