zames_pro 2.90.16 → 2.90.18

package/dist/commands.js

@@ -3,6 +3,7 @@ import path from 'path';
 import os from 'os';
 import { isImageName } from './attachments.js';
 import { SYSTEM_PROMPT_BUDGET_BYTES, kb, overBudget } from './prompt-budget.js';
+import { parseAssistantToolCall } from './restore-history.js';
 import { translate, DEFAULT_LOCALE, } from './i18n.js';
 // Helpers for the slash commands (/diff, /cost, /export, /doctor, /review,
 // /add-dir, /queue, /goal, custom commands). Pure functions, unit-tested
@@ -437,184 +438,6 @@ export function resolveExtraDir(input, workdir, t = translate('en')) {
     }
     return { path: abs };
 }
-/** 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;
-        if (/^\[system\]/.test(text))
-            return null;
-        if (/^The user ran \//.test(text))
-            return null;
-        return { role: 'user', text };
-    }
-    // Only a real DSML MARKER is protocol noise: a bare mention of the feature
-    // (an answer explaining the DSML parser) is a normal reply, and the old
-    // `/DSML/i` check dropped it from the restored dialogue (the same bug the
-    // /compact summary validator already fixed).
-    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;
-    const call = parseAssistantToolCall(text);
-    if (call) {
-        if (call.tool !== 'respond')
-            return null;
-        const msg = (call.message || '').trim();
-        if (!msg)
-            return null;
-        // The safety-classification block can sit INSIDE the respond message; the
-        // plain-text path already drops it, and printing the marker as the answer
-        // is the same leak.
-        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(m);
-        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);
-}
 // ---------- /compact ----------
 /**
  * The prompt that asks the model to compress the current chat into a handover

package/dist/compact.js

@@ -1,5 +1,6 @@
 import { translate } from './i18n.js';
-import { buildCompactPrompt, buildCompactCarryover, isUsableCompactSummary, trimRestoredMessages, formatRestoredHistory, } from './commands.js';
+import { buildCompactPrompt, buildCompactCarryover, isUsableCompactSummary, } from './commands.js';
+import { trimRestoredMessages, formatRestoredHistory, } from './restore-history.js';
 import { loadHooks, runLifecycleHooks } from './hooks.js';
 const NL = String.fromCharCode(10);
 /** How many times the summary call is retried before the local fallback. */
