@aragon-agent/cli 0.6.46 → 0.6.48

package/dist/ui/scrollback/limits.js

@@ -1,98 +0,0 @@
-/**
- * Structural limits of native-scroll mode (tui-native-terminal-scroll §4.3-§4.6).
- *
- * Structural caps live here; tunable policy lives in `config/schema.ts`. None of
- * these is a user preference: each one bounds a failure (a runaway write, a live
- * region that eats the screen) rather than expressing a taste.
- */
-export const SCROLLBACK_LIMITS = {
-    /** Pending static entries the drain holds before folding the oldest into a marker. */
-    feedCapacity: 32,
-    /** Rows one entry may print; the rest is replaced by one ASCII notice row. */
-    maxRowsPerEntry: 400,
-    /** Static rows per `stdout.write`; larger feeds are split into consecutive batches. */
-    maxRowsPerBatch: 2000,
-    /** tall-frame swallows within this window after a resize are expected and uncounted. */
-    guardResizeGraceMs: 250,
-    /** Consecutive out-of-resize tall frames that degrade the app to the placeholder. */
-    guardTripCount: 3,
-    /** Session summary rows printed on exit. */
-    exitSummaryMaxRows: 4,
-    /**
-     * Entries the region may hold on screen at once
-     * (tui-full-height-live-region D6; the WINDOW is defined by I-F8 and computed in
-     * `tail-window.ts`).
-     *
-     * 10 is DERIVED, not a preference. The band's left column is the whole pool
-     * (`pool = rows - 1 - header - composer - status`, i.e. 24 rows on a 30-row
-     * terminal) and one entry occupies about 2.4 rows, so a window of 4 would leave
-     * the column half empty - the blank band this feature removes. It stays in the
-     * per-frame COST class the old value of 4 was measured in: `EntryView` is
-     * memoised and only the streaming entry re-renders, so this bounds component
-     * instances, not per-frame work.
-     *
-     * There is deliberately NO companion row cap any more (retired: the old
-     * `maxLiveTailRows` / `liveTailRowShare` pair). The rows a tail may take are
-     * `band.previewRows` - the whole left column - and "the region can never be
-     * taller than the screen" is `liveRows === rows - 1`'s job (I-F5), not a second
-     * number's. Those two caps disagreed with the pool, and that disagreement WAS the
-     * blank band between the result and the running card.
-     */
-    liveTailMaxEntries: 10,
-    /**
-     * Safety margin the live tail asks for before it anchors its content to the TOP of
-     * the region (tui-first-reply-bottom-aligned, plan A-prime; the decision itself is
-     * `tail-anchor.ts`).
-     *
-     * 2 is DERIVED, not a preference. The anchor is decided from
-     * `layout/virtual-window.ts::estimateEntryRows`, which charges one separation row per
-     * entry and counts RAW markdown lines - so it UNDER-estimates a `#` heading (which
-     * also draws an `hrule`) and a code block (whose rail narrows the text by two columns,
-     * making long lines wrap). Inside a virtual window that error self-corrects when the
-     * entry is measured; the live region has no measurement pass, so the same error would
-     * decide which rows get CLIPPED - and `flex-start` clips the NEWEST rows.
-     * The margin must therefore always stay on the `bottom` side: a needless fallback
-     * costs one stacked frame, an early anchor hides the text the user is waiting for.
-     */
-    tailAnchorSlackRows: 2,
-    /**
-     * Rows the rail needs before the band will show it: `TODO_LIMITS.panelMinRows + 1`.
-     *
-     * The `+ 1` is not decoration - the rail takes its rows from the same pool as one
-     * preview row, and a band that seats the rail but no preview loses the streaming
-     * answer entirely (band.ts step 3 / AC-12).
-     */
-    railBandMinRows: 4,
-    /**
-     * How long the cursor-position probe waits for `ESC[<row>;<col>R`.
-     *
-     * A STRUCTURAL CAP, not a preference (tui-bottom-anchored-live-region §4.4): it
-     * bounds "how much startup latency a terminal that does not answer may cost". The
-     * round trip is under 5 ms locally and under 60 ms over SSH, so 150 ms is
-     * generous, and the probe runs once per session — never per frame, never per
-     * keystroke. Anything longer and a terminal without CPR support would pay it on
-     * every launch.
-     */
-    anchorProbeTimeoutMs: 150,
-    /**
-     * Settle window before re-measuring the cursor after a resize.
-     *
-     * A STRUCTURAL CAP for the same reason: a drag fires dozens of resize events, and
-     * one CPR per event would both flood the input channel and make the region jitter.
-     * 200 ms is below the point a user perceives as "the input box is stuck".
-     */
-    anchorReprobeDelayMs: 200,
-    /**
-     * Structural ceiling on the height of a STARTING canvas.
-     *
-     * It bounds the bytes a batch may write and the rows the content cache may hold on
-     * an extreme terminal (`rows` 3000). Two limits on how it may be applied, both
-     * arithmetic rather than taste:
-     *  - the rows a canvas leaves unused do not disappear, they stay above it as the
-     *    permanent region, so a smaller starting canvas never loses content;
-     *  - it must NEVER clip a live canvas. A canvas that has overflowed and scrolled
-     *    grows to `rows - 1`, and shrinking one back would make the next erase reach
-     *    above its own top: host output erased, every visible row printed twice.
-     */
-    maxCanvasRows: 200,
-};

