@aragon-agent/cli 0.6.7 → 0.6.8

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

@@ -1,29 +1,4 @@
-/**
- * Layout budget (spec §4.2a) — the ONE function that says how many rows the
- * viewport gets.
- *
- * Before v0.4.0 this number was computed nowhere and assumed in three places,
- * which is how the viewport ended up NON-MONOTONIC in `rows`: growing the
- * terminal from 27 to 28 rows promoted the header to the 8-row wordmark tier and
- * the visible content SHRANK from 18 rows to 13. Making the brand region a
- * constant 1 row (§4.2) is what fixes that, and this module is where the fix is
- * expressed as arithmetic so `budget.test.ts` can pin it.
- *
- * Deliberately NOT part of `frame.ts`: that file is the read-only foundation
- * (invariant I-1) and this is content-layer policy.
- *
- * Scope: the STATIC chrome only. One consumer is dynamic and is handled by the
- * degradation ladder in §5.2 instead of being averaged in here:
- *  - `AutocompletePopup` expands the bottom chrome by up to 9 rows.
- *
- * `ScrollViewport`'s "N new lines" hint used to be listed here as a second
- * dynamic consumer. It no longer exists: the number renders as a chip on the
- * composer's input row (tui-selection-and-scroll-follow §4.2), which costs
- * COLUMNS rather than rows. The arithmetic below is unchanged — the hint was
- * never in the budget in the first place — but leaving the bullet in place would
- * make this comment a true-sounding statement about a row that is gone (AC-12,
- * and the `wheel-scrolls-transcript-only` RV-3 lesson).
- */
+/** Fullscreen reserves three fixed rows; composer height is a footer layout input. */
 /** Below this many rows the composer's hint line is dropped to buy back a row. */
 export declare const HINT_MIN_ROWS = 20;
 export interface ChromeBudget {
@@ -50,28 +25,5 @@ export interface ChromeBudget {
  */
 export declare function clampDraftRows(rows: number, draftRows: number): number;
 export declare function chromeBudget(rows: number, draftRows?: number): ChromeBudget;
-/**
- * Rows available to the viewport at a given terminal height.
- *
- * Note what is NOT a parameter: whether the transcript is empty. The absence of
- * that argument is the guarantee that the first submitted message cannot make
- * the layout jump (A-4). Do not add it back.
- *
- * `draftRows` IS NOT THAT ARGUMENT, and the distinction is the whole of D-12.
- * A-4 forbids making the budget depend on TRANSCRIPT content, so that the first
- * submitted message cannot move the layout. `draftRows` depends only on what the
- * user is typing right now, and its whole purpose is that the jump is ALREADY
- * HAPPENING -- Yoga takes the rows out of the transcript whether or not this
- * function was told. `App` adds the hysteresis (grow now, shrink one tick later)
- * that keeps it from becoming per-keystroke jitter.
- *
- * It DEFAULTS TO 1, i.e. to the constant this function used to assume, so every
- * pre-existing caller and every pre-existing assertion is byte-identical -- and
- * `viewportRows.length` stays 1, because a parameter with a default does not
- * count toward it.
- *
- * Non-decreasing in `rows` at a fixed `draftRows = 1`: the one step where chrome
- * grows (the hint row at `HINT_MIN_ROWS`) coincides with `rows` growing by one,
- * so the net change is 0 rather than -1.
- */
-export declare function viewportRows(rows: number, draftRows?: number): number;
+/** Shared document height; the legacy draft argument remains source-compatible. */
+export declare function viewportRows(rows: number, _draftRows?: number): number;

package/dist/ui/layout/budget.js

@@ -1,29 +1,4 @@
-/**
- * Layout budget (spec §4.2a) — the ONE function that says how many rows the
- * viewport gets.
- *
- * Before v0.4.0 this number was computed nowhere and assumed in three places,
- * which is how the viewport ended up NON-MONOTONIC in `rows`: growing the
- * terminal from 27 to 28 rows promoted the header to the 8-row wordmark tier and
- * the visible content SHRANK from 18 rows to 13. Making the brand region a
- * constant 1 row (§4.2) is what fixes that, and this module is where the fix is
- * expressed as arithmetic so `budget.test.ts` can pin it.
- *
- * Deliberately NOT part of `frame.ts`: that file is the read-only foundation
- * (invariant I-1) and this is content-layer policy.
- *
- * Scope: the STATIC chrome only. One consumer is dynamic and is handled by the
- * degradation ladder in §5.2 instead of being averaged in here:
- *  - `AutocompletePopup` expands the bottom chrome by up to 9 rows.
- *
- * `ScrollViewport`'s "N new lines" hint used to be listed here as a second
- * dynamic consumer. It no longer exists: the number renders as a chip on the
- * composer's input row (tui-selection-and-scroll-follow §4.2), which costs
- * COLUMNS rather than rows. The arithmetic below is unchanged — the hint was
- * never in the budget in the first place — but leaving the bullet in place would
- * make this comment a true-sounding statement about a row that is gone (AC-12,
- * and the `wheel-scrolls-transcript-only` RV-3 lesson).
- */
+/** Fullscreen reserves three fixed rows; composer height is a footer layout input. */
 import { draftMaxRows } from '../composer-limits.js';
 import { frameHeight, MIN_FULLSCREEN_ROWS } from './frame.js';
 /** Below this many rows the composer's hint line is dropped to buy back a row. */
@@ -47,33 +22,9 @@ export function chromeBudget(rows, draftRows = 1) {
         status: 1,
     };
 }
-/**
- * Rows available to the viewport at a given terminal height.
- *
- * Note what is NOT a parameter: whether the transcript is empty. The absence of
- * that argument is the guarantee that the first submitted message cannot make
- * the layout jump (A-4). Do not add it back.
- *
- * `draftRows` IS NOT THAT ARGUMENT, and the distinction is the whole of D-12.
- * A-4 forbids making the budget depend on TRANSCRIPT content, so that the first
- * submitted message cannot move the layout. `draftRows` depends only on what the
- * user is typing right now, and its whole purpose is that the jump is ALREADY
- * HAPPENING -- Yoga takes the rows out of the transcript whether or not this
- * function was told. `App` adds the hysteresis (grow now, shrink one tick later)
- * that keeps it from becoming per-keystroke jitter.
- *
- * It DEFAULTS TO 1, i.e. to the constant this function used to assume, so every
- * pre-existing caller and every pre-existing assertion is byte-identical -- and
- * `viewportRows.length` stays 1, because a parameter with a default does not
- * count toward it.
- *
- * Non-decreasing in `rows` at a fixed `draftRows = 1`: the one step where chrome
- * grows (the hint row at `HINT_MIN_ROWS`) coincides with `rows` growing by one,
- * so the net change is 0 rather than -1.
- */
-export function viewportRows(rows, draftRows = 1) {
+/** Shared document height; the legacy draft argument remains source-compatible. */
+export function viewportRows(rows, _draftRows = 1) {
     if (!Number.isFinite(rows) || rows < MIN_FULLSCREEN_ROWS)
         return 0;
-    const c = chromeBudget(rows, draftRows);
-    return Math.max(0, frameHeight(rows) - c.header - c.toast - c.composer - c.status);
+    return Math.max(0, frameHeight(rows) - 3);
 }

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

@@ -0,0 +1,13 @@
+export interface DocumentLayoutInput {
+    rows: number;
+    bodyRows: number;
+    footerRows: number;
+}
+export interface DocumentLayout {
+    viewportRows: number;
+    paddingRows: number;
+    contentRows: number;
+    trailingContentRows: number;
+}
+/** Allocate the shared document, filling short sessions before the editor. */
+export declare function buildDocumentLayout(input: DocumentLayoutInput): DocumentLayout;

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

@@ -0,0 +1,11 @@
+import { frameHeight } from './frame.js';
+/** Allocate the shared document, filling short sessions before the editor. */
+export function buildDocumentLayout(input) {
+    const count = (n) => Number.isFinite(n) ? Math.max(0, Math.floor(n)) : 0;
+    const viewportRows = count(input.rows) > 0 ? Math.max(0, frameHeight(count(input.rows)) - 3) : 0;
+    const body = count(input.bodyRows);
+    const footer = count(input.footerRows);
+    const paddingRows = Math.max(0, viewportRows - body - footer);
+    return { viewportRows, paddingRows, contentRows: body + paddingRows + footer,
+        trailingContentRows: paddingRows + footer };
+}

package/dist/ui/layout/follow-state.d.ts

@@ -58,6 +58,7 @@ export interface FollowInput {
     overflowLines: number;
     /** Signed: rows appended at (or removed from) the tail since the last frame. */
     tailDelta: number;
+    layoutTailDelta?: number;
     /** True while a selection drag holds the viewport (§4.4). */
     hold: boolean;
     newLinesWhilePaused: number;

package/dist/ui/layout/follow-state.js

@@ -74,9 +74,7 @@ export function reduceFollow(input) {
     // of the drag (T-20).
     if (offset === 0 && !hold)
         return { offset, newLinesWhilePaused: 0 };
-    if (tailDelta === 0)
-        return { offset, newLinesWhilePaused: input.newLinesWhilePaused };
-    const next = clampScroll(offset + tailDelta, overflowLines);
+    const next = clampScroll(offset + tailDelta + (input.layoutTailDelta ?? 0), overflowLines);
     return {
         offset: next,
         // Only real arrivals arm the resume timer, and reaching the bottom by ANY

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/todo-layout.d.ts

@@ -8,6 +8,7 @@ export interface TodoRailLayoutInput {
     viewportBudget: number;
     teamRows: number;
     popupRows: number;
+    composerBaseRows?: number;
 }
 export interface TodoRailLayout {
     visible: boolean;

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

@@ -8,9 +8,10 @@ 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);
+    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 = budget - teamRows - popupRows;
+    const rows = input.mode === 'fullscreen' ? budget : budget - teamRows - popupRows;
     const width = todoRailWidth(cols);
     const reason = input.mode !== 'fullscreen' ? 'inline'
         : !input.panelEnabled ? 'disabled'

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/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.7",
+  "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.19",
+    "@aragon-agent/core": "^0.2.20",
     "chalk": "^5.6.2",
     "cli-highlight": "^2.0.0",
     "commander": "^12.1.0",