zames_pro 2.73.11 → 2.75.0

package/dist/tui/InputLine.js

@@ -0,0 +1,318 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// The live INPUT LINE — a wrapping, multi-line editor rendered by Ink with a
+// real terminal cursor (useCursor), so IME composition and the caret land on
+// the right cell.
+//
+// The editor state transitions are PURE (src/tui/edit.ts) and the key mapping
+// is PURE (src/tui/keys.ts). This component owns only the imperative parts:
+// reading key events from Ink's useInput, bracketed paste from usePaste,
+// calling the operator callbacks (submit / abort / attach), and painting the
+// visual rows via the shared layoutInput.
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { Box, Text, useInput, usePaste, useCursor, useWindowSize, useStdin, } from 'ink';
+import { translate } from '../i18n.js';
+import { layoutInput, SUGGEST_PAGE, } from '../input/layout.js';
+import { insertText, insertPaste, insertNewline, backspace, del, moveLeft, moveRight, moveHome, moveEnd, wordLeft, wordRight, deleteWordLeft, deleteWordRight, killToLineEnd, moveVisualRows, pushUndo, undoEdit, historyUp, historyDown, searchStart, searchNext, searchAccept, searchCancel, searchInput, searchBackspace, recordHistory, afterSubmit, } from './edit.js';
+import { dispatchKey, parseCsiU } from './keys.js';
+import { useSyncExternalStore } from 'react';
+import { matchSlashCommands, suggestWindow, completeSlashCommand, } from '../input/suggest.js';
+/** Render the visual rows of the buffer with the prompt on the first row. */
+function InputRows({ prompt, buf, cols, }) {
+    const lay = layoutInput(prompt, buf, 0, cols);
+    return (_jsx(Box, { flexDirection: "column", children: lay.rows.map((r, i) => (_jsxs(Text, { children: [_jsx(Text, { color: "#c8b06a", bold: true, children: r.prefix }), r.text] }, i))) }));
+}
+export function InputLine(props) {
+    const { columns } = useWindowSize();
+    const cols = columns || 80;
+    const { setCursorPosition } = useCursor();
+    const [suggestSelected, setSuggestSelected] = useState(-1);
+    // The visible page of the suggestion list follows the SELECTION: with more
+    // matches than one page, Ctrl+N could move the selection past the page and
+    // the highlight vanished (the operator "lost" the selected command). Derive
+    // the offset from the selection instead of keeping a separate state.
+    const suggestOffset = suggestSelected < 0 ? 0 : suggestSelected - (suggestSelected % SUGGEST_PAGE);
+    // The editor state lives in the STORE (props.store), read via
+    // useSyncExternalStore. This is what makes the typed line survive an Ink
+    // remount (a resize / pause): a local useState would be reset to empty on
+    // every remount, wiping what the operator had typed.
+    const st = useSyncExternalStore(props.store.subscribe, () => props.store.getSnapshot().edit);
+    const setSt = useCallback((next) => {
+        props.store.update((snap) => ({
+            edit: typeof next === 'function' ? next(snap.edit) : next,
+        }));
+    }, [props.store]);
+    // The input lives inside a rounded box: 2 columns of border (left/right) plus
+    // 1 column of inner padding on each side. The layout must wrap to the INNER
+    // width, or a long line would overflow the frame.
+    const innerCols = Math.max(4, cols - 4);
+    // Mirror the state into a ref so the useInput callback (a stable closure Ink
+    // calls for every key) always sees the latest values.
+    const stRef = useRef(st);
+    stRef.current = st;
+    // Layout for the CURRENT state — cursor positioning + visual-edge check.
+    const lay = useMemo(() => layoutInput(props.prompt, st.buf, st.cursor, innerCols), [props.prompt, st.buf, st.cursor, innerCols]);
+    const suggestions = useMemo(() => matchSlashCommands(st.buf, props.commands), [st.buf, props.commands]);
+    const apply = useCallback((fn) => {
+        setSt((prev) => {
+            const next = fn(prev);
+            if (next.pastes !== prev.pastes)
+                props.onPastesChange(next.pastes);
+            return next;
+        });
+    }, [props]);
+    const doSubmit = useCallback(() => {
+        const s = stRef.current;
+        if (props.locked)
+            return;
+        if (!s.buf.trim())
+            return;
+        const withHist = recordHistory(s, s.buf);
+        const next = afterSubmit(withHist);
+        setSt(next);
+        props.onHistoryChange(withHist.history);
+        // onSubmit MUST run BEFORE the paste list is cleared: the Ink adapter
+        // (TuiEditor.handleSubmit) expands `[Pasted lines#N]` markers by reading
+        // the store's paste list, so clearing it first sent the literal marker to
+        // the agent instead of the pasted text.
+        props.onSubmit(s.buf, props.attachments.slice());
+        props.onPastesChange(next.pastes);
+    }, [props]);
+    const handlePaste = useCallback(async (text) => {
+        const trimmed = String(text).trim();
+        const looksPath = !/\s/.test(trimmed) && /[./\\]/.test(trimmed) && trimmed.length < 500;
+        if (looksPath || trimmed.startsWith('data:')) {
+            try {
+                const att = await props.onAttach(text);
+                if (att) {
+                    apply((s) => insertText(s, att.marker));
+                    return;
+                }
+            }
+            catch {
+                // fall through to plain insert
+            }
+        }
+        apply((s) => insertPaste(s, text));
+    }, [apply, props]);
+    const tryClipboard = useCallback(async () => {
+        try {
+            const att = await props.onClipboard();
+            if (att)
+                apply((s) => insertText(s, att.marker));
+        }
+        catch {
+            // ignore
+        }
+    }, [apply, props]);
+    const runAction = useCallback((action) => {
+        if (!action)
+            return;
+        switch (action.type) {
+            case 'submit':
+                doSubmit();
+                return;
+            case 'newline':
+                apply(insertNewline);
+                return;
+            case 'insert':
+                apply((s) => pushUndo(insertText(s, action.text), true));
+                return;
+            case 'backspace':
+                apply((s) => backspace(pushUndo(s, true)));
+                return;
+            case 'delete':
+                apply((s) => del(pushUndo(s, true)));
+                return;
+            case 'left':
+                apply(moveLeft);
+                return;
+            case 'right':
+                apply(moveRight);
+                return;
+            case 'up':
+                apply((s) => moveVisualRows(s, -1, props.prompt, innerCols));
+                return;
+            case 'down':
+                apply((s) => moveVisualRows(s, 1, props.prompt, innerCols));
+                return;
+            case 'home':
+                apply(moveHome);
+                return;
+            case 'end':
+                apply(moveEnd);
+                return;
+            case 'wordLeft':
+                apply(wordLeft);
+                return;
+            case 'wordRight':
+                apply(wordRight);
+                return;
+            case 'deleteWordLeft':
+                apply((s) => deleteWordLeft(pushUndo(s)));
+                return;
+            case 'deleteWordRight':
+                apply((s) => deleteWordRight(pushUndo(s)));
+                return;
+            case 'killToEnd':
+                apply((s) => killToLineEnd(pushUndo(s)));
+                return;
+            case 'clearLine':
+                apply((s) => ({ ...pushUndo(s), buf: '', cursor: 0, pastes: [] }));
+                return;
+            case 'undoEdit':
+                apply(undoEdit);
+                return;
+            case 'complete':
+                apply((s) => {
+                    const next = completeSlashCommand(s.buf, matchSlashCommands(s.buf, props.commands), suggestSelected);
+                    if (next === null)
+                        return s;
+                    return { ...s, buf: next, cursor: Array.from(next).length };
+                });
+                return;
+            case 'suggestNext':
+                setSuggestSelected((n) => Math.min(suggestions.length - 1, (n < 0 ? -1 : n) + 1));
+                return;
+            case 'suggestPrev':
+                setSuggestSelected((n) => Math.max(-1, n - 1));
+                return;
+            case 'historyPrev':
+                apply(historyUp);
+                return;
+            case 'historyNext':
+                apply(historyDown);
+                return;
+            case 'searchStart':
+                apply(searchStart);
+                return;
+            case 'searchNext':
+                apply(searchNext);
+                return;
+            case 'searchAccept':
+                apply(searchAccept);
+                return;
+            case 'searchCancel':
+                apply(searchCancel);
+                return;
+            case 'searchInput':
+                apply((s) => searchInput(s, action.text));
+                return;
+            case 'searchBackspace':
+                apply(searchBackspace);
+                return;
+            case 'escape':
+                props.onEscape();
+                return;
+            case 'ctrlC':
+            case 'ctrlD':
+                props.onCtrlC();
+                return;
+            case 'clearScreen':
+                props.onClearScreen();
+                return;
+            case 'clipboard':
+                void tryClipboard();
+                return;
+            case 'copyCode':
+                props.onCopyCode();
+                return;
+            default:
+                return;
+        }
+    }, [
+        apply,
+        props,
+        suggestions,
+        suggestSelected,
+        innerCols,
+        doSubmit,
+        tryClipboard,
+    ]);
+    // The raw-stdin CSI-u handler is bound ONCE (its effect depends only on
+    // stdin), so it reads the latest `runAction` through a ref — otherwise the
+    // effect would re-bind on every render and could miss keystrokes.
+    const runActionRef = useRef(runAction);
+    runActionRef.current = runAction;
+    useInput((input, key) => {
+        const s = stRef.current;
+        if (props.locked) {
+            if (key.ctrl && input === 'c')
+                props.onCtrlC();
+            return;
+        }
+        const curLay = layoutInput(props.prompt, s.buf, s.cursor, innerCols);
+        const atTop = curLay.cursorRow === 0;
+        const atBottom = curLay.cursorRow === curLay.rows.length - 1;
+        const action = dispatchKey(input, key, {
+            searchMode: s.searchMode,
+            bufferEmpty: s.buf.length === 0,
+            // A trailing backslash before the cursor = line continuation: Enter
+            // then inserts a newline (and drops the backslash).
+            endsWithBackslash: Array.from(s.buf)[s.cursor - 1] === '\\',
+        }, { atTop, atBottom });
+        runAction(action);
+    }, { isActive: true });
+    // Bracketed paste arrives on a SEPARATE channel — Ink enables the paste mode
+    // automatically. Deliver the whole string to the same handler.
+    usePaste((text) => {
+        void handlePaste(text);
+    });
+    // RAW STDIN fallback for the KITTY CSI-u forms Ink DROPS. Ink hides the raw
+    // `sequence` for these (it yields `input=''`), so the modified
+    // Delete/Backspace bindings never fired (the operator's "Ctrl+Delete does
+    // nothing"). The legacy LineEditor parsed the bytes itself; we read the same
+    // raw stream here. Sequences split across reads are carried over.
+    const { stdin: rawStdin, isRawModeSupported } = useStdin();
+    useEffect(() => {
+        if (!isRawModeSupported)
+            return;
+        let carry = '';
+        const onRaw = (data) => {
+            const s = typeof data === 'string' ? data : data.toString('utf-8');
+            const buf = carry + s;
+            // Hold a trailing INCOMPLETE CSI-u sequence for the next read.
+            const m = /\u001b\[[0-9;:]*$/.exec(buf);
+            carry = m ? m[0] : '';
+            const scan = carry ? buf.slice(0, buf.length - carry.length) : buf;
+            // Find every complete CSI-u sequence and dispatch it.
+            const re = /\u001b\[[0-9;:]*u/g;
+            let hit;
+            while ((hit = re.exec(scan)) !== null) {
+                const action = parseCsiU(hit[0]);
+                if (action)
+                    runActionRef.current(action);
+            }
+        };
+        rawStdin.on('data', onRaw);
+        return () => {
+            rawStdin.removeListener('data', onRaw);
+        };
+    }, [rawStdin, isRawModeSupported]);
+    // Position the real terminal cursor on the input cell. `y` is the row within
+    // the live Ink output BELOW the log. Panel layout (top to bottom):
+    //   row 0            = divider
+    //   row 1            = status bar
+    //   row 2            = input box TOP border
+    //   rows 3..         = input rows
+    const cursorRow = lay.cursorRow;
+    const cursorX = 
+    // The input rows sit inside the rounded box, indented by 1 column for the
+    // left border and 1 for the box's inner padding. `layoutInput().cursorCol`
+    // is ALREADY a column count that includes the prompt prefix (wide chars
+    // counted as 2), so the terminal column is just 2 + cursorCol. The old
+    // code re-measured `rowText` up to `cursorCol` code points, which
+    // DOUBLE-counted wide chars: a CJK buffer put the caret at the line end
+    // instead of under the cursor.
+    2 + lay.cursorCol;
+    setCursorPosition({ x: cursorX, y: (props.cursorTop ?? 3) + cursorRow });
+    const { shown, moreCount } = suggestWindow(suggestions, suggestOffset);
+    const t = translate(props.locale);
+    return (_jsxs(Box, { flexDirection: "column", children: [suggestions.length > 0 && (_jsxs(Box, { flexDirection: "column", children: [shown.map((c, i) => {
+                        const label = c.hint ? c.name + ' ' + c.hint : c.name;
+                        const selected = suggestOffset + i === suggestSelected;
+                        return (_jsxs(Text, { children: [_jsx(Text, { color: "#c8b06a", children: selected ? ' ▸ ' : '   ' }), _jsx(Text, { color: "#c8b06a", children: label }), _jsx(Text, { color: "#5b616e", children: '  ' + c.description })] }, c.name));
+                    }), moreCount > 0 && (_jsx(Text, { color: "#5b616e", children: '   ' +
+                            t('editor.more', { n: String(moreCount) }) +
+                            '  ' +
+                            t('editor.page_hint') }))] })), _jsx(Box, { borderStyle: "round", borderColor: props.locked ? '#5b616e' : '#c8b06a', paddingLeft: 1, paddingRight: 1, flexDirection: "column", children: _jsx(InputRows, { prompt: props.prompt, buf: st.buf, cols: innerCols }) })] }));
+}

package/dist/tui/LogView.js

@@ -0,0 +1,48 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Static, Box, Text } from 'ink';
+import { theme } from '../theme.js';
+/** One log entry. `raw` items already carry ANSI colors and are printed
+ *  verbatim; structured items get a themed prefix. */
+export function LogRow({ entry }) {
+    if (entry.raw) {
+        // Pre-rendered (markdown answer, tool preview). Print as-is; Ink passes
+        // embedded ANSI escape sequences through to the terminal.
+        return _jsx(Text, { children: entry.text });
+    }
+    switch (entry.kind) {
+        case 'user':
+            return _jsx(Text, { children: theme.user('❯ ') + entry.text });
+        case 'assistant':
+            return _jsx(Text, { children: entry.text });
+        case 'tool':
+            return _jsx(Text, { children: entry.text });
+        case 'toolResult':
+            return _jsx(Text, { children: entry.text });
+        case 'warning':
+            return _jsx(Text, { children: theme.warn(entry.text) });
+        case 'summary':
+            return _jsx(Text, { children: entry.text });
+        case 'system':
+        default:
+            return _jsx(Text, { children: theme.system(entry.text) });
+    }
+}
+/**
+ * A NON-Static log list — a plain column of rows. Used in FULL-SCREEN mode,
+ * where <Static> does NOT work: Static is absolutely positioned and is ignored
+ * by a fixed-height flex layout (the rows would not appear inside our
+ * viewport). The caller windows the entries, so only the visible slice is
+ * rendered each frame.
+ */
+export function LogList({ entries, }) {
+    return (_jsx(Box, { flexDirection: "column", children: entries.map((entry) => (_jsx(LogRow, { entry: entry }, entry.id))) }));
+}
+/**
+ * The INLINE log — rendered through Ink's <Static>, which prints each item
+ * ONCE above the live area and never repaints it. This is the right tool for
+ * the inline layout (the terminal keeps the scrollback), but it must NOT be
+ * used inside a fixed-height flex box (see LogList).
+ */
+export function LogView({ entries, }) {
+    return (_jsx(Static, { items: entries, children: (entry) => (_jsx(Box, { flexDirection: "column", children: _jsx(LogRow, { entry: entry }) }, entry.id)) }));
+}

package/dist/tui/LoginForm.js

@@ -0,0 +1,83 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// A TUI LOGIN form (username + masked password) rendered by Ink.
+//
+// The browser's own interactive login uses readline / askPassword, which
+// PAUSES the whole TUI (Ink loses the terminal to readline and both fight for
+// stdin). This form keeps the login INSIDE the TUI: the browser calls an
+// injected `onLoginPrompt` callback and never touches stdin itself.
+//
+// It is deliberately simple (two fields, Tab/↑/↓ to switch, Enter to submit,
+// Esc to cancel) — a login is a rare, focused step, not a place for menus.
+import { useState } from 'react';
+import { Box, Text, useInput, useApp } from 'ink';
+import { UI, HintBar } from './widgets.js';
+import { maskSecret, validateLogin } from './login-pure.js';
+/** Mask every character of the password with `*`. */
+function mask(s) {
+    return maskSecret(s);
+}
+export function LoginForm({ t, initialUsername = '', initialPassword = '', note, onResult, }) {
+    const { exit } = useApp();
+    const [field, setField] = useState(initialUsername ? 'pass' : 'user');
+    const [user, setUser] = useState(initialUsername);
+    const [pass, setPass] = useState(initialPassword);
+    const [error, setError] = useState('');
+    const finish = (res) => {
+        onResult(res);
+        exit();
+    };
+    const submit = () => {
+        const v = validateLogin(user, pass);
+        if (!v.ok) {
+            setError(t(v.reason === 'user' ? 'auth.form.need_user' : 'auth.form.need_pass'));
+            setField(v.field);
+            return;
+        }
+        finish({ username: user.trim(), password: pass });
+    };
+    const append = (ch) => {
+        setError('');
+        if (field === 'user')
+            setUser((v) => v + ch);
+        else
+            setPass((v) => v + ch);
+    };
+    const backspace = () => {
+        setError('');
+        if (field === 'user')
+            setUser((v) => Array.from(v).slice(0, -1).join(''));
+        else
+            setPass((v) => Array.from(v).slice(0, -1).join(''));
+    };
+    useInput((input, key) => {
+        if (key.escape) {
+            finish(null);
+            return;
+        }
+        if (key.return) {
+            // Enter on the username moves to the password first (so a two-step
+            // prompt feels natural); Enter on the password submits.
+            if (field === 'user') {
+                setField('pass');
+                return;
+            }
+            submit();
+            return;
+        }
+        if (key.tab || key.upArrow || key.downArrow) {
+            setField((f) => (f === 'user' ? 'pass' : 'user'));
+            return;
+        }
+        if (key.backspace || key.delete) {
+            backspace();
+            return;
+        }
+        if (input && input >= ' ')
+            append(input);
+    });
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: UI.accent, paddingX: 2, children: [_jsx(Text, { color: UI.title, bold: true, children: '🔐 ' + t('auth.form.title') }), note ? _jsx(Text, { color: UI.dim, children: note }) : null, _jsxs(Box, { marginTop: 1, children: [_jsx(Text, { color: field === 'user' ? UI.accent : UI.dim, children: (field === 'user' ? '❯ ' : '  ') + t('auth.form.login') + ' ' }), _jsx(Text, { color: UI.text, children: user }), field === 'user' ? _jsx(Text, { color: UI.accent, children: "\u258F" }) : null] }), _jsxs(Box, { children: [_jsx(Text, { color: field === 'pass' ? UI.accent : UI.dim, children: (field === 'pass' ? '❯ ' : '  ') + t('auth.form.password') + ' ' }), _jsx(Text, { color: UI.text, children: mask(pass) }), field === 'pass' ? _jsx(Text, { color: UI.accent, children: "\u258F" }) : null] }), error ? (_jsx(Box, { marginTop: 1, children: _jsx(Text, { color: UI.err, children: '⚠ ' + error }) })) : null, _jsx(Box, { marginTop: 1, children: _jsx(HintBar, { hints: [
+                        ['Tab/↑↓', t('auth.form.hint_field')],
+                        ['Enter', t('auth.form.hint_submit')],
+                        ['Esc', t('auth.form.hint_cancel')],
+                    ] }) })] }));
+}

