@aragon-agent/cli 0.6.7 → 0.6.9

package/dist/ui/layout/frame.js

@@ -37,39 +37,3 @@ export function frameHeight(rows) {
     const r = rows && rows > 0 ? rows : FALLBACK_ROWS;
     return Math.max(0, r - 1);
 }
-/** `CI=` / `CI=0` / `CI=false` are not CI; anything else non-empty is. */
-function isTruthyEnv(value) {
-    if (value === undefined)
-        return false;
-    const v = value.trim().toLowerCase();
-    return v.length > 0 && v !== '0' && v !== 'false';
-}
-/**
- * Decide the render mode once, at startup (never re-decided at run time —
- * entering/leaving the alt-screen mid-session is a state machine we do not want).
- *
- * Order is semantics, not style:
- *  1. an explicit opt-out always wins (users can always get v0.2.0 back);
- *  2. `isTTY` is the one gate `--fullscreen` cannot override — writing ANSI into
- *     a pipe or a redirected file is a contract violation, whereas a heuristic
- *     misfire only costs polish;
- *  3. the explicit force comes next so it can beat the heuristics below;
- *  4. heuristics (TERM/CI/size), all overridable by `--fullscreen`.
- */
-export function decideRenderMode(flags, env, stdout) {
-    if (flags.fullscreen === false)
-        return 'inline';
-    if (!stdout?.isTTY)
-        return 'inline';
-    if (flags.fullscreen === true)
-        return 'fullscreen';
-    if (env.TERM === 'dumb')
-        return 'inline';
-    if (isTruthyEnv(env.CI))
-        return 'inline';
-    if ((stdout.rows ?? 0) < MIN_FULLSCREEN_ROWS)
-        return 'inline';
-    if ((stdout.columns ?? 0) < MIN_FULLSCREEN_COLS)
-        return 'inline';
-    return 'fullscreen';
-}

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

@@ -1,6 +1,4 @@
-import type { RenderMode } from './frame.js';
 export interface TodoRailLayoutInput {
-    mode: RenderMode;
     cols: number;
     panelEnabled: boolean;
     overlayOpen: boolean;
@@ -8,10 +6,11 @@ export interface TodoRailLayoutInput {
     viewportBudget: number;
     teamRows: number;
     popupRows: number;
+    composerBaseRows?: number;
 }
 export interface TodoRailLayout {
     visible: boolean;
-    reason: 'visible' | 'inline' | 'disabled' | 'overlay' | 'empty' | 'narrow' | 'short';
+    reason: 'visible' | 'disabled' | 'overlay' | 'empty' | 'narrow' | 'short';
     width: number;
     rows: number;
     contentCols: number;

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

@@ -8,17 +8,17 @@ 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 = budget;
     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 reason = !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 };
 }

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

