@aragon-agent/cli 0.6.7 → 0.6.9

package/dist/ui/frame-differ.js

@@ -25,6 +25,12 @@
  *    trailing `CSI K` removes only the residue a longer previous line left, and
  *    the trailing SGR reset before it stops a BCE terminal painting that residue
  *    in whatever background colour the line ended inside.
+ *    `CSI K` IS EMITTED ONLY WHEN THE LINE IS NARROWER THAN THE TERMINAL. A row
+ *    that already fills every column (the unified scrollbar paints the last one)
+ *    has no residue to clear, and on terminals that keep the cursor ON the last
+ *    column after writing it (a pending-wrap flag rather than a virtual column
+ *    N+1) the EL would erase the cell that was just written. `cols` unknown keeps
+ *    the old always-EL behaviour (`paintLine`).
  *  - I-5 · Every emitted batch ends parked on row `H+1`. Ink's own
  *    `previousLineCount` is computed from the string IT produced and is
  *    unaffected by what we actually wrote, so a later pass-through's
@@ -37,7 +43,10 @@
  *    the guard being absent is a permanently misaligned screen while the failure
  *    mode of it firing spuriously is one extra full repaint.
  */
+import stringWidth from 'string-width';
+import stripAnsi from 'strip-ansi';
 import { MIN_FULLSCREEN_ROWS } from './layout/frame.js';
+import { matchInkErasePrefix } from './frame-parser.js';
 // ---------------------------------------------------------------------------
 // Constants — exact, so no call site ever re-derives an escape sequence.
 // ---------------------------------------------------------------------------
@@ -55,20 +64,25 @@ const ERASE_DOWN = `${CSI}J`;
 /** DEC private mode 2026 — begin/end synchronized update (F2, §3.3). */
 const SYNC_BEGIN = `${CSI}?2026h`;
 const SYNC_END = `${CSI}?2026l`;
+function cursorTo(row) {
+    return `${CSI}${row};1H`;
+}
 /**
- * `eraseLines(n)` for any n ≥ 1, anchored at the start of the chunk.
+ * One addressed row: `CUP · SGR0 · line · SGR0 [· CSI K]` (I-4).
  *
- * FALLBACK ONLY (P2-3). Whenever `prev !== null` the differ already knows the
- * exact prefix it expects — `eraseLinesPrefix(prev.length + 1)` is a
- * deterministic string — so the hot path is `chunk.startsWith(expected)`:
- * linear, unambiguous, and it collapses step 7's `erased !== prev.length + 1`
- * test into the same comparison. This regex is reached only on the first
- * diffable chunk after a session start or an `invalidate()`, where no
- * expectation exists yet.
+ * The trailing `CSI K` clears residue a longer previous line left behind, so it is
+ * only meaningful when the line is narrower than the terminal. A line that already
+ * fills `cols` columns ends with the cursor in the pending-wrap state, where some
+ * terminals run EL from the LAST column and erase the cell just written; those
+ * rows get no EL. Width is measured exactly as Ink measures it (`string-width` over
+ * the ANSI-stripped text) and only for rows that changed, so it costs at most one
+ * measurement per changed viewport row. `cols` unknown => the original always-EL.
  */
