praxis-agent 0.22.0 → 0.23.1

package/dist/application/session-memory.d.ts

@@ -25,8 +25,11 @@ export interface SessionMemoryStoreOptions {
     sidecarRoot?: string;
 }
 /**
- * Durable sidecar for one session's extracted memory under
- * `<configRoot>/praxis/session-memory/<sessionId>/`. All writes are atomic
+ * Durable sidecar for one session's extracted memory. Claude compatibility
+ * defaults to `<configRoot>/praxis/session-memory/<sessionId>/`; callers may
+ * select another data plane with
+ * `<sidecarRoot>/session-memory/<sessionId>/` (for example, native
+ * `<configRoot>/state/session-memory/<sessionId>/`). All writes are atomic
  * (same-directory temp file, fsync, then rename) and version-checked. Never
  * touches shared Claude transcript entries.
  */

package/dist/application/session-memory.js

@@ -77,8 +77,11 @@ function parseSessionMemoryState(source) {
     return value;
 }
 /**
- * Durable sidecar for one session's extracted memory under
- * `<configRoot>/praxis/session-memory/<sessionId>/`. All writes are atomic
+ * Durable sidecar for one session's extracted memory. Claude compatibility
+ * defaults to `<configRoot>/praxis/session-memory/<sessionId>/`; callers may
+ * select another data plane with
+ * `<sidecarRoot>/session-memory/<sessionId>/` (for example, native
+ * `<configRoot>/state/session-memory/<sessionId>/`). All writes are atomic
  * (same-directory temp file, fsync, then rename) and version-checked. Never
  * touches shared Claude transcript entries.
  */

package/dist/cli/interactive.js

@@ -15,9 +15,11 @@ 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 { fullscreenInkRenderOptions } from './tui/fullscreen-renderer.js';
 import { StreamingFrameBuffer } from './tui/streaming-frame-buffer.js';
 import { createClaudeStatusLineInput, StatusLine } from './tui/status-line.js';
-import { FULLSCREEN_TRANSCRIPT_RESERVED_ROWS, projectTranscriptTail, projectTranscriptWindow, transcriptLineCount, } from './tui/transcript-viewport.js';
+import { FULLSCREEN_TRANSCRIPT_RESERVED_ROWS, transcriptLineCount, } from './tui/transcript-viewport.js';
+import { projectTuiView, resolveTuiRenderer } from './tui/tui-view-model.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';
@@ -26,6 +28,7 @@ import { filterTuiSlashCommands, mergeTuiSlashCommands, slashCommandQuery, } fro
 import { runDoctor, } from '../maintenance/doctor.js';
 import { canonicalClaudeCostModelName, formatCostSummary, } from './tui/cost-summary.js';
 import { createComposerEditor, deleteComposerBackward, deleteComposerForward, deleteComposerToEnd, deleteComposerToStart, deleteComposerWordBackward, insertComposerText, moveComposerCursor, moveComposerCursorByWord, } from './tui/composer-editor.js';
+import { routeComposerKey, } from './tui/composer-key-router.js';
 import { applyMentionReference, fileReferenceAtCursor, filterTuiMentionEntries, loadTuiFileEntries, } from './tui/file-picker.js';
 import { editTuiPrompt, openTuiEditorFile, } from './tui/external-editor.js';
 import { suspendTuiProcess } from './tui/terminal-suspend.js';
@@ -447,32 +450,31 @@ export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: sup
     const [contextWindowTokens, setContextWindowTokens] = useState(display.contextWindowTokens);
     const [history, setHistory] = useState([...initialHistory]);
     const [transcriptScrollOffset, setTranscriptScrollOffset] = useState(0);
-    // Startup diagnostics are useful before the first prompt, but they are not
-    // conversation history and must not suppress the new-session welcome panel.
-    // Only real user/assistant transcript entries start a conversation; every
-    // other kind (thinking, context, tool, shell, notices, results, and so on)
-    // is operational bookkeeping that must not hide the fresh-session welcome.
-    const isRealConversation = (item) => item.kind === 'user' || item.kind === 'assistant';
-    // The original loaded transcript decides whether the session was resumed,
-    // separately from the live history that grows while the session runs.
-    const resumedWithTranscript = initialHistory.some(isRealConversation);
-    const hasConversationHistory = history.some(isRealConversation);
-    // A session is resumed only when it was opened through `resume` and the
-    // original transcript already contained real conversation content. Supplying
-    // a session ID alone with an empty transcript keeps the session fresh, so the
-    // full welcome panel renders and the compact identity stays hidden until real
-    // 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
-        ? transcriptScrollOffset > 0
-            ? projectTranscriptWindow(history, Math.max(1, (rows ?? 0) - FULLSCREEN_TRANSCRIPT_RESERVED_ROWS), width, transcriptScrollOffset)
-            : projectTranscriptTail(history, Math.max(1, (rows ?? 0) - FULLSCREEN_TRANSCRIPT_RESERVED_ROWS), width)
-        : history;
+    // The pure TUI view model classifies the session identity (fresh/resumed/
+    // started) and projects the rendered transcript. Startup diagnostics are
+    // useful before the first prompt, but they are not conversation history and
+    // must not suppress the new-session welcome panel. Only real user/assistant
+    // transcript entries start a conversation; every other kind (thinking,
+    // context, tool, shell, notices, results, and so on) is operational
+    // bookkeeping that must not hide the fresh-session welcome. The original
+    // loaded transcript decides whether the session was resumed, separately from
+    // the live history that grows while the session runs. A session is resumed
+    // only when it was opened through `resume` and the original transcript
+    // already contained real conversation content. 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, resumed, freshSession, hasConversationHistory } = projectTuiView({
+        initialHistory,
+        history,
+        resume: resume !== undefined,
+        fixedViewport,
+        screenReader: axScreenReader,
+        rows,
+        width,
+        scrollOffset: transcriptScrollOffset,
+    });
     const sessionLoadRef = useRef(0);
     const [turnDiffs, setTurnDiffs] = useState([]);
     const turnNumberRef = useRef(0);
