@aragon-agent/cli 0.6.4 → 0.6.8

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

@@ -1,56 +1,7 @@
-/**
- * Rail geometry (todo-plan-execution §3.9) — the ONE place that says how wide
- * and how tall the todo rail is allowed to be.
- *
- * Pure and React-free, mirroring `budget.ts`, so `todo-rail.test.ts` can pin the
- * arithmetic without mounting anything. Deliberately NOT part of `budget.ts`:
- * that module answers "how many ROWS does the viewport get" and stays a function
- * of `rows` alone; the rail spends COLUMNS.
- *
- * NAMED FOR ITS POSITION, NOT ITS CONTENT, like `AppShellProps.rail` (D-18):
- * this is a layout primitive and `viewportRows` is its neighbour, not
- * `TodoPanel`.
- */
-/** Below this the marker + a two-word title do not fit and the column is noise. */
-export declare const TODO_RAIL_MIN_COLS = 18;
-/**
- * Above this, 20% is being spent on whitespace: at 36 columns a step title
- * already fits on one line, and the transcript is the surface that benefits from
- * a 200-column terminal. A deliberate, revertible deviation from a literal
- * reading of R-e; it only binds above 180 columns.
- */
+export declare const TODO_RAIL_MIN_COLS = 14;
 export declare const TODO_RAIL_MAX_COLS = 36;
-/** Under 80 columns the transcript needs every column; no rail at all. */
-export declare const TODO_RAIL_MIN_TOTAL_COLS = 80;
-/** Below this rail width the 2-column index prefix is dropped for content. */
+export declare const TODO_TRANSCRIPT_MIN_COLS = 62;
+export declare const TODO_RAIL_MIN_TOTAL_COLS: number;
 export declare const TODO_RAIL_INDEX_MIN_COLS = 22;
-/**
- * Two properties are pinned by tests, for the reason `budget.ts` records about
- * the viewport being non-monotonic before anyone measured it:
- *
- *  - NON-DECREASING in `cols` across [40, 300]. A user dragging a window wider
- *    must never see the rail get narrower.
- *  - `cols - todoRailWidth(cols) >= 62` for every `cols >= 80`. Every existing
- *    width heuristic inside the viewport (`TERSE_HINT_COLS` 42,
- *    `MIN_INDICATOR_COLS` 50, the status bar's 60/72 steps) sits below that
- *    floor, so no existing behaviour changes because a rail appeared (R-3).
- */
+/** Return a non-decreasing rail width; invalid or narrow terminals have no rail. */
 export declare function todoRailWidth(cols: number): number;
-/**
- * How many rows the rail may actually draw.
- *
- * IT IS NOT `viewportBudget`, AND THE DIFFERENCE IS NOT COSMETIC (P1-3 / D-23).
- * `viewportRows()` subtracts the STATIC chrome only, and says so; the live team
- * roster is mounted inside `AppShell`'s measured bottom box, where it costs a
- * header row, up to `TEAM_LIMITS.panelMaxRows` child rows, a `+N more` row and a
- * mail row that `viewportBudget` knows nothing about. `ScrollViewport` is immune
- * because it MEASURES itself; the rail does not measure - a second
- * measure -> setState -> measure loop is exactly what §1.2 refuses - so it has
- * to subtract.
- *
- * Ink clips overflow from the BOTTOM, so an over-request does not error: it
- * silently eats the last row, which is the `+N below` marker - the one row whose
- * absence is indistinguishable from "the list is short". That is why this is
- * arithmetic rather than a shrug at `overflow: hidden`.
- */
-export declare function todoRailRows(viewportBudget: number, teamActive: boolean): number;

package/dist/ui/layout/rail.js

