zames_pro 2.75.6 → 2.77.0

package/dist/index.js

@@ -530,9 +530,18 @@ async function refreshDynamicCommands(workdir) {
         for (const s of skills) {
             if (!s.userInvokable)
                 continue;
+            // A well-known skill (built-in or bundled methodology) has a localized
+            // description keyed by NAME — its SKILL.md frontmatter is agent-facing
+            // English, which must not leak into a Russian UI. `t` returns the key
+            // itself when it is missing, so an unknown (user-authored) skill falls
+            // back to its own description.
+            const descKey = 'skill.desc.' + s.name;
+            const localized = t(descKey);
             out.push({
                 name: '/' + s.name,
-                description: s.description || t('help.cmd.skill'),
+                description: localized !== descKey
+                    ? localized
+                    : s.description || t('help.cmd.skill'),
             });
         }
         const cmds = await loadCommands(workdir);
@@ -1099,7 +1108,7 @@ async function main() {
                 if (editor)
                     editor.pause();
                 try {
-                    return await askOperatorConfirm(null, t('perm.ask_sub', { tool: info.tool, reason: info.reason }));
+                    return await askOperatorConfirm(null, t('perm.ask_sub', { tool: info.tool, reason: info.reason }), t, currentLocale);
                 }
                 finally {
                     if (editor)
@@ -1901,6 +1910,7 @@ async function main() {
             getDefault: (path) => getByPath(DEFAULTS, path),
             set: (field, raw) => configSetRaw(field, raw),
             reset: (field) => configResetField(field),
+            locale: currentLocale,
         };
         try {
             // Prefer the Ink menu (nicer, resize-aware) when the TUI is enabled;
@@ -1981,6 +1991,7 @@ async function main() {
             const { selectListInk } = await import('./tui/run-select.js');
             picked = await selectListInk({
                 title: t('chats.pick_title'),
+                locale: currentLocale,
                 items: chats.map((c, i) => ({
                     value: c.id,
                     label: String(i + 1).padStart(2, ' ') + '. ' + c.title,
@@ -2014,6 +2025,7 @@ async function main() {
             const { selectListInk } = await import('./tui/run-select.js');
             picked = await selectListInk({
                 title: t('sessions.pick_title'),
+                locale: currentLocale,
                 items: sessions.map((s, i) => ({
                     value: s.id,
                     label: String(i + 1).padStart(2, ' ') +
@@ -2582,8 +2594,9 @@ async function main() {
                             items: models.map((m) => ({
                                 value: m.id,
                                 label: m.name || m.id,
-                                detail: m.id === config.qwen.model ? '← текущая' : m.id,
+                                detail: m.id === config.qwen.model ? t('tui.list.current') : m.id,
                             })),
+                            locale: currentLocale,
                         });
                     }
                     catch {
@@ -2775,6 +2788,13 @@ async function main() {
             const intervalStr = sp === -1 ? rest : rest.slice(0, sp);
             const taskStr = sp === -1 ? '' : rest.slice(sp + 1).trim();
             const ms = parseInterval(intervalStr);
+            if (!ms && intervalStr) {
+                // Say WHY the job was not added. A bare `10` is not a typo the agent
+                // can spot: it IS a valid interval (10 SECONDS), while an operator who
+                // meant ten minutes needs the `m` suffix.
+                console.error(theme.error(t('sched.interval_typo', { v: intervalStr })));
+                continue;
+            }
             if (!ms || !taskStr) {
                 console.error(theme.error(t('sched.loop_usage')));
                 continue;
@@ -2795,6 +2815,12 @@ async function main() {
                 when: formatInterval(ms),
                 task: taskStr,
             })));
+            // Tell the operator WHEN it will actually run. A scheduled task never
+            // interrupts a running turn: it is queued and starts only when the
+            // agent is idle (or right after the current task). The bare "added"
+            // line made a first /loop look like a no-op, so the operator re-sent the
+            // task by hand (the very report this line answers).
+            console.log(theme.dim(t('sched.added_hint')));
             continue;
         }
         if (lower === '/cron' || lower.startsWith('/cron ')) {
@@ -2824,6 +2850,7 @@ async function main() {
                 when: cronExpr + ' (in ~' + nextIn + ')',
                 task: taskStr,
             })));
+            console.log(theme.dim(t('sched.added_hint')));
             continue;
         }
         if (lower === '/jobs' || lower.startsWith('/jobs ')) {
@@ -3289,14 +3316,15 @@ async function main() {
             console.log(theme.system(mod.commands.formatDiff(out, { maxLines: 400 }, t)));
             continue;
         }
-        if (lower === '/diffstat') {
+        if (lower === '/diffstat' || lower.startsWith('/diffstat ')) {
+            const staged = lower.indexOf('--staged') !== -1;
             const { runGitArgs } = await import('./gitTools.js');
             const probe = await runGitArgs(['rev-parse', '--is-inside-work-tree'], currentWorkdir, 5000);
             if (probe.trim() !== 'true') {
                 console.error(theme.error(t('diff.not_repo')));
                 continue;
             }
-            const out = await runGitArgs(['diff', '--stat'], currentWorkdir, 20_000);
+            const out = await runGitArgs(mod.commands.diffStatGitArgs(staged), currentWorkdir, 20_000);
             console.log(theme.system(mod.commands.formatDiffStat(out, { maxLines: 60 }, t)));
             continue;
         }

package/dist/input.js

@@ -1601,7 +1601,13 @@ export class LineEditor {
         // A chunk may end in the MIDDLE of a PASTE marker (`ESC[2`, `ESC[20`, …).
         // Hold that tail back so the next chunk completes it; otherwise the
         // fragment is inserted as literal text and the paste is not bracketed.
-        const held = splitPasteTail(s);
+        // EXCEPTION: once inside a bracketed paste the body is appended VERBATIM
+        // to _pasteBuf (it is not parsed by this loop), so a held tail would be
+        // re-attached to `s` and inserted as text BEFORE the body — the tail
+        // (`1~`) leaked into the input line and was not part of the pasted text.
+        const held = this._inPaste
+            ? { head: s, tail: null }
+            : splitPasteTail(s);
         if (held.tail) {
             this._ctrlTail = held.tail;
             s = held.head;

package/dist/mcp.js

@@ -183,7 +183,15 @@ export function truncateMcpResult(s, limit = MCP_RESULT_LIMIT) {
     const str = String(s);
     if (str.length <= limit)
         return str;
-    const head = str.slice(0, limit);
+    let head = str.slice(0, limit);
+    // Never leave a lone HIGH surrogate at the cut: an emoji / astral CJK char
+    // sits on two UTF-16 units, and cutting between them hands the model a
+    // broken code point (same rule as truncateToolResult / capReport).
+    if (head.length > 0) {
+        const last = head.charCodeAt(head.length - 1);
+        if (last >= 0xd800 && last <= 0xdbff)
+            head = head.slice(0, -1);
+    }
     // Prefer a line boundary so a cut does not split a line in half.
     const nl = head.lastIndexOf(String.fromCharCode(10));
     const cut = nl > limit * 0.5 ? head.slice(0, nl + 1) : head;

package/dist/net-capture.js

@@ -280,6 +280,43 @@ export function extractTokenUsage(body) {
                 }
             }
         }
+        // An OpenAI-compatible body reports the turn size as usage.total_tokens.
+        const usage = o.usage;
+        if (usage && typeof usage === 'object') {
+            consider(usage.total_tokens);
+        }
+    }
+    if (found !== null)
+        return found;
+    // A PLAIN JSON body (not SSE): /api/v0/chat/history_messages answers this
+    // way, and every message carries the running counter. Without this a
+    // resumed chat showed no context size until the next completion. The
+    // payload is the whole history, so the LAST value wins.
+    try {
+        const root = JSON.parse(body);
+        const visit = (node) => {
+            if (node == null || typeof node !== 'object')
+                return;
+            if (Array.isArray(node)) {
+                for (const it of node)
+                    visit(it);
+                return;
+            }
+            const o = node;
+            consider(o.accumulated_token_usage);
+            const usage = o.usage;
+            if (usage && typeof usage === 'object')
+                consider(usage.total_tokens);
+            for (const key of Object.keys(o)) {
+                const v = o[key];
+                if (v && typeof v === 'object')
+                    visit(v);
+            }
+        };
+        visit(root);
+    }
+    catch {
+        // not plain JSON — nothing more to read
     }
     return found;
 }

package/dist/qwen-browser.js

@@ -1396,7 +1396,8 @@ export class QwenBrowser {
                             attempt: rateLimitRetries,
                             max: this.maxRateLimitRetries,
                         }));
-                        await this._sleepInterruptible(this.rateLimitWaitMs);
+                        if (await this._sleepInterruptible(this.rateLimitWaitMs))
+                            return '(прервано пользователем)';
                         continue;
                     }
                     if (e instanceof QwenServerBusyError || /server busy/i.test(msg)) {
@@ -1408,7 +1409,8 @@ export class QwenBrowser {
                             attempt: serverBusyRetries,
                             max: this.maxServerBusyRetries,
                         }));
-                        await this._sleepInterruptible(this.serverBusyWaitMs);
+                        if (await this._sleepInterruptible(this.serverBusyWaitMs))
+                            return '(прервано пользователем)';
                         continue;
                     }
                     if (e instanceof QwenIncompleteError) {
@@ -1419,7 +1421,8 @@ export class QwenBrowser {
                             attempt: incompleteRetries,
                             max: this.maxIncompleteRetries,
                         })));
-                        await this._sleepInterruptible(this.incompleteWaitMs);
+                        if (await this._sleepInterruptible(this.incompleteWaitMs))
+                            return '(прервано пользователем)';
                         continue;
                     }
                     // A LOST page/context ("Target page, context or browser has been

package/dist/qwen-chats.js

@@ -186,10 +186,17 @@ export function parseQwenHistory(json) {
             }
         }
         // `content_list` (phase-split output) is used when `content` is empty.
+        // Each part carries its PHASE, and the reasoning phase must never leak
+        // into the restored dialogue as the answer (the live SSE parser skips
+        // `thinking_summary` for the same reason).
         if (!text && Array.isArray(m.content_list)) {
             for (const part of m.content_list) {
-                if (part && typeof part.content === 'string')
-                    text += part.content;
+                if (!part || typeof part.content !== 'string')
+                    continue;
+                const phase = String(part.phase ?? part.type ?? '');
+                if (/think|reason/i.test(phase))
+                    continue;
+                text += part.content;
             }
         }
         // `reasoning_content` is the THINK phase and must never leak into the

package/dist/run-task.js

@@ -2,12 +2,15 @@ import { theme } from './theme.js';
 import { withGoal, mergeMessages, isSlashCommand, formatDuration, } from './commands.js';
 import { buildEvaluatorPrompt, buildContinuationDirective, parseGoalVerdict, GOAL_MAX_TURNS, } from './goal.js';
 import { formatCompactTokens, pasteReplacement, expandPastes } from './input.js';
+import { DEFAULT_LOCALE } from './i18n.js';
 import { providerAskDeadlineMs } from './config.js';
 // Ask the operator to approve a tool call flagged by an `ask` permission rule
 // (C1). While the LineEditor owns the terminal it must be paused first, or the
 // confirmation prompt and the input line fight for the same keys. A non-TTY run
 // has no way to answer, so it DENIES (never silently allows a guarded call).
-export async function askOperatorConfirm(editor, question, t) {
+export async function askOperatorConfirm(editor, question, t, 
+/** Language of the Ink dialog's key-hint bar (the labels use `t`). */
+locale = DEFAULT_LOCALE) {
     if (!(process.stdin.isTTY && process.stdout.isTTY))
         return false;
     // Prefer the Ink modal when the TUI owns the terminal: it keeps the layout
@@ -23,6 +26,9 @@ export async function askOperatorConfirm(editor, question, t) {
                 message: question,
                 yesLabel: tr('confirm.yes'),
                 noLabel: tr('confirm.no'),
+                // The dialog's key-hint bar is operator text: it must follow the SAME
+                // language as the labels above, not a hardcoded one.
+                locale,
             });
         }
         finally {
@@ -386,7 +392,7 @@ export async function runTask(deps, browser, tools, taskText, workdir, opts, att
                     // C1: a rule with action "ask". Show the reason and wait for the
                     // operator. In non-TTY this denies.
                     ui.warning(t('perm.ask', { tool: info.tool, reason: info.reason }));
-                    const ok = await askOperatorConfirm(editor || null, t('perm.confirm'), t);
+                    const ok = await askOperatorConfirm(editor || null, t('perm.confirm'), t, locale);
                     ui.warning(ok ? t('perm.allowed') : t('perm.denied'));
                     transcript?.log('permission_ask', {
                         tool: info.tool,

package/dist/scheduler.js

@@ -16,8 +16,17 @@ export function parseInterval(text) {
         : unit.startsWith('m')
             ? 60_000
             : 1000;
-    return n * mult;
+    const ms = n * mult;
+    // setInterval clamps its delay to a 32-bit signed int (~24.8 days) and Node
+    // warns on every tick, while the scheduler computes a fire time the timer
+    // can never reach — a huge value is a typo, not a schedule. Reject it here
+    // so the operator gets the usage/typo message instead of a silent dead job.
+    if (ms > MAX_TIMER_MS)
+        return null;
+    return ms;
 }
+/** Largest delay setInterval accepts (32-bit signed milliseconds). */
+export const MAX_TIMER_MS = 2_147_483_647;
 // Render an interval back to the shortest human form (used in listings).
 // Non-finite input (a cron job whose next fire could not be computed sets
 // nextAt to Infinity) renders as "-" instead of "Infinityh".
@@ -53,7 +62,10 @@ function parseCronField(field, min, max) {
         }
         else {
             lo = Number(range);
-            hi = lo;
+            // `N/step` (a start with a step, no range) is valid cron: it means from
+            // N up to the field maximum. Treating it as the single value N made a
+            // normal `5/20 * * * *` expression invalid.
+            hi = stepStr === undefined ? lo : max;
         }
         if (!Number.isInteger(lo) || !Number.isInteger(hi))
             return null;
@@ -128,6 +140,13 @@ export function formatJobLine(job, now) {
     const when = job.kind === 'loop'
         ? 'every ' + formatInterval(job.intervalMs || 0)
         : job.cron || '';
+    // A cron job whose next fire could not be computed stores Infinity (see
+    // due()). "next ~-" (formatInterval maps a non-finite value to '-') read
+    // like a normal schedule, so the job looked healthy while it could never
+    // fire again.
+    if (!Number.isFinite(job.nextAt)) {
+        return '  #' + job.id + ' [' + when + ', NEVER fires again] ' + job.task;
+    }
     const nextIn = formatInterval(Math.max(0, job.nextAt - now));
     return '  #' + job.id + ' [' + when + ', next ~' + nextIn + '] ' + job.task;
 }
@@ -142,7 +161,13 @@ export class Scheduler {
             kind: 'loop',
             task,
             intervalMs,
-            nextAt: now + intervalMs,
+            // The FIRST run is due at once: `/loop 30m <task>` means "start now,
+            // then repeat every 30m". Scheduling the first fire one full interval
+            // ahead left the operator staring at half an hour of silence right
+            // after the command — it read as "the loop did nothing". `due()`
+            // reschedules the job a full interval ahead AFTER it fires, so this
+            // does not become a busy loop.
+            nextAt: now,
             createdAt: now,
         };
         this.jobs.push(job);

package/dist/shell.js

@@ -84,10 +84,18 @@ function formatExecResult(err, stdout, stderr, timeout, okExitCodes) {
     return parts.join('\n');
 }
 export function runShell(workdir, command, timeout = 30_000, signal) {
+    // The timeout arrives from the MODEL's tool arguments, and exec validates it
+    // SYNCHRONOUSLY: a negative, fractional or non-numeric value throws
+    // ERR_OUT_OF_RANGE out of runShell instead of becoming a tool error string.
+    // Normalize it to the unsigned-integer contract (falling back to the
+    // default) so a sloppy call cannot crash the Bash tool.
+    const safeTimeout = typeof timeout === 'number' && Number.isFinite(timeout) && timeout >= 0
+        ? Math.floor(timeout)
+        : 30_000;
     return new Promise((resolve) => {
         const options = {
             cwd: workdir,
-            timeout,
+            timeout: safeTimeout,
             maxBuffer: 1024 * 1024 * 8,
             windowsHide: true,
             env: { ...process.env },
@@ -102,7 +110,7 @@ export function runShell(workdir, command, timeout = 30_000, signal) {
             options.shell = '/bin/sh';
         }
         exec(command, options, (err, stdout, stderr) => {
-            resolve(formatExecResult(err, stdout, stderr, timeout, []));
+            resolve(formatExecResult(err, stdout, stderr, safeTimeout, []));
         });
     });
 }

package/dist/subagent.js

@@ -23,9 +23,16 @@ export const SUBAGENT_REPORT_CAP = 20_000;
 export function capReport(text, cap = SUBAGENT_REPORT_CAP) {
     if (text.length <= cap)
         return text;
-    return (text.slice(0, cap) +
+    // Never split a surrogate PAIR (an emoji / astral CJK char): the high half
+    // alone is a lone surrogate. The report becomes the parent chat's tool
+    // result, so the same rule as truncateToolResult() applies.
+    let cut = cap;
+    const c = text.charCodeAt(cut - 1);
+    if (c >= 0xd800 && c <= 0xdbff)
+        cut--;
+    return (text.slice(0, cut) +
         '\n… [report truncated: ' +
-        (text.length - cap) +
+        (text.length - cut) +
         ' chars omitted]');
 }
 /**
@@ -171,8 +178,14 @@ export function createSubagentRunner(opts) {
             hookOut = await runLifecycleHooks(loadHooks(workdir), 'SubagentStop', workdir, { type: req.type, ok: failed ? 'false' : 'true' });
         }
         catch { }
-        if (failed)
-            return { ok: false, text: failed };
+        // A failed subagent must NOT lose the hook's stdout: a SubagentStop hook
+        // that reports the broken state is most useful exactly when the run died.
+        if (failed) {
+            return {
+                ok: false,
+                text: capReport(hookOut ? failed + '\n\n' + hookOut : failed),
+            };
+        }
         return {
             ok: true,
             text: capReport(hookOut ? report + '\n\n' + hookOut : report),

package/dist/tool-summary.js

@@ -79,5 +79,18 @@ export function looksLikeToolError(result) {
         head.startsWith('missing required argument') ||
         head.startsWith('failed') ||
         head.includes('command failed') ||
-        head.includes('exit code'));
+        head.includes('exit code') ||
+        // NOT every failure is a THROWN error: a PreToolUse hook, the permission
+        // policy and the operator's denial BLOCK the call and return their message
+        // as the result; an unknown tool and an aborted/timed-out run are reported
+        // in words too. Those calls never did their work, so a green check next to
+        // them lied to the operator.
+        head.startsWith('blocked by') ||
+        head.startsWith('denied by') ||
+        head.startsWith('unknown tool') ||
+        head.startsWith('subagents are not available') ||
+        head.startsWith('subagent failed') ||
+        head.startsWith('subagent error') ||
+        head.includes('process killed') ||
+        head.startsWith('(aborted by the operator)'));
 }

package/dist/tui/ConfigMenu.js

@@ -12,6 +12,7 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 // callbacks (the SAME ones the legacy menu takes), so the logic is shared.
 import { useMemo, useState } from 'react';
 import { Box, Text, useInput, useApp, useWindowSize } from 'ink';
+import { translate } from '../i18n.js';
 import { Checkbox, Select, UI, HintBar } from './widgets.js';
 /** Strip ANSI to measure a line's visible width. */
 function stripAnsi(s) {
@@ -37,8 +38,11 @@ function displayValue(field, value, t) {
     return String(value);
 }
 export function ConfigMenuApp(opts) {
-    const { fields, t, get, set, reset, getDefault } = opts;
+    const { fields, t, get, set, reset, getDefault, locale = 'en' } = opts;
     const { exit } = useApp();
+    // The hint bar is operator text: it follows the SAME locale the labels use
+    // (a hardcoded Russian bar showed up in an English UI).
+    const hint = translate(locale);
     const { columns, rows } = useWindowSize();
     const [cursor, setCursor] = useState(0);
     const [filterQuery, setFilterQuery] = useState('');
@@ -327,11 +331,11 @@ export function ConfigMenuApp(opts) {
         items.push(_jsx(Text, { color: UI.dim, children: '  ' + t('cfg.menu.no_match') }, "none"));
     }
     return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: UI.border, paddingX: 1, children: [_jsxs(Box, { justifyContent: "space-between", children: [_jsx(Text, { bold: true, color: UI.title, children: t('cfg.menu.title') }), _jsx(Text, { color: UI.dim, children: (visible.length ? cursor + 1 : 0) + '/' + visible.length })] }), _jsx(Text, { color: "#3a3f4b", children: '─'.repeat(Math.max(10, (columns || 80) - 6)) }), items, _jsx(Text, { color: "#3a3f4b", children: '─'.repeat(Math.max(10, (columns || 80) - 6)) }), editing ? (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: UI.text, children: t('cfg.menu.edit_hint') }), _jsx(Text, { color: UI.accent, children: '❯ ' + editBuf })] })) : filterMode ? (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: UI.text, children: t('cfg.menu.filter_hint') }), _jsx(Text, { color: UI.accent, children: '❯ ' + filterQuery })] })) : message ? (_jsx(Text, { color: UI.ok, children: message })) : filterQuery ? (_jsx(Text, { color: UI.dim, children: t('cfg.menu.filter_active', { q: filterQuery }) })) : null, _jsx(HintBar, { hints: [
-                    ['↑/↓', 'выбор'],
-                    ['←/→', 'изменить'],
-                    ['Enter', 'правка'],
-                    ['/', 'поиск'],
-                    ['d', 'сброс'],
-                    ['q', 'выход'],
+                    ['↑/↓', hint('tui.hint.select')],
+                    ['←/→', hint('tui.hint.change')],
+                    ['Enter', hint('tui.hint.edit')],
+                    ['/', hint('tui.hint.search')],
+                    ['d', hint('tui.hint.reset')],
+                    ['q', hint('tui.hint.quit')],
                 ] })] }));
 }

