zames_pro 2.17.0 → 2.18.0

package/README.md

@@ -147,6 +147,9 @@ Codex CLI:
  alwaysConfirm regex list).
 - /add-dir <path> — validate an extra directory (the sandbox is fixed at
  startup; relaunch with --dir to write there).
+- /resume <n> (after /chats) and /resume-id <id> — open a chat and PRINT its
+ dialogue into the terminal, so the restored context is visible. Only the
+ last 20 messages are shown (`RESTORED_HISTORY_LIMIT`).
 - /review [focus] [--staged] — ask the agent to review uncommitted changes
  and report findings (no code changes).
 

package/dist/agent-loop.js

@@ -129,6 +129,9 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
     let unparsedRetries = 0;
     const MAX_UNPARSED_RETRIES = 4;
     let finalRespondAsked = false;
+    // The operator is told ONCE that the agent is re-asking the model for a
+    // proper tool call (not on every retry — that would spam the terminal).
+    let toolRetryWarned = false;
     // Guard against "the agent stalled": DeepSeek sometimes sends a final text
     // that merely DESCRIBES the next tool call (or cuts the answer off
     // mid-word), and the agent silently finishes the task even though the work
@@ -207,9 +210,9 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
                 attempt: afterToolRetries,
                 error: e.message,
             });
-            safeWarning('browser.ask() did not return an answer within ' +
-                Math.round(askDeadlineMs / 1000) +
-                's — retrying the request.');
+            safeWarning(translate(locale)('ds.answer_timeout', {
+                sec: Math.round(askDeadlineMs / 1000),
+            }));
             if (afterToolRetries < MAX_AFTER_TOOL_RETRIES) {
                 afterToolRetries++;
                 await new Promise((r) => setTimeout(r, 1500));
@@ -218,8 +221,7 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
             transcript?.log('ask_timeout_exhausted', {
                 message: 'ask() did not return an answer and the retry limit is exhausted',
             });
-            safeWarning('browser.ask() stopped responding; retry limit exhausted, ' +
-                'stopping. No model answer — check the DeepSeek chat manually.');
+            safeWarning(translate(locale)('ds.answer_timeout_give_up'));
             return 'ask() watchdog: no model answer received';
         }
         await reportChat();
@@ -402,6 +404,16 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
                     attempt: unparsedRetries,
                     response: rawResponse.slice(0, 500),
                 });
