zames_pro 2.74.0 → 2.75.1

package/dist/tui/FullScreenApp.js

@@ -18,7 +18,7 @@ import { InputLine } from './InputLine.js';
 import { contentWidth } from '../width.js';
 import { translate } from '../i18n.js';
 import { suggestRowCount } from '../input/suggest.js';
-import { inputBoxRows } from '../input/layout.js';
+import { inputBoxRows, truncateToWidth, visLen } from '../input/layout.js';
 import { useMouseWheel } from './useMouseWheel.js';
 /** The header bar: title, version, working directory. */
 function Header({ store }) {
@@ -28,9 +28,22 @@ function Header({ store }) {
         .filter(Boolean)
         .join(' ');
     const left = '❯ ' + state.title + (state.version ? ' v' + state.version : '');
-    const dir = state.workdir ? '  ' + state.workdir : '';
-    const gap = Math.max(1, cols - left.length - dir.length - right.length - 2);
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: "#c8b06a", bold: true, children: left }), _jsx(Text, { color: "#7fc4f0", children: dir }), _jsx(Text, { children: ' '.repeat(gap) }), right ? _jsx(Text, { color: "#6fd0b0", children: right }) : null] }), _jsx(Text, { color: "#3a3f4b", children: '─'.repeat(cols) })] }));
+    const rawDir = state.workdir ? '  ' + state.workdir : '';
+    // The header MUST stay exactly ONE text row: FullScreenApp reserves
+    // HEADER_ROWS = 2 (title + divider) and the whole panel height is computed
+    // from it. A long working directory used to WRAP the title row at a narrow
+    // terminal (or a deep path), adding a third row the layout did not know
+    // about — Ink then overflowed the fixed `height={termRows}` column and the
+    // TOP input row was clipped (the operator saw the second line overprint the
+    // first). Truncate the directory (then the title) so the row always fits.
+    const gap = Math.max(1, cols - visLen(left) - visLen(rawDir) - visLen(right) - 2);
+    let dir = rawDir;
+    const budget = cols - visLen(left) - visLen(right) - 2;
+    if (visLen(dir) > budget)
+        dir = budget > 0 ? truncateToWidth(dir, budget) : '';
+    // If even title + provider exceed the width, drop the directory entirely.
+    const finalDir = gap >= 1 ? dir : '';
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: "#c8b06a", bold: true, children: left }), _jsx(Text, { color: "#7fc4f0", children: finalDir }), _jsx(Text, { children: ' '.repeat(Math.max(1, cols - visLen(left) - visLen(finalDir) - visLen(right) - 2)) }), right ? _jsx(Text, { color: "#6fd0b0", children: right }) : null] }), _jsx(Text, { color: "#3a3f4b", children: '─'.repeat(cols) })] }));
 }
 export function FullScreenApp({ store, inputProps, }) {
     const state = useSyncExternalStore(store.subscribe, store.getSnapshot);
@@ -49,8 +62,13 @@ export function FullScreenApp({ store, inputProps, }) {
     const INPUT_BOX_ROWS = inputBoxRows(state.prompt, state.edit.buf, state.edit.cursor, cols);
     // The suggestion popup renders ABOVE the input box; reserve its rows so
     // opening the list does not push the panel / shift the whole layout.
-    const suggestRows = suggestRowCount(state.edit.buf, state.commands);
-    const panelRows = HEADER_ROWS + STATUS_ROWS + INPUT_BOX_ROWS + suggestRows;
+    const suggestRows = suggestRowCount(state.edit.buf, state.commands, cols);
+    // A one-line hint UNDER the input box (selection / scroll keys). It is part
+    // of the fixed panel height, so the log viewport shrinks by one row instead
+    // of the panel overflowing; `cursorTop` (measured from the top) is NOT
+    // affected, so the caret cannot move.
+    const HINT_ROWS = 1;
+    const panelRows = HEADER_ROWS + STATUS_ROWS + INPUT_BOX_ROWS + suggestRows + HINT_ROWS;
     const logHeight = Math.max(1, termRows - panelRows);
     // Window the log BY RENDERED ROW: a long wrapped answer can be taller than
     // one entry, and an entry-count window either overflowed the panel or left
@@ -61,25 +79,40 @@ export function FullScreenApp({ store, inputProps, }) {
     const maxScroll = Math.max(0, total - logHeight);
     const scroll = Math.max(0, Math.min(state.scroll, maxScroll));
     const visible = windowByRows(all, logHeight, scroll, cols);
-    // Scroll the log with PgUp/PgDn.
+    // Scroll the log with PgUp/PgDn; Home/End jump to the very top/bottom. The
+    // input line OWNS Home/End while its buffer is non-empty (they move the
+    // caret), so the jump only applies to an EMPTY buffer — which is exactly
+    // when the operator is navigating the log to select a large block.
+    //
+    // `useInput` binds the callback ONCE, so a `scroll` captured in the closure
+    // goes STALE after the first scroll (PgUp/PgDn/Home/End then compute from an
+    // old offset and jump wrong). Read the live value from the store instead.
     useInput((_input, key) => {
         const step = Math.max(1, Math.floor(logHeight / 2));
+        const cur = store.getSnapshot().scroll;
         if (key.pageUp) {
-            store.set({ scroll: Math.min(maxScroll, scroll + step) });
+            store.set({ scroll: Math.min(maxScroll, cur + step) });
         }
         else if (key.pageDown) {
-            store.set({ scroll: Math.max(0, scroll - step) });
+            store.set({ scroll: Math.max(0, cur - step) });
+        }
+        else if (state.edit.buf.length === 0 && (key.home || key.end)) {
+            // Both the bare and the Ctrl-modified forms land here (Ink sets
+            // key.end / key.home for either), so Ctrl+End / Ctrl+Home are a
+            // reliable fallback on terminals that swallow the bare keys.
+            store.set({ scroll: key.home ? maxScroll : 0 });
         }
     });
     // Scroll the log with the MOUSE WHEEL. Ink does not parse mouse events, so
     // useMouseWheel reads the raw SGR sequences (see the hook). One wheel notch
     // scrolls ~3 rows, like most terminals.
     useMouseWheel((delta) => {
-        const next = scroll + delta * 3;
+        const cur = store.getSnapshot().scroll;
+        const next = cur + delta * 3;
         store.set({ scroll: Math.max(0, Math.min(maxScroll, next)) });
     }, state.mouseScroll);
     return (_jsxs(Box, { flexDirection: "column", height: termRows, children: [_jsx(Header, { store: store }), _jsx(Box, { flexDirection: "column", height: logHeight, overflow: "hidden", justifyContent: "flex-end", children: all.length === 0 ? (_jsx(Text, { color: "#5b616e", children: translate(state.locale)('editor.empty_hint') })) : (_jsx(LogList, { entries: visible })) }), _jsx(StatusBar, { state: state, divider: false }), _jsx(InputLine, { ...inputProps, store: store, 
                 // Cursor rows above the input box: header + log viewport + status.
-                cursorTop: HEADER_ROWS + logHeight + suggestRows + STATUS_ROWS + 1, prompt: state.prompt, locale: state.locale, commands: state.commands, locked: state.locked })] }));
+                cursorTop: HEADER_ROWS + logHeight + suggestRows + STATUS_ROWS + 1, prompt: state.prompt, locale: state.locale, commands: state.commands, locked: state.locked }), _jsx(Text, { color: "#5b616e", wrap: "truncate", children: ' ' + translate(state.locale)('editor.keys_hint') })] }));
 }
 void contentWidth;

