zames_pro 2.74.0 → 2.75.0

package/CHANGELOG.md

@@ -7,6 +7,30 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.75.0] - 2026-10-14
+
+### Added
+
+- **tui:** show a one-time hint about mouse selection
+- **tui:** Home/End jump to the top/bottom of the dialog
+- **tui:** mouse wheel scrolls the dialog by default
+
+### Fixed
+
+- **tui:** the status row keeps its height (inline caret on the input row)
+- **tui:** the status bar never wraps to a second line
+- **tui:** the caret lands correctly in a CJK buffer
+- **tui:** responsive dividers and wrapping-aware menu window
+- **tui:** log scroll reads the LIVE offset (no stale closure)
+- **tui:** Ctrl+Delete works (kitty CSI-u) and deletes left at end of line
+- **tui:** the mouse wheel no longer scrolls the input history (for good)
+- **attachments:** keep the items array identity across reset()
+- **tui:** the config menu now redraws on change and fits the terminal
+- **tui:** reserve the real number of rows for a wrapping suggest popup
+- **tui:** exact badge width (T0.7) and honor NO_COLOR (T0.11)
+- **tui:** deliver the FULL pasted text to the agent, not the [Pasted lines#N] marker
+- **tui:** separate SELECT/SCROLL mouse modes and stop the header wrapping the panel
+
 ## [2.74.0] - 2026-10-13
 
 ### Added

package/README.md

@@ -255,6 +255,18 @@ The prompt is a small line editor with persistent history:
   Claude Code's bash mode). The same sandbox guard as the `Bash` tool applies,
   so a direct command cannot leave the project either.
 
+Full-screen mode adds dialog navigation, so a long answer can be read and
+selected without leaving the terminal:
+
+- mouse wheel — scroll the dialog (never the input history; history is arrow
+  keys only). Selecting text needs `Shift`+drag, the standard TUI convention.
+- `PgUp` / `PgDn` — scroll the dialog half a screen.
+- `Home` / `End` — jump to the very top / bottom of the dialog (only while the
+  input line is empty; with text typed they move the caret as usual).
+- To copy a LARGE block, use `/export` (writes the whole session as Markdown)
+  or the transcript file (`/transcript` shows the path) — the terminal's own
+  drag-select cannot reach past one screen.
+
 Set `NO_COLOR=1` to disable colors (a calm default palette is used otherwise).
 
 ### Images and files
@@ -823,6 +835,18 @@ zames
   Claude Code). Действует та же песочница, что и для инструмента `Bash`, так
   что прямая команда тоже не может выйти за пределы проекта.
 
+В полноэкранном режиме добавляется навигация по диалогу, чтобы длинный ответ
+можно было прочитать и выделить не покидая терминал:
+
+- колесо мыши — скролл диалога (историю ввода колесо НЕ листает; история —
+  только стрелки). Выделение текста — `Shift`+протяжка, стандарт TUI.
+- `PgUp` / `PgDn` — листать диалог на пол-экрана.
+- `Home` / `End` — прыжок в самый верх / низ диалога (только когда строка ввода
+  пуста; при набранном тексте они двигают курсор, как обычно).
+- Чтобы скопировать БОЛЬШОЙ кусок, используйте `/export` (пишет всю сессию в
+  Markdown) или файл транскрипта (`/transcript` покажет путь) — собственным
+  выделением терминала за пределы одного экрана не выделить.
+
 Установите `NO_COLOR=1`, чтобы отключить цвета (иначе используется спокойная
 палитра по умолчанию).
 

package/dist/attachments.js