@@ -17,10 +17,11 @@ 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:
- * a `TranscriptList` rendered outside a `ScrollViewport` (inline mode, and every
+ * a `TranscriptList` rendered outside a `ScrollViewport` (including
  * test that mounts it bare) sees `viewportRows: 0`, which `selectWindow` reads
  * as "first frame" and answers by pinning the live tail.
  */

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

@@ -13,7 +13,7 @@
 import { createContext, useContext } from 'react';
 /**
  * The default is the UNMEASURED geometry, and consumers must treat it as such:
- * a `TranscriptList` rendered outside a `ScrollViewport` (inline mode, and every
+ * a `TranscriptList` rendered outside a `ScrollViewport` (including
  * test that mounts it bare) sees `viewportRows: 0`, which `selectWindow` reads
  * as "first frame" and answers by pinning the live tail.
  */
@@ -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/live-clamp.d.ts

@@ -1,32 +1,4 @@
-/**
- * Live-region clamp for INLINE render mode (tui-render-performance L5 / R6).
- *
- * Inline mode has no fixed frame, so nothing kept its live (non-`<Static>`)
- * region shorter than the terminal. When one live entry grew taller than
- * `stdout.rows`, Ink took the branch at `ink.js:118-123`:
- *
- *     if (outputHeight >= this.options.stdout.rows) {
- *       stdout.write(clearTerminal + this.fullStaticOutput + output);
- *     }
- *
- * `fullStaticOutput` accumulates EVERY `<Static>` frame of the whole session and
- * is never trimmed, so once that branch is taken it is taken on every subsequent
- * frame — bypassing both the `output !== lastOutput` dedupe and `throttledLog` —
- * and the terminal receives the entire session history thirty times a second.
- * That is a genuine hard freeze, and it is reachable today by any inline user
- * (`--no-fullscreen`, `TERM=dumb`, CI, a short or narrow terminal) whose model
- * writes a long answer.
- *
- * I-L5-1 — keeping the live region strictly below `stdout.rows` makes that
- * branch UNREACHABLE, which is the inline analogue of `frame.ts`'s
- * `frameHeight(r) < r` and deserves the same standing. We cannot bound Ink's
- * `fullStaticOutput` growth (it is private and append-only); preventing the
- * branch that WRITES it is the entire mitigation, and nothing about the memory
- * it holds is fixed by this module.
- *
- * Nothing is lost, only deferred: when the entry settles it moves into
- * `<Static>` and is printed in full.
- */
+/** Keep the newest thinking lines visible while an assistant entry streams. */
 export interface LiveClamp {
     text: string;
     /** Rows dropped off the FRONT. `0` means the text was returned untouched. */

package/dist/ui/live-clamp.js

@@ -1,32 +1,4 @@
-/**
- * Live-region clamp for INLINE render mode (tui-render-performance L5 / R6).
- *
- * Inline mode has no fixed frame, so nothing kept its live (non-`<Static>`)
- * region shorter than the terminal. When one live entry grew taller than
- * `stdout.rows`, Ink took the branch at `ink.js:118-123`:
- *
- *     if (outputHeight >= this.options.stdout.rows) {
- *       stdout.write(clearTerminal + this.fullStaticOutput + output);
- *     }
- *
- * `fullStaticOutput` accumulates EVERY `<Static>` frame of the whole session and
- * is never trimmed, so once that branch is taken it is taken on every subsequent
- * frame — bypassing both the `output !== lastOutput` dedupe and `throttledLog` —
- * and the terminal receives the entire session history thirty times a second.
- * That is a genuine hard freeze, and it is reachable today by any inline user
- * (`--no-fullscreen`, `TERM=dumb`, CI, a short or narrow terminal) whose model
- * writes a long answer.
- *
- * I-L5-1 — keeping the live region strictly below `stdout.rows` makes that
- * branch UNREACHABLE, which is the inline analogue of `frame.ts`'s
- * `frameHeight(r) < r` and deserves the same standing. We cannot bound Ink's
- * `fullStaticOutput` growth (it is private and append-only); preventing the
- * branch that WRITES it is the entire mitigation, and nothing about the memory
- * it holds is fixed by this module.
- *
- * Nothing is lost, only deferred: when the entry settles it moves into
- * `<Static>` and is printed in full.
- */
+/** Keep the newest thinking lines visible while an assistant entry streams. */
 /**
  * Keep the LAST `maxRows` rows of `text`; report how many were dropped.
  *

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,9 @@ 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'],
+        ['Run status row', 'Spinner and steer / interrupt keys, above the input during a run'],
+        ['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/run-status-row.d.ts

@@ -0,0 +1,61 @@
+/**
+ * The run status row's width plan (tui-scrollbar-edge-and-run-row §3.3.3).
+ *
+ * While a run is in flight, ONE row above the input box carries the spinner, the
+ * phrase and the `steer / interrupt / exit` hint clauses, and `planRunRow` decides
+ * what survives when the line is too narrow. It is a pure function with no React
+ * and no I/O so the whole ladder can be tested as arithmetic.
+ *
+ * THE ALLOCATION IS PER CLAUSE, NOT PER STRING, and that is the whole point.
+ * The idle hint row this one replaces owned the full line width and ended in
+ * `wrap="truncate"`; handing the label half the line and truncating the joined
+ * hint would cut `interrupt` to `inter...` at 38 columns - a regression of the
+ * "running hint is NEVER abbreviated" rule `Composer.hintText` documents. So:
+ *
+ *  - clauses are dropped WHOLE, from the tail (`exit`, then `stop N`), and
+ *  - `steer` and `interrupt` (REQUIRED_CLAUSES) are never dropped or cut mid-word
+ *    while the row is enabled, and
+ *  - the only thing allowed to end in an ellipsis is the label.
+ */
+/** Everything the label needs, kept in one shape so there is one place that names it. */
+export interface RunActivity {
+    /** Epoch ms the current run began - the phrase sequence's seed. */
+    startedAt: number;
+    /** `Date.now() - startedAt`, already computed by App's 200 ms ticker. */
+    elapsedMs: number;
+    /** The RAW config flag, never the widened one (single-spinner D-5). */
+    reducedMotion: boolean;
+    /** The tool currently in flight, if any. */
+    runningTool?: string;
+    /** A context compaction is in flight; outranks the tool name and the phrase. */
+    compacting?: boolean;
+}
+export interface RunRowPlanInput {
+    /** Width of the row's container (the composer's content columns). */
+    cols: number;
+    /** Spinner + space + label, in display columns (the label's natural width). */
+    labelCols: number;
+    /** Display width of each hint clause, most urgent first. */
+    hintClauseCols: readonly number[];
+    /** Display width of the separator between clauses (` · ` or ` - `). */
+    separatorCols: number;
+    /** Display width of the right-aligned mode chip; 0 = no chip. */
+    chipCols: number;
+}
+export interface RunRowPlan {
+    /** Columns the label may occupy; below its natural width it is ellipsized. */
+    labelCols: number;
+    /** How many leading clauses to show; 0 = none (defensive tier only). */
+    hintClauses: number;
+    /** Whether the chip fits after everything else. */
+    chip: boolean;
+}
+/** One leading space, matching the idle hint row's `'  '` indent. */
+export declare const RUN_ROW_LEAD = 1;
+/** Narrowest the label may be squeezed before a clause is dropped instead. */
+export declare const RUN_ROW_MIN_LABEL_COLS = 10;
+/** `steer` and `interrupt`: always whole while the row is enabled. */
+export declare const RUN_ROW_REQUIRED_CLAUSES = 2;
+/** Space kept between the last clause and the chip. */
+export declare const RUN_ROW_CHIP_GAP = 2;
+export declare function planRunRow(input: RunRowPlanInput): RunRowPlan;

package/dist/ui/run-status-row.js

@@ -0,0 +1,70 @@
+/**
+ * The run status row's width plan (tui-scrollbar-edge-and-run-row §3.3.3).
+ *
+ * While a run is in flight, ONE row above the input box carries the spinner, the
+ * phrase and the `steer / interrupt / exit` hint clauses, and `planRunRow` decides
+ * what survives when the line is too narrow. It is a pure function with no React
+ * and no I/O so the whole ladder can be tested as arithmetic.
+ *
+ * THE ALLOCATION IS PER CLAUSE, NOT PER STRING, and that is the whole point.
+ * The idle hint row this one replaces owned the full line width and ended in
+ * `wrap="truncate"`; handing the label half the line and truncating the joined
+ * hint would cut `interrupt` to `inter...` at 38 columns - a regression of the
+ * "running hint is NEVER abbreviated" rule `Composer.hintText` documents. So:
+ *
+ *  - clauses are dropped WHOLE, from the tail (`exit`, then `stop N`), and
+ *  - `steer` and `interrupt` (REQUIRED_CLAUSES) are never dropped or cut mid-word
+ *    while the row is enabled, and
+ *  - the only thing allowed to end in an ellipsis is the label.
+ */
+/** One leading space, matching the idle hint row's `'  '` indent. */
+export const RUN_ROW_LEAD = 1;
+/** Narrowest the label may be squeezed before a clause is dropped instead. */
+export const RUN_ROW_MIN_LABEL_COLS = 10;
+/** `steer` and `interrupt`: always whole while the row is enabled. */
+export const RUN_ROW_REQUIRED_CLAUSES = 2;
+/** Space kept between the last clause and the chip. */
+export const RUN_ROW_CHIP_GAP = 2;
+/** Non-finite or negative widths collapse to 0 so no input can make the plan throw. */
+function width(value) {
+    return Number.isFinite(value) && value > 0 ? Math.floor(value) : 0;
+}
+/** Width of the first `count` clauses joined by `separator`. */
+function clausesWidth(clauses, count, separator) {
+    if (count <= 0)
+        return 0;
+    let total = separator * (count - 1);
+    for (let i = 0; i < count; i += 1)
+        total += clauses[i] ?? 0;
+    return total;
+}
+export function planRunRow(input) {
+    const inner = Math.max(0, width(input.cols) - RUN_ROW_LEAD);
+    const natural = width(input.labelCols);
+    const separator = width(input.separatorCols);
+    const chipCols = width(input.chipCols);
+    const clauses = input.hintClauseCols.map(width);
+    const total = clauses.length;
+    const labelOnly = {
+        labelCols: Math.min(natural, inner), hintClauses: 0, chip: false,
+    };
+    if (total < RUN_ROW_REQUIRED_CLAUSES)
+        return labelOnly;
+    // Tier 1: everything fits; the chip is the first thing to go.
+    const everything = natural + separator + clausesWidth(clauses, total, separator);
+    if (everything <= inner) {
+        const chip = chipCols > 0 && everything + RUN_ROW_CHIP_GAP + chipCols <= inner;
+        return { labelCols: natural, hintClauses: total, chip };
+    }
+    // Tier 2: drop clauses from the tail, but never below the required two; only the
+    // label may be squeezed (down to its minimum) to make the remaining clauses fit.
+    for (let kept = total - 1; kept >= RUN_ROW_REQUIRED_CLAUSES; kept -= 1) {
+        const available = inner - separator - clausesWidth(clauses, kept, separator);
+        if (available >= RUN_ROW_MIN_LABEL_COLS) {
+            return { labelCols: Math.min(natural, available), hintClauses: kept, chip: false };
+        }
+    }
+    // Tier 3 (defensive, below ~40 columns): the label alone. The status bar's own
+    // `Esc x2 interrupt` carries the urgent hint at this width.
+    return labelOnly;
+}

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.d.ts

@@ -1,11 +1,3 @@
-/**
- * Plain-text session rendering (spec §4.4). Pure, colorless, ANSI-free, so the
- * exit replay can be piped, diffed, or pasted into an issue.
- *
- * Used only by the full-screen exit replay: inline mode already left the real
- * transcript in the terminal's native scrollback, and replaying there would
- * simply print everything twice.
- */
 import type { Entry, UsageTotal } from '../agent/reducer.js';
 import type { Glyphs } from './glyphs.js';
 export interface TranscriptTextOptions {

package/dist/ui/transcript-text.js

@@ -1,11 +1,3 @@
-/**
- * Plain-text session rendering (spec §4.4). Pure, colorless, ANSI-free, so the
- * exit replay can be piped, diffed, or pasted into an issue.
- *
- * Used only by the full-screen exit replay: inline mode already left the real
- * transcript in the terminal's native scrollback, and replaying there would
- * simply print everything twice.
- */
 import { formatCost, formatDuration, formatTokens, promptTokensOf } from '../agent/usage.js';
 import { formatRetryLine } from '../agent/retry-view.js';
 const DEFAULT_MAX_ENTRIES = 200;