zames_pro 2.50.1 → 2.51.0

package/dist/commands.js

@@ -1,29 +1,26 @@
 import path from 'path';
 import { isImageName } from './attachments.js';
+import { translate } from './i18n.js';
 // Helpers for the extra slash commands (/diff, /cost, /export, /doctor,
 // /permissions, /review, /add-dir). Pure functions, unit-tested without a
 // live agent/browser. index.ts only renders their output.
 const NL = String.fromCharCode(10);
 const CR = String.fromCharCode(13);
 // ---------- /diff ----------
-export function formatDiff(diffText, opts = {}) {
+export function formatDiff(diffText, opts = {}, t = translate('en')) {
     const maxLines = opts.maxLines ?? 200;
     const trimmed = String(diffText ?? '')
         .split(CR + NL)
         .join(NL)
         .trimEnd();
     if (!trimmed)
-        return '(no changes)';
+        return t('diff.no_changes');
     const lines = trimmed.split(NL);
     if (lines.length <= maxLines)
         return trimmed;
     const head = lines.slice(0, maxLines).join(NL);
     const rest = lines.length - maxLines;
-    return (head +
-        NL +
-        '... [' +
-        rest +
-        ' more lines, use Bash git diff for the full output]');
+    return head + NL + t('diff.more_lines', { n: String(rest) });
 }
 export function diffGitArgs(staged = false) {
     return staged ? 'git diff --staged' : 'git diff';
@@ -89,30 +86,30 @@ export function formatDuration(ms, units = EN_DURATION_UNITS) {
         return m + units.m + ' ' + pad(s) + units.s;
     return s + units.s;
 }
-export function renderCost(stats, transcriptFile, tokenUsage = null) {
+export function renderCost(stats, transcriptFile, tokenUsage = null, t = translate('en')) {
     const lines = [];
-    lines.push('Session stats:');
+    lines.push(t('cost.title'));
     if (typeof tokenUsage === 'number') {
-        lines.push(' context: ~' + tokenUsage + ' tokens (DeepSeek accumulated_token_usage)');
+        lines.push(t('cost.context_known', { n: String(tokenUsage) }));
     }
     else {
-        lines.push(' context: unknown (DeepSeek reports it after the first answer in a chat)');
+        lines.push(t('cost.context_unknown'));
     }
-    lines.push(' tasks: ' + stats.turns);
-    lines.push(' tool calls: ' + stats.toolCalls);
+    lines.push(t('cost.tasks', { n: String(stats.turns) }));
+    lines.push(t('cost.tool_calls', { n: String(stats.toolCalls) }));
     if (stats.autoCompacts > 0) {
-        lines.push(' auto-compacts: ' + stats.autoCompacts);
+        lines.push(t('cost.auto_compacts', { n: String(stats.autoCompacts) }));
     }
     const top = Object.entries(stats.toolCounts).sort((a, b) => b[1] - a[1]);
     if (top.length) {
-        lines.push(' by tool:');
+        lines.push(t('cost.by_tool'));
         for (const [name, n] of top)
             lines.push(' ' + name + ': ' + n);
     }
-    lines.push(' duration: ' + formatDuration(stats.durationMs));
+    lines.push(t('cost.duration', { dur: formatDuration(stats.durationMs) }));
     if (stats.startedAt)
-        lines.push(' started: ' + stats.startedAt);
-    lines.push(' transcript: ' + (transcriptFile || '(off)'));
+        lines.push(t('cost.started', { v: stats.startedAt }));
+    lines.push(t('cost.transcript', { v: transcriptFile || t('cost.off') }));
     return lines.join(NL);
 }
 // ---------- /export ----------
@@ -172,64 +169,74 @@ export function defaultExportPath(workdir, now = new Date()) {
         .replace('Z', '');
     return path.join(workdir, 'zames-export-' + stamp + '.md');
 }
-export function renderDoctor(d) {
+export function renderDoctor(d, t = translate('en')) {
     const rows = [];
     const row = (ok, label, value) => {
         rows.push(' ' + (ok ? '[OK] ' : '[WARN]') + ' ' + label.padEnd(16) + ' ' + value);
     };
+    const onoff = (b) => (b ? t('common.on') : t('common.off'));
     row(true, 'node', d.nodeVersion);
     row(true, 'platform', d.platform);
     row(true, 'workdir', d.workdir);
-    row(d.gitOk, 'git', d.gitOk ? 'repo (' + (d.gitBranch || 'detached') + ')' : 'not a repository');
-    row(d.configOk, 'config', d.configOk ? 'loaded' : 'error: ' + (d.configError || 'unknown'));
-    row(true, 'browser', d.browserChannel ? d.browserChannel : 'bundled chromium');
-    row(!!d.authSaved, 'auth', d.authSaved ? 'session saved (auto re-login ready)' : 'no saved session');
-    row(!!d.clipboardTool, 'clipboard', d.clipboardTool || 'no tool found (image paste disabled)');
-    row(true, 'mcp', d.mcpServers + ' server(s), ' + d.mcpTools + ' tool(s)');
-    row(d.transcriptOk, 'transcript', d.transcriptOk ? 'on' : 'off');
+    row(d.gitOk, 'git', d.gitOk
+        ? t('doctor.repo', { v: d.gitBranch || t('doctor.detached') })
+        : t('doctor.not_repo'));
+    row(d.configOk, 'config', d.configOk
+        ? t('doctor.loaded')
+        : t('doctor.error', { v: d.configError || t('doctor.unknown') }));
+    row(true, 'browser', d.browserChannel ? d.browserChannel : t('doctor.bundled'));
+    row(!!d.authSaved, 'auth', d.authSaved ? t('doctor.auth_saved') : t('doctor.auth_none'));
+    row(!!d.clipboardTool, 'clipboard', d.clipboardTool || t('doctor.clipboard_none'));
+    row(true, 'mcp', t('doctor.mcp', {
+        servers: String(d.mcpServers),
+        tools: String(d.mcpTools),
+    }));
+    row(d.transcriptOk, 'transcript', onoff(d.transcriptOk));
     if (typeof d.contextLimit === 'number' && d.contextLimit > 0) {
-        row(true, 'context', d.contextLimit.toLocaleString('en-US') + ' tokens');
+        row(true, 'context', t('doctor.tokens', {
+            v: d.contextLimit.toLocaleString('en-US'),
+        }));
     }
     if (d.gitOk && typeof d.hasOrigin === 'boolean') {
-        row(true, 'git remote', d.hasOrigin ? 'origin configured' : 'no origin');
+        row(true, 'git remote', d.hasOrigin ? t('doctor.origin_ok') : t('doctor.origin_none'));
     }
     if (typeof d.minSendIntervalMs === 'number') {
-        row(d.minSendIntervalMs > 0, 'send pause', Math.round(d.minSendIntervalMs / 1000) + 's between agent sends');
+        row(d.minSendIntervalMs > 0, 'send pause', t('doctor.send_pause', {
+            n: String(Math.round(d.minSendIntervalMs / 1000)),
+        }));
     }
     if (typeof d.sshRemote === 'boolean') {
-        row(true, 'session', d.sshRemote ? 'SSH remote' : 'local terminal');
+        row(true, 'session', d.sshRemote ? t('doctor.ssh') : t('doctor.local'));
     }
     if (d.headless) {
-        row(!!d.headlessUaCached, 'headless', d.headlessUaCached
-            ? 'UA cached (no relaunch)'
-            : 'no cached UA yet (first start relaunches once)');
+        row(!!d.headlessUaCached, 'headless', d.headlessUaCached ? t('doctor.ua_cached') : t('doctor.ua_not_cached'));
     }
-    return 'Doctor:' + NL + rows.join(NL);
+    return t('doctor.title') + NL + rows.join(NL);
 }
-export function renderPermissions(p) {
-    const onoff = (b) => (b ? 'ask' : 'allow');
+export function renderPermissions(p, t = translate('en')) {
+    const onoff = (b) => (b ? t('perm.ask') : t('perm.allow'));
     const lines = [];
-    lines.push('Tool permissions (confirmation settings):');
-    lines.push(' Write: ' + onoff(p.write));
-    lines.push(' Edit: ' + onoff(p.edit));
-    lines.push(' Bash: ' + onoff(p.bash));
+    lines.push(t('perm.title'));
+    lines.push(t('perm.write', { v: onoff(p.write) }));
+    lines.push(t('perm.edit', { v: onoff(p.edit) }));
+    lines.push(t('perm.bash', { v: onoff(p.bash) }));
     if (p.alwaysConfirm.length) {
-        lines.push(' Always confirm (regex):');
+        lines.push(t('perm.always'));
         for (const re of p.alwaysConfirm)
             lines.push(' ' + re);
     }
     lines.push('');
-    lines.push('Change with: /config set confirmation.write false (and .edit / .bash)');
+    lines.push(t('perm.change_hint'));
     return lines.join(NL);
 }
 // ---------- /add-dir ----------
-export function resolveExtraDir(input, workdir) {
+export function resolveExtraDir(input, workdir, t = translate('en')) {
     const raw = String(input ?? '').trim();
     if (!raw)
-        return { error: 'Usage: /add-dir <path>' };
+        return { error: t('adddir.usage') };
     const abs = path.resolve(workdir, raw);
     if (abs === path.resolve(workdir)) {
-        return { error: 'This is already the working directory.' };
+        return { error: t('adddir.same') };
     }
     return { path: abs };
 }

package/dist/config-menu.js

@@ -11,9 +11,9 @@
 import { theme } from './theme.js';
 import { visLen } from './input.js';
 const ESC = String.fromCharCode(27);
-// Strip ANSI sequences to compute the visible length of a line.
+// Strip ANSH sequences to compute the visible length of a line.
 function stripAnsi(s) {
-    return s.replace(/\x1b\[[0-9;?]*[A-Za-z]/g, '');
+    return s.replace(/\x1b\`[0-9;?]*[A-Za-z]/g, '');
 }
 // Visible COLUMNS of a line (ANSI removed, wide chars counted as 2). Using the
 // code-point count made the block height disagree with the real screen on lines
@@ -35,7 +35,7 @@ function displayValue(field, value, t) {
     return String(value);
 }
 function groupLabel(field, t) {
-    return t(field.groupKey);
+    return theme.system('  ' + t(field.groupKey));
 }
 /**
  * Show the interactive menu. Returns a promise that resolves when the
@@ -45,13 +45,20 @@ function groupLabel(field, t) {
 export function runConfigMenu(opts) {
     const input = opts.input || process.stdin;
     const output = opts.output || process.stdout;
-    const { fields, t, get, set, reset } = opts;
+    const { fields, t, get, set, reset, getDefault } = opts;
     if (!input.isTTY || !input.setRawMode) {
         return Promise.reject(new Error(t('cfg.menu.notty')));
     }
+    // cursor indexes the VISIBLE (filtered) list, not the full `fields`.
     let cursor = 0;
     let editing = false;
     let editBuf = '';
+    // Reverse/forward filter over the list (/ to enter, typing narrows it).
+    let filterMode = false;
+    let filterQuery = '';
+    // Second `d` on the same row confirms the reset, so a stray keypress
+    // cannot wipe a setting by accident.
+    let pendingReset = null;
     let message = null;
     let exited = false;
     let resolveDone = null;
@@ -59,18 +66,53 @@ export function runConfigMenu(opts) {
     input.setRawMode(true);
     input.resume();
     output.write(ESC + '[?25l'); // hide the cursor while rendering
+    // Fields that match the current filter (path, label or group contains the
+    // query, case-insensitive). Empty query -> everything.
+    const visible = () => {
+        const q = filterQuery.trim().toLowerCase();
+        if (!q)
+            return fields;
+        return fields.filter((f) => (f.path + ' ' + t(f.labelKey || f.path) + ' ' + t(f.groupKey))
+            .toLowerCase()
+            .includes(q));
+    };
+    const currentField = () => {
+        const vis = visible();
+        if (!vis.length)
+            return null;
+        if (cursor >= vis.length)
+            cursor = vis.length - 1;
+        return vis[cursor];
+    };
+    // True when the value differs from the default (the field is overridden
+    // in a config file), so the menu can mark it. Skipped with no getDefault.
+    const isModified = (f) => {
+        if (!getDefault)
+            return false;
+        const cur = get(f.path);
+        const def = getDefault(f.path);
+        try {
+            return JSON.stringify(cur) !== JSON.stringify(def);
+        }
+        catch {
+            return String(cur) !== String(def);
+        }
+    };
     // Menu rendering: lines go top to bottom, and we return the cursor to the
     // start of the block via relative moves so we don't spawn blank lines.
     let lastRows = 0;
     const render = () => {
         const lines = [];
         lines.push(theme.bold(t('cfg.menu.title')));
+        const vis = visible();
+        if (cursor >= vis.length)
+            cursor = Math.max(0, vis.length - 1);
         let lastGroup = '';
-        for (let i = 0; i < fields.length; i++) {
-            const f = fields[i];
+        for (let i = 0; i < vis.length; i++) {
+            const f = vis[i];
             const g = groupLabel(f, t);
             if (g !== lastGroup) {
-                lines.push(theme.system('  ' + g));
+                lines.push(g);
                 lastGroup = g;
             }
             const selected = i === cursor;
@@ -80,28 +122,50 @@ export function runConfigMenu(opts) {
                 : t(f.labelKey || f.path);
             const val = displayValue(f, get(f.path), t);
             const valText = selected ? theme.assistant(val) : theme.dim(val);
+            const mod = isModified(f) ? theme.warn('*') : '';
             const pathText = selected ? theme.dim('  ' + f.path) : '';
-            lines.push(marker + label + theme.dim('  =  ') + valText + pathText);
+            lines.push(marker + label + theme.dim('  =  ') + valText + mod + pathText);
+        }
+        if (!vis.length) {
+            lines.push(theme.dim('  ' + t('cfg.menu.no_match')));
         }
         if (editing) {
             lines.push('');
             lines.push(theme.user(t('cfg.menu.edit_hint')));
             lines.push(theme.prompt('\u276f ') + editBuf);
         }
+        else if (filterMode) {
+            lines.push('');
+            lines.push(theme.user(t('cfg.menu.filter_hint')));
+            lines.push(theme.prompt('\u276f ') + filterQuery);
+        }
         else if (message) {
             lines.push('');
             lines.push(theme.assistant(message));
         }
         else {
             lines.push('');
-            lines.push(theme.dim(t('cfg.menu.hint')));
+            if (filterQuery) {
+                lines.push(theme.dim(t('cfg.menu.filter_active', { q: filterQuery }) +
+                    '  ' +
+                    t('cfg.menu.hint')));
+            }
+            else {
+                lines.push('  ' + theme.dim(t('cfg.menu.hint')));
+                lines.push('  ' + theme.dim(t('cfg.menu.filter_hint')));
+            }
         }
         // Erase the previous block and print the new one. We count VISUAL lines
         // (accounting for wrapping by terminal width), otherwise on narrow
         // terminals you get "garbage" from unerased tails.
+        // Reserve the last column. A line whose visible width reaches exactly the
+        // terminal width hits the autowrap edge: depending on the terminal it
+        // either consumes two rows for the following `\n` or keeps a pending wrap,
+        // and in both cases a full-width divisor UNDERCOUNTS the block height — the
+        // erase then misses the tail and the config lines DUPLICATE on screen (the
+        // reported bug). Overcounting by one is a harmless blank row; undercounting
+        // is not, so we bias to the safe side here.
         const cols = output.columns || 80;
-        // Reserve the last column like the editor does: a row that fills the
-        // terminal exactly can autowrap, which desyncs the block height.
         const usable = Math.max(1, cols - 1);
         const rowsOf = (s) => {
             return Math.max(1, Math.ceil(visCols(s) / usable));
@@ -129,12 +193,12 @@ export function runConfigMenu(opts) {
             lastRows = 0;
         }
     };
-    const cleanup = (clearOnExit = false) => {
+    const cleanup = (cleanOnExit = false) => {
         if (exited)
             return;
         exited = true;
         input.removeListener('data', onData);
-        if (clearOnExit)
+        if (cleanOnExit)
             clearBlock();
         if (input.setRawMode)
             input.setRawMode(wasRaw || false);
@@ -143,10 +207,12 @@ export function runConfigMenu(opts) {
             resolveDone();
     };
     const commitEdit = () => {
-        const f = fields[cursor];
+        const f = currentField();
         const raw = editBuf.trim();
         editing = false;
         editBuf = '';
+        if (!f)
+            return;
         if (!raw) {
             message = null;
             return;
@@ -163,7 +229,9 @@ export function runConfigMenu(opts) {
         }
     };
     const toggle = () => {
-        const f = fields[cursor];
+        const f = currentField();
+        if (!f)
+            return;
         if (f.type === 'boolean') {
             const cur = get(f.path);
             set(f, cur === true ? 'false' : 'true');
@@ -213,20 +281,49 @@ export function runConfigMenu(opts) {
             render();
             return;
         }
+        // Filter mode (/): printable keys build the query, Esc/Enter leave it
+        // (keeping the query active), Ctrl+C exits the whole menu.
+        if (filterMode) {
+            for (const ch of s) {
+                if (ch === '\r' || ch === '\n' || ch === ESC) {
+                    filterMode = false;
+                    break;
+                }
+                if (ch === '\x03') {
+                    cleanup(true);
+                    return;
+                }
+                if (ch === '\x7f' || ch === '\b') {
+                    filterQuery = filterQuery.slice(0, -1);
+                }
+                else if (ch >= ' ') {
+                    filterQuery += ch;
+                }
+            }
+            cursor = 0;
+            render();
+            return;
+        }
         // The terminal may send several keys in one packet (fast typing,
         // auto-repeat, automation). We parse the buffer into tokens: first
         // escape sequences (arrows), then single characters.
         let i = 0;
         while (i < s.length) {
             if (s.startsWith('\x1b[A', i)) {
-                cursor = (cursor - 1 + fields.length) % fields.length;
+                const n = visible().length;
+                if (n > 0)
+                    cursor = (cursor - 1 + n) % n;
                 message = null;
+                pendingReset = null;
                 i += 3;
                 continue;
             }
             if (s.startsWith('\x1b[B', i)) {
-                cursor = (cursor + 1) % fields.length;
+                const n = visible().length;
+                if (n > 0)
+                    cursor = (cursor + 1) % n;
                 message = null;
+                pendingReset = null;
                 i += 3;
                 continue;
             }
@@ -237,21 +334,51 @@ export function runConfigMenu(opts) {
                 cleanup(true);
                 return;
             }
-            if (ch === 'k') {
-                cursor = (cursor - 1 + fields.length) % fields.length;
+            if (ch === '/') {
+                filterMode = true;
+                message = null;
+                // The rest of THIS packet belongs to the filter query (typing " /debug"
+                // arrives as one chunk, and without this the trailing characters fell
+                // through to the command keys — 'd' armed a reset instead of filtering).
+                for (const rest of s.slice(i + 1)) {
+                    if (rest === '\x7f' || rest === '\b') {
+                        filterQuery = filterQuery.slice(0, -1);
+                    }
+                    else if (rest >= ' ') {
+                        filterQuery += rest;
+                    }
+                }
+                cursor = 0;
+                i = s.length;
+            }
+            else if (ch === 'k') {
+                const n = visible().length;
+                if (n > 0)
+                    cursor = (cursor - 1 + n) % n;
                 message = null;
             }
             else if (ch === 'j') {
-                cursor = (cursor + 1) % fields.length;
+                const n = visible().length;
+                if (n > 0)
+                    cursor = (cursor + 1) % n;
                 message = null;
             }
             else if (ch === '\r' || ch === '\n' || ch === ' ') {
                 toggle();
             }
             else if (ch === 'd' || ch === 'D') {
-                const f = fields[cursor];
-                reset(f);
-                message = t('cfg.reset', { v: f.path });
+                const f = currentField();
+                if (f) {
+                    if (pendingReset === f.path) {
+                        reset(f);
+                        message = t('cfg.reset', { v: f.path });
+                        pendingReset = null;
+                    }
+                    else {
+                        pendingReset = f.path;
+                        message = t('cfg.menu.reset_confirm', { v: f.path });
+                    }
+                }
             }
             i++;
         }

package/dist/i18n.js

@@ -39,6 +39,10 @@ const CATALOG = {
     'common.unknown': { ru: 'неизвестно', en: 'unknown' },
     // ---------- help ----------
     'help.options': { ru: 'Опции CLI:', en: 'CLI options:' },
+    'help.color_note': {
+        ru: 'Цвет отключается переменной окружения NO_COLOR=1.',
+        en: 'Disable color with the NO_COLOR=1 environment variable.',
+    },
     'help.opt.dir': {
         ru: 'рабочая директория агента',
         en: 'agent working directory',
@@ -95,6 +99,10 @@ const CATALOG = {
         ru: '↑ / ↓                    история введённых сообщений',
         en: '↑ / ↓                     input history',
     },
+    'help.key.search': {
+        ru: 'Ctrl+R                   поиск по истории (обратный)',
+        en: 'Ctrl+R                    reverse-search the history',
+    },
     'help.key.words': {
         ru: 'Ctrl+← / Ctrl+→          перемещение по словам',
         en: 'Ctrl+← / Ctrl+→           move by words',
@@ -140,6 +148,10 @@ const CATALOG = {
         ru: '/resume <n>              открыть чат №n из /chats',
         en: '/resume <n>              open chat #n from /chats',
     },
+    'help.cmd.last': {
+        ru: '/last                    открыть последний чат этого каталога',
+        en: '/last                    open the last chat of this directory',
+    },
     'help.cmd.chat': {
         ru: '/chat                    показать текущий chat id',
         en: '/chat                    show current chat id',
@@ -464,6 +476,15 @@ const CATALOG = {
     'state.generating': { ru: '▶ генерация', en: '▶ generating' },
     'editor.more': { ru: '…ещё {n}', en: '…{n} more' },
     'editor.answer': { ru: '● Ответ', en: '● Answer' },
+    // Reverse search (Ctrl+R) status line. The query may be empty.
+    'editor.search_prompt': {
+        ru: '(обратный поиск) `{q}` — Ctrl+R дальше, Enter принять, Esc отмена',
+        en: '(reverse-i-search) `{q}` — Ctrl+R next, Enter accept, Esc cancel',
+    },
+    'editor.search_fail': {
+        ru: '(обратный поиск) `{q}` — не найдено, Esc отмена',
+        en: '(reverse-i-search) `{q}` — not found, Esc cancel',
+    },
     // ---------- status ----------
     'status.workdir': {
         ru: 'Рабочая директория: {v}',
@@ -539,10 +560,15 @@ const CATALOG = {
         en: 'Opening chat {id}...',
     },
     'msg.chat_opened': { ru: 'Чат открыт.', en: 'Chat opened.' },
+    'msg.version': { ru: 'Версия: {v}', en: 'Version: {v}' },
     'msg.interactive': {
         ru: 'Интерактивный режим. Введите задачу. Команды — /help. Выход — /exit.',
         en: 'Interactive mode. Enter a task. Commands — /help. Exit — /exit.',
     },
+    'msg.first_hint': {
+        ru: 'Подсказка: «/» — список команд, Ctrl+R — поиск по истории, картинку можно вставить через Ctrl+Shift+V.',
+        en: 'Hint: "/" lists commands, Ctrl+R searches history, paste an image with Ctrl+Shift+V.',
+    },
     'msg.queue_hint': {
         ru: 'Пока агент работает, можно печатать следующее сообщение — оно уйдёт в очередь (Enter — отправить, Esc — прервать).',
         en: 'While the agent works you can type the next message — it goes to the queue (Enter — send, Esc — abort).',
@@ -601,6 +627,99 @@ const CATALOG = {
     'dur.h': { ru: 'ч', en: 'h' },
     'dur.m': { ru: 'м', en: 'm' },
     'dur.s': { ru: 'с', en: 's' },
+    // ---------- /diff ----------
+    'diff.no_changes': { ru: '(нет изменений)', en: '(no changes)' },
+    'diff.more_lines': {
+        ru: '... [{n} строк ещё, полный вывод — Bash git diff]',
+        en: '... [{n} more lines, use Bash git diff for the full output]',
+    },
+    // ---------- /cost ----------
+    'cost.title': { ru: 'Статистика сессии:', en: 'Session stats:' },
+    'cost.context_known': {
+        ru: ' контекст: ~{n} токенов (DeepSeek accumulated_token_usage)',
+        en: ' context: ~{n} tokens (DeepSeek accumulated_token_usage)',
+    },
+    'cost.context_unknown': {
+        ru: ' контекст: неизвестно (DeepSeek сообщит после первого ответа в чате)',
+        en: ' context: unknown (DeepSeek reports it after the first answer in a chat)',
+    },
+    'cost.tasks': { ru: ' задач: {n}', en: ' tasks: {n}' },
+    'cost.tool_calls': {
+        ru: ' вызовов инструментов: {n}',
+        en: ' tool calls: {n}',
+    },
+    'cost.auto_compacts': { ru: ' авто-сжатий: {n}', en: ' auto-compacts: {n}' },
+    'cost.by_tool': { ru: ' по инструментам:', en: ' by tool:' },
+    'cost.duration': { ru: ' длительность: {dur}', en: ' duration: {dur}' },
+    'cost.started': { ru: ' начало: {v}', en: ' started: {v}' },
+    'cost.transcript': { ru: ' транскрипт: {v}', en: ' transcript: {v}' },
+    'cost.off': { ru: '(выкл)', en: '(off)' },
+    // ---------- /doctor ----------
+    'doctor.title': { ru: 'Диагностика:', en: 'Doctor:' },
+    'doctor.repo': { ru: 'репозиторий ({v})', en: 'repo ({v})' },
+    'doctor.detached': { ru: 'detached', en: 'detached' },
+    'doctor.not_repo': { ru: 'не репозиторий', en: 'not a repository' },
+    'doctor.loaded': { ru: 'загружен', en: 'loaded' },
+    'doctor.error': { ru: 'ошибка: {v}', en: 'error: {v}' },
+    'doctor.unknown': { ru: 'неизвестно', en: 'unknown' },
+    'doctor.bundled': { ru: 'встроенный chromium', en: 'bundled chromium' },
+    'doctor.auth_saved': {
+        ru: 'сессия сохранена (авто-вход готов)',
+        en: 'session saved (auto re-login ready)',
+    },
+    'doctor.auth_none': { ru: 'нет сохранённой сессии', en: 'no saved session' },
+    'doctor.clipboard_none': {
+        ru: 'инструмент не найден (вставка картинок отключена)',
+        en: 'no tool found (image paste disabled)',
+    },
+    'doctor.mcp': {
+        ru: '{servers} сервер(ов), {tools} инструмент(ов)',
+        en: '{servers} server(s), {tools} tool(s)',
+    },
+    'doctor.tokens': { ru: '{v} токенов', en: '{v} tokens' },
+    'doctor.origin_ok': { ru: 'origin настроен', en: 'origin configured' },
+    'doctor.origin_none': { ru: 'нет origin', en: 'no origin' },
+    'doctor.send_pause': {
+        ru: '{n}с между отправками агента',
+        en: '{n}s between agent sends',
+    },
+    'doctor.ssh': { ru: 'SSH-подключение', en: 'SSH remote' },
+    'doctor.local': { ru: 'локальный терминал', en: 'local terminal' },
+    'doctor.ua_cached': {
+        ru: 'UA закэширован (без перезапуска)',
+        en: 'UA cached (no relaunch)',
+    },
+    'doctor.ua_not_cached': {
+        ru: 'UA ещё не закэширован (первый запуск перезапустится один раз)',
+        en: 'no cached UA yet (first start relaunches once)',
+    },
+    // ---------- /permissions ----------
+    'perm.title': {
+        ru: 'Права инструментов (настройки подтверждений):',
+        en: 'Tool permissions (confirmation settings):',
+    },
+    'perm.write': { ru: ' Write: {v}', en: ' Write: {v}' },
+    'perm.edit': { ru: ' Edit: {v}', en: ' Edit: {v}' },
+    'perm.bash': { ru: ' Bash: {v}', en: ' Bash: {v}' },
+    'perm.ask': { ru: 'спрашивать', en: 'ask' },
+    'perm.allow': { ru: 'разрешить', en: 'allow' },
+    'perm.always': {
+        ru: ' Всегда подтверждать (regex):',
+        en: ' Always confirm (regex):',
+    },
+    'perm.change_hint': {
+        ru: 'Изменить: /config set confirmation.write false (и .edit / .bash)',
+        en: 'Change with: /config set confirmation.write false (and .edit / .bash)',
+    },
+    // ---------- /add-dir ----------
+    'adddir.usage': {
+        ru: 'Использование: /add-dir <path>',
+        en: 'Usage: /add-dir <path>',
+    },
+    'adddir.same': {
+        ru: 'Это уже рабочая директория.',
+        en: 'This is already the working directory.',
+    },
     'msg.from_queue': { ru: '▶ Из очереди: ', en: '▶ From queue: ' },
     'msg.from_queue_batch': {
         ru: '▶ Из очереди ({n} сообщ.): ',
@@ -1273,6 +1392,19 @@ const CATALOG = {
         en: '✔ Saved: {v} = {value}',
     },
     'cfg.menu.default': { ru: 'по умолчанию', en: 'default' },
+    'cfg.menu.filter_hint': {
+        ru: '/ — поиск по настройкам, d — сбросить (дважды), * — изменено от дефолта',
+        en: '/ search settings, d reset (press twice), * changed from default',
+    },
+    'cfg.menu.filter_active': {
+        ru: 'Фильтр: «{q}» (Esc/Enter — очистить)',
+        en: 'Filter: "{q}" (Esc/Enter to clear)',
+    },
+    'cfg.menu.no_match': { ru: '(нет совпадений)', en: '(no matches)' },
+    'cfg.menu.reset_confirm': {
+        ru: 'Нажми d ещё раз, чтобы сбросить {v}',
+        en: 'Press d again to reset {v}',
+    },
     'cfg.menu.notty': {
         ru: 'Меню доступно только в интерактивном терминале. Используй /config list|get|set.',
         en: 'The menu needs an interactive terminal. Use /config list|get|set.',

package/dist/index.js

@@ -292,9 +292,12 @@ ${theme.bold(t('help.options'))}
   --version, -v      ${t('help.opt.version')}
   --help, -h         ${t('help.opt.help')}
 
+${t('help.color_note')}
+
 ${theme.bold(t('help.while_working'))}
   ${t('help.key.queue')}
   ${t('help.key.history')}
+  ${t('help.key.search')}
   ${t('help.key.words')}
   ${t('help.key.slash')}
   ${t('help.key.newline')}
@@ -308,6 +311,7 @@ ${theme.bold(t('help.commands'))}
   ${t('help.cmd.resume_id')}
   ${t('help.cmd.chats')}
   ${t('help.cmd.resume')}
+  ${t('help.cmd.last')}
   ${t('help.cmd.chat')}
   ${t('help.cmd.cd')}
   ${t('help.cmd.pwd')}
@@ -316,20 +320,20 @@ ${theme.bold(t('help.commands'))}
   ${t('help.cmd.undo')}
   ${t('help.cmd.undo_list')}
   ${t('help.cmd.transcript')}
- ${t('help.cmd.diff')}
- ${t('help.cmd.cost')}
- ${t('help.cmd.export')}
- ${t('help.cmd.doctor')}
- ${t('help.cmd.permissions')}
- ${t('help.cmd.add_dir')}
- ${t('help.cmd.review')}
- ${t('help.cmd.goal')}
- ${t('help.cmd.loop')}
- ${t('help.cmd.cron')}
- ${t('help.cmd.jobs')}
- ${t('help.cmd.thinking')}
- ${t('help.cmd.web')}
- ${t('help.cmd.compact')}
+  ${t('help.cmd.diff')}
+  ${t('help.cmd.cost')}
+  ${t('help.cmd.export')}
+  ${t('help.cmd.doctor')}
+  ${t('help.cmd.permissions')}
+  ${t('help.cmd.add_dir')}
+  ${t('help.cmd.review')}
+  ${t('help.cmd.goal')}
+  ${t('help.cmd.loop')}
+  ${t('help.cmd.cron')}
+  ${t('help.cmd.jobs')}
+  ${t('help.cmd.thinking')}
+  ${t('help.cmd.web')}
+  ${t('help.cmd.compact')}
   ${t('help.cmd.queue')}
   ${t('help.cmd.tasks')}
   ${t('help.cmd.config')}
@@ -372,6 +376,7 @@ const SLASH_COMMANDS = [
     { name: '/chats', key: 'help.cmd.chats' },
     { name: '/resume', key: 'help.cmd.resume' },
     { name: '/resume-id', key: 'help.cmd.resume_id' },
+    { name: '/last', key: 'help.cmd.last' },
     { name: '/chat', key: 'help.cmd.chat' },
     { name: '/cd', key: 'help.cmd.cd' },
     { name: '/pwd', key: 'help.cmd.pwd' },
@@ -1190,9 +1195,14 @@ async function runTask(browser, tools, taskText, workdir, opts, attachments = []
 }
 // ---------- main ----------
 async function main() {
+    // Read the package version once: --version prints it and the interactive
+    // banner shows it (a version in the first lines is what a bug report needs).
+    const pkgVersion = await fs
+        .readFile(path.join(__dirname, '..', 'package.json'), 'utf-8')
+        .then((raw) => JSON.parse(raw).version)
+        .catch(() => '');
     if (hasFlag('--version') || hasFlag('-v')) {
-        const pkg = JSON.parse(await fs.readFile(path.join(__dirname, '..', 'package.json'), 'utf-8'));
-        console.log(pkg.version);
+        console.log(pkgVersion || 'unknown');
         return;
     }
     if (hasFlag('--help') || hasFlag('-h')) {
@@ -1215,6 +1225,7 @@ async function main() {
         process.exit(1);
     }
     console.log(theme.system(t('msg.working_dir', { v: currentWorkdir })));
+    console.log(theme.system(t('msg.version', { v: pkgVersion || '?' })));
     const transcript = new Transcript({
         dir: config.transcript.dir,
         enabled: config.transcript.enabled,
@@ -1327,6 +1338,7 @@ async function main() {
     }
     console.log(theme.system(t('msg.interactive')));
     console.log(theme.system(t('msg.queue_hint')));
+    console.log(theme.dim(t('msg.first_hint')));
     let freshChatNext = true;
     let sendSystemPromptNext = true;
     // Resuming an existing chat already has the system-prompt at its start, so
@@ -1946,6 +1958,7 @@ async function main() {
                 fields: CONFIG_SCHEMA,
                 t,
                 get: (path) => getByPath(config, path),
+                getDefault: (path) => getByPath(DEFAULTS, path),
                 set: (field, raw) => configSetRaw(field, raw),
                 reset: (field) => configResetField(field),
             });
@@ -2407,6 +2420,39 @@ async function main() {
             }
             continue;
         }
+        if (lower === '/last') {
+            // Quick resume of the last chat for THIS working directory — otherwise
+            // finding it meant /chats (a network fetch) or copying the id.
+            const last = loadLastSession(currentWorkdir);
+            if (!last || !last.id) {
+                console.error(theme.error(t('sessions.none')));
+                continue;
+            }
+            if (editor)
+                editor.lock(t('msg.input_locked'));
+            try {
+                if (editor)
+                    editor.clearScreen();
+                console.log(theme.system(t('msg.opening_chat', { id: last.id })));
+                await browser.openChat(last.id);
+                currentChatId = last.id;
+                freshChatNext = false;
+                sendSystemPromptNext = promptOnResume();
+                saveLastChat(last.id, currentWorkdir, last.title);
+                transcript.log('resume_chat', { id: last.id, title: last.title });
+                console.log(theme.assistant(t('msg.chat_opened')));
+                loadSessionTodos(last.id);
+                await printRestoredHistory(browser, editor, last.id);
+            }
+            catch (e) {
+                console.error(theme.error(t('msg.open_chat_error', { v: '' })), e.message);
+            }
+            finally {
+                if (editor)
+                    editor.unlock();
+            }
+            continue;
+        }
         if (lower.startsWith('/resume-id ')) {
             const id = trimmed.slice('/resume-id'.length).trim();
             if (!id) {
@@ -2818,7 +2864,7 @@ async function main() {
                 continue;
             }
             const out = await runGit(diffGitArgs(staged), currentWorkdir, 20_000);
-            console.log(theme.system(formatDiff(out, { maxLines: 400 })));
+            console.log(theme.system(formatDiff(out, { maxLines: 400 }, t)));
             continue;
         }
         if (lower === '/cost' || lower === '/usage') {
@@ -2832,7 +2878,7 @@ async function main() {
                     // best-effort
                 }
             }
-            console.log(theme.system(renderCost(stats, transcript.file, browser.getLastTokenUsage())));
+            console.log(theme.system(renderCost(stats, transcript.file, browser.getLastTokenUsage(), t)));
             continue;
         }
         if (lower === '/export' || lower.startsWith('/export ')) {
@@ -2907,7 +2953,7 @@ async function main() {
                 sshRemote: !!(process.env.SSH_CONNECTION || process.env.SSH_TTY),
                 headless: !!headless,
                 headlessUaCached: await headlessUACacheReady().catch(() => false),
-            })));
+            }, t)));
             continue;
         }
         if (lower === '/permissions' || lower === '/allowed-tools') {
@@ -2916,12 +2962,12 @@ async function main() {
                 edit: config.confirmation.edit,
                 bash: config.confirmation.bash,
                 alwaysConfirm: config.confirmation.alwaysConfirm,
-            })));
+            }, t)));
             continue;
         }
         if (lower === '/add-dir' || lower.startsWith('/add-dir ')) {
             const arg = trimmed.slice('/add-dir'.length).trim();
-            const res = resolveExtraDir(arg, currentWorkdir);
+            const res = resolveExtraDir(arg, currentWorkdir, t);
             if ('error' in res) {
                 console.error(theme.warn(res.error));
                 continue;

package/dist/input.js

@@ -1,4 +1,4 @@
-import { theme } from './theme.js';
+import { theme, divider } from './theme.js';
 import { renderMarkdown } from './markdown.js';
 import { randomThinkingPhrase, stripEllipsis, DOTS, renderDots, } from './spinner.js';
 import { translate } from './i18n.js';
@@ -315,10 +315,10 @@ export class LineEditor {
     // True while the dot-animation timer is running. Lets sendPause() update
     // only the base text (remaining seconds) without restarting the timer.
     _animating;
-    // Whether the animated status shows the trailing "Esc — стоп" hint. Off
-    // while a tool runs (its process cannot be cancelled).
-    _showHint;
     _dotPhase;
+    // When the current animated phase started, so the status can show its
+    // elapsed time. 0 when nothing is animating.
+    _animStart;
     _thinkBase;
     // Explicit lifecycle state of the send ('generating' | 'paused' |
     // 'settled' | ''). The thinking spinner already shows ACTIVITY, but it does
@@ -351,6 +351,11 @@ export class LineEditor {
     history;
     _histIndex;
     _histDraft;
+    // Incremental reverse-search over the history (Ctrl+R), bash-style.
+    _searchMode;
+    _searchQuery;
+    _searchIndex;
+    _searchSavedBuf;
     // Slash-command hints (shown when you type «/»).
     slashCommands;
     _suggestCount;
@@ -422,8 +427,8 @@ export class LineEditor {
         this._inPaste = false;
         this._dotTimer = null;
         this._animating = false;
-        this._showHint = true;
         this._dotPhase = 0;
+        this._animStart = 0;
         this._thinkBase = '';
         this._sendState = '';
         this._lastStatusBlock = '';
@@ -453,6 +458,10 @@ export class LineEditor {
         this.history = [];
         this._histIndex = 0;
         this._histDraft = '';
+        this._searchMode = false;
+        this._searchQuery = '';
+        this._searchIndex = -1;
+        this._searchSavedBuf = '';
         this.slashCommands = commands;
         this._suggestCount = 0;
         this.pastes = [];
@@ -508,16 +517,17 @@ export class LineEditor {
         return this.contextStatus;
     }
     // The context text colored by fill level: green (ok), yellow (warn),
-    // red (high).
+    // red (high). A leading marker repeats the level as TEXT, so the signal
+    // survives on a terminal without color and for a color-blind operator.
     _contextText() {
         const ctx = this._contextForRender();
         if (!ctx)
             return '';
         const level = tokenStatusLevel(this.contextTokens, this.contextLimit);
         if (level === 'high')
-            return theme.error(ctx);
+            return theme.error('⛔ ' + ctx);
         if (level === 'warn')
-            return theme.warn(ctx);
+            return theme.warn('▲ ' + ctx);
         return theme.success(ctx);
     }
     // The queue badge ("⧗N") shown before the context counter when messages are
@@ -1071,10 +1081,10 @@ export class LineEditor {
     _dots(n) {
         return renderDots(n);
     }
-    // Status-line hint ("Esc — stop"), localized.
+    // Status-line hint ("Esc — stop"), localized. Shown for every animated
+    // state: Esc really aborts both a generation and a running tool (the Bash
+    // child is killed via AbortSignal), so the promise is accurate.
     _hint() {
-        if (!this._showHint)
-            return '';
         return theme.dim('  ·  ' + translate(this.locale)('spinner.hint'));
     }
     // The lifecycle phase prefix for the status line, colored by meaning:
@@ -1110,24 +1120,37 @@ export class LineEditor {
     // Shared by the thinking spinner and the send-pause indicator, so the pause
     // is animated too (previously the pause was a static console line and the
     // dots stayed frozen).
-    //
-    // `showHint` (default true) controls the trailing "· Esc — стоп". While a
-    // TOOL runs we hide it: the tool's child process cannot be killed, so
-    // promising "Esc to stop" would be misleading.
-    _startAnimated(baseText, showHint = true) {
+    _startAnimated(baseText) {
         this._thinkBase = theme.brown(stripEllipsis(baseText));
-        this._showHint = showHint;
         this._dotPhase = 0;
-        this.setStatus(this._thinkBase + this._dots(0) + this._hint());
+        // Remember when the animation began so the status can show how long the
+        // current phase has been running ("12s"): a long reasoning turn otherwise
+        // looks identical to a hung one.
+        this._animStart = Date.now();
+        this.setStatus(this._thinkBase + this._dots(0) + this._elapsedLabel() + this._hint());
         this._stopDots();
         this._dotTimer = setInterval(() => {
             this._dotPhase = (this._dotPhase + 1) % DOTS.length;
-            this.setStatus(this._thinkBase + this._dots(this._dotPhase) + this._hint());
+            this.setStatus(this._thinkBase +
+                this._dots(this._dotPhase) +
+                this._elapsedLabel() +
+                this._hint());
         }, 400);
         this._animating = true;
         if (this._dotTimer.unref)
             this._dotTimer.unref();
     }
+    // Elapsed seconds of the current animated phase, formatted for the status
+    // line ("0s", "45s", "2m 05s"). Empty while nothing is animating.
+    _elapsedLabel() {
+        if (!this._animating || !this._animStart)
+            return '';
+        const sec = Math.floor((Date.now() - this._animStart) / 1000);
+        const m = Math.floor(sec / 60);
+        const s = sec % 60;
+        const text = m > 0 ? m + 'm ' + String(s).padStart(2, '0') + 's' : s + 's';
+        return theme.dim(' · ' + text);
+    }
     thinking() {
         this._startThinking();
     }
@@ -1194,7 +1217,7 @@ export class LineEditor {
             NL +
             rendered +
             NL +
-            theme.dim('─'.repeat(60)));
+            theme.dim(divider()));
     }
     // Warning to the operator (e.g. the agent stopped suspiciously).
     // Printed above the input line without overwriting it.
@@ -1492,6 +1515,93 @@ export class LineEditor {
         }
         this.cursor = Array.from(this.buf).length;
     }
+    // ---------- reverse-search (Ctrl+R) ----------
+    // Start an incremental reverse search, keeping the current buffer aside so
+    // Esc restores it (bash behavior). An empty history leaves the editor
+    // untouched.
+    _searchStart() {
+        if (!this.history.length)
+            return;
+        this._searchMode = true;
+        this._searchQuery = '';
+        this._searchIndex = this.history.length - 1;
+        this._searchSavedBuf = this.buf;
+        this._searchRefresh(true);
+        this._searchStatus();
+    }
+    // Recompute the match for the current query. `resetToNewest` moves the
+    // cursor back to the newest entry (used when the query changes; a repeated
+    // Ctrl+R keeps scanning older entries from the current index).
+    _searchRefresh(resetToNewest = false) {
+        const q = this._searchQuery;
+        if (resetToNewest)
+            this._searchIndex = this.history.length - 1;
+        for (let i = this._searchIndex; i >= 0; i--) {
+            if (q === '' || this.history[i].toLowerCase().includes(q.toLowerCase())) {
+                this._searchIndex = i;
+                return;
+            }
+        }
+        // No match from here: signal it and leave the buffer as-is.
+        this._searchIndex = -1;
+    }
+    // Show the search state in the status line. The matched entry is previewed
+    // in the input line live, so Enter can accept it at once.
+    _searchStatus() {
+        const t = translate(this.locale);
+        const q = this._searchQuery;
+        if (this._searchIndex >= 0) {
+            // Set the matched buffer BEFORE setStatus(): setStatus renders the
+            // block, so the preview must already be in the buffer.
+            this.buf = this.history[this._searchIndex];
+            this.cursor = Array.from(this.buf).length;
+            this.setStatus(t('editor.search_prompt', { q }));
+        }
+        else {
+            this.setStatus(t('editor.search_fail', { q }));
+        }
+    }
+    // One more Ctrl+R: move to the PREVIOUS (older) match.
+    _searchNext() {
+        if (this._searchIndex > 0) {
+            const prev = this._searchIndex;
+            this._searchIndex = prev - 1;
+            this._searchRefresh(false);
+            // If nothing matched above `prev`, keep the previous match.
+            if (this._searchIndex < 0)
+                this._searchIndex = prev;
+        }
+        this._searchStatus();
+    }
+    // Enter: keep the matched buffer and leave search mode.
+    _searchAccept() {
+        this._searchMode = false;
+        this._searchQuery = '';
+        this.setStatus('');
+        this._render();
+    }
+    // Esc / Ctrl+C: leave search mode and restore the buffer typed before it.
+    _searchCancel() {
+        this._searchMode = false;
+        this._searchQuery = '';
+        this.buf = this._searchSavedBuf;
+        this.cursor = Array.from(this.buf).length;
+        this.setStatus('');
+        this._render();
+    }
+    // A character typed during search extends the query; Backspace trims it.
+    _searchInput(ch) {
+        this._searchQuery += ch;
+        this._searchRefresh(true);
+        this._searchStatus();
+    }
+    _searchBackspace() {
+        if (!this._searchQuery.length)
+            return;
+        this._searchQuery = this._searchQuery.slice(0, -1);
+        this._searchRefresh(true);
+        this._searchStatus();
+    }
     _handle(data) {
         let s = data.toString('utf-8');
         // While locked (a long operation is running), swallow all input except
@@ -1513,11 +1623,40 @@ export class LineEditor {
             }
             return;
         }
-        if (!this._inPaste && s === ESC) {
+        if (!this._inPaste && s === ESC && !this._searchMode) {
             if (this.onEscape)
                 this.onEscape();
             return;
         }
+        // While the reverse search (Ctrl+R) is active, the editor is in a modal
+        // state: every printable key extends the query, Ctrl+R scans older
+        // entries, Enter accepts and Esc/Ctrl+C cancels. Handling this BEFORE the
+        // normal key dispatch keeps the search self-contained.
+        if (this._searchMode) {
+            let i = 0;
+            while (i < s.length) {
+                const code = s.charCodeAt(i);
+                if (code === 18) {
+                    this._searchNext();
+                }
+                else if (code === 13 || code === 10) {
+                    this._searchAccept();
+                    return;
+                }
+                else if (code === 27 || code === 3) {
+                    this._searchCancel();
+                    return;
+                }
+                else if (code === 127 || code === 8) {
+                    this._searchBackspace();
+                }
+                else if (code >= 32) {
+                    this._searchInput(s[i]);
+                }
+                i++;
+            }
+            return;
+        }
         while (s.length) {
             if (this._inPaste) {
                 const end = s.indexOf(PASTE_END);
@@ -1648,6 +1787,11 @@ export class LineEditor {
                 void this._tryClipboard();
                 continue;
             }
+            if (code === 18) {
+                // Ctrl+R — incremental reverse search over the input history.
+                this._searchStart();
+                continue;
+            }
             if (code === 23) {
                 this._deleteWordLeft();
                 this._renderInputOnly();

package/dist/self-review.js

@@ -1,6 +1,6 @@
 import path from 'path';
 import fs from 'fs/promises';
-import { theme } from './theme.js';
+import { theme, divider } from './theme.js';
 import { translate, DEFAULT_LOCALE } from './i18n.js';
 import { fileURLToPath } from 'url';
 import { ZAMES_HOME } from './config.js';
@@ -116,7 +116,7 @@ export async function selfReview({ browser, focus, transcript, locale, }) {
     await fs.writeFile(reportPath, finalMessage || t('self.report_empty'), 'utf-8');
     // Compute what changed
     const changed = await diffFiles(SRC_DIR, snapDir);
-    console.log(theme.system('─'.repeat(60)));
+    console.log(theme.system(divider()));
     console.log(theme.system(t('self.report_path', { v: reportPath })));
     console.log(theme.system(t('self.snapshot_path', { v: snapDir })));
     if (changed.length) {

package/dist/spinner.js

@@ -1,5 +1,5 @@
 import ora from 'ora';
-import { theme } from './theme.js';
+import { theme, divider } from './theme.js';
 import { renderMarkdown } from './markdown.js';
 import { translate } from './i18n.js';
 // Phrases for the "agent is working" spinner. Chosen in random order.
@@ -59,14 +59,9 @@ export function createSpinner(locale = 'ru') {
     // "running" dot sequence. Shared by the thinking spinner and the send-pause
     // indicator, so the pause is animated too (before, it was a static line and
     // the dots did not move — the operator saw a frozen spinner).
-    //
-    // `showHint` (default true) controls the trailing "· Esc — стоп". While a
-    // tool runs we hide it: its process cannot be cancelled, so promising a stop
-    // would be misleading.
-    const startAnimated = (baseText, showHint = true) => {
+    const startAnimated = (baseText) => {
         animBase = theme.brown(stripEllipsis(baseText));
-        const hint = showHint ? HINT : '';
-        start(animBase + renderDots(0) + hint);
+        start(animBase + renderDots(0) + HINT);
         dotPhase = 0;
         if (dotTimer)
             clearInterval(dotTimer);
@@ -74,7 +69,7 @@ export function createSpinner(locale = 'ru') {
             if (!spinner)
                 return;
             dotPhase = (dotPhase + 1) % DOTS.length;
-            spinner.text = animBase + renderDots(dotPhase) + hint;
+            spinner.text = animBase + renderDots(dotPhase) + HINT;
         }, 400);
         animating = true;
         if (dotTimer.unref)
@@ -158,7 +153,7 @@ export function createSpinner(locale = 'ru') {
             // (which is highlighted by the prompt with a golden arrow).
             console.log(NL + theme.assistant(translate(locale)('editor.answer')) + NL);
             console.log(rendered);
-            console.log(theme.dim('─'.repeat(60)) + NL);
+            console.log(theme.dim(divider()) + NL);
         },
         warning: (msg) => {
             stop();

package/dist/theme.js

@@ -29,7 +29,16 @@ export const theme = {
     success: chalk.hex('#a9c08c'), // soft sage
     brown: chalk.hex('#a1723f'), // brown (status/spinner)
     toggleOn: chalk.hex('#6fd0b0'), // teal-green — a toggle is ON
-    toggleOff: chalk.hex('#4a4f5a'), // dim gray — a toggle is OFF
     bold: chalk.bold,
 };
+// Horizontal rule that separates the model's answer from the next block. It
+// spans the terminal width (capped at `max`) so it does not look stubby on a
+// wide terminal. Falls back to 60 columns when the width is unknown (non-TTY).
+// One column is kept free, like everywhere else in the status/input layout, so
+// a full-width rule cannot trigger autowrap.
+export function divider(max = 100) {
+    const cols = process.stdout.columns || 0;
+    const width = Math.max(20, Math.min(max, cols ? cols - 1 : 60));
+    return '─'.repeat(width);
+}
 export default theme;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zames_pro",
-  "version": "2.50.1",
+  "version": "2.51.0",
   "description": "Terminal coding agent over chat.deepseek.com via Playwright",
   "type": "module",
   "bin": {