@@ -2691,6 +2693,14 @@ export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: sup
             }
             setUsage(result.usage);
             setCostUsd(result.costUsd);
+            // The active stream and its committed final item must never render in the
+            // same frame. Publish the cleared stream before appending the final
+            // assistant entry; there is no await between these operations, and the
+            // renderer's frame buffer prevents the identical text from being shown
+            // twice during the transition.
+            streamingFrameRef.current?.resetText();
+            streamingFrameRef.current?.resetThinking();
+            streamingFrameRef.current?.flush();
             append({ kind: 'assistant', text: result.text });
             if (turnMutatedFilesRef.current) {
                 try {
@@ -5735,7 +5745,22 @@ export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: sup
             clearComposerInput();
             return;
         }
-        editComposer();
+        const transition = routeComposerKey(editor(), {
+            value,
+            left: key.leftArrow,
+            right: key.rightArrow,
+            backspace: key.backspace,
+            delete: key.delete,
+            ctrl: key.ctrl,
+            meta: key.meta,
+            escape: key.escape || value === '\u001B',
+        });
+        if (transition.kind === 'cancel') {
+            clearComposerInput();
+        }
+        else if (transition.kind === 'edit') {
+            updateComposerEditor(transition.editor);
+        }
     });
     return (_jsx(TuiThemeProvider, { settings: themeSettings, children: _jsx(Box, { flexDirection: "column", ...(!fixedViewport
                 ? {}
@@ -5884,6 +5909,22 @@ export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: sup
                                     usage?.outputTokens,
                                 ].join(':'), width: width, ...(settingSources === undefined ? {} : { settingSources }) })] }))] })) }) }));
 }
+/**
+ * Whether the user explicitly saved a `tui` renderer value in configuration.
+ * A fresh install leaves the setting unset, so the interactive TTY session can
+ * default to the fullscreen renderer; once the user runs `/tui default` or
+ * `/tui fullscreen`, the saved value is honored. If configuration cannot be
+ * read, the loaded runtime setting is honored instead of guessing.
+ */
+async function tuiRendererExplicitlyConfigured(target) {
+    try {
+        const snapshot = await loadConfigSettings(target);
+        return snapshot.settings.tui !== undefined;
+    }
+    catch {
+        return true;
+    }
+}
 export async function runInteractive(options) {
     const controller = new AbortController();
     const signal = options.signal
@@ -5903,7 +5944,19 @@ export async function runInteractive(options) {
     const runtimeSettingsTarget = { configRoot, statePath };
     let currentRuntimeSettings = options.runtimeSettings ??
         (await loadRuntimeSettings(runtimeSettingsTarget));
-    let currentRenderer = currentRuntimeSettings.tui;
+    // Fullscreen is the default interactive TTY renderer. Classic remains the
+    // fallback for screen-reader and non-interactive execution, and an explicit
+    // renderer saved in configuration is honored over the default.
+    const rendererExplicitlyConfigured = await tuiRendererExplicitlyConfigured(runtimeSettingsTarget);
+    let currentRenderer = resolveTuiRenderer({
+        configured: currentRuntimeSettings.tui,
+        explicitlyConfigured: rendererExplicitlyConfigured,
+        interactiveTty: process.stdin.isTTY === true,
+        screenReader: options.axScreenReader ?? false,
+    });
+    if (currentRenderer !== currentRuntimeSettings.tui) {
+        currentRuntimeSettings = { ...currentRuntimeSettings, tui: currentRenderer };
+    }
     let rendererChange = null;
     let rendererNotice;
     const readRendererChange = () => rendererChange;
@@ -6026,9 +6079,8 @@ export async function runInteractive(options) {
                 ? { allowDangerouslySkipPermissions: true }
                 : {}) }), {
             exitOnCtrlC: false,
-            incrementalRendering: !options.axScreenReader,
+            ...fullscreenInkRenderOptions(currentRenderer, options.axScreenReader),
             interactive: true,
-            alternateScreen: currentRenderer === 'fullscreen',
         });
         await instance.waitUntilExit();
         if (activeTurn)

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

