zames_pro 2.90.15 → 2.90.18

package/CHANGELOG.md

@@ -7,6 +7,40 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.90.18] - 2026-10-30
+
+### Fixed
+
+- self-healing live interaction with the chat
+- **restore:** drop the loop's timeout nudge
+- **deepseek:** do not read a protocol marker mentioned in our own text
+- **restore:** keep the loop's timeout nudge out of the restored dialogue
+- **browser:** stop misreading a completed turn as truncated
+
+### Changed
+
+- drop the _netTurnBody and restore-nudge changes
+
+## [2.90.17] - 2026-10-30
+
+### Fixed
+
+- self-healing live interaction with the chat
+- **restore:** drop the loop's timeout nudge
+- **deepseek:** do not read a protocol marker mentioned in our own text
+- **restore:** keep the loop's timeout nudge out of the restored dialogue
+- **browser:** stop misreading a completed turn as truncated
+
+### Changed
+
+- drop the _netTurnBody and restore-nudge changes
+
+## [2.90.16] - 2026-10-29
+
+### Fixed
+
+- **browser:** apply the sanitized headless UA to the relaunch explicitly
+
 ## [2.90.15] - 2026-10-29
 
 ### Changed

package/dist/browser-chats.js

@@ -119,68 +119,109 @@ export function scrapeChatList(limit) {
  * builds match both an outer and an inner container, which printed each turn
  * twice). The model's reasoning (think class) is skipped.
  */
