@aragon-agent/cli 0.6.8 → 0.6.9

package/dist/ui/Transcript.js

@@ -1,33 +1,8 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-/**
- * Transcript (spec §3.8). Splits the entry list into a settled prefix rendered
- * once into Ink's `<Static>` (native terminal scrollback, never re-rendered)
- * and a live tail rendered normally. This kills per-token full re-renders and
- * flicker on long/fast sessions.
- *
- * `computeSettledCount` is pure and exported for `transcript-static.test.ts`.
- * The settled boundary is held MONOTONIC at render time: a previously-settled
- * entry never leaves `<Static>` (which cannot un-print it) even if it later
- * becomes expanded, so the live tail can never duplicate a scrolled-off entry.
- *
- * `EntryView` is shared by both render paths ON PURPOSE (§4.3 / §12). Forking it
- * to freeze inline's v0.2.0 output would mean writing every future entry-layer
- * change twice and watching the two drift; inline is a degradation path, not a
- * parallel product. What inline still guarantees is its GEOMETRY contract — no
- * fixed frame, `<Static>` keeps the settled history, no private ANSI — not its
- * pixel-for-pixel appearance.
- *
- * Two things changed with tui-render-performance:
- *   - `EntryView` is `React.memo`'d with an explicit comparator (L2 / R3), which
- *     is only worth anything because `mapEntry` already preserves object
- *     identity for untouched entries;
- *   - `TranscriptList` (the FULL-SCREEN body) mounts only the entries inside the
- *     viewport and replaces the rest with two spacer boxes (L3 / R1), and the
- *     inline `Transcript` clamps its live region so `ink.js:121` is unreachable
- *     (L5 / R6).
- */
-import React, { useCallback, useRef } from 'react';
-import { Box, Static, Text } from 'ink';
+/** Virtualized full-screen transcript and entry cards. */
+/** Virtualized full-screen transcript and shared entry cards. */
+import React, { useCallback } from 'react';
+import { Box, Text } from 'ink';
 import Spinner from 'ink-spinner';
 import { pickGlyphs, toolGlyph } from './glyphs.js';
 import { separationRows } from './density.js';
@@ -45,98 +20,6 @@ import { MeasuredEntry } from './layout/MeasuredEntry.js';
 import { useViewportGeometry } from './layout/viewport-geometry.js';
 import { estimateEntryRows, heightKey, selectWindow, VIRTUAL_LIMITS, } from './layout/virtual-window.js';
 import { advanceTailRows } from './layout/follow-state.js';
