zames_pro 2.17.0 → 2.19.0

package/README.md

@@ -138,8 +138,8 @@ config commands (/new, /chats, /resume, /cd, /status, /config,
 Codex CLI:
 
 - /diff [--staged] — show the working-tree git diff (--staged for the index).
-- /cost (alias /usage) — session stats: tasks, tool calls, duration
- (DeepSeek web does not expose token counts).
+- /cost (alias /usage) — session stats: tasks, tool calls, duration, and the
+ context size in tokens (DeepSeek's `accumulated_token_usage`).
 - /export [file] — write the session transcript to a Markdown file
  (zames-export-<stamp>.md by default).
 - /doctor — diagnose node, git, config, browser, clipboard and MCP.
@@ -147,8 +147,19 @@ 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).
+- /compact — ask DeepSeek to compress the current chat into a handover
+ summary, then open a NEW chat, resend the system prompt and post the summary
+ as the carried-over context. Use it when the context gets long.
+
+The token context is also shown live: the status line above the input has the
+spinner/text on the left and the context on the right (e.g. `125k · 13%`,
+percent of a 1M context). It comes from DeepSeek's `accumulated_token_usage`
+and is hidden until the first answer delivers it.
 
 
 ## Project context, skills and memory

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

@@ -1,5 +1,5 @@
 import { chromium, } from 'playwright';
-import { extractAnswer, dumpNetBody } from './net-capture.js';
+import { extractAnswer, extractTokenUsage, dumpNetBody } from './net-capture.js';
 import path from 'path';
 import os from 'os';
 import fs from 'fs/promises';
@@ -277,6 +277,18 @@ export class DeepSeekBrowser {
     _netCapture;
     _netCaptureAt;
     _netChatId;
+    // The latest CONTEXT size (in tokens) DeepSeek reported in the current
+    // chat. It is the `accumulated_token_usage` counter taken from the SSE
+    // completion stream and from /api/v0/chat/history_messages. Null until the
+    // first answer (or history fetch) delivers it. Shown by /cost and /status.
+    _lastTokenUsage;
+    // 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 +333,10 @@ export class DeepSeekBrowser {
         this._netCapture = '';
         this._netCaptureAt = 0;
         this._netChatId = null;
+        this._lastTokenUsage = null;
+        this._apiAuth = '';
+        this._apiPow = '';
+        this._lastHistoryError = '';
         this._netSniff = [];
         this._netSniffLimit = 5;
         this._netHookInstalled = false;
@@ -424,6 +440,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 {
@@ -445,6 +478,12 @@ export class DeepSeekBrowser {
             if (this._netSniff.length > this._netSniffLimit)
                 this._netSniff.shift();
             void dumpNetBody(url, body);
+            // Context size (tokens) reported by DeepSeek for this answer. Kept
+            // even when extractAnswer() returns nothing (a history_messages
+            // response carries the counter but no answer text).
+            const usage = extractTokenUsage(body);
+            if (usage !== null)
+                this._lastTokenUsage = usage;
             const extracted = extractAnswer(body);
             if (extracted) {
                 this._netCapture = extracted;
@@ -829,6 +868,20 @@ export class DeepSeekBrowser {
         if (this._netCapture && this._netCaptureAt >= this._lastSentAt) {
             return this._netCapture;
         }
+        return await this._readLastAnswerTextDom();
+    }
+    // The answer as rendered on the page, ALWAYS from the DOM (never from the
+    // network capture). This is what the "has a new answer started?" checks
+    // must compare against `beforeText`.
+    //
+    // Why a separate reader: `_readLastAnswerText()` prefers `_netCapture` when
+    // it is fresh. `beforeText` was taken through it, so after a send the
+    // network capture (the SAME text) made `cur` equal to `beforeText` — the
+    // "changed" signal never fired and ask() ended with "no new answer" and
+    // retried for minutes, while the operator saw the agent "stop after a tool
+    // call". The DOM reader has no such self-comparison problem: before the
+    // send the DOM shows the OLD answer, after it the NEW one.
+    async _readLastAnswerTextDom() {
         return await this.page.evaluate((sels) => {
             // DeepSeek stores the model's reasoning in .ds-think-content blocks.
             // They are NOT the answer and must never be picked up as the answer
@@ -895,6 +948,19 @@ export class DeepSeekBrowser {
     }
     async _readLastAnswerTextClean() {
         const raw = await this._readLastAnswerText().catch(() => '');
+        return this._cleanAnswer(raw);
+    }
+    // The same "clean" filter as _readLastAnswerTextClean, but read from the
+    // DOM only. Used by _askOnce for the before/after comparison: the network
+    // capture must not be compared against itself (see _readLastAnswerTextDom).
+    async _readLastAnswerTextCleanDom() {
+        const raw = await this._readLastAnswerTextDom().catch(() => '');
+        return this._cleanAnswer(raw);
+    }
+    // Drop service placeholders ("Reading…", "Thinking…") so they are not
+    // mistaken for an answer; keep everything else as-is (including whitespace
+    // the tool-call relies on).
+    _cleanAnswer(raw) {
         const t = (raw || '').trim();
         if (!t)
             return '';
@@ -1017,10 +1083,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 +1101,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 +1146,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 +1205,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,9 +1358,14 @@ export class DeepSeekBrowser {
             return '(прервано пользователем)';
         const input = await this._findVisible(INPUT_SELECTORS, 10_000);
         if (!input) {
-            throw new Error('Не найдено поле ввода. Запустите /debug-dom и поправьте INPUT_SELECTORS.');
-        }
-        const beforeText = await this._readLastAnswerTextClean().catch(() => '');
+            throw new Error(this._t('ds.input_missing'));
+        }
+        // `beforeText` MUST come from the DOM, not from _readLastAnswerText():
+        // that reader prefers the network capture, so comparing `cur` (also the
+        // capture) against `beforeText` compared the capture against itself and
+        // the "new answer" check never fired — the source of the
+        // ds.send_no_new_answer flapping.
+        const beforeText = await this._readLastAnswerTextCleanDom().catch(() => '');
         this._askDebug('SEND agent=' + agent + ' len=' + prompt.length + ' beforeLen=' + beforeText.length + ' beforeHead=' + JSON.stringify(beforeText.slice(0, 60)));
         await this._waitForSendSlot(agent);
         // Esc/Ctrl+C pressed during the pause — do not send anything.
@@ -1326,7 +1439,7 @@ export class DeepSeekBrowser {
             if (isServerBusyText(pageText)) {
                 throw new ServerBusyError(pageText.slice(0, 300));
             }
-            const cur = await this._readLastAnswerTextClean().catch(() => '');
+            const cur = await this._readLastAnswerTextCleanDom().catch(() => '');
             const bodyLen = await this.page
                 .evaluate(() => document.body.innerText.length)
                 .catch(() => 0);
@@ -1375,7 +1488,7 @@ export class DeepSeekBrowser {
             // (otherwise it is the old answer on screen) or a fresh network capture
             // proves a new answer. Returning an equal text made the loop re-run the
             // previous tool call.
-            const cur = await this._readLastAnswerTextClean().catch(() => '');
+            const cur = await this._readLastAnswerTextCleanDom().catch(() => '');
             const fresh = !!this._netCapture && this._netCaptureAt >= this._lastSentAt;
             if (cur && cur.trim() && normText(cur) !== normText(beforeText) && !(await this._isGenerating())) {
                 return cur;
@@ -1395,7 +1508,7 @@ export class DeepSeekBrowser {
             while (Date.now() < retryDeadline) {
                 if (this._abort)
                     return '(прервано пользователем)';
-                const cur2 = await this._readLastAnswerTextClean().catch(() => '');
+                const cur2 = await this._readLastAnswerTextCleanDom().catch(() => '');
                 const net2 = !!this._netCapture && this._netCaptureAt >= this._lastSentAt;
                 const grew2 = (await this.page
                     .evaluate(() => document.body.innerText.length)
@@ -1411,8 +1524,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().
@@ -1438,7 +1550,7 @@ export class DeepSeekBrowser {
                 }
             }
             const netFresh = !!this._netCapture && this._netCaptureAt >= this._lastSentAt;
-            const cur = await this._readLastAnswerTextClean().catch(() => '');
+            const cur = await this._readLastAnswerTextCleanDom().catch(() => '');
             // Ignore an "answer" that is identical to what was on the page BEFORE we
             // sent the message: that is the previous answer, not a new one. Returning
             // it would make the agent re-process the old tool call (or silently
@@ -1482,12 +1594,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 +1692,234 @@ 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 = [];
+                // The context size: the LATEST accumulated_token_usage in the chat
+                // (each message carries the running counter).
+                let usage = null;
+                for (const m of messages) {
+                    if (m && typeof m.accumulated_token_usage === 'number') {
+                        usage = m.accumulated_token_usage;
+                    }
+                    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, usage };
+            }
+            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 || '';
+        // Pick up the context size the history carries, so /resume (and /cost
+        // right after it) shows a real number even before the first answer.
+        const usage = res?.usage;
+        if (typeof usage === 'number')
+            this._lastTokenUsage = usage;
+        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) {
+                if (m && typeof m.accumulated_token_usage === 'number') {
+                    this._lastTokenUsage = m.accumulated_token_usage;
+                }
+                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();
@@ -1596,6 +1932,11 @@ export class DeepSeekBrowser {
             return this._netChatId;
         }
     }
+    // The latest context size (in tokens) DeepSeek reported for the current
+    // chat, or null when nothing has been seen yet. Used by /cost and /status.
+    getLastTokenUsage() {
+        return this._lastTokenUsage;
+    }
     async close() {
         try {
             if (this.context)

package/dist/commands.js

@@ -77,9 +77,15 @@ export function formatDuration(ms) {
         return m + 'm ' + pad(s) + 's';
     return s + 's';
 }
-export function renderCost(stats, transcriptFile) {
+export function renderCost(stats, transcriptFile, tokenUsage = null) {
     const lines = [];
-    lines.push('Session stats (DeepSeek web does not expose token counts):');
+    lines.push('Session stats:');
+    if (typeof tokenUsage === 'number') {
+        lines.push(' context: ~' + tokenUsage + ' tokens (DeepSeek accumulated_token_usage)');
+    }
+    else {
+        lines.push(' context: unknown (DeepSeek reports it after the first answer in a chat)');
+    }
     lines.push(' tasks: ' + stats.turns);
     lines.push(' tool calls: ' + stats.toolCalls);
     const top = Object.entries(stats.toolCounts).sort((a, b) => b[1] - a[1]);
@@ -186,6 +192,123 @@ 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);
+}
+// ---------- /compact ----------
+/**
+ * The prompt that asks the model to compress the current chat into a handover
+ * summary. It is sent to the OLD chat before a new one is opened; the answer
+ * (the summary) is then carried over as the context of the new chat.
+ *
+ * The summary must be self-sufficient: the new chat sees ONLY this text (plus
+ * the system prompt), so the model is told to keep facts, decisions, file
+ * paths, commands and the exact current state of the work.
+ */
+export function buildCompactPrompt(locale = 'ru') {
+    if (locale === 'en') {
+        return ('Compact the conversation so far into a handover summary for a NEW chat. ' +
+            'This summary is the ONLY context the new chat will start with, so it must be self-sufficient. ' +
+            'Include: (1) the user goal and constraints; (2) what has been done so far; ' +
+            '(3) the exact current state (files changed, commands run, their results); ' +
+            '(4) open questions and the next concrete steps. ' +
+            'Keep file paths, function/identifier names, commands and error texts verbatim. ' +
+            'Be concise but complete — no small talk, no code dumps beyond short essential snippets.');
+    }
+    return ('Сожми историю диалога в краткое резюме для НОВОГО чата. ' +
+        'Это резюме будет ЕДИНСТВЕННЫМ контекстом, с которым новый чат начнёт работу, поэтому оно должно быть самодостаточным. ' +
+        'Включи: (1) цель пользователя и ограничения; (2) что уже сделано; ' +
+        '(3) точное текущее состояние (изменённые файлы, выполненные команды и их результаты); ' +
+        '(4) открытые вопросы и следующие конкретные шаги. ' +
+        'Пути к файлам, имена функций/идентификаторов, команды и тексты ошибок сохраняй дословно. ' +
+        'Пиши кратко, но полно — без воды и без больших дампов кода (только короткие важные фрагменты).');
+}
+/**
+ * Wrap the model's summary into the text posted as the first message of the
+ * NEW chat. The system prompt is sent separately (sendSystemPrompt), so here
+ * we only mark the block as a carried-over context and add the operator's
+ * original goal so the model does not lose it.
+ */
+export function buildCompactCarryover(summary, task) {
+    const body = String(summary ?? '').trim();
+    const goal = String(task ?? '').trim();
+    let out = 'Context carried over from a previous chat (compacted). ' +
+        'Treat it as the history of our work so far and continue from the current state.';
+    out += NL + NL + body;
+    if (goal) {
+        out += NL + NL + 'Original task: ' + goal;
+    }
+    return out;
+}
 // ---------- /review ----------
 export function buildReviewPrompt(focus, hasStaged = false) {
     const scope = hasStaged ? 'staged' : 'uncommitted';

package/dist/i18n.js

@@ -86,6 +86,13 @@ const CATALOG = {
     'help.cmd.permissions': { ru: '/permissions настройки подтверждений', en: '/permissions confirmation settings' },
     'help.cmd.add_dir': { ru: '/add-dir <path> проверить директорию', en: '/add-dir <path> validate a directory' },
     'help.cmd.review': { ru: '/review [focus] ревью незакоммиченных изменений', en: '/review [focus] review uncommitted changes' },
+    'help.cmd.compact': { ru: '/compact сжать историю и открыть новый чат с резюме', en: '/compact compact the history and open a new chat with the summary' },
+    'compact.start': { ru: '🗜️ Сжимаю историю чата (DeepSeek)...', en: '🗜️ Compacting the chat history (DeepSeek)...' },
+    'compact.empty': { ru: 'Нечего сжимать: в чате ещё нет ответов.', en: 'Nothing to compact: the chat has no answers yet.' },
+    'compact.summary_failed': { ru: 'Не удалось получить резюме от модели: {v}', en: 'Could not get the summary from the model: {v}' },
+    'compact.done': { ru: '✅ История сжата, открыт новый чат с резюме.', en: '✅ History compacted, a new chat with the summary is open.' },
+    'compact.report': { ru: 'Резюме перенесено в новый чат ({chars} символов, токенов было ~{tokens}).', en: 'The summary was carried into the new chat ({chars} chars, ~{tokens} tokens before).' },
+    'compact.no_chat': { ru: 'Чат ещё не создан — сжимать нечего.', en: 'No chat created yet — nothing to compact.' },
     'diff.not_repo': { ru: 'Не git-репозиторий.', en: 'Not a git repository.' },
     'export.done': { ru: 'Сессия выгружена: {v}', en: 'Session exported: {v}' },
     'export.outside': { ru: 'Путь вне рабочей директории.', en: 'Path is outside the working directory.' },
@@ -209,6 +216,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 +322,13 @@ 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_tokens': { ru: 'Контекст чата: ~{v} токенов', en: 'Chat context: ~{v} tokens' },
+    '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.' },
@@ -272,6 +363,10 @@ const CATALOG = {
     'mcp.title': { ru: 'MCP-серверы (инструментов: {n}):', en: 'MCP servers ({n} tools):' },
     'mcp.status_error': { ru: '(ошибка: {v})', en: '(error: {v})' },
     'status.mcp': { ru: 'MCP-инструменты: {v}', en: 'MCP tools: {v}' },
+    'status.tokens': {
+        ru: 'Контекст (токенов): {v}',
+        en: 'Context (tokens): {v}',
+    },
     // ---------- config menu ----------
     'cfg.group.ui': { ru: 'Интерфейс', en: 'Interface' },
     'cfg.group.agent': { ru: 'Агент', en: 'Agent' },

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, buildCompactPrompt, buildCompactCarryover, } 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() {
@@ -242,6 +244,7 @@ ${theme.bold(t('help.commands'))}
  ${t('help.cmd.permissions')}
  ${t('help.cmd.add_dir')}
  ${t('help.cmd.review')}
+ ${t('help.cmd.compact')}
   ${t('help.cmd.config')}
   ${t('help.cmd.lang')}
   ${t('help.cmd.debug_dom')}
@@ -297,6 +300,7 @@ const SLASH_COMMANDS = [
     { name: '/permissions', key: 'help.cmd.permissions' },
     { name: '/add-dir', key: 'help.cmd.add_dir' },
     { name: '/review', key: 'help.cmd.review' },
+    { name: '/compact', key: 'help.cmd.compact' },
     { name: '/config', key: 'help.cmd.config' },
     { name: '/skills', key: 'help.cmd.skills' },
     { name: '/memory', key: 'help.cmd.memory' },
@@ -788,6 +792,72 @@ 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')));
+    const restoredTokens = browser.getLastTokenUsage();
+    if (typeof restoredTokens === 'number') {
+        out(theme.dim(t('chats.history_tokens', { v: String(restoredTokens) })));
+    }
+    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 +1161,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 })));
@@ -1130,6 +1201,10 @@ async function main() {
         });
         editor = ed;
         ed.setTmpDir(TMP_DIR);
+        // The token context right-aligned on the status line (above the input).
+        // The editor pulls the number on every render, so it follows the live
+        // DeepSeek counter (accumulated_token_usage) without a polling timer.
+        ed.onContextQuery = () => browser.getLastTokenUsage();
         ed.onAttach = async (raw) => {
             // Case 1: the paste is the image data itself (data URL / base64 blob).
             const image = parseImagePaste(raw);
@@ -1774,6 +1849,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 +1907,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);
@@ -2040,6 +2117,10 @@ async function main() {
             console.log(theme.system(t('status.mcp', {
                 v: mcpPool ? String(mcpPool.status().toolCount) : t('common.none'),
             })));
+            const tokens = browser.getLastTokenUsage();
+            console.log(theme.system(t('status.tokens', {
+                v: tokens === null ? t('common.unknown') : String(tokens),
+            })));
             continue;
         }
         if (lower === '/config' || lower.startsWith('/config ')) {
@@ -2073,7 +2154,7 @@ async function main() {
                     // best-effort
                 }
             }
-            console.log(theme.system(renderCost(stats, transcript.file)));
+            console.log(theme.system(renderCost(stats, transcript.file, browser.getLastTokenUsage())));
             continue;
         }
         if (lower === '/export' || lower.startsWith('/export ')) {
@@ -2167,6 +2248,91 @@ async function main() {
             console.log(theme.system(t('adddir.note', { v: res.path })));
             continue;
         }
+        if (lower === '/compact') {
+            // Compaction: ask DeepSeek (in the CURRENT chat) to compress the
+            // history into a handover summary, then start a NEW chat, resend the
+            // system prompt and post the summary as the carried-over context.
+            // This keeps the model working with a small context while nothing is
+            // lost: the summary plus the system prompt are all the new chat needs.
+            if (!currentChatId) {
+                currentChatId = await browser.getCurrentChatId();
+            }
+            if (!currentChatId) {
+                console.error(theme.warn(t('compact.no_chat')));
+                continue;
+            }
+            const beforeTokens = browser.getLastTokenUsage();
+            if (editor)
+                editor.lock(t('msg.input_locked'));
+            try {
+                console.log(theme.system(t('compact.start')));
+                // 1) Ask the OLD chat to summarize itself. agent: true - this is a
+                // real back-and-forth, so the send throttle applies.
+                let summary = '';
+                try {
+                    summary = await browser.ask(buildCompactPrompt(currentLocale), {
+                        agent: true,
+                        timeout: Math.max(60_000, config.browser.answerTimeoutMs),
+                    });
+                }
+                catch (e) {
+                    console.error(theme.error(t('compact.summary_failed', { v: e.message })));
+                    continue;
+                }
+                summary = String(summary || '').trim();
+                // A model "answer" that is actually an error/abort sentinel is not a
+                // summary - do not carry it over.
+                if (!summary || /^\(прервано пользователем\)$/.test(summary)) {
+                    console.error(theme.error(t('compact.summary_failed', { v: summary || t('common.unknown') })));
+                    continue;
+                }
+                transcript.log('compact_summary', {
+                    chars: summary.length,
+                    beforeTokens,
+                });
+                // 2) New chat + system prompt + the summary as the first message.
+                await browser.newChat();
+                await browser.ask(mod.buildSystemPrompt({
+                    workdir: currentWorkdir,
+                    tools: mod.createTools(currentWorkdir, { undo }),
+                    locale: currentLocale,
+                }), { timeout: 60_000, agent: false });
+                await browser.ask(buildCompactCarryover(summary, task ?? undefined), {
+                    timeout: 60_000,
+                    agent: false,
+                });
+                currentChatId = await browser.getCurrentChatId();
+                saveLastChat(currentChatId, currentWorkdir);
+                freshChatNext = false;
+                // The new chat already carries the system prompt and the context.
+                sendSystemPromptNext = false;
+                console.log(theme.assistant(t('compact.done') +
+                    String.fromCharCode(10) +
+                    t('compact.report', {
+                        chars: summary.length,
+                        tokens: beforeTokens === null
+                            ? t('common.unknown')
+                            : String(beforeTokens),
+                    })));
+                if (editor) {
+                    editor.printAbove(theme.dim(String.fromCharCode(10) +
+                        '--- compacted context ---' +
+                        String.fromCharCode(10) +
+                        summary +
+                        String.fromCharCode(10) +
+                        '--- end ---' +
+                        String.fromCharCode(10)));
+                }
+            }
+            catch (e) {
+                console.error(theme.error(e.message));
+            }
+            finally {
+                if (editor)
+                    editor.unlock();
+            }
+            continue;
+        }
         if (lower === '/review' || lower.startsWith('/review ')) {
             const rest = trimmed.slice('/review'.length).trim();
             const staged = rest.indexOf("--staged") !== -1;

package/dist/input.js

@@ -170,6 +170,31 @@ export function layoutInput(promptStr, buf, cursor, cols) {
     }
     return { rows, cursorRow, cursorCol };
 }
+// Format a token count for the status line: compact (10k, 125k) plus the
+// percentage of CONTEXT_LIMIT. Exported so it is unit-tested without a live
+// editor. A null/undefined/NaN count renders an empty string (no status).
+export const CONTEXT_LIMIT = 1_000_000;
+export function formatTokenStatus(tokens, limit = CONTEXT_LIMIT) {
+    if (typeof tokens !== 'number' || !Number.isFinite(tokens) || tokens < 0) {
+        return '';
+    }
+    const n = Math.round(tokens);
+    let compact;
+    if (n >= 1_000_000) {
+        const m = n / 1_000_000;
+        compact = (Number.isInteger(m) ? String(m) : m.toFixed(1)) + 'M';
+    }
+    else if (n >= 1_000) {
+        const k = n / 1_000;
+        compact = (k >= 100 ? String(Math.round(k)) : k.toFixed(1).replace(/\.0$/, '')) + 'k';
+    }
+    else {
+        compact = String(n);
+    }
+    const pct = Math.max(0, (n / limit) * 100);
+    const pctStr = pct >= 10 ? String(Math.round(pct)) : pct.toFixed(1);
+    return compact + ' · ' + pctStr + '%';
+}
 export class LineEditor {
     promptStr;
     buf;
@@ -218,6 +243,13 @@ export class LineEditor {
     // Interface language for the editor's own labels (hint, answer marker,
     // pause status). Everything the OPERATOR sees must be localized.
     locale;
+    // Token context for the status line: the compact count (10k/125k) plus the
+    // percentage of the context limit, right-aligned above the input line. Null
+    // hides it. Updated by the caller from browser.getLastTokenUsage().
+    contextStatus;
+    // A callback the editor calls to fetch the CURRENT token count before every
+    // status render, so the status line stays fresh without the caller polling.
+    onContextQuery;
     constructor({ prompt = '> ', commands = [], locale = 'ru' } = {}) {
         this.locale = locale;
         this.promptStr = prompt;
@@ -250,6 +282,22 @@ export class LineEditor {
         this.onAttach = null;
         this.onClipboard = null;
         this.locked = false;
+        this.contextStatus = null;
+        this.onContextQuery = null;
+    }
+    // The token status for the CURRENT render: refreshed from onContextQuery
+    // when wired, otherwise the last value passed to setContextStatus().
+    _contextForRender() {
+        if (this.onContextQuery) {
+            try {
+                const n = this.onContextQuery();
+                this.contextStatus = n === null || n === undefined ? null : formatTokenStatus(n) || null;
+            }
+            catch {
+                // A broken callback must never break the render.
+            }
+        }
+        return this.contextStatus;
     }
     // Read the OS clipboard for an image and insert its marker. Used when the
     // terminal sends no usable paste data (Ctrl+V / right-click / empty paste).
@@ -370,6 +418,11 @@ export class LineEditor {
         this.promptStr = str;
         this._render();
     }
+    // Update the token-context text shown at the right of the status line.
+    setContextStatus(tokens) {
+        this.contextStatus = formatTokenStatus(tokens) || null;
+        this._render();
+    }
     // Update the interface language (labels: hint, answer marker, pause).
     setLocale(locale) {
         this.locale = locale;
@@ -402,11 +455,29 @@ export class LineEditor {
         const cols = process.stdout.columns || 80;
         let out = '';
         let top = 0;
+        // Status line above the input: the spinner/answer text on the left and the
+        // token context right-aligned on the SAME row (10k · 12%). The context is
+        // refreshed from onContextQuery() on every render, so it follows the live
+        // DeepSeek counter without a polling timer of its own.
+        const ctx = this._contextForRender();
+        const ctxText = ctx ? theme.dim(ctx) : '';
         if (this.statusText) {
-            out += this.statusText + NL;
+            if (ctxText) {
+                const pad = Math.max(1, cols - visLen(this.statusText) - visLen(ctxText));
+                out += this.statusText + ' '.repeat(pad) + ctxText + NL;
+            }
+            else {
+                out += this.statusText + NL;
+            }
             // The status may wrap onto several lines — we account for this,
             // otherwise the block erase misses and statuses pile up.
-            top = visRows(this.statusText, cols);
+            top = visRows(this.statusText + (ctxText ? ' '.repeat(2) + ctxText : ''), cols);
+        }
+        else if (ctxText) {
+            // Idle: no spinner, but the context still belongs on its own line just
+            // above the input, right-aligned.
+            out += ' '.repeat(Math.max(0, cols - visLen(ctxText))) + ctxText + NL;
+            top = visRows(ctxText, cols);
         }
         const lay = layoutInput(this.promptStr, this.buf, this.cursor, cols);
         out += lay.rows.map((r) => r.prefix + r.text).join(NL);

package/dist/net-capture.js

@@ -159,6 +159,53 @@ export function extractAnswer(body) {
         return sse;
     return extractFromJson(body);
 }
+// The CONTEXT size (in tokens) DeepSeek reports for the current answer.
+//
+// chat.deepseek.com does not expose prompt_tokens/completion_tokens the way
+// the API does. What it sends instead is `accumulated_token_usage` — a
+// CUMULATIVE counter of the whole chat so far, present both in the SSE
+// completion stream and (per message) in /api/v0/chat/history_messages. It
+// is the number the operator wants for "how much context is used": the
+// latest value is the current size of the chat context in tokens.
+//
+// SSE placement:
+//   * the initial fragment: v.response.accumulated_token_usage
+//   * an update chunk: {"p":"response","o":"BATCH",
+//                       "v":[{"p":"accumulated_token_usage","v":N}, ...]}
+// We take the LAST value seen (the freshest).
+//
+// Returns null when the body carries no counter (e.g. an OpenAI-shaped
+// response or a non-answer endpoint) so the caller can keep the old value.
+export function extractTokenUsage(body) {
+    let found = null;
+    const consider = (n) => {
+        if (typeof n === 'number' && Number.isFinite(n) && n >= 0)
+            found = n;
+    };
+    for (const obj of parseDataLines(body)) {
+        if (obj == null || typeof obj !== 'object')
+            continue;
+        const o = obj;
+        // The initial fragment: v.response.accumulated_token_usage.
+        const v = o.v;
+        const resp = v && typeof v === 'object'
+            ? v.response
+            : undefined;
+        if (resp)
+            consider(resp.accumulated_token_usage);
+        // A BATCH update: v is an array of {"p":"accumulated_token_usage","v":N}.
+        if (Array.isArray(o.v)) {
+            for (const item of o.v) {
+                if (item && typeof item === 'object') {
+                    const it = item;
+                    if (it.p === 'accumulated_token_usage')
+                        consider(it.v);
+                }
+            }
+        }
+    }
+    return found;
+}
 // Saves the DeepSeek network response body to disk for post-mortem analysis.
 // The files live in ~/.zames/net-log — from them the real answer format is visible.
 // DEBUG ONLY: disabled unless ZAMES_NET_DEBUG=1. It writes a file per network

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zames_pro",
-  "version": "2.17.0",
+  "version": "2.19.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",