-export function scrapeChatMessages(opts) {
-    const think = new RegExp(opts.thinkRe, 'i');
-    const assistantRe = new RegExp(opts.assistantRe, 'i');
-    const inThink = (e) => {
-        let n = e;
-        while (n) {
-            const cls = (n.className || '').toString();
-            if (think.test(cls))
-                return true;
-            n = n.parentElement;
-        }
-        return false;
-    };
-    const textOf = (e) => {
-        const h = e;
-        const t = h.innerText || h.textContent || '';
-        const NL = String.fromCharCode(10);
-        return t.replace(new RegExp(NL + '{3,}', 'g'), NL + NL).trim();
-    };
-    const looksAssistant = (e) => {
-        const cls = (e.className || '').toString();
-        if (assistantRe.test(cls))
-            return true;
-        if (e.querySelector(opts.assistantSel))
-            return true;
-        if (e.querySelector(opts.markdownSel))
-            return true;
-        return false;
-    };
-    let blocks = [];
-    for (const s of opts.containerSels) {
-        const found = Array.from(document.querySelectorAll(s)).filter((e) => !inThink(e) && textOf(e).length > 0);
-        if (found.length) {
-            blocks = found;
-            break;
-        }
-    }
-    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) {
-            const t = textOf(b);
-            if (!t)
-                continue;
-            out.push({ role: looksAssistant(b) ? 'assistant' : 'user', text: t });
-        }
-        if (out.length)
-            return out;
-    }
-    for (const s of opts.answerSels) {
-        const list = Array.from(document.querySelectorAll(s)).filter((e) => !inThink(e));
-        if (!list.length)
-            continue;
-        for (const el of list) {
-            const t = textOf(el);
-            if (t)
-                out.push({ role: 'assistant', text: t });
-        }
-        break;
-    }
-    return out;
+// The in-page scraper is a SOURCE STRING compiled inside the page, not a
+// function reference: tsx/esbuild injects a `__name(...)` helper into every
+// NAMED function expression it transpiles, Playwright serializes that helper
+// into the page, and the page has no such global — the whole scraper then threw
+// `ReferenceError: __name is not defined` and the DOM fallback returned an
+// EMPTY dialogue. Keeping the text here makes the in-page code explicit and
+// testable (it is compiled with `new Function` by `scrapeChatMessagesInPage`).
+const SCRAPE_CHAT_MESSAGES_SOURCE = [
+    'function scrapeChatMessages(opts) {',
+    "  const think = new RegExp(opts.thinkRe, 'i')",
+    "  const assistantRe = new RegExp(opts.assistantRe, 'i')",
+    '  const inThink = (e) => {',
+    '    let n = e',
+    '    while (n) {',
+    "      if (think.test((n.className || '').toString())) return true",
+    '      n = n.parentElement',
+    '    }',
+    '    return false',
+    '  }',
+    '  const textOf = (e) => {',
+    "    const t = e.innerText || e.textContent || ''",
+    '    const NL = String.fromCharCode(10)',
+    "    return t.replace(new RegExp(NL + '{3,}', 'g'), NL + NL).trim()",
+    '  }',
+    '  // A REASONING block is UI state, not the answer, and it is not always a',
+    '  // PARENT of the text: DeepSeek renders it as a sibling that precedes the',
+    '  // markdown answer, so reading innerText printed the whole reasoning in the',
+    '  // restored dialogue. Remove the reasoning SUBTREES, then read the rest.',
+    '  const contentOf = (e) => {',
+    '    // The reasoning text is INSIDE the message, so it must be removed',
+    '    // before reading: the header line (Thought for N seconds) AND the',
+    '    // body that follows it. The answer is the part AFTER the body.',
+    '    const clone = e.cloneNode(true)',
+    '    let hadThink = false',
+    "    for (const t of Array.from(clone.querySelectorAll('*'))) {",
+    "      if (think.test((t.className || '').toString())) {",
+    '        hadThink = true',
+    '        t.remove()',
+    '      }',
+    '    }',
+    '    // The reasoning BODY can be a bare TEXT NODE (no element to remove),',
+    '    // and a cloned node may even lose the block structure, so the text is',
+    '    // taken from the ORIGINAL message and split into paragraphs: the',
+    '    // reasoning is the first one, the answer is the last one.',
+    '    const full = textOf(e)',
+    '    const nl = String.fromCharCode(10)',
+    '    const blocks = full.split(nl + nl).filter((p) => p.trim())',
+    "    if (!hadThink && !/^(thought|thinking|think) for/.test(blocks[0] || '')) {",
+    '      return full.trim()',
+    '    }',
+    "    const answer = blocks[blocks.length - 1] || ''",
+    "    const hdr = new RegExp('^(thought|thinking|think) for[^' + nl + ']*' + nl + '*')",
+    "    return answer.replace(hdr, '').trim()",
+    '  }',
+    '  // A USER bubble carries only the operator text; an assistant turn has a',
+    '  // rendered markdown wrapper (live: div.ds-markdown with',
+    '  // .ds-assistant-message-main-content).',
+    '  const looksAssistant = (e) => {',
+    "    if (assistantRe.test((e.className || '').toString())) return true",
+    '    if (e.querySelector(opts.assistantSel)) return true',
+    '    if (e.querySelector(opts.markdownSel)) return true',
+    '    return false',
+    '  }',
+    '  let blocks = []',
+    '  for (const s of opts.containerSels) {',
+    '    const found = Array.from(document.querySelectorAll(s)).filter(',
+    '      (e) => !inThink(e) && contentOf(e).length > 0,',
+    '    )',
+    '    if (found.length) {',
+    '      blocks = found',
+    '      break',
+    '    }',
+    '  }',
+    '  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) {',
+    '      const t = contentOf(b)',
+    '      if (!t) continue',
+    "      out.push({ role: looksAssistant(b) ? 'assistant' : 'user', text: t })",
+    '    }',
+    '    if (out.length) return out',
+    '  }',
+    '  for (const s of opts.answerSels) {',
+    '    const list = Array.from(document.querySelectorAll(s)).filter(',
+    '      (e) => !inThink(e),',
+    '    )',
+    '    if (!list.length) continue',
+    '    for (const el of list) {',
+    '      const t = contentOf(el)',
+    "      if (t) out.push({ role: 'assistant', text: t })",
+    '    }',
+    '    break',
+    '  }',
+    '  return out',
+    '}',
+].join(String.fromCharCode(10));
+/** The in-page scraper SOURCE (compiled inside the page, see above). */
+export function scrapeChatMessagesSource() {
+    return SCRAPE_CHAT_MESSAGES_SOURCE;
 }

package/dist/browser-pure.js

