praxis-agent 0.21.2 → 0.21.4

package/dist/cli/interactive.js

@@ -14,7 +14,9 @@ import { redactSensitiveText, sensitiveEnvironmentValues, } from '../platform/se
 import { CommandPalette, BtwPanel, Composer, DiffDashboard, DialogFrame, ExternalEditorWait, HelpMenu, HookDashboard, ListDashboard, MemoryDashboard, MentionPicker, ModelMenu, PermissionDashboard, SelectionMenu, SessionPicker, ThemePicker, CustomThemeEditor, SessionIdentity, Transcript, WelcomePanel, useTerminalRows, useTerminalWidth, } from './tui/claude-style.js';
 import { loadTuiMemoryFiles, openTuiMemoryFolder, } from './tui/memory-files.js';
 import { loadClaudeReleaseNotes } from './tui/release-notes.js';
+import { StreamingFrameBuffer } from './tui/streaming-frame-buffer.js';
 import { createClaudeStatusLineInput, StatusLine } from './tui/status-line.js';
+import { FULLSCREEN_TRANSCRIPT_RESERVED_ROWS, projectTranscriptTail, } from './tui/transcript-viewport.js';
 import { loadGitDiff, visiblePatchLines, } from './tui/git-diff.js';
 import { addTuiPermissionRule, loadTuiPermissionRules, removeTuiPermissionRule, } from './tui/permission-settings.js';
 import { createRecentlyDeniedStore, } from './tui/recently-denied.js';