-import { useTerminalSize } from './layout/useTerminalSize.js';
-/** Keep the last K entries in the live region so a mutating tail stays hot. */
-const LIVE_TAIL = 1;
-/**
- * Rows the inline live region leaves for the composer, the prompt echo and the
- * one-row margin Ink needs before `outputHeight >= stdout.rows` (I-L5-1).
- */
-const INLINE_LIVE_MARGIN = 4;
-/** Floor on the clamp, so a very short terminal still shows something useful. */
-const INLINE_LIVE_MIN_ROWS = 4;
-/**
- * Largest prefix length P such that `entries[0..P)` are all terminal, none is
- * within the last `LIVE_TAIL` entries, and none is currently expanded. Pure and
- * non-decreasing as entries terminalize (expanding a card can lower it — the
- * component clamps with a monotonic high-water mark to avoid Static duplication).
- */
-export function computeSettledCount(entries, expandedToolIds) {
-    const limit = entries.length - LIVE_TAIL;
-    let count = 0;
-    for (let i = 0; i < entries.length; i += 1) {
-        if (i >= limit)
-            break;
-        const e = entries[i];
-        if (expandedToolIds[e.id])
-            break;
-        if (e.kind === 'assistant' && e.streaming)
-            break;
-        if (e.kind === 'tool' && e.status !== 'done' && e.status !== 'error')
-            break;
-        // A live dispatch is not settled: its `runs` are rewritten on every
-        // `teamUpdate`, and `<Static>` cannot un-print what it has already drawn.
-        // The boundary is held MONOTONIC above, which is also why a `team` entry
-        // that never settles would be re-rendered on every frame for the rest of the
-        // session — the failure `session/persist.ts` normalizes away on load (P1-5).
-        if (e.kind === 'team' && e.active)
-            break;
-        // A live todo card is not settled either: it is rewritten on every
-        // `todoUpdate` for the whole turn, and `<Static>` cannot un-print what it has
-        // already drawn (C-5 / I-6). `session/persist.ts` forces `live: false` on
-        // load, which is the other half — a card that never settles is re-rendered
-        // on every frame for the rest of the session.
-        if (e.kind === 'todo' && e.live)
-            break;
-        // Nor is a retry card that is still counting down or still in flight: it is
-        // rewritten on every `retryScheduled` / `retryAttempt` and once a second by
-        // `retryTick`, and `<Static>` cannot un-print what it has already drawn.
-        // `session/persist.ts` forces a loaded card to `interrupted`, which is the
-        // other half — a card that never settles is re-rendered on every frame for
-        // the rest of the session (R-10).
-        if (e.kind === 'retry' && (e.phase === 'waiting' || e.phase === 'retrying'))
-            break;
-        // A live review card is not settled either: it is rewritten once, when the
-        // call comes back, and `<Static>` cannot un-print what it has already drawn
-        // (C-5). `session/persist.ts` forces `live: false` on load, which is the
-        // other half.
-        if (e.kind === 'fast' && e.live)
-            break;
-        // Nor is a compaction card whose call is still open: it is rewritten once,
-        // when the engine reports its verdict, and `<Static>` cannot un-print what it
-        // has already drawn (C-8). `session/persist.ts` forces `live: false` on load,
-        // which is the other half.
-        if (e.kind === 'compaction' && e.live)
-            break;
-        /**
-         * A SERVICE BLOCKS ONLY WHILE IT IS `starting` (D-11 / P0-4).
-         *
-         * Every clause above is bounded by an OPERATION — a dispatch, a turn, one
-         * LLM call, one countdown — which is why each of them can safely pin this
-         * prefix scan: the wait is short and it ends. A service is bounded by the
-         * USER'S INTENT. A dev server left up for an hour is the normal case, not
-         * the pathological one, so treating it like the other five would pin the
-         * boundary at the card and re-render the whole transcript from there on
-         * EVERY FRAME, FOREVER, on exactly the long sessions where it is least
-         * likely to be noticed.
-         *
-         * `starting` is different, and it is different for the reason that makes
-         * every other clause here legitimate: it is bounded by `readyTimeoutMs`,
-         * after which the supervisor calls the service `running` whatever happened.
-         *
-         * The cost of the rest is that a printed card stops mirroring live state —
-         * which is what a transcript IS. A terminal transition appends a NEW one-row
-         * entry rather than rewriting a card `<Static>` has already drawn, and live
-         * state lives in the status chip, `/bg` and `bash_output`. Weakening this to
-         * "any non-terminal service blocks" is the change D-11 exists to prevent;
-         * see condition 5 of the design's review verdict before making it.
-         */
-        if (e.kind === 'service' && e.status === 'starting')
-            break;
-        count = i + 1;
-    }
-    return count;
-}
 /**
  * The value `EntryView` should receive for `nowSec` on THIS entry.
  *
@@ -168,7 +51,7 @@ function noticeSymbol(level, theme) {
         return theme.symbols.warn;
     return theme.symbols.info;
 }
-function EntryViewImpl({ entry, prev, expanded, thinkingVisible, reducedMotion, density, mode, theme, caps, liveClampRows, nowSec, }) {
+function EntryViewImpl({ entry, prev, expanded, thinkingVisible, reducedMotion, density, theme, caps, nowSec, }) {
     const glyphs = pickGlyphs(caps);
     const separation = separationRows(prev, entry, density);
     const frame = (glyph, color, children) => (_jsx(EntryFrame, { glyph: glyph, color: color, continuation: glyphs.railVertical, separation: separation, spacerColor: theme.border, children: children }));
@@ -176,32 +59,14 @@ function EntryViewImpl({ entry, prev, expanded, thinkingVisible, reducedMotion,
         case 'user':
             return frame(glyphs.user, theme.user, _jsx(UserEntry, { text: entry.text, theme: theme, caps: caps }));
         case 'assistant': {
-            // While text streams, the spinner IS the role marker. Braille dots are
-            // both an animation and a Unicode-only glyph, so reduced motion and an
-            // ASCII terminal fall back to the same static marker (P2-11 / A-10).
-            //
-            // `reducedMotion` ARRIVES PRE-WIDENED FROM `App`: it is now
-            // `cfg.reducedMotion || activityVisible`, so this marker is static for the
-            // whole of every run and the activity row above the composer carries the
-            // one animation (single-spinner-while-running D-2). Nothing here changes —
-            // the expression already meant "do not animate here".
-            //
-            // THAT IS SAFE FOR `<Static>` BY CONSTRUCTION, not by luck: a settled
-            // prefix is printed once and can never be re-printed, so a boolean that
-            // changed how an already-printed entry renders would tear the history.
-            // `computeSettledCount` below breaks on EVERY condition that makes an
-            // entry animate (`:84` streaming, `:85` running tool, `:91` active team,
-            // `:104` retry, `:109` live fast), so every animating entry is in the live
-            // region and every entry in `<Static>` already has `animate === false` on
-            // both sides of the flip. Weakening a break clause breaks that proof.
             const animate = entry.streaming && !reducedMotion && caps.unicode;
             return frame(animate ? _jsx(Spinner, { type: "dots" }) : glyphs.assistant, theme.primary, _jsx(AssistantEntry, { text: entry.text, thinking: entry.thinking, thinkingOpen: entry.thinkingOpen, thinkingVisible: thinkingVisible, streaming: entry.streaming, aborted: entry.aborted, 
                 // `EntryViewImpl` hands each renderer EXPLICIT SCALAR PROPS, so
                 // nothing on the entry reaches a component by itself (P1-6b).
-                thinkingMs: entry.thinkingMs, revealable: mode === 'fullscreen', liveClampRows: liveClampRows, theme: theme, caps: caps }));
+                thinkingMs: entry.thinkingMs, theme: theme, caps: caps }));
         }
         case 'tool':
-            return frame(toolEntryGlyph(entry.name, caps), statusColor(entry.status, theme), _jsx(ToolCard, { name: entry.name, label: entry.label, argsRaw: entry.argsRaw, args: entry.args, status: entry.status, preview: entry.preview, patch: entry.patch, durationMs: entry.durationMs, isError: entry.isError, expanded: expanded, reducedMotion: reducedMotion, liveClampRows: liveClampRows, 
+            return frame(toolEntryGlyph(entry.name, caps), statusColor(entry.status, theme), _jsx(ToolCard, { name: entry.name, label: entry.label, argsRaw: entry.argsRaw, args: entry.args, status: entry.status, preview: entry.preview, patch: entry.patch, durationMs: entry.durationMs, isError: entry.isError, expanded: expanded, reducedMotion: reducedMotion, 
                 // `entry.live` AND NOT `entry.live ?? []` (P2-4): `ToolCard`'s default
                 // comparator sees a fresh `[]` as a changed prop, which is why that
                 // file already keeps a shared `EMPTY_LINES`.
@@ -263,10 +128,8 @@ export const EntryView = React.memo(EntryViewImpl, (a, b) => {
         a.thinkingVisible === b.thinkingVisible &&
         a.reducedMotion === b.reducedMotion &&
         a.density === b.density &&
-        a.mode === b.mode &&
         a.theme === b.theme &&
         a.caps === b.caps &&
-        a.liveClampRows === b.liveClampRows &&
         /*
          * ELEVENTH TERM, AND OMITTING IT IS THE TRAP I-L2-1 DESCRIBES ONE COMMENT UP
          * (P1-3). This comparator is a CLOSED LIST: a prop absent from it changes
@@ -279,27 +142,7 @@ export const EntryView = React.memo(EntryViewImpl, (a, b) => {
          */
         a.nowSec === b.nowSec);
 });