package/dist/tui/SelectList.js

@@ -0,0 +1,54 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// A reusable Ink SELECT LIST — a scrollable, keyboard-navigable list of items
+// with a title and an optional detail/description per row. Used by the model
+// picker and any future list menu (chats, sessions, ...).
+import { useMemo, useState } from 'react';
+import { Box, Text, useInput, useApp, useWindowSize } from 'ink';
+import { UI, HintBar } from './widgets.js';
+export function SelectList({ title, items, initial, onSelect, }) {
+    const { exit } = useApp();
+    const { rows, columns } = useWindowSize();
+    const start = Math.max(0, items.findIndex((it) => it.value === initial));
+    const [cursor, setCursor] = useState(start);
+    const maxRows = Math.max(3, (rows || 24) - 7);
+    // The divider must fit the box: the border (2) + paddingX (2) leave
+    // `cols - 6` usable columns. A hardcoded 40-char rule WRAPPED to a second
+    // row on a narrow terminal and left a ragged edge on a wide one.
+    const innerCols = Math.max(1, (columns || 80) - 6);
+    const win = useMemo(() => {
+        let top = Math.max(0, cursor - maxRows + 1);
+        if (cursor < top)
+            top = cursor;
+        return { top, end: Math.min(items.length, top + maxRows) };
+    }, [cursor, items.length, maxRows]);
+    const finish = (value) => {
+        onSelect(value);
+        exit();
+    };
+    useInput((input, key) => {
+        if (key.escape || (key.ctrl && input === 'c') || input === 'q') {
+            finish(null);
+            return;
+        }
+        if (key.upArrow || input === 'k') {
+            setCursor((c) => items.length ? (c - 1 + items.length) % items.length : 0);
+            return;
+        }
+        if (key.downArrow || input === 'j') {
+            setCursor((c) => (items.length ? (c + 1) % items.length : 0));
+            return;
+        }
+        if (key.return) {
+            finish(items[cursor]?.value ?? null);
+        }
+    });
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: UI.border, paddingX: 1, children: [_jsxs(Box, { justifyContent: "space-between", children: [_jsx(Text, { color: UI.title, bold: true, children: '◆ ' + title }), _jsx(Text, { color: UI.dim, children: items.length })] }), _jsx(Text, { color: "#3a3f4b", children: '─'.repeat(innerCols) }), items.slice(win.top, win.end).map((it, i) => {
+                const idx = win.top + i;
+                const sel = idx === cursor;
+                return (_jsxs(Text, { children: [_jsx(Text, { color: UI.accent, children: sel ? '❯ ' : '  ' }), _jsx(Text, { color: sel ? UI.accent : undefined, bold: sel, children: it.label }), it.detail ? _jsx(Text, { color: UI.dim, children: '  ' + it.detail }) : null] }, it.value));
+            }), _jsx(HintBar, { hints: [
+                    ['↑/↓', 'выбор'],
+                    ['Enter', 'ok'],
+                    ['Esc', 'отмена'],
+                ] })] }));
+}