@@ -108,10 +109,12 @@ export async function performCompact(opts) {
         }
         if (!summary) {
             let fallback = '';
+            let historyLen = 0;
             try {
                 const all = browser.fetchChatMessages && currentChatId
                     ? await browser.fetchChatMessages(currentChatId).catch(() => [])
                     : [];
+                historyLen = all.length;
                 const msgs = trimRestoredMessages(all, 0);
                 if (msgs.length) {
                     fallback = formatRestoredHistory(msgs, { limit: fallbackLimit });
@@ -124,7 +127,33 @@ export async function performCompact(opts) {
                 log(t('compact.summary_fallback', { v: String(fallbackLimit) }));
             }
             else {
-                const err = summaryErr || t('common.unknown');
+                // When the history endpoint gave NOTHING there is no model error to
+                // report: say WHICH count came back, otherwise the operator sees a
+                // bare "unknown" and cannot tell a blocked fetch from an empty chat.
+                // `_lastHistoryError` is part of the provider contract (types.ts), so
+                // it is read WITHOUT a cast.
+                const histErr = String(browser._lastHistoryError || '');
+                if (process.env.ZAMES_COMPACT_DEBUG)
+                    console.error('compact debug: historyLen=' +
+                        historyLen +
+                        ' id=' +
+                        currentChatId +
+                        ' err=' +
+                        (histErr || '-'));
+                // The reason must be ACTIONABLE: a model error, a BLOCKED history
+                // fetch (auth/HTTP) and a TOO-SHORT history end here, and a bare
+                // "unknown" hides which one it was.
+                const err = summaryErr
+                    ? summaryErr
+                    : histErr
+                        ? t('compact.summary_failed', { v: histErr })
+                        : historyLen <= 0
+                            ? t('compact.summary_failed', { v: 'history empty' }) +
+                                ' (' +
+                                historyLen +
+                                ')'
+                            : t('compact.summary_failed', { v: 'history too short' });
+                ' (' + historyLen + ')';
                 log(t('compact.summary_failed', { v: err }));
                 return {
                     ok: false,
@@ -146,6 +175,10 @@ export async function performCompact(opts) {
         // the duration — by now the exhausted chat is behind us and a refusal here
         // means the compaction itself cannot proceed, which the caller reports.
         const prevOnContextLimit = browser.onContextLimit;
+        // Compact sends skip the adaptive throttle: a fresh chat with a tiny
+        // prompt must not be refused for "too frequent" (see _waitForSendSlot).
+        const holder = browser;
+        holder.compactInProgress = true;
         if (contextExhausted && 'onContextLimit' in browser) {
             ;
             browser.onContextLimit = null;
@@ -162,6 +195,7 @@ export async function performCompact(opts) {
             });
         }
         finally {
+            holder.compactInProgress = false;
             if (contextExhausted && 'onContextLimit' in browser) {
                 ;
                 browser.onContextLimit = prevOnContextLimit || null;
@@ -197,13 +231,17 @@ export async function performCompact(opts) {
         };
     }
     catch (e) {
-        log(e.message);
+        // A thrown NON-Error (a rejected Playwright call, a string) used to give
+        // `error: undefined` and the caller reported a bare "unknown": the real
+        // reason for a failed compaction was lost.
+        const reason = e instanceof Error ? e.message : String(e || 'compaction failed');
+        log(reason);
         return {
             ok: false,
             chatId: currentChatId,
             summaryChars: 0,
             beforeTokens,
-            error: e.message,
+            error: reason || 'compaction failed',
         };
     }
     finally {

package/dist/deepseek-ui.js

@@ -94,12 +94,17 @@ export const RESTORE_ANSWER_SELECTORS = [
     'div[class*="ds-markdown"]',
 ];
 // Message-level containers for the restored dialogue (broad first).
+// MEASURED on the live page (2-turn chat): `[data-message-id]` no longer
+// exists, `[class*="chat-message"]`/`[class*="message-item"]` match nothing,
+// and the bare `[class*="_message"]` catch-all was a class-name HASH tail
+// (`_63c77b1`) — so the whole DOM fallback returned an EMPTY dialogue. The
+// real containers are `div.ds-message` (one per turn) and its scroll wrapper.
 export const MESSAGE_CONTAINER_SELECTORS = [
+    'div.ds-message',
     '[data-message-id]',
     '[class*="ds-message"]',
     '[class*="chat-message"]',
     '[class*="message-item"]',
-    '[class*="_message"]',
 ];
 // A message block is "assistant" when it carries the assistant class OR a
 // rendered markdown wrapper (a user bubble has no rendered markdown). Used by
@@ -216,7 +221,10 @@ export const TOGGLE_SELECTORS = [
     'div[role="button"][aria-pressed]',
     'button[aria-pressed]',
 ];
-export const DEEP_THINKING_RE = /глубок|deep\s*think/i;
+// `deep\s*think` does NOT match DeepSeek's live label "DeepThink" (no space),
+// so the reasoning toggle was never found and never applied — the agent ran
+// without reasoning no matter what `browser.deepThinking` said.
+export const DEEP_THINKING_RE = /глубок|deep\s*think|think/i;
 export const WEB_SEARCH_RE = /поиск|search/i;
 // ---------- attachments ----------
 export const ATTACH_SELECTORS = [
@@ -242,7 +250,15 @@ export const RATE_LIMIT_RE = /(messages? too frequent|too many requests|rate lim
 // Transient server-side hiccups (DeepSeek overloaded / hiccup). Unlike the
 // rate limit, these usually clear in seconds, so we retry quickly instead of
 // waiting minutes.
-export const SERVER_BUSY_RE = /(server (is )?busy|server error|service (is )?unavailable|temporarily unavailable|internal server error|\b50[234]\b|server overloaded|сервер занят|сервер перегружен|сервис недоступен|внутренняя ошибка|попробуйте позже)/i;
+// A toast container (role=alert / .toast) can include the TEXT OF THE
+// CONVERSATION around its notice, so a normal answer that merely SAYS
+// "try again later" or "the server is busy" looked like a dead server: the
+// loop threw ServerBusyError, clicked Continue and RESENT a healthy turn
+// (live: 6 Continue clicks on one answer). Match the notice SHAPE: the
+// phrase must be a STANDALONE CLAUSE (start/end of the text, after a
+// newline, or next to punctuation) and a sentence merely discussing it
+// ("if the server is busy, ...") must not match.
+export const SERVER_BUSY_RE = /(?:^|[\n!?]\s*|\.\s+|:\s+)(?:(?:(?:http|error|status|code)\s*[:#]?\s*)?5(?:02|03|04)(?:\s+(?:server\s+)?(?:error|unavailable|service\s+unavailable))?|server (?:is )?(?:temporarily )?(?:busy|overloaded)|service (?:is )?unavailable|temporarily unavailable|internal server error|bad gateway|gateway timeout|сервер (?:временно )?(?:занят|перегружен)|сервис недоступен|внутренняя ошибка сервера)(?:[.!,]|$)/im;
 // The chat's CONTEXT WINDOW is exhausted. DeepSeek refuses to continue the
 // conversation and answers with a non-retryable notice instead of a model
 // turn: "Length limit reached. Please start a new chat." (the Russian UI:
@@ -254,25 +270,45 @@ export const SERVER_BUSY_RE = /(server (is )?busy|server error|service (is )?una
 // or a server hiccup.
 export const CONTEXT_LIMIT_RE = /(length limit (?:has been )?reached|context (?:window|length) (?:is )?(?:exceeded|full)|maximum context|start a new (?:chat|conversation)|достигнут лимит длин|лимит длин[ыа] (?:достигнут|исчерпан)|начните новый чат|начните нов(ый|ую) (диалог|бесед))/i;
 // ---------- network protocol (SSE) ----------
-export const GENERATION_ERR_RE = /"finish_reason":\s*"generation_err"/i;
+// Every protocol marker is anchored to the START OF A LINE and to the exact
+// shape it has in the stream. Why: the old patterns matched the quoted pair
+// ANYWHERE in the body, and a chat/completion REQUEST body carries the whole
+// conversation — our own tool results and answers included. A task or a tool
+// output that merely MENTIONED the marker (e.g. while working on this very
+// detector) then looked like a truncated turn and the agent resent a task the
+// server never truncated. Inside a JSON string value those quotes are
+// ESCAPED, so a line-anchored pattern cannot match them.
+// A marker is read from the RAW SSE body, which ALSO carries the RESPONSE
+// text of the model — and a tool call quoting this very code used to trip
+// the detector. The anchor is therefore (a) the start of a LINE (the body is
+// JSON-escaped, so a quote inside the text is `\"` and never a line start)
+// and (b) the marker key must be the FIRST quoted key of its object, i.e.
+// no unescaped `"` may precede it on the line. `[^\\n]*?` stops at the
+// first quote (which broke the BATCH shape `"p":"response",..."quasi_status"`),
+// `.*?` alone stops at the first UNESCAPED quote — exactly what is wanted.
+// `(?:[^"\\]|\\.)*?` skips ESCAPED quotes (`\"` inside the model text)
+// and stops at the first REAL one — so the marker may sit after other keys
+// of the same line, but a quote inside our own text never anchors it.
+const MARKER_START = '^(?:data: ?|\\{).*?"';
+export const GENERATION_ERR_RE = new RegExp(MARKER_START + 'finish_reason": ?"generation_err"', 'im');
 // The server gave up on the turn ("Server busy, please try again later."):
 // finish_reason is `generation_timeout` and there is NO RESPONSE fragment, so
 // extractAnswer() returns '' and the finish loop would wait out the whole
 // timeout. Same failure family as generation_err — the turn did not complete,
 // so ask() must resend instead of hanging.
-export const GENERATION_TIMEOUT_RE = /"finish_reason":\s*"generation_timeout"/i;
+export const GENERATION_TIMEOUT_RE = new RegExp(MARKER_START + 'finish_reason": ?"generation_timeout"', 'im');
 // DeepSeek emits the generation status in TWO shapes: the initial message as a
 // JSON property (`"quasi_status":"FINISHED"` inside v.response) and later
 // BATCH updates (`{"p":"quasi_status","v":"FINISHED"}`). The old regex only
 // matched the BATCH form, so a FINISHED-without-answer turn that came in the
 // PROPERTY form (the real "Server is temporarily unavailable" case) was NOT
 // detected — the agent hung on "Stopped" until the timeout. Match both.
-export const INCOMPLETE_STATUS_RE = /"quasi_status"(?::|,"v":)"INCOMPLETE"/i;
+export const INCOMPLETE_STATUS_RE = new RegExp(MARKER_START + 'quasi_status"(?: ?: ?| ?,"v": ?)"INCOMPLETE"', 'im');
 // A turn that ENDED (`quasi_status: FINISHED`) but produced NO answer text —
 // the reasoning was generated and the model stopped WITHOUT a RESPONSE
 // fragment. The UI shows Stopped + Continue. Matches both the JSON-property
 // and the BATCH shape (see INCOMPLETE_STATUS_RE).
-export const FINISHED_STATUS_RE = /"quasi_status"(?::|,"v":)"FINISHED"/i;
+export const FINISHED_STATUS_RE = new RegExp(MARKER_START + 'quasi_status"(?: ?: ?| ?,"v": ?)"FINISHED"', 'im');
 // Only a completion/continue turn carries a real answer. Gating the capture
 // assignment to these URLs keeps a future endpoint (which happens to return a
 // `content`/`text` field) from clobbering the answer and looking fresh.

package/dist/glm-browser.js

@@ -43,6 +43,12 @@ function capNetBody(body) {
     return body.slice(0, head) + '\n...[truncated]...\n' + body.slice(-1024);
 }
 export class GlmBrowser {
+    /**
+     * 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;
     /** The chat a send must join (set by the agent loop; see types.ts). */
     resumeChatId = null;
     providerName = 'glm';
@@ -98,6 +104,7 @@ export class GlmBrowser {
     _lastTokenUsage;
     _toggles;
     _apiAuth;
+    /** Last error from fetchChatMessages ('' on success). */
     _lastHistoryError;
     _netBody;
     _netHookInstalled;
@@ -1395,6 +1402,13 @@ export class GlmBrowser {
     async _waitForSendSlot(agent) {
         if (!agent)
             return;
+        // A COMPACTION send is not a user turn: it goes into a FRESH chat whose
+        // whole content is the (tiny) system prompt + summary. Waiting out a
+        // block learned in the OLD chat, or being refused for "too frequent" on
+        // a two-message chat, killed the only recovery path. The throttle is
+        // irrelevant there — the send carries a few hundred tokens.
+        if (this.compactInProgress)
+            return;
         const gap = this.sendRuntime.waitMs();
         if (gap <= 0)
             return;

package/dist/glm-chats.js

@@ -66,12 +66,24 @@ export function scrapeGlmChatMessages(opts) {
     }
     const uniq = Array.from(new Set(containers));
     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) {
         const role = userRe.test((c.className || '').toString())
             ? 'user'
             : 'assistant';
-        const text = (c.textContent || '').trim();
+        const text = contentOf(c);
         if (!text)
             continue;
         out.push({ role, text });

package/dist/glm-ui.js

@@ -145,7 +145,10 @@ export function glmContextWindow(model) {
 // so a normal answer that merely mentions "try again" is not mistaken for a
 // limit.
 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|high demand/i;
+// The same lesson as the DeepSeek pattern: a normal answer may SAY "try
+// again later" or "high demand", so the phrase must be a standalone notice
+// and not a clause inside the reply.
+export const SERVER_BUSY_RE = /(?:^|[\n!?]\s*|\.\s+|:\s+)(?:server is busy|service unavailable|high demand|try again later)(?:[.!,]|$)/im;
 // ---------- attachments ----------
 // The observed upload control (a real filechooser on click).
 export const UPLOAD_BUTTON_SELECTOR = '#upload-file-button, button[class*="upload"]';

package/dist/index.js

@@ -292,11 +292,13 @@ const RELOADABLE = [
     // long-lived LineEditor, itself not reloadable) and spinner.ts, which already
     // picks up a fresh copy transitively.
     'commands',
+    'restore-history',
     'run-task',
     'attach-refs',
 ];
 const mod = {
     commands: null,
+    restore: null,
     attach: null,
     runTask: null,
     createTools,
@@ -361,6 +363,8 @@ async function reloadModules() {
         mod.backlogNeedsPruning = pick('backlog', 'backlogNeedsPruning');
     if (pick('commands', 'missingCommandArgs'))
         mod.commands = loaded.get('commands');
+    if (pick('restore-history', 'trimRestoredMessages'))
+        mod.restore = loaded.get('restore-history');
     if (pick('attach-refs', 'resolveAttachPath'))
         mod.attach = loaded.get('attach-refs');
     if (pick('run-task', 'runTask'))
@@ -941,8 +945,8 @@ async function printRestoredHistory(browser, ui, chatId = null) {
     // those. The "truncated" note must compare the DISPLAYABLE count with the
     // limit (comparing `all.length` always fired, because tool-calls are
     // dropped and the raw history is always longer).
-    const displayable = mod.commands.trimRestoredMessages(all, 0);
-    const messages = mod.commands.trimRestoredMessages(all);
+    const displayable = mod.restore.trimRestoredMessages(all, 0);
+    const messages = mod.restore.trimRestoredMessages(all);
     // Always surface the diagnostic line when the history could not be turned
     // into anything printable — otherwise "the dialogue is empty" is a dead end
     // (was the fetch blocked? did the chat really have no user turns?).
@@ -995,7 +999,7 @@ async function printRestoredHistory(browser, ui, chatId = null) {
     }
     if (displayable.length > messages.length) {
         out(theme.dim(t('chats.history_truncated', {
-            n: String(mod.commands.RESTORED_HISTORY_LIMIT),
+            n: String(mod.restore.RESTORED_HISTORY_LIMIT),
         })));
     }
 }
@@ -3682,7 +3686,7 @@ async function main() {
                     if (cid) {
                         const all = await browser.fetchChatMessages(cid).catch(() => []);
                         chatHasMessages =
-                            mod.commands.trimRestoredMessages(all, 0).length > 0;
+                            mod.restore.trimRestoredMessages(all, 0).length > 0;
                     }
                 }
                 if (chatHasMessages) {
@@ -3715,9 +3719,9 @@ async function main() {
                             const all = cid
                                 ? await browser.fetchChatMessages(cid).catch(() => [])
                                 : [];
-                            const msgs = mod.commands.trimRestoredMessages(all, 0);
+                            const msgs = mod.restore.trimRestoredMessages(all, 0);
                             if (msgs.length) {
-                                summary = mod.commands.formatRestoredHistory(msgs, {
+                                summary = mod.restore.formatRestoredHistory(msgs, {
                                     limit: 40,
                                 });
                             }

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.
 //