@@ -141,7 +141,12 @@ export class AttachmentStore {
     imageCount = 0;
     fileCount = 0;
     reset() {
-        this.items = [];
+        // Empty IN PLACE: the Ink tree captures `this.items` by reference at mount
+        // (InputLine's `attachments` prop). Reassigning to a new array left the
+        // tree holding the OLD one, so after the first submit every new attachment
+        // was appended to an array the UI no longer read — `onSubmit` got `[]` and
+        // the pasted image/file was silently dropped.
+        this.items.length = 0;
         this.imageCount = 0;
         this.fileCount = 0;
     }

package/dist/config.js

@@ -101,13 +101,13 @@ export const DEFAULTS = {
         // layout, which keeps the scrollback but is subject to reflow artifacts.
         alternateScreen: true,
         // In-app MOUSE-WHEEL scrolling of the log. ON by default: the operator
-        // wants the wheel to scroll the DIALOG. That needs terminal mouse
-        // REPORTING (1000/1006), which in turn means drag-select needs Shift (a
-        // terminal convention: Shift+drag bypasses the app). With this OFF the
-        // app does not enable reporting, and in the alternate screen most
-        // terminals then turn the wheel into Up/Down ARROW keys (DECSET 1007),
-        // which the editor maps to HISTORY — the exact bug reported. So ON is the
-        // only setting where the wheel behaves.
+        // asked that the wheel scroll the DIALOG (and it must NEVER scroll the
+        // input history — history is arrow keys only). That needs terminal mouse
+        // REPORTING (1000/1006) plus alternate-scroll OFF (1007l), so the wheel
+        // arrives as SGR events we consume and never as Up/Down arrows. The
+        // trade-off is that the terminal no longer does its own drag-select, so
+        // selecting text needs SHIFT+DRAG (the standard TUI convention). Set to
+        // false to give the terminal the mouse back (native select, wheel inert).
         mouseScroll: true,
     },
     // Off by default: a full tsc/eslint run after every edit is slow; opt in.

package/dist/i18n/common.js

@@ -64,6 +64,10 @@ export const commonMessages = {
         en: 'Working directory: {v}',
     },
     'msg.transcript': { ru: 'Транскрипт: {v}', en: 'Transcript: {v}' },
+    'msg.mouse_hint': {
+        ru: 'Мышь: колесо листает диалог (история — только стрелки), выделение текста — Shift+протяжка; PgUp/PgDn листают, Home/End — в начало/конец.',
+        en: 'Mouse: the wheel scrolls the dialog (history is arrow keys only), select text with Shift+drag; PgUp/PgDn scroll, Home/End jump to top/bottom.',
+    },
     'msg.new_chat': { ru: 'Создаю новый чат...', en: 'Creating a new chat...' },
     'msg.new_chat_ok': { ru: 'Новый чат.', en: 'New chat.' },
     'msg.resuming': {

package/dist/i18n/help.js

@@ -97,6 +97,14 @@ export const helpMessages = {
         ru: 'Esc, Ctrl+C              прервать текущую генерацию',
         en: 'Esc, Ctrl+C               abort current generation',
     },
+    'help.key.scroll': {
+        ru: 'PgUp / PgDn              листать диалог (Home/End — в начало/конец) [full-screen]',
+        en: 'PgUp / PgDn               scroll the dialog (Home/End — top/bottom) [full-screen]',
+    },
+    'help.key.wheel': {
+        ru: 'колесо мыши               скролл диалога; выделение — Shift+протяжка',
+        en: 'mouse wheel               scroll the dialog; select text with Shift+drag',
+    },
     'help.key.bang': {
         ru: '!команда                  выполнить shell-команду напрямую (мимо модели)',
         en: '!command                  run a shell command directly (bypass the model)',

package/dist/index.js

@@ -437,6 +437,8 @@ ${theme.bold(t('help.while_working'))}
   ${t('help.key.attach')}
   ${t('help.key.esc')}
   ${t('help.key.bang')}
+  ${t('help.key.scroll')}
+  ${t('help.key.wheel')}
 
 ${theme.bold(t('help.commands'))}
 
@@ -1596,6 +1598,13 @@ async function main() {
         };
         try {
             ed.start();
+            // One-time hint so the operator knows how selection works: with wheel
+            // scrolling on (the default) the terminal no longer selects natively, so
+            // a drag needs Shift. Printed ONCE, above the input, in full-screen TUI
+            // only (the legacy editor keeps native selection).
+            if (config.ui.tui && config.ui.alternateScreen) {
+                ed.printAbove(theme.dim(t('msg.mouse_hint')));
+            }
         }
         catch (e) {
             // A TUI mount failure must not kill the agent. We surface it and let the

package/dist/input/suggest.js

@@ -3,7 +3,7 @@
 // editor state: given the buffer text and the command list these decide which
 // commands to show, the visible window, and the Tab completion. Split out
 // (C3) so the fuzzy match can be unit-tested without driving the editor.
-import { SUGGEST_PAGE, isSubsequence } from './layout.js';
+import { SUGGEST_PAGE, isSubsequence, visLen, } from './layout.js';
 /**
  * The commands matching the current buffer. Shown only when the line starts
  * with «/» and is a single short word. The match is fuzzy: an exact prefix
@@ -62,13 +62,28 @@ export function suggestWindow(sugg, offset) {
  * (0 when no list). Full-screen mode uses this to RESERVE space above the
  * input panel so opening the list does not shift the layout (the operator saw
  * the whole screen jump when `/chats` or `/resume` hints appeared).
+ *
+ * With `cols > 0` a row whose label+description is WIDER than the terminal is
+ * counted as the multiple rows it actually wraps to; counting one row per
+ * command under-reserved the panel and the caret drifted on a narrow terminal
+ * (the command list carries descriptions up to ~60 chars).
  */
-export function suggestRowCount(buf, commands) {
+export function suggestRowCount(buf, commands, cols = 0) {
     const sugg = matchSlashCommands(buf, commands);
     if (!sugg.length)
         return 0;
-    const { moreCount } = suggestWindow(sugg, 0);
-    return Math.min(sugg.length, SUGGEST_PAGE) + (moreCount > 0 ? 1 : 0);
+    const { shown, moreCount } = suggestWindow(sugg, 0);
+    const width = Math.max(1, cols);
+    let rows = 0;
+    for (const c of shown) {
+        const label = c.hint ? c.name + ' ' + c.hint : c.name;
+        // 3 = ' ▸ ' prefix, 2 = the gap before the description.
+        const textWidth = 3 + visLen(label) + 2 + visLen(c.description);
+        rows += cols > 0 ? Math.max(1, Math.ceil(textWidth / width)) : 1;
+    }
+    if (moreCount > 0)
+        rows += 1;
+    return rows;
 }
 /**
  * Tab completion. With an explicit selection, insert that command. With a

package/dist/theme.js

@@ -1,5 +1,14 @@
 import chalk from 'chalk';
 import { contentWidth } from './width.js';
+// Respect NO_COLOR (https://no-color.org): when the operator sets it (any
+// non-empty value) drop ALL SGR codes so the output can be piped into a file
+// or a log viewer without escape noise. chalk 5 only auto-detects TTY/CI, it
+// does NOT read NO_COLOR, so the level is set explicitly here — the one place
+// the palette is built, so every consumer (theme, spinner, Ink Text colors
+// that go through chalk) is covered. chalk.level is the documented override.
+if (process.env.NO_COLOR) {
+    chalk.level = 0;
+}
 // A calm palette for a dark terminal.
 // Muted, slightly "faded" tones without high saturation
 // (in the spirit of Tokyo Night / Nord). The goal is comfortable reading of

package/dist/tui/ConfigMenu.js

@@ -47,6 +47,12 @@ export function ConfigMenuApp(opts) {
     const [editBuf, setEditBuf] = useState('');
     const [pendingReset, setPendingReset] = useState(null);
     const [message, setMessage] = useState(null);
+    // `get`/`set` mutate the LIVE config object in place, so React has no state
+    // change to react to and the row kept the OLD value on screen after a
+    // toggle/cycle (the operator saw «ru» while the config already held «en»).
+    // Bump this counter after every mutation to force a re-render.
+    const [version, setVersion] = useState(0);
+    const bump = () => setVersion((v) => v + 1);
     const visible = useMemo(() => {
         const q = filterQuery.trim().toLowerCase();
         if (!q)
@@ -78,6 +84,7 @@ export function ConfigMenuApp(opts) {
         }
         try {
             set(f, raw);
+            bump();
             setMessage(t('cfg.menu.saved', {
                 v: f.path,
                 value: displayValue(f, get(f.path), t),
@@ -93,6 +100,7 @@ export function ConfigMenuApp(opts) {
             return;
         if (f.type === 'boolean') {
             set(f, get(f.path) === true ? 'false' : 'true');
+            bump();
             setMessage(null);
             return;
         }
@@ -112,6 +120,7 @@ export function ConfigMenuApp(opts) {
         const base = idx < 0 ? 0 : idx;
         const next = f.values[(base + dir + f.values.length) % f.values.length];
         set(f, next);
+        bump();
         setMessage(null);
     };
     /** ←/→ acts on the focused row: cycle an enum, toggle a boolean. */
@@ -123,6 +132,7 @@ export function ConfigMenuApp(opts) {
             cycleEnum(f, dir);
         else if (f.type === 'boolean') {
             set(f, get(f.path) === true ? 'false' : 'true');
+            bump();
             setMessage(null);
         }
     };
@@ -229,6 +239,7 @@ export function ConfigMenuApp(opts) {
                 return;
             if (pendingReset === f.path) {
                 reset(f);
+                bump();
                 setMessage(t('cfg.reset', { v: f.path }));
                 setPendingReset(null);
             }
@@ -239,29 +250,51 @@ export function ConfigMenuApp(opts) {
             return;
         }
     });
-    // Windowed list: show a slice around the cursor, accounting for group headers.
+    // Windowed list: show a slice around the cursor. The window is measured in
+    // RENDERED ROWS, not items: each new group adds a header row, AND a label
+    // long enough to wrap takes more than one row. Counting one row per item
+    // let the block grow taller than the terminal and the top border/title
+    // scrolled off ("cut off at the top") on a narrow terminal.
     const termRows = rows || 24;
-    const maxItemRows = Math.max(3, termRows - 6);
+    const maxRows = Math.max(3, termRows - 8);
+    const innerCols = Math.max(1, (columns || 80) - 4);
     const shown = useMemo(() => {
-        // Walk back from the cursor until the window would overflow.
-        let start = Math.min(cursor, Math.max(0, visible.length - 1));
         const groupStart = (i) => i === 0 || visible[i].groupKey !== visible[i - 1].groupKey;
-        const rowsFor = (from) => {
+        // Rendered height of one item: 1 base row + wrapped extra rows. The label
+        // plus the value cell plus the path hint is approximated by the raw label
+        // length; over-estimating is safe (it only shortens the window).
+        const itemRows = (i) => {
+            const f = visible[i];
+            const label = f.labelKey ? t(f.labelKey) : f.path;
+            return Math.max(1, Math.ceil((label.length + 12) / innerCols));
+        };
+        const rowsIn = (a, b) => {
             let r = 0;
-            for (let i = from; i <= cursor; i++) {
-                if (i === from || groupStart(i))
+            for (let i = a; i < b; i++) {
+                if (groupStart(i))
                     r++;
-                r++;
+                r += itemRows(i);
             }
             return r;
         };
-        while (start > 0 && rowsFor(start - 1) <= maxItemRows)
+        if (!visible.length)
+            return { start: 0, end: 0 };
+        let start = cursor;
+        let end = cursor + 1;
+        // Fill downward first, then upward, so the cursor stays visible and the
+        // window uses the whole budget.
+        while (end < visible.length && rowsIn(start, end + 1) <= maxRows)
+            end++;
+        while (start > 0 && rowsIn(start - 1, end) <= maxRows)
             start--;
-        return { start, end: Math.min(visible.length, start + maxItemRows) };
-    }, [cursor, visible, maxItemRows]);
+        return { start, end };
+    }, [cursor, visible, maxRows, innerCols, t]);
     const usable = Math.max(1, (columns || 80) - 1);
     void visCols;
     void usable;
+    // Referenced so the value-cell recompute below depends on the mutation
+    // counter (a pure `get()` call has no reactive dependency of its own).
+    void version;
     const items = [];
     let lastGroup = '';
     for (let i = shown.start; i < shown.end; i++) {

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,7 +62,7 @@ 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 suggestRows = suggestRowCount(state.edit.buf, state.commands, cols);
     const panelRows = HEADER_ROWS + STATUS_ROWS + INPUT_BOX_ROWS + suggestRows;
     const logHeight = Math.max(1, termRows - panelRows);
     // Window the log BY RENDERED ROW: a long wrapped answer can be taller than
@@ -61,21 +74,36 @@ 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, 

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));