@@ -1,68 +1,16 @@
-/**
- * Rail geometry (todo-plan-execution §3.9) — the ONE place that says how wide
- * and how tall the todo rail is allowed to be.
- *
- * Pure and React-free, mirroring `budget.ts`, so `todo-rail.test.ts` can pin the
- * arithmetic without mounting anything. Deliberately NOT part of `budget.ts`:
- * that module answers "how many ROWS does the viewport get" and stays a function
- * of `rows` alone; the rail spends COLUMNS.
- *
- * NAMED FOR ITS POSITION, NOT ITS CONTENT, like `AppShellProps.rail` (D-18):
- * this is a layout primitive and `viewportRows` is its neighbour, not
- * `TodoPanel`.
- */
-import { TODO_LIMITS } from '../../todo/limits.js';
-/** R-e, literally: the rail asks for a fifth of the terminal. */
-const RAIL_FRACTION = 0.2;
-/** Below this the marker + a two-word title do not fit and the column is noise. */
-export const TODO_RAIL_MIN_COLS = 18;
-/**
- * Above this, 20% is being spent on whitespace: at 36 columns a step title
- * already fits on one line, and the transcript is the surface that benefits from
- * a 200-column terminal. A deliberate, revertible deviation from a literal
- * reading of R-e; it only binds above 180 columns.
- */
+/** Responsive TODO rail widths, measured in terminal columns including chrome. */
+const RAIL_FRACTION = 0.15;
+export const TODO_RAIL_MIN_COLS = 14;
 export const TODO_RAIL_MAX_COLS = 36;
-/** Under 80 columns the transcript needs every column; no rail at all. */
-export const TODO_RAIL_MIN_TOTAL_COLS = 80;
-/** Below this rail width the 2-column index prefix is dropped for content. */
+export const TODO_TRANSCRIPT_MIN_COLS = 62;
+export const TODO_RAIL_MIN_TOTAL_COLS = TODO_TRANSCRIPT_MIN_COLS + TODO_RAIL_MIN_COLS;
 export const TODO_RAIL_INDEX_MIN_COLS = 22;
-/**
- * Two properties are pinned by tests, for the reason `budget.ts` records about
- * the viewport being non-monotonic before anyone measured it:
- *
- *  - NON-DECREASING in `cols` across [40, 300]. A user dragging a window wider
- *    must never see the rail get narrower.
- *  - `cols - todoRailWidth(cols) >= 62` for every `cols >= 80`. Every existing
- *    width heuristic inside the viewport (`TERSE_HINT_COLS` 42,
- *    `MIN_INDICATOR_COLS` 50, the status bar's 60/72 steps) sits below that
- *    floor, so no existing behaviour changes because a rail appeared (R-3).
- */
+/** Return a non-decreasing rail width; invalid or narrow terminals have no rail. */
 export function todoRailWidth(cols) {
-    if (!Number.isFinite(cols) || cols < TODO_RAIL_MIN_TOTAL_COLS)
+    if (!Number.isFinite(cols))
         return 0;
-    return Math.min(TODO_RAIL_MAX_COLS, Math.max(TODO_RAIL_MIN_COLS, Math.round(cols * RAIL_FRACTION)));
-}
-/**
- * How many rows the rail may actually draw.
- *
- * IT IS NOT `viewportBudget`, AND THE DIFFERENCE IS NOT COSMETIC (P1-3 / D-23).
- * `viewportRows()` subtracts the STATIC chrome only, and says so; the live team
- * roster is mounted inside `AppShell`'s measured bottom box, where it costs a
- * header row, up to `TEAM_LIMITS.panelMaxRows` child rows, a `+N more` row and a
- * mail row that `viewportBudget` knows nothing about. `ScrollViewport` is immune
- * because it MEASURES itself; the rail does not measure - a second
- * measure -> setState -> measure loop is exactly what §1.2 refuses - so it has
- * to subtract.
- *
- * Ink clips overflow from the BOTTOM, so an over-request does not error: it
- * silently eats the last row, which is the `+N below` marker - the one row whose
- * absence is indistinguishable from "the list is short". That is why this is
- * arithmetic rather than a shrug at `overflow: hidden`.
- */
-export function todoRailRows(viewportBudget, teamActive) {
-    if (!Number.isFinite(viewportBudget))
+    const columns = Math.floor(cols);
+    if (columns < TODO_RAIL_MIN_TOTAL_COLS)
         return 0;
-    const reserved = teamActive ? TODO_LIMITS.railReservedRows : 0;
-    return Math.max(0, viewportBudget - reserved);
+    return Math.min(TODO_RAIL_MAX_COLS, Math.max(TODO_RAIL_MIN_COLS, Math.round(columns * RAIL_FRACTION)));
 }

