@aragon-agent/cli 0.6.2 → 0.6.4

package/CHANGELOG.md

@@ -5,6 +5,259 @@ All notable changes to `@aragon-agent/cli` are documented here. Entries at
 — those releases really were published under that name, so they are left as they
 were written.
 
+## Unreleased
+
+### Added
+
+- **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
+  chunks. Three separate failures fell out of that one omission, and on Windows
+  you hit all three at once.
+
+  A carriage return that landed alone in a chunk **sent the half-finished
+  message** — a fifteen-line paste could arrive as a dozen separate messages,
+  interleaved with the agent's replies. A carriage return in the middle of a
+  chunk was inserted into the draft as a literal `\r`, which the terminal obeyed
+  by **overwriting the row it was drawn on**. And a paste that survived both grew
+  the composer to the height of the pasted text, pushing the transcript out of a
+  frame whose row accounting still believed the composer was three rows tall.
+
+  Pasting now works the way it reads:
+
+  - **A paste never submits.** Line breaks become buffer newlines, exactly one
+    per source line break, `CRLF` and lone `CR` alike.
+  - **A short paste appears verbatim.** At or below 6 lines and 400 characters it
+    is inserted as-is, indentation intact, and renders exactly like typed text.
+  - **A large paste collapses to a placeholder** — `[Pasted text #1 +218 lines]`
+    — which occupies one line, carries its own size in its label, deletes as a
+    single unit (one `Backspace`, and `Ctrl+W` / `Ctrl+U` / `Ctrl+K` cannot leave
+    half of one behind), and expands back to the full text the moment you send.
+    The model receives every byte; the composer never has to draw them.
+  - **No pasted byte is executed as a terminal control.** `\r`, `\x1b`, NUL, DEL
+    and the C1 range are stripped from the payload — never from your keystrokes,
+    so `Ctrl+A` and Escape are untouched.
+  - **The composer has a ceiling.** A draft of any length occupies at most 3 / 6 /
+    10 rows depending on terminal height, scrolls internally to keep the caret
+    visible, shows how many rows are hidden above and below, and reports its true
+    height to the layout budget. Four hundred presses of `Shift+Enter` were
+    already able to destroy the frame; they no longer are.
+  - **A submitted message cannot make the transcript unresponsive.** A user entry
+    renders at most 40 rows plus a `... +N more lines` tail. The full text is kept
+    and the exit transcript is uncapped.
+
+  On terminals that support it, detection is **exact**: aragon asks for bracketed
+  paste (`DECSET 2004`) in full-screen mode and reads the markers the terminal
+  wraps your paste in. Where that is unavailable — inline mode, an old Windows
+  console — a heuristic on chunk shape catches the same cases, and it needs no
+  cooperation from the terminal at all. Both feed one code path.
+
+  Turn it off with `--no-paste`, `ARAGON_PASTE=0`, or
+  `aragon config set paste false`; the input path is then byte-for-byte what
+  0.6.2 did.
+
+### Fixed
+
+- **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
+  this, a ~100-character key pasted into Settings would have been stored wrapped
+  in invisible framing bytes, masked on screen by the password dots, and would
+  have failed to authenticate on every request afterwards with nothing anywhere
+  explaining why.
+
+- **`--no-mouse` still writes no mouse sequence.** Paste support installs a
+  stdin filter, and `paste` defaults to on, so the filter now exists in sessions
+  that disabled the mouse. Whether the mouse is on is a separate question from
+  whether the stream is wrapped, and the four places that used to conflate them
+  now ask the right one: `aragon --no-mouse` writes no `?1000h`, no `?1006h` and
+  no `?1002h`, leaves your terminal's own click-drag selection alone, and reports
+  `/mouse` as off — while pasting still works.
+
+### Changed
+
+- **Auto-compaction no longer reports compactions that did not happen.** A long
+  unattended run used to print a red `context not compacted #2: nothing_to_drop`
+  card into the transcript. The card was accurate; nobody had asked for it.
+  Auto-compaction evaluates itself at every turn boundary, and a checkpoint that
+  looks at the history and finds nothing worth dropping has changed nothing,
+  called nothing and spent nothing — a smoke alarm announcing "no fire" twice an
+  hour, in error colours, with a machine reason attached.
+
+  A compaction now announces itself **if and only if it commits to doing work**.
+  That is a position in the control flow, not a list of reason strings: everything
+  decided before the first spend is silent, and everything decided after it —
+  including every failure, the truncation fallback, an Esc, and a host fault — is
+  as loud as it ever was. A declined `pressure` checkpoint is now
+  indistinguishable from a turn on which the threshold was never crossed.
+
+  **`/compact` and overflow recovery are unchanged.** A compaction you asked for
+  is owed an answer, and a reactive compaction running after the provider has
+  already refused your request is the one moment the diagnosis matters most. Both
+  still report on every outcome.
+
+  **Quiet, not unrecorded.** Every attempt is still written to the diagnostic log
+  (its `compaction` line gains an `announced` field, so `announced: false` is one
+  grep), still charged to the anti-loop guards, and still counted by
+  `/compact status` — which now reads
+  `This session: 1 compaction (2 checkpoints declined), 94.2k tokens reclaimed`
+  when checkpoints declined, and is byte-identical to before when none did. If
+  declines keep happening, the self-disable notice still says so out loud, once,
+  naming the cause and the remedies. Card numbers are also contiguous again: `#N`
+  counts compactions that ran, not checkpoints that fired.
+
+  **Behaviour change for wrapper scripts.** A declined `pressure` compaction no
+  longer emits a `{ type: 'compaction', subtype: 'start' | 'end' }` pair on the
+  `--output-format json` stream, and no longer prints `[compaction] skipped:` on
+  `-p` stderr. The pairs stay balanced, so only consumers counting *attempts* are
+  affected; the diagnostic log reports those more accurately.
+
+### Added
+
+- **Context compaction, hardened — the trigger now counts the whole history, the
+  recent turns can no longer wedge a run, sub-agents get the same protection, and
+  a compaction is no longer irreversible.**
+
+  **The trigger was systematically late.** It fired on the provider's reported
+  usage for the PREVIOUS request, read at a checkpoint that runs AFTER the current
+  turn's tool results were appended — and tool results are the largest single
+  increment in this loop (100 KB per call, several per turn, ~25 k tokens each).
+  A session reading 88 % could be sending 110 %. Occupancy is now the measured
+  base PLUS an estimate of everything appended since that measurement, and the
+  status gauge reads the same number the trigger does, on every turn — including
+  the turns where a guard declines to compact, which is exactly when the number
+  matters most.
+
+  **The recent turns can no longer wedge a run.** Every previous rung of the
+  ladder operated on the head of the conversation. When the RETAINED tail was what
+  did not fit, each rung reported success or "nothing to drop" while the history
+  stayed un-sendable and the run died. Oversized `tool_result` bodies inside the
+  retained turns are now clipped, oldest first, only when the alternative is a
+  request the provider cannot accept. Nothing is removed — no message, no
+  tool-call id, no role — so a valid history stays valid. Every clip is announced
+  in the text the model reads, at the exact place the data went, and on the card,
+  in `/compact status`, on the JSON stream and in the archive.
+
+  **Sub-agents compact their own history** (`compaction.subagents`, default
+  `true`). A `task` child is bounded by 24 turns and fifteen minutes, and when one
+  overflowed its entire history was discarded and the dispatch reached the lead as
+  one partial sentence. Children run under tighter bounds than the lead: two
+  retained turns, at most two compactions, the fast tier preferred, and failure
+  forced to truncate because nobody is watching a background worker. No transcript
+  card — the lead's transcript describes the lead's context. Set
+  `compaction.subagents: false` to restore the previous behaviour exactly.
+
+  **A compaction is no longer irreversible** (`compaction.archive`, default
+  `true`). The dropped messages are written verbatim to `~/.aragon/compaction/`
+  before the splice is adopted. `/compact history` lists this run's archives,
+  `/compact show <n>` prints one's metadata and summary — never message bodies.
+  The directory is shared by every `aragon` on the machine, so files carry a
+  per-process run id and retention is two-tier: 20 files per run by count, plus a
+  seven-day sweep across all runs, so one session can never prune a live
+  neighbour's work. Writing is best-effort: a failure is logged and never affects
+  the compaction. This is deliberately **not** undo — restoring an over-full
+  history restores the condition that triggered the compaction.
+
+  **The long moment is legible.** The live card counts elapsed seconds and says
+  `esc to cancel`, which `AgentController.abort()` has always made true and no
+  surface has ever stated. A compaction that could only clip says so and names no
+  model, because none was called.
+
+  Two new config keys (`compaction.subagents`, `compaction.archive`), two new
+  environment variables (`ARAGON_COMPACTION_SUBAGENTS`,
+  `ARAGON_COMPACTION_ARCHIVE`), two new `/compact` verbs (`history`, `show <n>`),
+  and two new settings-screen rows. No flags were added.
+
+- **Context compaction — a long run no longer dies when the window fills, and it
+  is ON by default.** A session's conversation only grows: nothing anywhere
+  removed a message, so a 40-turn tool-heavy run had exactly one ending available
+  to it once the context window filled — an HTTP 400 and a banner reading
+  *"Context length exceeded — start a new conversation with /reset."* The
+  product's answer to running out of context was "throw away everything you were
+  doing."
+
+  Now, at **90 %** occupancy, the run pauses at a turn boundary, hands the older
+  part of the history to a summarizer, and swaps it for a structured record. Your
+  original task stays **verbatim**, the most recent turns stay **verbatim**, and
+  the run continues in the same loop with the same tools, the same todo list and
+  the same working directory.
+
+  **This changes behaviour for existing users, in the direction of not dying.**
+  `--no-compaction`, or `compaction.enabled: false`, restores the old behaviour
+  exactly: no manager is constructed, nothing is subscribed, no registry is
+  allocated, and a full window ends the run as it did before. Both flag forms are
+  declared, so a stored `false` survives a run that passes no flags.
+
+  Three ways it fires. **Proactively** on measured occupancy — the case that
+  happens almost every time. **Reactively** when the provider returns
+  `context_overflow` anyway, because the model is not in the static window table
+  or you are pointed at a proxy in front of a smaller one: one compaction, one
+  re-send, run continues. And **manually**, via `/compact`, which runs
+  immediately when idle and queues to the next turn boundary when running.
+
+  The trigger has two terms. 90 % of a 200 k window leaves 20 k, which is plenty;
+  90 % of a 32 k window leaves 3.2 k, which is less than a single `max_tokens` of
+  8192 — the request is already impossible. So compaction also fires whenever the
+  remaining headroom drops below one full response.
+
+  **The default summarizer is your own model, and that costs real money.**
+  `compaction.useFastTier` is `true`, but it is a *preference*: the fast tier is
+  off unless you configured it, so out of the box the first compaction is a
+  ~30 k-token call on the session's own model. It happens at most 5 times per
+  run, the alternative is losing the run entirely, and the spend is visible — in
+  the session total, priced with the summarizer's own table, and reported as
+  `pricing unknown` rather than `$0.00` when that table has never seen the model.
+  Configure the fast tier to make it cheap.
+
+  Summarization fails sometimes. The ladder is one retry (on your **main** model
+  if the first attempt used the fast tier), then a **truncation** that says so on
+  the card, on the JSON event stream, and inside the block the model itself
+  reads. `compaction.onFailure: "stop"` makes the other trade.
+
+  Four guards stop it looping on your money: never two on consecutive turns,
+  never more than 5 per run, a progress requirement, and a self-disable after two
+  no-progress attempts with a notice naming the cause and the fix. The guards are
+  **trigger-aware** — the reactive path stays armed even after a self-disable,
+  because a compaction answering a request the provider has already refused is
+  the difference between a live run and a dead one.
+
+  Three UI surfaces: `Compacting context…` on the activity row while it runs, a
+  `compacting` chip plus threshold-aligned gauge colours as state, and a
+  transcript card with the before/after counts, the summarizer, the duration and
+  an expandable summary as the record. The gauge falls **immediately** rather
+  than waiting for the next turn. `/compact status` is the guaranteed surface at
+  any width.
+
+  New: `compaction` config section (6 keys), `--compaction` / `--no-compaction` /
+  `--compaction-threshold`, `ARAGON_COMPACTION*` (3 vars), `/compact` (6 forms),
+  three settings-screen rows, a `compaction` event on the `aragon exec` JSON
+  stream (`EXEC_SCHEMA_VERSION` **unchanged** — adding an event type never bumps
+  it), and two stderr lines under `-p`.
+
+### Changed
+
+- **The context gauge now counts cache tokens**, through the same
+  `occupiedTokens` the compaction trigger reads. Anthropic reports `input_tokens`
+  *excluding* cached tokens and puts them in two separate fields, so the old
+  `inputTokens + outputTokens` silently under-reported occupancy for anyone
+  behind a caching gateway. That was already a defect in the number on the status
+  bar; it becomes a much worse one the moment a trigger fires on a different
+  number from the one you are watching.
+
+- **`context_overflow` now names `/compact` alongside `/reset`.** That remedy
+  list was complete until this release, because throwing the conversation away
+  really was the only exit.
+
+### Known limitation
+
+- **A summarizer that is 90 % faithful will, eventually, drop something the run
+  needed,** and no amount of prompt engineering closes that. The design bounds it
+  — verbatim task, verbatim recent turns, a block that tells the model the record
+  is partial, and three surfaces that make it visible so a human can step in —
+  but it does not eliminate it. That is inherent to compaction as a technique, it
+  is the same trade Claude Code and Codex make, and it is preferable by a wide
+  margin to the previous behaviour, which was to lose the entire run.
+
 ## 0.6.0
 
 ### Added
