zames_pro 2.10.7 → 2.10.9

package/dist/agent-loop.js

@@ -20,6 +20,11 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
         };
     };
     const safeThinking = safe(onThinking);
+    // Start the "working" indicator ONLY when a message is really sent (after
+    // the send-pause), not while the loop is still preparing the request.
+    // Previously safeThinking() fired before browser.ask(), so the spinner ran
+    // through the whole throttle pause / chat-open phase with nothing in flight.
+    browser.onSendStart = safeThinking;
     const safeAssistantThought = safe(onAssistantThought);
     const safeToolCall = safe(onToolCall);
     const safeToolResult = safe(onToolResult);
@@ -117,6 +122,14 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
     // instead get an EMPTY answer or the EXACT same answer as the previous turn
     // (a sign the new message was not sent), we nudge instead of stopping.
     let lastRaw = '';
+    // True when the PREVIOUS turn actually executed a tool. This is what
+    // makes a repeated answer "stale": the tool already ran, so running it
+    // again would duplicate side effects. If the previous answer looked like a
+    // call but was not recognized (e.g. a DSML/XML form the strict parser
+    // missed), the tool did NOT run and the echo is the only copy of the
+    // call — it must be executed, not discarded as stale.
+    // const ranToolLastTurn follows the previous turn's actual effect.
+    let lastTurnRanTool = false;
     let justRanTool = false;
     let watchdogRetries = 0;
     const MAX_WATCHDOG_RETRIES = 3;
