@aragon-agent/cli 0.6.31 → 0.6.33

package/CHANGELOG.md

@@ -8,6 +8,30 @@ were written.
 ## Unreleased
 
 ### Added
+- **Background jobs, and a bounded wait for them.** A command that finishes on its
+  own but takes far longer than one tool call - `python train.py`,
+  `huggingface-cli download`, `cargo build --release` - can now be started with
+  `bash({ command, background: true })` and comes back as a **`task`** (`t1`,
+  `t2`) rather than a `service`: it is `running` from the spawn instead of
+  spending its first minute as `starting`, and its first-frame result says so.
+  `job_wait({ job, timeoutSeconds?, since? })` blocks at most 60 seconds (default
+  `jobs.waitSeconds`, 30) and returns one status line, one extracted progress
+  line, at most six new output rows and a cursor - so waiting thirty seconds costs
+  one call instead of six `bash_output` polls, six model turns and six 200-row
+  tails. `job_list()` prints one line per job. Progress (`47%`, `epoch 3/10`,
+  `812/1000`, `1.2/3.4 GiB`) is extracted from the tail and not repeated while it
+  is unchanged; `[stalled]` reports silence with three options and kills nothing.
+  A job that ends while the model is busy produces a `<job_notices>` block at the
+  end of the next tool result, delivered exactly once even when the fast tier
+  clears the steering queue mid-run. Full output past the 200-row ring is mirrored
+  to `~/.aragon-agent/jobs/<session>/<id>.log`, and `bash_output`'s truncation
+  note names the path. New `jobs.*` section (5 keys, `aragon config set` and
+  `ARAGON_JOBS_*`), new `job` event and `background-jobs` capability in
+  `aragon exec`, and `/bg` now lists kind, elapsed and progress.
+  **Two defects fixed in passing:** a task that crashed within the settle window
+  was reported as still running (the guard tested `!== 'starting'` instead of
+  terminality), and a stopped job's result said "not ready yet - still coming
+  up". See [Background jobs and bounded waiting](README.md#background-jobs-and-bounded-waiting).
 - **`Ctrl+L` branches this session into a new terminal - and `Ctrl+R` now
   redraws (KEY BINDING CHANGE).** One keystroke opens a PowerShell (Windows) or
   bash (macOS/Linux) window in the session's current `/cwd`, running
@@ -97,6 +121,101 @@ were written.
 
 ### Fixed
 