-const ERASE_PREFIX_RE = /^(?:\x1b\[2K(?:\x1b\[1A)?)+\x1b\[G/;
-function cursorTo(row) {
-    return `${CSI}${row};1H`;
+function paintLine(row, line, cols) {
+    const head = cursorTo(row) + SGR_RESET + line + SGR_RESET;
+    if (cols !== undefined && stringWidth(stripAnsi(line)) >= cols)
+        return head;
+    return head + ERASE_TO_EOL;
 }
 /**
  * Rebuild `ansiEscapes.eraseLines(count)` byte for byte.
@@ -88,9 +102,6 @@ export function eraseLinesPrefix(count) {
     }
     return out + CURSOR_LEFT;
 }
-function countErases(prefix) {
-    return prefix.split(ERASE_LINE).length - 1;
-}
 export function createFrameDiffer(options) {
     /**
      * Last frame AS PAINTED — what is actually on the screen.
@@ -200,10 +211,7 @@ export function createFrameDiffer(options) {
             if (chunk.startsWith(expected))
                 return { prefix: expected, erased: prev.length + 1 };
         }
-        const m = ERASE_PREFIX_RE.exec(chunk);
-        if (m === null)
-            return null;
-        return { prefix: m[0], erased: countErases(m[0]) };
+        return matchInkErasePrefix(chunk);
     };
     /**
      * Full repaint — the first diffable frame of a session, every invalidation
@@ -228,13 +236,18 @@ export function createFrameDiffer(options) {
             cursorTo(lines.length + 1);
         return emit(wrapSync(payload), lines, raw, lines.length, true);
     };
+    /** Terminal width for this paint, or `undefined` when unknown (I-4: always EL). */
+    const liveCols = () => {
+        const cols = options.cols?.();
+        return cols !== undefined && Number.isFinite(cols) ? cols : undefined;
+    };
     const diffRepaint = (lines, raw, previous) => {
         const out = [];
+        const cols = liveCols();
         for (let i = 0; i < lines.length; i += 1) {
             // I-4: paint, THEN clear the tail. Never `ERASE_LINE` first.
-            if (lines[i] !== previous[i]) {
-                out.push(cursorTo(i + 1) + SGR_RESET + lines[i] + SGR_RESET + ERASE_TO_EOL);
-            }
+            if (lines[i] !== previous[i])
+                out.push(paintLine(i + 1, lines[i], cols));
         }
         // DEFENSIVE ONLY, not a live path (P2-4). `log-update.js:13-15` returns early
         // on an identical frame, so a chunk that reaches here differs by at least one
@@ -268,10 +281,10 @@ export function createFrameDiffer(options) {
             return '';
         const painted = applyDecorate(rawPrev);
         const out = [];
+        const cols = liveCols();
         for (let i = 0; i < painted.length; i += 1) {
-            if (painted[i] !== prev[i]) {
-                out.push(cursorTo(i + 1) + SGR_RESET + painted[i] + SGR_RESET + ERASE_TO_EOL);
-            }
+            if (painted[i] !== prev[i])
+                out.push(paintLine(i + 1, painted[i], cols));
         }
         prev = painted;
         if (out.length === 0)

package/dist/ui/frame-observer.d.ts

@@ -0,0 +1,17 @@
+import type { ScrollbarBridge } from './scrollbar-controller.js';
+export interface FrameSummary {
+    columns: number;
+    rows: number;
+    trackTop: number;
+    trackRows: number;
+}
+/** Observe before differ transformation, but acknowledge only after downstream write returns. */
+export declare function createFrameObserver(options: {
+    stdout: NodeJS.WriteStream;
+    terminal: NodeJS.WriteStream;
+    scrollbar: ScrollbarBridge;
+}): {
+    stdout: NodeJS.WriteStream;
+    dispose(): void;
+    invalidate(): void;
+};

package/dist/ui/frame-observer.js

@@ -0,0 +1,81 @@
+import stripAnsi from 'strip-ansi';
+import stringWidth from 'string-width';
+import { parseInkFrame } from './frame-parser.js';
+import { pickGlyphs } from './glyphs.js';
+function summarizeFrame(chunk, rows, cols) {
+    const lines = typeof chunk === 'string' ? parseInkFrame(chunk) : null;
+    if (!lines || rows < 12 || cols < 40 || lines.length !== rows - 1)
+        return null;
+    const unicode = pickGlyphs({ unicode: true, colorLevel: 0 });
+    const cells = new Set(['|', '#', unicode.scrollTrack, unicode.scrollThumb]);
+    const plain = lines.map((line) => stripAnsi(line));
+    const track = plain.slice(1, rows - 3);
+    if (plain.some((line) => stringWidth(line) > cols) ||
+        !track.every((line) => stringWidth(line) === cols && cells.has(line.slice(-1))))
+        return null;
+    return { columns: cols, rows, trackTop: 2, trackRows: rows - 4 };
+}
+/** Observe before differ transformation, but acknowledge only after downstream write returns. */
+export function createFrameObserver(options) {
+    const { stdout, terminal, scrollbar } = options;
+    let summary = null;
+    let disposed = false;
+    let resizeTimer = null;
+    const invalidate = () => { summary = null; scrollbar.invalidate(); };
+    const onResize = () => {
+        invalidate();
+        if (resizeTimer)
+            clearTimeout(resizeTimer);
+        // Ink suppresses identical frames when a resize burst returns to its starting size.
+        // Wait past the 50 ms React size debounce, then request a normal redraw if needed.
+        resizeTimer = setTimeout(() => {
+            resizeTimer = null;
+            if (!disposed && !scrollbar.frameReady)
+                scrollbar.requestRedraw?.();
+        }, 60);
+        resizeTimer.unref?.();
+    };
+    const match = () => {
+        const g = scrollbar.geometry;
+        scrollbar.frameReady = !!summary && !!g && summary.columns === terminal.columns &&
+            summary.rows === terminal.rows && g.trackCol === summary.columns &&
+            g.trackTop === summary.trackTop && g.trackRows === summary.trackRows;
+    };
+    const observe = (chunk) => {
+        summary = summarizeFrame(chunk, terminal.rows, terminal.columns);
+        if (!summary) {
+            invalidate();
+            return;
+        }
+        match();
+    };
+    scrollbar.onGeometry = match;
+    terminal.on('resize', onResize);
+    const bound = new Map();
+    const proxy = new Proxy(stdout, {
+        get(target, prop) {
+            if (prop === 'write')
+                return (...args) => {
+                    const result = Reflect.apply(target.write, target, args);
+                    if (!disposed)
+                        observe(args[0]);
+                    return result;
+                };
+            const value = Reflect.get(target, prop, target);
+            if (typeof value !== 'function')
+                return value;
+            if (!bound.has(prop))
+                bound.set(prop, value.bind(target));
+            return bound.get(prop);
+        },
+    });
+    return { stdout: proxy, invalidate, dispose: () => {
+            disposed = true;
+            if (resizeTimer)
+                clearTimeout(resizeTimer);
+            resizeTimer = null;
+            terminal.off('resize', onResize);
+            scrollbar.onGeometry = undefined;
+            invalidate();
+        } };
+}

package/dist/ui/frame-parser.d.ts

@@ -0,0 +1,7 @@
+/** Recognize Ink's erase-lines prefix without accepting arbitrary control writes. */
+export declare function matchInkErasePrefix(chunk: string): {
+    prefix: string;
+    erased: number;
+} | null;
+/** Parse complete frames, including Ink's prefixless initial frame. */
+export declare function parseInkFrame(chunk: string): string[] | null;

package/dist/ui/frame-parser.js

@@ -0,0 +1,18 @@
+/** Recognize Ink's erase-lines prefix without accepting arbitrary control writes. */
+export function matchInkErasePrefix(chunk) {
+    const match = /^(?:\x1b\[2K(?:\x1b\[1A)?)+\x1b\[G/.exec(chunk);
+    return match ? { prefix: match[0], erased: match[0].split('\x1b[2K').length - 1 } : null;
+}
+/** Parse complete frames, including Ink's prefixless initial frame. */
+export function parseInkFrame(chunk) {
+    const prefix = matchInkErasePrefix(chunk);
+    const body = chunk.slice(prefix?.prefix.length ?? 0);
+    if (!body.endsWith('\n'))
+        return null;
+    // SGR and OSC-8 may decorate text; cursor movement is never frame content.
+    const controls = body.replace(/\x1b\[[0-9;:]*m/g, '')
+        .replace(/\x1b\]8;[^\x07\x1b]*(?:\x07|\x1b\\)/g, '');
+    if (/[\x00-\x08\x0b-\x1f\x7f]/.test(controls))
+        return null;
+    return body.slice(0, -1).split('\n');
+}

package/dist/ui/ink-runtime.d.ts

@@ -0,0 +1 @@
+export declare const render: (node: import("react").ReactNode, options?: NodeJS.WriteStream | import("ink").RenderOptions) => import("ink").Instance;

package/dist/ui/ink-runtime.js

@@ -0,0 +1,21 @@
+import process from 'node:process';
+/** Ink 5 caches CI detection at import time and otherwise paints only on exit. */
+async function loadInk() {
+    if (!process.stdin.isTTY || !process.stdout.isTTY)
+        return import('ink');
+    const originalCi = process.env.CI;
+    try {
+        // A real interactive terminal always needs live frames and resize events.
+        // `0` also overrides CI_* / CONTINUOUS_INTEGRATION in Ink's detector.
+        process.env.CI = '0';
+        return await import('ink');
+    }
+    finally {
+        // Commands, subprocesses and the updater must see the original environment.
+        if (originalCi === undefined)
+            delete process.env.CI;
+        else
+            process.env.CI = originalCi;
+    }
+}
+export const { render } = await loadInk();

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

@@ -1,67 +1,13 @@
-/**
- * AppShell (spec §4.3) — the frame that makes R2 true.
- *
- * In `fullscreen` the root box has a FIXED height of `frameHeight(rows)` and the
- * middle viewport is the only `flexGrow` child, so the bottom chrome (toast /
- * composer / status bar) is physically the last thing on the screen from the
- * very first frame — empty session, long session, mid-scroll, overlay open.
- *
- * In `inline` the same children are emitted in the same order with no height
- * constraint, i.e. byte-for-byte the v0.2.0 document-flow behavior.
- */
+/** Stable fullscreen slots preserve the editor during overlays and small resizes. */
 import React from 'react';
-import { type RenderMode } from './frame.js';
 export interface AppShellProps {
-    mode: RenderMode;
     rows: number;
     cols: number;
     header: React.ReactNode;
     viewport: React.ReactNode;
-    /**
-     * The live subagent roster (team-subagents §6.1), or nothing.
-     *
-     * IT RENDERS IN THE BOTTOM CHROME OF THE FULL-SCREEN BRANCH, above `toast` and
-     * below the viewport: the roster is transient status about the run in progress,
-     * so it belongs with the other transient rows rather than inside the scrolling
-     * transcript, where it would be interleaved with history and scroll away.
-     */
-    team?: React.ReactNode;
-    /**
-     * The right-hand region of the MIDDLE band (todo-plan-execution §3.9), or
-     * nothing.
-     *
-     * NAMED FOR ITS POSITION, NOT ITS CONTENT (D-18): this file is a layout
-     * primitive and has no business knowing what a todo is. `team` above already
-     * leaks content vocabulary in here; there is no reason to repeat it.
-     *
-     * IT MUST BE RENDERED IN THE MIDDLE BAND, BESIDE THE VIEWPORT (C-6 / I-4) —
-     * that is what makes it a rail rather than another row of bottom chrome. Moved
-     * down into the bottom box it would stop being a column beside the transcript
-     * and start eating viewport height, growing and shrinking the transcript every
-     * time the list changed length.
-     *
-     * The INLINE branch does not include it at all — a structural guarantee rather
-     * than a promise that the caller passes `null` (non-goal 4).
-     */
-    rail?: React.ReactNode;
-    /**
-     * The one-row plan strip for INLINE mode (todo-plan-followthrough §3.7), or
-     * nothing.
-     *
-     * THE STRUCTURAL MIRROR OF `rail` ABOVE, in the opposite direction: the
-     * FULL-SCREEN branch does not reference it at all. The reason is the same one
-     * `rail`'s inline omission records — a prop that is merely SUPPOSED to be null
-     * in one mode becomes non-null eventually, and then the rail and the strip are
-     * both on screen showing the same list (I-6). Fullscreen has the rail; that is
-     * the whole design.
-     *
-     * It sits between `viewport` and `team`, mirroring where the rail sits in the
-     * other branch: last thing above the bottom chrome, so the strip and the
-     * roster read top-to-bottom in the same order in both modes.
-     */
-    strip?: React.ReactNode;
     toast: React.ReactNode;
-    composer: React.ReactNode;
     status: React.ReactNode;
+    inactive?: boolean;
+    placeholder?: React.ReactNode;
 }
-export declare function AppShell({ mode, rows, cols, header, viewport, team, rail, strip, toast, composer, status, }: AppShellProps): React.ReactElement;
+export declare function AppShell({ rows, cols, header, viewport, toast, status, inactive, placeholder, }: AppShellProps): React.ReactElement;

package/dist/ui/layout/AppShell.js

@@ -1,9 +1,6 @@
-import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box } from 'ink';
 import { frameHeight } from './frame.js';
-export function AppShell({ mode, rows, cols, header, viewport, team, rail, strip, toast, composer, status, }) {
-    if (mode === 'inline') {
-        return (_jsxs(Box, { flexDirection: "column", children: [header, viewport, strip, team, toast, composer, status] }));
-    }
-    return (_jsxs(Box, { flexDirection: "column", height: frameHeight(rows), width: cols, overflow: "hidden", children: [_jsx(Box, { flexDirection: "column", flexShrink: 0, children: header }), _jsxs(Box, { flexDirection: "row", flexGrow: 1, flexShrink: 1, overflow: "hidden", children: [_jsx(Box, { flexDirection: "column", flexGrow: 1, flexShrink: 1, overflow: "hidden", children: viewport }), rail] }), _jsxs(Box, { flexDirection: "column", flexShrink: 0, children: [team, toast, composer, status] })] }));
+export function AppShell({ rows, cols, header, viewport, toast, status, inactive = false, placeholder, }) {
+    return (_jsxs(Box, { flexDirection: "column", height: frameHeight(rows), width: cols, overflow: "hidden", children: [_jsxs(Box, { display: inactive ? 'none' : 'flex', flexDirection: "column", height: frameHeight(rows), width: cols, overflow: "hidden", children: [_jsx(Box, { height: 1, flexShrink: 0, overflow: "hidden", children: header }), _jsx(Box, { flexDirection: "column", flexGrow: 1, flexShrink: 1, overflow: "hidden", children: viewport }), _jsx(Box, { height: 1, flexShrink: 0, overflow: "hidden", children: toast }), _jsx(Box, { height: 1, flexShrink: 0, overflow: "hidden", children: status })] }), _jsx(Box, { display: inactive ? 'flex' : 'none', height: frameHeight(rows), overflow: "hidden", children: placeholder })] }));
 }

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

@@ -1,27 +1,3 @@
-/**
- * OverlayFrame (spec §4.4) — the shared shell for all four overlays.
- *
- * TWO CONTENT MODES, and the distinction is load-bearing:
- *
- *  - mode A (`rows`): the caller hands over an array of elements that are each
- *    exactly one row and `wrap="truncate"`. The frame slices them and OWNS the
- *    scroll keys. Used by Help and Settings.
- *
- *  - mode B (`children`): the content manages itself. The frame draws the title,
- *    the border and the footer, and touches NOTHING else — no slicing, no
- *    arrow-key handling, no position indicator.
- *
- * Mode B exists because of `ink-select-input`: it already windows itself via
- * `limit` and registers its own `useInput` with `isFocused` defaulting to true.
- * Ink dispatches a key to EVERY mounted input handler, so a frame that also
- * claimed the arrow keys would move the model picker's selection twice per press
- * — breaking a feature that already works. Slicing it by element would be worse
- * still, since it is a single component rather than a list of rows.
- *
- * `maxRows` may be `Infinity` (the inline render path, which has no fixed frame
- * and therefore no height to fit): the frame then renders everything and shows
- * no position indicator.
- */
 import React from 'react';
 import type { Theme } from '../theme.js';
 import type { TermCapabilities } from '../capabilities.js';
@@ -29,7 +5,7 @@ interface OverlayFrameBase {
     title: string;
     /** Footer text. Written by the CALLER so each overlay names its own keys. */
     hint: string;
-    /** Viewport rows the overlay may occupy; `Infinity` in inline mode. */
+    /** Viewport rows the overlay may occupy. */
     maxRows: number;
     cols?: number;
     theme: Theme;

package/dist/ui/layout/OverlayFrame.js

@@ -1,28 +1,4 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
-/**
- * OverlayFrame (spec §4.4) — the shared shell for all four overlays.
- *
- * TWO CONTENT MODES, and the distinction is load-bearing:
- *
- *  - mode A (`rows`): the caller hands over an array of elements that are each
- *    exactly one row and `wrap="truncate"`. The frame slices them and OWNS the
- *    scroll keys. Used by Help and Settings.
- *
- *  - mode B (`children`): the content manages itself. The frame draws the title,
- *    the border and the footer, and touches NOTHING else — no slicing, no
- *    arrow-key handling, no position indicator.
- *
- * Mode B exists because of `ink-select-input`: it already windows itself via
- * `limit` and registers its own `useInput` with `isFocused` defaulting to true.
- * Ink dispatches a key to EVERY mounted input handler, so a frame that also
- * claimed the arrow keys would move the model picker's selection twice per press
- * — breaking a feature that already works. Slicing it by element would be worse
- * still, since it is a single component rather than a list of rows.
- *
- * `maxRows` may be `Infinity` (the inline render path, which has no fixed frame
- * and therefore no height to fit): the frame then renders everything and shows
- * no position indicator.
- */
 import { useEffect } from 'react';
 import { Box, Text } from 'ink';
 import { pickGlyphs } from '../glyphs.js';

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

@@ -18,14 +18,15 @@ import React from 'react';
 import type { Theme } from '../theme.js';
 import type { TermCapabilities } from '../capabilities.js';
 import type { ThumbRange } from './scroll-indicator.js';
-/** Below this width a column of content is worth more than the affordance. */
-export declare const MIN_INDICATOR_COLS = 50;
+/** Smallest supported fullscreen width; every usable chat frame reserves the column. */
+export declare const MIN_INDICATOR_COLS = 40;
 export interface ScrollIndicatorProps {
     /** Viewport height in rows, as measured by `ScrollViewport`. */
     rows: number;
     /** `null` when the content fits — the rail is drawn as bare track. */
     thumb: ThumbRange | null;
+    dragging?: boolean;
     theme: Theme;
     caps: TermCapabilities;
 }
-export declare function ScrollIndicator({ rows, thumb, theme, caps, }: ScrollIndicatorProps): React.ReactElement;
+export declare function ScrollIndicator({ rows, thumb, dragging, theme, caps, }: ScrollIndicatorProps): React.ReactElement;

package/dist/ui/layout/ScrollIndicator.js

@@ -1,15 +1,15 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { Box, Text } from 'ink';
 import { pickGlyphs } from '../glyphs.js';
-/** Below this width a column of content is worth more than the affordance. */
-export const MIN_INDICATOR_COLS = 50;
-export function ScrollIndicator({ rows, thumb, theme, caps, }) {
+/** Smallest supported fullscreen width; every usable chat frame reserves the column. */
+export const MIN_INDICATOR_COLS = 40;
+export function ScrollIndicator({ rows, thumb, dragging = false, theme, caps, }) {
     const glyphs = pickGlyphs(caps);
     const count = Math.max(0, Math.floor(rows) || 0);
     const cells = [];
     for (let i = 0; i < count; i += 1) {
         const onThumb = !!thumb && i >= thumb.start && i < thumb.start + thumb.size;
-        cells.push(_jsx(Text, { color: onThumb ? theme.primary : theme.border, children: onThumb ? glyphs.scrollThumb : glyphs.scrollTrack }, i));
+        cells.push(_jsx(Text, { color: onThumb ? theme.primary : theme.muted, bold: onThumb && dragging, children: onThumb ? glyphs.scrollThumb : glyphs.scrollTrack }, i));
     }
     return (_jsx(Box, { flexDirection: "column", flexShrink: 0, width: 1, children: cells }));
 }

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

@@ -1,88 +1,38 @@
-/**
- * ScrollViewport (spec §4.5) — a self-drawn scrolling window built from Ink's
- * negative `marginTop` + `overflow: hidden` + `measureElement`.
- *
- * Once the frame occupies the whole screen, `<Static>` history is pushed above
- * the frame where only one line is visible, so native scrollback stops being a
- * usable mechanism and the app has to own scrolling. That is why this exists.
- *
- * SINGLE SOURCE OF TRUTH (review P1-7): both the metrics and the scroll offset
- * live here. The parent only pushes an *intent* down and receives one derived
- * *display* number back. Holding the offset in the parent as well would create a
- * measure → setState → re-render → measure loop whose convergence is provable
- * but whose frame count is not — expensive inside a 33 ms streaming window.
- *
- * AS OF tui-selection-and-scroll-follow THIS IS AN ADAPTER, NOT A POLICY OWNER.
- * The two follow rules are pure and live in `follow-state.ts`; what stays here is
- * measure → compute a tail delta → apply → arm a timer. `scroll.ts` is
- * unchanged, so every existing scroll test keeps passing (R-10).
- *
- * The "N new lines · PgDn" hint used to take this viewport's LAST ROW. It now
- * renders as a chip inside the composer's bordered input row (§4.2), which costs
- * zero rows and removes the feedback loop where the hint's own presence shrank
- * the viewport, which changed `overflowLines`, which was the number the hint
- * displayed. The data still leaves through `onScrolledLinesChange`.
- */
 import React from 'react';
+import { type DOMElement } from 'ink';
 import type { Theme } from '../theme.js';
 import type { TermCapabilities } from '../capabilities.js';
+import { type ScrollbarBridge } from '../scrollbar-controller.js';
 import { type ScrollIntent } from './scroll.js';
 import { type TailSink } from './follow-state.js';
 export interface ScrollViewportProps {
-    /**
-     * Scroll intent. `nonce` is monotonic so pressing the same key twice re-fires.
-     * `repeat` folds a coalesced wheel burst into one state update (defaults 1).
-     */
     intent?: {
         kind: ScrollIntent;
         nonce: number;
         repeat?: number;
     };
-    /** Bumped by the parent to force a pin to the newest output (e.g. on submit). */
     pinToBottomNonce?: number;
-    /** Derived display value for the status bar's `↑N`. Must be referentially stable. */
+    resetKey?: unknown;
     onScrolledLinesChange?: (lines: number) => void;
-    /**
-     * Rows hidden ABOVE the window, published on every change (§4.3.3).
-     *
-     * PUBLISHED, NOT LIFTED — the same shape as `onScrolledLinesChange`, so there
-     * is still exactly one owner of the offset. `shiftUp` changes exactly when the
-     * rows on screen move, which is the property the selection's clear-list was
-     * approximating by enumeration (I-9 / P1-4). Must be referentially stable.
-     */
-    onViewportShiftChange?: (shiftUp: number) => void;
-    /**
-     * The transcript's tail row counter (§4.3.1a), written during ITS render and
-     * therefore already current when this component's layout effect runs.
-     *
-     * ABSENT ⇒ NO ANCHORING AT ALL, deliberately: every existing caller and every
-     * existing test that does not supply it behaves exactly as it did before this
-     * feature, because `tailDelta` is then permanently 0.
-     */
+    onViewportShiftChange?: (shift: number) => void;
     tailRowsRef?: TailSink;
-    /**
-     * True while a selection drag is in progress (§4.4). It anchors the content
-     * even from a pinned viewport, and it suspends the resume timer.
-     */
     hold?: boolean;
-    /** Idle delay before returning to the newest line, in ms; `0` disables (AC-9). */
     resumeMs?: number;
-    /** Reserve the right-edge scroll-position rail (mouse-wheel §4.8). */
     showScrollIndicator?: boolean;
-    /**
-     * The viewport's own width, when it is narrower than the terminal
-     * (todo-plan-execution §3.9 / C-7).
-     *
-     * This component is the ONLY one inside the viewport subtree that reads
-     * `stdout.columns` directly, and the place it uses the number — the
-     * `MIN_INDICATOR_COLS` gate — is about how much room THIS BOX has, not how
-     * wide the terminal is. Once the todo rail takes its responsive share of the frame those two
-     * stop being the same number. Optional so every existing caller (and every
-     * test) is unchanged.
-     */
     cols?: number;
+    footer?: React.ReactNode;
+    rail?: React.ReactNode;
+    overlay?: React.ReactNode;
+    active?: boolean;
+    scrollbar?: ScrollbarBridge;
+    composerRef?: React.RefObject<DOMElement>;
+    onComposerVisibilityChange?: (visible: boolean) => void;
+    /** The run status row above the input box (tui-scrollbar-edge-and-run-row). */
+    activityRef?: React.RefObject<DOMElement>;
+    onActivityVisibilityChange?: (visible: boolean) => void;
     theme: Theme;
     caps: TermCapabilities;
     children: React.ReactNode;
 }
-export declare function ScrollViewport({ intent, pinToBottomNonce, onScrolledLinesChange, onViewportShiftChange, tailRowsRef, hold, resumeMs, showScrollIndicator, cols: colsProp, theme, caps, children, }: ScrollViewportProps): React.ReactElement;
+/** One offset for messages, padding and editor; hidden trees keep their local state. */
+export declare function ScrollViewport(props: ScrollViewportProps): React.ReactElement;