zames_pro 2.29.16 → 2.32.0

package/dist/browser.js

@@ -160,6 +160,10 @@ const STOP_SELECTORS = [
     'button:has-text("Остановить")',
     'button[aria-label*="Stop" i]',
 ];
+// Accessible name of the Stop button, for a TRUSTED Playwright click. It is a
+// bare stop word (optionally with a short suffix), anchored and length-limited
+// so a "Stop" inside rendered prose is never clicked.
+export const STOP_NAME_RE = /^(?:stop|остановить)(?:\s+\S{0,20})?\s*[.!…]?$/i;
 // DeepSeek's "Continue" button. With the reasoning ("Deep thinking") toggle
 // on, the server caps the THINK phase: the reasoning stops mid-way and the UI
 // offers a Continue button (this is NOT the same as a truncated turn with
@@ -332,6 +336,17 @@ export class DeepSeekBrowser {
     // rate limit. The click path now respects `minSendIntervalMs` like a send.
     _lastContinueAt;
     _abort;
+    // Set by cancelPendingAsk(): the agent loop's watchdog raced ask() against a
+    // deadline and the timer won. The underlying ask() may still be inside a
+    // rate-limit wait or the finish loop; this flag makes it bail out so the
+    // next iteration does not run TWO asks against the same page (two sends /
+    // two Continue clicks). Reset at the start of every _askOnce.
+    _askCancelled;
+    // Number of ask() calls currently in flight from OUR code. A
+    // completion/continue body that arrives while this is 0 was NOT initiated
+    // by us — it is the operator's own turn in the chat (or a manual resume in
+    // the web UI), and our next agent send must wait out the throttle from it.
+    _askInFlight;
     // The user pressed Esc/Ctrl+C — a "stop" for the WHOLE current batch of
     // tasks (including the queue). Unlike _abort (reset on every send), this
     // flag lives until a new task is explicitly started from the prompt.
@@ -344,6 +359,13 @@ export class DeepSeekBrowser {
     // (only reasoning). The DOM keeps showing reasoning/old text, so the loop
     // must not wait it out — it clicks Continue / resends. Reset before a send.
     _netNoAnswer;
+    // True when the LAST completion/continue body carried the rate limit
+    // ("Messages too frequent", finish_reason rate_limit_reached). The toast
+    // may be missed (it is a short-lived DOM node), so we ALSO recognise the
+    // error from the SSE body — otherwise ask() waited out the deadline and
+    // threw ds.send_no_new_answer while the chat plainly showed the rate limit.
+    // Reset before a send.
+    _netRateLimited;
     _netChatId;
     // The latest CONTEXT size (in tokens) DeepSeek reported in the current
     // chat. It is the `accumulated_token_usage` counter taken from the SSE
@@ -361,8 +383,6 @@ export class DeepSeekBrowser {
     // Last error from fetchChatMessages ('' on success). Surfaced under --debug
     // so a missing restored history can be diagnosed.
     _lastHistoryError;
-    _netSniff;
-    _netSniffLimit;
     // The RAW SSE body of the LAST answer response. Unlike `_netCapture`, this
     // is kept even when the body carries no RESPONSE text (a truncated turn:
     // generation_err / INCOMPLETE, or FINISHED-with-only-reasoning). The
@@ -421,18 +441,19 @@ export class DeepSeekBrowser {
         this._lastSentAt = 0;
         this._lastContinueAt = 0;
         this._abort = false;
+        this._askCancelled = false;
+        this._askInFlight = 0;
         this._stopped = false;
         this._netCapture = '';
         this._netCaptureAt = 0;
         this._netNoAnswer = false;
+        this._netRateLimited = false;
         this._netChatId = null;
         this._lastTokenUsage = null;
         this._toggles = { deepThinking, webSearch };
         this._apiAuth = '';
         this._apiPow = '';
         this._lastHistoryError = '';
-        this._netSniff = [];
-        this._netSniffLimit = 5;
         this._netBody = '';
         this._netHookInstalled = false;
         this.onSendStart = null;
@@ -590,9 +611,6 @@ export class DeepSeekBrowser {
             const body = await resp.text().catch(() => '');
             if (!body)
                 return;
-            this._netSniff.push({ url, contentType: ct, body });
-            if (this._netSniff.length > this._netSniffLimit)
-                this._netSniff.shift();
             void dumpNetBody(url, body);
             // Context size (tokens) reported by DeepSeek for this answer. Kept
             // even when extractAnswer() returns nothing (a history_messages
@@ -600,8 +618,13 @@ export class DeepSeekBrowser {
             const usage = extractTokenUsage(body);
             if (usage !== null)
                 this._lastTokenUsage = usage;
+            // Only a completion/continue turn carries a real answer. Gate the
+            // capture assignment to those URLs: a future endpoint returning a
+            // `content`/`text`/`response` string must not clobber the answer and
+            // look fresh (it would be returned as the final answer).
+            const isAnswerUrl = /chat\/(completion|continue)/i.test(url);
             const extracted = extractAnswer(body);
-            if (extracted) {
+            if (extracted && isAnswerUrl) {
                 this._netCapture = extracted;
                 this._netNoAnswer = false;
                 const cid = url.match(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/);
@@ -612,7 +635,15 @@ export class DeepSeekBrowser {
             // Store the RAW body for the CURRENT answer (completion/continue) so the
             // truncated/no-answer detectors can inspect it even when there is no
             // RESPONSE text (extractAnswer() returns '' for those bodies).
-            if (/chat\/(completion|continue)/i.test(url)) {
+            if (isAnswerUrl) {
+                // A completion/continue body that arrives while WE have no ask in
+                // flight was the OPERATOR's own turn (they sent a message by hand or
+                // resumed in the web UI). Record that moment so our next agent send
+                // waits out the throttle from it instead of firing too soon after the
+                // manual turn (which caused a rate limit). Do NOT touch the interval.
+                if (this._askInFlight === 0) {
+                    this._lastSentAt = Date.now();
+                }
                 this._netBody = body;
                 const cid = url.match(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/);
                 if (cid)
@@ -632,6 +663,15 @@ export class DeepSeekBrowser {
                     if (isGenerationIncompleteText(body)) {
                         this._netCapture = '';
                     }
+                    // The rate limit can arrive ONLY in the SSE body (the DOM toast is
+                    // short-lived and easy to miss). Recognise it here so ask() waits
+                    // instead of waiting out the deadline and throwing
+                    // ds.send_no_new_answer while the chat shows "Messages too
+                    // frequent".
+                    if (isRateLimitText(body)) {
+                        this._netRateLimited = true;
+                        this._netCapture = '';
+                    }
                     this._netCaptureAt = Date.now();
                 }
             }
@@ -985,18 +1025,61 @@ export class DeepSeekBrowser {
             return false;
         }
     }
+    // Wait for the INPUT to be present and visible, polling instead of a
+    // fixed sleep. Returns true as soon as it appears (or false on timeout).
+    async _awaitInput(timeoutMs = 5000) {
+        const deadline = Date.now() + timeoutMs;
+        while (Date.now() < deadline) {
+            const found = await this._findVisible(INPUT_SELECTORS, 400);
+            if (found)
+                return true;
+            await this.page.waitForTimeout(100);
+        }
+        return false;
+    }
+    // Did the chat actually CHANGE? Compares the current chat id (URL or the
+    // one sniffed off the network) with a baseline. Used to VERIFY newChat /
+    // openChat instead of blindly trusting a click that may have done nothing.
+    async _chatIdChangedFrom(baseline) {
+        const now = await this.getCurrentChatId();
+        return !!now && now !== baseline;
+    }
+    // Open a fresh chat. Returns as soon as the new-chat input is ready
+    // (polling), and VERIFIES the chat actually changed. A failed click falls
+    // back to navigating to the base URL, and we still wait for a positive
+    // signal before returning, so the next prompt is never sent into the OLD
+    // chat silently.
     async newChat() {
+        const before = await this.getCurrentChatId();
         const newChatBtn = this.page
             .locator('button, a')
             .filter({ hasText: /new chat|новый чат|новый диалог/i })
             .first();
+        let clicked = false;
         try {
             await newChatBtn.click({ timeout: 2000 });
-            await this.page.waitForTimeout(1000);
+            clicked = true;
         }
         catch {
+            // fall through to the goto fallback below
+        }
+        // Give the app a moment to react to the click, then poll for the positive
+        // signal (input ready AND chat changed). If the click did nothing, fall
+        // back to navigating to the base URL.
+        let ok = false;
+        const deadline = Date.now() + 5000;
+        while (Date.now() < deadline) {
+            if (await this._awaitInput(500)) {
+                if (!clicked || (await this._chatIdChangedFrom(before))) {
+                    ok = true;
+                    break;
+                }
+            }
+            await this.page.waitForTimeout(100);
+        }
+        if (!ok) {
             await this.page.goto(CHAT_URL, { waitUntil: 'domcontentloaded' });
-            await this.page.waitForTimeout(1000);
+            await this._awaitInput(5000);
         }
     }
     async _findVisible(selectors, timeout = 1000) {
@@ -1068,9 +1151,12 @@ export class DeepSeekBrowser {
             return out.replace(new RegExp(NL + '{3,}', 'g'), NL + NL).trim();
         }, ANSWER_SELECTORS);
     }
-    // We read ONLY visible toasts/notifications/errors, not the whole page
-    // text. Otherwise we catch "try again later" from service/hidden blocks
-    // and go into a false 5-minute rate-limit wait.
+    // We read ONLY visible toasts/notifications, not the whole page text.
+    // Otherwise we catch "try again later" from service/hidden blocks and go
+    // into a false 5-minute rate-limit wait. The old list also matched a broad
+    // `[class*="error" i]` / `[class*="alert" i]`, which picked up leftover
+    // text from the page and produced a FALSE rate limit (the agent stopped
+    // while the chat had no error). Keep only real toast/alert containers.
     async _readPageText() {
         return await this.page
             .evaluate(() => {
@@ -1078,8 +1164,6 @@ export class DeepSeekBrowser {
                 '[role="alert"]',
                 '[class*="toast" i]',
                 '[class*="notification" i]',
-                '[class*="alert" i]',
-                '[class*="error" i]',
             ];
             let out = '';
             for (const s of sels) {
@@ -1095,13 +1179,9 @@ export class DeepSeekBrowser {
         })
             .catch(() => '');
     }
-    async _readLastAnswerTextClean() {
-        const raw = await this._readLastAnswerText().catch(() => '');
-        return this._cleanAnswer(raw);
-    }
-    // The same "clean" filter as _readLastAnswerTextClean, but read from the
-    // DOM only. Used by _askOnce for the before/after comparison: the network
-    // capture must not be compared against itself (see _readLastAnswerTextDom).
+    // The "clean" filter, but read from the DOM only. Used by _askOnce for the
+    // before/after comparison: the network capture must not be compared against
+    // itself (see _readLastAnswerTextDom).
     async _readLastAnswerTextCleanDom() {
         const raw = await this._readLastAnswerTextDom().catch(() => '');
         return this._cleanAnswer(raw);
@@ -1150,11 +1230,65 @@ export class DeepSeekBrowser {
     async _isGenerating() {
         return await this._stopButtonVisible();
     }
+    // A CHEAP growth signal for the "did the answer start?" loop. The old
+    // code read `document.body.innerText.length` every ~300ms tick, which
+    // serializes the ENTIRE page text (sidebar, history, menus) and forces a
+    // layout — expensive on a long chat. This returns only the number of
+    // message/answer nodes plus the length of the LAST answer element, which is
+    // all we need to tell "the page grew / a new answer is streaming".
+    async _chatSignal() {
+        return await this.page
+            .evaluate(() => {
+            const nodes = document.querySelectorAll('[class*="ds-message"], [class*="chat-message"], .ds-markdown').length;
+            let lastLen = 0;
+            const answers = document.querySelectorAll('.ds-markdown');
+            if (answers.length) {
+                const lastEl = answers[answers.length - 1];
+                lastLen = (lastEl.innerText || '').length;
+            }
+            return { nodes, lastLen };
+        })
+            .catch(() => ({ nodes: 0, lastLen: 0 }));
+    }
+    // Cheap first probe for the Continue button. Runs ONE page.evaluate
+    // that scans buttons/role-buttons for a matching label and returns a boolean.
+    // The full Playwright getByRole scan (count + isVisible per element) plus the
+    // DOM fallback are two round-trips; on the COMMON path (no button on screen,
+    // probed every ~300ms tick) this single evaluate replaces them. Only when it
+    // HITS do we run the full scan to get a clickable Locator.
+    async _continueVisibleCheap() {
+        return await this.page
+            .evaluate(() => {
+            const re = /^(?:continue|продолжить|продолжение)(?:\s+(?:think(?:ing)?|reason(?:ing)?|размышлени[ея]|генераци[юя]|ответ))?\s*[.!…]?$/i;
+            const cands = Array.from(document.querySelectorAll('div[role="button"], button'));
+            for (const e of cands) {
+                const label = ((e.textContent || '') +
+                    ' ' +
+                    (e.getAttribute('aria-label') || ''))
+                    .replace(/\s+/g, ' ')
+                    .trim();
+                if (!re.test(label))
+                    continue;
+                const st = getComputedStyle(e);
+                if (st.display === 'none' || st.visibility === 'hidden')
+                    continue;
+                const r = e.getBoundingClientRect();
+                if (r.width > 0 && r.height > 0)
+                    return true;
+            }
+            return false;
+        })
+            .catch(() => false);
+    }
     // Is DeepSeek's "Continue" button currently visible? Used to BLOCK the
     // "answer settled" early-return in the finish loop: while Continue is on
     // screen the generation is PAUSED, not finished, so returning the partial
     // text there is exactly the "agent stopped with a Continue button" bug.
     async _continueButtonVisible() {
+        // Cheap first probe: on the common path (no button) this single evaluate
+        // replaces the getByRole count+isVisible scan and the DOM fallback.
+        if (!(await this._continueVisibleCheap()))
+            return false;
         try {
             const loc = this.page.getByRole('button', { name: CONTINUE_NAME_RE });
             const n = await loc.count().catch(() => 0);
@@ -1199,6 +1333,11 @@ export class DeepSeekBrowser {
     // only act on an EXACT short label so a random "Continue" in prose (a button
     // inside a rendered answer, etc.) is never clicked.
     async _clickContinueIfVisible() {
+        // Cheap first probe. The common case is "no button" and this is
+        // called every tick from the start-loop; the single evaluate replaces the
+        // getByRole count+isVisible scan plus the DOM fallback on that path.
+        if (!(await this._continueVisibleCheap()))
+            return false;
         // 1) Playwright's OWN click on the accessible name — this is a TRUSTED
         //    event and reliably triggers React handlers. The old in-page
         //    dispatchEvent/click often did nothing, which is exactly why the
@@ -1252,6 +1391,10 @@ export class DeepSeekBrowser {
             try {
                 await found.click({ timeout: 2000 });
                 this._lastContinueAt = Date.now();
+                // The auto-click is otherwise invisible. Emit ONE notice per
+                // click (the continueMinGapMs above already limits how often this
+                // can fire) so the operator sees why the turn resumed.
+                this._notice(this._t('ds.continue_clicked'));
                 return true;
             }
             catch { }
@@ -1297,6 +1440,10 @@ export class DeepSeekBrowser {
                 }
                 return false;
             });
+            if (clicked) {
+                this._lastContinueAt = Date.now();
+                this._notice(this._t('ds.continue_clicked'));
+            }
             return !!clicked;
         }
         catch {
@@ -1370,9 +1517,29 @@ export class DeepSeekBrowser {
             webSearch: await read(/поиск|search/i, this.webSearch),
         };
     }
+    // Stop the current generation. Used by Esc/Ctrl+C. Prefers a TRUSTED
+    // Playwright click on the Stop button (matched by its accessible name, the
+    // same technique as _clickContinueIfVisible): an in-page `e.click()` /
+    // dispatchEvent is IGNORED by DeepSeek's React button, so the old DOM-only
+    // path often did not stop anything. Falls back to a raw DOM scan and finally
+    // to Escape.
     async stopGeneration() {
         this._abort = true;
         this._stopped = true;
+        // 1) Trusted click on the accessible name.
+        try {
+            const loc = this.page.getByRole('button', { name: STOP_NAME_RE });
+            const n = await loc.count().catch(() => 0);
+            for (let i = 0; i < n; i++) {
+                const b = loc.nth(i);
+                if (await b.isVisible().catch(() => false)) {
+                    await b.click({ timeout: 2000 });
+                    return true;
+                }
+            }
+        }
+        catch { }
+        // 2) Legacy selector path.
         const btn = await this._findVisible(STOP_SELECTORS, 500);
         if (btn) {
             try {
@@ -1381,6 +1548,8 @@ export class DeepSeekBrowser {
             }
             catch { }
         }
+        // 3) Raw DOM scan + the full pointer/mouse sequence (older builds without
+        //    a proper role, or a click intercepted by an overlay).
         const clicked = await this.page
             .evaluate(() => {
             const btns = Array.from(document.querySelectorAll('div[role="button"], button'));
@@ -1390,6 +1559,15 @@ export class DeepSeekBrowser {
                     continue;
                 const svg = b.querySelector('svg');
                 if (svg && svg.querySelector('rect')) {
+                    for (const type of [
+                        'pointerdown',
+                        'mousedown',
+                        'pointerup',
+                        'mouseup',
+                        'click',
+                    ]) {
+                        b.dispatchEvent(new MouseEvent(type, { bubbles: true, cancelable: true }));
+                    }
                     b.click();
                     return true;
                 }
@@ -1416,116 +1594,139 @@ export class DeepSeekBrowser {
         // hiccup, not a failed send, and it is more likely in the reasoning
         // (deep thinking) mode, where the long THINK phase gets cut off.
         let incompleteRetries = 0;
-        while (attempt < this.askRetries) {
-            attempt++;
-            try {
-                return await this._askOnce(prompt, { timeout, agent, attachments });
-            }
-            catch (e) {
-                lastErr = e;
-                // Rate limit: DeepSeek did not accept the message. We wait a long time
-                // and resend into the SAME chat (without newChat — otherwise the
-                // context is lost). The waits don't consume the regular ask() attempts.
-                if (e instanceof RateLimitError) {
-                    rateLimitRetries++;
-                    if (rateLimitRetries > this.maxRateLimitRetries) {
-                        this._notice(theme.error(this._t('ds.rate_limit_give_up', {
-                            attempt: rateLimitRetries,
+        // Mark that OUR code has an ask in flight. A completion/continue body
+        // that arrives with _askInFlight === 0 was the operator's own turn, and
+        // _onResponse uses that to bump _lastSentAt so the next agent send waits
+        // out the throttle.
+        this._askInFlight++;
+        try {
+            // NOTE: `attempt` counts only GENUINE failures. The three retryable
+            // classes below (rate limit / server busy / truncated turn) have their OWN
+            // budgets and must NOT consume an ask() attempt — otherwise a rate limit
+            // at the start burns the whole askRetries budget and ask() gives up early.
+            while (attempt < this.askRetries) {
+                try {
+                    return await this._askOnce(prompt, { timeout, agent, attachments });
+                }
+                catch (e) {
+                    lastErr = e;
+                    // Rate limit: DeepSeek did not accept the message. We wait a long time
+                    // and resend into the SAME chat (without newChat — otherwise the
+                    // context is lost). The waits don't consume the regular ask() attempts.
+                    if (e instanceof RateLimitError) {
+                        rateLimitRetries++;
+                        if (rateLimitRetries > this.maxRateLimitRetries) {
+                            this._notice(theme.error(this._t('ds.rate_limit_give_up', {
+                                attempt: rateLimitRetries,
+                                min: Math.ceil(this.rateLimitWaitMs / 60000),
+                            })));
+                            throw e;
+                        }
+                        this._notice(theme.warn(this._t('ds.rate_limit_wait', {
                             min: Math.ceil(this.rateLimitWaitMs / 60000),
+                            attempt: rateLimitRetries,
+                            max: this.maxRateLimitRetries,
                         })));
-                        throw e;
+                        // Interruptible: Esc/Ctrl+C must cancel this long wait too,
+                        // otherwise "stop" stays frozen for up to 5 minutes.
+                        // The wait is ANIMATED through onSendPause (a live countdown), so the
+                        // operator sees the agent is waiting on the rate limit instead of a
+                        // frozen spinner. `_lastSentAt` is bumped so the countdown renders.
+                        const waitSec = Math.ceil(this.rateLimitWaitMs / 1000);
+                        const aborted = await this._waitRateLimit(waitSec);
+                        if (aborted)
+                            return '(прервано пользователем)';
+                        continue;
                     }
-                    this._notice(theme.warn(this._t('ds.rate_limit_wait', {
-                        min: Math.ceil(this.rateLimitWaitMs / 60000),
-                        attempt: rateLimitRetries,
-                        max: this.maxRateLimitRetries,
-                    })));
-                    // Interruptible: Esc/Ctrl+C must cancel this long wait too,
-                    // otherwise "stop" stays frozen for up to 5 minutes.
-                    // The wait is ANIMATED through onSendPause (a live countdown), so the
-                    // operator sees the agent is waiting on the rate limit instead of a
-                    // frozen spinner. `_lastSentAt` is bumped so the countdown renders.
-                    const waitSec = Math.ceil(this.rateLimitWaitMs / 1000);
-                    const aborted = await this._waitRateLimit(waitSec);
-                    if (aborted)
-                        return '(прервано пользователем)';
-                    continue;
-                }
-                // Server busy / overloaded: clear in seconds, so we retry quickly
-                // (unlike the rate limit). Without this branch the error fell into the
-                // generic ask() retry and the operator saw a bare message with no
-                // explanation of what DeepSeek is doing.
-                if (e instanceof ServerBusyError) {
-                    serverBusyRetries++;
-                    if (serverBusyRetries > this.maxServerBusyRetries) {
-                        this._notice(theme.error(this._t('ds.server_busy_give_up', {
+                    // Server busy / overloaded: clear in seconds, so we retry quickly
+                    // (unlike the rate limit). Without this branch the error fell into the
+                    // generic ask() retry and the operator saw a bare message with no
+                    // explanation of what DeepSeek is doing.
+                    if (e instanceof ServerBusyError) {
+                        serverBusyRetries++;
+                        if (serverBusyRetries > this.maxServerBusyRetries) {
+                            this._notice(theme.error(this._t('ds.server_busy_give_up', {
+                                attempt: serverBusyRetries,
+                            })));
+                            throw e;
+                        }
+                        this._notice(theme.warn(this._t('ds.server_busy_wait', {
+                            sec: Math.ceil(this.serverBusyWaitMs / 1000),
                             attempt: serverBusyRetries,
+                            max: this.maxServerBusyRetries,
                         })));
-                        throw e;
+                        const aborted = await this._sleepInterruptible(this.serverBusyWaitMs);
+                        if (aborted)
+                            return '(прервано пользователем)';
+                        continue;
                     }
-                    this._notice(theme.warn(this._t('ds.server_busy_wait', {
-                        sec: Math.ceil(this.serverBusyWaitMs / 1000),
-                        attempt: serverBusyRetries,
-                        max: this.maxServerBusyRetries,
-                    })));
-                    const aborted = await this._sleepInterruptible(this.serverBusyWaitMs);
-                    if (aborted)
-                        return '(прервано пользователем)';
-                    continue;
-                }
-                // The turn was TRUNCATED by the server (`generation_err`, INCOMPLETE):
-                // DeepSeek answered with a partial (often empty) answer and shows a
-                // "Continue" button. In reasoning mode this is much more likely. We
-                // resend the SAME prompt into the chat (that is what the Continue
-                // button does) instead of waiting for an answer that will never come.
-                if (e instanceof GenerationIncompleteError) {
-                    incompleteRetries++;
-                    if (incompleteRetries > this.maxIncompleteRetries) {
-                        this._notice(theme.error(this._t('ds.incomplete_give_up', {
+                    // The turn was TRUNCATED by the server (`generation_err`, INCOMPLETE):
+                    // DeepSeek answered with a partial (often empty) answer and shows a
+                    // "Continue" button. In reasoning mode this is much more likely. We
+                    // resend the SAME prompt into the chat (that is what the Continue
+                    // button does) instead of waiting for an answer that will never come.
+                    if (e instanceof GenerationIncompleteError) {
+                        incompleteRetries++;
+                        if (incompleteRetries > this.maxIncompleteRetries) {
+                            this._notice(theme.error(this._t('ds.incomplete_give_up', {
+                                attempt: incompleteRetries,
+                            })));
+                            throw e;
+                        }
+                        this._notice(theme.warn(this._t('ds.incomplete_retry', {
                             attempt: incompleteRetries,
+                            max: this.maxIncompleteRetries,
                         })));
-                        throw e;
+                        const aborted = await this._sleepInterruptible(this.incompleteWaitMs);
+                        if (aborted)
+                            return '(прервано пользователем)';
+                        continue;
                     }
-                    this._notice(theme.warn(this._t('ds.incomplete_retry', {
-                        attempt: incompleteRetries,
-                        max: this.maxIncompleteRetries,
+                    this._notice(theme.warn(this._t('ds.ask_retry', {
+                        attempt: attempt + 1,
+                        max: this.askRetries,
+                        error: e.message,
                     })));
-                    const aborted = await this._sleepInterruptible(this.incompleteWaitMs);
-                    if (aborted)
-                        return '(прервано пользователем)';
-                    continue;
-                }
-                this._notice(theme.warn(this._t('ds.ask_retry', {
-                    attempt,
-                    max: this.askRetries,
-                    error: e.message,
-                })));
-                // Only a genuinely LOST page justifies a restart. "Target page,
-                // context or browser has been closed" means the page is gone for good;
-                // a bare "browser" mention (e.g. a selector error containing the word)
-                // must NOT tear the window down — that was the "a new window opened"
-                // surprise during a resumed chat. We re-open the SAME context instead.
-                if (/target page, context or browser has been closed|page.*has been closed/i.test(e.message)) {
-                    this._notice(theme.warn(this._t('ds.ask_restart_browser')));
-                    try {
-                        await this.restart();
-                        await this.waitForLogin();
+                    // Only a genuinely LOST page justifies a restart. "Target page,
+                    // context or browser has been closed" means the page is gone for good;
+                    // a bare "browser" mention (e.g. a selector error containing the word)
+                    // must NOT tear the window down — that was the "a new window opened"
+                    // surprise during a resumed chat. We re-open the SAME context instead.
+                    if (/target page, context or browser has been closed|page.*has been closed/i.test(e.message)) {
+                        this._notice(theme.warn(this._t('ds.ask_restart_browser')));
+                        try {
+                            await this.restart();
+                            await this.waitForLogin();
+                        }
+                        catch (re) {
+                            this._notice(theme.warn(this._t('ds.ask_restart_failed', {
+                                error: re.message,
+                            })));
+                        }
                     }
-                    catch (re) {
-                        this._notice(theme.warn(this._t('ds.ask_restart_failed', {
-                            error: re.message,
-                        })));
+                    if (attempt < this.askRetries - 1) {
+                        await new Promise((r) => setTimeout(r, 2000 * (attempt + 1)));
                     }
-                }
-                if (attempt < this.askRetries) {
-                    await new Promise((r) => setTimeout(r, 2000 * attempt));
+                    attempt++;
                 }
             }
+            throw new Error(this._t('ds.ask_failed', {
+                max: this.askRetries,
+                error: lastErr?.message || '',
+            }));
         }
-        throw new Error(this._t('ds.ask_failed', {
-            max: this.askRetries,
-            error: lastErr?.message || '',
-        }));
+        finally {
+            this._askInFlight = Math.max(0, this._askInFlight - 1);
+        }
+    }
+    // Cancel an in-flight ask() whose caller (the agent-loop watchdog) already
+    // gave up on it. WITHOUT this the abandoned ask() kept running — it could
+    // still be inside `_waitRateLimit` (up to 300s) or the finish loop — while
+    // the NEXT iteration started a second ask() against the same page. Two asks
+    // then both send / both click Continue: a duplicate message and possible
+    // rate-limit hammering. The flag is reset at the start of every _askOnce.
+    cancelPendingAsk() {
+        this._askCancelled = true;
     }
     async _setInputText(input, text) {
         const tag = await input.evaluate((el) => el.tagName.toLowerCase());
@@ -1631,7 +1832,8 @@ export class DeepSeekBrowser {
                     btn.click({ timeout: 1500 }),
                 ]);
                 await chooser.setFiles(bufPayload);
-                await this.page.waitForTimeout(2500);
+                // Wait for the upload preview instead of a fixed 2.5s sleep.
+                await this._awaitUploadPreview(files.map((f) => f.name), 2500);
                 return;
             }
             catch { }
@@ -1650,7 +1852,32 @@ export class DeepSeekBrowser {
             return;
         }
         // Wait for the upload to finish (the attach preview to appear).
-        await this.page.waitForTimeout(2000);
+        await this._awaitUploadPreview(files.map((f) => f.name), 2000);
+    }
+    // Wait for the upload preview (the attached-file chip above the
+    // input) to appear, instead of a fixed 2.5s/2s sleep. The signal is the
+    // FILE NAME showing up on the page: we attach files BEFORE typing the text,
+    // so the name cannot appear there for any other reason. The old fixed value
+    // stays as the TIMEOUT CEILING, so a build where the name is not detected
+    // behaves exactly as before.
+    async _awaitUploadPreview(names, timeoutMs) {
+        const clean = names.map((n) => String(n || '').trim()).filter(Boolean);
+        if (!clean.length) {
+            await this.page.waitForTimeout(timeoutMs);
+            return;
+        }
+        const deadline = Date.now() + timeoutMs;
+        while (Date.now() < deadline) {
+            for (const name of clean) {
+                const n = await this.page
+                    .getByText(name, { exact: false })
+                    .count()
+                    .catch(() => 0);
+                if (n > 0)
+                    return;
+            }
+            await this.page.waitForTimeout(150);
+        }
     }
     // Wait out a rate-limit pause, showing an animated countdown through
     // onSendPause so the operator sees the agent is alive (not frozen). Returns
@@ -1724,6 +1951,10 @@ export class DeepSeekBrowser {
         while (left > 0) {
             if (this._abort)
                 return true;
+            // The watchdog abandoned this ask(): stop sleeping so the next ask()
+            // can start without two asks competing for the same page.
+            if (this._askCancelled)
+                return true;
             const chunk = Math.min(step, left);
             await this.page.waitForTimeout(chunk);
             left -= chunk;
@@ -1755,6 +1986,8 @@ export class DeepSeekBrowser {
         // 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;
+        // A fresh send clears a stale cancellation from a previous, abandoned ask.
+        this._askCancelled = false;
         if (this._stopped)
             return '(прервано пользователем)';
         const input = await this._findVisible(INPUT_SELECTORS, 10_000);
@@ -1792,6 +2025,7 @@ export class DeepSeekBrowser {
         this._netCapture = '';
         this._netCaptureAt = 0;
         this._netNoAnswer = false;
+        this._netRateLimited = false;
         this._netBody = '';
         // Align the DeepSeek chat toggles (deep thinking / web search) with the
         // configured state BEFORE typing. Doing it here (after the send-pause) it
@@ -1803,7 +2037,9 @@ export class DeepSeekBrowser {
             await this._attachFiles(attachments);
         }
         await this._setInputText(input, prompt);
-        await this.page.waitForTimeout(50);
+        // Send immediately: the input is already verified by _setInputText, and a
+        // clickable send button normally appears right away. The old code slept a
+        // fixed 50ms here, which only added latency (the button does not need it).
         let sent = false;
         for (const sel of SEND_SELECTORS) {
             const btn = this.page.locator(sel).last();
@@ -1824,12 +2060,12 @@ export class DeepSeekBrowser {
         this._lastSentAt = Date.now();
         this._askDebug('SENT at=' + this._lastSentAt);
         // Wait for the start: either Stop appeared, or the answer text changed,
-        // or the total amount of text on the page grew. In parallel we catch
-        // the rate-limit toast (only toasts, not the whole body).
+        // or the page grew (a new answer node / longer last answer). In parallel we
+        // catch the rate-limit toast (only toasts, not the whole body).
         const startDeadline = Date.now() + 30_000;
-        const startBodyLen = await this.page
-            .evaluate(() => document.body.innerText.length)
-            .catch(() => 0);
+        // A CHEAP growth signal (message-node count + last-answer length)
+        // instead of document.body.innerText.length, which walked the whole page.
+        const startSignal = await this._chatSignal();
         let started = false;
         // A stale/echo answer (the model repeats the previous text, or the answer
         // legitimately equals it) does NOT change `cur`. In that case the old loop
@@ -1840,7 +2076,7 @@ export class DeepSeekBrowser {
         let settledTicks = 0;
         let lastStartCur = '';
         while (Date.now() < startDeadline) {
-            if (this._abort)
+            if (this._abort || this._askCancelled)
                 return '(прервано пользователем)';
             const pageText = await this._readPageText();
             if (isRateLimitText(pageText)) {
@@ -1849,6 +2085,12 @@ export class DeepSeekBrowser {
             if (isServerBusyText(pageText)) {
                 throw new ServerBusyError(pageText.slice(0, 300));
             }
+            // The rate limit may be visible ONLY in the SSE body (the DOM toast is
+            // short-lived and easy to miss). The old code threw ds.send_no_new_answer
+            // at the deadline while the chat plainly showed "Messages too frequent".
+            if (this._netRateLimited && this._netCaptureAt >= this._lastSentAt) {
+                throw new RateLimitError(this._netBody.slice(0, 300) || 'rate limit (from network)');
+            }
             // The turn was truncated by the server: the SSE body carries
             // finish_reason=generation_err / quasi_status=INCOMPLETE and the UI
             // shows "Continue". Retry instead of waiting out the whole timeout.
@@ -1891,9 +2133,9 @@ export class DeepSeekBrowser {
                 this._askDebug('CLICKED Continue (start-loop)');
             }
             const cur = await this._readLastAnswerTextCleanDom().catch(() => '');
-            const bodyLen = await this.page
-                .evaluate(() => document.body.innerText.length)
-                .catch(() => 0);
+            // Cheap growth signal instead of the whole-body length.
+            const sig = await this._chatSignal();
+            const grew = sig.nodes > startSignal.nodes || sig.lastLen > startSignal.lastLen;
             // A NEW answer is the only reliable sign that the message was actually
             // sent: the text on the page must differ from what was there before the
             // send, OR the page must have grown. The Stop-button heuristic
@@ -1908,14 +2150,14 @@ export class DeepSeekBrowser {
             // 'changed' can stay false for a while — without this check ask() used
             // to hang until the full timeout and the agent appeared to "stop".
             const netStarted = !!this._netCapture && this._netCaptureAt >= this._lastSentAt;
-            if (changed || netStarted || bodyLen > startBodyLen) {
+            if (changed || netStarted || grew) {
                 started = true;
                 this._askDebug('STARTED changed=' +
                     changed +
                     ' netStarted=' +
                     netStarted +
-                    ' bodyGrew=' +
-                    (bodyLen > startBodyLen));
+                    ' grew=' +
+                    grew);
                 break;
             }
             // Fallback for an echo: the text equals beforeText, so it is the OLD
@@ -1945,8 +2187,8 @@ export class DeepSeekBrowser {
                 changed +
                 ' netStarted=' +
                 netStarted +
-                ' bodyLen=' +
-                bodyLen +
+                ' grew=' +
+                grew +
                 ' settled=' +
                 settledTicks +
                 ' generating=' +
@@ -1999,13 +2241,12 @@ export class DeepSeekBrowser {
             this._lastSentAt = Date.now();
             const retryDeadline = Date.now() + 20_000;
             while (Date.now() < retryDeadline) {
-                if (this._abort)
+                if (this._abort || this._askCancelled)
                     return '(прервано пользователем)';
                 const cur2 = await this._readLastAnswerTextCleanDom().catch(() => '');
                 const net2 = !!this._netCapture && this._netCaptureAt >= this._lastSentAt;
-                const grew2 = (await this.page
-                    .evaluate(() => document.body.innerText.length)
-                    .catch(() => 0)) > startBodyLen;
+                const sig2 = await this._chatSignal();
+                const grew2 = sig2.nodes > startSignal.nodes || sig2.lastLen > startSignal.lastLen;
                 if (net2 ||
                     grew2 ||
                     (!!cur2 && normText(cur2) !== normText(beforeText))) {
@@ -2027,7 +2268,7 @@ export class DeepSeekBrowser {
         let last = '';
         let stable = 0;
         while (Date.now() < deadline) {
-            if (this._abort) {
+            if (this._abort || this._askCancelled) {
                 return last || '(прервано пользователем)';
             }
             // Rate-limit / server-busy toast. The old code only read the toasts
@@ -2046,6 +2287,12 @@ export class DeepSeekBrowser {
                     throw new ServerBusyError(pageText.slice(0, 300));
                 }
             }
+            // The rate limit may exist only in the SSE body (the DOM toast is
+            // short-lived). Without this the loop waited out the deadline and threw
+            // ds.send_no_new_answer while the chat showed "Messages too frequent".
+            if (this._netRateLimited && this._netCaptureAt >= this._lastSentAt) {
+                throw new RateLimitError(this._netBody.slice(0, 300) || 'rate limit (from network)');
+            }
             // The server truncated the turn (generation_err / INCOMPLETE) or ended
             // it with only reasoning. PREFER the Continue button: it RESUMES the
             // same turn (`chat/continue`). Resending the prompt creates a NEW turn
@@ -2120,7 +2367,11 @@ export class DeepSeekBrowser {
                         }
                         stable = 0;
                     }
-                    else if (isNew || !(await this._isGenerating())) {
+                    else if (!(await this._isGenerating())) {
+                        // Only return when the generation has REALLY ended — no Stop
+                        // button AND no Continue button (checked above). The old condition
+                        // `isNew || !_isGenerating()` returned a still-streaming answer
+                        // merely because it looked "new", cutting a long answer short.
                         this._askDebug('RETURN stable curLen=' + cur.length);
                         return cur;
                     }
@@ -2249,6 +2500,8 @@ export class DeepSeekBrowser {
         }, limit);
     }
     async openChat(id) {
+        // Click the chat link and VERIFY the URL actually points at the
+        // requested chat before returning (polling, no fixed 1.5s sleep).
         const candidates = [`a[href$="/chat/s/${id}"]`, `a[href*="${id}"]`];
         for (const sel of candidates) {
             try {
@@ -2256,8 +2509,14 @@ export class DeepSeekBrowser {
                 if ((await loc.count()) === 0)
                     continue;
                 await loc.click({ timeout: 3000 });
-                await this.page.waitForTimeout(1500);
-                return true;
+                const deadline = Date.now() + 8000;
+                while (Date.now() < deadline) {
+                    if ((await this.getCurrentChatId()) === id) {
+                        await this._awaitInput(2000);
+                        return true;
+                    }
+                    await this.page.waitForTimeout(100);
+                }
             }
             catch { }
         }
@@ -2266,8 +2525,18 @@ export class DeepSeekBrowser {
                 waitUntil: 'domcontentloaded',
                 timeout: 20_000,
             });
-            await this.page.waitForTimeout(1500);
-            return true;
+            // Verify the navigation really landed on the requested chat; otherwise
+            // report the failure instead of sending the next prompt into the wrong
+            // chat silently.
+            const deadline = Date.now() + 10_000;
+            while (Date.now() < deadline) {
+                if ((await this.getCurrentChatId()) === id) {
+                    await this._awaitInput(2000);
+                    return true;
+                }
+                await this.page.waitForTimeout(100);
+            }
+            throw new Error('chat id did not change to ' + id);
         }
         catch (e) {
             throw new Error(this._t('ds.open_chat_failed', { id, error: e.message }));
@@ -2461,6 +2730,14 @@ export class DeepSeekBrowser {
                     break;
                 }
             }
+            // De-duplicate by node identity and drop a block that is NESTED
+            // inside another block. Some builds match both an outer message
+            // container and an inner one; without this the restored dialogue
+            // printed each turn twice. We keep only the OUTERMOST blocks.
+            if (blocks.length > 1) {
+                const unique = Array.from(new Set(blocks));
+                blocks = unique.filter((b) => !unique.some((other) => other !== b && other.contains(b)));
+            }
             const out = [];
             if (blocks.length) {
                 for (const b of blocks) {