package/dist/tui/InputLine.js

@@ -8,12 +8,12 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 // 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, useMemo, useRef, useState } from 'react';
-import { Box, Text, useInput, usePaste, useCursor, useWindowSize } from 'ink';
+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, visLen, charWidth, SUGGEST_PAGE, } from '../input/layout.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 } from './keys.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. */
@@ -69,9 +69,13 @@ export function InputLine(props) {
         const withHist = recordHistory(s, s.buf);
         const next = afterSubmit(withHist);
         setSt(next);
-        props.onPastesChange(next.pastes);
         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();
@@ -224,6 +228,11 @@ export function InputLine(props) {
         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) {
@@ -248,6 +257,37 @@ export function InputLine(props) {
     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
@@ -255,13 +295,15 @@ export function InputLine(props) {
     //   row 2            = input box TOP border
     //   rows 3..         = input rows
     const cursorRow = lay.cursorRow;
-    const rowText = lay.rows[cursorRow]?.text ?? '';
     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.
-    2 +
-        visLen(lay.rows[cursorRow]?.prefix ?? '') +
-        colWidth(rowText, lay.cursorCol - visLen(lay.rows[cursorRow]?.prefix ?? ''));
+    // 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);
@@ -274,12 +316,3 @@ export function InputLine(props) {
                             '  ' +
                             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 }) })] }));
 }