@@ -2,6 +2,7 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-run
 import { cloneElement, useEffect, useState } from 'react';
 import { Box, Text, useStdout } from 'ink';
 import { composerEditorSegments } from './composer-editor.js';
+import { composerLayoutForWidth } from './composer-layout.js';
 import { visiblePatchLines } from './git-diff.js';
 import { TUI_HOOK_MENU } from './hook-settings.js';
 import { tuiPalette, tuiSyntaxStyle, useTuiPalette, } from './theme.js';
@@ -379,7 +380,9 @@ function ToolTranscriptEntry({ call, detail, result, detailed, }) {
         : displayResult;
     const oldLines = contentLines(inputString(call, 'old_string'));
     const newLines = contentLines(inputString(call, 'new_string'));
-    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Text, { children: [_jsx(Text, { color: palette.accent, children: "\u23FA" }), ' ', _jsx(Text, { bold: true, children: toolHeading(call) })] }), !['Bash', 'Read', 'Edit'].includes(call.name) && detail ? (_jsxs(Text, { dimColor: true, children: [" ", detail] })) : null, result ? (_jsx(Box, { marginLeft: 2, flexDirection: "column", children: result.isError ? (_jsxs(Text, { color: palette.error, children: ["\u23BF Error: ", errorText] })) : call.name === 'Edit' ? (_jsxs(_Fragment, { children: [_jsxs(Text, { dimColor: true, children: ["\u23BF Added ", newLines.length, " line", newLines.length === 1 ? '' : 's', ", removed ", oldLines.length, " line", oldLines.length === 1 ? '' : 's'] }), oldLines.map((line, index) => (_jsx(SyntaxCodeLine, { prefix: `   ${index + 1} -`, text: line, change: "removed" }, `old-${index}`))), newLines.map((line, index) => (_jsx(SyntaxCodeLine, { prefix: `   ${index + 1} +`, text: line, change: "added" }, `new-${index}`)))] })) : resultIsDiff ? (_jsx(ToolResultText, { text: visible.join('\n'), prefix: "\u23BF " })) : (_jsxs(_Fragment, { children: [visible.map((line, index) => (_jsxs(Text, { dimColor: true, children: [index === 0 ? '⎿ ' : '   ', line || ' '] }, index))), hidden > 0 ? (_jsxs(Text, { dimColor: true, children: ['   ', "\u2026 +", hidden, " lines (ctrl+o to expand)"] })) : null] })) })) : null] }));
+    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Text, { children: [_jsx(Text, { color: palette.accent, children: "\u23FA" }), ' ', _jsx(Text, { bold: true, children: toolHeading(call) })] }), !['Bash', 'Read', 'Edit'].includes(call.name) && detail ? (_jsxs(Text, { dimColor: true, children: [" ", detail] })) : null, result ? (_jsx(Box, { marginLeft: 2, flexDirection: "column", children: result.isError ? (_jsxs(Text, { color: palette.error, children: ["\u23BF Error: ", errorText] })) : call.name === 'Edit' ? (_jsxs(_Fragment, { children: [_jsxs(Text, { dimColor: true, children: ["\u23BF Added ", newLines.length, " line", newLines.length === 1 ? '' : 's', ", removed ", oldLines.length, " line", oldLines.length === 1 ? '' : 's'] }), detailed &&
+                            oldLines.map((line, index) => (_jsx(SyntaxCodeLine, { prefix: `   ${index + 1} -`, text: line, change: "removed" }, `old-${index}`))), detailed &&
+                            newLines.map((line, index) => (_jsx(SyntaxCodeLine, { prefix: `   ${index + 1} +`, text: line, change: "added" }, `new-${index}`)))] })) : resultIsDiff ? (_jsx(ToolResultText, { text: visible.join('\n'), prefix: "\u23BF " })) : (_jsxs(_Fragment, { children: [visible.map((line, index) => (_jsxs(Text, { dimColor: true, children: [index === 0 ? '⎿ ' : '   ', line || ' '] }, index))), hidden > 0 ? (_jsxs(Text, { dimColor: true, children: ['   ', "\u2026 +", hidden, " lines (ctrl+o to expand)"] })) : null] })) })) : null] }));
 }
 function ThinkingBlock({ text, active, expanded, screenReader, }) {
     const palette = useTuiPalette();
@@ -976,9 +979,9 @@ export function Composer({ input, cursor, busy, clipboardBusy = false, status, d
                     : shellMode
                         ? `Shell command: ${input}`
                         : `Prompt: ${input}` }));