+- **The native-scroll screen is filled edge to edge, with no blank band anywhere.**
+  Three complaints, one cause: the live region was only as tall as the panel band
+  asked for, and every row it did not ask for became the canvas `gap` - blank rows
+  drawn *above* the content. So the app appeared to start halfway down the terminal,
+  a long blank band sat between a finished result and the card that was still running,
+  and the `TODO` rail stopped six rows or so above the input box. The region is now
+  the whole screen (`rows - 1`, the same height the full-screen layout uses): the
+  header is its first row, the input box and status line are its last two, the band
+  takes every row in between (`bandRows = pool`), so the rail spans the full height
+  above the composer and the tail column ends against it. The `gap` is 0 by
+  construction, not by tuning, and the scrollback writer is unchanged - `[gap][held]
+  [region]` collapses to `[region]` at that height. Two consequences worth knowing:
+  the region now shows the last ten entries of the conversation instead of only the
+  unfinished ones, and an entry is printed into your scrollback when it leaves that
+  window (so nothing is ever in both places at once); `/clear`, `--resume` and exit
+  flush the window first, which is why nothing visible is lost. The empty-session card
+  is drawn against the header rather than the input box, and `/perf` grew the three
+  numbers that make this self-checking: `top <n>` on the `mode native` line, plus
+  `pool=` and `window=<start>/<n>` on the `band:` line.
+- **The TODO rail and the subagent roster are back in the default (native) scroll
+  mode.** Printing the conversation into the terminal's own scrollback took the two
+  panels with it: the rail lived in the full-screen layout's middle band and the
+  roster in the viewport footer, and neither of those exists once the live region
+  takes over - so a running plan showed nothing but a `Todo: 2/5` chip and a running
+  dispatch showed `Team: 2/4 running` in plain grey. The live region now owns a
+  PANEL BAND directly above the input box: the `TODO` rail (markers, index,
+  `activeForm`, overflow, gauge) is the band's right-hand column, the `team` roster
+  (header line, one row per subagent with activity and elapsed time, `+N more`, the
+  supervisor line) sits at its top left, and the unfinished tail below them is
+  rendered with the **real** entry components instead of the text projection - a
+  running `team` card and a running `tool` card now look exactly like the ones the
+  full-screen mode draws, gutter included. Row and column allocation has one owner
+  (`ui/scrollback/band.ts`), the printed conversation still uses the full width, and
+  the six ways a panel can be absent (`disabled`, `empty`, `narrow`, `short`,
+  `overlay`, a degraded frame) each name themselves in a new `/perf` `band:` line.
+  `aragon config set scrollMode app` renders byte-identically to before.
+- **The test suite no longer mirrors modules into `%TEMP%`, and the release script
+  pins the runtime and installs from the lockfile.** A release failed with 252
+  "failed" test files whose every first error was
+  `ENOENT ... \Temp\<id>\ssr\.tmp-...`, while each of those files passed when run
+  alone: vitest 4's forks pool writes every transformed module into
+  `%TEMP%/<nanoid>/<environment>/`, creates that directory exactly once and never
+  re-checks it, and its only deleter does not synchronise with in-flight imports. A
+  directory that disappears mid-run therefore turns every not-yet-fetched module into
+  an import error that has nothing to do with the code under test. Both packages now
+  run `pool: 'threads'` (no module mirror is written at all), `vitest` and `vite` are
+  pinned to exact versions in both manifests and in a root `overrides` block,
+  `package-lock.json` is recomputed with them, and the release installs with `npm ci`
+  **before** any gate runs instead of re-resolving the tree after the version bump.
+  `npm run verify:test-gate` adds a version/environment pre-flight, and a failing test
+  run is attributed before anything is retried: only when every failing file's first
+  error is that mirror `ENOENT` does the release retry once, and a real failure is
+  never retried and never worded differently.
+- **The reply no longer floats in the middle of the screen: it sits directly on top of
+  the input box.** The previous release pinned the *composer* to the last two rows by
+  emitting blank rows between the newest printed line and the live region, so a
+  conversation that had not filled the screen left the answer stranded above a band of
+  blank space - the shorter the session, the wider the band. The writer now treats the
+  `rows - 1` rows above the parked cursor as a CANVAS it owns, laid out top-down as
+  `[gap][content][region]`: the blank space lives *above every visible content row*, and
+  the newest content row always touches the top row of the live region. The gap is
+  SKIPPED with `CUD`, never written, so a blank row still cannot reach the scrollback;
+  the content rows still on the canvas are redrawn in place when the layout moves them,
+  and a row that has left the canvas (scrolled away or erased at exit) is never written
+  again. The reflow-estimate chain is gone: a narrower or shorter window now drops the
+  geometry and re-measures (a couple of hundred milliseconds of ordinary appending)
+  instead of guessing an erase distance that could cut a re-flowed line in half. Two
+  self-healing paths the canvas would otherwise lose are explicit: a re-measurement adds
+  the canvas's own height to the reported "rows below the cursor" (reading only the
+  latter collapses the canvas onto the parked row and pushes the visible content into
+  the scrollback a second time), and every batch reconciles its grid with the live
+  terminal height first (a `resize` event arrives a libuv turn late, and on a terminal
+  that never answers CPR the composer would stay mid-screen for the whole session).
+  `/perf`'s `scrollback` line now reports `canvas`/`content`/`gap` rows, `scrolled` rows
+  and `anchor resets` alongside `region` and `anchor bottom via probe|fill|none`.
+  `anchor: unknown` (no TTY, no filter, no answer, or geometry lost after a foreign
+  write) stays byte-identical to the previous release, except for the documented case
+  where a width or a height change arrives while nothing is measured.
+- **In native scroll mode the composer stopped mid-screen after a reply, leaving a
+  screenful of blank rows below it.** The live region was positioned *relative to
+  the last printed line*, so on a conversation that had not filled the screen yet
+  the input box and status line sat wherever the history ended - the shorter the
+  session, the higher they floated - and closing an overlay, `/clear` or a shorter
+  draft moved them again. The writer now carries a measured `gap` ("rows left below
+  the parked cursor") and emits that many blank rows *above* the region, so
+  `pad + region + 1` equals the terminal height and the composer always occupies the
+  last two rows. The measurement is one `ESC[6n` before the first frame (raw mode
+  raised first, or the reply is line-buffered and echoed), with a one-off fill to the
+  bottom row as the fallback for terminals that never answer. The pad belongs to the
+  erasable block and never reaches the scrollback. `anchor: unknown` (no TTY, no
+  filter, no answer, or geometry lost after a foreign write) stays byte-identical to
+  the previous release. Re-probes are debounced 200 ms after a resize, coalesced, and
+  switched off the moment the screen is handed back - a query there would leak
+  `^[[12;1R` onto the shell prompt. `/perf`'s `scrollback` line now also reports
+  `block`/`pad` rows, `anchor bottom via probe|fill|none` and `anchor reprobes`.
 - **A long answer lost two characters at every hard wrap point - silently, in
   exactly the content a user copies out.** The transcript's content column had no
   width of its own, so Yoga laid each line out at the width it computed from the