@@ -409,6 +411,20 @@ export function InteractiveApp({ factory, initialSessions, initialPrompt, initia
     const [status, setStatus] = useState('ready');
     const [activeText, setActiveText] = useState('');
     const [activeThinking, setActiveThinking] = useState('');
+    // One provider-neutral streaming frame buffer per mounted app. RuntimeEvent
+    // text/thinking deltas accumulate here and are coalesced into bounded frames
+    // instead of causing a React state update per delta. The React state is only
+    // ever written through the buffer's publish callback so the buffer's committed
+    // prefix and the displayed text stay in sync. Disposed on unmount.
+    const streamingFrameRef = useRef(null);
+    if (streamingFrameRef.current === null) {
+        streamingFrameRef.current = new StreamingFrameBuffer({
+            publish: (frame) => {
+                setActiveText(frame.text);
+                setActiveThinking(frame.thinking);
+            },
+        });
+    }
     const [thinkingExpanded, setThinkingExpanded] = useState(false);
     const [turnDuration, setTurnDuration] = useState();
     const [usage, setUsage] = useState();
@@ -432,6 +448,13 @@ export function InteractiveApp({ factory, initialSessions, initialPrompt, initia
     // conversation content appears.
     const resumed = resume !== undefined && resumedWithTranscript;
     const freshSession = !resumed && !hasConversationHistory;
+    // Fullscreen projects only the newest transcript tail that fits the fixed
+    // viewport, leaving the composer/status chrome intact and keeping the active
+    // stream visible. Classic and screen-reader modes always render the full
+    // history exactly as before.
+    const projectedHistory = fixedViewport && !axScreenReader
+        ? projectTranscriptTail(history, Math.max(1, (rows ?? 0) - FULLSCREEN_TRANSCRIPT_RESERVED_ROWS), width)
+        : history;
     const sessionLoadRef = useRef(0);
     const [turnDiffs, setTurnDiffs] = useState([]);
     const turnNumberRef = useRef(0);
@@ -675,6 +698,7 @@ export function InteractiveApp({ factory, initialSessions, initialPrompt, initia
     }, [exit, signal]);
     useEffect(() => () => {
         componentMountedRef.current = false;
+        streamingFrameRef.current?.dispose();
         permissionRef.current?.resolve(false);
         elicitationRef.current?.resolve({ action: 'cancel' });
         questionRef.current?.resolve(null);
@@ -692,7 +716,13 @@ export function InteractiveApp({ factory, initialSessions, initialPrompt, initia
         else
             void closing.catch(() => undefined);
     }, []);
-    const append = (line) => setHistory((current) => [...current, line]);
+    const append = (line) => {
+        // Any unflushed streaming deltas must be published before the boundary
+        // transcript state so the active stream never renders below a tool,
+        // thinking, or completion entry that it textually precedes.
+        streamingFrameRef.current?.flush();
+        setHistory((current) => [...current, line]);
+    };
     useEffect(() => {
         if (initialThemeSettings !== undefined) {
             if (initialThemeLoadError)
@@ -1111,28 +1141,33 @@ export function InteractiveApp({ factory, initialSessions, initialPrompt, initia
     const handleEvent = (event) => {
         switch (event.type) {
             case 'text-delta':
-                setActiveText((current) => current + event.delta);
+                streamingFrameRef.current?.appendText(event.delta);
                 break;
             case 'thinking-start':
-                setActiveThinking(event.block.type === 'thinking'
-                    ? redactSensitiveText(event.block.thinking, sensitiveValues)
-                    : '');
+                streamingFrameRef.current?.resetThinking();
+                if (event.block.type === 'thinking') {
+                    streamingFrameRef.current?.appendThinking(redactSensitiveText(event.block.thinking, sensitiveValues));
+                }
                 break;
             case 'thinking-delta':
-                setActiveThinking((current) => current + redactSensitiveText(event.delta, sensitiveValues));
+                streamingFrameRef.current?.appendThinking(redactSensitiveText(event.delta, sensitiveValues));
                 break;
             case 'thinking-signature-delta':
                 // Signatures authenticate a thinking block for provider replay; they are
                 // intentionally not part of the user-visible reasoning summary.
                 break;
             case 'thinking-stop':
+                // append flushes pending thinking deltas before the retained boundary
+                // item, keeping streaming order correct; the effective thinking getter
+                // already includes any deltas not yet published.
                 append({
                     kind: 'thinking',
                     text: event.block.type === 'thinking'
                         ? redactSensitiveText(event.block.thinking, sensitiveValues)
-                        : activeThinking,
+                        : (streamingFrameRef.current?.thinking ?? ''),
                 });
-                setActiveThinking('');
+                streamingFrameRef.current?.resetThinking();
+                streamingFrameRef.current?.flush();
                 break;
             case 'user-message':
                 append({ kind: 'assistant', text: event.message });
@@ -2575,8 +2610,9 @@ export function InteractiveApp({ factory, initialSessions, initialPrompt, initia
             ? allSlashCommands.find((command) => command.name.toLowerCase() === submittedCommandName)?.progressMessage
             : undefined;
         setStatus(commandProgressMessage ?? 'assembling-context');
-        setActiveText('');
-        setActiveThinking('');
+        streamingFrameRef.current?.resetText();
+        streamingFrameRef.current?.resetThinking();
+        streamingFrameRef.current?.flush();
         if (runtimeSettingsRef.current.tips && !commandProgressMessage) {
             setStatus(spinnerTip(runtimeSettingsRef.current) ?? 'assembling-context');
         }
@@ -2641,8 +2677,9 @@ export function InteractiveApp({ factory, initialSessions, initialPrompt, initia
                     // Diff snapshots are a local presentation aid and must not fail a turn.
                 }
             }
-            setActiveText('');
-            setActiveThinking('');
+            streamingFrameRef.current?.resetText();
+            streamingFrameRef.current?.resetThinking();
+            streamingFrameRef.current?.flush();
             setStatus('ready');
             setTurnDuration(Date.now() - turnStartedAt);
             if (runtimeSettingsRef.current.notifChannel !== 'notifications_disabled') {
@@ -5131,8 +5168,9 @@ export function InteractiveApp({ factory, initialSessions, initialPrompt, initia
                 setHistory([]);
                 setUsage(undefined);
                 setCostUsd(undefined);
-                setActiveText('');
-                setActiveThinking('');
+                streamingFrameRef.current?.resetText();
+                streamingFrameRef.current?.resetThinking();
+                streamingFrameRef.current?.flush();
                 setThinkingExpanded(false);
                 setStatus('ready');
                 inputHistoryRef.current = [];
@@ -5647,7 +5685,13 @@ export function InteractiveApp({ factory, initialSessions, initialPrompt, initia
     });
     return (_jsx(TuiThemeProvider, { settings: themeSettings, children: _jsx(Box, { flexDirection: "column", ...(!fixedViewport
                 ? {}
-                : { height: rows, overflowY: 'hidden' }), children: selectingSession ? (_jsx(SessionPicker, { sessions: filteredPickerChoices, selectedIndex: selectedIndex, screenReader: axScreenReader, query: sessionSearch })) : (_jsxs(_Fragment, { children: [!axScreenReader && freshSession ? (_jsx(WelcomePanel, { display: runtimeDisplay, width: width, showTips: runtimeSettings.tips })) : null, sessionId ? (_jsxs(Text, { dimColor: true, children: ["Session ", sessionId.slice(0, 8)] })) : null, !axScreenReader && !resumed && hasConversationHistory ? (_jsx(SessionIdentity, { display: runtimeDisplay, width: width })) : null, _jsx(Transcript, { items: history, activeText: activeText, activeThinking: activeThinking, thinkingExpanded: thinkingExpanded, detailedTranscript: thinkingExpanded || runtimeSettings.verbose, screenReader: axScreenReader }), externalEditorRequest !== null ||
+                : { height: rows, overflowY: 'hidden' }), children: selectingSession ? (_jsx(SessionPicker, { sessions: filteredPickerChoices, selectedIndex: selectedIndex, screenReader: axScreenReader, query: sessionSearch })) : (_jsxs(_Fragment, { children: [!axScreenReader && freshSession ? (_jsx(WelcomePanel, { display: runtimeDisplay, width: width, showTips: runtimeSettings.tips })) : null, sessionId ? (_jsxs(Text, { dimColor: true, children: ["Session ", sessionId.slice(0, 8)] })) : null, !axScreenReader && !resumed && hasConversationHistory ? (_jsx(SessionIdentity, { display: runtimeDisplay, width: width })) : null, _jsx(Box, { ...(fixedViewport
+                            ? {
+                                flexShrink: 1,
+                                minHeight: 0,
+                                overflowY: 'hidden',
+                            }
+                            : {}), children: _jsx(Transcript, { items: projectedHistory, activeText: activeText, activeThinking: activeThinking, thinkingExpanded: thinkingExpanded, detailedTranscript: thinkingExpanded || runtimeSettings.verbose, screenReader: axScreenReader }) }), externalEditorRequest !== null ||
                         keybindingsEditing ||
                         memoryEditorRequest !== null ? (_jsx(ExternalEditorWait, { screenReader: axScreenReader })) : permission ? (permission.kind === 'tool' && toolPermissionModel ? (_jsx(ToolPermissionDialog, { model: toolPermissionModel, selection: permissionSelection, feedbackMode: permissionFeedbackMode, feedback: input, ruleEditor: permissionRuleEditor, screenReader: axScreenReader })) : (_jsxs(DialogFrame, { title: `Retry interrupted ${permission.call.name}?`, screenReader: axScreenReader, children: [_jsx(Box, { flexDirection: "column", paddingX: 1, paddingY: 1, children: _jsx(Text, { bold: true, children: describeTool(permission.call, sensitiveValues) }) }), _jsx(Text, { children: "Do you want to proceed?" }), _jsxs(Text, { inverse: !axScreenReader && permissionSelection === 0, children: [selectionPrefix(permissionSelection === 0, axScreenReader), "1. Yes"] }), _jsxs(Text, { inverse: !axScreenReader && permissionSelection === 1, children: [selectionPrefix(permissionSelection === 1, axScreenReader), "2. No"] }), permissionFeedbackMode ? (_jsxs(Text, { children: ["\u203A", ' ', input ||
                                         (permissionSelection === 0

package/dist/cli/tui/claude-style.d.ts

@@ -84,6 +84,12 @@ export declare function SessionIdentity({ display, width, }: {
 export declare function MarkdownText({ text }: {
     text: string;
 }): ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
+export declare const ACTIVE_STREAM_MAX_LINES = 40;
+export declare function activeStreamWindow(text: string): {
+    stableText: string;
+    pendingText: string;
+    truncated: boolean;
+};
 export declare function Transcript({ items, activeText, activeThinking, thinkingExpanded, detailedTranscript, screenReader, }: {
     items: readonly TranscriptItem[];
     activeText: string;

package/dist/cli/tui/claude-style.js

@@ -473,6 +473,44 @@ export function MarkdownText({ text }) {
     const palette = useTuiPalette();
     return cachedMarkdownTextElement(text, palette);
 }
+// Bounded streaming-text presentation. While a turn is in progress the active
+// assistant text grows on every frame; re-parsing the entire Markdown document
+// each frame would reflow the whole growing body and could let an unterminated
+// fence or heading corrupt the terminal frame. Instead only a bounded window of
+// the most recent complete lines is rendered through MarkdownText, and the
+// trailing partial line is rendered as plain text so incomplete Markdown stays
+// inert. Completed assistant turns still render the full document through the
+// regular history Markdown path, so observable final text is unchanged.
+export const ACTIVE_STREAM_MAX_LINES = 40;
+export function activeStreamWindow(text) {
+    const lastBreak = text.lastIndexOf('\n');
+    if (lastBreak === -1) {
+        return { stableText: '', pendingText: text, truncated: false };
+    }
+    const pendingText = text.slice(lastBreak + 1);
+    let cursor = lastBreak;
+    let lines = 0;
+    // Walk backwards to the newline that starts the bounded window's first line.
+    while (lines < ACTIVE_STREAM_MAX_LINES) {
+        const previous = cursor > 0 ? text.lastIndexOf('\n', cursor - 1) : -1;
+        if (previous === -1) {
+            cursor = 0;
+            break;
+        }
+        cursor = previous;
+        lines += 1;
+    }
+    const windowStart = cursor === 0 ? 0 : cursor + 1;
+    return {
+        stableText: text.slice(windowStart, lastBreak + 1),
+        pendingText,
+        truncated: windowStart > 0,
+    };
+}
+function ActiveStreamText({ text }) {
+    const { stableText, pendingText, truncated } = activeStreamWindow(text);
+    return (_jsxs(Box, { flexDirection: "column", children: [truncated ? _jsx(Text, { dimColor: true, children: "\u2026 earlier streaming content \u2026" }) : null, stableText ? _jsx(MarkdownText, { text: stableText }) : null, pendingText ? _jsx(Text, { children: pendingText }) : null] }));
+}
 export function Transcript({ items, activeText, activeThinking = '', thinkingExpanded = false, detailedTranscript = false, screenReader, }) {
     const palette = useTuiPalette();
     const detailed = thinkingExpanded || detailedTranscript;
@@ -585,7 +623,7 @@ export function Transcript({ items, activeText, activeThinking = '', thinkingExp
                     return (_jsx(Box, { marginLeft: 2, children: _jsxs(Text, { dimColor: true, children: ["\u23BF ", item.text] }) }, index));
                 }
                 return (_jsxs(Text, { ...(item.kind === 'warning' ? { color: palette.error } : {}), dimColor: item.kind === 'notice', children: [item.kind === 'warning' ? '⚠ ' : '· ', item.text] }, index));
-            }), activeThinking ? (_jsx(ThinkingBlock, { text: activeThinking, active: true, expanded: detailed, screenReader: screenReader })) : activeText ? (_jsxs(Box, { marginTop: 1, children: [screenReader ? (_jsx(Text, { children: "Praxis: " })) : (_jsx(Text, { color: palette.accent, children: "\u2733 " })), _jsx(MarkdownText, { text: activeText })] })) : null] }));
+            }), activeThinking ? (_jsx(ThinkingBlock, { text: activeThinking, active: true, expanded: detailed, screenReader: screenReader })) : activeText ? (_jsxs(Box, { marginTop: 1, children: [screenReader ? (_jsx(Text, { children: "Praxis: " })) : (_jsx(Text, { color: palette.accent, children: "\u2733 " })), screenReader ? (_jsx(MarkdownText, { text: activeText })) : (_jsx(ActiveStreamText, { text: activeText }))] })) : null] }));
 }
 export function DiffDashboard({ snapshots, sourceIndex, selectedIndex, viewingFile, scrollOffset, width, screenReader, }) {
     const palette = useTuiPalette();

package/dist/cli/tui/streaming-frame-buffer.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Provider-neutral streaming frame buffer for the interactive CLI.
+ *
+ * High-frequency RuntimeEvent text/thinking deltas are appended here and
+ * coalesced into bounded presentation frames published at a fixed cadence
+ * (default ~30 FPS). Deltas are never lost or reordered: each stream keeps a
+ * committed prefix (the last published value) plus an accumulating pending
+ * tail, and every published frame is the exact concatenation of every delta
+ * received since the previous frame.
+ *
+ * `flush()` publishes any pending deltas immediately and is used at lifecycle
+ * boundaries (thinking-stop, tool-call/result, permission/dialog transitions,
+ * turn completion/cancellation) so the transcript boundary state is always
+ * published after the streaming text that preceded it. `dispose()` cancels
+ * pending schedules and ignores later appends after the mounted app is torn
+ * down.
+ *
+ * Scheduling is injected so tests can drive frames deterministically without
+ * fixed sleeps.
+ */
+export interface StreamingFrame {
+    /** Full accumulated assistant text for the active stream. */
+    readonly text: string;
+    /** Full accumulated thinking text for the active stream. */
+    readonly thinking: string;
+}
+export interface StreamingFrameScheduler {
+    /** Schedule `callback` after `delayMs`; returns an opaque cancel handle. */
+    schedule(callback: () => void, delayMs: number): unknown;
+    /** Cancel a previously scheduled callback. */
+    cancel(handle: unknown): void;
+}
+export declare const DEFAULT_FRAME_INTERVAL_MS = 33;
+export interface StreamingFrameBufferOptions {
+    /** Called with every published frame. */
+    publish: (frame: StreamingFrame) => void;
+    /** Bounded cadence between frames; defaults to ~30 FPS. */
+    frameIntervalMs?: number;
+    /** Injected timer hook for deterministic tests. */
+    scheduler?: StreamingFrameScheduler;
+}
+export declare class StreamingFrameBuffer {
+    private readonly publishFrame;
+    private readonly frameIntervalMs;
+    private readonly scheduler;
+    private committedText;
+    private committedThinking;
+    private pendingText;
+    private pendingThinking;
+    private scheduled;
+    private scheduledHandle;
+    private disposed;
+    constructor(options: StreamingFrameBufferOptions);
+    /** Full effective text, including any deltas not yet published. */
+    get text(): string;
+    /** Full effective thinking, including any deltas not yet published. */
+    get thinking(): string;
+    get hasPending(): boolean;
+    get isDisposed(): boolean;
+    /** Append an assistant text delta and schedule a frame publish. */
+    appendText(delta: string): void;
+    /** Append a thinking delta and schedule a frame publish. */
+    appendThinking(delta: string): void;
+    /** Discard pending text and clear the active text on the next frame. */
+    resetText(): void;
+    /** Discard pending thinking and clear the active thinking on the next frame. */
+    resetThinking(): void;
+    /** Publish every pending delta immediately, canceling any scheduled frame. */
+    flush(): void;
+    /** Cancel pending schedules and ignore all later appends. */
+    dispose(): void;
+    private scheduleFrame;
+    private cancelScheduledFrame;
+    private publishPending;
+}
+//# sourceMappingURL=streaming-frame-buffer.d.ts.map

package/dist/cli/tui/streaming-frame-buffer.js

@@ -0,0 +1,148 @@
+/**
+ * Provider-neutral streaming frame buffer for the interactive CLI.
+ *
+ * High-frequency RuntimeEvent text/thinking deltas are appended here and
+ * coalesced into bounded presentation frames published at a fixed cadence
+ * (default ~30 FPS). Deltas are never lost or reordered: each stream keeps a
+ * committed prefix (the last published value) plus an accumulating pending
+ * tail, and every published frame is the exact concatenation of every delta
+ * received since the previous frame.
+ *
+ * `flush()` publishes any pending deltas immediately and is used at lifecycle
+ * boundaries (thinking-stop, tool-call/result, permission/dialog transitions,
+ * turn completion/cancellation) so the transcript boundary state is always
+ * published after the streaming text that preceded it. `dispose()` cancels
+ * pending schedules and ignores later appends after the mounted app is torn
+ * down.
+ *
+ * Scheduling is injected so tests can drive frames deterministically without
+ * fixed sleeps.
+ */
+export const DEFAULT_FRAME_INTERVAL_MS = 33;
+const timeoutScheduler = {
+    schedule(callback, delayMs) {
+        return setTimeout(callback, delayMs);
+    },
+    cancel(handle) {
+        clearTimeout(handle);
+    },
+};
+export class StreamingFrameBuffer {
+    publishFrame;
+    frameIntervalMs;
+    scheduler;
+    committedText = '';
+    committedThinking = '';
+    pendingText = null;
+    pendingThinking = null;
+    scheduled = false;
+    scheduledHandle = undefined;
+    disposed = false;
+    constructor(options) {
+        this.publishFrame = options.publish;
+        this.frameIntervalMs = options.frameIntervalMs ?? DEFAULT_FRAME_INTERVAL_MS;
+        this.scheduler = options.scheduler ?? timeoutScheduler;
+    }
+    /** Full effective text, including any deltas not yet published. */
+    get text() {
+        return this.pendingText ?? this.committedText;
+    }
+    /** Full effective thinking, including any deltas not yet published. */
+    get thinking() {
+        return this.pendingThinking ?? this.committedThinking;
+    }
+    get hasPending() {
+        return this.pendingText !== null || this.pendingThinking !== null;
+    }
+    get isDisposed() {
+        return this.disposed;
+    }
+    /** Append an assistant text delta and schedule a frame publish. */
+    appendText(delta) {
+        if (this.disposed)
+            return;
+        this.pendingText = (this.pendingText ?? this.committedText) + delta;
+        this.scheduleFrame();
+    }
+    /** Append a thinking delta and schedule a frame publish. */
+    appendThinking(delta) {
+        if (this.disposed)
+            return;
+        this.pendingThinking =
+            (this.pendingThinking ?? this.committedThinking) + delta;
+        this.scheduleFrame();
+    }
+    /** Discard pending text and clear the active text on the next frame. */
+    resetText() {
+        if (this.disposed)
+            return;
+        if (this.pendingText === '' ||
+            (this.pendingText === null && this.committedText === '')) {
+            return;
+        }
+        this.pendingText = '';
+        this.scheduleFrame();
+    }
+    /** Discard pending thinking and clear the active thinking on the next frame. */
+    resetThinking() {
+        if (this.disposed)
+            return;
+        if (this.pendingThinking === '' ||
+            (this.pendingThinking === null && this.committedThinking === '')) {
+            return;
+        }
+        this.pendingThinking = '';
+        this.scheduleFrame();
+    }
+    /** Publish every pending delta immediately, canceling any scheduled frame. */
+    flush() {
+        if (this.disposed)
+            return;
+        this.cancelScheduledFrame();
+        this.publishPending();
+    }
+    /** Cancel pending schedules and ignore all later appends. */
+    dispose() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        this.cancelScheduledFrame();
+        this.pendingText = null;
+        this.pendingThinking = null;
+    }
+    scheduleFrame() {
+        if (this.scheduled || this.disposed)
+            return;
+        this.scheduled = true;
+        this.scheduledHandle = this.scheduler.schedule(() => {
+            this.scheduled = false;
+            this.scheduledHandle = undefined;
+            this.publishPending();
+        }, this.frameIntervalMs);
+    }
+    cancelScheduledFrame() {
+        if (this.scheduledHandle !== undefined) {
+            this.scheduler.cancel(this.scheduledHandle);
+            this.scheduledHandle = undefined;
+            this.scheduled = false;
+        }
+    }
+    publishPending() {
+        if (this.disposed)
+            return;
+        if (this.pendingText === null && this.pendingThinking === null)
+            return;
+        if (this.pendingText !== null)
+            this.committedText = this.pendingText;
+        if (this.pendingThinking !== null) {
+            this.committedThinking = this.pendingThinking;
+        }
+        this.pendingText = null;
+        this.pendingThinking = null;
+        this.publishFrame({
+            text: this.committedText,
+            thinking: this.committedThinking,
+        });
+    }
+}
+//# sourceMappingURL=streaming-frame-buffer.js.map

package/dist/cli/tui/transcript-viewport.d.ts

@@ -0,0 +1,34 @@
+import type { TranscriptItem } from './claude-style.js';
+/**
+ * Rows reserved outside the shrinkable fullscreen transcript region: the top
+ * identity chrome, the composer separator/prompt/footer, and the status line,
+ * plus a small headroom so the active streaming tail stays visible below the
+ * projected history suffix. Fullscreen computes the transcript budget as
+ * `rows - FULLSCREEN_TRANSCRIPT_RESERVED_ROWS`.
+ */
+export declare const FULLSCREEN_TRANSCRIPT_RESERVED_ROWS = 12;
+/**
+ * Compact marker prepended to the projected tail of an oversized newest item so
+ * the truncation is visually explicit while the newest lines remain visible.
+ */
+export declare const TRANSCRIPT_TRUNCATION_MARKER = "\u2026";
+/**
+ * Deterministic estimate of the terminal rows one transcript item occupies in
+ * the TUI presentation. It is intentionally conservative (leans toward
+ * overestimation) so the suffix projector keeps the newest content visible
+ * rather than dropping items that would actually render.
+ */
+export declare function estimateTranscriptLines(item: TranscriptItem, width: number): number;
+/**
+ * Pure, deterministic suffix projector for the fullscreen transcript region.
+ *
+ * Given transcript items, a terminal row budget, and the usable width, it
+ * returns the longest suffix of items whose conservative line estimate fits
+ * the budget. The newest user/assistant content is always retained; if even
+ * the newest item exceeds the budget, that item is projected as a bounded tail
+ * clone rather than rendering an empty transcript (or clipping the tail below
+ * the viewport). Ordering and item object identity are preserved for items
+ * that fit and the input is never mutated.
+ */
+export declare function projectTranscriptTail(items: readonly TranscriptItem[], budget: number, width: number): readonly TranscriptItem[];
+//# sourceMappingURL=transcript-viewport.d.ts.map

package/dist/cli/tui/transcript-viewport.js

@@ -0,0 +1,156 @@
+/**
+ * Rows reserved outside the shrinkable fullscreen transcript region: the top
+ * identity chrome, the composer separator/prompt/footer, and the status line,
+ * plus a small headroom so the active streaming tail stays visible below the
+ * projected history suffix. Fullscreen computes the transcript budget as
+ * `rows - FULLSCREEN_TRANSCRIPT_RESERVED_ROWS`.
+ */
+export const FULLSCREEN_TRANSCRIPT_RESERVED_ROWS = 12;
+/**
+ * Conservative width-aware row estimate for a block of text. Blank lines still
+ * occupy a row, and every logical line wraps across `Math.ceil(length / width)`
+ * rows so the estimate leans high and never drops content that would actually
+ * fit.
+ */
+function wrappedLineCount(text, width) {
+    if (text === '')
+        return 1;
+    const usable = Math.max(1, width);
+    let rows = 0;
+    for (const line of text.split('\n')) {
+        rows += Math.max(1, Math.ceil(line.length / usable));
+    }
+    return rows;
+}
+function bounded(text, max) {
+    return text.length > max ? text.slice(0, max) : text;
+}
+/**
+ * Compact marker prepended to the projected tail of an oversized newest item so
+ * the truncation is visually explicit while the newest lines remain visible.
+ */
+export const TRANSCRIPT_TRUNCATION_MARKER = '…';
+/**
+ * Projects a text block to the longest trailing suffix (newest content) that
+ * fits `budget` terminal rows, prefixed with the truncation marker. The marker
+ * merges into the first kept line, so the result is exactly
+ * `${TRANSCRIPT_TRUNCATION_MARKER}${suffix}`. A text that already fits is
+ * returned unchanged.
+ */
+function projectTextTail(text, budget, width) {
+    if (wrappedLineCount(text, width) <= budget)
+        return text;
+    const lines = text.split('\n');
+    let start = lines.length;
+    // Wrapped rows of every kept line after the current front line (marker-free).
+    let rowsAfter = 0;
+    for (let index = lines.length - 1; index >= 0; index -= 1) {
+        const line = lines[index];
+        if (line === undefined)
+            break;
+        // This line becomes the front of the tail and carries the marker.
+        if (rowsAfter +
+            wrappedLineCount(`${TRANSCRIPT_TRUNCATION_MARKER}${line}`, width) >
+            budget) {
+            break;
+        }
+        start = index;
+        rowsAfter += wrappedLineCount(line, width);
+    }
+    return `${TRANSCRIPT_TRUNCATION_MARKER}${lines.slice(start).join('\n')}`;
+}
+/**
+ * Returns a cloned oversized text-bearing item whose text/summary is a bounded
+ * trailing suffix that fits `budget` rows, preserving the newest content and
+ * the item kind without mutating the input. Non-text display items (context,
+ * tool, tool-result, shell, shell-result) are returned unchanged.
+ */
+function projectOversizedItem(item, budget, width) {
+    switch (item.kind) {
+        case 'user':
+        case 'assistant':
+        case 'notice':
+        case 'warning':
+        case 'local-result':
+            return { ...item, text: projectTextTail(item.text, budget, width) };
+        case 'thinking':
+            return {
+                ...item,
+                text: projectTextTail(item.text, Math.max(1, budget - 1), width),
+            };
+        case 'compact':
+            return {
+                ...item,
+                summary: projectTextTail(item.summary, Math.max(1, budget - 1), width),
+            };
+        default:
+            return item;
+    }
+}
+/**
+ * Deterministic estimate of the terminal rows one transcript item occupies in
+ * the TUI presentation. It is intentionally conservative (leans toward
+ * overestimation) so the suffix projector keeps the newest content visible
+ * rather than dropping items that would actually render.
+ */
+export function estimateTranscriptLines(item, width) {
+    switch (item.kind) {
+        case 'user':
+        case 'assistant':
+        case 'notice':
+        case 'warning':
+        case 'local-result':
+            return wrappedLineCount(item.text, width);
+        case 'thinking':
+            return 1 + wrappedLineCount(item.text, width);
+        case 'compact':
+            return 1 + wrappedLineCount(item.summary, width);
+        case 'context':
+            return 12 + item.skills.length + item.memoryFiles.length;
+        case 'tool':
+            return 1 + (item.detail ? 1 : 0);
+        case 'tool-result':
+            return 1 + wrappedLineCount(bounded(item.text, 500), width);
+        case 'shell':
+            return 2 + wrappedLineCount(item.command, width);
+        case 'shell-result':
+            return wrappedLineCount(bounded(`${item.stdout}\n${item.stderr}`, 500), width);
+    }
+}
+/**
+ * Pure, deterministic suffix projector for the fullscreen transcript region.
+ *
+ * Given transcript items, a terminal row budget, and the usable width, it
+ * returns the longest suffix of items whose conservative line estimate fits
+ * the budget. The newest user/assistant content is always retained; if even
+ * the newest item exceeds the budget, that item is projected as a bounded tail
+ * clone rather than rendering an empty transcript (or clipping the tail below
+ * the viewport). Ordering and item object identity are preserved for items
+ * that fit and the input is never mutated.
+ */
+export function projectTranscriptTail(items, budget, width) {
+    if (items.length === 0)
+        return [];
+    const usableBudget = Math.max(1, budget);
+    let rows = 0;
+    let start = items.length;
+    for (let index = items.length - 1; index >= 0; index -= 1) {
+        const item = items[index];
+        if (item === undefined)
+            break;
+        const estimate = estimateTranscriptLines(item, width);
+        if (rows + estimate > usableBudget) {
+            // Stop at the first item that no longer fits. When no item has been
+            // added yet, even the newest item exceeds the budget: returning it whole
+            // would let Ink clip the oversized tail below the viewport, so project a
+            // bounded suffix clone that keeps the newest content visible instead.
+            return start === items.length
+                ? [projectOversizedItem(item, usableBudget, width)]
+                : items.slice(start);
+        }
+        rows += estimate;
+        start = index;
+    }
+    return items.slice(start);
+}
+//# sourceMappingURL=transcript-viewport.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "praxis-agent",
-  "version": "0.21.2",
+  "version": "0.21.4",
   "description": "Local-first, single-user general agent for the command line.",
   "license": "MIT",
   "author": "wuqisen",