package/dist/tui/ConfirmDialog.js

@@ -5,14 +5,16 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useState } from 'react';
 import { Box, Text, useInput, useApp } from 'ink';
 import { UI, HintBar } from './widgets.js';
+import { translate } from '../i18n.js';
 function Button({ label, focused, danger, }) {
     const color = danger ? UI.err : UI.on;
     return (_jsxs(Text, { children: [focused ? _jsx(Text, { color: color, children: '▸ ' }) : _jsx(Text, { children: '  ' }), _jsx(Text, { color: focused ? color : UI.dim, bold: focused, children: label })] }));
 }
-export function ConfirmDialog({ title, message, yesLabel, noLabel, onAnswer, }) {
+export function ConfirmDialog({ title, message, yesLabel, noLabel, onAnswer, locale = 'en', }) {
     // Focus starts on "no" — a stray Enter must not confirm a destructive action.
     const [yes, setYes] = useState(false);
     const { exit } = useApp();
+    const t = translate(locale);
     const answer = (ok) => {
         onAnswer(ok);
         exit();
@@ -35,8 +37,8 @@ export function ConfirmDialog({ title, message, yesLabel, noLabel, onAnswer, })
         }
     });
     return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: UI.warn, paddingX: 2, paddingY: 0, children: [_jsx(Text, { color: UI.warn, bold: true, children: '⚠ ' + title }), message ? _jsx(Text, { color: UI.text, children: message }) : null, _jsxs(Box, { marginTop: 1, children: [_jsx(Button, { label: yesLabel, focused: yes, danger: true }), _jsx(Text, { children: '    ' }), _jsx(Button, { label: noLabel, focused: !yes })] }), _jsx(HintBar, { hints: [
-                    ['←/→', 'выбор'],
-                    ['Enter', 'ok'],
+                    ['←/→', t('tui.hint.select')],
+                    ['Enter', t('tui.hint.ok')],
                     ['y/n', ''],
                 ] })] }));
 }

