@murphai/murph 0.1.1

package/dist/assistant/ui/ink.js

@@ -0,0 +1,2417 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import tty from 'node:tty';
+import { pathToFileURL } from 'node:url';
+import * as React from 'react';
+import { Box, Static, Text, render, useApp, useInput, useStdout, } from 'ink';
+import { assistantChatResultSchema, } from '@murphai/assistant-core/assistant-cli-contracts';
+import { discoverAssistantProviderModels, resolveAssistantCatalogReasoningOptions, resolveAssistantModelCatalog, } from '../provider-catalog.js';
+import { resolveCodexDisplayOptions } from '@murphai/assistant-core/assistant-codex';
+import { buildAssistantProviderDefaultsPatch, resolveAssistantOperatorDefaults, resolveAssistantProviderDefaults, saveAssistantOperatorDefaultsPatch, } from '@murphai/assistant-core/operator-config';
+import { openAssistantConversation, sendAssistantMessage, updateAssistantSessionOptions, } from '../service.js';
+import { extractRecoveredAssistantSession, isAssistantProviderConnectionLostError, isAssistantProviderInterruptedError, } from '@murphai/assistant-core/assistant-provider';
+import { appendAssistantTranscriptEntries, isAssistantSessionNotFoundError, listAssistantTranscriptEntries, redactAssistantDisplayPath, } from '../store.js';
+import { normalizeNullableString } from '@murphai/assistant-core/assistant-runtime';
+import { redactAssistantSessionForDisplay } from '@murphai/assistant-core/assistant-runtime';
+import { CHAT_COMPOSER_HINT, CHAT_SLASH_COMMANDS, CHAT_STARTER_SUGGESTIONS, applyProviderProgressEventToEntries, finalizePendingInkChatTraces, findAssistantModelOptionIndex, findAssistantReasoningOptionIndex, formatSessionBinding, applyInkChatTraceUpdates, getMatchingSlashCommands, resolveChatMetadataBadges, resolveChatSubmitAction, shouldShowChatComposerGuidance, shouldClearComposerForSubmitAction, seedChatEntries, } from './view-model.js';
+import { LIGHT_ASSISTANT_INK_THEME, captureAssistantInkThemeBaseline, resolveAssistantInkThemeForOpenChat, } from './theme.js';
+const AssistantInkThemeContext = React.createContext(LIGHT_ASSISTANT_INK_THEME);
+const StaticTranscript = Static;
+const COMPOSER_WORD_SEPARATORS = "`~!@#$%^&*()-=+[{]}\\\\|;:'\\\",.<>/?";
+const MODIFIED_RETURN_SEQUENCE = /^\u001b?\[27;(\d+);13~$/u;
+const RAW_ARROW_SEQUENCE = /^\u001b?(?:\[(?:(\d+;)?(\d+))?([ABCD])|O([ABCD]))$/u;
+const QUEUED_FOLLOW_UP_SHORTCUT_HINT = '⌥ + ↑ edit last queued message';
+const MAX_QUEUED_FOLLOW_UP_PREVIEW_LENGTH = 88;
+const ASSISTANT_INK_THEME_REFRESH_INTERVAL_MS = 2_000;
+function useAssistantInkTheme() {
+    return React.useContext(AssistantInkThemeContext);
+}
+const BUSY_INDICATOR_CHARACTER = '•';
+const ASSISTANT_CHAT_VIEW_PADDING_X = 1;
+const ASSISTANT_PLAIN_TEXT_WRAP_SLACK = 1;
+const ASSISTANT_INK_TTY_PATH = process.platform === 'win32' ? 'CONIN$' : '/dev/tty';
+export function resolveChromePanelBoxProps(props) {
+    const boxProps = {
+        flexDirection: 'column',
+        marginBottom: props.marginBottom ?? 1,
+        paddingX: props.paddingX ??
+            (typeof props.backgroundColor === 'string' && props.backgroundColor.length > 0
+                ? 1
+                : 0),
+        paddingY: props.paddingY ?? 0,
+        width: props.width ?? '100%',
+    };
+    if (typeof props.backgroundColor === 'string' && props.backgroundColor.length > 0) {
+        boxProps.backgroundColor = props.backgroundColor;
+    }
+    return boxProps;
+}
+export function supportsAssistantInkRawMode(stdin) {
+    return Boolean(stdin?.isTTY && typeof stdin.setRawMode === 'function');
+}
+export function resolveAssistantInkInputAdapter(input = {}) {
+    const stdin = input.stdin ?? process.stdin;
+    if (supportsAssistantInkRawMode(stdin)) {
+        return {
+            close: () => { },
+            source: 'stdin',
+            stdin,
+        };
+    }
+    const ttyPath = input.ttyPath ?? ASSISTANT_INK_TTY_PATH;
+    const openTtyFd = input.openTtyFd ??
+        ((pathToOpen, flags) => fs.openSync(pathToOpen, flags));
+    const createTtyReadStream = input.createTtyReadStream ??
+        ((fd) => new tty.ReadStream(fd));
+    let fd = null;
+    let closed = false;
+    const closeFallbackFd = () => {
+        if (fd === null || closed) {
+            return;
+        }
+        closed = true;
+        try {
+            fs.closeSync(fd);
+        }
+        catch { }
+    };
+    try {
+        fd = openTtyFd(ttyPath, 'r');
+        const ttyInput = createTtyReadStream(fd);
+        if (!supportsAssistantInkRawMode(ttyInput)) {
+            ttyInput.destroy?.();
+            closeFallbackFd();
+            return {
+                close: () => { },
+                source: 'unsupported',
+                stdin: null,
+            };
+        }
+        return {
+            close: () => {
+                ttyInput.destroy?.();
+                closeFallbackFd();
+            },
+            source: 'tty',
+            stdin: ttyInput,
+        };
+    }
+    catch {
+        closeFallbackFd();
+        return {
+            close: () => { },
+            source: 'unsupported',
+            stdin: null,
+        };
+    }
+}
+const ChromePanel = React.memo(function ChromePanel(props) {
+    const createElement = React.createElement;
+    return createElement(Box, resolveChromePanelBoxProps(props), props.children);
+});
+const BusySpinner = React.memo(function BusySpinner(input) {
+    const createElement = React.createElement;
+    const theme = useAssistantInkTheme();
+    return createElement(Text, {
+        color: input.color ?? theme.accentColor,
+    }, BUSY_INDICATOR_CHARACTER);
+});
+export function resolveMessageRoleLabel(kind) {
+    if (kind === 'error') {
+        return 'error';
+    }
+    return null;
+}
+const MessageRoleLabel = React.memo(function MessageRoleLabel(input) {
+    const createElement = React.createElement;
+    const theme = useAssistantInkTheme();
+    const label = resolveMessageRoleLabel(input.kind);
+    if (!label) {
+        return null;
+    }
+    return createElement(Box, {
+        marginBottom: 1,
+    }, createElement(Text, {
+        bold: true,
+        color: theme.errorColor,
+    }, label));
+});
+export function renderWrappedTextBlock(input) {
+    const createElement = React.createElement;
+    return createElement(Box, {
+        flexDirection: 'column',
+        width: '100%',
+    }, createElement(Text, {
+        color: input.color,
+        dimColor: input.dimColor,
+        wrap: 'wrap',
+    }, input.children));
+}
+export function wrapAssistantPlainText(input, columns) {
+    return input
+        .replaceAll('\r\n', '\n')
+        .split('\n')
+        .map((line) => wrapAssistantPlainTextLine(line, columns))
+        .join('\n');
+}
+function wrapAssistantPlainTextLine(input, columns) {
+    if (input.length === 0 || columns <= 0) {
+        return input;
+    }
+    const leadingWhitespace = input.match(/^\s*/u)?.[0] ?? '';
+    const content = input.slice(leadingWhitespace.length);
+    if (content.length === 0) {
+        return input;
+    }
+    const tokens = content.match(/\S+|\s+/gu) ?? [content];
+    const lines = [];
+    let currentLine = leadingWhitespace;
+    let currentWidth = leadingWhitespace.length;
+    let pendingWhitespace = '';
+    for (const token of tokens) {
+        if (/^\s+$/u.test(token)) {
+            pendingWhitespace += token;
+            continue;
+        }
+        const spacer = currentWidth > leadingWhitespace.length
+            ? pendingWhitespace.length > 0
+                ? pendingWhitespace
+                : ' '
+            : '';
+        const candidateWidth = currentWidth + spacer.length + token.length;
+        if (currentWidth > leadingWhitespace.length && candidateWidth > columns) {
+            lines.push(currentLine);
+            currentLine = `${leadingWhitespace}${token}`;
+            currentWidth = leadingWhitespace.length + token.length;
+            pendingWhitespace = '';
+            continue;
+        }
+        if (spacer.length > 0) {
+            currentLine += spacer;
+            currentWidth += spacer.length;
+        }
+        currentLine += token;
+        currentWidth += token.length;
+        pendingWhitespace = '';
+    }
+    lines.push(currentLine);
+    return lines.join('\n');
+}
+function resolveAssistantTerminalColumns(columns) {
+    return typeof columns === 'number' && Number.isFinite(columns)
+        ? Math.max(1, Math.floor(columns))
+        : 80;
+}
+export function resolveAssistantChatViewportWidth(columns) {
+    return Math.max(1, resolveAssistantTerminalColumns(columns) - ASSISTANT_CHAT_VIEW_PADDING_X * 2);
+}
+export function resolveAssistantPlainTextWrapColumns(columns) {
+    return Math.max(1, resolveAssistantChatViewportWidth(columns) - ASSISTANT_PLAIN_TEXT_WRAP_SLACK);
+}
+const WrappedTextBlock = React.memo(function WrappedTextBlock(input) {
+    return renderWrappedTextBlock(input);
+});
+export function renderWrappedPlainTextBlock(input) {
+    const createElement = React.createElement;
+    const lines = wrapAssistantPlainText(input.text, input.columns).split('\n');
+    return createElement(Box, {
+        flexDirection: 'column',
+        width: '100%',
+    }, ...lines.map((line, index) => createElement(Text, {
+        color: input.color,
+        dimColor: input.dimColor,
+        key: `wrapped-plain-text:${index}`,
+    }, line.length > 0 ? line : ' ')));
+}
+export function resolveAssistantTurnErrorPresentation(input) {
+    const errorText = input.error instanceof Error ? input.error.message : String(input.error);
+    const connectionLost = isAssistantProviderConnectionLostError(input.error);
+    const missingSession = isAssistantSessionNotFoundError(input.error);
+    const queuedFollowUpSuffix = input.restoredQueuedPromptCount > 0
+        ? ' Queued follow-ups are back in the composer.'
+        : '';
+    return {
+        entry: {
+            kind: 'error',
+            text: errorText,
+        },
+        persistTranscriptError: !missingSession,
+        status: connectionLost
+            ? {
+                kind: 'error',
+                text: `The assistant lost its provider connection. Restore connectivity, then keep chatting to resume.${queuedFollowUpSuffix}`,
+            }
+            : missingSession
+                ? {
+                    kind: 'error',
+                    text: `The local assistant session record is missing. Check the current vault/default vault or start a new chat.${queuedFollowUpSuffix}`,
+                }
+                : {
+                    kind: 'error',
+                    text: `The assistant hit an error. Fix it or keep chatting.${queuedFollowUpSuffix}`,
+                },
+    };
+}
+const WrappedPlainTextBlock = React.memo(function WrappedPlainTextBlock(input) {
+    return renderWrappedPlainTextBlock(input);
+});
+const FooterBadge = React.memo(function FooterBadge(input) {
+    const createElement = React.createElement;
+    const theme = useAssistantInkTheme();
+    const backgroundColor = input.badge.key === 'model' ? theme.accentColor : theme.footerBadgeBackground;
+    const color = input.badge.key === 'model'
+        ? theme.composerCursorTextColor
+        : input.badge.key === 'vault'
+            ? theme.mutedColor
+            : theme.footerBadgeTextColor;
+    return createElement(Text, {
+        backgroundColor,
+        color,
+    }, formatFooterBadgeText(input.badge));
+});
+export function formatFooterBadgeText(badge) {
+    if (badge.key === 'model' || badge.key === 'reasoning') {
+        return ` ${badge.value} `;
+    }
+    return ` ${badge.label}: ${badge.value} `;
+}
+export function splitAssistantMarkdownLinks(input) {
+    const segments = [];
+    const markdownLinkPattern = /\[([^\]\n]+)\]\(([^)\s]+)\)/gu;
+    let lastIndex = 0;
+    for (const match of input.matchAll(markdownLinkPattern)) {
+        const matchedText = match[0];
+        const label = match[1];
+        const target = match[2];
+        const start = match.index ?? -1;
+        if (typeof matchedText !== 'string' ||
+            typeof label !== 'string' ||
+            typeof target !== 'string' ||
+            start < 0) {
+            continue;
+        }
+        if (start > lastIndex) {
+            segments.push({
+                kind: 'text',
+                text: input.slice(lastIndex, start),
+            });
+        }
+        segments.push({
+            kind: 'link',
+            label,
+            target,
+        });
+        lastIndex = start + matchedText.length;
+    }
+    if (lastIndex < input.length) {
+        segments.push({
+            kind: 'text',
+            text: input.slice(lastIndex),
+        });
+    }
+    return segments.length > 0
+        ? segments
+        : [
+            {
+                kind: 'text',
+                text: input,
+            },
+        ];
+}
+export function resolveAssistantHyperlinkTarget(target) {
+    if (/^(https?|mailto):/iu.test(target)) {
+        return target;
+    }
+    const fragmentIndex = target.indexOf('#');
+    const pathPart = fragmentIndex >= 0
+        ? target.slice(0, fragmentIndex)
+        : target;
+    const fragment = fragmentIndex >= 0
+        ? target.slice(fragmentIndex)
+        : '';
+    if (!path.isAbsolute(pathPart)) {
+        return null;
+    }
+    return `${pathToFileURL(pathPart).href}${fragment}`;
+}
+export function formatAssistantTerminalHyperlink(label, target) {
+    return `\u001B]8;;${target}\u0007${label}\u001B]8;;\u0007`;
+}
+export function supportsAssistantTerminalHyperlinks(input = {}) {
+    const env = input.env ?? process.env;
+    const isTTY = input.isTTY ?? process.stderr.isTTY ?? false;
+    if (!isTTY || env.CI === 'true') {
+        return false;
+    }
+    if (env.FORCE_HYPERLINK === '1') {
+        return true;
+    }
+    return Boolean(env.KITTY_WINDOW_ID ||
+        env.ITERM_SESSION_ID ||
+        env.WT_SESSION ||
+        env.WEZTERM_PANE ||
+        env.VSCODE_INJECTION ||
+        env.TERM_PROGRAM === 'Apple_Terminal' ||
+        env.TERM_PROGRAM === 'WarpTerminal' ||
+        env.TERM_PROGRAM === 'vscode');
+}
+export function renderAssistantMessageText(input) {
+    const createElement = React.createElement;
+    const theme = useAssistantInkTheme();
+    const { stdout } = useStdout();
+    const enableHyperlinks = supportsAssistantTerminalHyperlinks();
+    const segments = splitAssistantMarkdownLinks(input.text);
+    const plainTextOnly = segments.every((segment) => segment.kind === 'text');
+    if (plainTextOnly) {
+        return createElement(WrappedTextBlock, {}, wrapAssistantPlainText(input.text, resolveAssistantPlainTextWrapColumns(stdout?.columns)));
+    }
+    return createElement(WrappedTextBlock, {}, ...segments.map((segment, index) => {
+        if (segment.kind === 'text') {
+            return segment.text;
+        }
+        const hyperlinkTarget = resolveAssistantHyperlinkTarget(segment.target);
+        const displayedLabel = hyperlinkTarget && enableHyperlinks
+            ? formatAssistantTerminalHyperlink(segment.label, hyperlinkTarget)
+            : segment.label;
+        return createElement(Text, {
+            color: theme.accentColor,
+            key: `link:${index}:${segment.label}`,
+            underline: true,
+        }, displayedLabel);
+    }));
+}
+function resolveComposerModifiedReturnAction(input, key) {
+    const match = MODIFIED_RETURN_SEQUENCE.exec(input);
+    if (!match) {
+        return null;
+    }
+    const modifier = Math.max(0, Number.parseInt(match[1] ?? '1', 10) - 1);
+    const shift = key.shift || (modifier & 1) === 1;
+    if (!shift) {
+        return {
+            kind: 'submit',
+            mode: 'enter',
+        };
+    }
+    return {
+        kind: 'edit',
+        input: '\n',
+        key: {
+            ...key,
+            return: false,
+            shift: true,
+        },
+    };
+}
+export function normalizeAssistantInkArrowKey(input, key) {
+    if (key.upArrow || key.downArrow || key.leftArrow || key.rightArrow) {
+        return key;
+    }
+    const match = RAW_ARROW_SEQUENCE.exec(input);
+    const direction = match?.[3] ?? match?.[4];
+    if (!direction) {
+        return key;
+    }
+    const modifier = Math.max(0, Number.parseInt(match?.[2] ?? '1', 10) - 1);
+    return {
+        ...key,
+        ctrl: key.ctrl || (modifier & 4) === 4,
+        downArrow: direction === 'B',
+        leftArrow: direction === 'D',
+        meta: key.meta || (modifier & 2) === 2,
+        rightArrow: direction === 'C',
+        shift: key.shift || (modifier & 1) === 1,
+        upArrow: direction === 'A',
+    };
+}
+export function mergeComposerDraftWithQueuedPrompts(draft, queuedPrompts) {
+    return [draft, ...queuedPrompts]
+        .filter((value) => value.trim().length > 0)
+        .join('\n\n');
+}
+export function resolveComposerTerminalAction(input, key) {
+    const normalizedKey = normalizeAssistantInkArrowKey(input, key);
+    const modifiedReturnAction = resolveComposerModifiedReturnAction(input, normalizedKey);
+    if (modifiedReturnAction) {
+        return modifiedReturnAction;
+    }
+    if ((input === '\u007f' || input === '\b') &&
+        !normalizedKey.ctrl &&
+        !normalizedKey.meta &&
+        !normalizedKey.shift &&
+        !normalizedKey.super &&
+        !normalizedKey.hyper) {
+        return {
+            kind: 'edit',
+            input: '',
+            key: {
+                ...normalizedKey,
+                backspace: true,
+                delete: false,
+            },
+        };
+    }
+    if (normalizedKey.meta && normalizedKey.upArrow) {
+        return {
+            kind: 'edit-last-queued',
+        };
+    }
+    if (normalizedKey.tab && !normalizedKey.shift) {
+        return {
+            kind: 'submit',
+            mode: 'tab',
+        };
+    }
+    if (normalizedKey.return) {
+        if (!normalizedKey.shift) {
+            return {
+                kind: 'submit',
+                mode: 'enter',
+            };
+        }
+        return {
+            kind: 'edit',
+            input: '\n',
+            key: {
+                ...normalizedKey,
+                return: false,
+            },
+        };
+    }
+    if (normalizedKey.delete) {
+        // Many terminals report the primary delete/backspace key as `delete`.
+        // Preserve an actual forward-delete path via Ctrl+D inside the editor helpers.
+        return {
+            kind: 'edit',
+            input,
+            key: {
+                ...normalizedKey,
+                backspace: true,
+                delete: false,
+            },
+        };
+    }
+    return {
+        kind: 'edit',
+        input,
+        key: normalizedKey,
+    };
+}
+export function formatQueuedFollowUpPreview(prompt) {
+    const normalized = prompt.trim().replace(/\s+/gu, ' ');
+    if (normalized.length <= MAX_QUEUED_FOLLOW_UP_PREVIEW_LENGTH) {
+        return normalized;
+    }
+    const truncated = normalized
+        .slice(0, MAX_QUEUED_FOLLOW_UP_PREVIEW_LENGTH - 1)
+        .trimEnd();
+    const boundary = truncated.lastIndexOf(' ');
+    const preview = boundary >= Math.floor(MAX_QUEUED_FOLLOW_UP_PREVIEW_LENGTH / 2)
+        ? truncated.slice(0, boundary).trimEnd()
+        : truncated;
+    return `${preview}…`;
+}
+function ComposerInput(props) {
+    const createElement = React.createElement;
+    const theme = useAssistantInkTheme();
+    const [displayValue, setDisplayValue] = React.useState(props.value);
+    const [cursorOffset, setCursorOffset] = React.useState(props.value.length);
+    const valueRef = React.useRef(props.value);
+    const cursorOffsetRef = React.useRef(props.value.length);
+    const killBufferRef = React.useRef('');
+    const preferredColumnRef = React.useRef(null);
+    const lastPropValueRef = React.useRef(props.value);
+    // Keep a queue of locally emitted draft values so older controlled echoes
+    // cannot clobber a newer in-flight paste or mid-buffer edit.
+    const pendingControlledValuesRef = React.useRef([]);
+    const onChangeRef = React.useRef(props.onChange);
+    const onEditLastQueuedPromptRef = React.useRef(props.onEditLastQueuedPrompt);
+    const onSubmitRef = React.useRef(props.onSubmit);
+    const disabledRef = React.useRef(props.disabled);
+    onChangeRef.current = props.onChange;
+    onEditLastQueuedPromptRef.current = props.onEditLastQueuedPrompt;
+    onSubmitRef.current = props.onSubmit;
+    disabledRef.current = props.disabled;
+    React.useLayoutEffect(() => {
+        const syncResult = reconcileComposerControlledValue({
+            cursorOffset: cursorOffsetRef.current,
+            currentValue: valueRef.current,
+            nextControlledValue: props.value,
+            pendingValues: pendingControlledValuesRef.current,
+            previousControlledValue: lastPropValueRef.current,
+        });
+        lastPropValueRef.current = props.value;
+        pendingControlledValuesRef.current = syncResult.pendingValues;
+        valueRef.current = syncResult.nextValue;
+        setDisplayValue((previous) => previous === syncResult.nextValue ? previous : syncResult.nextValue);
+        if (syncResult.cursorOffset !== cursorOffsetRef.current) {
+            cursorOffsetRef.current = syncResult.cursorOffset;
+            setCursorOffset(syncResult.cursorOffset);
+        }
+    }, [props.value]);
+    const handleComposerInput = React.useCallback((input, key) => {
+        if (disabledRef.current) {
+            return;
+        }
+        if ((key.shift && key.tab) || (key.ctrl && input === 'c')) {
+            return;
+        }
+        const currentValue = valueRef.current;
+        const currentCursorOffset = cursorOffsetRef.current;
+        const action = resolveComposerTerminalAction(input, key);
+        if (action.kind === 'edit-last-queued') {
+            onEditLastQueuedPromptRef.current();
+            return;
+        }
+        if (action.kind === 'edit' &&
+            (action.key.upArrow || action.key.downArrow)) {
+            const verticalMovement = resolveComposerVerticalCursorMove({
+                cursorOffset: currentCursorOffset,
+                direction: action.key.upArrow ? 'up' : 'down',
+                preferredColumn: preferredColumnRef.current,
+                value: currentValue,
+            });
+            if (verticalMovement.cursorOffset !== currentCursorOffset) {
+                cursorOffsetRef.current = verticalMovement.cursorOffset;
+                preferredColumnRef.current = verticalMovement.preferredColumn;
+                setCursorOffset(verticalMovement.cursorOffset);
+            }
+            return;
+        }
+        if (action.kind === 'submit') {
+            if (onSubmitRef.current(currentValue, action.mode) === 'clear') {
+                valueRef.current = '';
+                pendingControlledValuesRef.current = enqueuePendingComposerValue(pendingControlledValuesRef.current, '');
+                cursorOffsetRef.current = 0;
+                killBufferRef.current = '';
+                preferredColumnRef.current = null;
+                setDisplayValue('');
+                setCursorOffset(0);
+                onChangeRef.current('');
+            }
+            return;
+        }
+        if (action.kind !== 'edit') {
+            return;
+        }
+        const editingResult = applyComposerEditingInput({
+            cursorOffset: currentCursorOffset,
+            killBuffer: killBufferRef.current,
+            value: currentValue,
+        }, action.input, action.key);
+        if (!editingResult.handled) {
+            return;
+        }
+        cursorOffsetRef.current = editingResult.cursorOffset;
+        killBufferRef.current = editingResult.killBuffer;
+        valueRef.current = editingResult.value;
+        preferredColumnRef.current = null;
+        if (editingResult.cursorOffset !== currentCursorOffset) {
+            setCursorOffset(editingResult.cursorOffset);
+        }
+        if (editingResult.value !== currentValue) {
+            pendingControlledValuesRef.current = enqueuePendingComposerValue(pendingControlledValuesRef.current, editingResult.value);
+            setDisplayValue(editingResult.value);
+            onChangeRef.current(editingResult.value);
+        }
+    }, []);
+    useInput(handleComposerInput, {
+        isActive: !props.disabled,
+    });
+    return createElement(Box, {
+        flexDirection: 'column',
+        flexGrow: 1,
+        flexShrink: 1,
+    }, renderComposerValue({
+        cursorOffset,
+        disabled: props.disabled,
+        placeholder: props.placeholder,
+        theme,
+        value: displayValue,
+    }));
+}
+const ChatHeader = React.memo(function ChatHeader(props) {
+    const createElement = React.createElement;
+    const theme = useAssistantInkTheme();
+    const terminalColumns = process.stderr.columns ?? 80;
+    const terminalRows = process.stderr.rows ?? 24;
+    const compactHeader = terminalColumns < 72 || terminalRows < 18;
+    if (compactHeader) {
+        return createElement(ChromePanel, {
+            backgroundColor: theme.switcherBackground,
+            marginBottom: 1,
+        }, createElement(Text, {
+            wrap: 'wrap',
+        }, createElement(Text, { color: theme.accentColor }, '●'), ' ', createElement(Text, { bold: true }, 'Murph')), props.bindingSummary
+            ? createElement(Text, {
+                color: theme.mutedColor,
+                wrap: 'wrap',
+            }, props.bindingSummary)
+            : null);
+    }
+    return createElement(Box, {
+        flexDirection: 'column',
+        marginBottom: 1,
+        width: '100%',
+    }, createElement(ChromePanel, {
+        backgroundColor: theme.switcherBackground,
+        marginBottom: 1,
+    }, createElement(Text, {
+        wrap: 'wrap',
+    }, createElement(Text, { color: theme.accentColor }, '●'), ' ', createElement(Text, { bold: true }, 'Murph'), ' ', createElement(Text, { color: theme.mutedColor }, 'interactive chat'))), createElement(ChromePanel, {
+        backgroundColor: theme.switcherBackground,
+        marginBottom: 0,
+    }, createElement(Text, {
+        color: theme.mutedColor,
+        wrap: 'wrap',
+    }, createElement(Text, { color: theme.accentColor }, '↳'), ` ${props.bindingSummary ?? 'local transcript-backed session'}`)));
+});
+const ChatEntryRow = React.memo(function ChatEntryRow(props) {
+    const createElement = React.createElement;
+    const theme = useAssistantInkTheme();
+    const { stdout } = useStdout();
+    const rowWidth = resolveAssistantChatViewportWidth(stdout?.columns);
+    if (props.entry.kind === 'assistant') {
+        return createElement(ChromePanel, {
+            marginBottom: 1,
+            width: rowWidth,
+        }, createElement(AssistantMessageText, { text: props.entry.text }));
+    }
+    if (props.entry.kind === 'error') {
+        return createElement(ChromePanel, {
+            backgroundColor: theme.switcherBackground,
+            marginBottom: 1,
+            width: rowWidth,
+        }, createElement(MessageRoleLabel, {
+            kind: 'error',
+        }), createElement(WrappedTextBlock, {
+            color: theme.errorColor,
+        }, props.entry.text));
+    }
+    if (props.entry.kind === 'trace') {
+        return createElement(Box, {
+            marginBottom: 1,
+            paddingLeft: 2,
+            width: rowWidth,
+        }, createElement(WrappedPlainTextBlock, {
+            columns: Math.max(1, rowWidth - 2),
+            dimColor: true,
+            text: `${props.entry.pending ? '· ' : '  '}${props.entry.text}`,
+        }));
+    }
+    if (props.entry.kind === 'thinking' || props.entry.kind === 'status') {
+        return createElement(Box, {
+            marginBottom: 1,
+            width: rowWidth,
+        }, createElement(Box, {
+            flexDirection: 'row',
+            width: rowWidth,
+        }, createElement(Text, { dimColor: true }, props.entry.kind === 'thinking' ? '· ' : '↻ '), createElement(Box, {
+            flexDirection: 'column',
+            flexGrow: 1,
+            flexShrink: 1,
+        }, createElement(WrappedTextBlock, {
+            dimColor: true,
+        }, props.entry.text))));
+    }
+    return createElement(ChromePanel, {
+        backgroundColor: theme.composerBackground,
+        marginBottom: 1,
+        paddingY: 1,
+        width: rowWidth,
+    }, createElement(Box, {
+        flexDirection: 'row',
+        width: '100%',
+    }, createElement(Text, {
+        color: theme.composerTextColor,
+    }, '› '), createElement(Box, {
+        flexDirection: 'column',
+        flexGrow: 1,
+        flexShrink: 1,
+    }, createElement(Text, {
+        color: theme.composerTextColor,
+        wrap: 'wrap',
+    }, props.entry.text))));
+});
+const AssistantMessageText = React.memo(function AssistantMessageText(props) {
+    return renderAssistantMessageText(props);
+});
+export function renderChatTranscriptFeed(input) {
+    const createElement = React.createElement;
+    const { liveEntries, staticEntries } = partitionChatTranscriptEntries({
+        busy: input.busy,
+        entries: input.entries,
+    });
+    const staticRows = [
+        {
+            kind: 'header',
+            bindingSummary: input.bindingSummary,
+            sessionId: input.sessionId,
+        },
+        ...staticEntries.map((entry) => ({
+            kind: 'entry',
+            entry,
+        })),
+    ];
+    return createElement(React.Fragment, {}, createElement(StaticTranscript, {
+        items: staticRows,
+        children: renderStaticTranscriptRow,
+    }), createElement(Box, {
+        flexDirection: 'column',
+        width: '100%',
+    }, ...liveEntries.map((entry, index) => createElement(ChatEntryRow, {
+        key: `live-entry:${staticEntries.length + index}`,
+        entry,
+    }))));
+}
+export function partitionChatTranscriptEntries(input) {
+    if (input.entries.length === 0) {
+        return {
+            liveEntries: [],
+            staticEntries: [],
+        };
+    }
+    if (!input.busy) {
+        return {
+            liveEntries: [],
+            staticEntries: [...input.entries],
+        };
+    }
+    let lastUserEntryIndex = -1;
+    for (let index = input.entries.length - 1; index >= 0; index -= 1) {
+        const entry = input.entries[index];
+        if (entry?.kind === 'user') {
+            lastUserEntryIndex = index;
+            break;
+        }
+    }
+    if (lastUserEntryIndex < 0) {
+        return {
+            liveEntries: [...input.entries],
+            staticEntries: [],
+        };
+    }
+    return {
+        liveEntries: input.entries.slice(lastUserEntryIndex + 1),
+        staticEntries: input.entries.slice(0, lastUserEntryIndex + 1),
+    };
+}
+export function shouldShowBusyStatus(input) {
+    if (!input.busy) {
+        return false;
+    }
+    let lastUserEntryIndex = -1;
+    for (let index = input.entries.length - 1; index >= 0; index -= 1) {
+        if (input.entries[index]?.kind === 'user') {
+            lastUserEntryIndex = index;
+            break;
+        }
+    }
+    if (lastUserEntryIndex < 0) {
+        return true;
+    }
+    for (let index = lastUserEntryIndex + 1; index < input.entries.length; index += 1) {
+        const entry = input.entries[index];
+        if (entry?.kind === 'assistant' && normalizeNullableString(entry.text)) {
+            return false;
+        }
+        if (entry?.kind === 'error' && normalizeNullableString(entry.text)) {
+            return false;
+        }
+    }
+    return true;
+}
+function renderStaticTranscriptRow(item, index) {
+    const createElement = React.createElement;
+    if (item.kind === 'header') {
+        return createElement(ChatHeader, {
+            key: `static-header:${item.sessionId}`,
+            bindingSummary: item.bindingSummary,
+        });
+    }
+    return createElement(ChatEntryRow, {
+        key: `static-entry:${index}`,
+        entry: item.entry,
+    });
+}
+const ChatTranscriptFeed = React.memo(function ChatTranscriptFeed(input) {
+    return renderChatTranscriptFeed(input);
+});
+const ChatStatus = React.memo(function ChatStatus(props) {
+    const createElement = React.createElement;
+    const theme = useAssistantInkTheme();
+    const { stdout } = useStdout();
+    const wrapColumns = resolveAssistantPlainTextWrapColumns(stdout?.columns);
+    if (props.busy) {
+        const busyColor = props.status?.kind === 'error'
+            ? theme.errorColor
+            : props.status?.kind === 'success'
+                ? theme.successColor
+                : theme.infoColor;
+        const busyDetail = normalizeNullableString(props.status?.text);
+        const busyLabel = 'Working';
+        return createElement(ChromePanel, {
+            marginBottom: 1,
+        }, createElement(Box, {
+            flexDirection: 'row',
+            width: '100%',
+        }, createElement(BusySpinner, {
+            color: busyColor,
+        }), createElement(Text, {}, ' '), createElement(Box, {
+            flexDirection: 'column',
+            flexGrow: 1,
+            flexShrink: 1,
+        }, createElement(Text, {
+            color: busyColor,
+        }, busyLabel), busyDetail
+            ? createElement(WrappedPlainTextBlock, {
+                color: theme.mutedColor,
+                columns: wrapColumns,
+                text: busyDetail,
+            })
+            : null)));
+    }
+    if (!props.status) {
+        return null;
+    }
+    const statusColor = props.status.kind === 'error'
+        ? theme.errorColor
+        : props.status.kind === 'success'
+            ? theme.successColor
+            : theme.infoColor;
+    const statusIcon = props.status.kind === 'error'
+        ? '!'
+        : props.status.kind === 'success'
+            ? '✓'
+            : 'ℹ';
+    return createElement(ChromePanel, {
+        backgroundColor: theme.switcherBackground,
+        marginBottom: 1,
+    }, createElement(Box, {
+        flexDirection: 'row',
+        width: '100%',
+    }, createElement(Text, { color: statusColor }, `${statusIcon} `), createElement(Box, {
+        flexDirection: 'column',
+        flexGrow: 1,
+        flexShrink: 1,
+    }, createElement(WrappedPlainTextBlock, {
+        color: props.status.kind === 'info'
+            ? theme.composerTextColor
+            : statusColor,
+        columns: Math.max(1, wrapColumns - 2),
+        text: props.status.text,
+    }))));
+});
+const ChatComposer = React.memo(function ChatComposer(props) {
+    const createElement = React.createElement;
+    const theme = useAssistantInkTheme();
+    const { stdout } = useStdout();
+    const slashSuggestions = props.modelSwitcherActive
+        ? []
+        : getMatchingSlashCommands(props.value);
+    const showComposerGuidance = shouldShowChatComposerGuidance(props.entryCount);
+    const showStarterSuggestions = showComposerGuidance &&
+        !props.modelSwitcherActive &&
+        props.value.trim().length === 0;
+    const wrapColumns = resolveAssistantPlainTextWrapColumns(stdout?.columns);
+    return createElement(React.Fragment, {}, createElement(ChromePanel, {
+        backgroundColor: theme.composerBackground,
+        marginBottom: slashSuggestions.length > 0 ? 0 : 1,
+        paddingY: 1,
+    }, createElement(Box, {
+        flexDirection: 'row',
+        width: '100%',
+    }, createElement(Text, { color: theme.composerTextColor }, '› '), createElement(ComposerInput, {
+        disabled: props.modelSwitcherActive,
+        value: props.value,
+        placeholder: 'Type a message',
+        onChange: props.onChange,
+        onEditLastQueuedPrompt: props.onEditLastQueuedPrompt,
+        onSubmit: props.onSubmit,
+    })), showComposerGuidance
+        ? createElement(Box, {
+            marginTop: 1,
+        }, createElement(Text, {
+            color: theme.mutedColor,
+            wrap: 'wrap',
+        }, CHAT_COMPOSER_HINT))
+        : null, showStarterSuggestions
+        ? createElement(Box, {
+            marginTop: 1,
+            width: '100%',
+        }, createElement(Text, { color: theme.mutedColor }, 'try:'), createElement(WrappedPlainTextBlock, {
+            color: theme.accentColor,
+            columns: Math.max(1, wrapColumns - 2),
+            text: `  ${CHAT_STARTER_SUGGESTIONS.join(' · ')}`,
+        }))
+        : null), createElement(SlashCommandSuggestions, {
+        commands: slashSuggestions,
+    }));
+});
+const QueuedFollowUpStatus = React.memo(function QueuedFollowUpStatus(props) {
+    const createElement = React.createElement;
+    const theme = useAssistantInkTheme();
+    const { stdout } = useStdout();
+    if (props.queuedPromptCount === 0 || !props.latestPrompt) {
+        return null;
+    }
+    const extraQueuedCount = props.queuedPromptCount - 1;
+    const wrapColumns = resolveAssistantPlainTextWrapColumns(stdout?.columns);
+    return createElement(Box, {
+        flexDirection: 'column',
+        marginBottom: 1,
+        width: '100%',
+    }, createElement(Text, {
+        color: theme.composerTextColor,
+        wrap: 'wrap',
+    }, '• Queued follow-up messages'), createElement(WrappedPlainTextBlock, {
+        color: theme.composerTextColor,
+        columns: wrapColumns,
+        text: `  ↳ ${formatQueuedFollowUpPreview(props.latestPrompt)}`,
+    }), extraQueuedCount > 0
+        ? createElement(WrappedPlainTextBlock, {
+            color: theme.mutedColor,
+            columns: wrapColumns,
+            text: `    +${extraQueuedCount} more queued`,
+        })
+        : null, createElement(WrappedPlainTextBlock, {
+        color: theme.mutedColor,
+        columns: wrapColumns,
+        text: `    ${QUEUED_FOLLOW_UP_SHORTCUT_HINT}`,
+    }));
+});
+const ChatFooter = React.memo(function ChatFooter(props) {
+    const createElement = React.createElement;
+    return createElement(Box, {
+        flexDirection: 'column',
+        width: '100%',
+    }, createElement(Text, {
+        wrap: 'wrap',
+    }, ...props.badges.flatMap((badge, index) => [
+        index > 0 ? ' ' : '',
+        createElement(FooterBadge, {
+            badge,
+            key: `badge:${badge.key}`,
+        }),
+    ])));
+});
+function enqueuePendingComposerValue(pendingValues, nextValue) {
+    return pendingValues[pendingValues.length - 1] === nextValue
+        ? [...pendingValues]
+        : [...pendingValues, nextValue];
+}
+export function reconcileComposerControlledValue(input) {
+    // Controlled updates that match a queued local value are only acknowledgements
+    // from the parent state, so keep the newest local draft visible until the last
+    // pending value is observed. Anything else is an external restore/reset and
+    // should replace the live draft immediately.
+    const nextControlledValue = input.nextControlledValue;
+    const currentValue = input.currentValue;
+    const clampedCursorOffset = clampComposerCursorOffset(input.cursorOffset, currentValue.length);
+    if (nextControlledValue === input.previousControlledValue) {
+        return {
+            cursorOffset: clampedCursorOffset,
+            nextValue: currentValue,
+            pendingValues: [...input.pendingValues],
+        };
+    }
+    const matchedPendingIndex = input.pendingValues.indexOf(nextControlledValue);
+    if (matchedPendingIndex >= 0) {
+        const remainingPendingValues = input.pendingValues.slice(matchedPendingIndex + 1);
+        const nextValue = remainingPendingValues.length === 0 ? nextControlledValue : currentValue;
+        return {
+            cursorOffset: clampComposerCursorOffset(clampedCursorOffset, nextValue.length),
+            nextValue,
+            pendingValues: remainingPendingValues,
+        };
+    }
+    return {
+        cursorOffset: nextControlledValue.length,
+        nextValue: nextControlledValue,
+        pendingValues: [],
+    };
+}
+function clampComposerCursorOffset(offset, valueLength) {
+    return Math.max(0, Math.min(offset, valueLength));
+}
+function isComposerWordSeparator(character) {
+    return COMPOSER_WORD_SEPARATORS.includes(character);
+}
+function isComposerWhitespace(character) {
+    return /\s/u.test(character);
+}
+function moveComposerCursorLeft(state) {
+    return {
+        ...state,
+        cursorOffset: clampComposerCursorOffset(state.cursorOffset - 1, state.value.length),
+    };
+}
+function moveComposerCursorRight(state) {
+    return {
+        ...state,
+        cursorOffset: clampComposerCursorOffset(state.cursorOffset + 1, state.value.length),
+    };
+}
+function moveComposerCursorToStart(state) {
+    return {
+        ...state,
+        cursorOffset: 0,
+    };
+}
+function moveComposerCursorToEnd(state) {
+    return {
+        ...state,
+        cursorOffset: state.value.length,
+    };
+}
+function resolveComposerLineRanges(value) {
+    const ranges = [];
+    let lineStart = 0;
+    for (let index = 0; index < value.length; index += 1) {
+        if (value[index] !== '\n') {
+            continue;
+        }
+        ranges.push({
+            end: index,
+            start: lineStart,
+        });
+        lineStart = index + 1;
+    }
+    ranges.push({
+        end: value.length,
+        start: lineStart,
+    });
+    return ranges;
+}
+function resolveComposerCursorLocation(value, cursorOffset) {
+    const clampedCursorOffset = clampComposerCursorOffset(cursorOffset, value.length);
+    let lineIndex = 0;
+    let lineStart = 0;
+    for (let index = 0; index < clampedCursorOffset; index += 1) {
+        if (value[index] !== '\n') {
+            continue;
+        }
+        lineIndex += 1;
+        lineStart = index + 1;
+    }
+    return {
+        column: clampedCursorOffset - lineStart,
+        lineIndex,
+    };
+}
+export function resolveComposerVerticalCursorMove(input) {
+    const clampedCursorOffset = clampComposerCursorOffset(input.cursorOffset, input.value.length);
+    const lineRanges = resolveComposerLineRanges(input.value);
+    const currentLocation = resolveComposerCursorLocation(input.value, clampedCursorOffset);
+    const targetLineIndex = input.direction === 'up'
+        ? currentLocation.lineIndex - 1
+        : currentLocation.lineIndex + 1;
+    if (targetLineIndex < 0 || targetLineIndex >= lineRanges.length) {
+        return {
+            cursorOffset: clampedCursorOffset,
+            preferredColumn: input.preferredColumn,
+        };
+    }
+    const desiredColumn = input.preferredColumn ?? currentLocation.column;
+    const targetLine = lineRanges[targetLineIndex];
+    if (!targetLine) {
+        return {
+            cursorOffset: clampedCursorOffset,
+            preferredColumn: input.preferredColumn,
+        };
+    }
+    return {
+        cursorOffset: targetLine.start + Math.min(desiredColumn, targetLine.end - targetLine.start),
+        preferredColumn: desiredColumn,
+    };
+}
+function findComposerPreviousWordStart(value, cursorOffset) {
+    let index = clampComposerCursorOffset(cursorOffset, value.length);
+    while (index > 0) {
+        const previousCharacter = value.slice(index - 1, index);
+        if (!isComposerWhitespace(previousCharacter)) {
+            break;
+        }
+        index -= 1;
+    }
+    if (index === 0) {
+        return 0;
+    }
+    const previousCharacter = value.slice(index - 1, index);
+    const separator = isComposerWordSeparator(previousCharacter);
+    while (index > 0) {
+        const character = value.slice(index - 1, index);
+        if (isComposerWhitespace(character) ||
+            isComposerWordSeparator(character) !== separator) {
+            break;
+        }
+        index -= 1;
+    }
+    return index;
+}
+function findComposerNextWordEnd(value, cursorOffset) {
+    let index = clampComposerCursorOffset(cursorOffset, value.length);
+    while (index < value.length) {
+        const character = value.slice(index, index + 1);
+        if (!isComposerWhitespace(character)) {
+            break;
+        }
+        index += 1;
+    }
+    if (index >= value.length) {
+        return value.length;
+    }
+    const separator = isComposerWordSeparator(value.slice(index, index + 1));
+    while (index < value.length) {
+        const character = value.slice(index, index + 1);
+        if (isComposerWhitespace(character) ||
+            isComposerWordSeparator(character) !== separator) {
+            break;
+        }
+        index += 1;
+    }
+    return index;
+}
+function moveComposerCursorToPreviousWord(state) {
+    return {
+        ...state,
+        cursorOffset: findComposerPreviousWordStart(state.value, state.cursorOffset),
+    };
+}
+function moveComposerCursorToNextWord(state) {
+    return {
+        ...state,
+        cursorOffset: findComposerNextWordEnd(state.value, state.cursorOffset),
+    };
+}
+function replaceComposerRange(state, range, replacement) {
+    const nextValue = state.value.slice(0, range.start) + replacement + state.value.slice(range.end);
+    return {
+        ...state,
+        cursorOffset: range.start + replacement.length,
+        value: nextValue,
+    };
+}
+function killComposerRange(state, range) {
+    if (range.end <= range.start) {
+        return state;
+    }
+    return {
+        ...replaceComposerRange(state, range, ''),
+        killBuffer: state.value.slice(range.start, range.end),
+    };
+}
+function deleteComposerBackward(state) {
+    if (state.cursorOffset <= 0) {
+        return state;
+    }
+    return replaceComposerRange(state, {
+        end: state.cursorOffset,
+        start: state.cursorOffset - 1,
+    }, '');
+}
+function deleteComposerForward(state) {
+    if (state.cursorOffset >= state.value.length) {
+        return state;
+    }
+    return replaceComposerRange(state, {
+        end: state.cursorOffset + 1,
+        start: state.cursorOffset,
+    }, '');
+}
+function deleteComposerBackwardWord(state) {
+    return killComposerRange(state, {
+        end: state.cursorOffset,
+        start: findComposerPreviousWordStart(state.value, state.cursorOffset),
+    });
+}
+function deleteComposerForwardWord(state) {
+    return killComposerRange(state, {
+        end: findComposerNextWordEnd(state.value, state.cursorOffset),
+        start: state.cursorOffset,
+    });
+}
+function killComposerToStart(state) {
+    return killComposerRange(state, {
+        end: state.cursorOffset,
+        start: 0,
+    });
+}
+function killComposerToEnd(state) {
+    return killComposerRange(state, {
+        end: state.value.length,
+        start: state.cursorOffset,
+    });
+}
+function yankComposerKillBuffer(state) {
+    if (state.killBuffer.length === 0) {
+        return state;
+    }
+    return replaceComposerRange(state, {
+        end: state.cursorOffset,
+        start: state.cursorOffset,
+    }, state.killBuffer);
+}
+function finalizeComposerEditingResult(next) {
+    return {
+        ...next,
+        handled: true,
+    };
+}
+export function applyComposerEditingInput(state, input, key) {
+    const currentState = {
+        ...state,
+        cursorOffset: clampComposerCursorOffset(state.cursorOffset, state.value.length),
+    };
+    if (key.home || (key.super && key.leftArrow)) {
+        return finalizeComposerEditingResult(moveComposerCursorToStart(currentState));
+    }
+    if (key.end || (key.super && key.rightArrow)) {
+        return finalizeComposerEditingResult(moveComposerCursorToEnd(currentState));
+    }
+    if (key.leftArrow) {
+        return finalizeComposerEditingResult(key.meta || key.ctrl
+            ? moveComposerCursorToPreviousWord(currentState)
+            : moveComposerCursorLeft(currentState));
+    }
+    if (key.rightArrow) {
+        return finalizeComposerEditingResult(key.meta || key.ctrl
+            ? moveComposerCursorToNextWord(currentState)
+            : moveComposerCursorRight(currentState));
+    }
+    if (key.backspace) {
+        return finalizeComposerEditingResult(key.super
+            ? killComposerToStart(currentState)
+            : key.meta
+                ? deleteComposerBackwardWord(currentState)
+                : deleteComposerBackward(currentState));
+    }
+    if (key.delete) {
+        return finalizeComposerEditingResult(key.super
+            ? killComposerToEnd(currentState)
+            : key.meta
+                ? deleteComposerForwardWord(currentState)
+                : deleteComposerForward(currentState));
+    }
+    if (key.ctrl) {
+        switch (input) {
+            case 'a':
+                return finalizeComposerEditingResult(moveComposerCursorToStart(currentState));
+            case 'b':
+                return finalizeComposerEditingResult(moveComposerCursorLeft(currentState));
+            case 'd':
+                return finalizeComposerEditingResult(deleteComposerForward(currentState));
+            case 'e':
+                return finalizeComposerEditingResult(moveComposerCursorToEnd(currentState));
+            case 'f':
+                return finalizeComposerEditingResult(moveComposerCursorRight(currentState));
+            case 'h':
+                return finalizeComposerEditingResult(deleteComposerBackward(currentState));
+            case 'k':
+                return finalizeComposerEditingResult(killComposerToEnd(currentState));
+            case 'u':
+                return finalizeComposerEditingResult(killComposerToStart(currentState));
+            case 'w':
+                return finalizeComposerEditingResult(deleteComposerBackwardWord(currentState));
+            case 'y':
+                return finalizeComposerEditingResult(yankComposerKillBuffer(currentState));
+            default:
+                break;
+        }
+    }
+    if (key.meta) {
+        switch (input) {
+            case 'b':
+                return finalizeComposerEditingResult(moveComposerCursorToPreviousWord(currentState));
+            case 'd':
+                return finalizeComposerEditingResult(deleteComposerForwardWord(currentState));
+            case 'f':
+                return finalizeComposerEditingResult(moveComposerCursorToNextWord(currentState));
+            default:
+                break;
+        }
+    }
+    if (input.length === 0) {
+        return {
+            ...currentState,
+            handled: false,
+        };
+    }
+    const insertionText = normalizeComposerInsertedText(input);
+    if (insertionText.length === 0) {
+        return {
+            ...currentState,
+            handled: false,
+        };
+    }
+    return finalizeComposerEditingResult(replaceComposerRange(currentState, {
+        end: currentState.cursorOffset,
+        start: currentState.cursorOffset,
+    }, insertionText));
+}
+export function normalizeComposerInsertedText(input) {
+    return input.replace(/\r\n?/gu, '\n');
+}
+function resolveComposerCursorDisplay(input) {
+    const cursorOffset = clampComposerCursorOffset(input.cursorOffset, input.value.length);
+    const beforeCursor = input.value.slice(0, cursorOffset);
+    const rawCursorCharacter = input.value.slice(cursorOffset, cursorOffset + 1);
+    const afterCursor = cursorOffset < input.value.length
+        ? input.value.slice(cursorOffset + 1)
+        : '';
+    if (rawCursorCharacter === '\n') {
+        return {
+            afterCursor: `\n${input.value.slice(cursorOffset + 1)}`,
+            beforeCursor,
+            cursorCharacter: ' ',
+        };
+    }
+    if (rawCursorCharacter.length === 0) {
+        return {
+            afterCursor: '',
+            beforeCursor,
+            cursorCharacter: ' ',
+        };
+    }
+    return {
+        afterCursor,
+        beforeCursor,
+        cursorCharacter: rawCursorCharacter,
+    };
+}
+export function renderComposerValue(input) {
+    const createElement = React.createElement;
+    if (input.value.length === 0) {
+        if (input.disabled) {
+            return createElement(Text, {
+                color: input.theme.composerPlaceholderColor,
+                wrap: 'wrap',
+            }, input.placeholder);
+        }
+        const cursorCharacter = input.placeholder.slice(0, 1) || ' ';
+        const remainder = input.placeholder.slice(1);
+        return createElement(Text, {
+            color: input.theme.composerPlaceholderColor,
+            wrap: 'wrap',
+        }, createElement(Text, {
+            backgroundColor: input.theme.composerCursorBackground,
+            color: input.theme.composerCursorTextColor,
+        }, cursorCharacter), remainder);
+    }
+    const cursorDisplay = resolveComposerCursorDisplay({
+        cursorOffset: input.cursorOffset,
+        value: input.value,
+    });
+    if (input.disabled) {
+        return createElement(Text, {
+            color: input.theme.composerTextColor,
+            wrap: 'wrap',
+        }, input.value);
+    }
+    return createElement(Text, {
+        color: input.theme.composerTextColor,
+        wrap: 'wrap',
+    }, cursorDisplay.beforeCursor, createElement(Text, {
+        backgroundColor: input.theme.composerCursorBackground,
+        color: input.theme.composerCursorTextColor,
+    }, cursorDisplay.cursorCharacter), cursorDisplay.afterCursor);
+}
+function ModelSwitcher(props) {
+    const createElement = React.createElement;
+    const theme = useAssistantInkTheme();
+    const onCancelRef = React.useRef(props.onCancel);
+    const onConfirmRef = React.useRef(props.onConfirm);
+    const onMoveRef = React.useRef(props.onMove);
+    onCancelRef.current = props.onCancel;
+    onConfirmRef.current = props.onConfirm;
+    onMoveRef.current = props.onMove;
+    const handleModelSwitcherInput = React.useCallback((input, key) => {
+        const normalizedKey = normalizeAssistantInkArrowKey(input, key);
+        if (normalizedKey.escape) {
+            onCancelRef.current();
+            return;
+        }
+        if (normalizedKey.upArrow || input === 'k') {
+            onMoveRef.current(-1);
+            return;
+        }
+        if (normalizedKey.downArrow || input === 'j') {
+            onMoveRef.current(1);
+            return;
+        }
+        if (normalizedKey.return) {
+            onConfirmRef.current();
+        }
+    }, []);
+    useInput(handleModelSwitcherInput);
+    const selectedModelLabel = props.modelOptions[props.modelIndex]?.value ??
+        props.currentModel ??
+        'the current model';
+    const canChooseReasoning = props.reasoningOptions.length > 0;
+    const title = props.mode === 'model'
+        ? 'Choose a model'
+        : `Choose reasoning for ${selectedModelLabel}`;
+    const subtitle = props.mode === 'model'
+        ? canChooseReasoning
+            ? 'Step 1 of 2. Enter continues to reasoning depth.'
+            : 'Enter confirms the active model.'
+        : 'Step 2 of 2. Enter confirms the active reasoning depth.';
+    const helpText = props.mode === 'model'
+        ? canChooseReasoning
+            ? '↑/↓ move · Enter next · Esc close'
+            : '↑/↓ move · Enter confirm · Esc close'
+        : '↑/↓ move · Enter confirm · Esc back';
+    const options = props.mode === 'model'
+        ? props.modelOptions.map((option, index) => renderSwitcherRow({
+            current: normalizeNullableString(option.value) ===
+                normalizeNullableString(props.currentModel),
+            description: option.description,
+            index,
+            label: option.value,
+            selected: index === props.modelIndex,
+            theme,
+        }))
+        : props.reasoningOptions.map((option, index) => renderSwitcherRow({
+            current: isCurrentReasoningOption(option.value, props.currentReasoningEffort),
+            description: option.description,
+            index,
+            label: option.value === 'medium'
+                ? `${option.label} (default)`
+                : option.label,
+            selected: index === props.reasoningIndex,
+            theme,
+        }));
+    return createElement(ChromePanel, {
+        backgroundColor: theme.switcherBackground,
+        marginBottom: 1,
+    }, createElement(Box, {
+        flexDirection: 'column',
+    }, createElement(Text, {
+        bold: true,
+        color: theme.switcherTextColor,
+    }, title), createElement(Text, {
+        color: theme.switcherMutedColor,
+    }, subtitle), createElement(Box, {
+        height: 1,
+    }), ...options, createElement(Box, {
+        height: 1,
+    }), createElement(Text, {
+        color: theme.switcherMutedColor,
+    }, helpText)));
+}
+function SlashCommandSuggestions(input) {
+    const theme = useAssistantInkTheme();
+    const { stdout } = useStdout();
+    if (input.commands.length === 0) {
+        return null;
+    }
+    const createElement = React.createElement;
+    const wrapColumns = resolveAssistantPlainTextWrapColumns(stdout?.columns);
+    return createElement(ChromePanel, {
+        backgroundColor: theme.switcherBackground,
+        marginBottom: 1,
+    }, createElement(Text, {
+        bold: true,
+        color: theme.mutedColor,
+    }, 'commands'), ...input.commands.map((command) => createElement(Box, {
+        flexDirection: 'row',
+        key: command.command,
+        width: '100%',
+    }, createElement(Text, { color: theme.accentColor }, command.command), createElement(Box, {
+        flexDirection: 'column',
+        flexGrow: 1,
+        flexShrink: 1,
+    }, createElement(WrappedPlainTextBlock, {
+        color: theme.mutedColor,
+        columns: Math.max(1, wrapColumns - command.command.length - 2),
+        text: `  ${command.description}`,
+    })))));
+}
+function renderSwitcherRow(input) {
+    const createElement = React.createElement;
+    const textColor = input.selected
+        ? input.theme.switcherSelectionTextColor
+        : input.theme.switcherTextColor;
+    const descriptionColor = input.selected
+        ? input.theme.switcherSelectionTextColor
+        : input.theme.switcherMutedColor;
+    return createElement(Box, {
+        backgroundColor: input.selected
+            ? input.theme.switcherSelectionBackground
+            : undefined,
+        key: `${input.label}:${input.index}`,
+        flexDirection: 'column',
+        marginBottom: 1,
+        paddingX: 1,
+        width: '100%',
+    }, createElement(Text, {
+        color: textColor,
+    }, createElement(Text, { color: textColor }, input.selected ? '●' : '○'), ` ${input.index + 1}. ${input.label}`, input.current
+        ? createElement(Text, {
+            color: input.selected ? textColor : input.theme.accentColor,
+        }, ' · current')
+        : null), createElement(Text, {
+        color: descriptionColor,
+        wrap: 'wrap',
+    }, input.description));
+}
+function namespaceTurnTraceUpdates(updates, turnTracePrefix) {
+    return updates.map((update) => ({
+        ...update,
+        streamKey: update.streamKey
+            ? `${turnTracePrefix}:${update.streamKey}`
+            : update.streamKey,
+    }));
+}
+function namespaceProviderProgressEvent(event, turnTracePrefix) {
+    return {
+        ...event,
+        id: event.id ? `${turnTracePrefix}:${event.id}` : `${turnTracePrefix}:trace`,
+    };
+}
+function isCurrentReasoningOption(option, currentReasoningEffort) {
+    const normalizedCurrent = normalizeNullableString(currentReasoningEffort) ?? 'medium';
+    return normalizeNullableString(option) === normalizedCurrent;
+}
+function wrapPickerIndex(index, count) {
+    if (count <= 0) {
+        return 0;
+    }
+    return ((index % count) + count) % count;
+}
+function assistantModelDiscoveryResultsEqual(left, right) {
+    if (left === right) {
+        return true;
+    }
+    if (!left || !right) {
+        return false;
+    }
+    return (left.status === right.status &&
+        (normalizeNullableString(left.message) ?? null) ===
+            (normalizeNullableString(right.message) ?? null) &&
+        left.models.length === right.models.length &&
+        left.models.every((model, index) => model.id === right.models[index]?.id));
+}
+const EMPTY_ASSISTANT_PROMPT_QUEUE_STATE = {
+    prompts: [],
+};
+const IDLE_ASSISTANT_TURN_STATE = {
+    pauseRequested: false,
+    phase: 'idle',
+};
+export function reduceAssistantPromptQueueState(state, action) {
+    switch (action.kind) {
+        case 'clear':
+            return EMPTY_ASSISTANT_PROMPT_QUEUE_STATE;
+        case 'dequeue':
+            return state.prompts.length > 0
+                ? {
+                    prompts: state.prompts.slice(1),
+                }
+                : state;
+        case 'enqueue':
+            return {
+                prompts: [...state.prompts, action.prompt],
+            };
+        case 'pop-last':
+            return state.prompts.length > 0
+                ? {
+                    prompts: state.prompts.slice(0, -1),
+                }
+                : state;
+        default:
+            return state;
+    }
+}
+export function reduceAssistantTurnState(state, action) {
+    switch (action.kind) {
+        case 'finish':
+            return IDLE_ASSISTANT_TURN_STATE;
+        case 'request-pause':
+            return state.phase === 'running'
+                ? {
+                    ...state,
+                    pauseRequested: true,
+                }
+                : state;
+        case 'start':
+            return {
+                pauseRequested: false,
+                phase: 'running',
+            };
+        default:
+            return state;
+    }
+}
+function createAssistantTurnTracePrefix() {
+    return `turn:${Date.now()}:${Math.random().toString(36).slice(2, 8)}`;
+}
+export function resolveAssistantQueuedPromptDisposition(input) {
+    if (input.turnOutcome === 'failed' ||
+        input.turnOutcome === 'interrupted' ||
+        (input.pauseRequested && input.turnOutcome === 'completed')) {
+        return {
+            kind: 'restore-composer',
+            restoredQueuedPromptCount: input.queuedPrompts.length,
+        };
+    }
+    if (input.turnOutcome === 'completed' && input.queuedPrompts.length > 0) {
+        return {
+            kind: 'replay-next',
+            nextQueuedPrompt: input.queuedPrompts[0] ?? '',
+            remainingQueuedPrompts: input.queuedPrompts.slice(1),
+        };
+    }
+    return {
+        kind: 'idle',
+    };
+}
+function normalizeAssistantTurnSelection(input) {
+    return {
+        activeModel: normalizeNullableString(input.activeModel),
+        activeReasoningEffort: normalizeNullableString(input.activeReasoningEffort),
+    };
+}
+function resolveAssistantSessionTurnSelection(session) {
+    return normalizeAssistantTurnSelection({
+        activeModel: session.providerOptions.model,
+        activeReasoningEffort: session.providerOptions.reasoningEffort,
+    });
+}
+export function resolveAssistantSelectionAfterSessionSync(input) {
+    const currentSelection = normalizeAssistantTurnSelection(input.currentSelection);
+    const previousSessionSelection = resolveAssistantSessionTurnSelection(input.previousSession);
+    const nextSessionSelection = resolveAssistantSessionTurnSelection(input.nextSession);
+    const effectiveSelectionChanged = input.previousSession.provider !== input.nextSession.provider ||
+        previousSessionSelection.activeModel !== nextSessionSelection.activeModel ||
+        previousSessionSelection.activeReasoningEffort !==
+            nextSessionSelection.activeReasoningEffort;
+    return effectiveSelectionChanged ? nextSessionSelection : currentSelection;
+}
+export async function runAssistantPromptTurn(input) {
+    let streamedAssistantEntryKey = null;
+    const handleTraceEvent = (event) => {
+        const namespacedUpdates = namespaceTurnTraceUpdates(event.updates, input.turnTracePrefix);
+        if (namespacedUpdates.length === 0) {
+            return;
+        }
+        for (const update of namespacedUpdates) {
+            if (update.kind === 'assistant' && update.streamKey) {
+                streamedAssistantEntryKey = streamedAssistantEntryKey ?? update.streamKey;
+            }
+        }
+        input.setEntries((previous) => applyInkChatTraceUpdates(previous, namespacedUpdates));
+        const latestStatusUpdate = [...namespacedUpdates]
+            .reverse()
+            .find((update) => update.kind === 'error' || update.kind === 'status');
+        if (latestStatusUpdate) {
+            input.setStatus({
+                kind: latestStatusUpdate.kind === 'error' ? 'error' : 'info',
+                text: latestStatusUpdate.text,
+            });
+        }
+    };
+    try {
+        const result = await sendAssistantMessage({
+            ...input.input,
+            abortSignal: input.input.abortSignal,
+            conversation: {
+                ...(input.input.conversation ?? {}),
+                sessionId: input.session.sessionId,
+            },
+            model: input.activeModel,
+            onProviderEvent: (event) => {
+                input.setEntries((previous) => applyProviderProgressEventToEntries({
+                    entries: previous,
+                    event: namespaceProviderProgressEvent(event, input.turnTracePrefix),
+                }));
+            },
+            onTraceEvent: handleTraceEvent,
+            prompt: input.prompt,
+            reasoningEffort: input.activeReasoningEffort,
+            showThinkingTraces: true,
+        });
+        return {
+            delivery: result.delivery,
+            deliveryError: result.deliveryError,
+            kind: 'completed',
+            response: result.response,
+            session: result.session,
+            streamedAssistantEntryKey,
+        };
+    }
+    catch (error) {
+        const recoveredSession = extractRecoveredAssistantSession(error);
+        if (isAssistantProviderInterruptedError(error)) {
+            return {
+                kind: 'interrupted',
+                recoveredSession,
+            };
+        }
+        return {
+            error,
+            kind: 'failed',
+            recoveredSession,
+        };
+    }
+}
+function useAssistantChatController(input) {
+    const { exit } = useApp();
+    const [session, setSession] = React.useState(input.resolvedSession);
+    const [entries, setEntries] = React.useState(seedChatEntries(input.transcriptEntries));
+    const entriesRef = React.useRef(entries);
+    const [status, setStatus] = React.useState(null);
+    const [composerValue, setComposerValue] = React.useState('');
+    const initialActiveModel = normalizeNullableString(input.input.model) ??
+        normalizeNullableString(input.selectedProviderDefaults?.model) ??
+        normalizeNullableString(input.resolvedSession.providerOptions.model) ??
+        normalizeNullableString(input.codexDisplay.model);
+    const initialActiveReasoningEffort = normalizeNullableString(input.input.reasoningEffort) ??
+        normalizeNullableString(input.selectedProviderDefaults?.reasoningEffort) ??
+        normalizeNullableString(input.resolvedSession.providerOptions.reasoningEffort) ??
+        normalizeNullableString(input.codexDisplay.reasoningEffort);
+    const [activeModel, setActiveModel] = React.useState(initialActiveModel);
+    const [activeReasoningEffort, setActiveReasoningEffort] = React.useState(initialActiveReasoningEffort);
+    const [modelDiscovery, setModelDiscovery] = React.useState(null);
+    const [modelSwitcherState, setModelSwitcherState] = React.useState(null);
+    const [promptQueueState, setPromptQueueState] = React.useState(EMPTY_ASSISTANT_PROMPT_QUEUE_STATE);
+    const [turnState, setTurnState] = React.useState(IDLE_ASSISTANT_TURN_STATE);
+    const latestSessionRef = React.useRef(input.resolvedSession);
+    const latestTurnsRef = React.useRef(0);
+    const initialPromptRef = React.useRef(normalizeNullableString(input.input.initialPrompt));
+    const bootstrappedRef = React.useRef(false);
+    const promptQueueStateRef = React.useRef(EMPTY_ASSISTANT_PROMPT_QUEUE_STATE);
+    const turnStateRef = React.useRef(IDLE_ASSISTANT_TURN_STATE);
+    const activeTurnAbortControllerRef = React.useRef(null);
+    const activeSelectionRef = React.useRef({
+        activeModel: initialActiveModel,
+        activeReasoningEffort: initialActiveReasoningEffort,
+    });
+    const modelCatalog = resolveAssistantModelCatalog({
+        provider: session.provider,
+        baseUrl: session.providerOptions.baseUrl,
+        currentModel: activeModel,
+        currentReasoningEffort: activeReasoningEffort,
+        discovery: modelDiscovery,
+        headers: session.providerOptions.headers ?? null,
+        apiKeyEnv: session.providerOptions.apiKeyEnv,
+        oss: session.providerOptions.oss,
+        providerName: session.providerOptions.providerName,
+    });
+    const updatePromptQueue = React.useCallback((action) => {
+        const nextState = reduceAssistantPromptQueueState(promptQueueStateRef.current, action);
+        promptQueueStateRef.current = nextState;
+        setPromptQueueState(nextState);
+        return nextState;
+    }, []);
+    const updateTurnState = React.useCallback((action) => {
+        const nextState = reduceAssistantTurnState(turnStateRef.current, action);
+        turnStateRef.current = nextState;
+        setTurnState(nextState);
+        return nextState;
+    }, []);
+    React.useEffect(() => {
+        latestSessionRef.current = session;
+    }, [session]);
+    React.useEffect(() => {
+        entriesRef.current = entries;
+    }, [entries]);
+    const setActiveSelection = React.useCallback((nextSelection) => {
+        const normalizedSelection = normalizeAssistantTurnSelection(nextSelection);
+        activeSelectionRef.current = normalizedSelection;
+        setActiveModel(normalizedSelection.activeModel);
+        setActiveReasoningEffort(normalizedSelection.activeReasoningEffort);
+    }, []);
+    const commitSession = React.useCallback((nextSession) => {
+        const previousSession = latestSessionRef.current;
+        latestSessionRef.current = nextSession;
+        setSession(nextSession);
+        const nextSelection = resolveAssistantSelectionAfterSessionSync({
+            currentSelection: activeSelectionRef.current,
+            previousSession,
+            nextSession,
+        });
+        if (nextSelection.activeModel !== activeSelectionRef.current.activeModel ||
+            nextSelection.activeReasoningEffort !==
+                activeSelectionRef.current.activeReasoningEffort) {
+            setActiveSelection(nextSelection);
+        }
+    }, [setActiveSelection]);
+    React.useEffect(() => {
+        let cancelled = false;
+        const baseUrl = normalizeNullableString(session.providerOptions.baseUrl);
+        if (!modelCatalog.capabilities.supportsModelDiscovery || !baseUrl) {
+            setModelDiscovery((existing) => (existing === null ? existing : null));
+            return () => {
+                cancelled = true;
+            };
+        }
+        void (async () => {
+            const nextDiscovery = await discoverAssistantProviderModels({
+                provider: session.provider,
+                baseUrl,
+                apiKeyEnv: session.providerOptions.apiKeyEnv,
+                headers: session.providerOptions.headers ?? null,
+                providerName: session.providerOptions.providerName,
+            });
+            if (cancelled) {
+                return;
+            }
+            setModelDiscovery((existing) => assistantModelDiscoveryResultsEqual(existing, nextDiscovery)
+                ? existing
+                : nextDiscovery);
+        })();
+        return () => {
+            cancelled = true;
+        };
+    }, [
+        modelCatalog.capabilities.supportsModelDiscovery,
+        session.provider,
+        session.providerOptions.apiKeyEnv,
+        session.providerOptions.baseUrl,
+        session.providerOptions.headers,
+        session.providerOptions.providerName,
+    ]);
+    const queuePrompt = (prompt) => {
+        updatePromptQueue({
+            kind: 'enqueue',
+            prompt,
+        });
+    };
+    const applyQueuedPromptDisposition = (disposition, queuedPrompts) => {
+        if (disposition.kind === 'restore-composer') {
+            updatePromptQueue({
+                kind: 'clear',
+            });
+            if (queuedPrompts.length > 0) {
+                setComposerValue((previous) => mergeComposerDraftWithQueuedPrompts(previous, queuedPrompts));
+            }
+            return null;
+        }
+        if (disposition.kind === 'replay-next') {
+            promptQueueStateRef.current = {
+                prompts: disposition.remainingQueuedPrompts,
+            };
+            setPromptQueueState(promptQueueStateRef.current);
+            return disposition.nextQueuedPrompt;
+        }
+        return null;
+    };
+    const editLastQueuedPrompt = () => {
+        const lastQueuedPrompt = promptQueueStateRef.current.prompts.at(-1);
+        if (!lastQueuedPrompt) {
+            return;
+        }
+        updatePromptQueue({
+            kind: 'pop-last',
+        });
+        setComposerValue((previous) => mergeComposerDraftWithQueuedPrompts(previous, [lastQueuedPrompt]));
+    };
+    const startPromptTurn = (prompt) => {
+        setEntries((previous) => [
+            ...previous,
+            {
+                kind: 'user',
+                text: prompt,
+            },
+        ]);
+        setStatus(null);
+        updateTurnState({
+            kind: 'start',
+        });
+        const abortController = new AbortController();
+        const turnTracePrefix = createAssistantTurnTracePrefix();
+        activeTurnAbortControllerRef.current = abortController;
+        void (async () => {
+            const activeSelection = activeSelectionRef.current;
+            const outcome = await runAssistantPromptTurn({
+                activeModel: activeSelection.activeModel,
+                activeReasoningEffort: activeSelection.activeReasoningEffort,
+                input: {
+                    ...input.input,
+                    abortSignal: abortController.signal,
+                },
+                prompt,
+                session: latestSessionRef.current,
+                setEntries,
+                setStatus,
+                turnTracePrefix,
+            });
+            if ('session' in outcome &&
+                outcome.session !== latestSessionRef.current) {
+                commitSession(outcome.session);
+            }
+            if (outcome.kind === 'completed') {
+                latestTurnsRef.current += 1;
+                setEntries((previous) => outcome.streamedAssistantEntryKey
+                    ? applyInkChatTraceUpdates(previous, [
+                        {
+                            kind: 'assistant',
+                            mode: 'replace',
+                            streamKey: outcome.streamedAssistantEntryKey,
+                            text: outcome.response,
+                        },
+                    ])
+                    : [
+                        ...previous,
+                        {
+                            kind: 'assistant',
+                            text: outcome.response,
+                        },
+                    ]);
+                setStatus(outcome.delivery
+                    ? {
+                        kind: 'success',
+                        text: `Delivered over ${outcome.delivery.channel} to ${outcome.delivery.target}.`,
+                    }
+                    : outcome.deliveryError
+                        ? {
+                            kind: 'error',
+                            text: `Response saved locally, but delivery failed: ${outcome.deliveryError.message}`,
+                        }
+                        : null);
+            }
+            if (outcome.kind === 'failed') {
+                if (outcome.recoveredSession) {
+                    commitSession(outcome.recoveredSession);
+                }
+                const queuedPrompts = promptQueueStateRef.current.prompts;
+                const queuedPromptDisposition = resolveAssistantQueuedPromptDisposition({
+                    pauseRequested: false,
+                    queuedPrompts,
+                    turnOutcome: 'failed',
+                });
+                applyQueuedPromptDisposition(queuedPromptDisposition, queuedPrompts);
+                const errorPresentation = resolveAssistantTurnErrorPresentation({
+                    error: outcome.error,
+                    restoredQueuedPromptCount: queuedPromptDisposition.kind === 'restore-composer'
+                        ? queuedPromptDisposition.restoredQueuedPromptCount
+                        : 0,
+                });
+                setEntries((previous) => [
+                    ...previous,
+                    errorPresentation.entry,
+                ]);
+                setStatus(errorPresentation.status);
+                if (errorPresentation.persistTranscriptError) {
+                    void appendAssistantTranscriptEntries(input.input.vault, latestSessionRef.current.sessionId, [
+                        {
+                            kind: 'error',
+                            text: errorPresentation.entry.text,
+                        },
+                    ]).catch(() => { });
+                }
+            }
+            if (outcome.kind === 'interrupted' && outcome.recoveredSession) {
+                commitSession(outcome.recoveredSession);
+            }
+            activeTurnAbortControllerRef.current = null;
+            setEntries((previous) => finalizePendingInkChatTraces(previous, turnTracePrefix));
+            const pauseRequested = turnStateRef.current.pauseRequested;
+            updateTurnState({
+                kind: 'finish',
+            });
+            if (outcome.kind === 'interrupted') {
+                const queuedPrompts = promptQueueStateRef.current.prompts;
+                const queuedPromptDisposition = resolveAssistantQueuedPromptDisposition({
+                    pauseRequested,
+                    queuedPrompts,
+                    turnOutcome: 'interrupted',
+                });
+                applyQueuedPromptDisposition(queuedPromptDisposition, queuedPrompts);
+                setStatus({
+                    kind: 'info',
+                    text: queuedPromptDisposition.kind === 'restore-composer' &&
+                        queuedPromptDisposition.restoredQueuedPromptCount > 0
+                        ? 'Paused current turn. Queued follow-ups are back in the composer.'
+                        : 'Paused current turn.',
+                });
+                return;
+            }
+            const queuedPrompts = promptQueueStateRef.current.prompts;
+            const queuedPromptDisposition = resolveAssistantQueuedPromptDisposition({
+                pauseRequested,
+                queuedPrompts,
+                turnOutcome: outcome.kind,
+            });
+            if (queuedPromptDisposition.kind === 'restore-composer' &&
+                outcome.kind === 'completed' &&
+                pauseRequested) {
+                applyQueuedPromptDisposition(queuedPromptDisposition, queuedPrompts);
+                setStatus({
+                    kind: 'info',
+                    text: queuedPromptDisposition.restoredQueuedPromptCount > 0
+                        ? 'Stopped after the current turn. Queued follow-ups are back in the composer.'
+                        : 'Stopped after the current turn.',
+                });
+                return;
+            }
+            if (outcome.kind === 'completed') {
+                const nextQueuedPrompt = applyQueuedPromptDisposition(queuedPromptDisposition, queuedPrompts);
+                if (nextQueuedPrompt) {
+                    queueMicrotask(() => {
+                        startPromptTurn(nextQueuedPrompt);
+                    });
+                }
+            }
+        })();
+    };
+    const openModelSwitcher = () => {
+        const reasoningOptions = resolveAssistantCatalogReasoningOptions(modelCatalog.models[findAssistantModelOptionIndex(activeModel, modelCatalog.modelOptions)]);
+        setModelSwitcherState({
+            models: modelCatalog.models,
+            mode: 'model',
+            modelIndex: findAssistantModelOptionIndex(activeModel, modelCatalog.modelOptions),
+            reasoningIndex: findAssistantReasoningOptionIndex(activeReasoningEffort, reasoningOptions),
+            modelOptions: modelCatalog.modelOptions,
+            reasoningOptions,
+        });
+    };
+    const moveModelSwitcherSelection = (delta) => {
+        setModelSwitcherState((previous) => {
+            if (!previous) {
+                return previous;
+            }
+            if (previous.mode === 'model') {
+                const modelIndex = wrapPickerIndex(previous.modelIndex + delta, previous.modelOptions.length);
+                const reasoningOptions = resolveAssistantCatalogReasoningOptions(previous.models[modelIndex]);
+                return {
+                    ...previous,
+                    modelIndex,
+                    reasoningIndex: findAssistantReasoningOptionIndex(activeReasoningEffort, reasoningOptions),
+                    reasoningOptions,
+                };
+            }
+            return {
+                ...previous,
+                reasoningIndex: wrapPickerIndex(previous.reasoningIndex + delta, previous.reasoningOptions.length),
+            };
+        });
+    };
+    const cancelModelSwitcher = () => {
+        setModelSwitcherState((previous) => {
+            if (!previous) {
+                return previous;
+            }
+            if (previous.mode === 'reasoning') {
+                return {
+                    ...previous,
+                    mode: 'model',
+                };
+            }
+            return null;
+        });
+    };
+    const applyModelSwitcherSelection = (selection) => {
+        const nextModel = selection.modelOptions[selection.modelIndex]?.value ??
+            activeModel ??
+            null;
+        const nextReasoningEffort = selection.reasoningOptions.length > 0
+            ? selection.reasoningOptions[selection.reasoningIndex]?.value ??
+                activeReasoningEffort ??
+                'medium'
+            : null;
+        const selectedLabel = [
+            nextModel ?? 'the configured model',
+            normalizeNullableString(nextReasoningEffort),
+        ]
+            .filter((value) => Boolean(value))
+            .join(' ');
+        setActiveSelection({
+            activeModel: nextModel,
+            activeReasoningEffort: nextReasoningEffort,
+        });
+        setModelSwitcherState(null);
+        setStatus({
+            kind: 'info',
+            text: `Using ${selectedLabel}.`,
+        });
+        void (async () => {
+            try {
+                const updatedSession = await updateAssistantSessionOptions({
+                    vault: input.input.vault,
+                    sessionId: latestSessionRef.current.sessionId,
+                    providerOptions: {
+                        model: nextModel,
+                        reasoningEffort: nextReasoningEffort,
+                    },
+                });
+                commitSession(updatedSession);
+                await saveAssistantOperatorDefaultsPatch(buildAssistantProviderDefaultsPatch({
+                    defaults: input.defaults,
+                    provider: updatedSession.provider,
+                    providerConfig: {
+                        ...updatedSession.providerOptions,
+                        model: nextModel,
+                        reasoningEffort: nextReasoningEffort,
+                    },
+                }));
+            }
+            catch (error) {
+                setStatus({
+                    kind: 'error',
+                    text: error instanceof Error && error.message.trim().length > 0
+                        ? `Using ${selectedLabel} for now, but failed to save it for later chats: ${error.message}`
+                        : `Using ${selectedLabel} for now, but failed to save it for later chats.`,
+                });
+            }
+        })();
+    };
+    const confirmModelSwitcher = () => {
+        if (!modelSwitcherState) {
+            return;
+        }
+        if (modelSwitcherState.mode === 'model' &&
+            modelSwitcherState.reasoningOptions.length > 0) {
+            setModelSwitcherState({
+                ...modelSwitcherState,
+                mode: 'reasoning',
+            });
+            return;
+        }
+        applyModelSwitcherSelection(modelSwitcherState);
+    };
+    const requestPause = () => {
+        if (turnStateRef.current.phase !== 'running' ||
+            modelSwitcherState ||
+            turnStateRef.current.pauseRequested ||
+            !activeTurnAbortControllerRef.current) {
+            return;
+        }
+        updateTurnState({
+            kind: 'request-pause',
+        });
+        setStatus({
+            kind: 'info',
+            text: promptQueueStateRef.current.prompts.length > 0
+                ? 'Pausing current turn. Queued follow-ups will return to the composer.'
+                : 'Pausing current turn...',
+        });
+        activeTurnAbortControllerRef.current.abort();
+    };
+    useInput((_input, key) => {
+        if (!key.escape) {
+            return;
+        }
+        requestPause();
+    }, {
+        isActive: turnState.phase === 'running' && modelSwitcherState === null,
+    });
+    const submitPrompt = (rawValue, mode) => {
+        const action = resolveChatSubmitAction(rawValue, {
+            busy: turnState.phase === 'running',
+            trigger: mode,
+        });
+        if (action.kind === 'ignore') {
+            return 'keep';
+        }
+        if (action.kind === 'exit') {
+            exit();
+            return 'keep';
+        }
+        if (action.kind === 'session') {
+            setStatus({
+                kind: 'info',
+                text: `session ${latestSessionRef.current.sessionId}`,
+            });
+            return 'keep';
+        }
+        if (action.kind === 'model') {
+            setStatus(null);
+            openModelSwitcher();
+            return 'clear';
+        }
+        if (action.kind === 'queue') {
+            queuePrompt(action.prompt);
+            return 'clear';
+        }
+        startPromptTurn(action.prompt);
+        return shouldClearComposerForSubmitAction(action) ? 'clear' : 'keep';
+    };
+    React.useEffect(() => {
+        if (bootstrappedRef.current) {
+            return;
+        }
+        bootstrappedRef.current = true;
+        if (initialPromptRef.current) {
+            submitPrompt(initialPromptRef.current, 'enter');
+        }
+    }, []);
+    const bindingSummary = formatSessionBinding(session);
+    const metadataBadges = resolveChatMetadataBadges({
+        baseUrl: session.providerOptions.baseUrl,
+        provider: session.provider,
+        model: activeModel ?? session.providerOptions.model ?? input.codexDisplay.model,
+        reasoningEffort: activeReasoningEffort ?? input.codexDisplay.reasoningEffort,
+    }, input.redactedVault);
+    return {
+        activeModel,
+        activeReasoningEffort,
+        bindingSummary,
+        busy: turnState.phase === 'running',
+        cancelModelSwitcher,
+        composerValue,
+        confirmModelSwitcher,
+        editLastQueuedPrompt,
+        entries,
+        lastQueuedPrompt: promptQueueState.prompts.at(-1) ?? null,
+        latestSessionRef,
+        latestTurnsRef,
+        metadataBadges,
+        modelSwitcherState,
+        moveModelSwitcherSelection,
+        queuedPromptCount: promptQueueState.prompts.length,
+        session,
+        setComposerValue,
+        status,
+        submitPrompt,
+    };
+}
+export async function runAssistantChatWithInk(input) {
+    const startedAt = new Date().toISOString();
+    const defaults = await resolveAssistantOperatorDefaults();
+    const themeBaseline = captureAssistantInkThemeBaseline();
+    const resolved = await openAssistantConversation(input);
+    const selectedProviderDefaults = resolveAssistantProviderDefaults(defaults, resolved.session.provider);
+    const transcriptEntries = await listAssistantTranscriptEntries(input.vault, resolved.session.sessionId);
+    const redactedVault = redactAssistantDisplayPath(input.vault);
+    const codexDisplay = await resolveCodexDisplayOptions({
+        model: input.model ??
+            selectedProviderDefaults?.model ??
+            resolved.session.providerOptions.model,
+        profile: input.profile ??
+            selectedProviderDefaults?.profile ??
+            resolved.session.providerOptions.profile,
+    });
+    const inkInput = resolveAssistantInkInputAdapter();
+    if (!inkInput.stdin) {
+        throw new Error('Murph chat requires interactive terminal input. process.stdin does not support raw mode, and Murph could not open the controlling terminal for Ink input.');
+    }
+    const inkStdin = inkInput.stdin;
+    return await new Promise((resolve, reject) => {
+        let settled = false;
+        let instance = null;
+        const resolveOnce = (result) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            inkInput.close();
+            resolve(result);
+        };
+        const rejectOnce = (error) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            inkInput.close();
+            reject(error);
+        };
+        const App = () => {
+            const createElement = React.createElement;
+            const [theme, setTheme] = React.useState(() => themeBaseline.theme);
+            const controller = useAssistantChatController({
+                codexDisplay,
+                defaults,
+                input,
+                redactedVault,
+                resolvedSession: resolved.session,
+                selectedProviderDefaults,
+                transcriptEntries,
+            });
+            React.useEffect(() => {
+                if (process.platform !== 'darwin') {
+                    return undefined;
+                }
+                const refreshTimer = setInterval(() => {
+                    setTheme((currentTheme) => {
+                        const nextTheme = resolveAssistantInkThemeForOpenChat({
+                            currentMode: currentTheme.mode,
+                            initialAppleInterfaceStyle: themeBaseline.initialAppleInterfaceStyle,
+                            initialColorFgbg: themeBaseline.initialColorFgbg,
+                        });
+                        return nextTheme.mode === currentTheme.mode
+                            ? currentTheme
+                            : nextTheme;
+                    });
+                }, ASSISTANT_INK_THEME_REFRESH_INTERVAL_MS);
+                return () => {
+                    clearInterval(refreshTimer);
+                };
+            }, []);
+            React.useEffect(() => () => {
+                resolveOnce(assistantChatResultSchema.parse({
+                    vault: redactedVault,
+                    startedAt,
+                    stoppedAt: new Date().toISOString(),
+                    turns: controller.latestTurnsRef.current,
+                    session: redactAssistantSessionForDisplay(controller.latestSessionRef.current),
+                }));
+            }, []);
+            return createElement(AssistantInkThemeContext.Provider, {
+                value: theme,
+            }, createElement(Box, {
+                flexDirection: 'column',
+                paddingX: ASSISTANT_CHAT_VIEW_PADDING_X,
+                paddingY: 1,
+                width: '100%',
+            }, createElement(ChatTranscriptFeed, {
+                bindingSummary: controller.bindingSummary,
+                busy: controller.busy,
+                entries: controller.entries,
+                sessionId: controller.session.sessionId,
+            }), createElement(Box, {
+                flexDirection: 'column',
+                width: '100%',
+            }, createElement(ChatStatus, {
+                busy: shouldShowBusyStatus({
+                    busy: controller.busy,
+                    entries: controller.entries,
+                }),
+                status: controller.status,
+            }), createElement(QueuedFollowUpStatus, {
+                latestPrompt: controller.lastQueuedPrompt,
+                queuedPromptCount: controller.queuedPromptCount,
+            }), controller.modelSwitcherState
+                ? createElement(ModelSwitcher, {
+                    currentModel: controller.activeModel,
+                    currentReasoningEffort: controller.activeReasoningEffort,
+                    mode: controller.modelSwitcherState.mode,
+                    modelIndex: controller.modelSwitcherState.modelIndex,
+                    modelOptions: controller.modelSwitcherState.modelOptions,
+                    onCancel: controller.cancelModelSwitcher,
+                    onConfirm: controller.confirmModelSwitcher,
+                    onMove: controller.moveModelSwitcherSelection,
+                    reasoningIndex: controller.modelSwitcherState.reasoningIndex,
+                    reasoningOptions: controller.modelSwitcherState.reasoningOptions,
+                })
+                : null, createElement(ChatComposer, {
+                entryCount: controller.entries.length,
+                modelSwitcherActive: controller.modelSwitcherState !== null,
+                onChange: controller.setComposerValue,
+                onEditLastQueuedPrompt: controller.editLastQueuedPrompt,
+                onSubmit: controller.submitPrompt,
+                value: controller.composerValue,
+            }), createElement(ChatFooter, {
+                badges: controller.metadataBadges,
+            }))));
+        };
+        try {
+            instance = render(React.createElement(App), {
+                stderr: process.stderr,
+                stdin: inkStdin,
+                stdout: process.stderr,
+                patchConsole: false,
+            });
+            void instance.waitUntilExit().catch(rejectOnce);
+        }
+        catch (error) {
+            rejectOnce(error);
+            return;
+        }
+        if (!instance) {
+            rejectOnce(new Error('Ink chat failed to initialize.'));
+        }
+    });
+}
+//# sourceMappingURL=ink.js.map