-    const line = '─'.repeat(Math.max(12, Math.min(100, width)));
+    const { lineWidth, footerWidth, showEditorHint } = composerLayoutForWidth(width);
+    const line = '─'.repeat(lineWidth);
     const separatorColor = sessionColor === undefined ? undefined : palette.sessionColors[sessionColor];
-    const footerWidth = Math.min(100, width);
     const footerMode = `⏵⏵ ${permissionLabel(display.permissionMode)}`;
     const footerCompactMode = `⏵⏵ ${compactPermissionLabel(display.permissionMode)}`;
     const footerLeft = composerFooterLeft(footerWidth, busy, hasThinking, thinkingExpanded, footerMode, footerCompactMode);
@@ -995,7 +998,7 @@ export function Composer({ input, cursor, busy, clipboardBusy = false, status, d
                             ? 'Enter a shell command'
                             : 'Try "review this project"' }))] })), _jsx(Text, { ...(separatorColor === undefined
                     ? { dimColor: true }
-                    : { color: separatorColor }), children: line }), shortcutsVisible ? (_jsx(ShortcutHelp, { width: width })) : (_jsx(Box, { width: footerWidth, children: _jsx(Text, { wrap: "truncate", children: shellMode ? (_jsx(Text, { dimColor: true, children: "! for bash mode" })) : footerMessage ? (_jsxs(Text, { children: [_jsxs(Text, { dimColor: true, children: [footerMessageLeft, " \u00B7 "] }), footerMessage.isError ? (_jsx(Text, { color: palette.error, children: footerMessage.text })) : (_jsx(Text, { dimColor: true, children: footerMessage.text }))] })) : prStatus ? (_jsxs(Text, { children: [_jsxs(Text, { dimColor: true, children: [footerLeft, " \u00B7 "] }), _jsx(Text, { dimColor: true, children: prStatus })] })) : turnDuration ? (_jsxs(Text, { children: [_jsxs(Text, { dimColor: true, children: [footerLeft, " \u00B7 "] }), _jsxs(Text, { dimColor: true, children: ["Cooked for ", turnDuration] })] })) : display.effort ? (_jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: footerLeft }), _jsx(Text, { dimColor: true, children: " \u00B7 " }), _jsxs(Text, { color: palette.accent, children: ["\u25CF ", display.effort] }), footerWidth >= 100 ? (_jsxs(Text, { dimColor: true, children: [' ', "\u00B7 ", editorMode === 'vim' ? 'vim' : '/effort'] })) : null] })) : (_jsx(Text, { dimColor: true, children: footerLeft })) }) }))] }));
+                    : { color: separatorColor }), children: line }), shortcutsVisible ? (_jsx(ShortcutHelp, { width: width })) : (_jsx(Box, { width: footerWidth, children: _jsx(Text, { wrap: "truncate", children: shellMode ? (_jsx(Text, { dimColor: true, children: "! for bash mode" })) : footerMessage ? (_jsxs(Text, { children: [_jsxs(Text, { dimColor: true, children: [footerMessageLeft, " \u00B7 "] }), footerMessage.isError ? (_jsx(Text, { color: palette.error, children: footerMessage.text })) : (_jsx(Text, { dimColor: true, children: footerMessage.text }))] })) : prStatus ? (_jsxs(Text, { children: [_jsxs(Text, { dimColor: true, children: [footerLeft, " \u00B7 "] }), _jsx(Text, { dimColor: true, children: prStatus })] })) : turnDuration ? (_jsxs(Text, { children: [_jsxs(Text, { dimColor: true, children: [footerLeft, " \u00B7 "] }), _jsxs(Text, { dimColor: true, children: ["Cooked for ", turnDuration] })] })) : display.effort ? (_jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: footerLeft }), _jsx(Text, { dimColor: true, children: " \u00B7 " }), _jsxs(Text, { color: palette.accent, children: ["\u25CF ", display.effort] }), showEditorHint ? (_jsxs(Text, { dimColor: true, children: [' ', "\u00B7 ", editorMode === 'vim' ? 'vim' : '/effort'] })) : null] })) : (_jsx(Text, { dimColor: true, children: footerLeft })) }) }))] }));
 }
 export function DialogFrame({ title, children, screenReader, }) {
     const palette = useTuiPalette();

package/dist/cli/tui/composer-key-router.d.ts

@@ -0,0 +1,31 @@
+import { type ComposerEditorState } from './composer-editor.js';
+/**
+ * Projection of an ink useInput key event that the pure composer router
+ * consumes. It deliberately omits terminal/resolution concerns so the
+ * router can never submit, exit, or resolve a modal.
+ */
+export interface ComposerKeyProjection {
+    value: string;
+    left: boolean;
+    right: boolean;
+    backspace: boolean;
+    delete: boolean;
+    ctrl: boolean;
+    meta: boolean;
+    escape: boolean;
+}
+export type ComposerKeyTransition = {
+    kind: 'edit';
+    editor: ComposerEditorState;
+} | {
+    kind: 'cancel';
+} | {
+    kind: 'noop';
+};
+/**
+ * Pure normal-composer key transition router. Recognized editing input maps
+ * onto the existing composer-editor/composer-images primitives; Escape maps to
+ * a cancel result without mutating state; everything else is a noop.
+ */
+export declare function routeComposerKey(editor: ComposerEditorState, key: ComposerKeyProjection): ComposerKeyTransition;
+//# sourceMappingURL=composer-key-router.d.ts.map

package/dist/cli/tui/composer-key-router.js

@@ -0,0 +1,68 @@
+import { createComposerEditor, deleteComposerToEnd, deleteComposerToStart, deleteComposerWordBackward, insertComposerText, moveComposerCursorByWord, } from './composer-editor.js';
+import { deleteComposerImageBackward, deleteComposerImageForward, moveComposerCursorAcrossImages, } from './composer-images.js';
+/**
+ * Pure normal-composer key transition router. Recognized editing input maps
+ * onto the existing composer-editor/composer-images primitives; Escape maps to
+ * a cancel result without mutating state; everything else is a noop.
+ */
+export function routeComposerKey(editor, key) {
+    const state = createComposerEditor(editor.text, editor.cursor);
+    const lower = key.value.toLowerCase();
+    const controlKey = (letter) => (key.ctrl && lower === letter) ||
+        key.value === String.fromCharCode(letter.charCodeAt(0) - 96);
+    const printable = key.value.length > 0 &&
+        [...key.value].every((character) => {
+            const codePoint = character.codePointAt(0) ?? 0;
+            return codePoint >= 32 && codePoint !== 127;
+        });
+    if (key.escape)
+        return { kind: 'cancel' };
+    if (key.left) {
+        return {
+            kind: 'edit',
+            editor: key.meta
+                ? moveComposerCursorByWord(state, 'backward')
+                : moveComposerCursorAcrossImages(state, -1),
+        };
+    }
+    if (key.right) {
+        return {
+            kind: 'edit',
+            editor: key.meta
+                ? moveComposerCursorByWord(state, 'forward')
+                : moveComposerCursorAcrossImages(state, 1),
+        };
+    }
+    if (controlKey('a')) {
+        return { kind: 'edit', editor: createComposerEditor(state.text, 0) };
+    }
+    if (controlKey('e')) {
+        return { kind: 'edit', editor: createComposerEditor(state.text) };
+    }
+    if (controlKey('b')) {
+        return { kind: 'edit', editor: moveComposerCursorAcrossImages(state, -1) };
+    }
+    if (controlKey('f')) {
+        return { kind: 'edit', editor: moveComposerCursorAcrossImages(state, 1) };
+    }
+    if (controlKey('w')) {
+        return { kind: 'edit', editor: deleteComposerWordBackward(state) };
+    }
+    if (controlKey('u')) {
+        return { kind: 'edit', editor: deleteComposerToStart(state) };
+    }
+    if (controlKey('k')) {
+        return { kind: 'edit', editor: deleteComposerToEnd(state) };
+    }
+    if (key.backspace) {
+        return { kind: 'edit', editor: deleteComposerImageBackward(state) };
+    }
+    if (key.delete) {
+        return { kind: 'edit', editor: deleteComposerImageForward(state) };
+    }
+    if (!key.ctrl && !key.meta && key.value && printable) {
+        return { kind: 'edit', editor: insertComposerText(state, key.value) };
+    }
+    return { kind: 'noop' };
+}
+//# sourceMappingURL=composer-key-router.js.map

package/dist/cli/tui/composer-layout.d.ts

@@ -0,0 +1,7 @@
+export interface ComposerLayout {
+    lineWidth: number;
+    footerWidth: number;
+    showEditorHint: boolean;
+}
+export declare function composerLayoutForWidth(width: number): ComposerLayout;
+//# sourceMappingURL=composer-layout.d.ts.map

package/dist/cli/tui/composer-layout.js

@@ -0,0 +1,13 @@
+const MIN_COMPOSER_WIDTH = 12;
+const MAX_COMPOSER_WIDTH = 100;
+export function composerLayoutForWidth(width) {
+    const usableWidth = Number.isFinite(width)
+        ? Math.min(Math.max(width, MIN_COMPOSER_WIDTH), MAX_COMPOSER_WIDTH)
+        : MIN_COMPOSER_WIDTH;
+    return {
+        lineWidth: usableWidth,
+        footerWidth: usableWidth,
+        showEditorHint: usableWidth >= MAX_COMPOSER_WIDTH,
+    };
+}
+//# sourceMappingURL=composer-layout.js.map

package/dist/cli/tui/fullscreen-renderer.d.ts

@@ -0,0 +1,14 @@
+import type { TuiRendererMode } from './tui-view-model.js';
+/** Stable terminal-frame policy for the fullscreen renderer. */
+export interface FullscreenInkRenderOptions {
+    incrementalRendering: boolean;
+    alternateScreen: boolean;
+}
+/**
+ * The Ink render options for an interactive session. Fullscreen uses a stable
+ * terminal-frame policy: incremental rendering is disabled (every frame is a
+ * full redraw that erases the previous viewport) while classic and screen-reader
+ * modes keep their current behavior.
+ */
+export declare function fullscreenInkRenderOptions(currentRenderer: TuiRendererMode, axScreenReader: boolean | undefined): FullscreenInkRenderOptions;
+//# sourceMappingURL=fullscreen-renderer.d.ts.map

package/dist/cli/tui/fullscreen-renderer.js

@@ -0,0 +1,13 @@
+/**
+ * The Ink render options for an interactive session. Fullscreen uses a stable
+ * terminal-frame policy: incremental rendering is disabled (every frame is a
+ * full redraw that erases the previous viewport) while classic and screen-reader
+ * modes keep their current behavior.
+ */
+export function fullscreenInkRenderOptions(currentRenderer, axScreenReader) {
+    return {
+        incrementalRendering: currentRenderer !== 'fullscreen' && !axScreenReader,
+        alternateScreen: currentRenderer === 'fullscreen',
+    };
+}
+//# sourceMappingURL=fullscreen-renderer.js.map

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

@@ -8,6 +8,10 @@
  * tail, and every published frame is the exact concatenation of every delta
  * received since the previous frame.
  *
+ * Pending deltas are buffered as chunks and concatenated exactly once per
+ * published frame, so appending a delta stores the delta alone (amortized
+ * O(1)) instead of re-concatenating the full accumulated string.
+ *
  * `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
@@ -71,6 +75,8 @@ export declare class StreamingFrameBuffer {
     dispose(): void;
     private scheduleFrame;
     private cancelScheduledFrame;
+    private isTextResetRedundant;
+    private isThinkingResetRedundant;
     private publishPending;
 }
 //# sourceMappingURL=streaming-frame-buffer.d.ts.map

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

@@ -8,6 +8,10 @@
  * tail, and every published frame is the exact concatenation of every delta
  * received since the previous frame.
  *
+ * Pending deltas are buffered as chunks and concatenated exactly once per
+ * published frame, so appending a delta stores the delta alone (amortized
+ * O(1)) instead of re-concatenating the full accumulated string.
+ *
  * `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
@@ -45,11 +49,15 @@ export class StreamingFrameBuffer {
     }
     /** Full effective text, including any deltas not yet published. */
     get text() {
-        return this.pendingText ?? this.committedText;
+        return this.pendingText === null
+            ? this.committedText
+            : this.pendingText.base + this.pendingText.chunks.join('');
     }
     /** Full effective thinking, including any deltas not yet published. */
     get thinking() {
-        return this.pendingThinking ?? this.committedThinking;
+        return this.pendingThinking === null
+            ? this.committedThinking
+            : this.pendingThinking.base + this.pendingThinking.chunks.join('');
     }
     get hasPending() {
         return this.pendingText !== null || this.pendingThinking !== null;
@@ -61,37 +69,38 @@ export class StreamingFrameBuffer {
     appendText(delta) {
         if (this.disposed)
             return;
-        this.pendingText = (this.pendingText ?? this.committedText) + delta;
+        if (this.pendingText === null) {
+            this.pendingText = { base: this.committedText, chunks: [] };
+        }
+        this.pendingText.chunks.push(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;
+        if (this.pendingThinking === null) {
+            this.pendingThinking = { base: this.committedThinking, chunks: [] };
+        }
+        this.pendingThinking.chunks.push(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 === '')) {
+        if (this.isTextResetRedundant())
             return;
-        }
-        this.pendingText = '';
+        this.pendingText = { base: '', chunks: [] };
         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 === '')) {
+        if (this.isThinkingResetRedundant())
             return;
-        }
-        this.pendingThinking = '';
+        this.pendingThinking = { base: '', chunks: [] };
         this.scheduleFrame();
     }
     /** Publish every pending delta immediately, canceling any scheduled frame. */
@@ -127,15 +136,29 @@ export class StreamingFrameBuffer {
             this.scheduled = false;
         }
     }