package/dist/tui/SelectList.js

@@ -5,9 +5,11 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 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, }) {
+import { translate } from '../i18n.js';
+export function SelectList({ title, items, initial, locale = 'en', onSelect, }) {
     const { exit } = useApp();
     const { rows, columns } = useWindowSize();
+    const t = translate(locale);
     const start = Math.max(0, items.findIndex((it) => it.value === initial));
     const [cursor, setCursor] = useState(start);
     const maxRows = Math.max(3, (rows || 24) - 7);
@@ -47,8 +49,8 @@ export function SelectList({ title, items, initial, onSelect, }) {
                 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', 'отмена'],
+                    ['↑/↓', t('tui.hint.select')],
+                    ['Enter', t('tui.hint.ok')],
+                    ['Esc', t('tui.hint.cancel')],
                 ] })] }));
 }

package/dist/tui/TuiEditor.js

@@ -254,6 +254,10 @@ export class TuiEditor {
         this.printAbove(theme.userBar('▌ ') +
             theme.user(wrapToWidth(display, contentWidth() - 2)));
         this.store.set({ pastes: [] });
+        // Sending a message pins the log back to the newest content: the operator
+        // expects their message (and the answer) at the BOTTOM, so a viewport left
+        // scrolled-up (PgUp / wheel) must snap to scroll=0 on submit.
+        this.store.set({ scroll: 0 });
         this.onSubmit?.(text, atts);
         if (this.busy)
             this.thinking();

package/dist/tui/edit.js

@@ -82,35 +82,26 @@ export function deleteWordLeft(s) {
     return { ...s, buf: chars.join(''), cursor: i };
 }
 /**
- * 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.
+ * Delete the word on the RIGHT of the cursor (Ctrl+Delete / Alt+Delete):
+ * skip the whitespace after the cursor, then delete up to the end of the next
+ * word — the mirror of deleteWordLeft(). At the end of the line there is
+ * nothing to the right, so the buffer is left UNCHANGED (never a surprise
+ * leftward delete), matching the legacy LineEditor's _deleteWordRight().
  */
 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);