package/dist/ui/scrollback/live-preview.d.ts

@@ -1,34 +0,0 @@
-/**
- * Plain-text fallback rows for the native-scroll live region
- * (tui-native-terminal-scroll §4.6, tui-full-height-live-region RV-P2-7).
- *
- * THE REAL TAIL IS `LiveTail`, NOT THIS. Native mode draws the region's tail with the
- * actual entry components, so these rows are only the fallback for a frame that mounts
- * no component there (and the floor of the measurement path). They are kept rather than
- * deleted because the render tests use them to assert exactly that frame, and because
- * `<= 24 wrapToRows` calls per frame is far below the cost of the components it stands
- * in for.
- *
- * The input is the TAIL WINDOW (`selectTailWindow`), settled entries included: at
- * `H = rows - 1` the region shows the last K entries of the conversation, so a
- * projection built only from the unfinished ones would disagree with the screen.
- * The field keeps its historical name `unsettled` because it is still "the entries the
- * region is showing", and renaming it would touch the preview tests for no behaviour.
- *
- * PURE: no Ink, no theme, no I/O. Every returned row fits `cols` display columns.
- */
-import type { Entry } from '../../agent/reducer.js';
-export interface LivePreviewInput {
-    /**
-     * The entries to project, oldest first - the tail window in native mode. May include
-     * excluded entries; they are skipped.
-     */
-    unsettled: readonly Entry[];
-    /** Content width (`cols - 1`). */
-    cols: number;
-    /** Rows granted by the budget. */
-    rows: number;
-    thinkingVisible: boolean;
-}
-/** The last `rows` preview rows, oldest first. `[]` when `rows <= 0`. */
-export declare function buildLivePreview(input: LivePreviewInput): string[];

package/dist/ui/scrollback/live-preview.js