@@ -84,6 +337,74 @@ were written.
 
 ## Unreleased
 
+### Added
+
+- **Drag the mouse to select text, and release to copy it.** Full-screen mode
+  takes the alternate screen, turns on mouse reporting so the wheel can scroll a
+  transcript the terminal no longer knows how to scroll, and draws every row
+  itself. Each of those is right on its own; together they took your terminal's
+  own drag-to-select away and put nothing in its place. The only thing shipped
+  in its place was a one-line notice naming a bypass key that is Shift on some
+  emulators, Fn on others and a preference elsewhere — a workaround, told once,
+  in a line that scrolls away.
+
+  Press the left button and drag: the cells you drag across are highlighted as
+  you go, and releasing copies exactly them. The copy goes out over **OSC 52**
+  first, so it reaches the clipboard of the machine you are *sitting at* rather
+  than the one you are ssh'd into, with the platform clipboard binary attempted
+  alongside it for terminals that ignore the sequence. Neither mechanism is
+  detectable, so the toast names what was sent rather than claiming a success it
+  cannot verify. `/copy` now goes through the same path and gained ssh support on
+  the way.
+
+  The highlight is painted in the frame pipeline rather than in React, so a drag
+  costs one to three re-addressed rows instead of a re-render of the whole tree,
+  and the text that is copied is read from the same mirrored rows the highlight
+  was painted over — what you see is what you get by construction, not by a
+  staleness check that can be wrong.
+
+  Two switches, both reversible without a restart: `/mouse off` hands the mouse
+  back to your terminal for the session (and says plainly that the wheel goes
+  inert while it is off), `/mouse on` takes it back, and
+  `aragon config set mouseSelect false` keeps wheel scrolling while leaving
+  drag-select off — which also stops the CLI asking the terminal for motion
+  reports at all, so that session puts exactly the bytes on the wire that it did
+  before this release. `--no-mouse` remains the switch that captures nothing.
+
+### Changed
+
+- **Scrolling up now actually stops the transcript.** The viewport followed the
+  newest output by holding a *fixed distance from the bottom*, so scrolling up
+  during a run did not pause anything: twelve new rows of output moved the
+  window twelve rows down, and whatever you had scrolled up to read slid off the
+  top while you were reading it. The faster the agent talked, the faster your
+  reading position ran away.
+
+  While you are scrolled up, the transcript is now anchored to the **content**:
+  new output accumulates below the window instead of dragging the window along
+  with it, and the rows on screen hold still. After five seconds with no
+  scrolling the viewport returns to the newest line by itself — but only if
+  something actually arrived while you were paused, so reading a *finished*
+  transcript is never interrupted by a jump to a bottom that has not moved.
+  Every gesture restarts the countdown, a selection drag suspends it, and
+  `aragon config set scrollResumeMs 0` turns the return off entirely
+  (`ARAGON_SCROLL_RESUME_MS` sets it too).
+
+  The number the hint shows means something sharper as a result: it is now
+  literally "rows of newer output below your reading position", which is what
+  `PgDn` traverses and what the status bar's `↑N` has always shown.
+
+- **The "N new lines · PgDn" hint moved inside the input box.** It used to be
+  rendered as the viewport's own last row, which spent a line of your transcript
+  on chrome at exactly the moment the transcript was longest — and, because the
+  hint's presence shrank the viewport, it fed back into the very number it was
+  displaying. It is now a right-aligned chip on the composer's input row, inside
+  the border, where it costs no rows at all. The chip sits in a fixed-width cell
+  so the number gaining a digit cannot re-wrap a draft, it never truncates (the
+  draft wraps first), and unlike the teaching row below the box it neither fades
+  with experience nor disappears on a short terminal: how far behind you are is
+  state, not a tutorial.
+
 ### Fixed
 
 - **The working spinner no longer disappears when an ack takes its row.** Steer a