praxis-agent 0.35.0 → 0.37.0

package/dist/cli/tui/tui-interaction-router.d.ts

@@ -0,0 +1,78 @@
+import { type ComposerKeyProjection } from './composer-key-router.js';
+import type { ComposerEditorState } from './composer-editor.js';
+export type TuiScrollIntent = 'page-older' | 'page-newer' | 'half-page-older' | 'half-page-newer' | 'line-older' | 'line-newer' | 'none';
+export type TuiCancellationTarget = 'permission' | 'plan-approval' | 'question' | 'elicitation' | 'elicitation-url-waiting' | 'elicitation-options' | 'file-picker' | 'command-palette';
+export type TuiInteractionLayer = {
+    readonly kind: 'none';
+} | {
+    readonly kind: 'pending-prefix';
+} | {
+    readonly kind: 'cancelable';
+    readonly target: TuiCancellationTarget;
+} | {
+    readonly kind: 'delegated';
+    readonly target: 'session-picker' | 'menu';
+};
+export type TuiCallerIntent = 'none' | 'toggle-shortcuts' | 'open-agents' | 'implicit-newline';
+export interface TuiInteractionInput {
+    globalIntent: 'none' | 'exit' | 'suspend';
+    scrollIntent: TuiScrollIntent;
+    action: string | undefined;
+    composerKey: ComposerKeyProjection;
+    timestamp: number;
+    callerIntent: TuiCallerIntent;
+}
+export interface TuiInteractionSnapshot {
+    suspensionPending: boolean;
+    exitConfirmationArmed: boolean;
+    layer: TuiInteractionLayer;
+    busy: boolean;
+    viewport: {
+        enabled: boolean;
+        offset: number;
+        maxOffset: number;
+        pageRows: number;
+    };
+    composer: {
+        mode: 'readline' | 'vim-insert' | 'vim-normal';
+        editor: ComposerEditorState;
+        lastCancelAtMs: number;
+    };
+}
+export type TuiInteractionEffect = {
+    readonly kind: 'arm-exit-confirmation';
+} | {
+    readonly kind: 'dismiss-exit-confirmation';
+} | {
+    readonly kind: 'exit-application';
+} | {
+    readonly kind: 'request-process-suspension';
+} | {
+    readonly kind: 'cancel-tui-layer';
+    readonly target: TuiCancellationTarget;
+} | {
+    readonly kind: 'set-transcript-scroll-offset';
+    readonly offset: number;
+} | {
+    readonly kind: 'interrupt-turn';
+} | {
+    readonly kind: 'set-vim-insert-mode';
+    readonly insert: boolean;
+} | {
+    readonly kind: 'set-composer-editor';
+    readonly editor: ComposerEditorState;
+} | {
+    readonly kind: 'clear-composer';
+} | {
+    readonly kind: 'record-composer-cancel';
+    readonly timestamp: number;
+};
+export type TuiInteractionResult = {
+    readonly disposition: 'handled';
+    readonly effects: readonly TuiInteractionEffect[];
+} | {
+    readonly disposition: 'delegated';
+    readonly effects: readonly TuiInteractionEffect[];
+};
+export declare function routeTuiInteraction(snapshot: TuiInteractionSnapshot, input: TuiInteractionInput): TuiInteractionResult;
+//# sourceMappingURL=tui-interaction-router.d.ts.map

package/dist/cli/tui/tui-interaction-router.js

