@aragon-agent/cli 0.6.33 → 0.6.35

package/dist/ui/scrollback/renderer.js

@@ -17,6 +17,7 @@ import { Box, render } from 'ink';
 import { EntryView } from '../Transcript.js';
 import { getLogger } from '../../logging/logger.js';
 import { SCROLLBACK_LIMITS } from './limits.js';
+import { elisionRow } from './overflow-print.js';
 /**
  * Catches a throwing entry INSIDE the offscreen tree.
  *
@@ -76,30 +77,52 @@ function trimTrailingBlank(rows) {
 }
 export function createEntryRenderer(initial) {
     let options = initial;
-    let offscreen = null;
+    /**
+     * Resident offscreen instances, keyed by width.
+     *
+     * TWO SLOTS, NOT ONE. Ink reads `columns` once, at creation, so a width change needs a new
+     * instance - but a width change happens WITHIN one promotion pass as soon as the plan
+     * measures at the box width (`previewCols`) and prints at `contentCols`, and a single slot
+     * would then dispose and rebuild a complete Ink root on every such frame. Two slots cover
+     * both widths of the current geometry; a third width (an actual resize) evicts the oldest.
+     */
+    const slots = new Map();
+    const MAX_SLOTS = 2;
     let elidedRows = 0;
     let failures = 0;
     let guardKey = 0;