-/** Visible width of the first `col` code points of `text` (wide chars = 2). */
-function colWidth(text, col) {
-    const chars = Array.from(text);
-    let w = 0;
-    for (let i = 0; i < col && i < chars.length; i++) {
-        w += charWidth(chars[i].codePointAt(0));
-    }
-    return Math.max(0, w);
-}

package/dist/tui/SelectList.js

@@ -7,10 +7,14 @@ 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 } = useWindowSize();
+    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)
@@ -38,7 +42,7 @@ export function SelectList({ title, items, initial, onSelect, }) {
             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(40) }), items.slice(win.top, win.end).map((it, i) => {
+    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));

package/dist/tui/StatusBar.js

@@ -1,8 +1,8 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+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 } from '../input/layout.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)
@@ -24,50 +24,69 @@ function stateLabel(state, locale) {
     return '';
 }
 /** Visible width of the badge row (used to reserve space for the left
- *  status). An emoji is counted as 2 columns; the rest as 1. Approximation is
- *  fine — the goal is only to avoid clipping the badges. */
-function badgeTextWidth(state) {
+ *  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 += state.statusLine.length + 1;
+        w += visLen(state.statusLine) + 1;
     if (state.provider)
-        w += state.provider.length + 3;
+        w += visLen('[' + state.provider + '] ');
     if (state.queueLength > 0)
-        w += 2 + String(state.queueLength).length;
-    if (state.codeBlocks.length > 0)
-        w += 8;
+        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 += state.tasks.length + 1;
+        w += visLen(state.tasks) + 1;
+    const toggles = [];
     if (state.thinkingEnabled)
-        w += 3;
+        toggles.push('🧠\uFE0E');
     if (state.searchEnabled)
-        w += 3;
+        toggles.push('🌐\uFE0E');
+    if (toggles.length)
+        w += visLen(toggles.join(' ') + ' ');
     if (state.contextText) {
-        const marker = state.contextLevel === 'high' ? 2 : state.contextLevel === 'warn' ? 2 : 0;
-        w += state.contextText.length + marker;
+        const marker = state.contextLevel === 'high'
+            ? '⛔ '
+            : state.contextLevel === 'warn'
+                ? '▲ '
+                : '';
+        w += visLen(marker + state.contextText);
     }
     return w;
 }