@@ -0,0 +1,127 @@
+import { routeComposerKey, } from './composer-key-router.js';
+const handled = (effects = []) => ({
+    disposition: 'handled',
+    effects,
+});
+const delegated = (effects = []) => ({
+    disposition: 'delegated',
+    effects,
+});
+function finiteNonNegativeInteger(value) {
+    return Number.isFinite(value) ? Math.max(0, Math.trunc(value)) : 0;
+}
+function isEscape(key) {
+    return key.escape || key.value === '\u001B';
+}
+function canUseCancelWindow(timestamp, previous) {
+    return Number.isFinite(timestamp) && Number.isFinite(previous);
+}
+export function routeTuiInteraction(snapshot, input) {
+    if (input.globalIntent === 'exit') {
+        return snapshot.exitConfirmationArmed
+            ? handled([{ kind: 'exit-application' }])
+            : handled([{ kind: 'clear-composer' }, { kind: 'arm-exit-confirmation' }]);
+    }
+    if (input.globalIntent === 'suspend') {
+        return snapshot.suspensionPending
+            ? handled()
+            : handled([{ kind: 'request-process-suspension' }]);
+    }
+    const confirmationEffects = snapshot.exitConfirmationArmed
+        ? [{ kind: 'dismiss-exit-confirmation' }]
+        : [];
+    if (snapshot.layer.kind === 'pending-prefix')
+        return handled(confirmationEffects);
+    if (snapshot.layer.kind === 'cancelable') {
+        if (isEscape(input.composerKey) || input.action === 'chat:cancel') {
+            return handled([
+                ...confirmationEffects,
+                { kind: 'cancel-tui-layer', target: snapshot.layer.target },
+            ]);
+        }
+        return delegated(confirmationEffects);
+    }
+    if (snapshot.layer.kind === 'delegated')
+        return delegated(confirmationEffects);
+    const viewport = snapshot.viewport;
+    if (viewport.enabled && input.scrollIntent !== 'none') {
+        const pageRows = finiteNonNegativeInteger(viewport.pageRows);
+        const offset = finiteNonNegativeInteger(viewport.offset);
+        const maxOffset = finiteNonNegativeInteger(viewport.maxOffset);
+        const halfPage = Math.max(1, Math.trunc(pageRows / 2));
+        const movement = input.scrollIntent === 'page-older' || input.scrollIntent === 'page-newer'
+            ? pageRows
+            : input.scrollIntent === 'half-page-older' ||
+                input.scrollIntent === 'half-page-newer'
+                ? halfPage
+                : 1;
+        const older = input.scrollIntent === 'page-older' ||
+            input.scrollIntent === 'half-page-older' ||
+            input.scrollIntent === 'line-older';
+        const nextOffset = Math.min(maxOffset, Math.max(0, offset + (older ? movement : -movement)));
+        return handled([
+            ...confirmationEffects,
+            { kind: 'set-transcript-scroll-offset', offset: nextOffset },
+        ]);
+    }
+    if (snapshot.busy) {
+        if (input.action === 'app:toggleTranscript' ||
+            input.action === 'task:background') {
+            return delegated(confirmationEffects);
+        }
+        if (input.action === 'chat:cancel')
+            return handled([...confirmationEffects, { kind: 'interrupt-turn' }]);
+        return handled(confirmationEffects);
+    }
+    if (input.callerIntent !== 'none')
+        return delegated(confirmationEffects);
+    if (snapshot.composer.mode === 'vim-normal') {
+        if (input.composerKey.value === 'i' || input.composerKey.value === 'a') {
+            return handled([
+                ...confirmationEffects,
+                { kind: 'set-vim-insert-mode', insert: true },
+            ]);
+        }
+        if (input.composerKey.left || input.composerKey.right) {
+            const transition = routeComposerKey(snapshot.composer.editor, input.composerKey);
+            if (transition.kind === 'edit')
+                return handled([
+                    ...confirmationEffects,
+                    { kind: 'set-composer-editor', editor: transition.editor },
+                ]);
+        }
+        return handled(confirmationEffects);
+    }
+    if (snapshot.composer.mode === 'vim-insert' && isEscape(input.composerKey)) {
+        return handled([
+            ...confirmationEffects,
+            { kind: 'set-vim-insert-mode', insert: false },
+        ]);
+    }
+    if (input.action === 'chat:cancel') {
+        const timestamp = input.timestamp;
+        const cancelDelta = timestamp - snapshot.composer.lastCancelAtMs;
+        const shouldClear = canUseCancelWindow(timestamp, snapshot.composer.lastCancelAtMs) &&
+            cancelDelta >= 0 &&
+            cancelDelta <= 500;
+        return handled([
+            ...confirmationEffects,
+            ...(shouldClear ? [{ kind: 'clear-composer' }] : []),
+            ...(Number.isFinite(timestamp)
+                ? [{ kind: 'record-composer-cancel', timestamp }]
+                : []),
+        ]);
+    }
+    if (input.action !== undefined)
+        return delegated(confirmationEffects);
+    const transition = routeComposerKey(snapshot.composer.editor, input.composerKey);
+    if (transition.kind === 'edit')
+        return handled([
+            ...confirmationEffects,
+            { kind: 'set-composer-editor', editor: transition.editor },
+        ]);
+    if (transition.kind === 'cancel')
+        return handled([...confirmationEffects, { kind: 'clear-composer' }]);
+    return delegated(confirmationEffects);
+}
+//# sourceMappingURL=tui-interaction-router.js.map

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