-/**
- * Full-screen transcript body — the same entry renderers with NO `<Static>`.
- *
- * `<Static>` prints above the live frame; once the frame is `rows - 1` tall
- * there is exactly one visible line up there, so the mechanism stops being a
- * history view and starts being a leak. Full-screen therefore owns its history
- * inside `ScrollViewport` instead.
- *
- * `computeSettledCount` is deliberately NOT called here: its only job is to keep
- * an entry that already reached `<Static>` from flowing back into the live
- * region, and with no Static there is nothing to protect. The settled high-water
- * mark feeds nothing else — `/save` serializes `entries` in full — so leaving it
- * un-advanced has no side effect.
- *
- * VIRTUALISED (L3 / R1). `windowSize` is now the SCROLL HORIZON — how far back
- * the user can scroll — and no longer the rendering budget, because entries
- * outside the viewport are not mounted at all. What bounds the frame is
- * `selectWindow`, and the two spacers are what keep the scroll maths honest
- * while they are absent.
- */
-export function TranscriptList({ entries, expandedToolIds, thinkingVisible, reducedMotion, density, mode, nowSec, theme, caps, windowSize, cols, heights, mountedSink, tailSink, }) {
+export function TranscriptList({ entries, expandedToolIds, thinkingVisible, reducedMotion, density, nowSec, theme, caps, windowSize, cols, heights, mountedSink, tailSink, }) {
     const size = Math.max(1, Math.floor(windowSize));
     const visible = entries.length > size ? entries.slice(-size) : entries;
     const collapsed = entries.length - visible.length;
@@ -352,39 +195,6 @@ export function TranscriptList({ entries, expandedToolIds, thinkingVisible, redu
     }
     return (_jsxs(Box, { flexDirection: "column", flexShrink: 0, children: [collapsed > 0 && (_jsxs(Text, { wrap: "truncate", color: theme.hintFg ?? theme.muted, children: [glyphs.ellipsis, " ", collapsed, " earlier ", collapsed === 1 ? 'entry' : 'entries', " collapsed (/save exports the full session)"] })), selection.leadingRows > 0 && (_jsx(Box, { flexShrink: 0, height: selection.leadingRows })), slice.map((entry, i) => {
                 const index = selection.startIndex + i;
-                return (_jsx(MeasuredEntry, { heightKey: keyOf(entry), onMeasure: report, children: _jsx(EntryView, { entry: entry, prev: index > 0 ? visible[index - 1] : undefined, expanded: !!expandedToolIds[entry.id], thinkingVisible: thinkingVisible, reducedMotion: reducedMotion, density: density, mode: mode, nowSec: nowSecFor(entry, nowSec), theme: theme, caps: caps }) }, entry.id));
+                return (_jsx(MeasuredEntry, { heightKey: keyOf(entry), onMeasure: report, children: _jsx(EntryView, { entry: entry, prev: index > 0 ? visible[index - 1] : undefined, expanded: !!expandedToolIds[entry.id], thinkingVisible: thinkingVisible, reducedMotion: reducedMotion, density: density, nowSec: nowSecFor(entry, nowSec), theme: theme, caps: caps }) }, entry.id));
             }), selection.trailingRows > 0 && (_jsx(Box, { flexShrink: 0, height: selection.trailingRows }))] }));
 }
-export function Transcript({ entries, expandedToolIds, thinkingVisible, reducedMotion, density, mode, nowSec, theme, caps, }) {
-    const highWater = useRef(0);
-    const prevLen = useRef(0);
-    const { rows } = useTerminalSize();
-    const raw = computeSettledCount(entries, expandedToolIds);
-    // The transcript shrank (clear / reset / restore) — drop the high-water mark.
-    if (entries.length < prevLen.current)
-        highWater.current = 0;
-    prevLen.current = entries.length;
-    const settled = Math.min(entries.length, Math.max(highWater.current, raw));
-    highWater.current = settled;
-    const settledEntries = entries.slice(0, settled);
-    const liveEntries = entries.slice(settled);
-    // I-L5-1 — the live region must stay strictly below `stdout.rows`, or Ink
-    // takes the `ink.js:118-123` branch and writes `clearTerminal +
-    // fullStaticOutput + output` on EVERY subsequent frame for the rest of the
-    // session.
-    //
-    // `LIVE_TAIL` is 1, so the common case is the design's `rows - 4` less the one
-    // row the clamp marker costs. THE DIVISION IS NOT DECORATION: the settled
-    // boundary is held back by an expanded card, a running tool, a live dispatch
-    // or a live todo list, and in every one of those cases the region holds
-    // SEVERAL entries at once — a flat per-entry ceiling of `rows - 4` would then
-    // overrun by a multiple of itself. `- 1` pays for each entry's marker row.
-    //
-    // The residual: an entry contributes at least its header row whatever the
-    // clamp says, so the bound holds while the live region holds fewer than about
-    // `rows / 2` entries. Bounding it unconditionally would mean refusing to draw
-    // a live entry at all, which is worse than a tall frame.
-    const liveBudget = Math.max(INLINE_LIVE_MIN_ROWS, rows - INLINE_LIVE_MARGIN);
-    const liveClampRows = Math.max(1, Math.floor(liveBudget / Math.max(1, liveEntries.length)) - 1);
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Static, { items: settledEntries, children: (entry, index) => (_jsx(EntryView, { entry: entry, prev: index > 0 ? settledEntries[index - 1] : undefined, expanded: !!expandedToolIds[entry.id], thinkingVisible: thinkingVisible, reducedMotion: reducedMotion, density: density, mode: mode, theme: theme, caps: caps }, entry.id)) }), _jsx(Box, { flexDirection: "column", children: liveEntries.map((entry, i) => (_jsx(EntryView, { entry: entry, prev: i > 0 ? liveEntries[i - 1] : entries[settled - 1], expanded: !!expandedToolIds[entry.id], thinkingVisible: thinkingVisible, reducedMotion: reducedMotion, density: density, mode: mode, theme: theme, caps: caps, liveClampRows: liveClampRows, nowSec: nowSecFor(entry, nowSec) }, entry.id))) })] }));
-}

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

