zames_pro 2.75.0 → 2.75.2

package/CHANGELOG.md

@@ -7,6 +7,26 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.75.2] - 2026-10-15
+
+### Changed
+
+- batch read-only tool calls and skip redundant checkpoints
+
+## [2.75.1] - 2026-10-15
+
+### Added
+
+- remove /resume; Ctrl+Delete always deletes the word BEFORE the cursor
+- **tui:** drop the working directory from the prompt
+- **tui:** persistent key hint under the input box
+
+### Fixed
+
+- stop advertising the removed /resume and make the i18n guard real
+- **tui:** Ctrl+Delete works in VSCode (it sends ESC d)
+- **tui:** Ctrl+Delete deletes the word BEFORE the cursor
+
 ## [2.75.0] - 2026-10-14
 
 ### Added

package/dist/agent-loop.js

@@ -180,6 +180,15 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
     // block after the tool loop).
     let malformedRetries = 0;
     const MAX_MALFORMED_RETRIES = 3;
+    // Tool-result caps for the message fed back to the model. A single result
+    // gets a generous cap; in a BATCH each item is capped and the ASSEMBLED
+    // message is capped again, so a big batch cannot exceed what the chat input
+    // accepts (a failed paste loses the whole turn). The caps are explicit:
+    // truncateToolResult() appends `[...truncated N chars]` so the model knows
+    // it is looking at a partial output.
+    const TOOL_RESULT_LIMIT = 24_000;
+    const BATCH_ITEM_LIMIT = 16_000;
+    const BATCH_TOTAL_LIMIT = 120_000;
     let stallRetries = 0;
     const MAX_STALL_RETRIES = 5;
     // SINGLE shared budget for "the answer is not a recognized tool call".
@@ -752,6 +761,14 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
         // and no call matches an `ask` permission rule (a concurrent operator
         // prompt would race). Anything else keeps the strict sequential loop, so
         // mutating side effects never reorder.
+        //
+        // MUTATING tools (Write/Edit/MultiEdit) are deliberately NOT here even
+        // though writes to different files are logically independent: (a)
+        // UndoStore.backup() does a read-modify-write of ONE shared index file, so
+        // two concurrent backups race and lose a record; (b) PostToolUse hooks and
+        // diagnostics must run in a defined order. A batch of mutating calls still
+        // costs only ONE round-trip (the sequential loop below runs them all for
+        // the same answer), so nothing is lost by keeping them sequential.
         const PARALLEL_SAFE = new Set(['Read', 'Glob', 'Grep', 'LS', 'WebFetch']);
         const readOnlyBatch = callsToRun.length > 1 &&
             !(hookConfig.PreToolUse && hookConfig.PreToolUse.length) &&