@@ -1,118 +0,0 @@
-/**
- * Plain-text fallback rows for the native-scroll live region
- * (tui-native-terminal-scroll §4.6, tui-full-height-live-region RV-P2-7).
- *
- * THE REAL TAIL IS `LiveTail`, NOT THIS. Native mode draws the region's tail with the
- * actual entry components, so these rows are only the fallback for a frame that mounts
- * no component there (and the floor of the measurement path). They are kept rather than
- * deleted because the render tests use them to assert exactly that frame, and because
- * `<= 24 wrapToRows` calls per frame is far below the cost of the components it stands
- * in for.
- *
- * The input is the TAIL WINDOW (`selectTailWindow`), settled entries included: at
- * `H = rows - 1` the region shows the last K entries of the conversation, so a
- * projection built only from the unfinished ones would disagree with the screen.
- * The field keeps its historical name `unsettled` because it is still "the entries the
- * region is showing", and renaming it would touch the preview tests for no behaviour.
- *
- * PURE: no Ink, no theme, no I/O. Every returned row fits `cols` display columns.
- */
-import { clampLiveText } from '../live-clamp.js';
-import { wrapToRows } from '../layout/wrap-rows.js';
-import { isExcluded } from './settled-boundary.js';
-import { isLiveTeamCard, outcomePhrase, rosterCounts } from '../team-status.js';
-import { clipLine } from './writer-shapes.js';
-const MAX_TEAM_RUN_ROWS = 3;
-const TOOL_LIVE_ROWS = 6;
-function firstLine(text) {
-    const line = text.split('\n').find((candidate) => candidate.trim().length > 0);
-    return (line ?? '').trim();
-}
-function fit(text, cols) {
-    return clipLine(text, Math.max(1, cols)).text;
-}
-function assistantRows(entry, cols, rows, thinkingVisible) {
-    const out = [];
-    const thinking = (entry.thinking ?? '').trim();
-    if (entry.text.trim().length === 0) {
-        if (thinking.length > 0 && thinkingVisible) {
-            const last = thinking.split('\n').filter((line) => line.trim().length > 0).pop() ?? '';
-            out.push(fit(`thinking: ${last.trim()}`, cols));
-        }
-        else if (entry.streaming) {
-            out.push('thinking...');
-        }
-        return out;
-    }
-    const clamped = clampLiveText(entry.text, rows * 2);
-    out.push(...wrapToRows(clamped.text, cols).map((row) => fit(row, cols)));
-    return out;
-}
-function toolRows(entry, cols) {
-    const head = entry.label && entry.label.length > 0 ? entry.label : entry.name;
-    const out = [fit(`${entry.status === 'running' ? '>' : '.'} ${head}`, cols)];
-    const live = (entry.live ?? []).slice(-TOOL_LIVE_ROWS);
-    for (const row of live)
-        out.push(fit(`  ${row}`, cols));
-    return out;
-}
-function teamRows(entry, cols) {
-    // ONLY A SETTLED CARD REACHES HERE (the live one projects nothing, below), so the
-    // outcome phrase - `team-status.ts`'s own sentence - replaces an always-zero fraction.
-    const counts = rosterCounts(entry.runs);
-    const out = [fit(`Team: ${outcomePhrase(counts)}`, cols)];
-    for (const run of entry.runs.slice(0, MAX_TEAM_RUN_ROWS)) {
-        out.push(fit(`  ${run.label} ${run.phase}`, cols));
-    }
-    return out;
-}
-function entryRows(entry, input) {
-    const { cols, rows, thinkingVisible } = input;
-    switch (entry.kind) {
-        case 'assistant':
-            return assistantRows(entry, cols, rows, thinkingVisible);
-        case 'tool':
-            return toolRows(entry, cols);
-        case 'team':
-            // THE LIVE DISPATCH HAS ONE SURFACE (tui-subagent-double-roster A-2): this
-            // projection is the text fallback for the same slot `LiveTail` fills, so a
-            // `Team: n/m running` line here would be the second live block again, one level
-            // down. A settled card still projects normally.
-            return isLiveTeamCard(entry) ? [] : teamRows(entry, cols);
-        case 'todo':
-            return [fit(`Todo: ${entry.doneCount}/${entry.total}`, cols)];
-        case 'compaction':
-            return [fit(`Compacting context...`, cols)];
-        case 'retry':
-            return [fit(`Retrying (${entry.attempt}/${entry.maxRetries})...`, cols)];
-        case 'fast':
-            return [fit(`Fast review ${entry.reviewIndex}...`, cols)];
-        case 'queued':
-            return [fit(`Queued: ${firstLine(entry.text)}`, cols)];
-        case 'user':
-            return [fit(`> ${firstLine(entry.text)}`, cols)];
-        case 'notice':
-            return [fit(firstLine(entry.text), cols)];
-        case 'service':
-            return [];
-        case 'governance':
-            return [fit(`Governance: ${entry.card.title}`, cols)];
-        default: {
-            const exhaustive = entry;
-            return exhaustive;
-        }
-    }
-}
-/** The last `rows` preview rows, oldest first. `[]` when `rows <= 0`. */
-export function buildLivePreview(input) {
-    const rows = Math.floor(input.rows);
-    if (rows <= 0)
-        return [];
-    const all = [];
-    for (const entry of input.unsettled) {
-        if (isExcluded(entry))
-            continue;
-        all.push(...entryRows(entry, input));
-    }
-    return all.slice(-rows);
-}