@@ -29,29 +29,6 @@ interface AssistantEntryProps {
      * `thought for 0s` is a lie where a bare `thought` is merely terse.
      */
     thinkingMs?: number;
-    /**
-     * Whether pressing `Ctrl+T` would actually reveal THIS entry's body — i.e.
-     * `mode === 'fullscreen'` (D-16 / P0-2).
-     *
-     * In inline mode a settled entry has already been printed into Ink's
-     * `<Static>`, which cannot un-print or re-print (`Transcript.tsx:9-10`), and
-     * the settled boundary is held monotonic precisely so an entry never flows back
-     * out. With thinking hidden by default the body is never printed there AT ALL,
-     * so a row reading `ctrl+t to show` would be an instruction that provably does
-     * nothing. The row degrades to `* thought for 12s` instead — still honest that
-     * reasoning happened and how long it took, and silent about a key that cannot
-     * deliver.
-     */
-    revealable?: boolean;
-    /**
-     * Inline mode only (L5): keep at most this many rows of a LIVE entry, so the
-     * non-`<Static>` region cannot reach `stdout.rows`. `undefined` means no
-     * clamp on the ANSWER BODY, which is what the full-screen branch passes — so
-     * the rendered answer there is byte-identical to a pre-feature build. (The
-     * thinking block has its own streaming clamp below and is not covered by that
-     * statement.)
-     */
-    liveClampRows?: number;
     theme: Theme;
     caps: TermCapabilities;
 }