-/** The badge row: statusLine, provider, queue, tasks, toggles, context. */
-function Badges({ state }) {
-    const parts = [];
+/** 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) {
-        parts.push(_jsxs(Text, { color: "#808896", children: [state.statusLine, ' '] }, "sl"));
+        add('sl', visLen(state.statusLine) + 1, _jsxs(Text, { color: "#808896", children: [state.statusLine, ' '] }, "sl"));
     }
     if (state.provider) {
-        parts.push(_jsx(Text, { color: "#808896", children: '[' + state.provider + '] ' }, "prov"));
+        add('prov', visLen('[' + state.provider + '] '), _jsx(Text, { color: "#808896", children: '[' + state.provider + '] ' }, "prov"));
     }
     if (state.queueLength > 0) {
-        parts.push(_jsxs(Text, { color: "#c9a86a", children: ['⧗' + state.queueLength, ' '] }, "q"));
+        add('q', visLen('⧗' + state.queueLength + ' '), _jsxs(Text, { color: "#c9a86a", children: ['⧗' + state.queueLength, ' '] }, "q"));
     }
     if (state.codeBlocks.length > 0) {
-        // A hint that the last answer has copyable code: Ctrl+Y copies the last
-        // block (or the focused one), like a copy button in a GUI chat.
         const idx = state.codeFocus >= 0 ? state.codeFocus + 1 : state.codeBlocks.length;
-        parts.push(_jsx(Text, { color: "#7fc4f0", children: '⌘ ' + idx + '/' + state.codeBlocks.length + ' ' }, "code"));
+        const label = '⌘ ' + idx + '/' + state.codeBlocks.length + ' ';
+        add('code', visLen(label), _jsx(Text, { color: "#7fc4f0", children: label }, "code"));
     }
     if (state.tasks) {
-        parts.push(_jsxs(Text, { color: "#808896", children: [state.tasks, ' '] }, "t"));
+        add('t', visLen(state.tasks) + 1, _jsxs(Text, { color: "#808896", children: [state.tasks, ' '] }, "t"));
     }
     const toggles = [];
     if (state.thinkingEnabled)
@@ -75,7 +94,8 @@ function Badges({ state }) {
     if (state.searchEnabled)
         toggles.push('🌐\uFE0E');
     if (toggles.length) {
-        parts.push(_jsx(Text, { color: "#6fd0b0", children: toggles.join(' ') + ' ' }, "tg"));
+        const label = toggles.join(' ') + ' ';
+        add('tg', visLen(label), _jsx(Text, { color: "#6fd0b0", children: label }, "tg"));
     }
     if (state.contextText) {
         const color = state.contextLevel === 'high'
@@ -88,11 +108,20 @@ function Badges({ state }) {
             : state.contextLevel === 'warn'
                 ? '▲ '
                 : '';
-        parts.push(_jsx(Text, { color: color, children: marker + state.contextText }, "ctx"));
+        const label = marker + state.contextText;
+        add('ctx', visLen(label), _jsx(Text, { color: color, children: label }, "ctx"));
     }
-    if (!parts.length)
+    if (!all.length)
         return null;
-    return _jsx(Box, { children: parts });
+    // 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
@@ -129,12 +158,13 @@ export function StatusBar({ state, divider = true, }) {
     const scrollNote = state.scroll > 0 ? `↑ прокручено на ${state.scroll} стр. · PgDn/End` : '';
     const leftText = scrollNote || prefix + left;
     const showLeft = !!leftText;
-    // Keep the badge row visible: the left status truncates to whatever space is
-    // left after the badges, instead of pushing them off the right edge (they
-    // used to be clipped: "[DeepSee⧗1 задачи: 3/...").
+    // 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 badgeWidth = badgeTextWidth(state);
-    const maxLeft = Math.max(0, cols - badgeWidth - 2);
-    const leftOut = showLeft ? truncateToWidth(leftText, maxLeft) : '';
-    return (_jsxs(Box, { flexDirection: "column", children: [divider ? _jsx(Text, { color: "#3a3f4b", children: '─'.repeat(cols) }) : null, _jsxs(Box, { justifyContent: "space-between", children: [_jsx(Box, { children: leftOut ? _jsx(Text, { color: "#a1723f", children: leftOut }) : _jsx(Text, { children: " " }) }), _jsx(Badges, { state: state })] })] }));
+    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)) })] })] }));
 }

package/dist/tui/TuiApp.js

@@ -9,7 +9,7 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 // (never repainted), the bottom section re-renders as state changes, so the
 // input stays pinned at the bottom while answers scroll up into scrollback.
 import React, { useSyncExternalStore } from 'react';
-import { Box } from 'ink';
+import { Box, useWindowSize } from 'ink';
 import { LogView } from './LogView.js';
 import { StatusBar } from './StatusBar.js';
 import { InputLine } from './InputLine.js';
@@ -23,6 +23,7 @@ export function TuiApp({ store, inputProps, initialPrintedCount = 0, }) {
     // + the suggestion popup (which renders above the box and would otherwise
     // shift the caret down by its row count). Without the suggestRows term the
     // caret drifted whenever the «/» list opened.
-    const suggestRows = suggestRowCount(state.edit.buf, state.commands);
+    const cols = useWindowSize().columns || 80;
+    const suggestRows = suggestRowCount(state.edit.buf, state.commands, cols);
     return (_jsxs(Box, { flexDirection: "column", children: [_jsx(LogView, { entries: entries }), _jsx(StatusBar, { state: state }), _jsx(InputLine, { ...inputProps, store: store, prompt: state.prompt, locale: state.locale, commands: state.commands, locked: state.locked, cursorTop: 3 + suggestRows })] }));
 }

package/dist/tui/TuiEditor.js

@@ -1,4 +1,20 @@
 import { jsx as _jsx } from "react/jsx-runtime";
+// TuiEditor — a drop-in replacement for the hand-rolled LineEditor backed by an
+// Ink/React render tree.
+//
+// WHY an adapter and not a rewrite of index.ts:
+//   * index.ts (4200 lines) and run-task.ts call the UI through a large but
+//     STABLE imperative surface (`printAbove`, `lock`, `toolCall`, `busy`, ...);
+//   * Ink renders from React state, which can only be driven from inside the
+//     tree. The adapter is the seam: it implements the SAME surface and forwards
+//     every call into the TuiStore, which the tree subscribes to.
+// So the rest of the agent is unchanged; only the rendering engine differs.
+//
+// Lifecycle: `start()` mounts the Ink app; `dispose()` unmounts it. A `pause()`
+// /`resume()` pair suspends the tree for a foreign full-screen UI (the config
+// menu) — implemented as unmount/remount so the foreign program owns the
+// terminal cleanly.
+import fs from 'node:fs';
 import { render } from 'ink';
 import { TuiStore } from './store.js';
 import { TuiApp } from './TuiApp.js';
@@ -126,6 +142,26 @@ export class TuiEditor {
             alternateScreen: this.alternateScreen,
         });
         this.rendered = true;
+        // DEV DIAGNOSTIC: dump every raw stdin chunk to a file so a terminal's
+        // key encoding (e.g. Ctrl+Delete = ESC d in VSCode) can be captured from
+        // the LIVE agent, not guessed. Off unless ZAMES_TUI_KEY_DEBUG names a
+        // file.
+        const keyDbg = process.env.ZAMES_TUI_KEY_DEBUG;
+        if (keyDbg) {
+            process.stdin.on('data', (d) => {
+                try {
+                    fs.appendFileSync(keyDbg, new Date().toISOString() +
+                        ' ' +
+                        d.toString('hex') +
+                        ' ' +
+                        JSON.stringify(d.toString('utf-8')) +
+                        String.fromCharCode(10));
+                }
+                catch {
+                    /* ignore */
+                }
+            });
+        }
         this.installResizeHandler();
         // Entries shown so far are now on screen; a later remount must not reprint
         // them.
