@aragon-agent/cli 0.6.3 → 0.6.7

package/dist/ui/entries/UserEntry.d.ts

@@ -3,15 +3,29 @@
  *
  * The role glyph, the gutter rail and the inter-entry spacing all belong to
  * `EntryFrame` now (§4.3), so this component renders content and nothing else.
- * That is also why it takes no `caps`: it has no glyph of its own left to
- * degrade.
+ *
+ * IT DOES TAKE `caps` AS OF tui-paste-handling (G7): the row cap below needs one
+ * glyph, and a hardcoded ellipsis is the exact failure `glyphs.ts` exists to
+ * prevent. That is the only reason the earlier "it has no glyph of its own left
+ * to degrade" note no longer holds.
  */
 import React from 'react';
 import type { Theme } from '../theme.js';
-declare function UserEntryImpl({ text, theme }: {
+import type { TermCapabilities } from '../capabilities.js';
+declare function UserEntryImpl({ text, theme, caps, }: {
     text: string;
     theme: Theme;
+    caps: TermCapabilities;
 }): React.ReactElement;
+/**
+ * Rows this component renders for a given text.
+ *
+ * EXPORTED SO `virtual-window.ts` AND THIS FILE CANNOT DISAGREE (I-13). The
+ * render cap and the height estimate are ONE number; an over-estimated entry is
+ * never mounted, so it is never measured, so the estimate never self-corrects --
+ * which makes that particular disagreement permanent and silent.
+ */
+export declare function userEntryRenderedRows(lineCount: number): number;
 /**
  * `React.memo` with the DEFAULT comparator (tui-render-performance L2 / R3).
  * `mapEntry` already preserves object identity for untouched entries, so the

package/dist/ui/entries/UserEntry.js

@@ -1,16 +1,45 @@
-import { jsx as _jsx } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 /**
  * Render a user message entry.
  *
  * The role glyph, the gutter rail and the inter-entry spacing all belong to
  * `EntryFrame` now (§4.3), so this component renders content and nothing else.
- * That is also why it takes no `caps`: it has no glyph of its own left to
- * degrade.
+ *
+ * IT DOES TAKE `caps` AS OF tui-paste-handling (G7): the row cap below needs one
+ * glyph, and a hardcoded ellipsis is the exact failure `glyphs.ts` exists to
+ * prevent. That is the only reason the earlier "it has no glyph of its own left
+ * to degrade" note no longer holds.
  */
 import React from 'react';
 import { Box, Text } from 'ink';
-function UserEntryImpl({ text, theme }) {
-    return (_jsx(Box, { flexDirection: "column", children: text.split('\n').map((line, i) => (_jsx(Text, { color: theme.user, bold: i === 0, children: line }, i))) }));
+import { pickGlyphs } from '../glyphs.js';
+import { USER_ENTRY_MAX_ROWS } from '../composer-limits.js';
+function UserEntryImpl({ text, theme, caps, }) {
+    const glyphs = pickGlyphs(caps);
+    const all = text.split('\n');
+    // A submitted 5 000-line paste otherwise asks Yoga to lay out 5 000 nodes
+    // inside a measured entry -- the hazard `render-cache.ts:37` already records
+    // in the same words ("a multi-megabyte 'code block' is almost always a pasted
+    // log"). The full text stays in `ViewState` and in the exit transcript, which
+    // is deliberately NOT capped: a replay a user pipes into an issue must be
+    // complete.
+    const hidden = Math.max(0, all.length - USER_ENTRY_MAX_ROWS);
+    const shown = hidden > 0 ? all.slice(0, USER_ENTRY_MAX_ROWS) : all;
+    return (_jsxs(Box, { flexDirection: "column", children: [shown.map((line, i) => (_jsx(Text, { color: theme.user, bold: i === 0, children: line }, i))), hidden > 0 && (
+            // The tail NAMES the number of hidden rows rather than hiding them
+            // silently, which is what makes the cap honest (D-9 / R-10).
+            _jsx(Text, { color: theme.muted, children: `${glyphs.ellipsis} +${hidden} more lines` }))] }));
+}
+/**
+ * Rows this component renders for a given text.
+ *
+ * EXPORTED SO `virtual-window.ts` AND THIS FILE CANNOT DISAGREE (I-13). The
+ * render cap and the height estimate are ONE number; an over-estimated entry is
+ * never mounted, so it is never measured, so the estimate never self-corrects --
+ * which makes that particular disagreement permanent and silent.
+ */
+export function userEntryRenderedRows(lineCount) {
+    return lineCount > USER_ENTRY_MAX_ROWS ? USER_ENTRY_MAX_ROWS + 1 : lineCount;
 }
 /**
  * `React.memo` with the DEFAULT comparator (tui-render-performance L2 / R3).

package/dist/ui/exit-snapshot.d.ts

@@ -14,6 +14,15 @@
 import type { Entry, UsageTotal } from '../agent/reducer.js';
 export interface ExitSnapshot {
     entries: Entry[];
+    /**
+     * The session total, FORWARDED not copied.
+     *
+     * It gained `cacheReadTokens` / `cacheWriteTokens`
+     * (context-usage-gauge-accuracy §3.6) and this file needed no change for it,
+     * which is the point of referencing the reducer's type rather than restating
+     * its fields: `renderTranscriptText` reads the total through `promptTokensOf`,
+     * so the exit summary and the status bar cannot drift apart.
+     */
     usageTotal: UsageTotal;
     provider: string;
     model: string;

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

@@ -76,7 +76,7 @@ export interface ScrollViewportProps {
      * 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 a fifth of the frame those two
+     * 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.
      */

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

@@ -0,0 +1,18 @@
+export interface AutocompleteLayoutInput {
+    itemCount: number;
+    selected: number;
+    maxRows?: number;
+    maxHeight?: number;
+}
+export interface AutocompleteLayout {
+    start: number;
+    count: number;
+    moreBelow: number;
+    showMore: boolean;
+    rowCount: number;
+}
+/** Window suggestions within a total row budget including borders and footer.
+ * Only omitted maxHeight is unlimited. Explicit invalid numbers become zero.
+ * Selection is clamped to the available items; no input is mutated or rejected.
+ */
+export declare function buildAutocompleteLayout(input: AutocompleteLayoutInput): AutocompleteLayout;

package/dist/ui/layout/autocomplete.js

@@ -0,0 +1,26 @@
+/** Window suggestions within a total row budget including borders and footer.
+ * Only omitted maxHeight is unlimited. Explicit invalid numbers become zero.
+ * Selection is clamped to the available items; no input is mutated or rejected.
+ */
+export function buildAutocompleteLayout(input) {
+    const total = nonNegativeInt(input.itemCount);
+    const maxRows = input.maxRows === undefined ? 6 : nonNegativeInt(input.maxRows);
+    const height = input.maxHeight === undefined ? Infinity : nonNegativeInt(input.maxHeight);
+    if (total === 0 || maxRows === 0 || height < 3) {
+        return { start: 0, count: 0, moreBelow: 0, showMore: false, rowCount: 0 };
+    }
+    const selected = Math.min(total - 1, nonNegativeInt(input.selected));
+    let count = Math.min(total, maxRows, height - 2);
+    const windowStart = () => Math.max(0, Math.min(selected - count + 1, total - count));
+    let start = windowStart();
+    if (count >= 2 && start + count < total && count + 3 > height) {
+        count--;
+        start = windowStart();
+    }
+    const moreBelow = total - start - count;
+    const showMore = moreBelow > 0 && count + 3 <= height;
+    return { start, count, moreBelow, showMore, rowCount: 2 + count + Number(showMore) };
+}
+function nonNegativeInt(value) {
+    return Number.isFinite(value) ? Math.max(0, Math.floor(value)) : 0;
+}

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

@@ -30,11 +30,26 @@ export interface ChromeBudget {
     /** Brand bar. Constant 1 in full-screen — this is what makes A-3 hold. */
     header: number;
     toast: number;
-    /** Round border (2) + input row (1), plus the hint row when it fits. */
+    /**
+     * Round border (2) + the DRAFT's own rows, plus the hint row when it fits.
+     *
+     * The draft term used to be the constant 1 that the `3` / `4` below encode.
+     * That constant is what made a pasted 200-line draft draw the transcript 197
+     * rows shorter than every consumer of `viewportRows` believed -- the trap
+     * `BottomStatusRow.tsx:5-27` already documents at 1/200th the magnitude.
+     */
     composer: number;
     status: number;
 }
-export declare function chromeBudget(rows: number): ChromeBudget;
+/**
+ * The composer's draft rows, clamped to what this terminal height allows.
+ *
+ * Exported so the reporter and the budget clamp with ONE function: I-8 requires
+ * the rendered row count and the number handed to `viewportRows` to be the same
+ * number, and two clamps are how they stop being.
+ */
+export declare function clampDraftRows(rows: number, draftRows: number): number;
+export declare function chromeBudget(rows: number, draftRows?: number): ChromeBudget;
 /**
  * Rows available to the viewport at a given terminal height.
  *
@@ -42,8 +57,21 @@ export declare function chromeBudget(rows: number): ChromeBudget;
  * that argument is the guarantee that the first submitted message cannot make
  * the layout jump (A-4). Do not add it back.
  *
- * Non-decreasing in `rows`: the one step where chrome grows (the hint row at
- * `HINT_MIN_ROWS`) coincides with `rows` growing by one, so the net change is 0
- * rather than -1.
+ * `draftRows` IS NOT THAT ARGUMENT, and the distinction is the whole of D-12.
+ * A-4 forbids making the budget depend on TRANSCRIPT content, so that the first
+ * submitted message cannot move the layout. `draftRows` depends only on what the
+ * user is typing right now, and its whole purpose is that the jump is ALREADY
+ * HAPPENING -- Yoga takes the rows out of the transcript whether or not this
+ * function was told. `App` adds the hysteresis (grow now, shrink one tick later)
+ * that keeps it from becoming per-keystroke jitter.
+ *
+ * It DEFAULTS TO 1, i.e. to the constant this function used to assume, so every
+ * pre-existing caller and every pre-existing assertion is byte-identical -- and
+ * `viewportRows.length` stays 1, because a parameter with a default does not
+ * count toward it.
+ *
+ * Non-decreasing in `rows` at a fixed `draftRows = 1`: the one step where chrome
+ * grows (the hint row at `HINT_MIN_ROWS`) coincides with `rows` growing by one,
+ * so the net change is 0 rather than -1.
  */
-export declare function viewportRows(rows: number): number;
+export declare function viewportRows(rows: number, draftRows?: number): number;

package/dist/ui/layout/budget.js

@@ -24,14 +24,26 @@
  * make this comment a true-sounding statement about a row that is gone (AC-12,
  * and the `wheel-scrolls-transcript-only` RV-3 lesson).
  */
+import { draftMaxRows } from '../composer-limits.js';
 import { frameHeight, MIN_FULLSCREEN_ROWS } from './frame.js';
 /** Below this many rows the composer's hint line is dropped to buy back a row. */
 export const HINT_MIN_ROWS = 20;
-export function chromeBudget(rows) {
+/**
+ * The composer's draft rows, clamped to what this terminal height allows.
+ *
+ * Exported so the reporter and the budget clamp with ONE function: I-8 requires
+ * the rendered row count and the number handed to `viewportRows` to be the same
+ * number, and two clamps are how they stop being.
+ */
+export function clampDraftRows(rows, draftRows) {
+    const wanted = Number.isFinite(draftRows) ? Math.floor(draftRows) : 1;
+    return Math.max(1, Math.min(wanted, draftMaxRows(rows)));
+}
+export function chromeBudget(rows, draftRows = 1) {
     return {
         header: 1,
         toast: 1,
-        composer: rows >= HINT_MIN_ROWS ? 4 : 3,
+        composer: 2 + clampDraftRows(rows, draftRows) + (rows >= HINT_MIN_ROWS ? 1 : 0),
         status: 1,
     };
 }
@@ -42,13 +54,26 @@ export function chromeBudget(rows) {
  * that argument is the guarantee that the first submitted message cannot make
  * the layout jump (A-4). Do not add it back.
  *
- * Non-decreasing in `rows`: the one step where chrome grows (the hint row at
- * `HINT_MIN_ROWS`) coincides with `rows` growing by one, so the net change is 0
- * rather than -1.
+ * `draftRows` IS NOT THAT ARGUMENT, and the distinction is the whole of D-12.
+ * A-4 forbids making the budget depend on TRANSCRIPT content, so that the first
+ * submitted message cannot move the layout. `draftRows` depends only on what the
+ * user is typing right now, and its whole purpose is that the jump is ALREADY
+ * HAPPENING -- Yoga takes the rows out of the transcript whether or not this
+ * function was told. `App` adds the hysteresis (grow now, shrink one tick later)
+ * that keeps it from becoming per-keystroke jitter.
+ *
+ * It DEFAULTS TO 1, i.e. to the constant this function used to assume, so every
+ * pre-existing caller and every pre-existing assertion is byte-identical -- and
+ * `viewportRows.length` stays 1, because a parameter with a default does not
+ * count toward it.
+ *
+ * Non-decreasing in `rows` at a fixed `draftRows = 1`: the one step where chrome
+ * grows (the hint row at `HINT_MIN_ROWS`) coincides with `rows` growing by one,
+ * so the net change is 0 rather than -1.
  */
-export function viewportRows(rows) {
+export function viewportRows(rows, draftRows = 1) {
     if (!Number.isFinite(rows) || rows < MIN_FULLSCREEN_ROWS)
         return 0;
-    const c = chromeBudget(rows);
+    const c = chromeBudget(rows, draftRows);
     return Math.max(0, frameHeight(rows) - c.header - c.toast - c.composer - c.status);
 }

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

@@ -1,56 +1,7 @@
-/**
- * Rail geometry (todo-plan-execution §3.9) — the ONE place that says how wide
- * and how tall the todo rail is allowed to be.
- *
- * Pure and React-free, mirroring `budget.ts`, so `todo-rail.test.ts` can pin the
- * arithmetic without mounting anything. Deliberately NOT part of `budget.ts`:
- * that module answers "how many ROWS does the viewport get" and stays a function
- * of `rows` alone; the rail spends COLUMNS.
- *
- * NAMED FOR ITS POSITION, NOT ITS CONTENT, like `AppShellProps.rail` (D-18):
- * this is a layout primitive and `viewportRows` is its neighbour, not
- * `TodoPanel`.
- */
-/** Below this the marker + a two-word title do not fit and the column is noise. */
-export declare const TODO_RAIL_MIN_COLS = 18;
-/**
- * Above this, 20% is being spent on whitespace: at 36 columns a step title
- * already fits on one line, and the transcript is the surface that benefits from
- * a 200-column terminal. A deliberate, revertible deviation from a literal
- * reading of R-e; it only binds above 180 columns.
- */
+export declare const TODO_RAIL_MIN_COLS = 14;
 export declare const TODO_RAIL_MAX_COLS = 36;
-/** Under 80 columns the transcript needs every column; no rail at all. */
-export declare const TODO_RAIL_MIN_TOTAL_COLS = 80;
-/** Below this rail width the 2-column index prefix is dropped for content. */
+export declare const TODO_TRANSCRIPT_MIN_COLS = 62;
+export declare const TODO_RAIL_MIN_TOTAL_COLS: number;
 export declare const TODO_RAIL_INDEX_MIN_COLS = 22;
-/**
- * Two properties are pinned by tests, for the reason `budget.ts` records about
- * the viewport being non-monotonic before anyone measured it:
- *
- *  - NON-DECREASING in `cols` across [40, 300]. A user dragging a window wider
- *    must never see the rail get narrower.
- *  - `cols - todoRailWidth(cols) >= 62` for every `cols >= 80`. Every existing
- *    width heuristic inside the viewport (`TERSE_HINT_COLS` 42,
- *    `MIN_INDICATOR_COLS` 50, the status bar's 60/72 steps) sits below that
- *    floor, so no existing behaviour changes because a rail appeared (R-3).
- */
+/** Return a non-decreasing rail width; invalid or narrow terminals have no rail. */
 export declare function todoRailWidth(cols: number): number;
-/**
- * How many rows the rail may actually draw.
- *
- * IT IS NOT `viewportBudget`, AND THE DIFFERENCE IS NOT COSMETIC (P1-3 / D-23).
- * `viewportRows()` subtracts the STATIC chrome only, and says so; the live team
- * roster is mounted inside `AppShell`'s measured bottom box, where it costs a
- * header row, up to `TEAM_LIMITS.panelMaxRows` child rows, a `+N more` row and a
- * mail row that `viewportBudget` knows nothing about. `ScrollViewport` is immune
- * because it MEASURES itself; the rail does not measure - a second
- * measure -> setState -> measure loop is exactly what §1.2 refuses - so it has
- * to subtract.
- *
- * Ink clips overflow from the BOTTOM, so an over-request does not error: it
- * silently eats the last row, which is the `+N below` marker - the one row whose
- * absence is indistinguishable from "the list is short". That is why this is
- * arithmetic rather than a shrug at `overflow: hidden`.
- */
-export declare function todoRailRows(viewportBudget: number, teamActive: boolean): number;

package/dist/ui/layout/rail.js

@@ -1,68 +1,16 @@
-/**
- * Rail geometry (todo-plan-execution §3.9) — the ONE place that says how wide
- * and how tall the todo rail is allowed to be.
- *
- * Pure and React-free, mirroring `budget.ts`, so `todo-rail.test.ts` can pin the
- * arithmetic without mounting anything. Deliberately NOT part of `budget.ts`:
- * that module answers "how many ROWS does the viewport get" and stays a function
- * of `rows` alone; the rail spends COLUMNS.
- *
- * NAMED FOR ITS POSITION, NOT ITS CONTENT, like `AppShellProps.rail` (D-18):
- * this is a layout primitive and `viewportRows` is its neighbour, not
- * `TodoPanel`.
- */
-import { TODO_LIMITS } from '../../todo/limits.js';
-/** R-e, literally: the rail asks for a fifth of the terminal. */
-const RAIL_FRACTION = 0.2;
-/** Below this the marker + a two-word title do not fit and the column is noise. */
-export const TODO_RAIL_MIN_COLS = 18;
-/**
- * Above this, 20% is being spent on whitespace: at 36 columns a step title
- * already fits on one line, and the transcript is the surface that benefits from
- * a 200-column terminal. A deliberate, revertible deviation from a literal
- * reading of R-e; it only binds above 180 columns.
- */
+/** Responsive TODO rail widths, measured in terminal columns including chrome. */
+const RAIL_FRACTION = 0.15;
+export const TODO_RAIL_MIN_COLS = 14;
 export const TODO_RAIL_MAX_COLS = 36;
-/** Under 80 columns the transcript needs every column; no rail at all. */
-export const TODO_RAIL_MIN_TOTAL_COLS = 80;
-/** Below this rail width the 2-column index prefix is dropped for content. */
+export const TODO_TRANSCRIPT_MIN_COLS = 62;
+export const TODO_RAIL_MIN_TOTAL_COLS = TODO_TRANSCRIPT_MIN_COLS + TODO_RAIL_MIN_COLS;
 export const TODO_RAIL_INDEX_MIN_COLS = 22;
-/**
- * Two properties are pinned by tests, for the reason `budget.ts` records about
- * the viewport being non-monotonic before anyone measured it:
- *
- *  - NON-DECREASING in `cols` across [40, 300]. A user dragging a window wider
- *    must never see the rail get narrower.
- *  - `cols - todoRailWidth(cols) >= 62` for every `cols >= 80`. Every existing
- *    width heuristic inside the viewport (`TERSE_HINT_COLS` 42,
- *    `MIN_INDICATOR_COLS` 50, the status bar's 60/72 steps) sits below that
- *    floor, so no existing behaviour changes because a rail appeared (R-3).
- */
+/** Return a non-decreasing rail width; invalid or narrow terminals have no rail. */
 export function todoRailWidth(cols) {
-    if (!Number.isFinite(cols) || cols < TODO_RAIL_MIN_TOTAL_COLS)
+    if (!Number.isFinite(cols))
         return 0;
-    return Math.min(TODO_RAIL_MAX_COLS, Math.max(TODO_RAIL_MIN_COLS, Math.round(cols * RAIL_FRACTION)));
-}
-/**
- * How many rows the rail may actually draw.
- *
- * IT IS NOT `viewportBudget`, AND THE DIFFERENCE IS NOT COSMETIC (P1-3 / D-23).
- * `viewportRows()` subtracts the STATIC chrome only, and says so; the live team
- * roster is mounted inside `AppShell`'s measured bottom box, where it costs a
- * header row, up to `TEAM_LIMITS.panelMaxRows` child rows, a `+N more` row and a
- * mail row that `viewportBudget` knows nothing about. `ScrollViewport` is immune
- * because it MEASURES itself; the rail does not measure - a second
- * measure -> setState -> measure loop is exactly what §1.2 refuses - so it has
- * to subtract.
- *
- * Ink clips overflow from the BOTTOM, so an over-request does not error: it
- * silently eats the last row, which is the `+N below` marker - the one row whose
- * absence is indistinguishable from "the list is short". That is why this is
- * arithmetic rather than a shrug at `overflow: hidden`.
- */
-export function todoRailRows(viewportBudget, teamActive) {
-    if (!Number.isFinite(viewportBudget))
+    const columns = Math.floor(cols);
+    if (columns < TODO_RAIL_MIN_TOTAL_COLS)
         return 0;
-    const reserved = teamActive ? TODO_LIMITS.railReservedRows : 0;
-    return Math.max(0, viewportBudget - reserved);
+    return Math.min(TODO_RAIL_MAX_COLS, Math.max(TODO_RAIL_MIN_COLS, Math.round(columns * RAIL_FRACTION)));
 }

package/dist/ui/layout/team-panel.d.ts

@@ -0,0 +1,18 @@
+import type { SubagentRun, TeamSnapshot } from '../../team/types.js';
+export interface TeamPanelLayout {
+    collapsed: boolean;
+    rowCount: number;
+    visible: SubagentRun[];
+    hiddenTotal: number;
+    hiddenRunning: number;
+}
+export interface TeamPanelLayoutInput {
+    snapshot: TeamSnapshot | null;
+    terminalRows: number;
+    availableRows: number;
+}
+/** Project actual roster rows, preserving three middle rows when expanded.
+ * Invalid geometry becomes zero; legacy callers may pass positive Infinity
+ * for an unlimited available-row budget. Does not throw or mutate the snapshot.
+ */
+export declare function buildTeamPanelLayout(input: TeamPanelLayoutInput): TeamPanelLayout;

package/dist/ui/layout/team-panel.js

@@ -0,0 +1,22 @@
+import { TEAM_LIMITS } from '../../team/limits.js';
+import { selectPanelRows } from '../../team/panel-rows.js';
+import { TODO_LIMITS } from '../../todo/limits.js';
+/** Project actual roster rows, preserving three middle rows when expanded.
+ * Invalid geometry becomes zero; legacy callers may pass positive Infinity
+ * for an unlimited available-row budget. Does not throw or mutate the snapshot.
+ */
+export function buildTeamPanelLayout(input) {
+    const available = input.availableRows === Infinity ? Infinity : nonNegativeInt(input.availableRows);
+    if (!input.snapshot || available < 1) {
+        return { collapsed: true, rowCount: 0, visible: [], hiddenTotal: 0, hiddenRunning: 0 };
+    }
+    const selection = selectPanelRows(input.snapshot.runs, TEAM_LIMITS.panelMaxRows);
+    const natural = 1 + selection.visible.length + Number(selection.hiddenTotal > 0)
+        + Number(Boolean(input.snapshot.lastMessage));
+    const collapsed = nonNegativeInt(input.terminalRows) < TEAM_LIMITS.panelCollapseRows
+        || available - natural < TODO_LIMITS.panelMinRows;
+    return { ...selection, collapsed, rowCount: collapsed ? 1 : natural };
+}
+function nonNegativeInt(value) {
+    return Number.isFinite(value) ? Math.max(0, Math.floor(value)) : 0;
+}

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

@@ -0,0 +1,24 @@
+import type { RenderMode } from './frame.js';
+export interface TodoRailLayoutInput {
+    mode: RenderMode;
+    cols: number;
+    panelEnabled: boolean;
+    overlayOpen: boolean;
+    itemCount: number;
+    viewportBudget: number;
+    teamRows: number;
+    popupRows: number;
+}
+export interface TodoRailLayout {
+    visible: boolean;
+    reason: 'visible' | 'inline' | 'disabled' | 'overlay' | 'empty' | 'narrow' | 'short';
+    width: number;
+    rows: number;
+    contentCols: number;
+    popupMaxHeight: number;
+}
+/** Allocate columns and rows from the same team/menu projections as the renderers.
+ * Invalid geometry becomes zero, excess team/menu rows are clamped. Menu capacity
+ * never depends on menu occupancy or rail visibility, preventing feedback loops.
+ */
+export declare function buildTodoRailLayout(input: TodoRailLayoutInput): TodoRailLayout;

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

@@ -0,0 +1,27 @@
+import { TODO_LIMITS } from '../../todo/limits.js';
+import { todoRailWidth } from './rail.js';
+/** Allocate columns and rows from the same team/menu projections as the renderers.
+ * Invalid geometry becomes zero, excess team/menu rows are clamped. Menu capacity
+ * never depends on menu occupancy or rail visibility, preventing feedback loops.
+ */
+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 popupRows = popupMaxHeight < 3 ? 0 : Math.min(nonNegativeInt(input.popupRows), popupMaxHeight);
+    const rows = budget - teamRows - popupRows;
+    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 visible = reason === 'visible';
+    return { visible, reason, width, rows, contentCols: cols - (visible ? width : 0), popupMaxHeight };
+}
+function nonNegativeInt(value) {
+    return Number.isFinite(value) ? Math.max(0, Math.floor(value)) : 0;
+}

package/dist/ui/layout/virtual-window.js

@@ -35,6 +35,7 @@
 import { FAST_LIMITS } from '../../fast/limits.js';
 import { COMPACTION_LIMITS } from '../../compaction/limits.js';
 import { GUTTER_WIDTH } from './Gutter.js';
+import { USER_ENTRY_MAX_ROWS } from '../composer-limits.js';
 export const VIRTUAL_LIMITS = {
     /**
      * Entries kept mounted on each side of the visible band.
@@ -123,6 +124,22 @@ export function entryRevision(entry) {
          */
         case 'compaction':
             return `c${entry.live ? 1 : 0}.${entry.summary?.length ?? 0}.${entry.mode}.${entry.applied ? 1 : 0}`;
+        /**
+         * `rowsSeen`, AND NEVER `rows.length` (background-service-supervision P0-3).
+         *
+         * The service tail is a FIXED-SIZE RING: it evicts its oldest row while
+         * appending a new one, so the joined length is unchanged while the content is
+         * not. That is verbatim the NON-APPEND mutation I-L3-1 above says must extend
+         * the revision, and it is the same trap — and the same fix — as the `tool`
+         * branch's `liveSeq` two cases up. A length term would go on matching while
+         * the card changed underneath it, and the card would freeze at a stale height
+         * AND a stale rendered subtree with nothing anywhere reporting it.
+         *
+         * `status` and the presence of a URL are in because both change the rows the
+         * card draws; `exitCode` is in because the terminal row names it.
+         */
+        case 'service':
+            return `v${entry.status}.${entry.rowsSeen}.${entry.url ? 1 : 0}.${entry.exitCode ?? -1}.${entry.terminal ? 1 : 0}`;
         default:
             return 'x';
     }
@@ -164,6 +181,10 @@ const TOOL_COLLAPSED_LINES = 8;
 const DIFF_COLLAPSED_LINES = 12;
 /** Live tail rows in `ToolCard`; duplicated as a NUMBER, for the same reason. */
 const TOOL_LIVE_TAIL_ROWS = 8;
+/** Tail rows a COLLAPSED `ServiceCard` draws; duplicated for the same reason. */
+const SERVICE_COLLAPSED_TAIL_ROWS = 2;
+/** Tail rows an EXPANDED `ServiceCard` draws; the snapshot cap (8). */
+const SERVICE_EXPANDED_TAIL_ROWS = 8;
 /**
  * Pure UPPER-BOUND estimate of an entry's height, used until a real measurement
  * exists.
@@ -181,7 +202,14 @@ export function estimateEntryRows(entry, cols, density, expanded, thinkingVisibl
     const separation = density === 'comfortable' ? 1 : 0;
     switch (entry.kind) {
         case 'user':
-            return separation + wrappedRows(entry.text, usable);
+            // MIRRORS `UserEntry`'s RENDER CAP (+1 for the `... +N more lines` tail).
+            // THESE TWO NUMBERS ARE ONE NUMBER (I-13). Capping the renderer alone
+            // would leave this function believing a 5 000-line message is 5 000 rows
+            // tall -- and unlike an ordinary over-estimate that failure does NOT
+            // self-correct: this file's own note above records that "an entry
+            // estimated at 400 rows is exactly the one that never gets mounted", and
+            // an unmounted entry is never measured.
+            return (separation + Math.min(wrappedRows(entry.text, usable), USER_ENTRY_MAX_ROWS + 1));
         case 'notice':
             return separation + wrappedRows(entry.text, usable);
         case 'assistant': {
@@ -277,6 +305,28 @@ export function estimateEntryRows(entry, cols, density, expanded, thinkingVisibl
             const footer = lines > body || (expanded && lines > COMPACTION_LIMITS.cardTextRows) ? 1 : 0;
             return separation + 1 + 1 + body + footer;
         }
+        /**
+         * THE THIRD SWITCH, and adding the case to only one of this file's two
+         * yields a transcript whose scroll arithmetic disagrees with what it drew —
+         * drift rather than an error (P0-3 / RV-13). Both `default` branches swallow
+         * an unknown kind silently, and `virtual-window.test.ts` hand-enumerates
+         * kinds, so neither omission turns anything red on its own.
+         *
+         * A terminal record is exactly one row. A live card is the status row, the
+         * URL row when there is one, and the tail — counted, not wrapped, which is
+         * legitimate only because every row is `wrap="truncate"` AND clipped at
+         * `LIVE_ROW_MAX_CHARS` on the way into the ring, the same coupling the
+         * `tool` branch above records for itself.
+         */
+        case 'service': {
+            if (entry.terminal)
+                return separation + 1;
+            const url = entry.url ? 1 : 0;
+            const tail = expanded
+                ? Math.min(entry.rows.length, SERVICE_EXPANDED_TAIL_ROWS)
+                : Math.min(entry.rows.length, SERVICE_COLLAPSED_TAIL_ROWS);
+            return separation + 1 + url + tail;
+        }
         default:
             return separation + 1;
     }

package/dist/ui/overlays/HelpOverlay.js

@@ -26,6 +26,9 @@ function keyRows(times) {
         // startup notice is the other place, and it scrolls away.
         ['Drag (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.
+        ['Paste', 'Inserted as-is up to 6 lines; larger becomes [Pasted text #N] (--no-paste)'],
     ];
 }
 const COMMANDS = [

package/dist/ui/overlays/PlanReviewOverlay.js

@@ -27,6 +27,7 @@ import { Text, useInput } from 'ink';
 import { pickGlyphs } from '../glyphs.js';
 import { OverlayFrame } from '../layout/OverlayFrame.js';
 import { wrapToRows } from '../layout/wrap-rows.js';
+import { stripPasteFrames } from '../paste-frames.js';
 /** The frame's border plus its one-column padding on each side. */
 const FRAME_CHROME_COLS = 4;
 export function PlanReviewOverlay({ plan, maxRows, cols, scrollOffset, onScrollClamp, theme, caps, onVerdict, }) {
@@ -55,8 +56,15 @@ export function PlanReviewOverlay({ plan, maxRows, cols, scrollOffset, onScrollC
                 setFeedback(feedback.slice(0, -1));
                 return;
             }
-            if (input && !key.ctrl && !key.meta && !key.tab)
-                setFeedback(feedback + input);
+            // `stripPasteFrames`, NOT `input` (I-12 / P0-2). This is the THIRD consumer
+            // that appends `input` to a string; the design's table listed it as
+            // "key-driven only, inert", which was true of the version that had no
+            // free-text field. Revision feedback is exactly the kind of thing a user
+            // pastes — a failing test, a stack trace — and a framed paste appended
+            // verbatim would put NULs into text the model then reads.
+            if (input && !key.ctrl && !key.meta && !key.tab) {
+                setFeedback(feedback + stripPasteFrames(input));
+            }
             return;
         }
         if (input === 'a' || input === 'A')