@aragon-agent/cli 0.5.8 → 0.5.9

package/dist/ui/transcript-text.js

@@ -7,6 +7,7 @@
  * simply print everything twice.
  */
 import { formatCost, formatDuration, formatTokens } from '../agent/usage.js';
+import { formatRetryLine } from '../agent/retry-view.js';
 const DEFAULT_MAX_ENTRIES = 200;
 const CONTINUATION_INDENT = '  ';
 const TOOL_INDENT = '  ';
@@ -84,6 +85,32 @@ function renderEntry(entry, glyphs) {
             ];
             return lines;
         }
+        case 'retry': {
+            // A turn that spent three minutes retrying is exactly the kind of cost an
+            // exported transcript is supposed to account for — the same argument the
+            // `team` case above makes in its own words. This file's `default: return []`
+            // means the addition is a CHOICE rather than a compile requirement, and it is
+            // worth making: without it a replay of a session that lost two minutes to a
+            // 529 shows a gap and no reason for it.
+            const glyph = entry.phase === 'exhausted' ? glyphs.error : glyphs.retry;
+            return [
+                `${TOOL_INDENT}${glyph} ${formatRetryLine(entry, glyphs, Date.now())}`,
+            ];
+        }
+        case 'fast': {
+            // Reviews are real spend and real advice, and an exported transcript that
+            // omitted them would be unaccountable for both — the argument the `team`
+            // and `retry` cases above each make in their own words.
+            const glyph = entry.status === 'failed' ? glyphs.toolError : glyphs.toolDone;
+            const duration = entry.durationMs === undefined ? '' : ` (${entry.durationMs}ms)`;
+            const head = `${TOOL_INDENT}${glyph} fast review #${entry.reviewIndex} ${entry.model} ` +
+                `turn ${entry.turn}${duration}`;
+            if (entry.status === 'advice' && entry.text) {
+                return [head, ...entry.text.split('\n').map((l) => `${TOOL_INDENT}${CONTINUATION_INDENT}${l}`)];
+            }
+            const detail = entry.detail ? `: ${entry.detail}` : '';
+            return [`${head} ${entry.status}${detail}`];
+        }
         case 'notice': {
             const glyph = entry.level === 'error'
                 ? glyphs.error

package/dist/ui/use-wheel-routing.d.ts

@@ -1,31 +1,26 @@
 /**
- * Wheel routing (mouse-wheel-region-routing §4.6 / §4.7).
+ * Wheel routing (wheel-scrolls-transcript-only §4.1).
  *
- * Subscribes to the mouse source, turns each wheel notch into a band via
- * `hitTestWheel`, and dispatches it to the transcript, an open overlay, or the
- * prompt-history stepper. Lives outside `App.tsx` because that file is exactly
- * at the 1000-line ceiling `CLAUDE.md` sets, and because the routing table is
- * the most testable part of this feature and does not want to be inside a
- * 1000-line component (D-13).
+ * Subscribes to the mouse source and dispatches every notch to THE ONE
+ * SCROLLABLE REGION ON SCREEN — the transcript, or the controlled overlay
+ * covering it. Lives outside `App.tsx` because the routing table is the most
+ * testable part of this feature and a table wants to be readable on its own,
+ * away from a large component (D-13).
  *
- * THE TWO BANDS HAVE DIFFERENT PHYSICS, and that is the requirement rather than
- * a tuning choice (§4.7). A physical notch produces ONE SGR report, whereas
- * alternate-scroll used to produce three arrow keys:
+ * THE POINTER ROW IS NOT CONSULTED, and that is the requirement rather than a
+ * simplification (§1). A wheel notch is a VIEWPORT gesture: the pointer in a
+ * TUI rests wherever the user last left it — in a chat-shaped app, next to the
+ * thing they type into — so routing by row meant the ordinary "scroll back to
+ * see what the agent just did" gesture landed on the composer and replaced the
+ * draft with an old prompt. Prompt history belongs to `↑` / `↓` alone (G1 / G3),
+ * which is the contract Claude Code, Codex and every full-screen terminal app
+ * the user brings muscle memory from already follow.
  *
- *  - transcript: 3 rows per notch, matching the terminal's own convention and
- *    the muscle memory users bring from every other full-screen app;
- *  - composer: exactly ONE history step per notch. Multiplying here would make
- *    a single flick jump three prompts back — unusable, and destructive when a
- *    draft is in play.
- *
- * Bursts are handled differently for the same reason: transcript events are
- * coalesced into one intent carrying `repeat`, composer events never are (they
- * are rate-limited by the human, and each must produce its own visible step).
+ * Every notch is coalesced into one intent carrying `repeat`, no matter how fast
+ * the wheel spins: one gesture, one `setState`, one render.
  */
-import { type MutableRefObject } from 'react';
 import type { Overlay } from '../agent/reducer.js';
 import type { MouseSource } from '../input/stdin-mouse-filter.js';
-import { type FrameGeometry } from './layout/regions.js';
 import type { ScrollIntent } from './layout/scroll.js';
 /**
  * Rows a PgUp/PgDn — and a Shift+wheel notch — moves inside a controlled
@@ -37,22 +32,11 @@ export declare const OVERLAY_PAGE = 8;
 export interface WheelRoutingOptions {
     /** Absent when mouse support is off, in inline mode, or on a non-TTY. */
     mouseSource?: MouseSource;
-    /** Live frame geometry, written by `AppShell`'s layout effect (§4.5). */
-    geometryRef: MutableRefObject<FrameGeometry>;
-    /**
-     * Test-only seam (§8.2): when set, the router reads this instead of the
-     * measured ref, so a routing test never depends on `measureElement` working
-     * under `ink-testing-library` — a dependency no other test in this package
-     * exercises, and one that would make a routing regression present as a
-     * measurement flake.
-     */
-    geometryOverride?: FrameGeometry;
     /** Read at EVENT time for the routing branch, and again at FLUSH time (P1-3). */
     getOverlay: () => Overlay | null;
     onScroll: (kind: ScrollIntent, repeat: number) => void;
     /** Signed row delta; the caller clamps at 0 the way the keyboard branch does. */
     onOverlayScroll: (delta: number) => void;
-    onHistoryStep: (dir: 'up' | 'down') => void;
 }
 export interface WheelRouting {
     /**

package/dist/ui/use-wheel-routing.js

@@ -1,29 +1,25 @@
 /**
- * Wheel routing (mouse-wheel-region-routing §4.6 / §4.7).
+ * Wheel routing (wheel-scrolls-transcript-only §4.1).
  *
- * Subscribes to the mouse source, turns each wheel notch into a band via
- * `hitTestWheel`, and dispatches it to the transcript, an open overlay, or the
- * prompt-history stepper. Lives outside `App.tsx` because that file is exactly
- * at the 1000-line ceiling `CLAUDE.md` sets, and because the routing table is
- * the most testable part of this feature and does not want to be inside a
- * 1000-line component (D-13).
+ * Subscribes to the mouse source and dispatches every notch to THE ONE
+ * SCROLLABLE REGION ON SCREEN — the transcript, or the controlled overlay
+ * covering it. Lives outside `App.tsx` because the routing table is the most
+ * testable part of this feature and a table wants to be readable on its own,
+ * away from a large component (D-13).
  *
- * THE TWO BANDS HAVE DIFFERENT PHYSICS, and that is the requirement rather than
- * a tuning choice (§4.7). A physical notch produces ONE SGR report, whereas
- * alternate-scroll used to produce three arrow keys:
+ * THE POINTER ROW IS NOT CONSULTED, and that is the requirement rather than a
+ * simplification (§1). A wheel notch is a VIEWPORT gesture: the pointer in a
+ * TUI rests wherever the user last left it — in a chat-shaped app, next to the
+ * thing they type into — so routing by row meant the ordinary "scroll back to
+ * see what the agent just did" gesture landed on the composer and replaced the
+ * draft with an old prompt. Prompt history belongs to `↑` / `↓` alone (G1 / G3),
+ * which is the contract Claude Code, Codex and every full-screen terminal app
+ * the user brings muscle memory from already follow.
  *
- *  - transcript: 3 rows per notch, matching the terminal's own convention and
- *    the muscle memory users bring from every other full-screen app;
- *  - composer: exactly ONE history step per notch. Multiplying here would make
- *    a single flick jump three prompts back — unusable, and destructive when a
- *    draft is in play.
- *
- * Bursts are handled differently for the same reason: transcript events are
- * coalesced into one intent carrying `repeat`, composer events never are (they
- * are rate-limited by the human, and each must produce its own visible step).
+ * Every notch is coalesced into one intent carrying `repeat`, no matter how fast
+ * the wheel spins: one gesture, one `setState`, one render.
  */
 import { useCallback, useEffect, useRef } from 'react';
-import { hitTestWheel } from './layout/regions.js';
 /**
  * Rows a PgUp/PgDn — and a Shift+wheel notch — moves inside a controlled
  * overlay. Declared here rather than in `App.tsx` because both the keyboard
@@ -89,42 +85,29 @@ export function useWheelRouting(options) {
     }, [flush]);
     const route = useCallback((event) => {
         const current = optionsRef.current;
-        const geometry = current.geometryOverride ?? current.geometryRef.current;
-        const band = hitTestWheel(event.y, geometry);
         const overlay = current.getOverlay();
-        // THE OVERLAY BRANCH IS EVALUATED FIRST AND RETURNS FOR EVERY BAND IT
+        // THE OVERLAY BRANCH IS EVALUATED FIRST AND RETURNS FOR EVERY OVERLAY IT
         // RECOGNIZES — the same two ordering rules the keyboard handler follows,
         // and for the same reason (R-P1-7).
         if (overlay) {
-            // The composer is inactive behind an overlay; stepping a hidden draft
-            // is worse than doing nothing.
-            if (band !== 'content')
-                return;
             // Modes A only. `model` / `confirm` / `question` own their own keys and
             // scrolling them would leave an inconsistent cursor (R-11).
             const controlled = overlay === 'help' || overlay === 'settings' || overlay === 'plan';
             if (!controlled)
                 return;
+            // D-3: the row is not consulted here either. Behind an overlay the
+            // composer is inactive and the overlay is the only scrollable thing on
+            // screen, so a notch anywhere scrolls it.
             const step = event.shift ? OVERLAY_PAGE : OVERLAY_LINES_PER_NOTCH;
             current.onOverlayScroll(event.dir === 'up' ? -step : step);
             return;
         }
-        if (band === 'composer') {
-            // §4.7: the accumulator flushes when the BAND changes, not only when
-            // the direction does. The composer path is never coalesced, so without
-            // this the transcript scroll that preceded the pointer moving down
-            // lands ~16 ms AFTER the history step it happened before — the two
-            // halves of one gesture, applied out of order.
-            flush();
-            current.onHistoryStep(event.dir);
-            return;
-        }
         if (event.shift) {
             accumulate(event.dir === 'up' ? 'pageUp' : 'pageDown', 1);
             return;
         }
         accumulate(event.dir === 'up' ? 'lineUp' : 'lineDown', CONTENT_LINES_PER_NOTCH);
-    }, [accumulate, flush]);
+    }, [accumulate]);
     const { mouseSource } = options;
     useEffect(() => {
         if (!mouseSource)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aragon-agent/cli",
-  "version": "0.5.8",
+  "version": "0.5.9",
   "description": "AragonAgent CLI — a Claude-Code / Codex-style interactive terminal UI (TUI) on top of the @aragon-agent/core engine. Installable and runnable via npm / npx.",
   "license": "MIT",
   "author": "AragonAgent contributors",
@@ -52,7 +52,7 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@aragon-agent/core": "^0.2.8",
+    "@aragon-agent/core": "^0.2.9",
     "chalk": "^5.6.2",
     "cli-highlight": "^2.0.0",
     "commander": "^12.1.0",

package/dist/ui/layout/regions.d.ts

@@ -1,55 +0,0 @@
-/**
- * Wheel band hit-testing (mouse-wheel-region-routing §4.5) — pure, React-free.
- *
- * The requirement is stated in terms of REGIONS ("scrolling over the agent area
- * scrolls the transcript; scrolling over the input box steps prompt history"),
- * so the router needs to turn a reported terminal row into one of two bands.
- *
- * The boundary is MEASURED, never computed from `budget.ts`. That arithmetic
- * describes the PLANNED chrome, but the real bottom chrome grows and shrinks at
- * run time: the toast row comes and goes, the hint row is dropped below
- * `HINT_MIN_ROWS`, and the autocomplete popup adds up to nine rows. Routing off
- * the plan would put the boundary in the wrong place exactly when the popup is
- * open — the moment precision matters most (D-5 / D-16).
- */
-export type WheelBand = 'content' | 'composer';
-export interface FrameGeometry {
-    /**
-     * 1-based row of the frame's first row. 1 in the alternate screen.
-     *
-     * This is DERIVED, not assumed, and it has a named dependency: it holds
-     * because the full-screen transcript renders no `<Static>`
-     * (`Transcript.tsx`), so Ink's `log-update` writes `frameHeight(rows) = rows-1`
-     * lines plus a newline into a `rows`-row buffer — nothing scrolls, and the
-     * frame sits at rows `1 … rows-1` with the cursor parked on the undrawn last
-     * row. Reintroducing `<Static>` into the full-screen path pushes the frame
-     * down the screen and silently biases every hit test; whoever does that has
-     * to change `top` here at the same time.
-     */
-    top: number;
-    /** Rows the frame occupies — `frameHeight(rows)`. */
-    height: number;
-    /** Measured rows of the bottom chrome (toast + composer + status). */
-    bottom: number;
-}
-/**
- * The "I do not know where the frame is" value.
- *
- * `App` writes it into the geometry ref on every render path that does NOT
- * render the full-screen `AppShell` — the terminal-too-small placeholder and
- * inline mode — so a stale measurement can never outlive the frame it
- * described. There is deliberately no arithmetic fallback: an unmeasured frame
- * routes to `'content'`, which is the band that cannot destroy anything, and
- * one invisible frame after a resize is a better failure than a wrong band
- * (§4.5, P1-5 / D-16).
- */
-export declare const UNMEASURED_GEOMETRY: FrameGeometry;
-/**
- * Which band does terminal row `y` belong to?
- *
- * Fails toward `'content'`: the whole point of this feature is that a wheel
- * notch must never edit the user's draft (I-3), so every degenerate input —
- * nothing measured yet, a row outside the frame, a chrome measurement that
- * swallowed the screen — resolves to the harmless direction.
- */
-export declare function hitTestWheel(y: number, geometry: FrameGeometry): WheelBand;

package/dist/ui/layout/regions.js

@@ -1,52 +0,0 @@
-/**
- * Wheel band hit-testing (mouse-wheel-region-routing §4.5) — pure, React-free.
- *
- * The requirement is stated in terms of REGIONS ("scrolling over the agent area
- * scrolls the transcript; scrolling over the input box steps prompt history"),
- * so the router needs to turn a reported terminal row into one of two bands.
- *
- * The boundary is MEASURED, never computed from `budget.ts`. That arithmetic
- * describes the PLANNED chrome, but the real bottom chrome grows and shrinks at
- * run time: the toast row comes and goes, the hint row is dropped below
- * `HINT_MIN_ROWS`, and the autocomplete popup adds up to nine rows. Routing off
- * the plan would put the boundary in the wrong place exactly when the popup is
- * open — the moment precision matters most (D-5 / D-16).
- */
-/**
- * The "I do not know where the frame is" value.
- *
- * `App` writes it into the geometry ref on every render path that does NOT
- * render the full-screen `AppShell` — the terminal-too-small placeholder and
- * inline mode — so a stale measurement can never outlive the frame it
- * described. There is deliberately no arithmetic fallback: an unmeasured frame
- * routes to `'content'`, which is the band that cannot destroy anything, and
- * one invisible frame after a resize is a better failure than a wrong band
- * (§4.5, P1-5 / D-16).
- */
-export const UNMEASURED_GEOMETRY = { top: 1, height: 0, bottom: 0 };
-/**
- * Which band does terminal row `y` belong to?
- *
- * Fails toward `'content'`: the whole point of this feature is that a wheel
- * notch must never edit the user's draft (I-3), so every degenerate input —
- * nothing measured yet, a row outside the frame, a chrome measurement that
- * swallowed the screen — resolves to the harmless direction.
- */
-export function hitTestWheel(y, geometry) {
-    const { top, height } = geometry;
-    if (!Number.isFinite(height) || height <= 0)
-        return 'content';
-    if (!Number.isFinite(y))
-        return 'content';
-    // Clamp into the frame so the one undrawn bottom row — and any off-by-one
-    // from a terminal that reports 0-based rows — lands on a real band instead of
-    // being dropped.
-    const row = Math.min(Math.max(Math.floor(y), top), top + height - 1);
-    // I-6: at least one content row always survives. This clamp is a backstop
-    // that should never fire, and that is checkable rather than hopeful: the
-    // completion popup is capped at `viewportRows(rows) - 4`, so the measured
-    // chrome tops out at `rows - 6` against a frame of `rows - 1` — five content
-    // rows survive the worst case the layout can produce.
-    const bottom = Math.min(Math.max(Math.floor(geometry.bottom) || 0, 0), height - 1);
-    return row >= top + height - bottom ? 'composer' : 'content';
-}