zames_pro 2.90.15 → 2.90.18

package/dist/net-capture.js

@@ -138,11 +138,28 @@ function pickAnswerText(node) {
                 return inner;
         }
     }
-    for (const key of ['content', 'text', 'answer', 'response']) {
+    // A DeepSeek response OBJECT ({"response":{fragments:[...]}}) must not be
+    // read as a string answer: `response` is a NODE here, and only a string
+    // under it is text.
+    for (const key of ['content', 'text', 'answer']) {
         const v = obj[key];
         if (typeof v === 'string' && v)
             return v;
     }
+    const respText = obj.response;
+    if (typeof respText === 'string' && respText)
+        return respText;
+    // The DeepSeek shape: v.response.fragments[] -> type RESPONSE -> content.
+    const frags = obj.response?.fragments;
+    if (Array.isArray(frags)) {
+        let acc = '';
+        for (const fr of frags) {
+            if (fr && fr.type === 'RESPONSE' && typeof fr.content === 'string')
+                acc += fr.content;
+        }
+        if (acc)
+            return acc;
+    }
     for (const key of ['delta', 'message', 'data', 'payload', 'v']) {
         const v = obj[key];
         if (v && typeof v === 'object') {
@@ -179,7 +196,10 @@ const MIN_REAL_ANSWER_CHARS = 1;
  * a closing `}` / `]` / `)` left by a truncation that began mid-structure).
  * Listing only the opening brackets let a lone `}` count as a COMPLETE answer.
  */
-const TRUNCATED_HEAD_RE = /^[\s{}[\]()]*$/;
+// A lone `{`, `[`, `<`, a bracket pair or whitespace: the SNAPSHOT of a
+// RESPONSE that is still streaming, never an answer. `<` matters because a
+// DSML call starts with a bare `<>` chunk.
+const TRUNCATED_HEAD_RE = /^[\s{}[\]()<>]*$/;
 // How many chars of RESPONSE text the body carries, or -1 when there is NO
 // RESPONSE fragment at all. The fragment is SSE/JSON-encoded, so the content
 // may contain `\"` escapes AND raw `"` inside the JSON (the capture is the RAW
@@ -196,8 +216,12 @@ function responseContentLength(body) {
     // captured without the SSE framing) measured as 0 even when it carried a
     // real SHORT answer. Count the content strings from the raw body and decode
     // them, so an escaped quote does not inflate the count.
+    // The chunk may contain a RAW newline (SSE wraps long lines and a fragment
+    // decoded here can carry one), which `.`-based classes do not match: the
+    // old `\.` alternative then ended the match at the first line break and a
+    // MULTI-LINE answer measured as a single head char. `[\s\S]` covers it.
     let len = 0;
-    const re = /"type":"RESPONSE"[^}]*?"content":"((?:[^"\\]|\\.)*)"/g;
+    const re = /"type":"RESPONSE"[^}]*?"content":"((?:[^"\\]|\\[\s\S])*)"/g;
     let m;
     while ((m = re.exec(b)) !== null) {
         let text = m[1];
@@ -241,6 +265,37 @@ export function isFinishedWithoutAnswer(body) {
     // treat the absence of a real answer as "no answer produced".
     return true;
 }
+/**
+ * True when a FINISHED body still carries NO complete answer — its only
+ * RESPONSE text is a truncated head (empty, a bare `{`, or a lone newline).
+ *
+ * Such a body used to be reported as a DEAD turn right away, but DeepSeek
+ * streams the answer: the first fragment is only a SNAPSHOT of the first bytes
+ * (`"content":"{\\""` for a DSML/XML call) and the rest arrives in APPEND
+ * chunks a moment later. Treating the snapshot as final made the finish loop
+ * click Continue / throw `GenerationIncompleteError` on turns that were still
+ * answering, so the real answer never reached the parser and the operator saw
+ * `DeepSeek оборвал ответ` / `не ответил за 120с`.
+ *
+ * The snapshot is rebuilt from the RAW body on every network event, so the
+ * finish loop just keeps waiting while this returns true: the next event
+ * carries more text and `isFinishedWithAnswer()` takes over.
+ */
+export function isFinishedAwaitingAnswer(body) {
+    const b = String(body || '');
+    if (!b)
+        return false;
+    if (!FINISHED_STATUS_RE.test(b))
+        return false;
+    // Measured on 83 live FINISHED bodies: the fragment-regex measure called a
+    // COMPLETE DSML/JSON tool call (<200 chars) a snapshot, so the finish loop
+    // kept waiting and re-sent healthy turns. The real signal is a FINISHED body
+    // with NO answer at all, or nothing but a truncated head (a lone `{`, `<`,
+    // a newline) — that is a SNAPSHOT of a call still arriving. Anything else
+    // already carries the answer.
+    const text = extractAnswer(b).trim();
+    return text === '' || TRUNCATED_HEAD_RE.test(text);
+}
 /**
  * True when the SSE body shows a turn that ENDED (`quasi_status: FINISHED`)
  * AND carried a non-empty RESPONSE fragment — i.e. the server is done and the
@@ -257,10 +312,13 @@ export function isFinishedWithAnswer(body) {
         return false;
     if (!FINISHED_STATUS_RE.test(b))
         return false;
-    // A truncated RESPONSE head (a lone `{`) is NOT a complete answer: the
-    // finish loop would return it as the model's text and the tool-call parser
-    // would fail on it. Require real content (see responseTextLength).
-    return responseContentLength(b) >= MIN_REAL_ANSWER_CHARS;
+    // The measure is the DECODED answer text, not the fragment regex: a live
+    // DSML/JSON tool call arrives as a short RESPONSE whose first bytes are a
+    // bare `<` / `{`, and the regex read that as a 1-char "answer", so a
+    // COMPLETE turn was never recognised as finished (the loop kept waiting and
+    // re-sent it). A truncated head is still not an answer.
+    const text = extractAnswer(b).trim();
+    return text !== '' && !TRUNCATED_HEAD_RE.test(text);
 }
 // The CONTEXT size (in tokens) DeepSeek reports for the current answer.
 //

package/dist/qwen-browser.js

@@ -27,7 +27,7 @@ import { awaitUploadPreview, readAttachBuffers } from './attach-flow.js';
 import { theme } from './theme.js';
 import { recoverFromContextLimit } from './context-limit.js';
 import { scrapeQwenChatList, scrapeQwenChatMessages, parseQwenChatList, parseQwenHistory, } from './qwen-chats.js';
-import { cleanAnswer, headlessEngineKey, readCachedHeadlessUA, writeCachedHeadlessUA, sanitizeHeadlessUA, cleanSingletonFiles, profileLooksLocked, nukeProfile, writeAuthMarker, } from './browser-pure.js';
+import { cleanAnswer, headlessEngineKey, readCachedHeadlessUA, writeCachedHeadlessUA, sanitizeHeadlessUA, needsHeadlessUaFix, cleanSingletonFiles, profileLooksLocked, nukeProfile, writeAuthMarker, } from './browser-pure.js';
 import { chatSignalInDom, dumpDomCountsInDom, isElementEnabledInDom, readInputTrimmedTextInDom, readLastAnswerInDom, readPageToastsInDom, readUserAgentInDom, setBusyTitleInDom, clickStopInDom, stopButtonVisibleInDom, } from './browser-dom.js';
 import { probeUiHealth, } from './ui-health.js';
 import { CHAT_URL, CHAT_ID_RE, chatUrl, INPUT_SELECTORS, SEND_SELECTORS, STOP_SELECTORS, STOP_NAME_RE, NEW_CHAT_SELECTOR, MODEL_TRIGGER_SELECTOR, MODELS_URL, CHAT_LIST_URL, chatHistoryUrl, AGE_GATE_MODAL, AGE_GATE_CONTINUE, AGE_GATE_YEAR_SELECT, AGE_GATE_YEAR_OPTION, COOKIE_ACCEPT_RE, ATTACH_SELECTORS, ATTACH_MENU_TRIGGER, ATTACH_MENU_ITEM_RE, THINKING_SELECTOR, THINKING_MODE_RE, FAST_MODE_RE, WEB_SEARCH_MENU_RE, ANSWER_SELECTORS, THINK_CLASS_RE, MESSAGE_CONTAINER_SELECTORS, ASSISTANT_CLASS_RE, CHAT_SIGNAL_NODES_SELECTOR, MARKDOWN_SELECTOR, TOGGLE_SELECTORS, } from './qwen-ui.js';
@@ -57,6 +57,12 @@ function capNetBody(body) {
     return body.slice(0, head) + '\n...[truncated]...\n' + body.slice(-1024);
 }
 export class QwenBrowser {
+    /**
+     * True while a CONTEXT-LIMIT compaction runs in a fresh chat: that chat
+     * starts EMPTY (no system prompt yet), so a COMPACT prompt is tiny and must
+     * NOT be refused with a rate limit by the adaptive throttle.
+     */
+    compactInProgress = false;
     providerName = 'qwen';
     /** The chat a send must join (set by the agent loop; see types.ts). */
     resumeChatId = null;
@@ -122,6 +128,7 @@ export class QwenBrowser {
     _appliedThinking;
     _appliedWebSearch;
     _apiAuth;
+    /** Last error from fetchChatMessages ('' on success). */
     _lastHistoryError;
     _netBody;
     _netHookInstalled;
@@ -264,7 +271,12 @@ export class QwenBrowser {
     async _fixHeadlessUserAgent() {
         if (!this.headless)
             return;
-        if (this.userAgent)
+        // A UA that is ALREADY sanitized came from the cache; there is nothing to
+        // fix and nothing to relaunch for. Any other value (including an empty
+        // one) is the engine's own UA, which may still carry the marker — the old
+        // blanket `if (this.userAgent) return` skipped the fix for exactly that
+        // case, leaving `HeadlessChrome` in the live browser.
+        if (!needsHeadlessUaFix(this.userAgent))
             return;
         try {
             const ua = await this.page.evaluate(readUserAgentInDom);
@@ -272,18 +284,20 @@ export class QwenBrowser {
             if (fixed === ua)
                 return;
             this.userAgent = fixed;
-            void writeCachedHeadlessUA(headlessEngineKey(), fixed);
+            await writeCachedHeadlessUA(headlessEngineKey(), fixed);
             if (this.debug)
                 console.error('qwen profile: headless UA -> relaunching plain Chrome UA');
             await this.context.close().catch(() => { });
-            await this._launchOnce();
+            // Apply the UA to THIS launch explicitly: re-reading it from the fresh
+            // page would keep the marker the fix exists to remove.
+            await this._launchOnce(fixed);
         }
         catch (e) {
             if (this.debug)
                 console.error('qwen profile: UA fix failed:', e.message);
         }
     }
-    async _launchOnce() {
+    async _launchOnce(uaOverride) {
         const options = {
             headless: this.headless,
             slowMo: 10,
@@ -291,8 +305,9 @@ export class QwenBrowser {
         };
         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(QWEN_USER_DATA_DIR, options);
         }
@@ -1642,6 +1657,10 @@ export class QwenBrowser {
     async _waitForSendSlot(agent) {
         if (!agent)
             return;
+        // A COMPACTION send goes into a FRESH chat with a tiny prompt; the
+        // fixed gap learned in the OLD chat must not delay the recovery.
+        if (this.compactInProgress)
+            return;
         if (!this._lastSentAt)
             return;
         const gap = this.sendIntervalMs() - (Date.now() - this._lastSentAt);

package/dist/qwen-chats.js

@@ -71,13 +71,25 @@ export function scrapeQwenChatMessages(opts) {
     const uniq = Array.from(new Set(containers));
     // Keep only the OUTERMOST block of a nested pair.
     const blocks = uniq.filter((b) => !uniq.some((o) => o !== b && o.contains(b)));
+    // A REASONING block is UI state, not the answer. It is not always a PARENT
+    // of the text (a provider may render it as a sibling of the answer), so the
+    // message text is read from a CLONE with the reasoning subtrees removed —
+    // otherwise the restored dialogue printed the whole THINK phase.
+    const contentOf = (e) => {
+        const clone = e.cloneNode(true);
+        for (const t of Array.from(clone.querySelectorAll('*'))) {
+            if (thinkRe.test((t.className || '').toString()))
+                t.remove();
+        }
+        return (clone.textContent || '').trim();
+    };
     const out = [];
     for (const c of blocks) {
         let node = c.querySelector('[class*="markdown"], [class*="answer"]');
         const isAssistant = assistantRe.test(c.className || '') || !!node;
         if (!node)
             node = c;
-        const text = (node.textContent || '').trim();
+        const text = contentOf(node);
         if (!text)
             continue;
         out.push({ role: isAssistant ? 'assistant' : 'user', text });

package/dist/qwen-net-capture.js

@@ -1,3 +1,4 @@
+import { SERVER_BUSY_RE } from './qwen-ui.js';
 // Extraction of the RAW model answer from Qwen Chat's (chat.qwen.ai) network
 // data. The DOM distorts the answer (markdown/LaTeX/link auto-detection), so
 // — exactly like the DeepSeek path (net-capture.ts) — the answer the agent
@@ -316,7 +317,12 @@ export function isServerBusyText(body) {
     const errNotice = /event:\s*error|"type"\s*:\s*"error"|"error"\s*:/i.test(b);
     if (!errNotice && hasAnswerContent(b))
         return false;
-    return /server is busy|service unavailable|try again later/i.test(b);
+    // A bare notice without JSON framing (`Service unavailable`) is still a
+    // notice; a sentence that merely mentions one is not (SERVER_BUSY_RE needs
+    // the clause to start at the beginning / after punctuation / after a JSON
+    // key).
+    return (SERVER_BUSY_RE.test(b) ||
+        /^(?:please )?try again later[.!]?$/i.test(b.trim()));
 }
 // The chat's CONTEXT WINDOW is exhausted. Qwen refuses the turn and no retry
 // in the same chat can succeed - the only way out is a compaction into a

package/dist/qwen-ui.js

@@ -171,7 +171,14 @@ export const LOGIN_SELECTORS = [
 // ---------- service statuses / errors ----------
 // Qwen's rate-limit / busy notices (best-effort; the toast may be short-lived).
 export const RATE_LIMIT_RE = /too many requests|rate limit|too frequent|please try again later|слишком часто/i;
-export const SERVER_BUSY_RE = /server is busy|service unavailable|try again later/i;
+// A notice, not a phrase inside the answer (same lesson as the DeepSeek
+// pattern): the classifier also requires an error payload or an answer-less
+// body, and the phrase must stand alone.
+// A NOTICE, not a phrase inside a reply: the phrase must start a clause
+// (start of the text, after a newline/punctuation/colon, or right after a
+// `"content":"` / `"error":"` JSON key) and end one. A normal answer that
+// says "try again later" therefore does not look like a dead server.
+export const SERVER_BUSY_RE = /(?:^|[\n!?:]\s*|\.\s+|"(?:content|error)"\s*:\s*")(?:server is busy|service unavailable|try again later)(?=[.!,]|"|$)/im;
 // ---------- toggles (thinking mode / web search) ----------
 // Qwen exposes thinking as a MODE dropdown (`.qwen-thinking-selector`, label
 // "Auto" by default) with options Auto / Thinking / Fast — NOT a boolean

package/dist/restore-history.js

@@ -0,0 +1,304 @@
+// The RESTORED-DIALOGUE layer: what the operator sees when a chat is
+// reopened (/resume, /resume-id, startup). Every provider's stored history is
+// raw protocol text — the system prompt, tool results, tool-call JSON, the
+// model's safety block — so a restore must KEEP only the operator's own turns
+// and the agent's `respond` message. The formatting used to live inside the
+// DeepSeek DOM scraper, which is why only DeepSeek produced a readable
+// dialogue: Qwen/GLM store the SAME raw text through the same endpoints, so
+// normalization and truncation moved HERE, where every provider shares them.
+import { parseToolCall } from './answer-parse.js';
+const NL = String.fromCharCode(10);
+/** How many messages of the dialogue are printed by default. */
+export const RESTORED_HISTORY_LIMIT = 20;
+/**
+ * Longest restored message KEPT for display. The system prompt (leaked into
+ * history) is far bigger and is filtered by the noise checks below; a real
+ * answer above this size is shortened instead of being dropped.
+ */
+const RESTORED_MESSAGE_MAX = 100_000;
+/**
+ * DeepSeek stores the assistant turn VERBATIM: either a raw tool-call JSON
+ * ({"tool":"Read","args":{...}}, frequently dirty/truncated) or a `respond`
+ * call that carries the real message for the operator
+ * ({"tool":"respond","args":{"message":"..."}}). The operator only wants the
+ * `respond` message (and plain-text answers) — a tool-call is protocol noise.
+ *
+ * Returns the tool name and, for `respond`, the unwrapped message. Tolerant on
+ * purpose: the stored JSON is often dirty (a stray `}}`, a missing "args"
+ * wrapper), so a bare JSON.parse is not enough.
+ */
+export function parseAssistantToolCall(text) {
+    const t = String(text || '').trim();
+    if (!t)
+        return null;
+    // Broken heads like `<|tool": ...` or `tool": "Bash"` are tolerated.
+    const m = t.match(/tool"?\s*:\s*"([^"\s]+)"/);
+    if (!m)
+        return null;
+    const tool = m[1];
+    if (tool !== 'respond')
+        return { tool };
+    const greedy = t.match(/"message"\s*:\s*"([\s\S]*)"\s*\}*\s*$/);
+    let raw = greedy ? greedy[1] : '';
+    if (!greedy) {
+        // The value is not a quoted string (a number, a boolean, an array, a
+        // nested object): there is no operator-facing MESSAGE here. The old
+        // fallback sliced the raw text from the key and the restored turn printed
+        // `:42}}` / `:[1,2]}}` as if it were the model's answer.
+        const value = t.slice(t.indexOf('"message"') + 9).replace(/^\s*:\s*/, '');
+        if (!value.startsWith('"'))
+            return { tool, message: '' };
+        raw = value.replace(/^"/, '');
+    }
+    return { tool, message: unescapeJsonString(raw) };
+}
+/** Decode the JSON escape sequences that appear inside a captured string. */
+export function unescapeJsonString(s) {
+    // A `\uD800`-style escape that is NOT followed by a low surrogate (a
+    // truncated or hand-written payload) would become a LONE surrogate - a
+    // broken code point the restored dialogue prints as `?`. Decode a valid PAIR
+    // as one code point and drop an unpaired half.
+    let pendingHigh = '';
+    return String(s || '')
+        .replace(/\\u([0-9a-fA-F]{4})/g, (_x, h) => {
+        const cp = parseInt(h, 16);
+        if (cp >= 0xd800 && cp <= 0xdbff) {
+            pendingHigh = String.fromCharCode(cp);
+            return '';
+        }
+        if (cp >= 0xdc00 && cp <= 0xdfff) {
+            const high = pendingHigh;
+            pendingHigh = '';
+            return high ? high + String.fromCharCode(cp) : '';
+        }
+        pendingHigh = '';
+        return String.fromCharCode(cp);
+    })
+        .replace(/\\n/g, NL)
+        .replace(/\\r/g, String.fromCharCode(13))
+        .replace(/\\t/g, String.fromCharCode(9))
+        .replace(/\\"/g, '"')
+        .replace(/\\\\/g, '\\');
+}
+/**
+ * Normalize one restored message for display:
+ *  - USER: drop the protocol noise (system-prompt, tool results, nudges) — it
+ *    is not the operator's words.
+ *  - ASSISTANT: unwrap a `respond` call to its message; drop any other
+ *    tool-call (protocol noise); keep plain-text answers.
+ * Returns null when the message must not be shown.
+ */
+export function normalizeRestoredMessage(m) {
+    let text = String((m && m.text) || '').trim();
+    if (!text)
+        return null;
+    // The size cap exists to keep a leaked SYSTEM PROMPT (or another giant
+    // protocol blob) out of the restored dialogue. It must NOT drop a real
+    // answer: a long report/diff/document easily exceeds the cap, and dropping
+    // it silently left the operator with a dialogue where the agent's own reply
+    // was missing. Keep such a message but shorten it for display.
+    if (text.length > RESTORED_MESSAGE_MAX) {
+        // Never split a surrogate PAIR: the cut is in UTF-16 units, so a high half
+        // alone would reach the terminal as a broken code point (same rule as
+        // truncateToolResult / capReport / cutHookText).
+        let cut = RESTORED_MESSAGE_MAX;
+        const last = text.charCodeAt(cut - 1);
+        if (last >= 0xd800 && last <= 0xdbff)
+            cut--;
+        text = text.slice(0, cut) + '…';
+    }
+    if (m.role === 'user') {
+        if (/^Tool result for /.test(text))
+            return null;
+        if (/^You are a coding agent running in a terminal/.test(text))
+            return null;
+        if (/^You stopped after a tool result/.test(text))
+            return null;
+        // The agent loop's own watchdog nudge is protocol noise written by US, not
+        // by the operator: when an answer timed out the loop resends this text as
+        // the "user" message. It used to leak into the restored dialogue (a dozen
+        // copies after a flaky run), so drop it like the other nudges.
+        if (/^The previous turn was cut off/.test(text))
+            return null;
+        if (/^\[system\]/.test(text))
+            return null;
+        if (/^The user ran \//.test(text))
+            return null;
+        // `/compact` posts its summary as a USER turn, prefixed with a marker the
+        // loop writes (not the operator): a restored dialogue should show the
+        // TASK, not the mechanical handover.
+        if (/^Compact the conversation so far/.test(text))
+            return null;
+        if (/^This is the handover summary/.test(text))
+            return null;
+        const stripped = stripUserFraming(text);
+        if (!stripped)
+            return null;
+        return { role: 'user', text: stripped };
+    }
+    // Reasoning is UI state, not the answer.
+    text = stripThinkBlocks(text);
+    if (!text)
+        return null;
+    // Only a real DSML MARKER is protocol noise: a bare mention of the feature
+    // (an answer explaining the DSML parser) is a normal reply.
+    if (/[<｜]\s*DSML\s*[>｜]/i.test(text))
+        return null;
+    if (/^<system>/i.test(text))
+        return null;
+    // The model sometimes emits its own safety-classification block as a plain
+    // "answer"; it is not for the operator.
+    if (/<ds_safety>/i.test(text))
+        return null;
+    if (/^Safe$/i.test(text))
+        return null;
+    // EVERY format the parser knows, not just the legacy `{"tool":...}` head.
+    const generic = toolCallOf(text);
+    if (generic) {
+        if (generic.tool !== 'respond')
+            return null;
+        const msg = (generic.message || '').trim();
+        if (!msg)
+            return null;
+        if (/<\/?ds_safety\b/i.test(msg))
+            return null;
+        return { role: 'assistant', text: msg };
+    }
+    const legacy = parseAssistantToolCall(text);
+    if (legacy) {
+        if (legacy.tool !== 'respond')
+            return null;
+        const msg = (legacy.message || '').trim();
+        if (!msg)
+            return null;
+        if (/<\/?ds_safety\b/i.test(msg))
+            return null;
+        return { role: 'assistant', text: msg };
+    }
+    // A plain-text answer (written without the respond wrapper) — show as-is.
+    return { role: 'assistant', text };
+}
+/** Back-compat predicate: is the message worth showing at all? */
+export function isDisplayableMessage(m) {
+    return normalizeRestoredMessage(m) !== null;
+}
+/**
+ * Keep only the last `limit` messages, dropping protocol noise and UNWRAPPING
+ * the assistant `respond` calls to their operator-facing text.
+ */
+export function trimRestoredMessages(messages, limit = RESTORED_HISTORY_LIMIT) {
+    const clean = [];
+    for (const m of messages || []) {
+        if (!m || typeof m.text !== 'string')
+            continue;
+        const n = normalizeRestoredMessage({
+            role: m.role === 'user' ? 'user' : 'assistant',
+            text: String(m.text),
+        });
+        if (n)
+            clean.push(n);
+    }
+    if (limit > 0 && clean.length > limit)
+        return clean.slice(clean.length - limit);
+    return clean;
+}
+/**
+ * Render the restored dialogue as plain text lines: "❯ ..." for the operator,
+ * "● ..." for the agent. Markdown rendering is done by the caller (it needs
+ * the terminal width); this helper is pure and unit-tested.
+ */
+export function formatRestoredHistory(messages, opts = {}) {
+    const list = trimRestoredMessages(messages, opts.limit ?? RESTORED_HISTORY_LIMIT);
+    const out = [];
+    for (const m of list) {
+        const marker = m.role === 'user' ? '❯ ' : '● ';
+        out.push(marker + m.text.trim());
+    }
+    return out.join(NL + NL);
+}
+/**
+ * Remove the reasoning a provider renders INTO the message text.
+ *
+ * Qwen/GLM expose the THINK phase as part of the turn, and a DeepSeek DOM
+ * scrape keeps the collapsible "Thought for N seconds" header after the
+ * reasoning subtree is stripped. Reasoning is NOT the answer, so a restored
+ * dialogue must not show it.
+ */
+export function stripThinkBlocks(text) {
+    let t = String(text || '');
+    // A fenced or tagged reasoning block, the shape every provider uses when it
+    // stores the phase inline.
+    t = t.replace(/<(think|thinking|reasoning)>[\s\S]*?<\/\1>\s*/gi, '');
+    t = t.replace(/```(?:think|thinking|reasoning)\s*[\s\S]*?```\s*/gi, '');
+    // "Thought for 1 second" / "Think for 12s" — a header LINE. Live DOM
+    // scrape: the header, then the answer ("Thought for 1 second" + NEWLINE +
+    // "OK2"); the reasoning BODY was already removed with its subtree.
+    // A single newline: with the blank-line form the `[\s\S]*?` below ate
+    // the whole answer and the restored turn vanished.
+    t = t.replace(/^\s*(?:thought|thinking|think)\s+for\s+[^\n]*\n?/i, '');
+    // The DOM may hand the header WITHOUT its newline ("Thought for 1
+    // secondOK2"): drop the header up to the first non-space run only when a
+    // line break or the end of the text follows it.
+    return t.trim();
+}
+/**
+ * Drop a provider's OWN framing from a user turn so the restored dialogue
+ * shows the operator's words: DeepSeek stores "You are a coding agent ..." as a
+ * USER message and prefixes a task with `<system>...</system>`.
+ */
+export function stripUserFraming(text) {
+    let t = String(text || '');
+    for (let i = 0; i < 3; i++) {
+        const next = t.replace(/^\s*<system>[\s\S]*?<\/system>\s*/i, '');
+        if (next === t)
+            break;
+        t = next;
+    }
+    return t.trim();
+}
+/**
+ * A turn that is a TOOL CALL (any provider, any format the parser knows) is
+ * protocol noise in the restored dialogue, EXCEPT a `respond` call, whose
+ * message is the agent's real answer.
+ *
+ * Returns the call when it is one, `null` otherwise, and the operator-facing
+ * message for a `respond`.
+ */
+export function toolCallOf(text) {
+    const t = String(text || '').trim();
+    if (!t)
+        return null;
+    // A real call starts with a bracket, a marker or the `tool` key; the strict
+    // parser is only consulted then, so ordinary prose is never re-parsed (and a
+    // bare "tool:" inside a report does not turn the report into a call).
+    if (!/^[\s\[\{<]/.test(t) && !/tool"?\s*:/.test(t.slice(0, 200))) {
+        return null;
+    }
+    let calls = [];
+    try {
+        const parsed = parseToolCall(t);
+        calls = (Array.isArray(parsed) ? parsed : parsed ? [parsed] : []);
+    }
+    catch {
+        return null;
+    }
+    if (!calls.length)
+        return null;
+    const first = calls[0];
+    if (first.tool === 'respond') {
+        const msg = first.args?.message;
+        return { tool: 'respond', message: typeof msg === 'string' ? msg : '' };
+    }
+    return { tool: first.tool };
+}
+/** Convert a provider history to the shared restored-message shape. */
+export function toRestoredMessages(messages) {
+    const out = [];
+    for (const m of messages || []) {
+        if (!m || typeof m.text !== 'string')
+            continue;
+        const role = m.role === 'user' ? 'user' : 'assistant';
+        out.push({ role, text: m.text });
+    }
+    return out;
+}

package/dist/tui/TuiEditor.js

@@ -252,6 +252,14 @@ export class TuiEditor {
         }
     }
     // ---------- submission ----------
+    /**
+     * Submit a message as if the operator pressed Enter. The demo recorder
+     * (scripts/demo-replay.mts) needs the REAL entry path — the turn rule and
+     * the bar-marked rows — without a keypress.
+     */
+    submitQuestion(text) {
+        this.handleSubmit(text, []);
+    }
     handleSubmit(display, atts) {
         const text = expandPastes(this.store.getSnapshot().pastes, display);
         this.attachments.reset();

package/package.json

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