@@ -300,6 +300,18 @@ export function isRateLimitText(text) {
 // start a new chat." and will refuse every further send into this chat. Distinct
 // from the rate limit (which clears with time) and from a server hiccup — the
 // only recovery is compaction, so ask() must not retry in the same chat.
+/**
+ * A toast container can include the surrounding CONVERSATION, so a task that
+ * merely quotes "Length limit reached" (as the smoke script does while
+ * testing this detector) looked like a refused send and killed the run. A
+ * real notice is its OWN message: SHORT, and the phrase starts it.
+ */
+export function isContextLimitNotice(text) {
+    const t = String(text || '').trim();
+    if (!t || t.length > 400)
+        return false;
+    return isContextLimitText(t);
+}
 export function isContextLimitText(text) {
     return CONTEXT_LIMIT_RE.test(String(text || ''));
 }
@@ -383,3 +395,19 @@ export async function nukeProfile(dir = USER_DATA_DIR) {
     }
     catch { }
 }
+/**
+ * PURE: does this browser still need the headless User-Agent fix?
+ *
+ * `_fixHeadlessUserAgent()` bails out for an "already configured" UA — but
+ * using `if (this.userAgent) return` was wrong: the field is also the ENGINE's
+ * own UA captured from the page, and a config UA that merely CONTAINS the
+ * `HeadlessChrome` marker needs the fix just as much. The only value that can
+ * skip the fix is one that is already sanitized (and non-empty — an empty
+ * string means "ask the engine", not "use a blank UA").
+ */
+export function needsHeadlessUaFix(ua) {
+    const value = String(ua ?? '');
+    if (!value)
+        return true;
+    return sanitizeHeadlessUA(value) !== value;
+}

package/dist/browser.js

@@ -1,11 +1,11 @@
 import { chromium, } from 'playwright';
 import { noteSwallowed } from './swallow.js';
 import { interactiveBrowserLogin, loginIsInteractive, canShowWindow, } from './browser-login.js';
-import { extractAnswer, extractTokenUsage, dumpNetBody, isFinishedWithoutAnswer, isFinishedWithAnswer, } from './net-capture.js';
+import { extractAnswer, extractTokenUsage, dumpNetBody, isFinishedWithoutAnswer, isFinishedAwaitingAnswer, isFinishedWithAnswer, } from './net-capture.js';
 import { rewriteFailedAttachments } from './commands.js';
 import { recoverFromContextLimit } from './context-limit.js';
 import { awaitUploadPreview, readAttachBuffers } from './attach-flow.js';
-import { parseHistoryMessages, extractChatMessages, scrapeChatList, scrapeChatMessages, } from './browser-chats.js';
+import { parseHistoryMessages, extractChatMessages, scrapeChatList, scrapeChatMessagesSource, } from './browser-chats.js';
 import { CHAT_URL, CHAT_ID_RE, chatUrl, HISTORY_MESSAGES_URL, BUTTON_CLASS_RE, INPUT_SELECTORS, SEND_SELECTORS, STOP_SELECTORS, STOP_NAME_RE, CONTINUE_NAME_RE, ANSWER_SELECTORS, THINK_CLASS_RE, MESSAGE_CONTAINER_SELECTORS, RESTORE_ANSWER_SELECTORS, ASSISTANT_CLASS_RE, ASSISTANT_SELECTOR, ANSWER_MARKDOWN_SELECTOR, MARKDOWN_SELECTOR, CHAT_SIGNAL_NODES_SELECTOR, NEW_CHAT_SELECTOR, NEW_CHAT_TEXT_RE, PASSWORD_SELECTORS, LOGIN_SELECTORS, LOGIN_SUBMIT_SELECTORS, MFA_CODE_SELECTORS, MFA_SUBMIT_SELECTORS, MFA_SEND_CODE_SELECTORS, MFA_SEND_CODE_RE, LOGIN_BUTTON_SELECTOR, LOGIN_NAME_RE, LOGIN_FORM_SUBMIT_RE, SIDEBAR_TOGGLE_SELECTORS, TOGGLE_SELECTORS, DEEP_THINKING_RE, WEB_SEARCH_RE, ATTACH_SELECTORS, ANSWER_URL_RE, } from './deepseek-ui.js';
 import { probeUiHealth, } from './ui-health.js';
 import { readPageToastsInDom, readLoginErrorInDom, readMfaAccountInDom, readLastAnswerInDom, chatSignalInDom, continueVisibleCheapInDom, stopButtonVisibleInDom, clickStopInDom, continueVisibleInDom, clickContinueInDom, readUserAgentInDom, findLoginInputIndexInDom, submitLoginFormInDom, setBusyTitleInDom, pasteTextIntoElement, readElementText, elementTagNameInDom, isElementEnabledInDom, readInputTrimmedTextInDom, dumpDomCountsInDom, } from './browser-dom.js';