package/dist/ui/scrollback/overflow-print.d.ts

@@ -1,108 +0,0 @@
-/**
- * TOP GIVE-WAY - the row-level print plan of the native-scroll live region
- * (tui-final-reply-truncated-unscrollable, plan A-prime / B3).
- *
- * THE DEFECT THIS ANSWERS. The region is the whole screen (`H = rows - 1`), so the box
- * that holds the conversation is only `previewRows` tall (24 rows on a 30-row terminal),
- * while the boundary that decides what may print into the terminal's scrollback is
- * counted in ENTRIES (`liveTailMaxEntries`). A settled answer taller than the box is
- * therefore inside the window, never printed, and clipped from the top by
- * `justifyContent="flex-end"`. Native mode has no in-frame viewport - the wheel scrolls
- * the terminal's scrollback - so the clipped rows exist nowhere the user can reach.
- *
- * The region cannot simply grow: a frame as tall as the terminal makes Ink write
- * `clearTerminal` (which contains `ESC[3J`) and that erases the user's scrollback. So the
- * only direction that keeps both promises is this one: the box keeps showing what it can,
- * and the rows it hides are PRINTED into the scrollback, where the terminal's own scroll
- * already reaches. Nothing on screen changes; the head of a long answer simply becomes
- * readable one wheel turn up.
- *
- * WHAT THE PLAN GUARANTEES (the invariants the implementation batches are verified by):
- *  I-B1 `printed(e) + visible(e) = rows(e)` and the two ranges are adjacent and disjoint,
- *       so `scrollback + screen` covers every row exactly once (no gap, no duplicate).
- *  I-B2 Only STABLE entries may print, and the FIRST unstable entry is a wall: nothing at
- *       or after it is ever planned, even when a stable entry follows it (a `notice` after
- *       a streaming answer is stable, and printing it here would put rows into the
- *       scrollback out of conversation order, which is unrecoverable).
- *  I-B3 The plan is ordered oldest-first and carries no gaps: the caller prints the
- *       segments in the order given, so the scrollback keeps conversation order.
- *  I-B4 It never plans a row that is still on screen: `hiddenRows` is measured against the
- *       box height, and the box clips from the TOP only while it is bottom-anchored
- *       (`tail-anchor.ts`), which the caller checks before printing anything.
- *
- * PURE: no Ink, no I/O, no clock, no `node:*`. That is why the caller injects the measured
- * heights and the printed counts instead of this module measuring anything itself: the same
- * arithmetic then drives a unit test with an arbitrary table instead of a screen.
- */
-import type { Entry } from '../../agent/reducer.js';
-/** One entry of the tail window, as the planner needs it. */
-export interface OverflowWindowEntry {
-    entry: Entry;
-    /**
-     * Rows this entry occupies in the live region, measured at the SAME width the region
-     * draws it at (`previewCols`). An estimate is not good enough here: the plan decides how
-     * many rows are hidden, and a wrong count either duplicates a visible row or leaves one
-     * unreachable.
-     */
-    rows: number;
-    /** Leading rows of this entry already in the scrollback, `0` when none. */
-    printed: number;
-    /**
-     * `isEntryStable(entry, runActive, isTail)` for this entry - the caller's answer, because
-     * "is this the tail" is a property of the FULL list and the window is a filtered slice.
-     */
-    stable: boolean;
-}
-/** One run of rows to print: `[fromRow, toRow)` of `entry`'s own rows. */
-export interface OverflowSegment {
-    /** Index into the window the planner was given. */
-    index: number;
-    id: string;
-    /** First row to print, 0-based from the top of the entry. */
-    fromRow: number;
-    /** One past the last row to print. */
-    toRow: number;
-}
-export interface OverflowPlan {
-    /** Rows to hand to the writer, oldest entry first (I-B3). */
-    segments: readonly OverflowSegment[];
-    /** Rows the box hides above its top edge; `0` when the window fits. */
-    hiddenRows: number;
-    /** Measured height of the whole window, including entries past the wall. */
-    totalRows: number;
-}
-/**
- * Which rows of the window the box is hiding, and how many of them are not printed yet.
- *
- * @param window The tail window, OLDEST FIRST, excluded entries already dropped.
- * @param budgetRows Height of the box that shows the window (`band.previewRows`).
- * @returns The print plan; `segments` is empty when nothing is hidden or when the first
- * unstable entry sits at the top of the window (see I-B2).
- */
-export declare function planOverflowPrint(window: readonly OverflowWindowEntry[], budgetRows: number): OverflowPlan;
-/**
- * The row that marks a WIDTH CHANGE inside one entry's printed history.
- *
- * "Rows already printed" is a width-relative quantity: a line that took two rows at 80
- * columns takes one at 120. Continuing to slice at the old index would skip content
- * (`W1` breaks) or repeat it silently. So a width change prints this seam and restarts the
- * entry at the new width: every row stays reachable, and the only cost is one bounded
- * repetition of the rows above the seam (documented in the README).
- */
-export declare function reflowSeamRow(printedRows: number, printedCols: number, cols: number): string;
-/** The single wording of the per-entry row cap, shared by the renderer and the pipeline. */
-export declare function elisionRow(hidden: number): string;
-/**
- * Apply `maxRowsPerEntry` to the REMAINDER of one entry.
- *
- * The cap used to be a single "keep the first 399 rows, then say how many were dropped".
- * That is still what a never-printed entry gets (`headRows === 0`), because it keeps the
- * part of the answer the user has already scrolled past. An entry whose HEAD is already in
- * the scrollback gets the opposite treatment on purpose: the notice goes FIRST and the LAST
- * rows follow, because the tail is the part the reader is looking at on screen, and eliding
- * it would delete the answer they just finished reading from their history.
- *
- * @param tail Rows still to print (`body.slice(fromRow)`).
- * @param headRows Rows of this entry already printed.
- */
-export declare function capPrintedRows(tail: readonly string[], headRows: number): readonly string[];