package/dist/tui/StatusBar.js

@@ -0,0 +1,170 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text, useAnimation, useWindowSize } from 'ink';
+import { translate } from '../i18n.js';
+import { DOTS, stripEllipsis } from '../spinner.js';
+import { truncateToWidth, visLen } from '../input/layout.js';
+/** Elapsed seconds of the current animated phase ("0s", "45s", "2m 05s"). */
+function elapsedLabel(startedAt, animating) {
+    if (!animating || !startedAt)
+        return '';
+    const sec = Math.floor((Date.now() - startedAt) / 1000);
+    const m = Math.floor(sec / 60);
+    const s = sec % 60;
+    const text = m > 0 ? m + 'm ' + String(s).padStart(2, '0') + 's' : s + 's';
+    return ' · ' + text;
+}
+/** Lifecycle prefix, colored by meaning (generating / settled). */
+function stateLabel(state, locale) {
+    if (state.sendState === 'generating') {
+        return translate(locale)('state.generating') + ':';
+    }
+    if (state.sendState === 'settled') {
+        return translate(locale)('state.settled') + ':';
+    }
+    return '';
+}
+/** Visible width of the badge row (used to reserve space for the left
+ *  status). Measured with the shared `visLen` so wide chars (CJK/emoji) count
+ *  as 2 and the emoji's text-presentation selector (\uFE0E) as 0 — a plain
+ *  `.length` counted an emoji as 1 and a CJK badge was clipped on a narrow
+ *  terminal (BACKLOG T0.7). Exported so the width arithmetic is unit-tested
+ *  without rendering. */
+export function badgeTextWidth(state) {
+    let w = 0;
+    if (state.statusLine)
+        w += visLen(state.statusLine) + 1;
+    if (state.provider)
+        w += visLen('[' + state.provider + '] ');
+    if (state.queueLength > 0)
+        w += visLen('⧗' + state.queueLength + ' ');
+    if (state.codeBlocks.length > 0) {
+        const idx = state.codeFocus >= 0 ? state.codeFocus + 1 : state.codeBlocks.length;
+        w += visLen('⌘ ' + idx + '/' + state.codeBlocks.length + ' ');
+    }
+    if (state.tasks)
+        w += visLen(state.tasks) + 1;
+    const toggles = [];
+    if (state.thinkingEnabled)
+        toggles.push('🧠\uFE0E');
+    if (state.searchEnabled)
+        toggles.push('🌐\uFE0E');
+    if (toggles.length)
+        w += visLen(toggles.join(' ') + ' ');
+    if (state.contextText) {
+        const marker = state.contextLevel === 'high'
+            ? '⛔ '
+            : state.contextLevel === 'warn'
+                ? '▲ '
+                : '';
+        w += visLen(marker + state.contextText);
+    }
+    return w;
+}
+/** The badge row: statusLine, provider, queue, tasks, toggles, context.
+ *  `maxWidth` caps the row so it never wraps to a second line; when the badges
+ *  do not fit, the lowest-priority ones (statusLine, then provider) are
+ *  dropped first so the context counter — the most useful — survives. */
+function Badges({ state, budget = Infinity, }) {
+    // Each badge is (node, visible width); lowest-priority first so the context
+    // counter (last) survives when the row is tight.
+    const all = [];
+    const add = (key, w, node) => {
+        all.push({ key, w, node });
+    };
+    if (state.statusLine) {
+        add('sl', visLen(state.statusLine) + 1, _jsxs(Text, { color: "#808896", children: [state.statusLine, ' '] }, "sl"));
+    }
+    if (state.provider) {
+        add('prov', visLen('[' + state.provider + '] '), _jsx(Text, { color: "#808896", children: '[' + state.provider + '] ' }, "prov"));
+    }
+    if (state.queueLength > 0) {
+        add('q', visLen('⧗' + state.queueLength + ' '), _jsxs(Text, { color: "#c9a86a", children: ['⧗' + state.queueLength, ' '] }, "q"));
+    }
+    if (state.codeBlocks.length > 0) {
+        const idx = state.codeFocus >= 0 ? state.codeFocus + 1 : state.codeBlocks.length;
+        const label = '⌘ ' + idx + '/' + state.codeBlocks.length + ' ';
+        add('code', visLen(label), _jsx(Text, { color: "#7fc4f0", children: label }, "code"));
+    }
+    if (state.tasks) {
+        add('t', visLen(state.tasks) + 1, _jsxs(Text, { color: "#808896", children: [state.tasks, ' '] }, "t"));
+    }
+    const toggles = [];
+    if (state.thinkingEnabled)
+        toggles.push('🧠\uFE0E');
+    if (state.searchEnabled)
+        toggles.push('🌐\uFE0E');
+    if (toggles.length) {
+        const label = toggles.join(' ') + ' ';
+        add('tg', visLen(label), _jsx(Text, { color: "#6fd0b0", children: label }, "tg"));
+    }
+    if (state.contextText) {
+        const color = state.contextLevel === 'high'
+            ? '#c98a80'
+            : state.contextLevel === 'warn'
+                ? '#c9a86a'
+                : '#a9c08c';
+        const marker = state.contextLevel === 'high'
+            ? '⛔ '
+            : state.contextLevel === 'warn'
+                ? '▲ '
+                : '';
+        const label = marker + state.contextText;
+        add('ctx', visLen(label), _jsx(Text, { color: color, children: label }, "ctx"));
+    }
+    if (!all.length)
+        return null;
+    // Drop badges from the FRONT (statusLine, provider, ... least important)
+    // until the row fits the budget. Keep at least the last (context).
+    let total = all.reduce((n, b) => n + b.w, 0);
+    let start = 0;
+    while (total > budget && start < all.length - 1) {
+        total -= all[start].w;
+        start++;
+    }
+    return _jsx(_Fragment, { children: all.slice(start).map((b) => b.node) });
+}
+export function StatusBar({ state, divider = true, }) {
+    // Drive the spinner from Ink's shared animation timer (one timer for the
+    // whole tree). The interval matches the old 400ms dot cadence.
+    const animating = state.busy || !!state.animBase;
+    const { frame } = useAnimation({ interval: 400, isActive: animating });
+    const t = translate(state.locale);
+    const stateLbl = stateLabel(state, state.locale);
+    let left;
+    if (state.pendingText) {
+        left = '✎ ' + state.pendingText + '  ·  ' + t('spinner.hint');
+    }
+    else if (state.animBase) {
+        const dots = DOTS[frame % DOTS.length] ?? '';
+        const pad = '   '.slice(dots.length);
+        left =
+            stripEllipsis(state.animBase) +
+                dots +
+                pad +
+                elapsedLabel(state.animStart, animating) +
+                '  ·  ' +
+                t('spinner.hint');
+    }
+    else if (state.statusText) {
+        left = state.statusText;
+    }
+    else {
+        left = '';
+    }
+    const prefix = stateLbl ? stateLbl + ' ' : '';
+    // When the log is scrolled up, show a marker in the status line (NOT as a
+    // separate row below the input — that pushed the panel up and made the input
+    // jump). It replaces the spinner text while scrolled, so it never adds a row.
+    const scrollNote = state.scroll > 0 ? `↑ прокручено на ${state.scroll} стр. · PgDn/End` : '';
+    const leftText = scrollNote || prefix + left;
+    const showLeft = !!leftText;
+    // Keep the row on ONE line. The left status gets at most a third of the
+    // width (it is the least important); the badges take the rest and DROP whole
+    // badges until they fit (the context counter survives longest). Estimating
+    // the badge width for the left budget was circular and let the row overshoot
+    // to a second line on a narrow terminal.
+    const cols = useWindowSize().columns || 80;
+    const leftBudget = Math.max(0, Math.min(Math.floor(cols / 3), cols - 14));
+    const leftOut = showLeft ? truncateToWidth(leftText, leftBudget) : '';
+    return (_jsxs(Box, { flexDirection: "column", children: [divider ? _jsx(Text, { color: "#3a3f4b", children: '─'.repeat(cols) }) : null, _jsxs(Box, { flexDirection: "row", width: Math.max(1, cols - 2), height: 1, children: [_jsx(Text, { color: "#a1723f", children: leftOut || ' ' }), _jsx(Box, { flexGrow: 1 }), _jsx(Badges, { state: state, budget: Math.max(0, cols - 2 - visLen(leftOut)) })] })] }));
+}