package/dist/ui/layout/scroll-indicator.d.ts

@@ -24,4 +24,4 @@ export interface ThumbRange {
  * gets a one-row thumb, because an indicator that vanishes at exactly the
  * moment the transcript is longest is worse than no indicator at all.
  */
-export declare function thumbRange(viewportRows: number, contentRows: number, offsetFromBottom: number): ThumbRange | null;
+export declare function thumbRange(viewportRows: number, contentRows: number, offsetFromBottom: number, reserveTravel?: boolean): ThumbRange | null;

package/dist/ui/layout/scroll-indicator.js

@@ -18,7 +18,7 @@
  * gets a one-row thumb, because an indicator that vanishes at exactly the
  * moment the transcript is longest is worse than no indicator at all.
  */
-export function thumbRange(viewportRows, contentRows, offsetFromBottom) {
+export function thumbRange(viewportRows, contentRows, offsetFromBottom, reserveTravel = false) {
     const viewport = Math.floor(viewportRows);
     const content = Math.floor(contentRows);
     if (!Number.isFinite(viewport) || !Number.isFinite(content))
@@ -27,7 +27,8 @@ export function thumbRange(viewportRows, contentRows, offsetFromBottom) {
         return null;
     const overflow = content - viewport;
     const offset = Math.min(Math.max(Math.floor(offsetFromBottom) || 0, 0), overflow);
-    const size = Math.min(viewport, Math.max(1, Math.round((viewport * viewport) / content)));
+    const maximum = reserveTravel && viewport >= 2 ? viewport - 1 : viewport;
+    const size = Math.min(maximum, Math.max(1, Math.round((viewport * viewport) / content)));
     const travel = viewport - size;
     const hiddenAbove = overflow - offset;
     const start = travel <= 0 ? 0 : Math.round((hiddenAbove / overflow) * travel);

package/dist/ui/layout/scrollbar-geometry.d.ts

@@ -0,0 +1,17 @@
+import type { ThumbRange } from './scroll-indicator.js';
+export interface ScrollbarGeometry {
+    trackTop: number;
+    trackCol: number;
+    trackRows: number;
+    contentRows: number;
+    offset: number;
+    thumb: ThumbRange | null;
+    revision: number;
+}
+export interface ThumbOffsetInput {
+    geometry: ScrollbarGeometry;
+    pointerY: number;
+    grabRow: number;
+}
+/** Convert a captured pointer to a bottom-relative offset, with exact endpoints. */
+export declare function offsetForThumb({ geometry: g, pointerY, grabRow }: ThumbOffsetInput): number;

package/dist/ui/layout/scrollbar-geometry.js

@@ -0,0 +1,13 @@
+/** Convert a captured pointer to a bottom-relative offset, with exact endpoints. */
+export function offsetForThumb({ geometry: g, pointerY, grabRow }) {
+    const values = [g.trackTop, g.trackRows, g.contentRows, pointerY, grabRow];
+    if (!values.every(Number.isFinite) || !g.thumb)
+        return g.offset;
+    const overflow = Math.max(0, g.contentRows - g.trackRows);
+    const travel = g.trackRows - g.thumb.size;
+    if (travel <= 0 || overflow === 0)
+        return g.offset;
+    const grab = Math.min(Math.max(0, Math.floor(grabRow)), g.thumb.size - 1);
+    const top = Math.min(travel, Math.max(0, Math.floor(pointerY) - g.trackTop - grab));
+    return overflow - Math.round(top / travel * overflow);
+}

package/dist/ui/layout/team-panel.d.ts

@@ -0,0 +1,18 @@
+import type { SubagentRun, TeamSnapshot } from '../../team/types.js';
+export interface TeamPanelLayout {
+    collapsed: boolean;
+    rowCount: number;
+    visible: SubagentRun[];
+    hiddenTotal: number;
+    hiddenRunning: number;
+}
+export interface TeamPanelLayoutInput {
+    snapshot: TeamSnapshot | null;
+    terminalRows: number;
+    availableRows: number;
+}
+/** Project actual roster rows, preserving three middle rows when expanded.
+ * Invalid geometry becomes zero; legacy callers may pass positive Infinity
+ * for an unlimited available-row budget. Does not throw or mutate the snapshot.
+ */
+export declare function buildTeamPanelLayout(input: TeamPanelLayoutInput): TeamPanelLayout;

package/dist/ui/layout/team-panel.js

@@ -0,0 +1,22 @@
+import { TEAM_LIMITS } from '../../team/limits.js';
+import { selectPanelRows } from '../../team/panel-rows.js';
+import { TODO_LIMITS } from '../../todo/limits.js';
+/** Project actual roster rows, preserving three middle rows when expanded.
+ * Invalid geometry becomes zero; legacy callers may pass positive Infinity
+ * for an unlimited available-row budget. Does not throw or mutate the snapshot.
+ */
+export function buildTeamPanelLayout(input) {
+    const available = input.availableRows === Infinity ? Infinity : nonNegativeInt(input.availableRows);
+    if (!input.snapshot || available < 1) {
+        return { collapsed: true, rowCount: 0, visible: [], hiddenTotal: 0, hiddenRunning: 0 };
+    }
+    const selection = selectPanelRows(input.snapshot.runs, TEAM_LIMITS.panelMaxRows);
+    const natural = 1 + selection.visible.length + Number(selection.hiddenTotal > 0)
+        + Number(Boolean(input.snapshot.lastMessage));
+    const collapsed = nonNegativeInt(input.terminalRows) < TEAM_LIMITS.panelCollapseRows
+        || available - natural < TODO_LIMITS.panelMinRows;
+    return { ...selection, collapsed, rowCount: collapsed ? 1 : natural };
+}
+function nonNegativeInt(value) {
+    return Number.isFinite(value) ? Math.max(0, Math.floor(value)) : 0;
+}

package/dist/ui/layout/todo-layout.d.ts

@@ -0,0 +1,25 @@
+import type { RenderMode } from './frame.js';
+export interface TodoRailLayoutInput {
+    mode: RenderMode;
+    cols: number;
+    panelEnabled: boolean;
+    overlayOpen: boolean;
+    itemCount: number;
+    viewportBudget: number;
+    teamRows: number;
+    popupRows: number;
+    composerBaseRows?: number;
+}
+export interface TodoRailLayout {
+    visible: boolean;
+    reason: 'visible' | 'inline' | 'disabled' | 'overlay' | 'empty' | 'narrow' | 'short';
+    width: number;
+    rows: number;
+    contentCols: number;
+    popupMaxHeight: number;
+}
+/** Allocate columns and rows from the same team/menu projections as the renderers.
+ * Invalid geometry becomes zero, excess team/menu rows are clamped. Menu capacity
+ * never depends on menu occupancy or rail visibility, preventing feedback loops.
+ */
+export declare function buildTodoRailLayout(input: TodoRailLayoutInput): TodoRailLayout;

package/dist/ui/layout/todo-layout.js

@@ -0,0 +1,28 @@
+import { TODO_LIMITS } from '../../todo/limits.js';
+import { todoRailWidth } from './rail.js';
+/** Allocate columns and rows from the same team/menu projections as the renderers.
+ * Invalid geometry becomes zero, excess team/menu rows are clamped. Menu capacity
+ * never depends on menu occupancy or rail visibility, preventing feedback loops.
+ */
+export function buildTodoRailLayout(input) {
+    const cols = nonNegativeInt(input.cols);
+    const budget = nonNegativeInt(input.viewportBudget);
+    const teamRows = Math.min(budget, nonNegativeInt(input.teamRows));
+    const popupMaxHeight = Math.max(0, budget - teamRows - TODO_LIMITS.panelMinRows
+        - nonNegativeInt(input.composerBaseRows ?? 0));
+    const popupRows = popupMaxHeight < 3 ? 0 : Math.min(nonNegativeInt(input.popupRows), popupMaxHeight);
+    const rows = input.mode === 'fullscreen' ? budget : budget - teamRows - popupRows;
+    const width = todoRailWidth(cols);
+    const reason = input.mode !== 'fullscreen' ? 'inline'
+        : !input.panelEnabled ? 'disabled'
+            : input.overlayOpen ? 'overlay'
+                : nonNegativeInt(input.itemCount) === 0 ? 'empty'
+                    : width === 0 ? 'narrow'
+                        : rows < TODO_LIMITS.panelMinRows ? 'short'
+                            : 'visible';
+    const visible = reason === 'visible';
+    return { visible, reason, width, rows, contentCols: cols - (visible ? width : 0), popupMaxHeight };
+}
+function nonNegativeInt(value) {
+    return Number.isFinite(value) ? Math.max(0, Math.floor(value)) : 0;
+}

package/dist/ui/layout/viewport-geometry.d.ts

@@ -17,6 +17,7 @@ export interface ViewportGeometry {
     offset: number;
     /** Natural (unclipped) height of the content, in rows. */
     contentRows: number;
+    trailingContentRows?: number;
 }
 /**
  * The default is the UNMEASURED geometry, and consumers must treat it as such:

package/dist/ui/layout/viewport-geometry.js

@@ -21,6 +21,7 @@ export const ViewportGeometryContext = createContext({
     viewportRows: 0,
     offset: 0,
     contentRows: 0,
+    trailingContentRows: 0,
 });
 export function useViewportGeometry() {
     return useContext(ViewportGeometryContext);

package/dist/ui/layout/virtual-window.d.ts

@@ -98,6 +98,7 @@ export interface WindowSelection {
     totalRows: number;
 }
 export interface SelectWindowInput {
+    trailingContentRows?: number;
     entries: readonly Entry[];
     /** Measured, else estimated; never 0 for a real entry. */
     heightOf: (index: number) => number;

package/dist/ui/layout/virtual-window.js

@@ -352,7 +352,7 @@ export function selectWindow(input) {
     const viewport = Math.max(1, Math.floor(input.viewportRows) || 0);
     const offset = Math.max(0, Math.floor(input.offset) || 0);
     const overscan = Math.max(VIRTUAL_LIMITS.overscan, Math.floor(input.overscan) || 0);
-    const bottom = totalRows - offset;
+    const bottom = totalRows + (input.trailingContentRows ?? 0) - offset;
     const top = bottom - viewport;
     let start = n - 1;
     let acc = 0;

package/dist/ui/overlays/HelpOverlay.js

@@ -6,7 +6,9 @@ function keyRows(times) {
     return [
         ['Enter', 'Submit (idle) / queue steering (running); re-pins to the newest output'],
         ['Alt+Enter / Shift+Enter', 'Insert newline'],
-        ['Esc', 'Abort run / close overlay'],
+        ['Esc', 'Close menu / overlay'],
+        ['Esc twice', 'Interrupt run (within 1.5s)'],
+        ['Esc again', 'Force-stop after requesting interruption'],
         // BOTH KEYS ARE LISTED HERE, and this row is why (shift-tab-mode-toggle-
         // still-dead-on-windows, review R-7). The hint row above the composer is the
         // other place the fallback is named, and it has two off-switches - a short
@@ -24,7 +26,8 @@ function keyRows(times) {
         // Drag-select is the one affordance here a user cannot discover by pressing
         // a key, so it has to be named somewhere they can look it up. The one-shot
         // startup notice is the other place, and it scrolls away.
-        ['Drag (left button)', 'Select text on screen; releasing copies it'],
+        ['Drag right edge', 'Scroll messages and input together; type to return'],
+        ['Drag text (left button)', 'Select text on screen; releasing copies it'],
         ['Up / Down', 'Prompt history (empty input)'],
         // Pasting is the one affordance here with no key of its own, so the only
         // place a user can learn what happened to their 218 lines is this row.

package/dist/ui/screen.d.ts

@@ -43,7 +43,7 @@ export interface AltScreenOptions {
      *
      * SAME "ALREADY DECIDED ELSEWHERE" DISCIPLINE AS `mouse`: this module must
      * never derive it from config. `cli.tsx` passes
-     * `mouseFilter !== null && cfg.mouseSelect`.
+     * `mouseOn`, after the filter and VT capability have been resolved.
      *
      * Optional, defaulting to `false`, so every pre-existing caller and every
      * pre-existing test emits exactly the bytes it emitted before (AC-8 / T-34).

package/dist/ui/screen.js

@@ -23,18 +23,16 @@ const SHOW_CURSOR = '\x1b[?25h';
  * text rather than raw bytes above 0x7F that `setEncoding('utf8')` would mangle.
  *
  * `?1002` is BUTTON-EVENT TRACKING: motion is reported ONLY WHILE A BUTTON IS
- * HELD, which is what drag-select needs and costs exactly zero reports while the
+ * HELD, which both scrollbar dragging and text selection need and costs exactly zero reports while the
  * pointer is idle. This comment used to lump it together with `?1003` and
  * dismiss both as "floods stdin on every pointer move" — true of `?1003`
  * (any-event), false of `?1002`, and the sentence had to go in the same commit
  * that started asking for it or it would stand as a documented reason not to
  * (AC-11 / D-10).
  *
- * IT IS GATED ON `motion`, i.e. on the resolved `mouseSelect` capability, and
- * that is what makes "S3 is revertible" a byte-level fact rather than a claim:
- * with drag-select off the sequences below are byte-identical to the constants
- * they replaced (AC-8 / D-15). `disableMouse` is the exact reverse of
- * `enableMouse` for both values (I-1 / AC-7).
+ * Motion is enabled with mouse reporting, independently of text selection.
+ * Disabling selection must still allow scrollbar gestures. The enable/disable
+ * sequences remain paired for both values of this resolved capability.
  */
 const enableMouse = (motion) => `\x1b[?1000h${motion ? '\x1b[?1002h' : ''}\x1b[?1006h`;
 const disableMouse = (motion) => `\x1b[?1006l${motion ? '\x1b[?1002l' : ''}\x1b[?1000l`;

package/dist/ui/scrollbar-controller.d.ts

@@ -0,0 +1,30 @@
+import type { MouseEvent } from '../input/mouse-events.js';
+import { type ScrollbarGeometry } from './layout/scrollbar-geometry.js';
+export interface ScrollbarController {
+    handle(event: MouseEvent): boolean;
+    cancel(): void;
+    dispose(): void;
+    isCaptured(): boolean;
+}
+export interface ScrollbarOptions {
+    getGeometry(): ScrollbarGeometry | null;
+    setOffset(offset: number): void;
+    page(direction: 'pageUp' | 'pageDown'): void;
+    onHold(held: boolean): void;
+    onStart(): void;
+    isEnabled(): boolean;
+}
+export interface ScrollbarBridge {
+    controller: ScrollbarController | null;
+    geometry: ScrollbarGeometry | null;
+    frameReady: boolean;
+    isEnabled(): boolean;
+    onStart?: () => void;
+    onGeometry?: () => void;
+    requestRedraw?: () => void;
+    invalidate(): void;
+}
+/** Build the late-bound terminal bridge; no scroll position is owned here. */
+export declare function createScrollbarBridge(isEnabled: () => boolean): ScrollbarBridge;
+/** Own one pointer gesture and bounded timers; positioning remains in the viewport. */
+export declare function createScrollbarController(options: ScrollbarOptions): ScrollbarController;

package/dist/ui/scrollbar-controller.js

@@ -0,0 +1,124 @@
+import { offsetForThumb } from './layout/scrollbar-geometry.js';
+/** Build the late-bound terminal bridge; no scroll position is owned here. */
+export function createScrollbarBridge(isEnabled) {
+    const bridge = {
+        controller: null, geometry: null, frameReady: false, isEnabled,
+        invalidate: () => { bridge.frameReady = false; bridge.controller?.cancel(); },
+    };
+    return bridge;
+}
+/** Own one pointer gesture and bounded timers; positioning remains in the viewport. */
+export function createScrollbarController(options) {
+    return new ScrollbarGesture(options);
+}
+class ScrollbarGesture {
+    options;
+    capture = null;
+    timer = null;
+    watchdog = null;
+    swallowLate = false;
+    disposed = false;
+    constructor(options) {
+        this.options = options;
+    }
+    isCaptured() { return this.capture !== null; }
+    cancel() {
+        if (this.timer)
+            clearTimeout(this.timer);
+        if (this.watchdog)
+            clearTimeout(this.watchdog);
+        this.timer = this.watchdog = null;
+        const held = this.capture !== null;
+        this.capture = null;
+        if (held) {
+            this.swallowLate = true;
+            this.options.onHold(false);
+        }
+    }
+    dispose() { this.cancel(); this.disposed = true; }
+    armWatchdog() {
+        if (this.watchdog)
+            clearTimeout(this.watchdog);
+        this.watchdog = setTimeout(() => this.cancel(), 30000);
+        this.watchdog.unref?.();
+    }
+    flush() {
+        if (this.timer)
+            clearTimeout(this.timer);
+        this.timer = null;
+        const g = this.options.getGeometry();
+        if (!this.capture || !g || !this.options.isEnabled() ||
+            g.revision !== this.capture.revision) {
+            this.cancel();
+            return;
+        }
+        const y = this.capture.pendingY;
+        this.capture.pendingY = null;
+        if (y !== null)
+            this.options.setOffset(offsetForThumb({ geometry: g,
+                pointerY: y, grabRow: this.capture.grabRow }));
+    }
+    move(y) {
+        if (!this.capture || this.capture.kind !== 'thumb' || y === this.capture.lastPointerY)
+            return;
+        this.capture.lastPointerY = y;
+        this.capture.pendingY = y;
+        if (!this.timer) {
+            this.timer = setTimeout(() => this.flush(), 16);
+            this.timer.unref?.();
+        }
+    }
+    press(event) {
+        this.cancel();
+        this.swallowLate = false;
+        const g = this.options.getGeometry();
+        if (!g || !this.canPress(event, g))
+            return false;
+        const row = event.y - g.trackTop;
+        const thumb = g.thumb;
+        const inside = thumb && row >= thumb.start && row < thumb.start + thumb.size;
+        this.capture = { kind: inside && g.trackRows > thumb.size ? 'thumb' : 'track',
+            grabRow: inside ? row - thumb.start : 0, revision: g.revision,
+            lastPointerY: event.y, pendingY: null };
+        this.options.onStart();
+        this.options.onHold(true);
+        this.armWatchdog();
+        if (thumb && !inside)
+            this.options.page(row < thumb.start ? 'pageUp' : 'pageDown');
+        return true;
+    }
+    canPress(event, g) {
+        const plainLeft = event.button === 0 && !event.shift && !event.alt && !event.ctrl;
+        const inTrack = event.x === g.trackCol && event.y >= g.trackTop &&
+            event.y < g.trackTop + g.trackRows;
+        return this.options.isEnabled() && plainLeft && inTrack;
+    }
+    handle(event) {
+        if (this.disposed)
+            return false;
+        if (event.kind === 'wheel')
+            return this.capture !== null;
+        if (![event.x, event.y].every(Number.isFinite))
+            return this.capture !== null;
+        if (event.kind === 'press')
+            return this.press(event);
+        if (!this.capture)
+            return this.swallowLate;
+        if (event.button !== 0) {
+            this.cancel();
+            return false;
+        }
+        if (!this.options.isEnabled()) {
+            this.cancel();
+            return true;
+        }
+        this.move(event.y);
+        if (event.kind === 'release') {
+            this.flush();
+            this.cancel();
+        }
+        else
+            this.armWatchdog();
+        return true;
+    }
+}

package/dist/ui/transcript-text.js

@@ -6,7 +6,7 @@
  * transcript in the terminal's native scrollback, and replaying there would
  * simply print everything twice.
  */
-import { formatCost, formatDuration, formatTokens } from '../agent/usage.js';
+import { formatCost, formatDuration, formatTokens, promptTokensOf } from '../agent/usage.js';
 import { formatRetryLine } from '../agent/retry-view.js';
 const DEFAULT_MAX_ENTRIES = 200;
 const CONTINUATION_INDENT = '  ';
@@ -199,7 +199,11 @@ function renderEntry(entry, glyphs) {
 export function renderTranscriptText(entries, opts) {
     const turns = entries.filter((e) => e.kind === 'user').length;
     const g = opts.glyphs;
-    const tokens = `${formatTokens(opts.usageTotal.inputTokens)}${g.arrowUp} ${formatTokens(opts.usageTotal.outputTokens)}${g.arrowDown}`;
+    // THE SAME PROMPT-SIDE TOTAL THE STATUS BAR SHOWS (context-usage-gauge-accuracy
+    // §3.6). This line is what a user compares against the bar they were watching a
+    // second earlier, so a different unit here would look like the exit summary
+    // losing tokens.
+    const tokens = `${formatTokens(promptTokensOf(opts.usageTotal))}${g.arrowUp} ${formatTokens(opts.usageTotal.outputTokens)}${g.arrowDown}`;
     const summary = [
         'aragon',
         `${opts.provider}:${opts.model}`,

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

@@ -30,6 +30,8 @@ import type { ScrollIntent } from './layout/scroll.js';
  */
 export declare const OVERLAY_PAGE = 8;
 export interface WheelRoutingOptions {
+    isPointerCaptured?: () => boolean;
+    isActive?: () => boolean;
     /** Absent when mouse support is off, in inline mode, or on a non-TTY. */
     mouseSource?: MouseSource;
     /** Read at EVENT time for the routing branch, and again at FLUSH time (P1-3). */

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

@@ -61,6 +61,8 @@ export function useWheelRouting(options) {
         accumulator.current = null;
         if (!pending)
             return;
+        if (optionsRef.current.isPointerCaptured?.() || optionsRef.current.isActive?.() === false)
+            return;
         // P1-3: THE DECISION BELONGS AT FLUSH TIME, not at event time, because the
         // event-time decision is the one that goes stale. `App` swaps
         // `ScrollViewport` out for an overlay, and 16 ms is more than wide enough
@@ -93,6 +95,10 @@ export function useWheelRouting(options) {
         if (event.kind !== 'wheel')
             return;
         const current = optionsRef.current;
+        if (current.isPointerCaptured?.() || current.isActive?.() === false) {
+            clearCoalescer();
+            return;
+        }
         const overlay = current.getOverlay();
         // THE OVERLAY BRANCH IS EVALUATED FIRST AND RETURNS FOR EVERY OVERLAY IT
         // RECOGNIZES — the same two ordering rules the keyboard handler follows,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aragon-agent/cli",
-  "version": "0.6.4",
+  "version": "0.6.8",
   "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",
@@ -56,7 +56,7 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@aragon-agent/core": "^0.2.16",
+    "@aragon-agent/core": "^0.2.20",
     "chalk": "^5.6.2",
     "cli-highlight": "^2.0.0",
     "commander": "^12.1.0",