package/dist/ui/scrollback/overflow-print.js

@@ -1,120 +0,0 @@
-/**
- * TOP GIVE-WAY - the row-level print plan of the native-scroll live region
- * (tui-final-reply-truncated-unscrollable, plan A-prime / B3).
- *
- * THE DEFECT THIS ANSWERS. The region is the whole screen (`H = rows - 1`), so the box
- * that holds the conversation is only `previewRows` tall (24 rows on a 30-row terminal),
- * while the boundary that decides what may print into the terminal's scrollback is
- * counted in ENTRIES (`liveTailMaxEntries`). A settled answer taller than the box is
- * therefore inside the window, never printed, and clipped from the top by
- * `justifyContent="flex-end"`. Native mode has no in-frame viewport - the wheel scrolls
- * the terminal's scrollback - so the clipped rows exist nowhere the user can reach.
- *
- * The region cannot simply grow: a frame as tall as the terminal makes Ink write
- * `clearTerminal` (which contains `ESC[3J`) and that erases the user's scrollback. So the
- * only direction that keeps both promises is this one: the box keeps showing what it can,
- * and the rows it hides are PRINTED into the scrollback, where the terminal's own scroll
- * already reaches. Nothing on screen changes; the head of a long answer simply becomes
- * readable one wheel turn up.
- *
- * WHAT THE PLAN GUARANTEES (the invariants the implementation batches are verified by):
- *  I-B1 `printed(e) + visible(e) = rows(e)` and the two ranges are adjacent and disjoint,
- *       so `scrollback + screen` covers every row exactly once (no gap, no duplicate).
- *  I-B2 Only STABLE entries may print, and the FIRST unstable entry is a wall: nothing at
- *       or after it is ever planned, even when a stable entry follows it (a `notice` after
- *       a streaming answer is stable, and printing it here would put rows into the
- *       scrollback out of conversation order, which is unrecoverable).
- *  I-B3 The plan is ordered oldest-first and carries no gaps: the caller prints the
- *       segments in the order given, so the scrollback keeps conversation order.
- *  I-B4 It never plans a row that is still on screen: `hiddenRows` is measured against the
- *       box height, and the box clips from the TOP only while it is bottom-anchored
- *       (`tail-anchor.ts`), which the caller checks before printing anything.
- *
- * PURE: no Ink, no I/O, no clock, no `node:*`. That is why the caller injects the measured
- * heights and the printed counts instead of this module measuring anything itself: the same
- * arithmetic then drives a unit test with an arbitrary table instead of a screen.
- */
-import { SCROLLBACK_LIMITS } from './limits.js';
-function wholeRows(value) {
-    return Number.isFinite(value) ? Math.max(0, Math.floor(value)) : 0;
-}
-/**
- * Which rows of the window the box is hiding, and how many of them are not printed yet.
- *
- * @param window The tail window, OLDEST FIRST, excluded entries already dropped.
- * @param budgetRows Height of the box that shows the window (`band.previewRows`).
- * @returns The print plan; `segments` is empty when nothing is hidden or when the first
- * unstable entry sits at the top of the window (see I-B2).
- */
-export function planOverflowPrint(window, budgetRows) {
-    const totalRows = window.reduce((sum, item) => sum + wholeRows(item.rows), 0);
-    // Rows past the wall are on screen too (the box is one box), so they count towards the
-    // height - they are simply never printable themselves.
-    const hiddenRows = Math.max(0, totalRows - wholeRows(budgetRows));
-    if (hiddenRows === 0)
-        return { segments: [], hiddenRows, totalRows };
-    const segments = [];
-    let offset = 0;
-    for (const [index, item] of window.entries()) {
-        // I-B2 - the wall. Nothing at or after the first unstable entry may print, and because
-        // the loop walks in order, "at or after" needs nothing more than a `break`.
-        if (!item.stable)
-            break;
-        // Every row from here down is visible: the box clips exactly `hiddenRows` rows off the
-        // top, so once the accumulated offset reaches it the plan is complete.
-        if (offset >= hiddenRows)
-            break;
-        const hiddenOfEntry = Math.min(wholeRows(item.rows), hiddenRows - offset);
-        const printed = wholeRows(item.printed);
-        if (hiddenOfEntry > printed) {
-            segments.push({ index, id: item.entry.id, fromRow: printed, toRow: hiddenOfEntry });
-        }
-        offset += wholeRows(item.rows);
-    }
-    return { segments, hiddenRows, totalRows };
-}
-/**
- * The row that marks a WIDTH CHANGE inside one entry's printed history.
- *
- * "Rows already printed" is a width-relative quantity: a line that took two rows at 80
- * columns takes one at 120. Continuing to slice at the old index would skip content
- * (`W1` breaks) or repeat it silently. So a width change prints this seam and restarts the
- * entry at the new width: every row stays reachable, and the only cost is one bounded
- * repetition of the rows above the seam (documented in the README).
- */
-export function reflowSeamRow(printedRows, printedCols, cols) {
-    return `[-- reflowed to ${cols} columns; ${printedRows} row(s) above were printed at ` +
-        `${printedCols} columns --]`;
-}
-/** The single wording of the per-entry row cap, shared by the renderer and the pipeline. */
-export function elisionRow(hidden) {
-    return `[+${hidden} rows not printed - scrollback entry cap]`;
-}
-/**
- * Apply `maxRowsPerEntry` to the REMAINDER of one entry.
- *
- * The cap used to be a single "keep the first 399 rows, then say how many were dropped".
- * That is still what a never-printed entry gets (`headRows === 0`), because it keeps the
- * part of the answer the user has already scrolled past. An entry whose HEAD is already in
- * the scrollback gets the opposite treatment on purpose: the notice goes FIRST and the LAST
- * rows follow, because the tail is the part the reader is looking at on screen, and eliding
- * it would delete the answer they just finished reading from their history.
- *
- * @param tail Rows still to print (`body.slice(fromRow)`).
- * @param headRows Rows of this entry already printed.
- */
-export function capPrintedRows(tail, headRows) {
-    const cap = SCROLLBACK_LIMITS.maxRowsPerEntry;
-    const printed = wholeRows(headRows);
-    if (printed + tail.length <= cap)
-        return tail;
-    if (printed === 0) {
-        const keep = Math.max(0, cap - 1);
-        return [...tail.slice(0, keep), elisionRow(tail.length - keep)];
-    }
-    // One row is spent on the notice itself.
-    const keep = Math.max(0, cap - printed - 1);
-    if (keep === 0)
-        return [elisionRow(tail.length)];
-    return [elisionRow(tail.length - keep), ...tail.slice(tail.length - keep)];
-}