@@ -1064,15 +1081,23 @@ ${diag}`;
         if (results.length === 1) {
             const r = results[0];
             const resultStr = typeof r.result === 'string' ? r.result : JSON.stringify(r.result);
-            message = `Tool result for ${r.tool}:\n${truncateToolResult(resultStr, 12_000)}`;
+            message = `Tool result for ${r.tool}:\n${truncateToolResult(resultStr, TOOL_RESULT_LIMIT)}`;
         }
         else {
             message = results
                 .map((r) => {
                 const resultStr = typeof r.result === 'string' ? r.result : JSON.stringify(r.result);
-                return `Tool result for ${r.tool}:\n${truncateToolResult(resultStr, 8000)}`;
+                return `Tool result for ${r.tool}:\n${truncateToolResult(resultStr, BATCH_ITEM_LIMIT)}`;
             })
                 .join('\n\n');
+            // A large batch (e.g. 8 Reads) could still add up past what the chat
+            // input accepts; a too-long message fails to paste (ds.input_partial) and
+            // the whole turn is lost. Cap the ASSEMBLED message as a safety net,
+            // keeping the per-item truncation markers (the model still sees WHAT was
+            // dropped, just a bit more of it).
+            if (message.length > BATCH_TOTAL_LIMIT) {
+                message = truncateToolResult(message, BATCH_TOTAL_LIMIT);
+            }
         }
         // Append the argument-error nudge (set inside the batch loop) now that
         // `message` has been rebuilt from `results`. Cleared so it fires once per

package/dist/browser.js

@@ -1895,8 +1895,11 @@ export class DeepSeekBrowser {
             }
             // Reasoning-mode pause during the THINK phase: click Continue so the
             // generation resumes (the button appears before any RESPONSE text, so
-            // the start-wait would otherwise spin until the deadline).
-            if (this.autoContinue && (await this._clickContinueIfVisible())) {
+            // the start-wait would otherwise spin until the deadline). Probing
+            // PROACTIVELY is meaningful only with the reasoning toggle ON.
+            if (this.autoContinue &&
+                this.deepThinking &&
+                (await this._clickContinueIfVisible())) {
                 this._askDebug('CLICKED Continue (start-loop)');
             }
             const cur = await this._readLastAnswerTextCleanDom().catch(() => '');
@@ -1935,8 +1938,12 @@ export class DeepSeekBrowser {
             const notGenerating = !(await this._isGenerating());
             const differs = !!cur && normText(cur) !== normText(beforeText);
             // Do NOT accept a "settled" answer while Continue is on screen — that
-            // is a paused generation, not a finished one.
-            const paused = this.autoContinue && (await this._continueButtonVisible());
+            // is a paused generation, not a finished one. The paused check only
+            // applies with the reasoning toggle ON (the THINK-phase pause); without
+            // it a stable answer is a genuinely finished one.
+            const paused = this.autoContinue &&
+                this.deepThinking &&
+                (await this._continueButtonVisible());
             if (differs && cur === lastStartCur && notGenerating && !paused) {
                 settledTicks++;
                 if (settledTicks >= 2) {
@@ -2095,8 +2102,15 @@ export class DeepSeekBrowser {
             }
             // Reasoning-mode pause: DeepSeek caps the THINK phase and shows a
             // Continue button; the model does not resume by itself. Click it so the
-            // answer keeps flowing instead of waiting for the operator.
-            if (this.autoContinue && (await this._clickContinueIfVisible())) {
+            // answer keeps flowing instead of waiting for the operator. Only probe
+            // PROACTIVELY when the reasoning (Deep thinking) toggle is ON: the
+            // THINK-phase pause does not occur without it, so an idle probe on every
+            // tick is a wasted evaluate. The truncated / finished-without-answer
+            // branches above stay unconditional — those are server faults, not a
+            // reasoning pause, and occur with the toggle off too.
+            if (this.autoContinue &&
+                this.deepThinking &&
+                (await this._clickContinueIfVisible())) {
                 this._askDebug('CLICKED Continue (finish-loop)');
                 continue;
             }
@@ -2156,8 +2170,11 @@ export class DeepSeekBrowser {
                     // A PAUSED generation also looks "stable" (the text stops changing
                     // while Continue is on screen), so the old check returned the
                     // partial answer here — the "agent stopped with a Continue button"
-                    // symptom. Click Continue and keep waiting instead.
-                    if (this.autoContinue && (await this._continueButtonVisible())) {
+                    // symptom. Click Continue and keep waiting instead. Only relevant
+                    // with the reasoning toggle ON (the THINK-phase pause).
+                    if (this.autoContinue &&
+                        this.deepThinking &&
+                        (await this._continueButtonVisible())) {
                         if (await this._clickContinueIfVisible()) {
                             this._askDebug('CLICKED Continue (before early return)');
                         }
@@ -2205,7 +2222,8 @@ export class DeepSeekBrowser {
         if (last && (normText(last) !== normText(beforeText) || this._netCapture)) {
             // If Continue is STILL on screen, the turn is paused, not finished:
             // click once more and report what we have rather than silently stopping.
-            if (this.autoContinue)
+            // Only with the reasoning toggle ON (the THINK-phase pause).
+            if (this.autoContinue && this.deepThinking)
                 await this._clickContinueIfVisible();
             this._askDebug('RETURN last len=' + last.length);
             return last;

package/dist/checkpoint.js

@@ -69,6 +69,19 @@ function runTar(args, cwd, timeout = 60_000) {
         });
     });
 }
+// Git fingerprint of a working tree: HEAD plus the porcelain status. Two
+// snapshots with the same fingerprint hold the same TRACKED state, so a
+// second checkpoint would be a duplicate. Returns null for a non-git dir (or
+// when git is unavailable) — then the caller always snapshots (no debounce).
+function workdirFingerprint(workdir) {
+    return new Promise((resolve) => {
+        execFile('git', ['-C', workdir, 'status', '--porcelain=v1', '--branch'], { timeout: 10_000, maxBuffer: 1024 * 1024, windowsHide: true }, (err, stdout) => {
+            if (err)
+                return resolve(null);
+            resolve(String(stdout || '').trim() || 'clean');
+        });
+    });
+}
 async function copyTree(from, to) {
     await fs.mkdir(to, { recursive: true });
     const entries = await fs.readdir(from, { withFileTypes: true });
@@ -116,10 +129,34 @@ export class CheckpointStore {
      * unreadable dir or a timeout yields null, never a thrown error — a failed
      * checkpoint must not abort the task it was meant to protect.
      */
-    async create(workdir, label) {
+    async create(workdir, label, 
+    /** When false, always create a new archive (skip the fingerprint dedupe). */
+    allowDedupe = true) {
         if (!this.enabled)
             return null;
         await this._ensure();
+        // Debounce: a checkpoint is taken before EVERY task, and consecutive
+        // tasks in one queue often start with an IDENTICAL tracked state (the
+        // previous task made no commit and no tracked edit that survived).
+        // Re-taring the whole tree then only burns time. If the last record for
+        // this workdir carries the SAME git fingerprint, reuse it instead of
+        // snapshotting again. Non-git dirs get a null fingerprint and are always
+        // snapshotted (we cannot cheaply prove the tree is unchanged).
+        const fingerprint = allowDedupe ? await workdirFingerprint(workdir) : null;
+        if (fingerprint) {
+            const history = await this._readIndex();
+            const last = [...history]
+                .reverse()
+                .find((r) => r.workdir === workdir && r.fingerprint);
+            if (last &&
+                last.fingerprint === fingerprint &&
+                (await fs
+                    .access(last.file)
+                    .then(() => true)
+                    .catch(() => false))) {
+                return last;
+            }
+        }
         const stamp = Date.now();
         // Two checkpoints in the SAME millisecond would share `${stamp}.tgz` and
         // the second would overwrite the first (losing a snapshot). Add a random
@@ -134,6 +171,8 @@ export class CheckpointStore {
         const record = { stamp, file, workdir };
         if (label)
             record.label = label;
+        if (fingerprint)
+            record.fingerprint = fingerprint;
         const history = await this._readIndex();
         history.push(record);
         const kept = rotateRecords(history, this.maxBackups);
@@ -171,7 +210,7 @@ export class CheckpointStore {
         if (!exists)
             return { ok: false, reason: 'archive_missing' };
         // Backup the CURRENT tree before touching it.
-        const backup = await this.create(record.workdir, 'pre-rewind');
+        const backup = await this.create(record.workdir, 'pre-rewind', false);
         // Extract to a temp dir FIRST; only a successful extract may touch workdir
         // (otherwise a bad archive would wipe the tree).
         const tmp = await fs.mkdtemp(path.join(os.tmpdir(), 'zames-rewind-'));

package/dist/commands.js

@@ -981,7 +981,6 @@ export const SLASH_COMMANDS = [
     { name: '/clear', key: 'help.cmd.new' },
     { name: '/sessions', key: 'help.cmd.sessions' },
     { 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: '/retry', key: 'help.cmd.retry' },

package/dist/i18n/common.js

@@ -64,10 +64,6 @@ 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': {
@@ -258,14 +254,6 @@ export const commonMessages = {
         ru: 'Нет блока кода #{n}.',
         en: 'No code block #{n}.',
     },
-    'copy.code_hint': {
-        ru: 'блок кода {n}/{m} · Ctrl+Y — копировать',
-        en: 'code block {n}/{m} · Ctrl+Y to copy',
-    },
-    'copy_code.usage': {
-        ru: 'Использование: /copy-code [номер] — копировать блок кода последнего ответа (по умолчанию последний). /copy-code list — список.',
-        en: 'Usage: /copy-code [n] — copy a code block from the last answer (default: the last). /copy-code list — list them.',
-    },
     'copy_code.list': {
         ru: 'Блоки кода последнего ответа:',
         en: 'Code blocks in the last answer:',

package/dist/i18n/config.js

@@ -6,7 +6,6 @@ export const configMessages = {
     'cfg.group.checkpoint': { ru: 'Чекпойнты', en: 'Checkpoints' },
     'cfg.group.transcript': { ru: 'Транскрипт', en: 'Transcript' },
     'cfg.group.browser': { ru: 'Браузер / DeepSeek', en: 'Browser / DeepSeek' },
-    'cfg.group.qwen': { ru: 'Qwen', en: 'Qwen' },
     'cfg.f.provider': { ru: 'Провайдер чата', en: 'Chat provider' },
     'cfg.f.qwen_model': {
         ru: 'Модель Qwen (id)',

package/dist/i18n/help.js

@@ -133,10 +133,6 @@ export const helpMessages = {
         ru: '/chats [фильтр]          список последних чатов DeepSeek',
         en: '/chats [filter]          recent DeepSeek chats',
     },
-    'help.cmd.resume': {
-        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',

package/dist/i18n/qwen.js

@@ -14,10 +14,6 @@ export const qwenMessages = {
         ru: 'Код из письма Qwen: ',
         en: 'Qwen email code: ',
     },
-    'qwen.login_pass_prompt': {
-        ru: 'Пароль Qwen: ',
-        en: 'Qwen password: ',
-    },
     'qwen.login_ok': {
         ru: 'Qwen: вход выполнен.',
         en: 'Qwen: signed in.',

package/dist/i18n/self-review.js

@@ -113,8 +113,8 @@ export const selfReviewMessages = {
         en: 'Pick a chat (↑/↓, Enter to open, Esc to cancel)',
     },
     'chats.use_resume': {
-        ru: '\nИспользуй /resume <n> для продолжения.\n',
-        en: '\nUse /resume <n> to continue.\n',
+        ru: '\nДля продолжения используй /resume-id <id> (полный id в скобках).\n',
+        en: '\nTo continue use /resume-id <id> (the full id in brackets).\n',
     },
     'chats.none_hint': {
         ru: 'Чатов не найдено. Возможно, сайдбар свёрнут или селекторы устарели.',
@@ -128,22 +128,6 @@ export const selfReviewMessages = {
         ru: ' Системный промпт НЕ пересылается (он уже в начале чата). Включить: /config set browser.resendPromptOnResume true.\n',
         en: ' The system prompt is NOT resent (it is already at the start of the chat). Enable: /config set browser.resendPromptOnResume true.\n',
     },
-    'chats.resume_usage': {
-        ru: 'Использование: /resume <n>  (или /chats для списка)',
-        en: 'Usage: /resume <n>  (or /chats for the list)',
-    },
-    'chats.need_number': {
-        ru: 'Нужен номер из /chats.',
-        en: 'A number from /chats is required.',
-    },
-    'chats.run_chats_first': {
-        ru: 'Сначала выполни /chats.',
-        en: 'Run /chats first.',
-    },
-    'chats.no_n': {
-        ru: 'Нет чата №{n}. Всего: {total}.',
-        en: 'No chat #{n}. Total: {total}.',
-    },
     'chats.opening': { ru: 'Открываю: {v}', en: 'Opening: {v}' },
     'chats.prompt_will_resend': {
         ru: ' Системный промпт будет переслан на следующей задаче.\n',

package/dist/i18n/spinner.js

@@ -30,6 +30,11 @@ export const spinnerMessages = {
         ru: 'Напишите задачу и нажмите Enter. /help — команды, Ctrl+J — новая строка.',
         en: 'Type a task and press Enter. /help for commands, Ctrl+J for a new line.',
     },
+    // One-line key hint UNDER the input box (full-screen mode).
+    'editor.keys_hint': {
+        ru: 'выделение — Shift+протяжка · колесо — скролл · PgUp/PgDn листают · Home/End — в начало/конец',
+        en: 'select — Shift+drag · wheel — scroll · PgUp/PgDn scroll · Home/End top/bottom',
+    },
     // Reverse search (Ctrl+R) status line. The query may be empty.
     'editor.search_prompt': {
         ru: '(обратный поиск) `{q}` — Ctrl+R дальше, Enter принять, Esc отмена',

package/dist/index.js

@@ -155,7 +155,7 @@ if (jsonMode) {
 // ---------- session persistence ----------
 // We store sessions (DeepSeek chats) in ~/.zames/.sessions so they survive
 // a restart and are available for explicit restore (--resume-last,
-// --chat <id>, /resume <n>). They are NOT brought up automatically on launch.
+// --chat <id>, /resume-id <id>). They are NOT brought up automatically on launch.
 // Previously there was a single last-chat.json file that got lost when the
 // project changed and gave no list of sessions to restore.
 function saveLastChat(id, workdir = '', title = '') {
@@ -163,7 +163,7 @@ function saveLastChat(id, workdir = '', title = '') {
         return;
     // Tag the session with the ACTIVE provider: a chat id is only meaningful to
     // the backend that created it, so a later resume must open it in the same
-    // one (or refuse). Without this a /provider switch made /resume try to open a
+    // one (or refuse). Without this a /provider switch made a resume try to open a
     // qwen id in DeepSeek (and vice versa).
     saveSession({ id, workdir, title, provider: config.provider });
 }
@@ -446,7 +446,6 @@ ${theme.bold(t('help.sec.session'))}
   ${t('help.cmd.new')}
   ${t('help.cmd.sessions')}
   ${t('help.cmd.chats')}
-  ${t('help.cmd.resume')}
   ${t('help.cmd.resume_id')}
   ${t('help.cmd.last')}
   ${t('help.cmd.retry')}
@@ -1007,7 +1006,10 @@ async function main() {
     // `--resend-prompt` or `browser.resendPromptOnResume` forces it (e.g. when
     // the prompt/tools changed).
     const promptOnResume = () => resendPrompt || config.browser.resendPromptOnResume === true;
-    let lastChats = [];
+    // Assigned by the /chats handler before it is read; no initial value needed
+    // (the empty-array default was flagged as a useless assignment once the
+    // /resume <n> handler that read it was removed).
+    let lastChats;
     let currentChatId = null;
     // The last task the operator sent (used by /retry). Plain text only.
     let lastTaskText = '';
@@ -1081,7 +1083,7 @@ async function main() {
             total: String(items.length),
         });
     };
-    // Re-inject a persisted checklist after /resume or the startup restore.
+    // Re-inject a persisted checklist after /resume-id or the startup restore.
     // The list is REPLACED (not merged): a resumed chat with no saved checklist
     // must clear the previous chat's tasks, otherwise the status line keeps
     // showing them for a chat that never had them.
@@ -1234,17 +1236,18 @@ async function main() {
         });
     };
     const buildPrompt = () => {
-        let tail;
         if (reviewMode) {
-            tail =
+            // Review mode is rare and MEANINGFUL, so it stays in the prompt.
+            return (theme.prompt('❯ ') +
+                theme.dim('(') +
                 theme.warn(t('prompt.review')) +
-                    theme.dim(':') +
-                    theme.dir(reviewMode.snapName);
+                theme.dim(':') +
+                theme.dir(reviewMode.snapName) +
+                theme.dim(') '));
         }
-        else {
-            tail = theme.dir(dirLabel(currentWorkdir));
-        }
-        return theme.prompt('❯ ') + tail + theme.dim(' › ');
+        // No working-directory tail: it ate input width and is already in the
+        // header / /pwd. A bare prompt keeps room for the task text.
+        return theme.prompt('❯ ') + theme.dim('› ');
     };
     await refreshDynamicCommands(currentWorkdir);
     if (process.stdin.isTTY && process.stdout.isTTY) {
@@ -1598,13 +1601,8 @@ 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')));
-            }
+            // The key/selection hint is now a PERSISTENT row under the input box
+            // (FullScreenApp), so the old one-time printAbove is redundant.
         }
         catch (e) {
             // A TUI mount failure must not kill the agent. We surface it and let the
@@ -1900,7 +1898,7 @@ async function main() {
         });
     }
     // Open a chat by its ChatInfo and print the restored dialogue. Shared by
-    // /resume and the interactive /chats list, so both paths behave identically
+    // /resume-id and the interactive /chats list, so both paths behave identically
     // (todos reloaded, prompt-resend decision, transcript event).
     const openResumedChat = async (pick) => {
         if (editor)
@@ -2016,16 +2014,19 @@ async function main() {
             }
             else {
                 let tail;
+                // The non-TTY fallback prompt mirrors buildPrompt(): bare, no dir.
                 if (reviewMode) {
                     tail =
-                        theme.warn(t('prompt.review')) +
+                        theme.dim('(') +
+                            theme.warn(t('prompt.review')) +
                             theme.dim(':') +
-                            theme.dir(reviewMode.snapName);
+                            theme.dir(reviewMode.snapName) +
+                            theme.dim(') ');
                 }
                 else {
-                    tail = theme.dir(dirLabel(currentWorkdir));
+                    tail = theme.dim('› ');
                 }
-                input = await promptOnce(theme.prompt('❯ ') + tail + theme.dim(' › '));
+                input = await promptOnce(theme.prompt('❯ ') + tail);
             }
         }
         catch {
@@ -2327,8 +2328,8 @@ async function main() {
                             continue;
                     }
                     console.log(theme.system(t('chats.recent')));
-                    // The number is the index in the FULL list, so `/resume <n>` keeps
-                    // pointing at the same chat even when a filter narrows the view.
+                    // The number is the index in the FULL list (a filter only narrows
+                    // the VIEW), and the full id in brackets is what /resume-id takes.
                     for (const c of shown) {
                         const idx = lastChats.indexOf(c);
                         const n = String(idx + 1).padStart(2, ' ');
@@ -2347,29 +2348,6 @@ async function main() {
             }
             continue;
         }
-        if (lower === '/resume' || lower.startsWith('/resume ')) {
-            const arg = trimmed.slice(7).trim();
-            if (!arg) {
-                console.error(theme.error(t('chats.resume_usage')));
-                continue;
-            }
-            const n = Number(arg);
-            if (!Number.isFinite(n) || n < 1) {
-                console.error(theme.error(t('chats.need_number')));
-                continue;
-            }
-            if (!lastChats.length) {
-                console.error(theme.error(t('chats.run_chats_first')));
-                continue;
-            }
-            const pick = lastChats[n - 1];
-            if (!pick) {
-                console.error(theme.error(t('chats.no_n', { n, total: lastChats.length })));
-                continue;
-            }
-            await openResumedChat(pick);
-            continue;
-        }
         if (lower === '/provider' || lower.startsWith('/provider ')) {
             const arg = trimmed.slice('/provider'.length).trim().toLowerCase();
             if (!arg || arg === 'status') {

package/dist/system-prompt.js

@@ -234,6 +234,33 @@ Prefer the most specific tool; a wrong choice wastes a turn:
 - Reading a file whose path you already know -> Read, not Bash cat.
 - A broad search/exploration that would flood this chat -> the Task tool
   (a subagent in its own chat) if it is available, then work from its report.
+
+## Batch independent calls (IMPORTANT: saves round-trips)
+
+Every separate turn costs a full send + throttle pause, so DO NOT dribble
+calls out one at a time when you already know several are needed. When the
+next step requires reading, searching or writing SEVERAL known targets, emit
+ONE JSON array with all of them in a single answer:
+
+[{"tool": "Read", "args": {"path": "a.ts"}},
+ {"tool": "Read", "args": {"path": "b.ts"}},
+ {"tool": "Grep", "args": {"pattern": "foo", "include": "*.ts"}}]
+
+Rules for a batch:
+- BATCH only INDEPENDENT calls: no call may depend on another call's result
+  (do not batch a Read and an Edit of the same file, and never batch two
+  writes to the SAME path).
+- Read-only calls (Read, Glob, Grep, LS, WebFetch) run CONCURRENTLY, so a
+  batch of them is several times faster than the same calls one by one.
+- Writing to SEVERAL DIFFERENT files can be batched too (e.g. three Write
+  calls to three different new paths, or Edits to different files). Mutating
+  calls in a batch run in order, so a batch still saves the extra round-trips
+  even though the writes themselves are serialized.
+- If the next step depends on what a call RETURNS, that call must be alone
+  (or be the last one in the batch).
+- Typical wins: read all the files a task mentions at once; grep for all the
+  symbols you need at once; after planning a multi-file change, write all the
+  files you can write independently at once.
 ${subagentSection}
 ## MCP tools
 

package/dist/tui/FullScreenApp.js

@@ -63,7 +63,12 @@ export function FullScreenApp({ store, inputProps, }) {
     // 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, cols);
-    const panelRows = HEADER_ROWS + STATUS_ROWS + INPUT_BOX_ROWS + suggestRows;
+    // A one-line hint UNDER the input box (selection / scroll keys). It is part
+    // of the fixed panel height, so the log viewport shrinks by one row instead
+    // of the panel overflowing; `cursorTop` (measured from the top) is NOT
+    // affected, so the caret cannot move.
+    const HINT_ROWS = 1;
+    const panelRows = HEADER_ROWS + STATUS_ROWS + INPUT_BOX_ROWS + suggestRows + HINT_ROWS;
     const logHeight = Math.max(1, termRows - panelRows);
     // Window the log BY RENDERED ROW: a long wrapped answer can be taller than
     // one entry, and an entry-count window either overflowed the panel or left
@@ -108,6 +113,6 @@ export function FullScreenApp({ store, inputProps, }) {
     }, state.mouseScroll);
     return (_jsxs(Box, { flexDirection: "column", height: termRows, children: [_jsx(Header, { store: store }), _jsx(Box, { flexDirection: "column", height: logHeight, overflow: "hidden", justifyContent: "flex-end", children: all.length === 0 ? (_jsx(Text, { color: "#5b616e", children: translate(state.locale)('editor.empty_hint') })) : (_jsx(LogList, { entries: visible })) }), _jsx(StatusBar, { state: state, divider: false }), _jsx(InputLine, { ...inputProps, store: store, 
                 // Cursor rows above the input box: header + log viewport + status.
-                cursorTop: HEADER_ROWS + logHeight + suggestRows + STATUS_ROWS + 1, prompt: state.prompt, locale: state.locale, commands: state.commands, locked: state.locked })] }));
+                cursorTop: HEADER_ROWS + logHeight + suggestRows + STATUS_ROWS + 1, prompt: state.prompt, locale: state.locale, commands: state.commands, locked: state.locked }), _jsx(Text, { color: "#5b616e", wrap: "truncate", children: ' ' + translate(state.locale)('editor.keys_hint') })] }));
 }
 void contentWidth;

package/dist/tui/TuiEditor.js

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

package/dist/tui/keys.js

@@ -35,7 +35,8 @@ export function parseCsiU(raw) {
     if (cp === 13 && (ctrl || alt))
         return { type: 'newline' };
     if (cp === 3) {
-        return ctrl || alt ? { type: 'deleteWordRight' } : { type: 'delete' };
+        // Ctrl/Alt+Delete deletes the word on the LEFT (see dispatchKey).
+        return ctrl || alt ? { type: 'deleteWordLeft' } : { type: 'delete' };
     }
     if (cp === 127) {
         return ctrl || alt ? { type: 'deleteWordLeft' } : { type: 'backspace' };
@@ -84,8 +85,11 @@ export function dispatchKey(input, key, ctx, isVisualEdge) {
             return { type: 'wordLeft' };
         if (key.rightArrow)
             return { type: 'wordRight' };
+        // Ctrl+Delete deletes the word BEFORE the cursor (the operator's binding:
+        // "Ctrl+Del must delete the word before the cursor"). Ctrl+Backspace does
+        // the same. Plain Delete still deletes one char to the RIGHT.
         if (key.delete)
-            return { type: 'deleteWordRight' };
+            return { type: 'deleteWordLeft' };
         if (key.backspace)
             return { type: 'deleteWordLeft' };
         if (key.home)
@@ -140,10 +144,17 @@ export function dispatchKey(input, key, ctx, isVisualEdge) {
             return { type: 'wordLeft' };
         if (input === 'f')
             return { type: 'wordRight' };
+        // VSCode sends Ctrl+Delete as `ESC d` (which Ink reports as Alt+d).
+        // The operator expects it to delete the word BEFORE the cursor.
+        if (input === 'd')
+            return { type: 'deleteWordLeft' };
         if (key.backspace)
             return { type: 'deleteWordLeft' };
+        // Alt/Ctrl+Delete also deletes the word BEFORE the cursor (the operator's
+        // binding, consistent with ESC d): some terminals encode Ctrl+Delete as
+        // meta+Delete rather than ESC d.
         if (key.delete)
-            return { type: 'deleteWordRight' };
+            return { type: 'deleteWordLeft' };
         return null;
     }
     // ---- LF as a bare newline (Ctrl+J) ----

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zames_pro",
-  "version": "2.75.0",
+  "version": "2.75.2",
   "description": "Terminal coding agent that drives a real browser to chat with DeepSeek, Qwen and other web LLMs — no API key required. Reads and edits files, runs commands, commits to git, like Claude Code / Codex CLI.",
   "type": "module",
   "bin": {

package/scripts/ctd-live-driver.mts

@@ -0,0 +1,51 @@
+// Drive the live-like probe: type a seed, then send Ctrl+Delete in EVERY
+// encoding a terminal might use, and print the raw bytes + the buffer.
+import { spawn } from 'node:child_process'
+import fs from 'node:fs'
+import path from 'node:path'
+
+const ESC = String.fromCharCode(27)
+const LOG = '/tmp/ctd-live.log'
+try {
+  fs.unlinkSync(LOG)
+} catch {
+  /* ignore */
+}
+
+const child = spawn(
+  'script',
+  ['-qec', 'npx tsx scripts/ctd-live.tsx', '/dev/null'],
+  {
+    cwd: path.resolve('.'),
+    env: { ...process.env, COLUMNS: '80', LINES: '24', PROBE_CTD_LOG: LOG },
+  },
+)
+child.stdout.on('data', () => {})
+child.stderr.on('data', () => {})
+
+const seq = process.argv[2] || 'xterm'
+const enc: Record<string, string> = {
+  xterm: ESC + '[3;5~',
+  kitty: ESC + '[3;5u',
+  vt: ESC + '[3;5:1~',
+}
+const bytes = enc[seq] ?? seq
+
+setTimeout(() => {
+  child.stdin.write('foo bar baz') // seed
+  setTimeout(() => {
+    child.stdin.write(bytes) // the Ctrl+Delete encoding
+    setTimeout(() => {
+      const log = fs.readFileSync(LOG, 'utf-8')
+      process.stdout.write('=== ' + seq + ' ===' + String.fromCharCode(10))
+      process.stdout.write(
+        log
+          .split(String.fromCharCode(10))
+          .filter((l) => l.startsWith('RAW') || l.startsWith('BUF'))
+          .join(String.fromCharCode(10)) + String.fromCharCode(10),
+      )
+      child.kill('SIGTERM')
+    }, 500)
+  }, 400)
+}, 5000)
+child.on('close', () => process.exit(0))

package/scripts/ctd-live.tsx

@@ -0,0 +1,33 @@
+// Minimal LIVE-like probe: the REAL TuiEditor exactly as index.ts builds it
+// (default options), plus a raw-stdin TAP that logs every byte the terminal
+// sends, so we can see EXACTLY what Ctrl+Delete produces on this terminal.
+import fs from 'node:fs'
+import { TuiEditor } from '../src/tui/TuiEditor.js'
+
+const LOG = process.env.PROBE_CTD_LOG || '/tmp/ctd-live.log'
+fs.writeFileSync(LOG, '')
+const w = (s: string): void => {
+  fs.appendFileSync(LOG, s + String.fromCharCode(10))
+}
+
+const ed = new TuiEditor({
+  prompt: '❯ › ',
+  commands: [],
+  locale: 'ru',
+  alternateScreen: true,
+})
+ed.onSubmit = () => {}
+ed.onAttach = () => null
+ed.onClipboard = () => Promise.resolve(null)
+ed.start()
+
+// Tap raw stdin: hex-dump every chunk so we see the exact bytes.
+process.stdin.on('data', (d: Buffer) => {
+  w('RAW ' + d.toString('hex') + ' ' + JSON.stringify(d.toString('utf-8')))
+})
+// Log the buffer after every change.
+ed.store.subscribe(() => {
+  const s = ed.store.getSnapshot().edit
+  w('BUF ' + JSON.stringify(s.buf) + ' cur=' + s.cursor)
+})
+setInterval(() => {}, 1 << 30)

package/scripts/escd-live-driver.mts

@@ -0,0 +1,37 @@
+// Send `ESC d` (what VSCode sends for Ctrl+Delete) to the REAL TuiEditor and
+// print the resulting buffer.
+import { spawn } from 'node:child_process'
+import fs from 'node:fs'
+import path from 'node:path'
+const ESC = String.fromCharCode(27)
+const LOG = '/tmp/ctd-live.log'
+try {
+  fs.unlinkSync(LOG)
+} catch {}
+const child = spawn(
+  'script',
+  ['-qec', 'npx tsx scripts/ctd-live.tsx', '/dev/null'],
+  {
+    cwd: path.resolve('.'),
+    env: { ...process.env, COLUMNS: '80', LINES: '24', PROBE_CTD_LOG: LOG },
+  },
+)
+child.stdout.on('data', () => {})
+child.stderr.on('data', () => {})
+setTimeout(() => {
+  child.stdin.write('foo bar baz')
+  setTimeout(() => {
+    child.stdin.write(ESC + 'd')
+    setTimeout(() => {
+      const log = fs.readFileSync(LOG, 'utf-8')
+      process.stdout.write(
+        log
+          .split(String.fromCharCode(10))
+          .filter((l) => l.startsWith('RAW') || l.startsWith('BUF'))
+          .join(String.fromCharCode(10)) + String.fromCharCode(10),
+      )
+      child.kill('SIGTERM')
+    }, 500)
+  }, 400)
+}, 5000)
+child.on('close', () => process.exit(0))

package/scripts/ru-shot.mts

@@ -0,0 +1,20 @@
+import { spawn } from 'node:child_process'
+import path from 'node:path'
+import { Term } from '../test/vt100.mts'
+const NL = String.fromCharCode(10)
+const term = new Term(20, 80)
+const child = spawn(
+  'script',
+  ['-qec', 'npx tsx scripts/tui-repro.tsx', '/dev/null'],
+  {
+    cwd: path.resolve('.'),
+    env: { ...process.env, COLUMNS: '80', LINES: '20', PROBE_LOCALE: 'ru' },
+  },
+)
+child.stdout.on('data', (d) => term.write(d.toString('utf-8')))
+child.stderr.on('data', (d) => term.write(d.toString('utf-8')))
+setTimeout(() => {
+  process.stdout.write(term.render() + NL)
+  child.kill('SIGTERM')
+}, 5000)
+child.on('close', () => process.exit(0))

package/scripts/tui-repro.tsx

@@ -28,8 +28,8 @@ store.set({
   title: 'zames_pro',
   version: '2.34.0',
   workdir: '/workspaces/zames/zames_pro',
-  prompt: '➔ zames_pro › ',
-  locale: 'en',
+  prompt: '❯ › ',
+  locale: process.env.PROBE_LOCALE === 'ru' ? 'ru' : 'en',
   commands,
   edit: { ...initialEditState(), buf: process.argv[2] ?? '' },
 })