+    isTextResetRedundant() {
+        if (this.pendingText === null)
+            return this.committedText === '';
+        return (this.pendingText.base === '' && this.pendingText.chunks.join('') === '');
+    }
+    isThinkingResetRedundant() {
+        if (this.pendingThinking === null)
+            return this.committedThinking === '';
+        return (this.pendingThinking.base === '' &&
+            this.pendingThinking.chunks.join('') === '');
+    }
     publishPending() {
         if (this.disposed)
             return;
         if (this.pendingText === null && this.pendingThinking === null)
             return;
-        if (this.pendingText !== null)
-            this.committedText = this.pendingText;
+        if (this.pendingText !== null) {
+            this.committedText =
+                this.pendingText.base + this.pendingText.chunks.join('');
+        }
         if (this.pendingThinking !== null) {
-            this.committedThinking = this.pendingThinking;
+            this.committedThinking =
+                this.pendingThinking.base + this.pendingThinking.chunks.join('');
         }
         this.pendingText = null;
         this.pendingThinking = null;

package/dist/cli/tui/tool-permission.js

@@ -8,6 +8,7 @@ import { extractPermissionRules, permissionRuleValueToString, shellPermissionSug
 import { redactSensitiveText } from '../../platform/sensitive-data.js';
 import { resolveDataPlaneRoot, } from '../../persistence/data-plane.js';
 import { composerEditorSegments, } from './composer-editor.js';
+import { useTuiPalette } from './theme.js';
 function stringInput(call, name) {
     const value = call.input[name];
     return typeof value === 'string' ? value : undefined;
@@ -369,9 +370,10 @@ export function projectTuiToolPermission(call, cwd, sensitiveValues, decision, d
     });
 }
 export function ToolPermissionDialog({ model, selection, feedbackMode, feedback, ruleEditor, screenReader, }) {
-    return (_jsxs(Box, { flexDirection: "column", borderStyle: screenReader ? undefined : 'round', borderColor: "yellow", paddingX: screenReader ? 0 : 1, marginTop: 1, children: [_jsx(Text, { bold: true, children: model.title }), model.subtitle ? _jsx(Text, { dimColor: true, children: model.subtitle }) : null, _jsxs(Box, { flexDirection: "column", paddingX: 1, paddingY: 1, children: [model.detail.map((line, index) => {
+    const palette = useTuiPalette();
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: screenReader ? undefined : 'round', borderColor: palette.warning, paddingX: screenReader ? 0 : 1, marginTop: 1, children: [_jsx(Text, { bold: true, color: palette.warning, children: model.title }), model.subtitle ? _jsx(Text, { dimColor: true, children: model.subtitle }) : null, _jsxs(Box, { flexDirection: "column", paddingX: 1, paddingY: 1, children: [model.detail.map((line, index) => {
                         const content = `${line.prefix ? `${line.prefix} ` : ''}${line.text}`;
-                        return line.prefix ? (_jsx(Text, { color: line.prefix === '+' ? 'green' : 'red', children: content }, `${index}-${line.prefix}`)) : (_jsx(Text, { children: content }, `${index}-`));
+                        return line.prefix ? (_jsx(Text, { color: line.prefix === '+' ? palette.success : palette.error, children: content }, `${index}-${line.prefix}`)) : (_jsx(Text, { children: content }, `${index}-`));
                     }), model.description ? _jsx(Text, { dimColor: true, children: model.description }) : null] }), model.explanation ? _jsx(Text, { dimColor: true, children: model.explanation }) : null, _jsx(Text, { children: model.question }), model.options.map((option, index) => {
                 const selected = selection === index;
                 const editor = option.editableRule
@@ -381,7 +383,7 @@ export function ToolPermissionDialog({ model, selection, feedbackMode, feedback,
                     })
                     : null;
                 const segments = editor ? composerEditorSegments(editor) : null;
-                return (_jsxs(Text, { bold: selected, children: [selected ? (screenReader ? 'Selected: ' : '❯ ') : '  ', index + 1, ". ", option.label, segments ? (screenReader || !selected ? (`: ${editor?.text ?? ''}`) : (_jsxs(Text, { children: [": ", segments.before, _jsx(Text, { inverse: true, children: segments.current ?? ' ' }), segments.after] }))) : null] }, `${option.action}-${index}`));
+                return (_jsxs(Text, { bold: selected, ...(selected ? { color: palette.brand } : {}), children: [selected ? (screenReader ? 'Selected: ' : '❯ ') : '  ', index + 1, ". ", option.label, segments ? (screenReader || !selected ? (`: ${editor?.text ?? ''}`) : (_jsxs(Text, { children: [": ", segments.before, _jsx(Text, { inverse: true, children: segments.current ?? ' ' }), segments.after] }))) : null] }, `${option.action}-${index}`));
             }), feedbackMode ? (_jsxs(Text, { children: ["\u203A", ' ', feedback ||
                         (model.options[selection]?.action === 'deny'
                             ? 'tell Praxis what to do differently'

package/dist/cli/tui/tui-view-model.d.ts

@@ -0,0 +1,46 @@
+import type { TranscriptItem } from './claude-style.js';
+export type TuiRendererMode = 'default' | 'fullscreen';
+/**
+ * Inputs for the pure TUI view projection. `history` is the live transcript
+ * that grows while the session runs; `initialHistory` is the transcript loaded
+ * before rendering and decides the resumed/fresh identity. `resume` is true
+ * only when the session was opened through a resume option.
+ */
+export interface TuiViewInput {
+    initialHistory: readonly TranscriptItem[];
+    history: readonly TranscriptItem[];
+    resume: boolean;
+    fixedViewport: boolean;
+    screenReader: boolean;
+    rows: number | undefined;
+    width: number;
+    scrollOffset: number;
+}
+export interface TuiViewModel {
+    projectedHistory: readonly TranscriptItem[];
+    resumed: boolean;
+    freshSession: boolean;
+    hasConversationHistory: boolean;
+}
+/**
+ * Pure, deterministic TUI projection. It classifies the session identity
+ * (fresh/resumed/started) and projects the rendered transcript exactly as the
+ * fullscreen renderer needs it, preserving TranscriptItem identity and order
+ * and the fullscreen suffix/window behavior. It never writes to transcripts or
+ * alters runtime events.
+ */
+export declare function projectTuiView(input: TuiViewInput): TuiViewModel;
+export interface TuiRendererInput {
+    configured: TuiRendererMode;
+    explicitlyConfigured: boolean;
+    interactiveTty: boolean;
+    screenReader: boolean;
+}
+/**
+ * Resolves the renderer for an interactive session. Fullscreen is the default
+ * for interactive TTY execution; classic remains the fallback for screen-reader
+ * and non-interactive paths, and an explicit renderer configuration is always
+ * honored over the default.
+ */
+export declare function resolveTuiRenderer(input: TuiRendererInput): TuiRendererMode;
+//# sourceMappingURL=tui-view-model.d.ts.map

package/dist/cli/tui/tui-view-model.js

@@ -0,0 +1,52 @@
+import { FULLSCREEN_TRANSCRIPT_RESERVED_ROWS, projectTranscriptTail, projectTranscriptWindow, } from './transcript-viewport.js';
+/**
+ * Pure, deterministic TUI projection. It classifies the session identity
+ * (fresh/resumed/started) and projects the rendered transcript exactly as the
+ * fullscreen renderer needs it, preserving TranscriptItem identity and order
+ * and the fullscreen suffix/window behavior. It never writes to transcripts or
+ * alters runtime events.
+ */
+export function projectTuiView(input) {
+    // Startup diagnostics are useful before the first prompt, but they are not
+    // conversation history and must not suppress the new-session welcome panel.
+    // Only real user/assistant transcript entries start a conversation; every
+    // other kind (thinking, context, tool, shell, notices, results, and so on)
+    // is operational bookkeeping that must not hide the fresh-session welcome.
+    const isRealConversation = (item) => item.kind === 'user' || item.kind === 'assistant';
+    // The original loaded transcript decides whether the session was resumed,
+    // separately from the live history that grows while the session runs.
+    const resumed = input.resume && input.initialHistory.some(isRealConversation);
+    const hasConversationHistory = input.history.some(isRealConversation);
+    // A session is resumed only when it was opened through `resume` and the
+    // original transcript already contained real conversation content. Supplying
+    // a session ID alone with an empty transcript keeps the session fresh, so the
+    // full welcome panel renders and the compact identity stays hidden until real
+    // conversation content appears.
+    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 = input.fixedViewport && !input.screenReader
+        ? input.scrollOffset > 0
+            ? projectTranscriptWindow(input.history, Math.max(1, (input.rows ?? 0) - FULLSCREEN_TRANSCRIPT_RESERVED_ROWS), input.width, input.scrollOffset)
+            : projectTranscriptTail(input.history, Math.max(1, (input.rows ?? 0) - FULLSCREEN_TRANSCRIPT_RESERVED_ROWS), input.width)
+        : input.history;
+    return { projectedHistory, resumed, freshSession, hasConversationHistory };
+}
+/**
+ * Resolves the renderer for an interactive session. Fullscreen is the default
+ * for interactive TTY execution; classic remains the fallback for screen-reader
+ * and non-interactive paths, and an explicit renderer configuration is always
+ * honored over the default.
+ */
+export function resolveTuiRenderer(input) {
+    if (input.screenReader)
+        return 'default';
+    if (!input.interactiveTty)
+        return 'default';
+    if (input.explicitlyConfigured)
+        return input.configured;
+    return 'fullscreen';
+}
+//# sourceMappingURL=tui-view-model.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "praxis-agent",
-  "version": "0.22.0",
+  "version": "0.23.1",
   "description": "Local-first, single-user general agent for the command line.",
   "license": "MIT",
   "author": "wuqisen",
@@ -44,6 +44,7 @@
     "test:docs": "node scripts/verify-docs.mjs",
     "test:compat": "npm run build && node scripts/verify-claude-compatibility.mjs && node scripts/verify-claude-advanced-fixtures.mjs",
     "test:compat:all": "npm run build && node scripts/verify-compatibility-matrix.mjs",
+    "test:tui:pty": "npm run build && node scripts/verify-fullscreen-rendering.mjs",
     "test:cli-surface-compat": "npm run build && node scripts/verify-cli-surface-parity.mjs",
     "test:cli-controls-compat": "npm run build && node scripts/verify-cli-controls.mjs",
     "test:conditional-compat": "npm run build && node scripts/verify-conditional-rules.mjs",