@@ -453,9 +489,9 @@ export class TuiEditor {
             return false;
         }
         const pick = typeof index === 'number'
-            ? blocks.find((b) => b.index === index) ?? null
+            ? (blocks.find((b) => b.index === index) ?? null)
             : snap.codeFocus >= 0
-                ? blocks[snap.codeFocus] ?? null
+                ? (blocks[snap.codeFocus] ?? null)
                 : blocks[blocks.length - 1];
         if (!pick) {
             this.printAbove(theme.warn(translate(this.locale)('copy.bad_index', { n: String(index) })));
@@ -464,10 +500,14 @@ export class TuiEditor {
         const res = this.onCopyText?.(pick.text) ?? { ok: false, via: 'none' };
         const label = 'code #' + pick.index + (pick.lang ? ' (' + pick.lang + ')' : '');
         if (res.ok) {
-            this.printAbove(theme.assistant(translate(this.locale)('copy.done', { tool: res.via }) + ' — ' + label));
+            this.printAbove(theme.assistant(translate(this.locale)('copy.done', { tool: res.via }) +
+                ' — ' +
+                label));
         }
         else {
-            this.printAbove(theme.warn(translate(this.locale)('copy.failed', { tool: res.via }) + ' — ' + label));
+            this.printAbove(theme.warn(translate(this.locale)('copy.failed', { tool: res.via }) +
+                ' — ' +
+                label));
         }
         return res.ok;
     }

package/dist/tui/edit.js

@@ -81,9 +81,29 @@ export function deleteWordLeft(s) {
     chars.splice(i, s.cursor - i);
     return { ...s, buf: chars.join(''), cursor: i };
 }
-/** Delete the word on the RIGHT of the cursor (Ctrl+Delete / Alt+Delete). */
+/**
+ * Delete the word on the RIGHT of the cursor (Ctrl+Delete / Alt+Delete).
+ *
+ * FALLBACK: at the END of the line there is no word to the right, so the key
+ * did NOTHING and the operator (whose terminal sends the standard xterm
+ * Ctrl+Delete) read it as "Ctrl+Delete does not delete the word before the
+ * cursor". Deleting the word on the LEFT there matches what other terminal
+ * editors do and what the operator expects, while keeping the standard
+ * right-delete when the cursor is mid-line.
+ */
 export function deleteWordRight(s) {
     const chars = charsOf(s);
+    // Nothing to the right (end of buffer or only whitespace to the newline):
+    // delete the word on the LEFT instead of doing nothing.
+    let probe = s.cursor;
+    while (probe < chars.length &&
+        chars[probe] !== NL &&
+        /\s/.test(chars[probe])) {
+        probe++;
+    }
+    if (probe >= chars.length || chars[probe] === NL) {
+        return deleteWordLeft(s);
+    }
     let i = s.cursor;
     while (i < chars.length && /\s/.test(chars[i]))
         i++;

package/dist/tui/keys.js

@@ -9,6 +9,40 @@
 // Kept free of React/Ink runtime imports beyond the Key TYPE, so it is
 // unit-testable.
 const LF = String.fromCharCode(10);
+/**
+ * Ctrl/Alt + named keys under the KITTY keyboard protocol (CSI-u). Ink's
+ * `parseKeypress` recognizes the MODIFIED ARROW forms but returns `name=''`
+ * for the modified Delete/Backspace codepoints (CSI 3;5u, 127;5u, ...), so
+ * `useInput` yields an empty input/name and the binding never fires — the
+ * operator's "Ctrl+Delete does nothing". The legacy LineEditor parsed these
+ * bytes itself; the TUI reads them from raw stdin (Ink hides `sequence`) and
+ * maps the known ones to the SAME actions so both editors behave alike.
+ *
+ * Returns null when the string is not one of these sequences. Pure + exported
+ * for tests.
+ */
+export function parseCsiU(raw) {
+    // CSI codepoint ; modifier [: eventType] u — e.g. ESC[3;5u (Ctrl+Delete),
+    // ESC[127;5u (Ctrl+Backspace), ESC[3u (plain Delete),
+    // ESC[127u (plain Backspace), ESC[13;5u (Ctrl+Enter).
+    const m = /^\u001b\[(\d+)(?:;(\d+))?(?::\d+)?u$/.exec(raw);
+    if (!m)
+        return null;
+    const cp = Number(m[1]);
+    const mod = m[2] ? Number(m[2]) - 1 : 0;
+    const ctrl = (mod & 4) !== 0;
+    const alt = (mod & 2) !== 0;
+    if (cp === 13 && (ctrl || alt))
+        return { type: 'newline' };
+    if (cp === 3) {
+        // Ctrl/Alt+Delete deletes the word on the LEFT (see dispatchKey).
+        return ctrl || alt ? { type: 'deleteWordLeft' } : { type: 'delete' };
+    }
+    if (cp === 127) {
+        return ctrl || alt ? { type: 'deleteWordLeft' } : { type: 'backspace' };
+    }
+    return null;
+}
 /**
  * Map a normalized Ink keypress to an editor action.
  *
@@ -51,8 +85,11 @@ export function dispatchKey(input, key, ctx, isVisualEdge) {
             return { type: 'wordLeft' };
         if (key.rightArrow)
             return { type: 'wordRight' };
+        // Ctrl+Delete deletes the word BEFORE the cursor (the operator's binding:
+        // "Ctrl+Del must delete the word before the cursor"). Ctrl+Backspace does
+        // the same. Plain Delete still deletes one char to the RIGHT.
         if (key.delete)
-            return { type: 'deleteWordRight' };
+            return { type: 'deleteWordLeft' };
         if (key.backspace)
             return { type: 'deleteWordLeft' };
         if (key.home)
@@ -107,10 +144,17 @@ export function dispatchKey(input, key, ctx, isVisualEdge) {
             return { type: 'wordLeft' };
         if (input === 'f')
             return { type: 'wordRight' };
+        // VSCode sends Ctrl+Delete as `ESC d` (which Ink reports as Alt+d).
+        // The operator expects it to delete the word BEFORE the cursor.
+        if (input === 'd')
+            return { type: 'deleteWordLeft' };
         if (key.backspace)
             return { type: 'deleteWordLeft' };
+        // Alt/Ctrl+Delete also deletes the word BEFORE the cursor (the operator's
+        // binding, consistent with ESC d): some terminals encode Ctrl+Delete as
+        // meta+Delete rather than ESC d.
         if (key.delete)
-            return { type: 'deleteWordRight' };
+            return { type: 'deleteWordLeft' };
         return null;
     }
     // ---- LF as a bare newline (Ctrl+J) ----

package/dist/tui/store.js

@@ -40,7 +40,7 @@ function initialState() {
         queueLength: 0,
         tasks: '',
         provider: '',
-        mouseScroll: false,
+        mouseScroll: true,
         thinkingEnabled: false,
         searchEnabled: false,
         statusLine: '',