package/dist/ui/entries/AssistantEntry.js

@@ -22,7 +22,7 @@ import { splitLinesCached } from '../render-cache.js';
 import { clampLiveText } from '../live-clamp.js';
 import { formatDuration } from '../../agent/usage.js';
 function AssistantEntryImpl(props) {
-    const { text, thinking, thinkingOpen, thinkingVisible, streaming, aborted, thinkingMs, revealable, liveClampRows, theme, caps, } = props;
+    const { text, thinking, thinkingOpen, thinkingVisible, streaming, aborted, thinkingMs, theme, caps, } = props;
     const glyphs = pickGlyphs(caps);
     const hasThinking = !!thinking && thinking.trim().length > 0;
     const hasText = text.trim().length > 0;
@@ -32,12 +32,11 @@ function AssistantEntryImpl(props) {
     // full-screen mode: it is scratch reasoning the user reads the newest end of,
     // and an unbounded one is the single easiest way to push a live entry past the
     // whole viewport.
-    const thinkingRows = liveClampRows ?? (streaming ? STREAMING_THINKING_ROWS : undefined);
+    const thinkingRows = streaming ? STREAMING_THINKING_ROWS : undefined;
     const clampedThinking = hasThinking && thinkingRows !== undefined
         ? clampLiveText(thinking, thinkingRows)
         : { text: thinking ?? '', hiddenRows: 0 };
-    const body = liveClampRows === undefined ? { text, hiddenRows: 0 } : clampLiveText(text, liveClampRows);
-    return (_jsxs(Box, { flexDirection: "column", children: [hasThinking && thinkingVisible && (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { wrap: "truncate", color: theme.thinking, children: [glyphs.thinking, " thinking", thinkingOpen ? glyphs.ellipsis : ''] }), _jsxs(Box, { flexDirection: "column", marginLeft: 2, children: [clampedThinking.hiddenRows > 0 && (_jsxs(Text, { color: theme.muted, children: [glyphs.ellipsis, " ", clampedThinking.hiddenRows, " earlier", ' ', clampedThinking.hiddenRows === 1 ? 'line' : 'lines'] })), splitLinesCached(clampedThinking.text).map((line, i) => (_jsx(Text, { color: theme.thinking, dimColor: true, children: line }, i)))] })] })), hasThinking && !thinkingVisible && !streaming && (_jsxs(Text, { wrap: "truncate", color: theme.muted, children: [glyphs.thinking, " thought", thinkingMs !== undefined ? ` for ${formatDuration(thinkingMs)}` : '', revealable ? ` ${glyphs.midDot} ctrl+t to show` : ''] })), (hasText || streaming) && (_jsxs(Box, { flexDirection: "column", children: [body.hiddenRows > 0 && (_jsxs(Text, { wrap: "truncate", color: theme.muted, children: [glyphs.ellipsis, " ", body.hiddenRows, " earlier", ' ', body.hiddenRows === 1 ? 'line' : 'lines', " ", glyphs.midDot, " shown in full when this entry finishes"] })), hasText ? (_jsx(Markdown, { text: body.text, theme: theme, caps: caps })) : (_jsx(Text, { color: theme.muted, children: glyphs.ellipsis })), aborted && _jsx(Text, { color: theme.noticeWarn, children: "[aborted]" })] }))] }));
+    return (_jsxs(Box, { flexDirection: "column", children: [hasThinking && thinkingVisible && (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { wrap: "truncate", color: theme.thinking, children: [glyphs.thinking, " thinking", thinkingOpen ? glyphs.ellipsis : ''] }), _jsxs(Box, { flexDirection: "column", marginLeft: 2, children: [clampedThinking.hiddenRows > 0 && (_jsxs(Text, { color: theme.muted, children: [glyphs.ellipsis, " ", clampedThinking.hiddenRows, " earlier", ' ', clampedThinking.hiddenRows === 1 ? 'line' : 'lines'] })), splitLinesCached(clampedThinking.text).map((line, i) => (_jsx(Text, { color: theme.thinking, dimColor: true, children: line }, i)))] })] })), hasThinking && !thinkingVisible && !streaming && (_jsxs(Text, { wrap: "truncate", color: theme.muted, children: [glyphs.thinking, " thought", thinkingMs !== undefined ? ` for ${formatDuration(thinkingMs)}` : '', ` ${glyphs.midDot} ctrl+t to show`] })), (hasText || streaming) && (_jsxs(Box, { flexDirection: "column", children: [hasText ? (_jsx(Markdown, { text: text, theme: theme, caps: caps })) : (_jsx(Text, { color: theme.muted, children: glyphs.ellipsis })), aborted && _jsx(Text, { color: theme.noticeWarn, children: "[aborted]" })] }))] }));
 }
 /** Rows of live thinking kept on screen while an answer streams. */
 const STREAMING_THINKING_ROWS = 24;

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