@@ -23,7 +23,7 @@ export { STOP_NAME_RE, CONTINUE_NAME_RE };
 // imported for the class below and RE-EXPORTED here, so the public API of this
 // module is unchanged (tests and other modules import these names from
 // './browser.js').
-import { askPassword, USER_DATA_DIR, parseHeadlessUACache, headlessEngineKey, readCachedHeadlessUA, writeCachedHeadlessUA, headlessUACacheReady, sanitizeHeadlessUA, writeAuthMarker, isGenerationIncompleteText, isRateLimitText, isServerBusyText, isContextLimitText, normText, cleanAnswer, RateLimitError, ServerBusyError, GenerationIncompleteError, ContextLimitError, cleanSingletonFiles, profileLooksLocked, nukeProfile, } from './browser-pure.js';
+import { askPassword, USER_DATA_DIR, parseHeadlessUACache, headlessEngineKey, readCachedHeadlessUA, writeCachedHeadlessUA, headlessUACacheReady, sanitizeHeadlessUA, needsHeadlessUaFix, writeAuthMarker, isGenerationIncompleteText, isRateLimitText, isServerBusyText, isContextLimitNotice, isContextLimitText, normText, cleanAnswer, RateLimitError, ServerBusyError, GenerationIncompleteError, ContextLimitError, cleanSingletonFiles, profileLooksLocked, nukeProfile, } from './browser-pure.js';
 export { askPassword, parseHeadlessUACache, headlessUACacheReady, sanitizeHeadlessUA, isGenerationIncompleteText, isRateLimitText, isServerBusyText, isContextLimitText, normText, RateLimitError, ServerBusyError, GenerationIncompleteError, ContextLimitError, };
 export class DeepSeekBrowser {
     providerName = 'deepseek';
@@ -130,6 +130,7 @@ export class DeepSeekBrowser {
     _apiPow;
     // Last error from fetchChatMessages ('' on success). Surfaced under --debug
     // so a missing restored history can be diagnosed.
+    /** Last error from fetchChatMessages ('' on success). */
     _lastHistoryError;
     // 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:
@@ -330,6 +331,12 @@ export class DeepSeekBrowser {
     async _fixHeadlessUserAgent() {
         if (!this.headless)
             return;
+        // An already-sanitized UA (from the cache or a previous fix) needs no
+        // relaunch; an EMPTY field or a config UA that still carries the marker
+        // must be fixed, which the old blanket `if (this.userAgent) return` skipped
+        // on Qwen/GLM.
+        if (!needsHeadlessUaFix(this.userAgent))
+            return;
         try {
             const ua = await this.page.evaluate(readUserAgentInDom);
             const fixed = sanitizeHeadlessUA(ua);
@@ -338,18 +345,28 @@ export class DeepSeekBrowser {
             this.userAgent = fixed;
             // Remember the good UA for this engine build so the NEXT headless start
             // uses it immediately (no relaunch). Keyed by executable path.
-            void writeCachedHeadlessUA(headlessEngineKey(), fixed);
+            await writeCachedHeadlessUA(headlessEngineKey(), fixed);
             if (this.debug)
                 console.error('profile: headless UA -> relaunching with a plain Chrome UA');
             await this.context.close().catch(() => { });
-            await this._launchOnce();
+            // Pass the UA EXPLICITLY: it was just sanitized, and relying on the field
+            // meant the relaunch could read the page's own UA back and keep the
+            // HeadlessChrome marker (a 403 / login wall from DeepSeek's CDN).
+            await this._launchOnce(fixed);
         }
         catch (e) {
             if (this.debug)
                 console.error('profile: UA fix failed:', e.message);
         }
     }
-    async _launchOnce() {
+    /**
+     * Launch the persistent context. `uaOverride` applies a User-Agent to THIS
+     * launch without storing it first: the UA fix reads the engine UA from the
+     * page it is about to close, so passing the value explicitly is the only way
+     * the relaunch cannot fall back to the un-sanitized UA (a stored field was
+     * read by the OLD page and then re-read by the new one).
+     */
+    async _launchOnce(uaOverride) {
         const options = {
             headless: this.headless,
             // 30ms slowMo per Playwright action added up over thousands of DOM
@@ -360,8 +377,9 @@ export class DeepSeekBrowser {
         };
         if (this.channel)
             options.channel = this.channel;
-        if (this.userAgent)
-            options.userAgent = this.userAgent;
+        const ua = uaOverride || this.userAgent;
+        if (ua)
+            options.userAgent = ua;
         try {
             this.context = await chromium.launchPersistentContext(USER_DATA_DIR, options);
         }
@@ -491,7 +509,7 @@ export class DeepSeekBrowser {
                 // `!extracted` guard skipped the check and the finish loop waited out
                 // the whole askDeadlineMs. Run the check on the RAW body regardless of
                 // whether a (bogus) fragment was extracted.
-                if (isFinishedWithoutAnswer(body)) {
+                if (isFinishedWithoutAnswer(body) && !isFinishedAwaitingAnswer(body)) {
                     // The UI shows Stopped + Continue. Record it with a fresh timestamp
                     // so the ask() loops do not wait out the timeout — they click
                     // Continue / resend.
@@ -2057,6 +2075,8 @@ export class DeepSeekBrowser {
         report(gap);
         this._emitSendState('paused');
         await this._sleepInterruptible(gap, report);
+        if (!this._abort && !this._askCancelled)
+            this._emitSendState('settled');
     }
     // Sleep in small slices so Esc/Ctrl+C can cancel the wait promptly.
     // Returns true if the sleep was cut short by _abort.
@@ -2251,15 +2271,22 @@ export class DeepSeekBrowser {
             // Checked BEFORE the rate limit and the server hiccup: DeepSeek shows the
             // context notice INSTEAD of an answer, and both of those branches would
             // retry the same send into a chat that can never accept it again.
-            if (isContextLimitText(pageText)) {
+            // A toast container can carry the TEXT of the conversation: a task
+            // that merely MENTIONS "Length limit reached" (the smoke script does)
+            // made the send look refused and every later turn died on the
+            // compaction path. Only a notice that is its own message counts — see
+            // isContextLimitNotice().
+            if (isContextLimitNotice(pageText)) {
                 throw new ContextLimitError(pageText.slice(0, 300));
             }
             if (isRateLimitText(pageText)) {
                 throw new RateLimitError(pageText.slice(0, 300));
             }
-            if (isServerBusyText(pageText)) {
-                throw new ServerBusyError(pageText.slice(0, 300));
-            }
+            // NOT checked here: a server-busy NOTICE lives in a toast that can
+            // carry the surrounding answer text, and a normal answer that merely
+            // mentions "the server is busy" made this throw and RESENT a healthy
+            // turn (live: 6 Continue clicks on one answer). The SSE body is the
+            // authoritative place for it (_netServerBusy, see _onResponse).
             // 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".
@@ -2273,7 +2300,29 @@ export class DeepSeekBrowser {
             // truncated body has NO RESPONSE fragment, so extractAnswer() returned
             // '' and `_netCapture` was empty — guarding on it made this branch dead
             // code and the agent hung on "Stopped" until the timeout.
-            if (this._netCaptureAt >= this._lastSentAt &&
+            // A truncated turn whose first RESPONSE fragment is only a HEAD (a bare
+            // `{` or a newline) is NOT dead: DeepSeek streams the answer and the rest
+            // arrives in APPEND chunks a moment later, so keep waiting instead of
+            // resending. Without this every DSML/XML answer produced the false
+            // "DeepSeek оборвал ответ" message.
+            const awaitingAnswer = this._netCaptureAt >= this._lastSentAt &&
+                isFinishedAwaitingAnswer(this._netBody);
+            if (awaitingAnswer) {
+                this._askDebug('START-loop awaiting-answer (head-only snapshot)');
+            }
+            // A COMPLETE answer wins over a stale truncation marker: the model
+            // may quote `generation_err` (our own detector source) or DeepSeek may
+            // end the turn with a marker AFTER the answer arrived. Resending or
+            // clicking Continue then LOSES a good answer (live: turn 10 repeated
+            // turn 9 and hit the watchdog).
+            const doneAnswer = this._netCaptureAt >= this._lastSentAt &&
+                isFinishedWithAnswer(this._netBody);
+            if (doneAnswer) {
+                this._askDebug('START-loop FINISHED-with-answer, return');
+                return this._cleanAnswer(this._netCapture);
+            }
+            if (!awaitingAnswer &&
+                this._netCaptureAt >= this._lastSentAt &&
                 isGenerationIncompleteText(this._netBody)) {
                 // PREFER the Continue button: it RESUMES the same truncated turn (a
                 // `chat/continue` request). Resending the prompt creates a NEW turn and
@@ -2309,6 +2358,11 @@ export class DeepSeekBrowser {
                 this.deepThinking &&
                 (await this._clickContinueIfVisible())) {
                 this._askDebug('CLICKED Continue (start-loop)');
+                // A click RESUMES the turn. Without the wait the next tick clicks
+                // again the instant the button is still painted, and a "messages
+                // too frequent" hits from our OWN burst of chat/continue requests.
+                this._lastContinueAt = Date.now();
+                await this.page.waitForTimeout(500);
             }
             const cur = await this._readLastAnswerTextCleanDom().catch(() => '');
             // Cheap growth signal instead of the whole-body length.
@@ -2352,7 +2406,14 @@ export class DeepSeekBrowser {
             const paused = this.autoContinue &&
                 this.deepThinking &&
                 (await this._continueButtonVisible());
-            if (differs && cur === lastStartCur && notGenerating && !paused) {
+            // A head-only snapshot with no appended text yet is NOT settled: the
+            // answer is still arriving, so a repeated DOM read must not be returned
+            // as a finished answer (that was the "DeepSeek оборвал ответ" loop).
+            if (!awaitingAnswer &&
+                differs &&
+                cur === lastStartCur &&
+                notGenerating &&
+                !paused) {
                 settledTicks++;
                 if (settledTicks >= 2) {
                     this._askDebug('SETTLED-differs return len=' + cur.length);
@@ -2474,9 +2535,9 @@ export class DeepSeekBrowser {
                 if (isRateLimitText(pageText)) {
                     throw new RateLimitError(pageText.slice(0, 300));
                 }
-                if (isServerBusyText(pageText)) {
-                    throw new ServerBusyError(pageText.slice(0, 300));
-                }
+                // The server-busy check is deliberately ABSENT: its toast can contain
+                // the answer text, and a healthy answer that mentioned it threw here
+                // (see the start-wait comment).
             }
             // 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
@@ -2496,10 +2557,30 @@ export class DeepSeekBrowser {
             // and duplicates the work — only do that when there is no button to
             // click. Runs on the RAW `_netBody` (a truncated body has no RESPONSE,
             // so `_netCapture` is empty and the old guard was dead code).
-            const truncated = this._netCaptureAt >= this._lastSentAt &&
+            // A COMPLETE answer is NOT truncated, whatever marker the body also
+            // carries (a quoted `generation_err`, a late status): acting on it
+            // would resend a healthy turn (live: a turn repeated the previous
+            // answer and hit the watchdog).
+            const doneAnswer = this._netCaptureAt >= this._lastSentAt &&
+                isFinishedWithAnswer(this._netBody);
+            const truncated = !doneAnswer &&
+                this._netCaptureAt >= this._lastSentAt &&
                 isGenerationIncompleteText(this._netBody);
-            const noAnswer = this._netNoAnswer && this._netCaptureAt >= this._lastSentAt;
+            const noAnswer = !doneAnswer &&
+                this._netNoAnswer &&
+                this._netCaptureAt >= this._lastSentAt;
             if ((truncated || noAnswer) && this.autoContinue) {
+                // MEASURED: a COMPLETE DSML tool call ends with the event `close`
+                // and `{click_behavior:'none', auto_resume:false}`, yet the DOM may
+                // still paint a "Continue" control for a moment. Clicking it sends a
+                // chat/continue request into an ENDED turn — the reply is "Messages
+                // too frequent" and the answer is lost. If the SSE says FINISHED
+                // WITH an answer, accept it first; Continue is for a turn that has
+                // NOT finished.
+                if (isFinishedWithAnswer(this._netBody)) {
+                    this._askDebug('SKIP Continue: FINISHED with answer');
+                    return this._cleanAnswer(this._netCapture);
+                }
                 if (await this._clickContinueIfVisible()) {
                     this._askDebug('CLICKED Continue (finish-loop, truncated=' +
                         truncated +
@@ -2591,7 +2672,9 @@ export class DeepSeekBrowser {
             if (this._netCaptureAt >= this._lastSentAt &&
                 isFinishedWithAnswer(this._netBody) === false &&
                 isGenerationIncompleteText(this._netBody) === false &&
-                (this._netNoAnswer || isFinishedWithoutAnswer(this._netBody))) {
+                (this._netNoAnswer ||
+                    (isFinishedWithoutAnswer(this._netBody) &&
+                        !isFinishedAwaitingAnswer(this._netBody)))) {
                 deadTicks++;
                 if (deadTicks >= 6 && !(await this._continueButtonVisible())) {
                     this._askDebug('THROW dead-turn (finished without answer)');
@@ -2618,6 +2701,13 @@ export class DeepSeekBrowser {
                         (await this._continueButtonVisible())) {
                         if (await this._clickContinueIfVisible()) {
                             this._askDebug('CLICKED Continue (before early return)');
+                            // A model-generated tool call often ENDS with DeepSeek's own
+                            // 'click to continue' offer (a Continue button inside the
+                            // ANSWER), which is not a pause. Returning here is what the
+                            // loop wants; the old unconditional `continue` spun until the
+                            // watchdog and looked like a stalled agent.
+                            this._askDebug('RETURN stable-with-continue len=' + cur.length);
+                            return cur;
                         }
                         stable = 0;
                     }
@@ -2837,6 +2927,11 @@ export class DeepSeekBrowser {
                 };
             }
         }, { chatId: id, auth, pow, historyUrl: HISTORY_MESSAGES_URL })
+            // A Playwright page TIMES OUT on its own (30s default) and the
+            // in-page fetch has no timeout at all: on a rate-limited / hung chat
+            // the promise never settles, so /compact (and /resume) waited forever
+            // and reported a bare "unknown". Fail fast instead — the caller has a
+            // local fallback.
             .catch((e) => ({
             error: 'evaluate failed: ' + e.message,
             messages: null,
@@ -2879,22 +2974,34 @@ export class DeepSeekBrowser {
     // bottom. Used by /resume and /resume-id so the operator sees the restored
     // context in the terminal instead of just "Chat opened.".
     //
-    // Best-effort DOM scraping (the in-page scrapeChatMessages in
-    // browser-chats.ts, kept as a named export so the class stays thin): role
+    // Best-effort DOM scraping (the in-page scrapeChatMessages SOURCE in
+    // browser-chats.ts — a source string, NOT a function reference, because tsx
+    // injects a `__name` helper into a transpiled function and the page has no
+    // such global, which silently emptied this fallback): role
     // detection relies on the ds-assistant-message-* class, anything that is not
     // an assistant block is a user message, and the model's reasoning
     // (.ds-think-content) is skipped exactly like in _readLastAnswerText.
     async readChatMessages() {
         if (!this.page)
             return [];
+        // The scraper travels as SOURCE and is compiled inside the page: tsx
+        // injects a `__name` helper into a transpiled function reference, the page
+        // has no such global, and the whole fallback threw a ReferenceError (the
+        // restored dialogue came back empty).
         const raw = await this.page
-            .evaluate(scrapeChatMessages, {
-            containerSels: MESSAGE_CONTAINER_SELECTORS,
-            answerSels: RESTORE_ANSWER_SELECTORS,
-            thinkRe: THINK_CLASS_RE.source,
-            assistantRe: ASSISTANT_CLASS_RE.source,
-            assistantSel: ASSISTANT_SELECTOR,
-            markdownSel: ANSWER_MARKDOWN_SELECTOR,
+            .evaluate((payload) => {
+            const factory = new Function(payload.source + '; return scrapeChatMessages');
+            return factory()(payload.opts);
+        }, {
+            source: scrapeChatMessagesSource(),
+            opts: {
+                containerSels: MESSAGE_CONTAINER_SELECTORS,
+                answerSels: RESTORE_ANSWER_SELECTORS,
+                thinkRe: THINK_CLASS_RE.source,
+                assistantRe: ASSISTANT_CLASS_RE.source,
+                assistantSel: ASSISTANT_SELECTOR,
+                markdownSel: ANSWER_MARKDOWN_SELECTOR,
+            },
         })
             .catch(() => []);
         return raw;