@@ -0,0 +1,114 @@
+import type { TranscriptItem } from './transcript-presentation.js';
+import { type TranscriptPresentationEntry } from './transcript-presentation.js';
+import { appendTuiHistory, createTuiHistoryChange, type TuiHistoryChange } from './transcript-window-model.js';
+import type { TuiPresentationEnvironment } from './presentation-environment.js';
+export { appendTuiHistory, createTuiHistoryChange };
+export type { TuiHistoryChange };
+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 {
+    readonly initialHistory: readonly TranscriptItem[];
+    readonly history: readonly TranscriptItem[];
+    readonly resume: boolean;
+    readonly fixedViewport: boolean;
+    readonly screenReader: boolean;
+    readonly rows: number | undefined;
+    readonly width: number;
+    readonly scrollOffset: number;
+    readonly detailedTranscript: boolean;
+    readonly historyChange?: TuiHistoryChange;
+}
+export interface TuiViewModel {
+    readonly transcriptEntries: readonly TranscriptPresentationEntry[];
+    readonly transcriptPageRows: number;
+    readonly maxTranscriptScrollOffset: number;
+    readonly resumed: boolean;
+    readonly freshSession: boolean;
+    readonly hasConversationHistory: boolean;
+}
+export declare function projectTuiView(input: TuiViewInput, previous?: TuiViewModel): TuiViewModel;
+export interface TuiScreenSurfaceModels {
+    readonly sessionPicker: unknown;
+    readonly priority: unknown;
+    readonly secondary: unknown;
+    readonly overlay: unknown;
+}
+export interface TuiScreenInput<Surfaces extends TuiScreenSurfaceModels = TuiScreenSurfaceModels> {
+    readonly presentation: TuiPresentationEnvironment;
+    readonly conversation: {
+        readonly initialHistory: readonly TranscriptItem[];
+        readonly history: readonly TranscriptItem[];
+        readonly historyChange?: TuiHistoryChange;
+        readonly resumeRequested: boolean;
+        readonly scrollOffset: number;
+        readonly detailed: boolean;
+        readonly activeText: string;
+        readonly activeThinking: string;
+    };
+    readonly sessionId: string | null;
+    readonly surfaces: {
+        readonly sessionPicker?: Surfaces['sessionPicker'];
+        readonly priority?: Surfaces['priority'];
+        readonly secondary?: Surfaces['secondary'];
+        readonly overlays: readonly Surfaces['overlay'][];
+    };
+}
+export interface TuiTranscriptScreenModel {
+    readonly entries: readonly TranscriptPresentationEntry[];
+    readonly pageRows: number;
+    readonly maxScrollOffset: number;
+    readonly scrollOffset: number;
+    readonly readingMode: 'normal' | 'audit' | 'screen-reader';
+    readonly active: {
+        readonly text: string;
+        readonly thinking: string;
+        readonly visible: boolean;
+    };
+}
+export type TuiScreenForeground<Surfaces extends TuiScreenSurfaceModels> = {
+    readonly kind: 'priority';
+    readonly surface: Surfaces['priority'];
+} | {
+    readonly kind: 'secondary';
+    readonly surface: Surfaces['secondary'];
+} | {
+    readonly kind: 'compose';
+    readonly overlays: readonly Surfaces['overlay'][];
+};
+export type TuiScreenBody<Surfaces extends TuiScreenSurfaceModels> = {
+    readonly kind: 'session-picker';
+    readonly surface: Surfaces['sessionPicker'];
+} | {
+    readonly kind: 'conversation';
+    readonly intro: 'welcome' | 'identity' | 'none';
+    readonly sessionLabel?: string;
+    readonly resumed: boolean;
+    readonly freshSession: boolean;
+    readonly hasConversationHistory: boolean;
+    readonly transcript: TuiTranscriptScreenModel;
+    readonly foreground: TuiScreenForeground<Surfaces>;
+};
+export interface TuiScreenModel<Surfaces extends TuiScreenSurfaceModels = TuiScreenSurfaceModels> {
+    readonly presentation: TuiPresentationEnvironment;
+    readonly body: TuiScreenBody<Surfaces>;
+}
+export declare function projectTuiScreen<Surfaces extends TuiScreenSurfaceModels>(input: TuiScreenInput<Surfaces>, previous?: TuiScreenModel<Surfaces>): TuiScreenModel<Surfaces>;
+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-screen-model.d.ts.map

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