package/dist/ui/scrollback/renderer.d.ts

@@ -1,48 +0,0 @@
-/**
- * Offscreen entry renderer (tui-native-terminal-scroll §4.5 / D4).
- *
- * Settled entries are rendered ONCE, to ANSI text, by a resident Ink instance that
- * writes to a fake stdout (`debug: true`: Ink then emits the complete layout in one
- * write per render and never touches log-update). The resulting rows go to the feed
- * and are printed; they are never mounted in the live React tree, so the per-frame
- * render cost stays proportional to what is on screen, not to the session length.
- *
- * Failure isolation (I-S12): one entry that throws while rendering degrades to a
- * single placeholder row. It must never block the queue or take the session down.
- */
-import React from 'react';
-import type { Entry } from '../../agent/reducer.js';
-import type { TermCapabilities } from '../capabilities.js';
-import type { DensityMode } from '../density.js';
-import type { Theme } from '../theme.js';
-export interface EntryRenderOptions {
-    theme: Theme;
-    caps: TermCapabilities;
-    density: DensityMode;
-    thinkingVisible: boolean;
-    reducedMotion: boolean;
-}
-export interface EntryRenderer {
-    /** Rows for one entry at `cols` columns, capped at `maxRowsPerEntry`; `[]` when it renders as nothing. */
-    renderEntry(entry: Entry, prev: Entry | undefined, cols: number, expanded?: boolean): string[];
-    /**
-     * The SAME rows, UNCAPPED.
-     *
-     * "Top give-way" (`overflow-print.ts`) slices one entry across two print passes, so it
-     * needs the real row count and the real rows: `capRows` truncates before returning, and a
-     * row budget computed from a truncated array puts the cut in the wrong place (a 800-row
-     * answer would compute its cut on 400 rows and print rows the screen is still showing).
-     * The cap is applied by the caller, once, where it knows how many rows are already printed.
-     */
-    renderEntryRows(entry: Entry, prev: Entry | undefined, cols: number, expanded?: boolean): string[];
-    /** Rows for an arbitrary node (the startup header and opener). */
-    renderNode(node: React.ReactNode, cols: number): string[];
-    /** Options for LATER renders; already printed rows never change. */
-    setOptions(partial: Partial<EntryRenderOptions>): void;
-    stats(): {
-        elidedRows: number;
-        failures: number;
-    };
-    dispose(): void;
-}
-export declare function createEntryRenderer(initial: EntryRenderOptions): EntryRenderer;