@aragon-agent/cli 0.6.8 → 0.6.10

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/glyphs.d.ts

@@ -117,6 +117,15 @@ export interface Glyphs {
      * scan fails the build if either spelling appears anywhere else.
      */
     retry: string;
+    /**
+     * A message queued behind a running turn (tui-shift-enter-copy-queue 5.4).
+     * The rail marker on the `Queue: ...` row.
+     *
+     * HERE rather than in `QueuedEntry`, for the reason this file's header
+     * gives: a literal in a component bypasses `pickGlyphs` entirely and
+     * shows mojibake on a legacy console whatever the capability probe said.
+     */
+    queued: string;
     /**
      * Context compaction (context-auto-compaction §6.3). The rail marker on the
      * compaction card.

package/dist/ui/glyphs.js

@@ -66,6 +66,7 @@ const UNICODE_GLYPHS = {
     todoDone: '✔',
     retry: '↻',
     compaction: '⤓',
+    queued: '◷',
     tool: {
         read_file: '▤',
         write_file: '✎',
@@ -129,6 +130,7 @@ const ASCII_GLYPHS = {
     todoDone: '[x]',
     retry: '[r]',
     compaction: '[c]',
+    queued: '*',
     tool: {
         read_file: '=',
         write_file: '+',

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;

package/dist/ui/layout/OverlayFrame.js

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

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

@@ -27,6 +27,9 @@ export interface ScrollViewportProps {
     scrollbar?: ScrollbarBridge;
     composerRef?: React.RefObject<DOMElement>;
     onComposerVisibilityChange?: (visible: boolean) => void;
+    /** The run status row above the input box (tui-scrollbar-edge-and-run-row). */
+    activityRef?: React.RefObject<DOMElement>;
+    onActivityVisibilityChange?: (visible: boolean) => void;
     theme: Theme;
     caps: TermCapabilities;
     children: React.ReactNode;

package/dist/ui/layout/ScrollViewport.js

@@ -8,17 +8,23 @@ import { reduceFollow, shouldArmResume } from './follow-state.js';
 import { thumbRange } from './scroll-indicator.js';
 import { ScrollIndicator } from './ScrollIndicator.js';
 import { buildDocumentLayout } from './document-layout.js';
-function composerVisible(composer, clip) {
-    if (!composer || !clip)
+/**
+ * Whether `element` lies fully inside `clip`. A missing element (not mounted) or
+ * clip reports `true`, so a caller that consumes the answer must first know the
+ * element is actually mounted. Rows are one line tall, so "partially visible"
+ * cannot occur for the run status row.
+ */
+function elementVisible(element, clip) {
+    if (!element || !clip)
         return true;
     let top = 0;
-    let current = composer;
+    let current = element;
     while (current && current !== clip) {
         top += current.yogaNode?.getComputedTop() ?? 0;
         current = current.parentNode;
     }
     return current === clip && top >= 0 &&
-        top + measureElement(composer).height <= measureElement(clip).height;
+        top + measureElement(element).height <= measureElement(clip).height;
 }
 /** One offset for messages, padding and editor; hidden trees keep their local state. */
 export function ScrollViewport(props) {
@@ -45,6 +51,7 @@ export function ScrollViewport(props) {
     const lastPin = useRef(props.pinToBottomNonce);
     const lastReset = useRef(props.resetKey);
     const lastVisible = useRef();
+    const lastActivityVisible = useRef();
     const previousActive = useRef(active);
     const geometryRevision = useRef(0);
     const geometryBounds = useRef('');
@@ -186,11 +193,16 @@ export function ScrollViewport(props) {
                 thumb: thumbRange(viewport, content, next, true), revision: geometryRevision.current };
             scrollbar.onGeometry?.();
         }
-        const visible = composerVisible(props.composerRef?.current ?? null, clipRef.current);
+        const visible = elementVisible(props.composerRef?.current ?? null, clipRef.current);
         if (lastVisible.current !== visible) {
             lastVisible.current = visible;
             props.onComposerVisibilityChange?.(visible);
         }
+        const activityVisible = elementVisible(props.activityRef?.current ?? null, clipRef.current);
+        if (lastActivityVisible.current !== activityVisible) {
+            lastActivityVisible.current = activityVisible;
+            props.onActivityVisibilityChange?.(activityVisible);
+        }
     });
     const shiftUp = Math.max(0, metrics.content - metrics.viewport - offset);
     useEffect(() => { props.onScrolledLinesChange?.(offset); }, [offset, props.onScrolledLinesChange]);

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

@@ -4,7 +4,6 @@
  * Two pure functions with zero React dependency so the load-bearing invariant
  * I-1 (`frameHeight(r) < r`) can be pinned by a unit test rather than by hope.
  */
-export type RenderMode = 'fullscreen' | 'inline';
 /** Below this many rows a full-screen frame has no usable viewport left. */
 export declare const MIN_FULLSCREEN_ROWS = 12;
 /** Below this many columns the chrome (composer + status bar) cannot line-wrap sanely. */
@@ -35,24 +34,3 @@ export declare const FALLBACK_COLS = 80;
  * terminal is strictly better than a per-frame full-screen repaint.
  */
 export declare function frameHeight(rows: number | undefined): number;
-interface StdoutLike {
-    isTTY?: boolean;
-    rows?: number;
-    columns?: number;
-}
-/**
- * Decide the render mode once, at startup (never re-decided at run time —
- * entering/leaving the alt-screen mid-session is a state machine we do not want).
- *
- * Order is semantics, not style:
- *  1. an explicit opt-out always wins (users can always get v0.2.0 back);
- *  2. `isTTY` is the one gate `--fullscreen` cannot override — writing ANSI into
- *     a pipe or a redirected file is a contract violation, whereas a heuristic
- *     misfire only costs polish;
- *  3. the explicit force comes next so it can beat the heuristics below;
- *  4. heuristics (TERM/CI/size), all overridable by `--fullscreen`.
- */
-export declare function decideRenderMode(flags: {
-    fullscreen?: boolean;
-}, env: Record<string, string | undefined>, stdout: StdoutLike | undefined): RenderMode;
-export {};

package/dist/ui/layout/frame.js

@@ -37,39 +37,3 @@ export function frameHeight(rows) {
     const r = rows && rows > 0 ? rows : FALLBACK_ROWS;
     return Math.max(0, r - 1);
 }
-/** `CI=` / `CI=0` / `CI=false` are not CI; anything else non-empty is. */
-function isTruthyEnv(value) {
-    if (value === undefined)
-        return false;
-    const v = value.trim().toLowerCase();
-    return v.length > 0 && v !== '0' && v !== 'false';
-}
-/**
- * Decide the render mode once, at startup (never re-decided at run time —
- * entering/leaving the alt-screen mid-session is a state machine we do not want).
- *
- * Order is semantics, not style:
- *  1. an explicit opt-out always wins (users can always get v0.2.0 back);
- *  2. `isTTY` is the one gate `--fullscreen` cannot override — writing ANSI into
- *     a pipe or a redirected file is a contract violation, whereas a heuristic
- *     misfire only costs polish;
- *  3. the explicit force comes next so it can beat the heuristics below;
- *  4. heuristics (TERM/CI/size), all overridable by `--fullscreen`.
- */
-export function decideRenderMode(flags, env, stdout) {
-    if (flags.fullscreen === false)
-        return 'inline';
-    if (!stdout?.isTTY)
-        return 'inline';
-    if (flags.fullscreen === true)
-        return 'fullscreen';
-    if (env.TERM === 'dumb')
-        return 'inline';
-    if (isTruthyEnv(env.CI))
-        return 'inline';
-    if ((stdout.rows ?? 0) < MIN_FULLSCREEN_ROWS)
-        return 'inline';
-    if ((stdout.columns ?? 0) < MIN_FULLSCREEN_COLS)
-        return 'inline';
-    return 'fullscreen';
-}

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

@@ -1,6 +1,4 @@
-import type { RenderMode } from './frame.js';
 export interface TodoRailLayoutInput {
-    mode: RenderMode;
     cols: number;
     panelEnabled: boolean;
     overlayOpen: boolean;
@@ -12,7 +10,7 @@ export interface TodoRailLayoutInput {
 }
 export interface TodoRailLayout {
     visible: boolean;
-    reason: 'visible' | 'inline' | 'disabled' | 'overlay' | 'empty' | 'narrow' | 'short';
+    reason: 'visible' | 'disabled' | 'overlay' | 'empty' | 'narrow' | 'short';
     width: number;
     rows: number;
     contentCols: number;

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

@@ -11,15 +11,14 @@ export function buildTodoRailLayout(input) {
     const popupMaxHeight = Math.max(0, budget - teamRows - TODO_LIMITS.panelMinRows
         - nonNegativeInt(input.composerBaseRows ?? 0));
     const popupRows = popupMaxHeight < 3 ? 0 : Math.min(nonNegativeInt(input.popupRows), popupMaxHeight);
-    const rows = input.mode === 'fullscreen' ? budget : budget - teamRows - popupRows;
+    const rows = budget;
     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 reason = !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 };
 }

package/dist/ui/layout/viewport-geometry.d.ts

@@ -21,7 +21,7 @@ export interface ViewportGeometry {
 }
 /**
  * The default is the UNMEASURED geometry, and consumers must treat it as such:
- * a `TranscriptList` rendered outside a `ScrollViewport` (inline mode, and every
+ * a `TranscriptList` rendered outside a `ScrollViewport` (including
  * test that mounts it bare) sees `viewportRows: 0`, which `selectWindow` reads
  * as "first frame" and answers by pinning the live tail.
  */

package/dist/ui/layout/viewport-geometry.js

@@ -13,7 +13,7 @@
 import { createContext, useContext } from 'react';
 /**
  * The default is the UNMEASURED geometry, and consumers must treat it as such:
- * a `TranscriptList` rendered outside a `ScrollViewport` (inline mode, and every
+ * a `TranscriptList` rendered outside a `ScrollViewport` (including
  * test that mounts it bare) sees `viewportRows: 0`, which `selectWindow` reads
  * as "first frame" and answers by pinning the live tail.
  */

package/dist/ui/live-clamp.d.ts

@@ -1,32 +1,4 @@
-/**
- * Live-region clamp for INLINE render mode (tui-render-performance L5 / R6).
- *
- * Inline mode has no fixed frame, so nothing kept its live (non-`<Static>`)
- * region shorter than the terminal. When one live entry grew taller than
- * `stdout.rows`, Ink took the branch at `ink.js:118-123`:
- *
- *     if (outputHeight >= this.options.stdout.rows) {
- *       stdout.write(clearTerminal + this.fullStaticOutput + output);
- *     }
- *
- * `fullStaticOutput` accumulates EVERY `<Static>` frame of the whole session and
- * is never trimmed, so once that branch is taken it is taken on every subsequent
- * frame — bypassing both the `output !== lastOutput` dedupe and `throttledLog` —
- * and the terminal receives the entire session history thirty times a second.
- * That is a genuine hard freeze, and it is reachable today by any inline user
- * (`--no-fullscreen`, `TERM=dumb`, CI, a short or narrow terminal) whose model
- * writes a long answer.
- *
- * I-L5-1 — keeping the live region strictly below `stdout.rows` makes that
- * branch UNREACHABLE, which is the inline analogue of `frame.ts`'s
- * `frameHeight(r) < r` and deserves the same standing. We cannot bound Ink's
- * `fullStaticOutput` growth (it is private and append-only); preventing the
- * branch that WRITES it is the entire mitigation, and nothing about the memory
- * it holds is fixed by this module.
- *
- * Nothing is lost, only deferred: when the entry settles it moves into
- * `<Static>` and is printed in full.
- */
+/** Keep the newest thinking lines visible while an assistant entry streams. */
 export interface LiveClamp {
     text: string;
     /** Rows dropped off the FRONT. `0` means the text was returned untouched. */

package/dist/ui/live-clamp.js

@@ -1,32 +1,4 @@
-/**
- * Live-region clamp for INLINE render mode (tui-render-performance L5 / R6).
- *
- * Inline mode has no fixed frame, so nothing kept its live (non-`<Static>`)
- * region shorter than the terminal. When one live entry grew taller than
- * `stdout.rows`, Ink took the branch at `ink.js:118-123`:
- *
- *     if (outputHeight >= this.options.stdout.rows) {
- *       stdout.write(clearTerminal + this.fullStaticOutput + output);
- *     }
- *
- * `fullStaticOutput` accumulates EVERY `<Static>` frame of the whole session and
- * is never trimmed, so once that branch is taken it is taken on every subsequent
- * frame — bypassing both the `output !== lastOutput` dedupe and `throttledLog` —
- * and the terminal receives the entire session history thirty times a second.
- * That is a genuine hard freeze, and it is reachable today by any inline user
- * (`--no-fullscreen`, `TERM=dumb`, CI, a short or narrow terminal) whose model
- * writes a long answer.
- *
- * I-L5-1 — keeping the live region strictly below `stdout.rows` makes that
- * branch UNREACHABLE, which is the inline analogue of `frame.ts`'s
- * `frameHeight(r) < r` and deserves the same standing. We cannot bound Ink's
- * `fullStaticOutput` growth (it is private and append-only); preventing the
- * branch that WRITES it is the entire mitigation, and nothing about the memory
- * it holds is fixed by this module.
- *
- * Nothing is lost, only deferred: when the entry settles it moves into
- * `<Static>` and is printed in full.
- */
+/** Keep the newest thinking lines visible while an assistant entry streams. */
 /**
  * Keep the LAST `maxRows` rows of `text`; report how many were dropped.
  *

package/dist/ui/overlays/HelpOverlay.js

@@ -27,7 +27,9 @@ function keyRows(times) {
         // a key, so it has to be named somewhere they can look it up. The one-shot
         // startup notice is the other place, and it scrolls away.
         ['Drag right edge', 'Scroll messages and input together; type to return'],
-        ['Drag text (left button)', 'Select text on screen; releasing copies it'],
+        ['Run status row', 'Spinner and queue / interrupt keys, above the input during a run'],
+        ['Drag text (left button)', 'Select text on screen; the highlight waits'],
+        ['Ctrl+C (with a selection)', 'Copy the pending selection - does not arm exit'],
         ['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.

package/dist/ui/overlays/PlanReviewOverlay.js

@@ -28,6 +28,7 @@ import { pickGlyphs } from '../glyphs.js';
 import { OverlayFrame } from '../layout/OverlayFrame.js';
 import { wrapToRows } from '../layout/wrap-rows.js';
 import { stripPasteFrames } from '../paste-frames.js';
+import { stripEnterFrames } from '../enter-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, }) {
@@ -63,7 +64,10 @@ export function PlanReviewOverlay({ plan, maxRows, cols, scrollOffset, onScrollC
             // 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));
+                // `stripEnterFrames` rides inside it for the newline frame a
+                // Shift+Enter broadcasts (tui-shift-enter-copy-queue 3.5): same hazard,
+                // same fix, and this order is the one that leaves no NUL in the draft.
+                setFeedback(feedback + stripPasteFrames(stripEnterFrames(input)));
             }
             return;
         }