+                // Tell the operator WHY nothing is happening: the model wrote text
+                // instead of a tool call and the agent is asking it to continue. Only
+                // once per task, otherwise the retry budget spams the terminal.
+                if (!toolRetryWarned) {
+                    toolRetryWarned = true;
+                    safeWarning(translate(locale)('ds.tool_retry', {
+                        attempt: unparsedRetries,
+                        max: MAX_UNPARSED_RETRIES,
+                    }));
+                }
                 message =
                     (justRanTool
                         ? 'You stopped after a tool call and wrote plain text. '

package/dist/browser.js

@@ -277,6 +277,13 @@ export class DeepSeekBrowser {
     _netCapture;
     _netCaptureAt;
     _netChatId;
+    // Authorization / PoW headers sniffed from DeepSeek's own API requests, so
+    // fetchChatMessages can replay them (a bare fetch does not get them).
+    _apiAuth;
+    _apiPow;
+    // Last error from fetchChatMessages ('' on success). Surfaced under --debug
+    // so a missing restored history can be diagnosed.
+    _lastHistoryError;
     _netSniff;
     _netSniffLimit;
     _netHookInstalled;
@@ -321,6 +328,9 @@ export class DeepSeekBrowser {
         this._netCapture = '';
         this._netCaptureAt = 0;
         this._netChatId = null;
+        this._apiAuth = '';
+        this._apiPow = '';
+        this._lastHistoryError = '';
         this._netSniff = [];
         this._netSniffLimit = 5;
         this._netHookInstalled = false;
@@ -424,6 +434,23 @@ export class DeepSeekBrowser {
         pg.on('response', (resp) => {
             void this._onResponse(resp).catch(() => { });
         });
+        // DeepSeek's own API calls carry an Authorization header (the app reads a
+        // token from its storage and sets it explicitly). A bare fetch from our
+        // code does NOT get it, so history_messages would answer 401/empty.
+        // Sniff the header off the real requests and replay it later.
+        pg.on('request', (req) => {
+            try {
+                const url = req.url();
+                if (!/deepseek\.com\/api\//i.test(url))
+                    return;
+                const h = req.headers();
+                if (h['authorization'])
+                    this._apiAuth = h['authorization'];
+                if (h['x-ds-pow-response'])
+                    this._apiPow = h['x-ds-pow-response'];
+            }
+            catch { }
+        });
     }
     async _onResponse(resp) {
         try {
@@ -1017,10 +1044,17 @@ export class DeepSeekBrowser {
                 if (e instanceof RateLimitError) {
                     rateLimitRetries++;
                     if (rateLimitRetries > this.maxRateLimitRetries) {
-                        console.error(theme.error(`✖ DeepSeek не принял сообщение после ${rateLimitRetries} пауз по ${Math.ceil(this.rateLimitWaitMs / 60000)} мин.`));
+                        console.error(theme.error(this._t('ds.rate_limit_give_up', {
+                            attempt: rateLimitRetries,
+                            min: Math.ceil(this.rateLimitWaitMs / 60000),
+                        })));
                         throw e;
                     }
-                    console.error(theme.warn(`⏳ DeepSeek: «слишком часто». Жду ${Math.ceil(this.rateLimitWaitMs / 60000)} мин (${rateLimitRetries}/${this.maxRateLimitRetries}) и повторю...`));
+                    console.error(theme.warn(this._t('ds.rate_limit_wait', {
+                        min: Math.ceil(this.rateLimitWaitMs / 60000),
+                        attempt: rateLimitRetries,
+                        max: this.maxRateLimitRetries,
+                    })));
                     // Interruptible: Esc/Ctrl+C must cancel this long wait too,
                     // otherwise "stop" stays frozen for up to 5 minutes.
                     const aborted = await this._sleepInterruptible(this.rateLimitWaitMs);
@@ -1028,15 +1062,44 @@ export class DeepSeekBrowser {
                         return '(прервано пользователем)';
                     continue;
                 }
-                console.error(`\n⚠ ask() попытка ${attempt}/${this.askRetries} провалилась: ${e.message}`);
+                // Server busy / overloaded: clear in seconds, so we retry quickly
+                // (unlike the rate limit). Without this branch the error fell into the
+                // generic ask() retry and the operator saw a bare message with no
+                // explanation of what DeepSeek is doing.
+                if (e instanceof ServerBusyError) {
+                    serverBusyRetries++;
+                    if (serverBusyRetries > this.maxServerBusyRetries) {
+                        console.error(theme.error(this._t('ds.server_busy_give_up', {
+                            attempt: serverBusyRetries,
+                        })));
+                        throw e;
+                    }
+                    console.error(theme.warn(this._t('ds.server_busy_wait', {
+                        sec: Math.ceil(this.serverBusyWaitMs / 1000),
+                        attempt: serverBusyRetries,
+                        max: this.maxServerBusyRetries,
+                    })));
+                    const aborted = await this._sleepInterruptible(this.serverBusyWaitMs);
+                    if (aborted)
+                        return '(прервано пользователем)';
+                    continue;
+                }
+                console.error('\n' +
+                    theme.warn(this._t('ds.ask_retry', {
+                        attempt,
+                        max: this.askRetries,
+                        error: e.message,
+                    })));
                 if (/closed|crash|Target page|browser/i.test(e.message)) {
-                    console.error('⚠ перезапускаю браузер...');
+                    console.error(theme.warn(this._t('ds.ask_restart_browser')));
                     try {
                         await this.restart();
                         await this.waitForLogin();
                     }
                     catch (re) {
-                        console.error(`⚠ не удалось перезапустить: ${re.message}`);
+                        console.error(theme.warn(this._t('ds.ask_restart_failed', {
+                            error: re.message,
+                        })));
                     }
                 }
                 if (attempt < this.askRetries) {
@@ -1044,7 +1107,10 @@ export class DeepSeekBrowser {
                 }
             }
         }
-        throw new Error(`ask() провалился после ${this.askRetries} попыток: ${lastErr?.message}`);
+        throw new Error(this._t('ds.ask_failed', {
+            max: this.askRetries,
+            error: lastErr?.message || '',
+        }));
     }
     async _setInputText(input, text) {
         const tag = await input.evaluate((el) => el.tagName.toLowerCase());
@@ -1100,7 +1166,10 @@ export class DeepSeekBrowser {
                 return el.innerText || el.textContent || "";
             });
             if (norm(got2) !== norm(text)) {
-                throw new Error("Не удалось вставить текст в поле ввода DeepSeek целиком (вставлено " + norm(got2).length + " из " + norm(text).length + " символов). Сообщение не отправлено, чтобы не отправить обрезанный текст.");
+                throw new Error(this._t('ds.input_partial', {
+                    got: norm(got2).length,
+                    want: norm(text).length,
+                }));
             }
         }
     }
@@ -1250,7 +1319,7 @@ export class DeepSeekBrowser {
             return '(прервано пользователем)';
         const input = await this._findVisible(INPUT_SELECTORS, 10_000);
         if (!input) {
-            throw new Error('Не найдено поле ввода. Запустите /debug-dom и поправьте INPUT_SELECTORS.');
+            throw new Error(this._t('ds.input_missing'));
         }
         const beforeText = await this._readLastAnswerTextClean().catch(() => '');
         this._askDebug('SEND agent=' + agent + ' len=' + prompt.length + ' beforeLen=' + beforeText.length + ' beforeHead=' + JSON.stringify(beforeText.slice(0, 60)));
@@ -1411,8 +1480,7 @@ export class DeepSeekBrowser {
             }
         }
         if (!started) {
-            throw new Error('Ответ не начал генерироваться за 35с даже после повторной отправки. ' +
-                'Проверьте чат DeepSeek вручную.');
+            throw new Error(this._t('ds.send_no_start'));
         }
         // Wait until the answer stops changing. We check the "not generating"
         // condition via text growth, NOT via _isGenerating().
@@ -1482,12 +1550,11 @@ export class DeepSeekBrowser {
             return this._netCapture;
         }
         this._askDebug('THROW no-new-answer lastLen=' + last.length + ' beforeLen=' + beforeText.length);
-        throw new Error('Новый ответ не получен (на странице остался прежний текст). ' +
-            'Возможно, сообщение не отправилось.');
+        throw new Error(this._t('ds.send_no_new_answer'));
     }
     async dumpDom(filePath) {
         if (!this.page)
-            throw new Error('браузер не запущен');
+            throw new Error(this._t('ds.not_launched'));
         const html = await this.page.content();
         await fs.writeFile(filePath, html, 'utf-8');
         const report = await this.page.evaluate((sels) => {
@@ -1581,9 +1648,220 @@ export class DeepSeekBrowser {
             return true;
         }
         catch (e) {
-            throw new Error(`Не удалось открыть чат ${id}: ${e.message}`);
+            throw new Error(this._t('ds.open_chat_failed', { id, error: e.message }));
+        }
+    }
+    // Fetch the WHOLE dialogue from DeepSeek's own history endpoint instead of
+    // scraping the DOM. The rendered page only shows a part of the history (the
+    // list is virtualized), while /api/v0/chat/history_messages returns every
+    // message of the chat as JSON. The request is made INSIDE the page, so the
+    // auth cookie and the CSRF/PoW handling are the browser's.
+    //
+    // Shape of data.biz_data.chat_messages[]: { role: 'USER'|'ASSISTANT',
+    // fragments: [{ type: 'REQUEST'|'RESPONSE'|'THINK'|'FILE', content }] }.
+    // We keep REQUEST (user) and RESPONSE (assistant); THINK (reasoning) is
+    // skipped and FILE fragments carry no text.
+    async fetchChatMessages(id) {
+        this._lastHistoryError = '';
+        if (!this.page || !id)
+            return [];
+        // The Authorization header is sniffed off DeepSeek's own API requests. On
+        // a freshly opened chat that request may not have fired yet — wait a bit
+        // (up to 3s) so the replay is authorized instead of answering 401/empty.
+        for (let i = 0; i < 15 && !this._apiAuth; i++) {
+            await this.page.waitForTimeout(200);
+        }
+        const auth = this._apiAuth;
+        const pow = this._apiPow;
+        const res = await this.page
+            .evaluate(async (opts) => {
+            try {
+                const url = 'https://chat.deepseek.com/api/v0/chat/history_messages?chat_session_id=' +
+                    encodeURIComponent(opts.chatId);
+                const headers = {
+                    accept: 'application/json',
+                };
+                if (opts.auth)
+                    headers['authorization'] = opts.auth;
+                if (opts.pow)
+                    headers['x-ds-pow-response'] = opts.pow;
+                const resp = await fetch(url, {
+                    credentials: 'include',
+                    headers,
+                });
+                if (!resp.ok)
+                    return { error: 'HTTP ' + resp.status, list: [] };
+                const json = await resp.json();
+                const messages = json && json.data && json.data.biz_data
+                    ? json.data.biz_data.chat_messages
+                    : null;
+                if (!Array.isArray(messages)) {
+                    return { error: 'no chat_messages in response', list: [] };
+                }
+                const NL = String.fromCharCode(10);
+                const out = [];
+                for (const m of messages) {
+                    const role = m && m.role === 'ASSISTANT' ? 'assistant' : 'user';
+                    const want = role === 'assistant' ? 'RESPONSE' : 'REQUEST';
+                    let text = '';
+                    for (const fr of (m && m.fragments) || []) {
+                        if (!fr || fr.type !== want)
+                            continue;
+                        if (typeof fr.content === 'string')
+                            text += fr.content;
+                    }
+                    text = text.replace(new RegExp(NL + '{3,}', 'g'), NL + NL).trim();
+                    if (text)
+                        out.push({ role, text });
+                }
+                return { error: '', list: out };
+            }
+            catch (e) {
+                return { error: 'fetch failed: ' + e.message, list: [] };
+            }
+        }, { chatId: id, auth, pow })
+            .catch((e) => ({
+            error: 'evaluate failed: ' + e.message,
+            list: [],
+        }));
+        this._lastHistoryError = res?.error || '';
+        const list = (res?.list || []);
+        if (list.length || !res?.error)
+            return list;
+        // Fallback: Playwright's own request context (shares the browser cookies)
+        // when the in-page fetch was blocked (CSP, CORS, a page error).
+        this._lastHistoryError = res.error;
+        try {
+            const resp = await this.page.request.get('https://chat.deepseek.com/api/v0/chat/history_messages?chat_session_id=' +
+                encodeURIComponent(id), { headers: { accept: 'application/json' } });
+            if (!resp.ok())
+                return list;
+            const json = (await resp.json());
+            const messages = json?.data?.biz_data?.chat_messages;
+            if (!Array.isArray(messages))
+                return list;
+            const NL = String.fromCharCode(10);
+            const out = [];
+            for (const m of messages) {
+                const role = m && m.role === 'ASSISTANT' ? 'assistant' : 'user';
+                const want = role === 'assistant' ? 'RESPONSE' : 'REQUEST';
+                let text = '';
+                for (const fr of (m && m.fragments) || []) {
+                    if (!fr || fr.type !== want)
+                        continue;
+                    if (typeof fr.content === 'string')
+                        text += fr.content;
+                }
+                text = text.replace(new RegExp(NL + '{3,}', 'g'), NL + NL).trim();
+                if (text)
+                    out.push({ role, text });
+            }
+            this._lastHistoryError = '';
+            return out;
+        }
+        catch (e) {
+            this._lastHistoryError = 'request failed: ' + e.message;
+            return list;
         }
     }
+    // Read the WHOLE visible dialogue of the currently open chat, top to
+    // 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: DeepSeek renders every message as a markdown
+    // block (assistant) or a plain bubble (user). Role detection relies on the
+    // ds-assistant-message-* class; anything that is not an assistant block is
+    // treated as a user message. The model's reasoning (.ds-think-content) is
+    // skipped, exactly like in _readLastAnswerText.
+    async readChatMessages() {
+        if (!this.page)
+            return [];
+        const raw = await this.page
+            .evaluate(() => {
+            const inThink = (e) => {
+                let n = e;
+                while (n) {
+                    const cls = (n.className || '').toString();
+                    if (/ds-think-content|thinking-content/i.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();
+            };
+            // A message block is "assistant" when it contains an answer markdown
+            // wrapper (ds-markdown / ds-assistant-message), otherwise it is a
+            // user bubble. DeepSeek's class names drift between builds, so the
+            // detection is content-based, not class-prefix-based.
+            const looksAssistant = (e) => {
+                const cls = (e.className || '').toString();
+                if (/ds-assistant-message|assistant-message/i.test(cls))
+                    return true;
+                if (e.querySelector('[class*="ds-assistant-message"]'))
+                    return true;
+                // A user bubble has no rendered markdown; an answer does.
+                if (e.querySelector('[class*="ds-markdown"]'))
+                    return true;
+                return false;
+            };
+            // Message-level containers first (broad), then the answer wrappers.
+            const containerSels = [
+                '[data-message-id]',
+                '[class*="ds-message"]',
+                '[class*="chat-message"]',
+                '[class*="message-item"]',
+                '[class*="_message"]',
+            ];
+            let blocks = [];
+            for (const s of containerSels) {
+                const found = Array.from(document.querySelectorAll(s)).filter((e) => !inThink(e) && textOf(e).length > 0);
+                if (found.length) {
+                    blocks = found;
+                    break;
+                }
+            }
+            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;
+            }
+            // Last resort: assistant answers only (no user turns) — better than
+            // nothing when no message container matched.
+            const sels = [
+                'div.ds-assistant-message-main-content',
+                'div[class*="ds-assistant-message-main-content"]',
+                'div[class*="ds-markdown"]',
+            ];
+            for (const s of sels) {
+                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;
+        })
+            .catch(() => []);
+        return raw;
+    }
     async getCurrentChatId() {
         try {
             const url = this.page.url();

package/dist/commands.js

@@ -186,6 +186,78 @@ export function resolveExtraDir(input, workdir) {
     }
     return { path: abs };
 }
+/** How many characters of the dialogue are printed by default. */
+export const RESTORED_HISTORY_LIMIT = 20;
+/**
+ * Is this message worth showing to the operator as part of the dialogue?
+ *
+ * The chat history contains a lot of protocol noise that is meaningless in
+ * the terminal: the system-prompt (a huge REQUEST), tool results
+ * ("Tool result for ..."), the agent's raw tool-calls (JSON / DSML), the
+ * "You stopped after a tool result..." nudges, and the agent's <system> notes.
+ * We keep only real user turns and real assistant answers.
+ */
+export function isDisplayableMessage(m) {
+    const text = String((m && m.text) || '').trim();
+    if (!text)
+        return false;
+    if (text.length > 100_000)
+        return false; // the system-prompt / a giant blob
+    if (m.role === 'user') {
+        // Tool output, the system-prompt and the corrective nudges are not the
+        // operator's words.
+        if (/^Tool result for /.test(text))
+            return false;
+        if (/^You are a coding agent running in a terminal/.test(text))
+            return false;
+        if (/^You stopped after a tool result/.test(text))
+            return false;
+        if (/^\[system\]/.test(text))
+            return false;
+        if (/^The user ran \//.test(text))
+            return false;
+        return true;
+    }
+    // Assistant: a tool-call (JSON or DSML) is not an answer to show. The
+    // DSML markers use FULL-WIDTH vertical bars (｜｜DSML), so the regex must
+    // match them, not the ASCII pipe.
+    if (/DSML/i.test(text))
+        return false;
+    if (/^<system>/i.test(text))
+        return false;
+    if (/"tool"\s*:/.test(text.slice(0, 600))) {
+        return false;
+    }
+    if (/^\s*[\[{]/.test(text) && /"args"\s*:/.test(text.slice(0, 600))) {
+        return false;
+    }
+    return true;
+}
+/**
+ * Keep only the last `limit` messages and drop empties/service noise. The
+ * source (network history or DOM) may contain protocol messages; they are
+ * filtered out here so the terminal output stays readable.
+ */
+export function trimRestoredMessages(messages, limit = RESTORED_HISTORY_LIMIT) {
+    const clean = (messages || []).filter((m) => m && typeof m.text === 'string' && isDisplayableMessage(m));
+    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);
+}
 // ---------- /review ----------
 export function buildReviewPrompt(focus, hasStaged = false) {
     const scope = hasStaged ? 'staged' : 'uncommitted';

package/dist/i18n.js

@@ -209,6 +209,83 @@ const CATALOG = {
     'msg.reload_error': { ru: 'Ошибка reload:', en: 'Reload error:' },
     'msg.abort_gen_short': { ru: '⏹ Esc — прерываю генерацию...', en: '⏹ Esc — aborting generation...' },
     'msg.abort_ctrlc_short': { ru: '⏹ Ctrl+C — прерываю генерацию...', en: '⏹ Ctrl+C — aborting generation...' },
+    // ---------- DeepSeek-side problems (what is happening right now) ----------
+    // The operator must understand WHY the agent is waiting or stopped: a rate
+    // limit, a server hiccup, a refused send, a login problem. These strings are
+    // printed around the moment they happen (browser.ts / agent-loop.ts), not as
+    // a bare error at the end of the run.
+    'ds.rate_limit_wait': {
+        ru: '⏳ DeepSeek: «слишком часто». Жду {min} мин ({attempt}/{max}) и повторю отправку...',
+        en: '⏳ DeepSeek: "too frequent". Waiting {min} min ({attempt}/{max}), then resending...',
+    },
+    'ds.rate_limit_give_up': {
+        ru: '✖ DeepSeek не принял сообщение после {attempt} пауз по {min} мин. Подожди и попробуй снова.',
+        en: '✖ DeepSeek refused the message after {attempt} waits of {min} min. Wait and try again.',
+    },
+    'ds.server_busy_wait': {
+        ru: '⏳ DeepSeek: сервер занят. Жду {sec}с ({attempt}/{max}) и повторю...',
+        en: '⏳ DeepSeek: server busy. Waiting {sec}s ({attempt}/{max}), then retrying...',
+    },
+    'ds.server_busy_give_up': {
+        ru: '✖ DeepSeek: сервер не ответил после {attempt} повторов. Попробуй позже.',
+        en: '✖ DeepSeek: the server did not respond after {attempt} retries. Try again later.',
+    },
+    'ds.ask_retry': {
+        ru: '⚠ Ответ не получен ({attempt}/{max}): {error} — повторяю...',
+        en: '⚠ No answer yet ({attempt}/{max}): {error} — retrying...',
+    },
+    'ds.ask_restart_browser': {
+        ru: '⚠ Браузер потерял страницу — перезапускаю и вхожу заново...',
+        en: '⚠ The browser lost the page — restarting and signing in again...',
+    },
+    'ds.ask_restart_failed': {
+        ru: '⚠ Не удалось перезапустить браузер: {error}',
+        en: '⚠ Could not restart the browser: {error}',
+    },
+    'ds.ask_failed': {
+        ru: '✖ Не удалось получить ответ от DeepSeek после {max} попыток: {error}',
+        en: '✖ Could not get an answer from DeepSeek after {max} attempts: {error}',
+    },
+    'ds.input_missing': {
+        ru: '✖ Не найдено поле ввода на странице DeepSeek. Запусти /debug-dom и поправь INPUT_SELECTORS.',
+        en: '✖ The DeepSeek input field was not found. Run /debug-dom and fix INPUT_SELECTORS.',
+    },
+    'ds.input_partial': {
+        ru: '✖ Не удалось вставить текст в поле ввода целиком ({got} из {want} символов). Сообщение не отправлено, чтобы не отправить обрезанный текст. Попробуй ещё раз или разбей сообщение.',
+        en: '✖ Could not paste the whole text into the input ({got} of {want} chars). The message was not sent to avoid sending a truncated text. Retry or split the message.',
+    },
+    'ds.send_no_start': {
+        ru: '✖ Ответ не начал генерироваться за 35с даже после повторной отправки. Проверь чат DeepSeek вручную (возможно, кнопка отправки не нажимается или сессия разлогинилась).',
+        en: '✖ The answer did not start generating within 35s even after resending. Check the DeepSeek chat manually (the send button may not be clickable or the session may have expired).',
+    },
+    'ds.send_no_new_answer': {
+        ru: '✖ Новый ответ не получен — на странице остался прежний текст. Возможно, сообщение не отправилось. Проверь чат DeepSeek вручную.',
+        en: '✖ No new answer received — the page still shows the previous text. The message may not have been sent. Check the DeepSeek chat manually.',
+    },
+    'ds.answer_timeout': {
+        ru: '⏳ DeepSeek не ответил за {sec}с — повторяю запрос...',
+        en: '⏳ DeepSeek did not answer within {sec}s — retrying the request...',
+    },
+    'ds.answer_timeout_give_up': {
+        ru: '✖ DeepSeek перестал отвечать, лимит повторов исчерпан. Модель не дала ответа — проверь чат DeepSeek вручную.',
+        en: '✖ DeepSeek stopped responding, retry limit exhausted. The model gave no answer — check the DeepSeek chat manually.',
+    },
+    'ds.tool_retry': {
+        ru: '⏳ Агент не распознал ответ модели — прошу продолжить ({attempt}/{max})...',
+        en: '⏳ The agent did not recognize the model answer — asking it to continue ({attempt}/{max})...',
+    },
+    'ds.stalled': {
+        ru: '⚠ Агент остановился, не завершив задачу (модель перестала вызывать инструменты). Проверь чат DeepSeek — задача может быть не выполнена.',
+        en: '⚠ The agent stopped before finishing (the model stopped calling tools). Check the DeepSeek chat — the task may be incomplete.',
+    },
+    'ds.not_launched': {
+        ru: '✖ Браузер не запущен.',
+        en: '✖ The browser is not launched.',
+    },
+    'ds.open_chat_failed': {
+        ru: '✖ Не удалось открыть чат {id}: {error}',
+        en: '✖ Could not open chat {id}: {error}',
+    },
     // ---------- self-review ----------
     'self.review_failed': { ru: 'Самообзор провалился:', en: 'Self-review failed:' },
     'self.fix_usage': { ru: 'Использование: /self-fix <name> [фокус]', en: 'Usage: /self-fix <name> [focus]' },
@@ -238,6 +315,12 @@ const CATALOG = {
     'chats.prompt_will_resend': { ru: ' Системный промпт будет переслан на следующей задаче.\n', en: ' System prompt will be resent on the next task.\n' },
     'chats.current_id': { ru: 'Текущий chat id: {v}', en: 'Current chat id: {v}' },
     'chats.not_created': { ru: 'Чат ещё не создан.', en: 'No chat created yet.' },
+    'chats.history_title': { ru: 'Диалог чата:', en: 'Chat dialogue:' },
+    'chats.history_empty': { ru: 'Диалог пуст или не удалось прочитать сообщения.', en: 'The dialogue is empty or the messages could not be read.' },
+    'chats.history_service_only': { ru: 'В этом чате нет пользовательских реплик — только служебные сообщения агента (вызовы инструментов).', en: 'This chat has no user turns — only the agent service messages (tool calls).' },
+    'chats.history_truncated': { ru: '… показаны последние {n} сообщений.', en: '… showing the last {n} messages.' },
+    'chats.history_you': { ru: 'Вы', en: 'You' },
+    'chats.history_agent': { ru: 'Агент', en: 'Agent' },
     'sessions.dir': { ru: 'Папка сессий: {v}', en: 'Sessions dir: {v}' },
     'sessions.none': { ru: 'Сохранённых сессий нет. Они появятся после первой задачи/чата.', en: 'No saved sessions. They appear after the first task/chat.' },
     'sessions.restore_hint': { ru: 'Восстановить: /resume-id <id>  (полный id) или /resume <n> после /chats.', en: 'Restore: /resume-id <id> (full id) or /resume <n> after /chats.' },

package/dist/index.js

@@ -16,10 +16,12 @@ import { translate, normalizeLocale, localeDisplayName, isLocale, } from './i18n
 import { Transcript } from './transcript.js';
 import { UndoStore } from './undo.js';
 import { selfReview, selfDiff, selfApply, selfList } from './self-review.js';
-import { formatDiff, diffGitArgs, parseTranscript, summarizeTranscript, renderCost, formatExport, defaultExportPath, renderDoctor, renderPermissions, resolveExtraDir, buildReviewPrompt, } from './commands.js';
+import { formatDiff, diffGitArgs, parseTranscript, summarizeTranscript, renderCost, formatExport, defaultExportPath, renderDoctor, renderPermissions, resolveExtraDir, buildReviewPrompt, trimRestoredMessages, RESTORED_HISTORY_LIMIT, } from './commands.js';
+import { renderMarkdown } from './markdown.js';
 import { closeWeb } from './web.js';
 import { saveSession, loadLastSession, listSessions, sessionsDir, } from './sessions.js';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const NL = String.fromCharCode(10);
 // True when a DeepSeek session/credentials were stored earlier (auth.json).
 // Used by /doctor to report that auto re-login is ready.
 function authMarkerExists() {
@@ -788,6 +790,68 @@ async function resolveWorkdir() {
     }
     return dir;
 }
+// ---------- restored dialogue ----------
+/**
+ * Print the dialogue of the just-opened chat into the terminal. Called by
+ * /resume, /resume-id and on startup when a previous session is restored, so
+ * the operator sees the context instead of a bare "Chat opened.".
+ *
+ * Best-effort: a DOM-scraping failure must never break the restore.
+ */
+async function printRestoredHistory(browser, ui, chatId = null) {
+    // Prefer DeepSeek's own history endpoint (complete, unvirtualized); fall
+    // back to scraping the rendered DOM when the request fails.
+    let all = [];
+    let fetchCount = -1;
+    let domCount = -1;
+    if (chatId && browser.fetchChatMessages) {
+        all = await browser.fetchChatMessages(chatId).catch(() => []);
+        fetchCount = all.length;
+    }
+    if (!all.length && browser.readChatMessages) {
+        all = await browser.readChatMessages().catch(() => []);
+        domCount = all.length;
+    }
+    const messages = 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?).
+    if (!all.length || (debug && !messages.length)) {
+        console.log(theme.dim(`[history] chat=${chatId || '-'} fetch=${fetchCount} dom=${domCount} raw=${all.length} shown=${messages.length} auth=${browser._apiAuth ? 'yes' : 'no'} err=${browser._lastHistoryError || '-'}`));
+    }
+    if (!all.length) {
+        console.log(theme.system(t('chats.history_empty')));
+        return;
+    }
+    if (!messages.length) {
+        // The history exists but contains only service/protocol messages (e.g.
+        // a chat where only the system-prompt and tool-calls were stored).
+        console.log(theme.system(t('chats.history_service_only', { n: String(all.length) })));
+        return;
+    }
+    const out = (text) => {
+        if (ui)
+            ui.printAbove(text);
+        else
+            console.log(text);
+    };
+    out(theme.system(t('chats.history_title')));
+    for (const m of messages) {
+        if (m.role === 'user') {
+            out(theme.user('❯ ' + t('chats.history_you') + ': ') + m.text.trim());
+        }
+        else {
+            out(NL +
+                theme.assistant('● ' + t('chats.history_agent') + ':') +
+                NL +
+                renderMarkdown(m.text.trim()) +
+                NL);
+        }
+    }
+    if (all.length > messages.length) {
+        out(theme.dim(t('chats.history_truncated', { n: String(RESTORED_HISTORY_LIMIT) })));
+    }
+}
 // ---------- task runner ----------
 async function runTask(browser, tools, taskText, workdir, opts, attachments = []) {
     const { transcript, freshChat, sendSystemPrompt, queue = [], ui: editor, onChatReady, } = opts;
@@ -1091,6 +1155,7 @@ async function main() {
             sendSystemPromptNext = resendPrompt;
             saveLastChat(resumeId, currentWorkdir);
             console.log(theme.system(t('msg.chat_opened') + ' ' + resumeId + String.fromCharCode(10)));
+            await printRestoredHistory(browser, null, resumeId);
         }
         catch (e) {
             console.error(theme.error(t('msg.open_chat_error', { v: e.message })));
@@ -1774,6 +1839,7 @@ async function main() {
                     theme.system(resendPrompt
                         ? ' Системный промпт будет переслан на следующей задаче.\n'
                         : ' Контекст чата сохранён. Системный промпт не пересылается (--resend-prompt чтобы дослать).\n'));
+                await printRestoredHistory(browser, editor, pick.id);
             }
             catch (e) {
                 console.error(theme.error(t('msg.open_chat_error', { v: '' })), e.message);
@@ -1831,6 +1897,7 @@ async function main() {
                 transcript.log('resume_chat', { id });
                 console.log(theme.assistant('Чат открыт.') +
                     theme.system(String.fromCharCode(10)));
+                await printRestoredHistory(browser, editor, id);
             }
             catch (e) {
                 console.error(theme.error(t('msg.open_chat_error', { v: '' })), e.message);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zames_pro",
-  "version": "2.17.0",
+  "version": "2.18.0",
   "description": "Terminal coding agent over chat.deepseek.com via Playwright",
   "type": "module",
   "bin": {
@@ -15,7 +15,7 @@
   ],
   "scripts": {
     "start": "node ./dist/index.js",
-    "dev": "tsx ./src/index.ts --dev",
+    "dev": "ZAMES_NET_DEBUG=1 tsx ./src/index.ts --dev",
     "build": "tsc -p tsconfig.build.json",
     "typecheck": "tsc --noEmit",
     "prepublishOnly": "npm run build",