-    const dispose = () => {
-        if (!offscreen)
+    const disposeSlot = (cols) => {
+        const target = slots.get(cols);
+        if (!target)
             return;
-        const current = offscreen;
-        offscreen = null;
+        slots.delete(cols);
         try {
-            current.instance.unmount();
-            current.instance.cleanup();
+            target.instance.unmount();
+            target.instance.cleanup();
         }
         catch {
             // Tearing down a fake stream must never throw into an exit path.
         }
     };
+    const dispose = () => {
+        for (const cols of [...slots.keys()])
+            disposeSlot(cols);
+    };
     /** Ink reads `columns` once, at creation, so a width change rebuilds the instance. */
     const ensure = (cols) => {
-        if (offscreen && offscreen.cols === cols)
-            return offscreen;
-        dispose();
-        offscreen = createOffscreen(cols);
-        return offscreen;
+        const resident = slots.get(cols);
+        if (resident) {
+            // Refresh the recency order so the OTHER width is the eviction candidate.
+            slots.delete(cols);
+            slots.set(cols, resident);
+            return resident;
+        }
+        const evictable = [...slots.keys()][0];
+        if (evictable !== undefined && slots.size >= MAX_SLOTS)
+            disposeSlot(evictable);
+        const created = createOffscreen(cols);
+        slots.set(cols, created);
+        return created;
     };
     const capRows = (rows) => {
         const cap = SCROLLBACK_LIMITS.maxRowsPerEntry;
@@ -107,9 +130,9 @@ export function createEntryRenderer(initial) {
             return rows;
         const hidden = rows.length - (cap - 1);
         elidedRows += hidden;
-        return [...rows.slice(0, cap - 1), `[+${hidden} rows not printed - scrollback entry cap]`];
+        return [...rows.slice(0, cap - 1), elisionRow(hidden)];
     };
-    const renderNode = (node, cols) => {
+    const renderFrame = (node, cols) => {
         const target = ensure(Math.max(1, Math.floor(cols)));
         target.last.value = null;
         target.failure.error = NO_FAILURE;
@@ -122,27 +145,32 @@ export function createEntryRenderer(initial) {
             throw failure;
         if (frame === null)
             throw new Error('offscreen Ink instance produced no frame');
-        return capRows(trimTrailingBlank(frame.split('\n')));
+        return trimTrailingBlank(frame.split('\n'));
     };
     const failureRow = (label) => {
         failures += 1;
         return [`[aragon] ${label} could not be rendered`];
     };
+    const entryFrame = (entry, prev, cols, expanded) => renderFrame(_jsx(EntryView, { entry: entry, prev: prev, expanded: expanded, thinkingVisible: options.thinkingVisible, reducedMotion: options.reducedMotion, density: options.density, theme: options.theme, caps: options.caps }), cols);
+    const renderEntryRows = (entry, prev, cols, expanded = false) => {
+        try {
+            return entryFrame(entry, prev, cols, expanded);
+        }
+        catch (error) {
+            getLogger().warn('cli', 'entry_render_failed', {
+                id: entry.id, kind: entry.kind, error: String(error),
+            });
+            return failureRow(`entry ${entry.id} (${entry.kind})`);
+        }
+    };
     return {
         renderEntry(entry, prev, cols, expanded = false) {
-            try {
-                return renderNode(_jsx(EntryView, { entry: entry, prev: prev, expanded: expanded, thinkingVisible: options.thinkingVisible, reducedMotion: options.reducedMotion, density: options.density, theme: options.theme, caps: options.caps }), cols);
-            }
-            catch (error) {
-                getLogger().warn('cli', 'entry_render_failed', {
-                    id: entry.id, kind: entry.kind, error: String(error),
-                });
-                return failureRow(`entry ${entry.id} (${entry.kind})`);
-            }
+            return capRows(renderEntryRows(entry, prev, cols, expanded));
         },
+        renderEntryRows,
         renderNode(node, cols) {
             try {
-                return renderNode(node, cols);
+                return capRows(renderFrame(node, cols));
             }
             catch (error) {
                 getLogger().warn('cli', 'node_render_failed', { error: String(error) });

package/dist/ui/scrollback/tail-anchor.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Where the live tail sits inside the band's preview box
+ * (tui-first-reply-bottom-aligned, plan A-prime).
+ *
+ * THE DEFECT THIS ANSWERS. The box is always the whole pool (`band.previewRows`, 24 rows
+ * on a 30-row terminal) while a first turn is four rows tall. A constant
+ * `justifyContent="flex-end"` therefore pushed those four rows against the composer and
+ * left every unused row ABOVE the conversation - the "the first reply starts at the
+ * bottom of the screen" report. The answer is conditional anchoring: top while the
+ * content fits, so the conversation is written downwards from under the header.
+ *
+ * WHY THE FALLBACK IS `bottom` AND NOT THE OTHER WAY ROUND. `flex-start` inside an
+ * `overflow="hidden"` box clips the NEWEST rows (Ink's clip rectangle is the box's
+ * `[top, top + height]`), and a streaming entry is never printable
+ * (`settled-boundary.ts` holds it unstable, and "printed is forever"). Overflowing to
+ * `flex-start` would hide the text the user is waiting for; overflowing to `flex-end`
+ * hides the oldest rows, which the tail window prints on its way out.
+ *
+ * THE THRESHOLD CARRIES A MARGIN. `rowOf` is an ESTIMATE, and the one available
+ * (`layout/virtual-window.ts::estimateEntryRows`) under-counts a `#` heading and a code
+ * block. The margin in `SCROLLBACK_LIMITS.tailAnchorSlackRows` absorbs that error on the
+ * `bottom` side, the only direction that cannot clip something new.
+ *
+ * PURE: no Ink, no I/O, no clock, and deliberately no import of `virtual-window.ts` (its
+ * import graph reaches a `.tsx` gutter). The row height is injected, so this stays three
+ * parameters and a unit test can drive it with any table it likes.
+ */
+import type { Entry } from '../../agent/reducer.js';
+/** `top` = content grows down from the header; `bottom` = newest row hugs the composer. */
+export type TailAnchor = 'top' | 'bottom';
+/**
+ * Which alignment the live tail should use for the entries it is about to render.
+ *
+ * @param entries The entries THIS FRAME renders (already windowed by `selectTailEntries`;
+ * summing the whole conversation would make every session past the entry cap overflow and
+ * anchor to the bottom forever).
+ * @param budgetRows Height of the box that will clip them, in rows.
+ * @param rowOf Estimated height of one entry, including its separation row.
+ * @returns `top` when the estimates plus `tailAnchorSlackRows` fit in `budgetRows`,
+ * `bottom` otherwise (and for the first entry that does not fit, so the loop stops early).
+ */
+export declare function tailAnchor(entries: readonly Entry[], budgetRows: number, rowOf: (entry: Entry) => number): TailAnchor;
+/**
+ * The anchor this frame really uses: MEASURED when the measurement exists, estimated
+ * otherwise.
+ *
+ * WHY A MEASURED ANSWER WINS (tui-final-reply-truncated-unscrollable). The estimate is an
+ * upper bound that charges a separation row this renderer may not draw, so it can claim the
+ * content overflows while it actually fits (the block sits at the bottom of a half-empty
+ * box - the very complaint `tui-first-reply-bottom-aligned` answered) and it under-counts a
+ * heading or a wrapped code block, so it can claim the content fits while the box is really
+ * clipping. The second error is the expensive one now: "top give-way" only prints while the
+ * box is bottom-anchored (that is the branch that clips the TOP), so a wrongly top-anchored
+ * box would clip the newest rows and print the oldest ones - the wrong half, twice.
+ *
+ * A measured total is available only when every window entry is stable AND already measured
+ * at the current geometry (`use-scrollback-view.ts` keeps that cache), which is exactly the
+ * frame on which a print decision is being made. Every other frame - streaming, resize,
+ * first sight of a new entry - falls back to the estimate, unchanged.
+ *
+ * @param measuredRows Measured height of the same entries, or `undefined` when unknown.
+ */
+export declare function resolveTailAnchor(input: {
+    entries: readonly Entry[];
+    budgetRows: number;
+    rowOf: (entry: Entry) => number;
+    measuredRows: number | undefined;
+}): TailAnchor;

package/dist/ui/scrollback/tail-anchor.js

@@ -0,0 +1,77 @@
+/**
+ * Where the live tail sits inside the band's preview box
+ * (tui-first-reply-bottom-aligned, plan A-prime).
+ *
+ * THE DEFECT THIS ANSWERS. The box is always the whole pool (`band.previewRows`, 24 rows
+ * on a 30-row terminal) while a first turn is four rows tall. A constant
+ * `justifyContent="flex-end"` therefore pushed those four rows against the composer and
+ * left every unused row ABOVE the conversation - the "the first reply starts at the
+ * bottom of the screen" report. The answer is conditional anchoring: top while the
+ * content fits, so the conversation is written downwards from under the header.
+ *
+ * WHY THE FALLBACK IS `bottom` AND NOT THE OTHER WAY ROUND. `flex-start` inside an
+ * `overflow="hidden"` box clips the NEWEST rows (Ink's clip rectangle is the box's
+ * `[top, top + height]`), and a streaming entry is never printable
+ * (`settled-boundary.ts` holds it unstable, and "printed is forever"). Overflowing to
+ * `flex-start` would hide the text the user is waiting for; overflowing to `flex-end`
+ * hides the oldest rows, which the tail window prints on its way out.
+ *
+ * THE THRESHOLD CARRIES A MARGIN. `rowOf` is an ESTIMATE, and the one available
+ * (`layout/virtual-window.ts::estimateEntryRows`) under-counts a `#` heading and a code
+ * block. The margin in `SCROLLBACK_LIMITS.tailAnchorSlackRows` absorbs that error on the
+ * `bottom` side, the only direction that cannot clip something new.
+ *
+ * PURE: no Ink, no I/O, no clock, and deliberately no import of `virtual-window.ts` (its
+ * import graph reaches a `.tsx` gutter). The row height is injected, so this stays three
+ * parameters and a unit test can drive it with any table it likes.
+ */
+import { SCROLLBACK_LIMITS } from './limits.js';
+/**
+ * Which alignment the live tail should use for the entries it is about to render.
+ *
+ * @param entries The entries THIS FRAME renders (already windowed by `selectTailEntries`;
+ * summing the whole conversation would make every session past the entry cap overflow and
+ * anchor to the bottom forever).
+ * @param budgetRows Height of the box that will clip them, in rows.
+ * @param rowOf Estimated height of one entry, including its separation row.
+ * @returns `top` when the estimates plus `tailAnchorSlackRows` fit in `budgetRows`,
+ * `bottom` otherwise (and for the first entry that does not fit, so the loop stops early).
+ */
+export function tailAnchor(entries, budgetRows, rowOf) {
+    const budget = Number.isFinite(budgetRows) ? Math.max(0, Math.floor(budgetRows)) : 0;
+    let rows = 0;
+    for (const entry of entries) {
+        rows += Math.max(0, rowOf(entry));
+        if (rows + SCROLLBACK_LIMITS.tailAnchorSlackRows > budget)
+            return 'bottom';
+    }
+    return 'top';
+}
+/**
+ * The anchor this frame really uses: MEASURED when the measurement exists, estimated
+ * otherwise.
+ *
+ * WHY A MEASURED ANSWER WINS (tui-final-reply-truncated-unscrollable). The estimate is an
+ * upper bound that charges a separation row this renderer may not draw, so it can claim the
+ * content overflows while it actually fits (the block sits at the bottom of a half-empty
+ * box - the very complaint `tui-first-reply-bottom-aligned` answered) and it under-counts a
+ * heading or a wrapped code block, so it can claim the content fits while the box is really
+ * clipping. The second error is the expensive one now: "top give-way" only prints while the
+ * box is bottom-anchored (that is the branch that clips the TOP), so a wrongly top-anchored
+ * box would clip the newest rows and print the oldest ones - the wrong half, twice.
+ *
+ * A measured total is available only when every window entry is stable AND already measured
+ * at the current geometry (`use-scrollback-view.ts` keeps that cache), which is exactly the
+ * frame on which a print decision is being made. Every other frame - streaming, resize,
+ * first sight of a new entry - falls back to the estimate, unchanged.
+ *
+ * @param measuredRows Measured height of the same entries, or `undefined` when unknown.
+ */
+export function resolveTailAnchor(input) {
+    const { entries, budgetRows, rowOf, measuredRows } = input;
+    if (measuredRows === undefined || !Number.isFinite(measuredRows)) {
+        return tailAnchor(entries, budgetRows, rowOf);
+    }
+    const budget = Number.isFinite(budgetRows) ? Math.max(0, Math.floor(budgetRows)) : 0;
+    return measuredRows > budget ? 'bottom' : 'top';
+}

package/dist/ui/scrollback/tail-window.d.ts

@@ -10,22 +10,35 @@
  * only the unfinished cards on it. So the region now shows the last `K` PRINTABLE
  * entries - settled or not - and an entry is printed when it LEAVES that window.
  *
- * The window is defined by ENTRY COUNT, never by measured height: a single entry taller
- * than the region is clipped from the top by `justifyContent="flex-end"` and stays in
- * the window until `K` further entries arrive (README, known limitation 2). Measuring
- * heights here would need the offscreen renderer on every frame, which is the cost this
- * module exists to avoid.
+ * The window is defined by ENTRY COUNT, never by measured height; what a single entry
+ * taller than the region used to do is the whole subject of
+ * `overflow-print.ts` (tui-final-reply-truncated-unscrollable). The box still clips it
+ * from the top with `justifyContent="flex-end"`, but the rows it hides are now PRINTED
+ * into the terminal's scrollback, where the wheel already reaches, instead of waiting for
+ * `K` further entries (README, known limitation 2 - rewritten by that fix).
  *
  * PURE: no Ink, no I/O, no clock. `promote()` (the writer's only feeder) takes
- * `printBoundary`'s result and keeps its own `printedIds` authority, so "printed is
+ * `printBoundary`'s result and keeps its own `printed` authority, so "printed is
  * forward-only" (RV-7) is unchanged.
  *
  * PRINTABILITY != VISIBILITY. `isExcluded` entries (a non-terminal `service` card) never
  * print and never take a slot in the window; an entry that is in the window may still be
- * scrolled out of sight by a taller neighbour (README, known limitation 5). The second
- * gap is disclosed by `/perf`'s `window=<start>/<n>`, not by a second measurement.
+ * scrolled out of sight by a taller neighbour. That second gap is what the row-level plan
+ * closes, and `/perf`'s `window=<start>/<n> head=<rows>` is how it stays observable.
  */
 import type { Entry } from '../../agent/reducer.js';
+/**
+ * Entries that take NO slot in the window: they neither print nor take a row.
+ *
+ * A LIVE DISPATCH CARD JOINS THE NON-TERMINAL SERVICE CARD HERE
+ * (tui-subagent-double-roster A-2'): the roster draws the live dispatch and the
+ * transcript draws nothing, so the window must not spend one of its slots on an
+ * entry that is not on screen. THE PRINT PUMP AND THE BOX MUST AGREE ABOUT SLOTS:
+ * so both window functions below skip it, and `LiveTail.selectTailEntries` - the
+ * window function the box renders - imports this one instead of spelling the
+ * composition out a second time.
+ */
+export declare function isSlotless(entry: Entry): boolean;
 export interface TailWindow {
     /** First index of the window inside the full entry list. */
     start: number;

package/dist/ui/scrollback/tail-window.js

@@ -10,22 +10,38 @@
  * only the unfinished cards on it. So the region now shows the last `K` PRINTABLE
  * entries - settled or not - and an entry is printed when it LEAVES that window.
  *
- * The window is defined by ENTRY COUNT, never by measured height: a single entry taller
- * than the region is clipped from the top by `justifyContent="flex-end"` and stays in
- * the window until `K` further entries arrive (README, known limitation 2). Measuring
- * heights here would need the offscreen renderer on every frame, which is the cost this
- * module exists to avoid.
+ * The window is defined by ENTRY COUNT, never by measured height; what a single entry
+ * taller than the region used to do is the whole subject of
+ * `overflow-print.ts` (tui-final-reply-truncated-unscrollable). The box still clips it
+ * from the top with `justifyContent="flex-end"`, but the rows it hides are now PRINTED
+ * into the terminal's scrollback, where the wheel already reaches, instead of waiting for
+ * `K` further entries (README, known limitation 2 - rewritten by that fix).
  *
  * PURE: no Ink, no I/O, no clock. `promote()` (the writer's only feeder) takes
- * `printBoundary`'s result and keeps its own `printedIds` authority, so "printed is
+ * `printBoundary`'s result and keeps its own `printed` authority, so "printed is
  * forward-only" (RV-7) is unchanged.
  *
  * PRINTABILITY != VISIBILITY. `isExcluded` entries (a non-terminal `service` card) never
  * print and never take a slot in the window; an entry that is in the window may still be
- * scrolled out of sight by a taller neighbour (README, known limitation 5). The second
- * gap is disclosed by `/perf`'s `window=<start>/<n>`, not by a second measurement.
+ * scrolled out of sight by a taller neighbour. That second gap is what the row-level plan
+ * closes, and `/perf`'s `window=<start>/<n> head=<rows>` is how it stays observable.
  */
 import { isExcluded, settledCount } from './settled-boundary.js';
+import { isLiveTeamCard } from '../team-status.js';
+/**
+ * Entries that take NO slot in the window: they neither print nor take a row.
+ *
+ * A LIVE DISPATCH CARD JOINS THE NON-TERMINAL SERVICE CARD HERE
+ * (tui-subagent-double-roster A-2'): the roster draws the live dispatch and the
+ * transcript draws nothing, so the window must not spend one of its slots on an
+ * entry that is not on screen. THE PRINT PUMP AND THE BOX MUST AGREE ABOUT SLOTS:
+ * so both window functions below skip it, and `LiveTail.selectTailEntries` - the
+ * window function the box renders - imports this one instead of spelling the
+ * composition out a second time.
+ */
+export function isSlotless(entry) {
+    return isExcluded(entry) || isLiveTeamCard(entry);
+}
 /**
  * The index of the first entry that is still on screen: count backwards up to
  * `maxEntries` PRINTABLE entries. Everything before it has left the region and is the
@@ -41,7 +57,7 @@ export function tailWindowStart(entries, maxEntries) {
         return entries.length;
     let seen = 0;
     for (let i = entries.length - 1; i >= 0; i -= 1) {
-        if (isExcluded(entries[i]))
+        if (isSlotless(entries[i]))
             continue;
         seen += 1;
         if (seen === limit)
@@ -53,7 +69,7 @@ export function tailWindowStart(entries, maxEntries) {
 /** `entries.slice(start)` with the entries that never print dropped. */
 export function selectTailWindow(entries, maxEntries) {
     const start = tailWindowStart(entries, maxEntries);
-    return { start, entries: entries.slice(start).filter((entry) => !isExcluded(entry)) };
+    return { start, entries: entries.slice(start).filter((entry) => !isSlotless(entry)) };
 }
 /**
  * The print boundary: never print what the region is still showing.

package/dist/ui/scrollback/use-scrollback-view.d.ts

@@ -1,6 +1,7 @@
 /**
  * `useScrollbackView` — the promotion pipeline of native-scroll mode
- * (tui-native-terminal-scroll §4.4 / §6.2, tui-full-height-live-region D3/D4/D7/D8).
+ * (tui-native-terminal-scroll §4.4 / §6.2, tui-full-height-live-region D3/D4/D7/D8,
+ * tui-final-reply-truncated-unscrollable A-prime).
  *
  * `App` calls it ALWAYS (hooks cannot be conditional); `enabled: false` makes every
  * effect a no-op and keeps `scrollMode: 'app'` byte-identical to the pre-feature
@@ -12,8 +13,15 @@
  *     writer. Entries still on screen are never printed - at `H = rows - 1` a printed
  *     row is pushed back off the top by the next frame, and a second copy in the
  *     scrollback would be a duplicate the user meets by scrolling up (I-F8).
- *  2. Computes the live-region budget, the window and the tail rows for the shell.
- *  3. Flushes the window before either reset path (`/clear`, `--resume`) and on exit,
+ *  2. Gives way at the TOP (tui-final-reply-truncated-unscrollable). The window is still
+ *     counted in ENTRIES, so a settled answer taller than the box used to sit inside the
+ *     window forever, clipped by `justifyContent="flex-end"`, in a mode whose wheel only
+ *     scrolls the terminal's scrollback: the clipped rows existed nowhere the user could
+ *     reach. The rows the box hides are now measured (`overflow-print.ts`) and printed, so
+ *     `scrollback + screen` covers every row exactly once. Screen unchanged, reachability
+ *     fixed.
+ *  3. Computes the live-region budget, the window and the tail rows for the shell.
+ *  4. Flushes the window before either reset path (`/clear`, `--resume`) and on exit,
  *     so "on screen but not printed yet" can never become "lost" (D8 / I-F12).
  *
  * THE HEADER AND THE OPENER ARE NOT PRINTED HERE ANY MORE (D3/D4). They are slots of
@@ -27,13 +35,20 @@
  * issued from inside the main tree's commit (a layout effect) is deferred until that
  * commit finishes, so its frame would not exist when the effect reads it. A microtask
  * runs after the commit has unwound, where the offscreen render is synchronous again.
- * Everything the pass needs is read from refs for that reason.
  *
- * `printedIds` is the ONLY authority on "already printed" (RV-7). The cursor is just
- * a hint for where to resume scanning: entries leave the list by retain-ring
- * trimming AND by reducer deletion (empty settled assistants, abandoned tool
- * cards), so an id-keyed cursor can dangle, and then the only correct answer is to
- * rescan and let `printedIds` skip.
+ * THE PASS READS THE COMMITTED FRAME, NOT THE LATEST RENDER. `latest` is refreshed during
+ * render, so it can be a frame ahead of the screen; `committed` is written by a layout
+ * effect and therefore describes exactly the frame the user is looking at. With
+ * entry-granular bookkeeping the difference was harmless (printing was idempotent per
+ * entry); with ROW-granular bookkeeping it would slice this frame's picture with another
+ * frame's row numbers, and the result is a duplicate or a hole.
+ *
+ * `printed` is the ONLY authority on "already printed" (RV-7): a `Map` from entry id to
+ * the leading rows already handed to the writer, and the width they were measured at. The
+ * cursor is just a hint for where to resume scanning: entries leave the list by retain-ring
+ * trimming AND by reducer deletion (empty settled assistants, abandoned tool cards), so an
+ * id-keyed cursor can dangle, and then the only correct answer is to rescan and let
+ * `printed` skip.
  */
 import type { Entry } from '../../agent/reducer.js';
 import type { TermCapabilities } from '../capabilities.js';
@@ -50,7 +65,7 @@ export interface ScrollbackBridge {
     requestFlush: () => void;
     /**
      * Installed by the hook on mount (reads the latest entries through a ref).
-     * `restore()` calls it on every exit path; it is idempotent through `printedIds`
+     * `restore()` calls it on every exit path; it is idempotent through `printed`
      * and it releases the offscreen renderer when done.
      */
     settleAllNow: () => void;
@@ -89,6 +104,11 @@ export interface UseScrollbackViewArgs {
     panelEnabled: boolean;
     /** `buildTeamPanelLayout().rowCount`; 0 when nothing is dispatched. */
     teamRowsNatural: number;
+    /**
+     * `state.expandedToolIds` - REQUIRED, because the height of a window entry depends on it
+     * and a forgotten value would measure an expansion the region is not drawing.
+     */
+    expandedToolIds: Record<string, true>;
 }
 export interface ScrollbackView {
     budget: ScrollbackBudget | null;
@@ -101,6 +121,14 @@ export interface ScrollbackView {
      */
     tailEntries: readonly Entry[];
     windowStart: number;
+    /**
+     * Measured height of `tailEntries`, once every one of them is stable AND measured at the
+     * current geometry; `undefined` otherwise. `LiveTail` prefers it over the estimate - see
+     * `tail-anchor.ts::resolveTailAnchor` for why the measured answer has to win.
+     */
+    measuredTailRows: number | undefined;
+    /** Rows the top give-way has printed this session; `/perf`'s `head=`. */
+    headRows: number;
     /** Print a fresh EXPANDED copy of an entry; false when it cannot be found / rendered. */
     reprintExpanded(entryId: string): boolean;
     /** Promote everything still unprinted (shutdown) - `flushUnprinted(latest entries)`. */