@aragon-agent/cli 0.6.8 → 0.6.10

package/dist/ui/Transcript.js

@@ -1,38 +1,14 @@
 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';
 import { EntryFrame } from './entries/EntryFrame.js';
 import { UserEntry } from './entries/UserEntry.js';
+import { QueuedEntry } from './entries/QueuedEntry.js';
 import { AssistantEntry } from './entries/AssistantEntry.js';
 import { ToolCard, statusColor, toolEntryGlyph } from './entries/ToolCard.js';
 import { TeamCard, teamCardColor } from './entries/TeamCard.js';
@@ -45,98 +21,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,40 +52,27 @@ 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 }));
     switch (entry.kind) {
         case 'user':
             return frame(glyphs.user, theme.user, _jsx(UserEntry, { text: entry.text, theme: theme, caps: caps }));
+        case 'queued':
+            // `theme.muted`: quieter than a user message, louder than a notice --
+            // the row exists to be noticed UNTIL it is accepted, then rewritten in
+            // place by `turnStart` (5.2.3).
+            return frame(glyphs.queued, theme.muted, _jsx(QueuedEntry, { 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 +134,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 +148,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 +201,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/enter-frames.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Reading Enter frames back out of an Ink `input` string
+ * (tui-shift-enter-copy-queue 3.5) -- pure.
+ *
+ * The stdin filter rewrites a modified Enter into `ENTER_NEWLINE_FRAME` inline,
+ * in stream order, exactly the way it frames a paste. This module is the only
+ * place that takes those frames apart again, and it handles BOTH newline
+ * sources the composer can see in one `input` string:
+ *
+ *  - `ENTER_NEWLINE_FRAME` -- Shift+Enter / Alt+Enter / CSI-u Enter, translated
+ *    by the filter; and
+ *  - a bare `\n` -- Ctrl+J, which Ink parses to `name: 'enter'` with
+ *    `input === '\n'` and NO `key.return`, so it reaches this branch as an
+ *    ordinary (control) character that must still mean "newline".
+ *
+ * I-12, THE BROADCAST OBLIGATION, APPLIES TO THESE FRAMES TOO. `useInput`
+ * re-emits every chunk to every mounted handler, `stripPasteFrames` does not
+ * know this frame, and a NUL appended into `SettingsScreen`'s API-key field
+ * renders as nothing and silently breaks authentication -- the exact accident
+ * class that function's own doc records. `stripEnterFrames` is the equivalent
+ * guard for overlays with no paste model of their own.
+ */
+import { type FrameSegment } from './paste-frames.js';
+/** True when this `input` carries at least one Enter frame -- the branch guard. */
+export declare function hasEnterFrame(input: string): boolean;
+/**
+ * Split an `input` string into ordered text runs and newline runs.
+ *
+ * Text-only by construction (paste frames are `mergeWithPasteRuns`'s job), so
+ * the paste id never has to exist here -- `PromptInput` allocates ids for paste
+ * segments while building the reducer's action, exactly as the paste branch
+ * does (P1-5: the reducer stays pure and this stays a function of its input).
+ */
+export declare function splitEnterFrames(input: string): FrameSegment[];
+/**
+ * Merge newline runs with the paste frames that share the same `input`.
+ *
+ * Ink drains its buffer in one size-less `read()`, so the filter's TWO writes
+ * (one per frame family) can arrive as ONE chunk carrying both a paste frame
+ * and an Enter frame. Neither splitter alone preserves that order --
+ * `splitPasteFrames` sanitises `\n` out of its text runs, and this module's
+ * spans treat a paste payload as ordinary text -- so the merge walks the
+ * ORIGINAL string once: paste frames become paste segments (payload through
+ * `sanitisePaste`, as `splitPasteFrames` does), and the spans between them are
+ * segmented with the SAME walker `splitEnterFrames` uses, which is what keeps
+ * the two views from disagreeing about where a newline sits.
+ *
+ * Paste segments carry NO id here (P1-5); the caller assigns one per segment
+ * only when it builds the reducer's action.
+ */
+export declare function mergeWithPasteRuns(input: string, runs: FrameSegment[]): FrameSegment[];
+/**
+ * Remove every Enter frame for a consumer that has no newline model of its
+ * own, replacing each frame with `'\n'` (tui-shift-enter-copy-queue 3.5, the
+ * I-12 analogue for this frame family).
+ *
+ * NO OTHER SANITISATION, unlike `stripPasteFrames`: the overlay call sites wrap
+ * this INSIDE their existing `stripPasteFrames(...)` call, and the composite
+ * keeps that function's byte-level guarantees. Composed the other way round a
+ * lone NUL frame would survive as its payload letter; composed this way the
+ * frame's newline lands exactly where a bare Ctrl+J lands today.
+ */
+export declare function stripEnterFrames(input: string): string;

package/dist/ui/enter-frames.js

@@ -0,0 +1,136 @@
+/**
+ * Reading Enter frames back out of an Ink `input` string
+ * (tui-shift-enter-copy-queue 3.5) -- pure.
+ *
+ * The stdin filter rewrites a modified Enter into `ENTER_NEWLINE_FRAME` inline,
+ * in stream order, exactly the way it frames a paste. This module is the only
+ * place that takes those frames apart again, and it handles BOTH newline
+ * sources the composer can see in one `input` string:
+ *
+ *  - `ENTER_NEWLINE_FRAME` -- Shift+Enter / Alt+Enter / CSI-u Enter, translated
+ *    by the filter; and
+ *  - a bare `\n` -- Ctrl+J, which Ink parses to `name: 'enter'` with
+ *    `input === '\n'` and NO `key.return`, so it reaches this branch as an
+ *    ordinary (control) character that must still mean "newline".
+ *
+ * I-12, THE BROADCAST OBLIGATION, APPLIES TO THESE FRAMES TOO. `useInput`
+ * re-emits every chunk to every mounted handler, `stripPasteFrames` does not
+ * know this frame, and a NUL appended into `SettingsScreen`'s API-key field
+ * renders as nothing and silently breaks authentication -- the exact accident
+ * class that function's own doc records. `stripEnterFrames` is the equivalent
+ * guard for overlays with no paste model of their own.
+ */
+import { ENTER_NEWLINE_FRAME, PASTE_CLOSE, PASTE_OPEN } from '../input/limits.js';
+import { sanitisePaste } from '../input/paste-parse.js';
+import { sanitiseTyped } from './paste-frames.js';
+/** True when this `input` carries at least one Enter frame -- the branch guard. */
+export function hasEnterFrame(input) {
+    return input.includes(ENTER_NEWLINE_FRAME);
+}
+/**
+ * Split one Enter-frame-free span into ordered text / newline segments.
+ *
+ * Every newline source -- frame or bare `\n` -- yields ONE
+ * `{ kind: 'text', text: '\n' }` segment, so the editor's existing `input`
+ * action inserts it through the same path typing uses and the draft's row
+ * budget applies unchanged. Non-newline text is accumulated and passed through
+ * `sanitiseTyped` (I-14): a chunk that carries a frame can also carry the
+ * keystrokes that arrived beside it, and a coalesced CR must not be spliced
+ * back into the draft raw.
+ */
+function splitEnterSpan(span) {
+    const segments = [];
+    let text = '';
+    const pushText = () => {
+        const clean = sanitiseTyped(text);
+        if (clean.length > 0)
+            segments.push({ kind: 'text', text: clean });
+        text = '';
+    };
+    let i = 0;
+    while (i < span.length) {
+        if (span.startsWith(ENTER_NEWLINE_FRAME, i)) {
+            pushText();
+            segments.push({ kind: 'text', text: '\n' });
+            i += ENTER_NEWLINE_FRAME.length;
+            continue;
+        }
+        if (span[i] === '\n') {
+            pushText();
+            segments.push({ kind: 'text', text: '\n' });
+            i += 1;
+            continue;
+        }
+        text += span[i];
+        i += 1;
+    }
+    pushText();
+    return segments;
+}
+/**
+ * Split an `input` string into ordered text runs and newline runs.
+ *
+ * Text-only by construction (paste frames are `mergeWithPasteRuns`'s job), so
+ * the paste id never has to exist here -- `PromptInput` allocates ids for paste
+ * segments while building the reducer's action, exactly as the paste branch
+ * does (P1-5: the reducer stays pure and this stays a function of its input).
+ */
+export function splitEnterFrames(input) {
+    return splitEnterSpan(input);
+}
+/**
+ * Merge newline runs with the paste frames that share the same `input`.
+ *
+ * Ink drains its buffer in one size-less `read()`, so the filter's TWO writes
+ * (one per frame family) can arrive as ONE chunk carrying both a paste frame
+ * and an Enter frame. Neither splitter alone preserves that order --
+ * `splitPasteFrames` sanitises `\n` out of its text runs, and this module's
+ * spans treat a paste payload as ordinary text -- so the merge walks the
+ * ORIGINAL string once: paste frames become paste segments (payload through
+ * `sanitisePaste`, as `splitPasteFrames` does), and the spans between them are
+ * segmented with the SAME walker `splitEnterFrames` uses, which is what keeps
+ * the two views from disagreeing about where a newline sits.
+ *
+ * Paste segments carry NO id here (P1-5); the caller assigns one per segment
+ * only when it builds the reducer's action.
+ */
+export function mergeWithPasteRuns(input, runs) {
+    if (!input.includes(PASTE_OPEN))
+        return runs;
+    const merged = [];
+    let i = 0;
+    while (i < input.length) {
+        const open = input.indexOf(PASTE_OPEN, i);
+        if (open === -1) {
+            merged.push(...splitEnterSpan(input.slice(i)));
+            break;
+        }
+        merged.push(...splitEnterSpan(input.slice(i, open)));
+        const bodyStart = open + PASTE_OPEN.length;
+        const close = input.indexOf(PASTE_CLOSE, bodyStart);
+        const body = close === -1 ? input.slice(bodyStart) : input.slice(bodyStart, close);
+        const payload = sanitisePaste(body);
+        if (payload.length > 0)
+            merged.push({ kind: 'paste', text: payload });
+        if (close === -1)
+            break;
+        i = close + PASTE_CLOSE.length;
+    }
+    return merged;
+}
+/**
+ * Remove every Enter frame for a consumer that has no newline model of its
+ * own, replacing each frame with `'\n'` (tui-shift-enter-copy-queue 3.5, the
+ * I-12 analogue for this frame family).
+ *
+ * NO OTHER SANITISATION, unlike `stripPasteFrames`: the overlay call sites wrap
+ * this INSIDE their existing `stripPasteFrames(...)` call, and the composite
+ * keeps that function's byte-level guarantees. Composed the other way round a
+ * lone NUL frame would survive as its payload letter; composed this way the
+ * frame's newline lands exactly where a bare Ctrl+J lands today.
+ */
+export function stripEnterFrames(input) {
+    if (!hasEnterFrame(input))
+        return input;
+    return input.split(ENTER_NEWLINE_FRAME).join('\n');
+}

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

@@ -0,0 +1,27 @@
+/**
+ * Render a queued steering message (tui-shift-enter-copy-queue 5.4).
+ *
+ * ONE ROW, ALWAYS. `wrap="truncate"` -- the run-status-row width policy, for
+ * the height-estimate reason DiffView learned the hard way: a queued message
+ * can be arbitrarily long, and an entry whose wrapped height disagrees with its
+ * estimate is exactly the one the virtual window never re-measures.
+ *
+ * The glyph and the rail belong to `EntryFrame`, exactly as for every other
+ * entry; this component renders content only.
+ */
+import React from 'react';
+import type { Theme } from '../theme.js';
+import type { TermCapabilities } from '../capabilities.js';
+declare function QueuedEntryImpl({ text, theme, caps, }: {
+    text: string;
+    theme: Theme;
+    caps: TermCapabilities;
+}): React.ReactElement;
+/**
+ * `React.memo` with the DEFAULT comparator, like every sibling entry card: the
+ * reducer rebuilds the entry object only when it changes, and a `queued` entry
+ * changes exactly twice -- once when appended, once when it is rewritten into a
+ * `user` entry and stops being this component's problem.
+ */
+export declare const QueuedEntry: React.MemoExoticComponent<typeof QueuedEntryImpl>;
+export {};

package/dist/ui/entries/QueuedEntry.js

@@ -0,0 +1,30 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * Render a queued steering message (tui-shift-enter-copy-queue 5.4).
+ *
+ * ONE ROW, ALWAYS. `wrap="truncate"` -- the run-status-row width policy, for
+ * the height-estimate reason DiffView learned the hard way: a queued message
+ * can be arbitrarily long, and an entry whose wrapped height disagrees with its
+ * estimate is exactly the one the virtual window never re-measures.
+ *
+ * The glyph and the rail belong to `EntryFrame`, exactly as for every other
+ * entry; this component renders content only.
+ */
+import React from 'react';
+import { Text } from 'ink';
+import { pickGlyphs } from '../glyphs.js';
+function QueuedEntryImpl({ text, theme, caps, }) {
+    const glyphs = pickGlyphs(caps);
+    const lines = text.split('\n');
+    const first = lines[0] ?? '';
+    const extra = lines.length - 1;
+    const suffix = extra > 0 ? ` ${glyphs.ellipsis}+${extra} line${extra === 1 ? '' : 's'}` : '';
+    return (_jsx(Text, { wrap: "truncate", color: theme.muted, children: `Queue: ${first}${suffix}` }));
+}
+/**
+ * `React.memo` with the DEFAULT comparator, like every sibling entry card: the
+ * reducer rebuilds the entry object only when it changes, and a `queued` entry
+ * changes exactly twice -- once when appended, once when it is rewritten into a
+ * `user` entry and stops being this component's problem.
+ */
+export const QueuedEntry = React.memo(QueuedEntryImpl);

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).