@@ -126,11 +139,18 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
     let afterToolRetries = 0;
     const MAX_AFTER_TOOL_RETRIES = 6;
     for (let i = 0; i < maxIterations; i++) {
-        safeThinking();
+        // NOTE: the spinner is NOT started here. browser.onSendStart fires it
+        // right when the message is actually typed/sent (after the send-pause),
+        // so no spinner runs during the pre-send phase.
         // The first message (task) is user input: no throttle.
         // Subsequent ones (tool-result and resend requests) are agent sends:
         // throttled so we don't hit the rate limit.
         const isFirst = i === 0;
+        // Did the PREVIOUS turn actually execute a tool? Used by the stale
+        // check below. We take a snapshot and immediately clear it: it will be
+        // set again at the end of this iteration only if a tool really runs.
+        const ranToolPrevTurn = lastTurnRanTool;
+        lastTurnRanTool = false;
         // Safety net: browser.ask() has its own timeout, but a stuck send used to
         // block the whole loop and look like a silent stop. We race it against a
         // hard deadline and treat a timeout as a nudge (re-ask), never as a
@@ -194,18 +214,31 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
         // previous answer with different markdown emphasis (`**done**` vs `done`),
         // which defeated an exact match and made the loop run the SAME tool again —
         // the "stopped after a tool call" signature with a duplicate call.
-        const wdStale = justRanTool &&
+        //
+        // AN ECHO IS NOT ALWAYS STALE: the previous answer may have been a
+        // DSML/XML call that the strict parser missed and the loop never actually
+        // ran. In that case the echo is the ONLY copy of the call we can get,
+        // and discarding it as "stale" burns the watchdog budget and stalls the
+        // agent. So we first check whether the echo itself parses as a tool
+        // call (including the XML/DSML form); if it does, we do NOT treat it
+        // as stale — the call gets run below like any other.
+        // Stale means: the PREVIOUS turn actually ran a tool (lastTurnRanTool)
+        // and this answer is a repeat of the previous one. If the previous
+        // answer never ran a tool (unrecognized DSML call), the repeat is NOT
+        // stale — it is the only copy of the call and must be executed.
+        const staleCandidate = ranToolPrevTurn &&
             lastRaw.trim() !== '' &&
             (rawResponse.trim() === lastRaw.trim() ||
                 normForStale(rawResponse) === normForStale(lastRaw));
+        const wdStale = staleCandidate;
         const wdNoCall = justRanTool &&
             !wdEmpty &&
             !wdStale &&
             parseToolCall(rawResponse) === null &&
             !responseLooksLikeToolCall(rawResponse);
-        // A stale answer is discarded even when it parses to a valid call: it is a
-        // duplicate of the previous turn, and re-running the tool would repeat
-        // side effects and stall the loop.
+        // A stale answer is discarded only when it does NOT parse as a tool
+        // call (see wdStale above); an echo of a call that never ran is a real
+        // call and must be executed, not dropped.
         if (!isFirst && (wdEmpty || wdStale || wdNoCall) && watchdogRetries < MAX_WATCHDOG_RETRIES) {
             watchdogRetries++;
             transcript?.log('watchdog_nudge', {
@@ -464,6 +497,10 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
         // A tool just ran — the next answer is expected to be a fresh tool call.
         // Reset the watchdog so the next empty/repeated answer is nudged.
         justRanTool = true;
+        // The tool really executed on this turn. The NEXT iteration will treat
+        // a repeat of this answer as stale only because of this flag (see NEXT,
+        // not the current, justRanTool check).
+        lastTurnRanTool = true;
         watchdogRetries = 0;
         // A fresh tool call just ran: reset the per-tool-result nudge budget so
         // a long chain of tools is not cut off by an earlier bad turn.

package/dist/browser.js

@@ -139,6 +139,11 @@ export class DeepSeekBrowser {
     _netSniff;
     _netSniffLimit;
     _netHookInstalled;
+    // Fired right when a message is actually typed/sent (AFTER the send-pause
+    // and attachments). Used to start the "agent is working" spinner only when
+    // a generation really begins, not during the pre-send phase (chat open,
+    // throttle wait), which used to show a spinner with no work in flight.
+    onSendStart;
     constructor({ headless = false, debug = false, channel = 'chrome', answerTimeoutMs = 180000, askRetries = 3, stabilityChecks = 3, stabilityDelayMs = 1000, minSendIntervalMs = 15000, rateLimitWaitMs = 300000, maxRateLimitRetries = 6, maxServerBusyRetries = 5, serverBusyWaitMs = 3000, } = {}) {
         this.headless = headless;
         this.debug = debug;
@@ -161,6 +166,7 @@ export class DeepSeekBrowser {
         this._netSniff = [];
         this._netSniffLimit = 5;
         this._netHookInstalled = false;
+        this.onSendStart = null;
     }
     async launch() {
         await killStaleChrome();
@@ -460,7 +466,11 @@ export class DeepSeekBrowser {
                         throw e;
                     }
                     console.error(theme.warn(`⏳ DeepSeek: «слишком часто». Жду ${Math.ceil(this.rateLimitWaitMs / 60000)} мин (${rateLimitRetries}/${this.maxRateLimitRetries}) и повторю...`));
-                    await this.page.waitForTimeout(this.rateLimitWaitMs);
+                    // Interruptible: Esc/Ctrl+C must cancel this long wait too,
+                    // otherwise "stop" stays frozen for up to 5 minutes.
+                    const aborted = await this._sleepInterruptible(this.rateLimitWaitMs);
+                    if (aborted)
+                        return '(прервано пользователем)';
                     continue;
                 }
                 console.error(`\n⚠ ask() попытка ${attempt}/${this.askRetries} провалилась: ${e.message}`);
@@ -605,6 +615,12 @@ export class DeepSeekBrowser {
     // Pause between sends. Applied ONLY to agent messages
     // (tool-result, system-prompt) so we don't hit the rate limit.
     // User input is sent without delay.
+    //
+    // The wait is INTERRUPTIBLE: Esc/Ctrl+C sets _abort, and we check it every
+    // 100ms instead of one long page.waitForTimeout(gap). Before, Esc pressed
+    // during this pause did nothing to the pause itself — the send was still
+    // delayed by the remaining seconds, and the stop request only took effect
+    // after the pause. This is the main "Esc does not cancel the pause" bug.
     async _waitForSendSlot(agent) {
         if (!agent)
             return;
@@ -614,7 +630,21 @@ export class DeepSeekBrowser {
         if (gap <= 0)
             return;
         console.error(theme.warn(`⏳ пауза ${Math.ceil(gap / 1000)}с перед отправкой`));
-        await this.page.waitForTimeout(gap);
+        await this._sleepInterruptible(gap);
+    }
+    // Sleep in small slices so Esc/Ctrl+C can cancel the wait promptly.
+    // Returns true if the sleep was cut short by _abort.
+    async _sleepInterruptible(ms) {
+        const step = 100;
+        let left = ms;
+        while (left > 0) {
+            if (this._abort)
+                return true;
+            const chunk = Math.min(step, left);
+            await this.page.waitForTimeout(chunk);
+            left -= chunk;
+        }
+        return this._abort;
     }
     // DEBUG: append ask() phases to ~/.zames/ask-debug.log so a stall can be
     // diagnosed from the field (what the DOM/network looked like at each step).
@@ -630,7 +660,12 @@ export class DeepSeekBrowser {
     }
     async _askOnce(prompt, { timeout, agent, attachments = [], }) {
         // We reset the abort flag ONLY at the very start of the send.
+        // _stopped (Esc for the WHOLE batch) is NOT reset here: it may have been
+        // set while a previous send was waiting in the pause. If it is set, the
+        // user asked to stop and we must not start a new generation at all.
         this._abort = false;
+        if (this._stopped)
+            return '(прервано пользователем)';
         const input = await this._findVisible(INPUT_SELECTORS, 10_000);
         if (!input) {
             throw new Error('Не найдено поле ввода. Запустите /debug-dom и поправьте INPUT_SELECTORS.');
@@ -638,6 +673,19 @@ export class DeepSeekBrowser {
         const beforeText = await this._readLastAnswerTextClean().catch(() => '');
         this._askDebug('SEND agent=' + agent + ' len=' + prompt.length + ' beforeLen=' + beforeText.length + ' beforeHead=' + JSON.stringify(beforeText.slice(0, 60)));
         await this._waitForSendSlot(agent);
+        // Esc/Ctrl+C pressed during the pause — do not send anything.
+        if (this._abort)
+            return '(прервано пользователем)';
+        // The pause is over and we are really about to type/send: only NOW start
+        // the "working" indicator. The spinner used to be started by the caller
+        // BEFORE ask(), so it ran for the whole throttle pause and chat-opening
+        // phase with no generation in flight.
+        if (this.onSendStart) {
+            try {
+                this.onSendStart();
+            }
+            catch { }
+        }
         this._netCapture = '';
         this._netCaptureAt = 0;
         // Attach files/images FIRST (before the text): the DeepSeek upload widget

package/dist/i18n.js

@@ -128,6 +128,7 @@ const CATALOG = {
     'msg.new_chat': { ru: 'Создаю новый чат...', en: 'Creating a new chat...' },
     'msg.new_chat_ok': { ru: 'Новый чат.', en: 'New chat.' },
     'msg.resuming': { ru: 'Восстанавливаю сессию {id}...', en: 'Restoring session {id}...' },
+    'msg.input_locked': { ru: 'Идёт операция, ввод временно заблокирован…', en: 'Operation in progress, input is temporarily locked…' },
     'msg.opening_chat': { ru: 'Открываю чат {id}...', en: 'Opening chat {id}...' },
     'msg.chat_opened': { ru: 'Чат открыт.', en: 'Chat opened.' },
     'msg.interactive': { ru: 'Интерактивный режим. Введите задачу. Команды — /help. Выход — /exit.', en: 'Interactive mode. Enter a task. Commands — /help. Exit — /exit.' },

package/dist/index.js

@@ -714,9 +714,15 @@ async function runTask(browser, tools, taskText, workdir, opts, attachments = []
         };
         // Execute the task, then everything the user managed to type while it
         // ran. The queue may be replenished right during draining.
+        //
+        // NOTE: we do NOT call ui.thinking() here. runAgentLoop() fires
+        // onThinking() right before the actual browser send (after the send
+        // pause, system-prompt, etc.), so the spinner only appears when a
+        // generation really starts. Calling it here made the spinner run for
+        // the whole pre-send phase (chat creation, throttle wait) with no
+        // generation in flight.
         while (true) {
-            ui.thinking();
-            await mod.runAgentLoop({
+            const outcome = await mod.runAgentLoop({
                 browser,
                 tools,
                 task: next.text,
@@ -735,6 +741,16 @@ async function runTask(browser, tools, taskText, workdir, opts, attachments = []
                 debugLog: debug,
                 locale: currentLocale,
             });
+            // The loop may end WITHOUT a model answer: an exhausted iteration
+            // limit or an ask() watchdog (the model stopped responding). In that
+            // case no assistant message was shown, and the operator saw the run
+            // just "stop" after a tool call with no explanation. Surface it.
+            if (outcome &&
+                (outcome.startsWith('Достигнут лимит итераций') ||
+                    outcome.startsWith('ask() watchdog'))) {
+                ui.warning(outcome);
+                transcript?.log('agent_no_answer', { outcome });
+            }
             // Aborted (Esc/Ctrl+C) — we don't start the next tasks from the queue
             // and clear it, so "stop" really stops everything.
             if (browser._stopped) {
@@ -770,6 +786,9 @@ async function runTask(browser, tools, taskText, workdir, opts, attachments = []
     finally {
         stopWatching();
         ui.stop();
+        // Detach the send hook so a later browser.ask() outside this task cannot
+        // start a stale spinner.
+        browser.onSendStart = null;
     }
 }
 // ---------- main ----------
@@ -1339,6 +1358,8 @@ async function main() {
         }
         if (['/new', '/clear', 'new'].includes(lower)) {
             console.log(theme.system(t('msg.new_chat')));
+            if (editor)
+                editor.lock(t('msg.input_locked'));
             try {
                 await browser.newChat();
                 freshChatNext = false;
@@ -1351,6 +1372,10 @@ async function main() {
             catch (e) {
                 console.error(theme.error(t('msg.new_chat_error', { v: e.message })), e.message);
             }
+            finally {
+                if (editor)
+                    editor.unlock();
+            }
             continue;
         }
         // ---------- Self-review ----------
@@ -1360,6 +1385,8 @@ async function main() {
             const originalWorkdir = reviewMode
                 ? reviewMode.originalWorkdir
                 : currentWorkdir;
+            if (editor)
+                editor.lock(t('msg.input_locked'));
             try {
                 const result = await mod.selfReview({
                     browser,
@@ -1388,6 +1415,10 @@ async function main() {
                 if (debug)
                     console.error(e.stack);
             }
+            finally {
+                if (editor)
+                    editor.unlock();
+            }
             continue;
         }
         if (lower === '/self-fix' || lower.startsWith('/self-fix ')) {
@@ -1513,6 +1544,8 @@ async function main() {
         // ---------- Regular commands ----------
         if (lower === '/chats') {
             const spin = editor || mod.createSpinner(currentLocale);
+            if (editor)
+                editor.lock(t('msg.input_locked'));
             spin.thinking();
             try {
                 lastChats = await browser.listChats(30);
@@ -1533,6 +1566,10 @@ async function main() {
                 spin.stop();
                 console.error(theme.error(t('chats.fetch_error')), e.message);
             }
+            finally {
+                if (editor)
+                    editor.unlock();
+            }
             continue;
         }
         if (lower === '/resume' || lower.startsWith('/resume ')) {
@@ -1556,6 +1593,8 @@ async function main() {
                 continue;
             }
             console.log(theme.system(t('chats.opening', { v: pick.title })));
+            if (editor)
+                editor.lock(t('msg.input_locked'));
             try {
                 await browser.openChat(pick.id);
                 currentChatId = pick.id;
@@ -1571,6 +1610,10 @@ async function main() {
             catch (e) {
                 console.error(theme.error(t('msg.open_chat_error', { v: '' })), e.message);
             }
+            finally {
+                if (editor)
+                    editor.unlock();
+            }
             continue;
         }
         if (lower === '/chat') {
@@ -1608,6 +1651,8 @@ async function main() {
                 console.error(theme.error(t('sessions.resume_id_usage')));
                 continue;
             }
+            if (editor)
+                editor.lock(t('msg.input_locked'));
             try {
                 console.log(theme.system(t('msg.opening_chat', { id })));
                 await browser.openChat(id);
@@ -1622,6 +1667,10 @@ async function main() {
             catch (e) {
                 console.error(theme.error(t('msg.open_chat_error', { v: '' })), e.message);
             }
+            finally {
+                if (editor)
+                    editor.unlock();
+            }
             continue;
         }
         if (lower === '/pwd') {

package/dist/input.js

@@ -207,6 +207,11 @@ export class LineEditor {
     // Clipboard callback: tries to read an image from the OS clipboard when the
     // terminal itself sends no usable data (Ctrl+V, right-click, empty paste).
     onClipboard;
+    // When locked, the editor ignores text input and Enter (submit). Used while
+    // a long operation runs (chat resume/open, /new, self-review): otherwise the
+    // user could type and send a message mid-operation, and it would be queued
+    // and sent right after the operation, breaking the restored session.
+    locked;
     constructor({ prompt = '> ', commands = [] } = {}) {
         this.promptStr = prompt;
         this.buf = '';
@@ -236,6 +241,7 @@ export class LineEditor {
         this._tmpDir = '';
         this.onAttach = null;
         this.onClipboard = null;
+        this.locked = false;
     }
     // Read the OS clipboard for an image and insert its marker. Used when the
     // terminal sends no usable paste data (Ctrl+V / right-click / empty paste).
@@ -333,6 +339,19 @@ export class LineEditor {
         this._writeBlock();
         this._render();
     }
+    // Lock input while a long operation runs (chat resume/open, /new,
+    // self-review). The line stays visible but text input and Enter are ignored,
+    // so a message typed mid-operation is not queued and sent afterwards,
+    // breaking the restored session. Ctrl+C/Ctrl+D still work so the user can
+    // abort.
+    lock(status) {
+        this.locked = true;
+        if (status)
+            this.setStatus(theme.dim(status));
+    }
+    unlock() {
+        this.locked = false;
+    }
     setPrompt(str) {
         this.promptStr = str;
         this._render();
@@ -481,6 +500,10 @@ export class LineEditor {
     }
     // ---------- input ----------
     _submit() {
+        if (this.locked) {
+            this._render();
+            return;
+        }
         const display = this.buf;
         if (!display.trim()) {
             this._render();
@@ -716,6 +739,25 @@ export class LineEditor {
     }
     _handle(data) {
         let s = data.toString('utf-8');
+        // While locked (a long operation is running), swallow all input except
+        // Ctrl+C / Ctrl+D — so the user can still abort, but cannot type a message
+        // that would be queued and sent after the operation.
+        if (this.locked) {
+            if (s.length === 1) {
+                const c = s.charCodeAt(0);
+                if (c === 3) {
+                    if (this.onCtrlC)
+                        this.onCtrlC();
+                    return;
+                }
+                if (c === 4) {
+                    if (this.onCtrlC)
+                        this.onCtrlC();
+                    return;
+                }
+            }
+            return;
+        }
         if (!this._inPaste && s === ESC) {
             if (this.onEscape)
                 this.onEscape();

package/package.json

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