@@ -0,0 +1,210 @@
+import { FULLSCREEN_TRANSCRIPT_RESERVED_ROWS } from './transcript-viewport.js';
+import { appendTuiHistory, createTuiHistoryChange, projectTranscriptWindow, } from './transcript-window-model.js';
+export { appendTuiHistory, createTuiHistoryChange };
+/**
+ * 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.
+ */
+const transcriptState = Symbol('transcript-window-state');
+const classificationState = Symbol('tui-classification-state');
+const selectionState = Symbol('tui-selection-state');
+export function projectTuiView(input, previous) {
+    // 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';
+    const priorState = previous?.[transcriptState];
+    const priorClassification = previous?.[classificationState];
+    // 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 mode = input.screenReader
+        ? 'screen-reader'
+        : input.detailedTranscript
+            ? 'audit'
+            : 'normal';
+    const transcriptPageRows = Math.max(2, (input.rows ?? 0) - FULLSCREEN_TRANSCRIPT_RESERVED_ROWS);
+    const retained = projectTranscriptWindow({
+        history: input.history,
+        mode,
+        width: input.width,
+        pageRows: transcriptPageRows,
+        scrollOffset: input.scrollOffset,
+        revision: input.historyChange?.revision ?? 0,
+        bounded: input.fixedViewport && !input.screenReader,
+    }, priorState, input.historyChange);
+    const classificationCompatible = previous !== undefined &&
+        priorClassification !== undefined &&
+        priorState !== undefined &&
+        priorClassification.history === priorState.history &&
+        priorClassification.revision === priorState.revision &&
+        priorClassification.initialHistory === input.initialHistory &&
+        priorClassification.resume === input.resume;
+    const sameClassification = classificationCompatible && retained.transition === 'same';
+    const appendedClassification = classificationCompatible && retained.transition === 'append';
+    // The original loaded transcript decides whether the session was resumed,
+    // separately from the live history that grows while the session runs.
+    const resumed = sameClassification || appendedClassification
+        ? priorClassification.resumed
+        : input.resume && input.initialHistory.some(isRealConversation);
+    const hasConversationHistory = sameClassification
+        ? priorClassification.hasConversationHistory
+        : appendedClassification
+            ? priorClassification.hasConversationHistory ||
+                input.history.slice(priorState.history.length).some(isRealConversation)
+            : 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;
+    const fullEntries = retained.allEntries;
+    const maxTranscriptScrollOffset = retained.maxOffset;
+    const projectedEntries = input.fixedViewport && !input.screenReader ? retained.entries : fullEntries;
+    const priorSelection = previous?.[selectionState];
+    const transcriptEntries = priorSelection &&
+        priorSelection.offset === input.scrollOffset &&
+        priorSelection.width === input.width &&
+        priorSelection.mode === mode &&
+        priorSelection.fixedViewport === input.fixedViewport &&
+        priorSelection.screenReader === input.screenReader &&
+        priorSelection.pageRows === transcriptPageRows &&
+        priorState === retained.state
+        ? priorSelection.entries
+        : projectedEntries;
+    const result = {
+        transcriptEntries,
+        transcriptPageRows,
+        maxTranscriptScrollOffset,
+        resumed,
+        freshSession,
+        hasConversationHistory,
+    };
+    Object.defineProperty(result, transcriptState, {
+        value: retained.state,
+        enumerable: false,
+    });
+    Object.defineProperty(result, classificationState, {
+        value: {
+            initialHistory: input.initialHistory,
+            resume: input.resume,
+            history: input.history,
+            revision: retained.state.revision,
+            resumed,
+            hasConversationHistory,
+        },
+        enumerable: false,
+    });
+    Object.defineProperty(result, selectionState, {
+        value: {
+            offset: input.scrollOffset,
+            width: input.width,
+            mode,
+            fixedViewport: input.fixedViewport,
+            screenReader: input.screenReader,
+            pageRows: transcriptPageRows,
+            entries: transcriptEntries,
+        },
+        enumerable: false,
+    });
+    return result;
+}
+const screenViewState = Symbol('tui-screen-view-state');
+export function projectTuiScreen(input, previous) {
+    const conversation = input.conversation;
+    const priorView = previous?.[screenViewState];
+    const view = projectTuiView({
+        initialHistory: conversation.initialHistory,
+        history: conversation.history,
+        resume: conversation.resumeRequested,
+        fixedViewport: input.presentation.fixedViewport,
+        screenReader: input.presentation.screenReader,
+        rows: input.presentation.viewport.rows,
+        width: input.presentation.viewport.columns,
+        scrollOffset: conversation.scrollOffset,
+        detailedTranscript: conversation.detailed,
+        ...(conversation.historyChange === undefined
+            ? {}
+            : { historyChange: conversation.historyChange }),
+    }, priorView);
+    const readingMode = input.presentation.screenReader
+        ? 'screen-reader'
+        : conversation.detailed
+            ? 'audit'
+            : 'normal';
+    const scrollOffset = Math.min(Math.max(0, conversation.scrollOffset), view.maxTranscriptScrollOffset);
+    const transcript = {
+        entries: view.transcriptEntries,
+        pageRows: view.transcriptPageRows,
+        maxScrollOffset: view.maxTranscriptScrollOffset,
+        scrollOffset,
+        readingMode,
+        active: {
+            text: conversation.activeText,
+            thinking: conversation.activeThinking,
+            visible: scrollOffset === 0,
+        },
+    };
+    let body;
+    if (input.surfaces.sessionPicker !== undefined) {
+        body = { kind: 'session-picker', surface: input.surfaces.sessionPicker };
+    }
+    else {
+        const intro = input.presentation.screenReader
+            ? 'none'
+            : view.freshSession
+                ? 'welcome'
+                : !view.resumed && view.hasConversationHistory
+                    ? 'identity'
+                    : 'none';
+        const foreground = input.surfaces.priority !== undefined
+            ? { kind: 'priority', surface: input.surfaces.priority }
+            : input.surfaces.secondary !== undefined
+                ? { kind: 'secondary', surface: input.surfaces.secondary }
+                : { kind: 'compose', overlays: input.surfaces.overlays };
+        body = {
+            kind: 'conversation',
+            intro,
+            ...(input.sessionId === null
+                ? {}
+                : { sessionLabel: input.sessionId.slice(0, 8) }),
+            resumed: view.resumed,
+            freshSession: view.freshSession,
+            hasConversationHistory: view.hasConversationHistory,
+            transcript,
+            foreground,
+        };
+    }
+    const result = {
+        presentation: input.presentation,
+        body,
+    };
+    Object.defineProperty(result, screenViewState, {
+        value: view,
+        enumerable: false,
+    });
+    return result;
+}
+/**
+ * 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-screen-model.js.map

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

@@ -1,50 +1,3 @@
-import type { TranscriptItem } from './transcript-presentation.js';
-import { type TranscriptPresentationEntry } from './transcript-presentation.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;
-    detailedTranscript: boolean;
-}
-export interface TuiViewModel {
-    transcriptEntries: readonly TranscriptPresentationEntry[];
-    transcriptPageRows: number;
-    maxTranscriptScrollOffset: number;
-    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;
+export { appendTuiHistory, createTuiHistoryChange, projectTuiView, resolveTuiRenderer, } from './tui-screen-model.js';
+export type { TuiHistoryChange, TuiRendererInput, TuiRendererMode, TuiViewInput, TuiViewModel, } from './tui-screen-model.js';
 //# sourceMappingURL=tui-view-model.d.ts.map

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

@@ -1,69 +1,2 @@
-import { projectTranscriptPresentation, } from './transcript-presentation.js';
-import { FULLSCREEN_TRANSCRIPT_RESERVED_ROWS, projectTranscriptPresentationTail, projectTranscriptPresentationWindow, transcriptPresentationLineCount, } 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 mode = input.screenReader
-        ? 'screen-reader'
-        : input.detailedTranscript
-            ? 'audit'
-            : 'normal';
-    const fullEntries = projectTranscriptPresentation(input.history, mode);
-    const transcriptPageRows = Math.max(2, (input.rows ?? 0) - FULLSCREEN_TRANSCRIPT_RESERVED_ROWS);
-    const maxTranscriptScrollOffset = Math.max(0, transcriptPresentationLineCount(fullEntries, input.width, mode) -
-        transcriptPageRows);
-    const transcriptEntries = input.fixedViewport && !input.screenReader
-        ? input.scrollOffset > 0
-            ? projectTranscriptPresentationWindow(fullEntries, transcriptPageRows, input.width, input.scrollOffset, mode)
-            : projectTranscriptPresentationTail(fullEntries, transcriptPageRows, input.width, mode)
-        : fullEntries;
-    return {
-        transcriptEntries,
-        transcriptPageRows,
-        maxTranscriptScrollOffset,
-        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';
-}
+export { appendTuiHistory, createTuiHistoryChange, projectTuiView, resolveTuiRenderer, } from './tui-screen-model.js';
 //# sourceMappingURL=tui-view-model.js.map