@aragon-agent/cli 0.6.4 → 0.6.8

package/CHANGELOG.md

@@ -9,6 +9,20 @@ were written.
 
 ### Added
 
+- **`system/init` now lists what this build can do.** A new optional
+  `capabilities: string[]` field, carrying `["interrupt"]` for this release.
+
+  A wrapper cannot tell by observation whether an interrupt will settle
+  gracefully or kill the process outright, and guessing wrong costs the user
+  their conversation. Rather than have callers compare version numbers — which
+  breaks on forks, prereleases, and version shapes nobody anticipated — the
+  build now says so itself, in an event that already arrives on every start.
+  Absent on older builds, and absence should be read as "no", never as
+  "probably".
+
+  Additive, so `schemaVersion` does not move. Consumers that do not know the
+  field ignore it, exactly as the schema contract asks.
+
 - **The composer understands pasting.** Until now it did not have the concept at
   all: every byte the terminal delivered on stdin was a keystroke, and a
   clipboard block is thousands of bytes arriving in an unpredictable number of
@@ -58,6 +72,29 @@ were written.
 
 ### Fixed
 
+- **`{"type":"interrupt"}` now really does settle the run — on every platform.**
+  The stdin interrupt frame used to raise a SIGINT at our own process. On POSIX
+  that reaches the runner's terminator and the run winds down properly: it
+  breaks out of the loop, persists the session, and emits `result` with the
+  usage and cost. On Windows, Node does not deliver a self-directed SIGINT to
+  its own handlers — the process simply terminated with exit code 1, having run
+  none of it.
+
+  For anyone using `aragon exec` interactively that difference was invisible,
+  because an interrupt there is usually the last thing that happens. It is not
+  invisible to a **wrapper** that interrupts a turn and then respawns on the same
+  `--session-id` to keep the conversation going: on Windows it silently got back
+  a session missing everything since the previous save. `exec/index.ts` has
+  carried a comment about that caller for some time ("PERSIST FIRST, ANNOUNCE
+  SECOND … a caller that reads `result` and immediately respawns with the same
+  `--session-id` must not race the writer"), so the intent was there; the path
+  just could not be reached on Windows.
+
+  The frame now calls the runner directly instead of going through a signal.
+  POSIX behaviour is byte-for-byte unchanged — the same code runs, with the same
+  `stopReason`, the same exit code 130, and the same two-second window in which a
+  second signal still forces an immediate exit.
+
 - **A pasted API key is stored correctly again.** Ink broadcasts each stdin chunk
   to every mounted input handler, so the settings screen, the question overlay
   and the plan-review feedback field all see what the composer sees. Without

package/README.md

@@ -413,6 +413,7 @@ signal ends the run (`130` SIGINT, `143` SIGTERM, `129` SIGHUP).
 | `/retry [show\|on\|off\|max <n>]` | API retry: the effective ladder, the on/off switch, the retry count. Takes effect **in the running session**, children included |
 | `/fast [on\|off\|model <id>\|provider <id>\|same\|review <n\|off>\|delegate on\|off]` | Fast model tier: status and this session's totals, the on/off switch, which model, the review cadence |
 | `/compact [status\|on\|off\|threshold <n>\|keep <n>\|history\|show <n>\|<instructions>]` | Context compaction: occupancy and this session's totals, the on/off switch, when it fires, how much it keeps. With free text, compacts now and tells the summarizer what to pay attention to |
+| `/context` | What the context gauge is showing: occupancy split into measured and estimated, the window and **where it came from**, how stale the measurement is, compaction's actual state, and what the session-spend readout includes |
 | `/bg [list\|logs <id> [n]\|stop <id\|all>\|status]` | Background services: what is running, its log tail, and how to stop it. `list` is the default |
 | `/update [status\|now\|skip\|off]` | Auto-update: what is running, what is available, where it came from, when it looks again. `now` forces a check past the throttle; `skip` declines the offered version until a newer one appears |
 | `/theme <auto\|warm\|cool\|light>` | Switch the color theme live (persisted) |
@@ -437,8 +438,9 @@ completes, `Up` / `Down` moves the selection, `Esc` closes it.
 | `Alt+Enter` / `Shift+Enter` | Insert a newline |
 | `Shift+Tab` | Toggle **plan mode** (`BUILD` <-> `PLAN`). Equivalent: `/plan`. On Windows this needs a console flag Node < 22.17 does not set; aragon sets it at startup — see [Requirements](#requirements) |
 | `Ctrl+P` | The same toggle, over a channel no Windows console can swallow. Use it if `Shift+Tab` does nothing |
-| `Esc` | Abort the run / close an overlay / close a popup |
-| `Esc` ×2 | **Force-stop** a run that did not abort: kills the shell command it is blocked on and returns the view to `idle`. The second press only does anything while the run is *still* running, so in a healthy run it is a no-op |
+| `Esc` | Close an overlay or popup; otherwise ask for interruption confirmation. While idle, cancel pending auto-continuation |
+| `Esc` ×2 | Interrupt the run when pressed within 1.5 seconds. Other keys or closing a menu cancel the first press |
+| `Esc` again after interruption | **Force-stop** a run that is still stopping, kill foreground shell commands and return to `idle`; background services remain running |
 | `Ctrl+C` | Stop the background **services** the agent started, when there are any. It does not arm exit |
 | `Ctrl+C` ×2 | Exit (first press warns), once no services are running |
 | `Ctrl+L` | Redraw the frame (clear the screen in inline mode) |
@@ -459,8 +461,11 @@ completes, `Up` / `Down` moves the selection, `Esc` closes it.
 In **full-screen mode** the transcript is scrolled by the app itself: `PgUp` /
 `PgDn` and `Shift+↑` / `Shift+↓`. While pinned to the bottom the viewport follows
 new output automatically; once you scroll away the status bar shows `↑N`, a slim
-rail on the right edge shows where you are, and a hint counts the lines below
-you. Submitting a message always re-pins to the newest output. In **inline mode**
+scrollbar occupies the terminal's last column (including 40-column windows). Drag its thumb
+to move through history, or click the track to move one page. Messages, the team panel
+and the input area scroll together; typing or editing returns to the input without
+losing the draft. The fixed status row shows `PgDn down` while reading history.
+`PgDn` moves one page down; editing or submitting returns directly to the end. In **inline mode**
 (`--no-fullscreen`) history lives in your terminal's native scrollback, printed
 once via Ink `<Static>`.
 
@@ -473,9 +478,10 @@ open. It never touches your draft, and it never recalls prompt history: that is
 Two things follow from the app owning the mouse, and they are worth knowing
 before you meet them:
 
-- **Selecting text now needs `Shift`+drag** in most terminals. That is the
-  terminal's convention for "an application is tracking the mouse", not
-  something this CLI can opt out of while still reading wheel events.
+- **Dragging text selects and copies it when mouse selection is enabled.**
+  Dragging the last-column scrollbar scrolls instead. `--no-mouse-select` disables
+  text selection while preserving scrollbar dragging. `Shift`+drag uses the
+  terminal's native selection on hosts that support that convention.
 - **`tmux` with `mouse on` keeps the wheel for itself**, so the app never sees
   it. `set -g mouse off` hands it back.
 - **A Windows console on Node below 22.17.0 cannot report the wheel at all**,
@@ -511,7 +517,7 @@ Density and hints are settable the same three ways: `--compact` / `--no-hints`
 for one run, `aragon config set density compact` / `aragon config set hints false`
 to persist. The composer hint row also shortens to `? help` on its own after a
 few sessions — except while a run is in progress, when it always spells out
-`esc abort` in full.
+`esc ×2 interrupt` in full.
 
 ## What you see while it runs
 
@@ -623,8 +629,9 @@ near-identical added ones.
 
 - Your previous shell output is **covered, not erased**, and returns untouched
   when you exit. Nothing in your scrollback is destroyed.
-- The frame is fixed at `rows - 1` tall, which is what keeps the composer and the
-  status bar at the bottom of the screen even on an empty session.
+- The frame is fixed at `rows - 1` tall. The header, activity row and status bar
+  stay visible. The input belongs to the scrolling document; short sessions fill
+  the space above it, and browsing history moves it out of view.
 
 On exit the session is replayed into the normal buffer as plain text so the
 conversation survives leaving the screen (`--no-exit-transcript` opts out;
@@ -637,10 +644,13 @@ writing screen-control sequences into a pipe or a redirected file is never safe.
 `--no-fullscreen`, `ARAGON_FULLSCREEN=0`, or `aragon config set fullscreen false`
 opt out permanently.
 
-The terminal's native scrollback and mouse wheel do not scroll the transcript in
-this mode, and mouse tracking is deliberately left off because enabling it costs
-text selection and copy in most terminals. If a crash ever strands your terminal
-on the alternate screen, `reset` restores it.
+The alternate screen uses an application scrollbar rather than the terminal's
+native scrollback. Windows Terminal and conhost have different mouse/VT capabilities;
+the PowerShell version alone does not determine dragging support. If the host cannot
+deliver SGR mouse reports, the scrollbar remains visible and keyboard scrolling works.
+`--no-mouse` provides that keyboard-only path; `--no-diff-render` disables output
+differencing without disabling the scrollbar. A mid-session resize below 40 columns
+or 12 rows displays a size hint and preserves the draft for restoration.
 
 ## Render performance
 
@@ -741,8 +751,8 @@ assumptions rather than to retry.
 
 **Dismissing a plan is not how you stop.** `Esc` on a plan card asks for a
 *better* plan — the agent is told to refine it and submit again — so a model that
-keeps submitting keeps getting cards. To stop the run itself, **press `Esc`
-twice**: the first closes the card, the second aborts the run. `Ctrl+C` twice
+keeps submitting keeps getting cards. To stop the run itself, close the card with `Esc`, then **press `Esc`
+twice within 1.5 seconds** to interrupt. Closing the card never counts as the first press. `Ctrl+C` twice
 still exits the session outright.
 
 ### Where the mode is shown
@@ -799,7 +809,8 @@ ask — and the agent writes the finished plan as its final message in markdown.
 For work with three or more distinct steps the agent keeps a **visible plan**:
 it writes a checklist with the `todo_write` tool, marks exactly one item as in
 progress, and ticks it off before starting the next. In full-screen mode that
-list is rendered as a right-hand rail, about a fifth of the terminal wide.
+list is rendered as a right-hand rail, targeting 15% of the terminal width
+(14–36 columns, including its separator and padding).
 
 ```
   transcript ...                            | TODO             2/7
@@ -807,8 +818,7 @@ list is rendered as a right-hand rail, about a fifth of the terminal wide.
                                             |
                                             | v  1 Read the reducer
                                             | v  2 Design the store
-                                            | >  3 Wiring the rail into
-                                            |      AppShell
+                                            | >  3 Wiring the rail...
                                             | o  4 Add the panel-rows test
                                             | o  5 Update the README
                                             |      +2 more
@@ -820,8 +830,8 @@ for a question, or for a search with no work attached — and a one-item list
 against an empty plan is refused outright. A session that never plans has
 byte-identical layout to a build without this feature.
 
-**The list is a projection of what the model believes**, so nothing that does
-not also tell the model may change it — except you, saying so:
+**The list shows the current task's plan.** Starting a new task or explicitly
+clearing the list removes this live view while preserving conversation history:
 
 - `/clear` and `/todo clear` take the plan off the screen. Neither touches the
   conversation, so the model still knows what it was doing and its next update
@@ -830,10 +840,14 @@ not also tell the model may change it — except you, saying so:
 - `/save` writes the list and `/resume` restores it. Resuming a session that has
   no list clears the current one, rather than leaving a plan on screen whose
   conversation has just been replaced.
-- A finished plan is dropped at the START of your next message, so you still get
-  to see `7/7 done`. An unfinished one survives "continue" / "now do the rest",
-  and is dropped after three unrelated turns rather than holding a fifth of the
-  screen for the rest of the session.
+- A normal new task clears the previous plan, including unfinished steps, only
+  when it starts successfully. The completed run keeps its final plan visible.
+  `/todo continue` and automatic continuation preserve the plan and its timestamp;
+  ordinary text such as "continue" starts a new task. Steering keeps the current
+  plan. Until a valid new `todo_write`, the rail, inline strip and count stay hidden.
+  Startup failure or cancellation keeps the old plan. History cards remain available.
+- During a live run, interrupt before `/reset` or `/resume`. A conversation switch
+  while startup is waiting cancels that pending request and returns the view to idle.
 
 ### When a run ends with steps left
 
@@ -856,7 +870,7 @@ setting:
 
 `Esc` during the grace window cancels; so does typing anything. A run that ended
 with an **error** never auto-continues in any mode — you get a warning instead.
-A run **you** aborted with `Esc` now says nothing at all, where it used to
+A run **you** interrupted with two `Esc` presses now says nothing at all, where it used to
 report what you had just interrupted.
 
 `/todo follow off` is the third mode: no notice, no continuation, silence.
@@ -888,11 +902,19 @@ planning discipline and hides the column — which is what you want with a scree
 reader, and what `--no-todo-panel` does for a whole session. Under `-p` the plan
 is written to stderr as `[todo] 3/7 <step>` lines, suppressed by `--quiet`.
 
-The rail is not mounted below 80 columns, while an overlay is open, in inline
-mode, or when the viewport is too short to say anything useful; the transcript
-keeps at least 62 columns at every width. In those cases the counter appears in
-the status bar instead, and the checklist is still written into the transcript
-as one card per turn.
+右栏从 76 列开始显示，正文至少保留 62 列；100 列终端使用 15 列右栏。
+已有任务时，团队面板按实际行数占用空间，补全菜单的边框和提示也计入预算。
+例如 100×20、团队占 8 行时，TODO 仍以 4 行紧凑视图显示。
+
+剩余 3–5 行时保留标题、完成计数、当前任务与合并提示 `-A +B`：
+`-9 +10` 表示上方隐藏 9 项、下方隐藏 10 项。6 行起使用常规视图；
+所有任务各占一行，全文仍可在正文任务卡片中查看。进度条需要至少 20 列、8 行。
+输入增长导致空间不足时团队先折叠为摘要；菜单不足 3 行时隐藏，其候选不会拦截输入。
+
+低于 76 列、共享区域不足 3 行、打开 overlay、显式关闭面板、没有任务或
+inline 模式时不显示右栏。低于 12 行使用原有小终端提示；扩大窗口后自动恢复。
+inline 仍使用上文的单行任务条。`/todo status` 中的 `Panel: on` 仅表示配置开启，
+实际可见性还取决于数据和窗口空间；可以通过该命令区分未生成计划与暂时隐藏。
 
 ## Built-in tools
 
@@ -998,7 +1020,8 @@ than features. `bash` now always settles: it returns when the process exits
 rather than when its output stream closes, so a command that detaches a
 grandchild can no longer leave the turn pending forever, and it is handed a
 closed stdin so a command that prompts fails instead of blocking on a read
-nobody will answer. And `Esc` twice always force-stops, whatever the flag says.
+nobody will answer. Two `Esc` presses request interruption; another press force-stops a stuck run,
+whatever the flag says.
 
 ## Team subagents
 
@@ -1070,7 +1093,7 @@ children's tokens are folded into the `[usage]` footer.
   `debug`. A `team_send` subject is recorded, never its body; a subagent's brief
   and summary only at `trace`.
 
-**`Esc`** aborts the whole dispatch — every subagent within a couple of seconds
+**Two `Esc` presses within 1.5 seconds** abort the whole dispatch — every subagent within a couple of seconds
 — and the report comes back marked `ABORTED` with whatever was finished.
 
 ## Fast model tier
@@ -1211,6 +1234,84 @@ it for a background advisory is how an unrequested call ends up competing with
 you for a rate-limited provider's quota. The review's own wall-clock bound is
 20 s.
 
+## The context gauge
+
+The right end of the status bar answers one question: **how full is the context,
+out of how much.**
+
+```
+[####----] 43%  86.0k/200.0k   total 1.2M^ 48.0k v   $3.21   12 tok/s  1m02s
+            ^        ^         ^
+            |        |         +-- session spend, prompt side / output side
+            |        +-- occupied / window
+            +-- the two together, as a percentage
+```
+
+The readouts drop as the terminal narrows, in that order of priority:
+
+| Columns | Right cluster |
+|---|---|
+| >= 96 | `[####----] 43%  86.0k/200.0k  total 1.2M^ 48.0k v  $3.21` |
+| 72-95 | `[####----] 43%  86.0k/200.0k  $3.21` |
+| 60-71 | `[####----] 43%  $3.21` |
+| < 60 | `43%  $3.21` |
+
+**Two different markers, because there are two different things to doubt.**
+
+- `~` sits on the **percentage** and means the *numerator* is partly a guess:
+  either no completed turn has reported usage yet (right after `/resume`, or
+  right after a compaction), or tool results have been appended since the last
+  measurement and their size is estimated.
+- `?` sits on the **window** and means the *denominator* is a guess: the model is
+  not in the built-in table, so a flat 128 000 was substituted. See
+  `contextWindow` below.
+
+**The percentage keeps moving during a turn.** Every tool result nudges it,
+whether or not compaction is enabled — it is not a compaction feature, and a
+session started with `--no-compaction` gets the same live reading. After
+`/resume` the gauge shows the restored session's real occupancy immediately,
+without sending anything.
+
+### `/context`
+
+The gauge is a bar and a rounded percentage; `/context` is the full answer, at
+any width, in any mode:
+
+```
+Context
+  Occupancy      43%   86.2k of 200.0k   [measured 85.1k + 1.1k estimated]
+  Window         200000   from the model table
+  Since measured 1.1k estimated tokens appended since the last provider-reported usage
+  Compaction     on - triggers at 90% (amber at 75%), 2 this session, 118.0k reclaimed
+  Session spend  1.2M in (incl. 940.0k cache read, 12.0k cache write) / 48.2k out, $3.21
+                 includes subagent, fast-tier and compaction spend,
+                 not just this conversation
+```
+
+Two lines are worth reading closely. **`Window`** always names where the number
+came from — the model table, your own `contextWindow`, or the invented
+placeholder — because those are indistinguishable everywhere else. And
+**`Compaction`** reports what is actually true of this session, including
+`off - not registered for this session (started with --no-compaction)`; it never
+promises a threshold that nothing will act on.
+
+### `contextWindow`
+
+When the model is not in the built-in table — a custom `baseUrl`, a self-hosted
+id, something released last week — the denominator is a **fabricated** 128 000
+and the percentage is meaningless. Correct it:
+
+```bash
+aragon config set contextWindow 1000000   # persisted; prints "Set contextWindow = 1000000"
+aragon config set contextWindow auto      # back to the model table / placeholder
+ARAGON_CONTEXT_WINDOW=1000000 aragon      # one session
+```
+
+Values are clamped to `[8000, 5000000]`; `auto` (the default) is stored as
+`null`. Setting it removes the `?` marker, because you have asserted the number —
+and `/context` still shows that it came from you, which is what makes a wrong
+value findable.
+
 ## Context compaction
 
 A long agentic run fills the model's context window. Before this existed, the
@@ -1307,7 +1408,10 @@ Three surfaces, each answering something the others cannot:
 - **As state** — a `compacting` chip in the status bar, and the context gauge's
   colours aligned to your own thresholds. The gauge **falls immediately** after a
   compaction rather than waiting for the next turn, with a `~` while the value is
-  derived rather than measured.
+  derived rather than measured. The colours follow your configured thresholds
+  whenever compaction is **enabled**, even if no summarizer model currently
+  resolves; after `/compact off` they fall back to the generic 60 / 85, because
+  colouring by a rescue that is not coming is worse than not colouring at all.
 - **As a record** — a transcript card with the before/after message and token
   counts, the summarizer, the duration, and the summary itself. `Ctrl+O` expands
   it.
@@ -1320,7 +1424,9 @@ self-disabled, or the ladder ran out.
 
 `/compact status` is the guaranteed surface: the chip drops on a narrow terminal
 and the card scrolls away, but the command answers at any width, in any mode,
-after the fact.
+after the fact. For the gauge specifically, [`/context`](#the-context-gauge) is
+the equivalent — and it works in a session that never registered compaction at
+all.
 
 ### When the RECENT turns are what does not fit
 
@@ -1701,6 +1807,8 @@ env / `.env` → CLI flags**.
   reasoning blocks), `ARAGON_LIVE_TOOL_OUTPUT` (`0` keeps a running tool card to
   one line),
   `ARAGON_MAX_TOKENS` (a number, or `auto` / `0` for the per-model ceiling),
+  `ARAGON_CONTEXT_WINDOW` (a number, or `auto`; the denominator the context
+  gauge measures against),
   `ARAGON_THEME`,
   `ARAGON_FULLSCREEN`, `ARAGON_PLAN` (`1` starts in plan mode),
   `ARAGON_TEAM` (`0` disables team subagents), `ARAGON_TEAM_MAX` (fan-out width),
@@ -1728,6 +1836,7 @@ env / `.env` → CLI flags**.
 | Config key | Default | Meaning |
 | --- | --- | --- |
 | `maxTokens` | `64000` | Output token cap, clamped to `[256, 200000]`. `null` means **auto** — use each model's own ceiling, never above 64000. Absent means the default. See [Output token limits](#output-token-limits). |
+| `contextWindow` | `null` | The window the context gauge measures against, clamped to `[8000, 5000000]`. `null` means **auto** — the built-in model table, or a fabricated 128000 for a model it has never seen. Set it when the gauge shows `?` on the denominator. See [The context gauge](#the-context-gauge). |
 | `showThinking` | `false` | Draw the reasoning the model returns. `thinkingLevel` is the effort the provider is asked to **spend**; this is whether the terminal **shows** it. Off by default: a settled turn that thought leaves one muted `thought for 12s` row in its place, so nothing is hidden silently. |
 | `liveToolOutput` | `true` | Draw up to eight sanitised rows of a **running** tool's output on its card, plus a `no output for Ns` row when the child goes quiet. On by default, unlike `showThinking`: this ADDS the information a long `bash` call otherwise hides, and its cost is bounded by construction — eight rows per call, sixteen calls, whatever the command emits. Turn it off and the card is a single `running` row again, with no store allocated and no recorder attached. |
 | `fullscreen` | `true` | Use the full-screen TUI (still subject to the automatic downgrades). Setting it to `false` opts out permanently; leaving it `true` is *not* a force — only `--fullscreen` / `ARAGON_FULLSCREEN=1` override the heuristics. |
@@ -1805,6 +1914,8 @@ ARAGON_MAX_TOKENS=32000 aragon       # env layer, between the flag and the file
 aragon config set maxTokens 32000    # persisted; prints "Set maxTokens = 32000"
 aragon config set maxTokens auto     # persisted as null
 aragon config set maxTokens default  # back to 64000
+aragon config set contextWindow 1000000  # the gauge's denominator
+aragon config set contextWindow auto     # back to the model table
 aragon config get maxTokens          # "64000" | "auto"
 ```
 
@@ -2137,7 +2248,7 @@ node packages/cli/dist/cli.js --version
   shebang; `node packages/cli/dist/cli.js --version` prints the version.
 - `npm pack -w packages/cli --dry-run --json` lists `dist/cli.js` under `files`.
 - With `ANTHROPIC_API_KEY` set: `aragon` streams a reply, a tool card renders,
-  `Esc` aborts mid-run, `/model` switches models, `/settings` saves a key,
+  `Esc` twice interrupts mid-run, `/model` switches models, `/settings` saves a key,
   `Ctrl+C` twice exits.
 - `echo "list files" | node dist/cli.js -p` prints an answer and exits `0`.
 - A missing/invalid key produces a visible, actionable message (never a blank
@@ -2155,7 +2266,7 @@ node packages/cli/dist/cli.js --version
   nothing is truncated to a single line.
 - `--no-hints` on a 20-row terminal in plan mode - the status bar still says
   `PLAN` with no chip on screen.
-- Dismiss a plan card with `Esc`, let the agent resubmit, then press `Esc` twice:
+- Dismiss a plan card with `Esc`, let the agent resubmit, then close the card and press `Esc` twice within 1.5 seconds:
   the run aborts and the session returns to an idle prompt. Do this one BY HAND
   as well as in a test - the point of the check is whether the exit is findable,
   which no assertion can tell you.
@@ -2163,3 +2274,18 @@ node packages/cli/dist/cli.js --version
 ## License
 
 MIT
+
+
+### 输入光标与任务切换验收
+
+输入获得应用内焦点时，光标每 500 ms 明暗切换；编辑、移动和恢复焦点后立即亮起。
+`reducedMotion` 开启时保持常亮，弹层打开时暂停。fullscreen 和 inline 使用相同规则。
+单色终端用等列宽的下划线标记，原文相同时改用 `^`，零宽附加码点保留以兼容 Ink。
+标记不进入草稿、历史或提交文本；屏幕选择复制会包含当时可见的标记。
+UTF-16 编辑和 ZWJ/组合字形仍有既有限制，本次修复保证视觉光标定位及相位布局稳定。
+
+在 Windows Terminal/PowerShell 与 POSIX TTY 分别验证两种模式，窗口覆盖
+120×30、100×20、80×24、60×16：观察空输入、英文、中文、emoji、多行和组合附加符至少三个周期。
+检查流式输出不阻止闪烁；单 ESC 不停止任务，两击中断，卡住时第三击强停；菜单关闭不计入两击。
+任务结束后保留最终计划，下一条普通消息启动时旧计划消失，新有效计划出现才恢复；显式续跑保留计划。
+强停后立即提交，在等待中双 ESC 取消，旧引擎退出后不得自行执行已取消的消息。

package/dist/agent/controller.d.ts

@@ -8,6 +8,7 @@
  * success — that promise resolves even on failure. Success/failure is derived
  * from the event stream by the reducer (TUI) and the headless writer.
  */
+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 ConfirmRequest } from '../tools/index.js';
@@ -18,8 +19,9 @@ import type { TeamEvent, TeamSnapshot } from '../team/types.js';
 import { ProcSupervisor } from '../proc/supervisor.js';
 import type { ProcEventListener, ServiceSnapshot } from '../proc/types.js';
 import { type FastStatus } from '../fast/wiring.js';
-import type { FastEventListener } from '../fast/types.js';
-import type { CompactionEventListener, CompactionSnapshot } from '../compaction/types.js';
+import type { FastEventListener, FastSnapshot } from '../fast/types.js';
+import { ContextMeter, type ContextUsageListener } from '../compaction/meter.js';
+import type { CompactionEventListener, CompactionSnapshot, ContextUsageSnapshot } from '../compaction/types.js';
 import type { TodoEventListener, TodoSnapshot } from '../todo/types.js';
 import { type HumanInputGate } from '../tools/human-input.js';
 import { SkillService, type ApprovalGate } from '../skills/service.js';
@@ -178,6 +180,7 @@ export declare class AgentController {
     private readonly outputListeners;
     private readonly fast;
     private readonly compaction;
+    private readonly contextMeter;
     private readonly procs;
     /**
      * The host's notice channel, kept so `prompt()`'s totality has somewhere to
@@ -205,6 +208,7 @@ export declare class AgentController {
      * abort lands.
      */
     private runGen;
+    private startupSequence;
     /**
      * Set SYNCHRONOUSLY by `abort()` before `agent.abort()` (§3.5.4a guard 1).
      * Cleared at the next `agent_start`.
@@ -262,21 +266,23 @@ export declare class AgentController {
      * underlying promise so headless mode can await completion. `agent.prompt()`
      * never rejects, so callers must not treat resolution as success.
      */
-    prompt(text: string): Promise<void>;
+    prompt(text: string, options?: PromptOptions): Promise<PromptOutcome>;
     /**
      * Wait for the engine to unwind, bounded.
      *
      * BOUNDED BECAUSE THE UNBOUNDED CASE IS THE ONE THIS FEATURE IS ABOUT: a tool
-     * that never settles is exactly why rung two exists, and `Agent.waitForIdle()`
+     * that never settles is exactly why the force-stop rung exists, and `Agent.waitForIdle()`
      * alone would hang here for as long as it hangs there. The budget is the two
      * graces a wedged `bash` can legitimately spend, plus the executor's own.
      */
     private waitForEngineIdle;
-    /** The pre-round body of `prompt`, unchanged apart from being private. */
+    /** Prepare before clearing the plan, then enter the engine without yielding. */
     private startPrompt;
+    /** Cancel pending startup as well as any engine run already in progress. */
     abort(): void;
+    private stopEngine;
     /**
-     * Rung two of the Esc ladder: stop the AGENT, whatever it is blocked on
+     * Final rung of the Esc ladder: stop the AGENT, whatever it is blocked on
      * (§3.6 / G3).
      *
      * FOUR STEPS, AND THE FOURTH IS AN ABSENCE.
@@ -284,7 +290,7 @@ export declare class AgentController {
      *   1. `abort()` - everything it does today, unchanged.
      *   2. `killForeground('force')` - hard-kill every tracked foreground `bash`
      *      child. THIS is what actually unblocks a wedged `await tool.execute`;
-     *      an abort signal a tool ignores is advisory, and rung two exists for
+     *      an abort signal a tool ignores is advisory, and the force-stop rung exists for
      *      precisely the tools that ignore it.
      *   3. `runGen += 1` - so `App` can drop the events the engine will keep
      *      emitting while it unwinds (I-7). Without it the view bounces straight
@@ -293,7 +299,7 @@ export declare class AgentController {
      *      `Ctrl+C` stops the SERVICES. That asymmetry is the user's own two
      *      sentences and it is exactly the kind of thing a later reader will
      *      "fix" by making this kill everything - which would mean a user who
-     *      pressed Esc twice to stop a runaway turn also lost the dev server they
+     *      confirmed a force-stop of a runaway turn also lost the dev server they
      *      had been working against for an hour. It is invariant I-4.
      *
      * UNCONDITIONAL ON `bash.background` (P1-6 / D-9). The supervisor is always
@@ -612,6 +618,41 @@ export declare class AgentController {
      * `subscribeTodos` already set.
      */
     subscribeFast(listener: FastEventListener): () => void;
+    /**
+     * The FIFTH thin forwarder: the current fast-tier snapshot, or `null` when
+     * this session never registered a tier at all
+     * (web-use-tier-cooperation-and-control-closure §4.2.1).
+     *
+     * `null` and "a snapshot with `live: false`" are different answers and callers
+     * depend on the difference: the first means "there is no tier here", the
+     * second means "there is one and it is not usable right now".
+     *
+     * Deliberately NOT folded into the existing `review_end` event: that shape is
+     * consumed by `App` too, and this round promised to be purely additive.
+     */
+    fastSnapshot(): FastSnapshot | null;
+    /**
+     * Subscribe to occupancy publications. Returns an unsubscribe function.
+     *
+     * THE SOLE UPSTREAM OF `ViewState.context` (I-1). The gauge used to have two
+     * writers - `turnEnd` and a `contextTokensEstimated` dispatch fired from two
+     * places in `App` - which is the entire cause of P0-1: both wrote in the same
+     * synchronous fan-out and the second one won, restoring the pre-compaction
+     * figure one statement after the bar had correctly fallen. One writer makes
+     * that class of bug unrepresentable rather than merely fixed.
+     */
+    subscribeContextUsage(listener: ContextUsageListener): () => void;
+    /**
+     * Occupancy right now, re-measuring if the history has moved.
+     *
+     * `/context` READS THIS AND NOT `getCompactionSnapshot().pressure` (RV-8). The
+     * latter returns `offCompactionSnapshot()`'s hardcoded zero pressure when
+     * compaction was never registered, so a report built on it would read 0 % for
+     * precisely the sessions this feature exists to fix.
+     */
+    getContextUsage(): ContextUsageSnapshot;
+    /** The meter itself, for the wiring's single-instance assertion and tests. */
+    getContextMeter(): ContextMeter;
     /** Whether a `ContextManager` exists at all. Fixed at construction. */
     isCompactionRegistered(): boolean;
     /** Whether it will actually fire. Flipped live by `/compact on|off`. */