-    }
+    // Stop at a NEWLINE: it is whitespace for /\s/ but must never be swallowed
+    // by a word delete (the old code guarded this; without the guard the key
+    // ate the line break).
     let i = s.cursor;
-    while (i < chars.length && /\s/.test(chars[i]))
+    while (i < chars.length && chars[i] !== NL && /\s/.test(chars[i]))
         i++;
-    while (i < chars.length && !/\s/.test(chars[i]))
+    while (i < chars.length && chars[i] !== NL && !/\s/.test(chars[i]))
         i++;
+    if (i === s.cursor)
+        return s;
     chars.splice(s.cursor, i - s.cursor);
-    return { ...s, buf: chars.join('') };
+    return { ...s, buf: chars.join(''), cursor: s.cursor };
 }
 /** Delete from the cursor to the end of the current LOGICAL line (Ctrl+K). */
 export function killToLineEnd(s) {

package/dist/tui/keys.js

@@ -35,8 +35,8 @@ export function parseCsiU(raw) {
     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' };
+        // Ctrl/Alt+Delete deletes the word on the RIGHT (standard editor binding).
+        return ctrl || alt ? { type: 'deleteWordRight' } : { type: 'delete' };
     }
     if (cp === 127) {
         return ctrl || alt ? { type: 'deleteWordLeft' } : { type: 'backspace' };
@@ -85,11 +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.
+        // Ctrl+Delete deletes the word AFTER the cursor (the standard editor
+        // binding, same as the legacy LineEditor). Ctrl+Backspace deletes the word
+        // BEFORE it. Plain Delete still deletes one char to the right.
         if (key.delete)
-            return { type: 'deleteWordLeft' };
+            return { type: 'deleteWordRight' };
         if (key.backspace)
             return { type: 'deleteWordLeft' };
         if (key.home)
@@ -143,16 +143,16 @@ export function dispatchKey(input, key, ctx, isVisualEdge) {
         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.
+        // Standard editor binding: delete the word AFTER the cursor.
         if (input === 'd')
-            return { type: 'deleteWordLeft' };
+            return { type: 'deleteWordRight' };
         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.
+        // Alt/Ctrl+Delete also deletes the word AFTER the cursor (consistent with
+        // ESC d): some terminals encode Ctrl+Delete as meta+Delete rather than
+        // ESC d.
         if (key.delete)
-            return { type: 'deleteWordLeft' };
+            return { type: 'deleteWordRight' };
         return null;
     }
     // ---- LF as a bare newline (Ctrl+J) ----