@@ -32,12 +32,6 @@ export declare const DIFF_COLLAPSED_LINES = 12;
 export interface DiffViewProps {
     patch: FilePatch;
     expanded?: boolean;
-    /**
-     * Inline mode only (L5): ceiling on the rows a LIVE card contributes to the
-     * non-`<Static>` region. `undefined` — what the full-screen branch passes —
-     * means no clamp.
-     */
-    liveClampRows?: number;
     theme: Theme;
 }
 /** One rendered row: a patch line, or the `@@` separator between two hunks. */
@@ -56,7 +50,7 @@ interface DiffRow {
  * disagree.
  */
 export declare function diffRows(patch: FilePatch): DiffRow[];
-declare function DiffViewImpl({ patch, expanded, liveClampRows, theme, }: DiffViewProps): React.ReactElement;
+declare function DiffViewImpl({ patch, expanded, theme, }: DiffViewProps): React.ReactElement;
 /**
  * `React.memo` with the DEFAULT comparator, matching `ToolCard`'s boundary.
  * `patch` qualifies as a prop only because the reducer writes it ONCE at

package/dist/ui/entries/DiffView.js

@@ -86,9 +86,9 @@ function gutterWidth(rows) {
             max = row.num;
     return Math.min(GUTTER_MAX, Math.max(GUTTER_MIN, String(max).length));
 }
-function DiffViewImpl({ patch, expanded, liveClampRows, theme, }) {
+function DiffViewImpl({ patch, expanded, theme, }) {
     const rows = diffRows(patch);
-    const ceiling = Math.min(expanded ? rows.length : DIFF_COLLAPSED_LINES, liveClampRows ?? Number.POSITIVE_INFINITY);
+    const ceiling = expanded ? rows.length : DIFF_COLLAPSED_LINES;
     const visible = ceiling >= rows.length ? rows : rows.slice(0, Math.max(0, ceiling));
     const hidden = rows.length - visible.length;
     const width = gutterWidth(rows);

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

@@ -37,12 +37,6 @@ interface ToolCardProps {
     isError?: boolean;
     expanded?: boolean;
     reducedMotion?: boolean;
-    /**
-     * Inline mode only (L5): ceiling on the rows a LIVE card contributes to the
-     * non-`<Static>` region. `undefined` — what the full-screen branch passes —
-     * means no clamp and byte-identical output.
-     */
-    liveClampRows?: number;
     /**
      * The sanitised live tail while the tool runs
      * (agent-activity-presentation-live §3.3.4).

package/dist/ui/entries/ToolCard.js

@@ -80,7 +80,7 @@ export function toolEntryGlyph(name, caps) {
     return toolGlyph(pickGlyphs(caps), name);
 }
 function ToolCardImpl(props) {
-    const { name, argsRaw, args, status, preview, patch, durationMs, isError, expanded, reducedMotion, liveClampRows, live, lastOutputAt, nowSec, theme, caps, } = props;
+    const { name, argsRaw, args, status, preview, patch, durationMs, isError, expanded, reducedMotion, live, lastOutputAt, nowSec, theme, caps, } = props;
     const glyphs = pickGlyphs(caps);
     const color = statusColor(status, theme);
     const previewText = preview ?? '';
@@ -88,12 +88,7 @@ function ToolCardImpl(props) {
     // is immutable once written, and this used to reallocate up to 200 strings per
     // card per frame (R3).
     const previewLines = previewText.length > 0 ? splitLinesCached(previewText) : EMPTY_LINES;
-    // Head-first, exactly as before: the collapsed card shows the FIRST 8 lines.
-    // The inline clamp only lowers the ceiling — it never changes which end is
-    // kept, because `Ctrl+O` on a 5 000-line bash result is precisely how an
-    // inline session reaches `ink.js:121` (I-L5-1) and the fix must not also
-    // reshuffle what a full-screen user has been reading for four releases.
-    const ceiling = Math.min(expanded ? previewLines.length : COLLAPSED_LINES, liveClampRows ?? Number.POSITIVE_INFINITY);
+    const ceiling = expanded ? previewLines.length : COLLAPSED_LINES;
     const visibleLines = ceiling >= previewLines.length ? previewLines : previewLines.slice(0, ceiling);
     const hidden = previewLines.length - visibleLines.length;
     const settled = status === 'done' || status === 'error';
@@ -110,11 +105,7 @@ function ToolCardImpl(props) {
     // NOW" (D-25). Head-first while live would freeze on the first eight lines a
     // build ever printed and then never change again.
     const liveRows = live ?? EMPTY_LINES;
-    const liveCeiling = Math.min(COLLAPSED_LINES, 
-    // Inline only: `liveClampRows` already subtracts one row per live entry to
-    // pay for a marker (`Transcript.tsx:534-538`), which is what this card's
-    // unconditional footer spends (AC-36 / P2-7).
-    liveClampRows ?? Number.POSITIVE_INFINITY);
+    const liveCeiling = COLLAPSED_LINES;
     const visibleLive = liveRows.length > liveCeiling ? liveRows.slice(-Math.max(1, liveCeiling)) : liveRows;
     const showLive = !settled && visibleLive.length > 0;
     // THE OUTER GUARD WIDENS WITH THE BRANCH (P2-2). It was `previewLines.length >
@@ -153,7 +144,7 @@ function ToolCardImpl(props) {
                         // "constant row count" the exactness its arithmetic claims. A
                         // space is also what the terminal itself shows for a blank line.
                         // eslint-disable-next-line react/no-array-index-key
-                        _jsx(Text, { wrap: "truncate", color: theme.muted, children: row.length > 0 ? row : ' ' }, i))), _jsx(Text, { color: theme.muted, children: liveFooter })] })) : showPatch ? (_jsx(DiffView, { patch: patch, expanded: expanded, liveClampRows: liveClampRows, theme: theme })) : (_jsxs(_Fragment, { children: [_jsx(ToolPreview, { name: name, lines: visibleLines, theme: theme, isError: isError }), !expanded && hidden > 0 && (_jsxs(Text, { color: theme.muted, children: ["+", hidden, " ", hidden === 1 ? 'line' : 'lines', " (Ctrl+O)"] })), expanded && hidden > 0 && (_jsxs(Text, { color: theme.muted, children: ["+", hidden, " ", hidden === 1 ? 'line' : 'lines', " ", glyphs.midDot, " shown in full when this entry finishes"] })), expanded && previewLines.length > COLLAPSED_LINES && (_jsx(Text, { color: theme.muted, children: "(Ctrl+O to collapse)" }))] })) }))] }));
+                        _jsx(Text, { wrap: "truncate", color: theme.muted, children: row.length > 0 ? row : ' ' }, i))), _jsx(Text, { color: theme.muted, children: liveFooter })] })) : showPatch ? (_jsx(DiffView, { patch: patch, expanded: expanded, theme: theme })) : (_jsxs(_Fragment, { children: [_jsx(ToolPreview, { name: name, lines: visibleLines, theme: theme, isError: isError }), !expanded && hidden > 0 && (_jsxs(Text, { color: theme.muted, children: ["+", hidden, " ", hidden === 1 ? 'line' : 'lines', " (Ctrl+O)"] })), expanded && hidden > 0 && (_jsxs(Text, { color: theme.muted, children: ["+", hidden, " ", hidden === 1 ? 'line' : 'lines', " ", glyphs.midDot, " shown in full when this entry finishes"] })), expanded && previewLines.length > COLLAPSED_LINES && (_jsx(Text, { color: theme.muted, children: "(Ctrl+O to collapse)" }))] })) }))] }));
 }
 /**
  * `React.memo` with the DEFAULT comparator (tui-render-performance L2 / R3).

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

@@ -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
@@ -56,6 +62,13 @@ export interface FrameDifferOptions {
      * on resize. `undefined` ⇒ stand down and pass through.
      */
     rows: () => number | undefined;
+    /**
+     * Live terminal width, read on every paint and never cached (like `rows`).
+     * Absent or non-finite => every changed row ends in `CSI K` (the original
+     * behaviour); finite => rows whose display width is >= `cols` skip the EL so
+     * the last column (the scrollbar) is never erased (I-4).
+     */
+    cols?: () => number | undefined;
     /** Raised once, on the 0→1 edge of `fallbacks` (§5.6). */
     onFirstFallback?: () => void;
     /**

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,6 +43,8 @@
  *    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';
 // ---------------------------------------------------------------------------
@@ -59,6 +67,23 @@ const SYNC_END = `${CSI}?2026l`;
 function cursorTo(row) {
     return `${CSI}${row};1H`;
 }
+/**
+ * One addressed row: `CUP · SGR0 · line · SGR0 [· CSI K]` (I-4).
+ *
+ * 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.
+ */
+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.
  *
@@ -211,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
@@ -251,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/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,22 +1,13 @@
 /** 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;
-    /** Legacy inline footer; fullscreen assembles these slots inside its viewport. */
-    team?: React.ReactNode;
-    /** Kept source-compatible; fullscreen rail is owned by ScrollViewport. */
-    rail?: React.ReactNode;
-    /** Inline-only plan strip. */
-    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, strip, toast, composer, status, inactive, placeholder, }: 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, strip, toast, composer, status, inactive = false, placeholder, }) {
-    if (mode === 'inline') {
-        return (_jsxs(Box, { flexDirection: "column", children: [header, viewport, strip, 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;