praxis-agent 0.21.2 → 0.21.3

package/dist/cli/interactive.js

@@ -14,6 +14,7 @@ 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 { loadGitDiff, visiblePatchLines, } from './tui/git-diff.js';
 import { addTuiPermissionRule, loadTuiPermissionRules, removeTuiPermissionRule, } from './tui/permission-settings.js';
@@ -409,6 +410,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();
@@ -675,6 +690,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 +708,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 +1133,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 +2602,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 +2669,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 +5160,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 +5677,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: history, 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/package.json

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