zames_pro 2.18.0 → 2.20.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.
@@ -152,6 +152,15 @@ Codex CLI:
  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 is COLORED by fill level: green below 50%,
+yellow 50-80%, red above 80%. It comes from DeepSeek's
+`accumulated_token_usage` and is hidden until the first answer delivers it.
 
 
 ## Project context, skills and memory

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,11 @@ 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;
@@ -328,6 +333,7 @@ export class DeepSeekBrowser {
         this._netCapture = '';
         this._netCaptureAt = 0;
         this._netChatId = null;
+        this._lastTokenUsage = null;
         this._apiAuth = '';
         this._apiPow = '';
         this._lastHistoryError = '';
@@ -472,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;
@@ -856,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
@@ -922,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 '';
@@ -1157,13 +1196,14 @@ export class DeepSeekBrowser {
         // replied to the wrong thing (or nothing), and the loop looked stalled.
         if (norm(got) !== norm(text)) {
             await input.click();
-            await this.page.keyboard.press("Control+A");
-            await this.page.keyboard.press("Delete");
+            await this.page.keyboard.press('Control+A');
+            await this.page.keyboard.press('Delete');
             await this.page.keyboard.insertText(text);
             const got2 = await input.evaluate((el) => {
-                if (el.tagName.toLowerCase() === "textarea" || el.tagName.toLowerCase() === "input")
+                if (el.tagName.toLowerCase() === 'textarea' ||
+                    el.tagName.toLowerCase() === 'input')
                     return el.value;
-                return el.innerText || el.textContent || "";
+                return el.innerText || el.textContent || '';
             });
             if (norm(got2) !== norm(text)) {
                 throw new Error(this._t('ds.input_partial', {
@@ -1321,8 +1361,20 @@ export class DeepSeekBrowser {
         if (!input) {
             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)));
+        // `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.
         if (this._abort)
@@ -1395,7 +1447,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);
@@ -1415,7 +1467,12 @@ export class DeepSeekBrowser {
             const netStarted = !!this._netCapture && this._netCaptureAt >= this._lastSentAt;
             if (changed || netStarted || bodyLen > startBodyLen) {
                 started = true;
-                this._askDebug('STARTED changed=' + changed + ' netStarted=' + netStarted + ' bodyGrew=' + (bodyLen > startBodyLen));
+                this._askDebug('STARTED changed=' +
+                    changed +
+                    ' netStarted=' +
+                    netStarted +
+                    ' bodyGrew=' +
+                    (bodyLen > startBodyLen));
                 break;
             }
             // Fallback for an echo: the text equals beforeText, so it is the OLD
@@ -1436,7 +1493,18 @@ export class DeepSeekBrowser {
                 settledTicks = 0;
             }
             lastStartCur = cur;
-            this._askDebug('START-loop curLen=' + cur.length + ' changed=' + changed + ' netStarted=' + netStarted + ' bodyLen=' + bodyLen + ' settled=' + settledTicks + ' generating=' + notGenerating);
+            this._askDebug('START-loop curLen=' +
+                cur.length +
+                ' changed=' +
+                changed +
+                ' netStarted=' +
+                netStarted +
+                ' bodyLen=' +
+                bodyLen +
+                ' settled=' +
+                settledTicks +
+                ' generating=' +
+                notGenerating);
             await this.page.waitForTimeout(300);
         }
         if (!started) {
@@ -1444,9 +1512,12 @@ 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())) {
+            if (cur &&
+                cur.trim() &&
+                normText(cur) !== normText(beforeText) &&
+                !(await this._isGenerating())) {
                 return cur;
             }
             if (fresh) {
@@ -1464,7 +1535,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)
@@ -1506,14 +1577,20 @@ export class DeepSeekBrowser {
                 }
             }
             const netFresh = !!this._netCapture && this._netCaptureAt >= this._lastSentAt;
-            const cur = await this._readLastAnswerTextClean().catch(() => '');
+            // The DOM may be empty while the answer is already in the network
+            // capture (a resumed chat re-renders its history, the answer selector
+            // may lag, or page.evaluate times out). In that case fall back to the
+            // raw capture: it is the CURRENT answer and must not be ignored just
+            // because the DOM has not caught up.
+            let cur = await this._readLastAnswerTextCleanDom().catch(() => '');
+            if (!cur && netFresh)
+                cur = this._cleanAnswer(this._netCapture);
             // 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
             // stop). We keep waiting instead. A fresh network capture is exempt: it
             // belongs to the CURRENT send even if the DOM still shows the old text.
-            const isNew = !!cur &&
-                (netFresh || normText(cur) !== normText(beforeText));
+            const isNew = !!cur && (netFresh || normText(cur) !== normText(beforeText));
             // An echo/stale answer equals beforeText, so isNew stays false and the
             // old loop waited until the full timeout — the "agent stopped after a
             // tool call" hang. If generation has clearly ENDED (no Stop button) and
@@ -1537,7 +1614,18 @@ export class DeepSeekBrowser {
             }
             if (isNew)
                 last = cur;
-            this._askDebug('FIN-loop isNew=' + isNew + ' sameAsBefore=' + sameAsBefore + ' stable=' + stable + ' curLen=' + cur.length + ' lastLen=' + last.length + ' netFresh=' + netFresh);
+            this._askDebug('FIN-loop isNew=' +
+                isNew +
+                ' sameAsBefore=' +
+                sameAsBefore +
+                ' stable=' +
+                stable +
+                ' curLen=' +
+                cur.length +
+                ' lastLen=' +
+                last.length +
+                ' netFresh=' +
+                netFresh);
             await this.page.waitForTimeout(Math.max(0, this.stabilityDelayMs));
         }
         if (last && (normText(last) !== normText(beforeText) || this._netCapture)) {
@@ -1549,7 +1637,10 @@ export class DeepSeekBrowser {
         if (this._netCapture && this._netCaptureAt >= this._lastSentAt) {
             return this._netCapture;
         }
-        this._askDebug('THROW no-new-answer lastLen=' + last.length + ' beforeLen=' + beforeText.length);
+        this._askDebug('THROW no-new-answer lastLen=' +
+            last.length +
+            ' beforeLen=' +
+            beforeText.length);
         throw new Error(this._t('ds.send_no_new_answer'));
     }
     async dumpDom(filePath) {
@@ -1700,7 +1791,13 @@ export class DeepSeekBrowser {
                 }
                 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 = '';
@@ -1714,7 +1811,7 @@ export class DeepSeekBrowser {
                     if (text)
                         out.push({ role, text });
                 }
-                return { error: '', list: out };
+                return { error: '', list: out, usage };
             }
             catch (e) {
                 return { error: 'fetch failed: ' + e.message, list: [] };
@@ -1725,6 +1822,11 @@ export class DeepSeekBrowser {
             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;
@@ -1743,6 +1845,9 @@ export class DeepSeekBrowser {
             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 = '';
@@ -1874,6 +1979,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]);
@@ -258,6 +264,51 @@ export function formatRestoredHistory(messages, opts = {}) {
     }
     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.' },
@@ -316,6 +323,7 @@ const CATALOG = {
     '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.' },
@@ -355,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,7 +16,7 @@ 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, trimRestoredMessages, RESTORED_HISTORY_LIMIT, } 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';
@@ -244,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')}
@@ -299,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' },
@@ -836,6 +838,10 @@ async function printRestoredHistory(browser, ui, chatId = null) {
             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());
@@ -1195,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);
@@ -2107,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 ')) {
@@ -2140,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 ')) {
@@ -2234,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,49 @@ 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;
+// Thresholds for coloring the context counter. Below YELLOW the value is
+// green (plenty of room), between YELLOW and RED it is yellow (getting full),
+// above RED it is red (nearly exhausted). Percent of CONTEXT_LIMIT.
+export const CONTEXT_YELLOW_PCT = 50;
+export const CONTEXT_RED_PCT = 80;
+// The color role for a context fill level, as a stable string so it can be
+// unit-tested without a terminal: 'ok' | 'warn' | 'high'. Null tokens -> null.
+export function tokenStatusLevel(tokens, limit = CONTEXT_LIMIT) {
+    if (typeof tokens !== 'number' || !Number.isFinite(tokens) || tokens < 0) {
+        return null;
+    }
+    const pct = (tokens / limit) * 100;
+    if (pct >= CONTEXT_RED_PCT)
+        return 'high';
+    if (pct >= CONTEXT_YELLOW_PCT)
+        return 'warn';
+    return 'ok';
+}
+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 +261,15 @@ 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;
+    // The raw token count behind contextStatus (for the color level).
+    contextTokens;
+    // 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 +302,38 @@ export class LineEditor {
         this.onAttach = null;
         this.onClipboard = null;
         this.locked = false;
+        this.contextStatus = null;
+        this.contextTokens = 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.contextTokens = typeof n === 'number' ? n : null;
+                this.contextStatus =
+                    n === null || n === undefined ? null : formatTokenStatus(n) || null;
+            }
+            catch {
+                // A broken callback must never break the render.
+            }
+        }
+        return this.contextStatus;
+    }
+    // The context text colored by fill level: green (ok), yellow (warn),
+    // red (high).
+    _contextText() {
+        const ctx = this._contextForRender();
+        if (!ctx)
+            return '';
+        const level = tokenStatusLevel(this.contextTokens);
+        if (level === 'high')
+            return theme.error(ctx);
+        if (level === 'warn')
+            return theme.warn(ctx);
+        return theme.success(ctx);
     }
     // 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 +454,13 @@ export class LineEditor {
         this.promptStr = str;
         this._render();
     }
+    // Update the token-context text shown at the right of the status line.
+    setContextStatus(tokens) {
+        this.contextTokens =
+            typeof tokens === 'number' && Number.isFinite(tokens) ? tokens : null;
+        this.contextStatus = formatTokenStatus(tokens) || null;
+        this._render();
+    }
     // Update the interface language (labels: hint, answer marker, pause).
     setLocale(locale) {
         this.locale = locale;
@@ -402,11 +493,41 @@ 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 ctxText = this._contextText();
         if (this.statusText) {
-            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);
+            if (ctxText) {
+                // Right-align the context on the SAME row as the status. When the
+                // status is too long to leave room, do NOT cram them together (that
+                // pushed the trailing `%` past the right edge and it got truncated):
+                // put the context on its own line instead.
+                const space = cols - visLen(this.statusText) - visLen(ctxText);
+                if (space >= 2) {
+                    out += this.statusText + ' '.repeat(space) + ctxText + NL;
+                    top = visRows(this.statusText + ' '.repeat(2) + ctxText, cols);
+                }
+                else {
+                    out += this.statusText + NL;
+                    top = visRows(this.statusText, cols);
+                    out += ' '.repeat(Math.max(0, cols - visLen(ctxText))) + ctxText + NL;
+                    top += visRows(ctxText, cols);
+                }
+            }
+            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);
+            }
+        }
+        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.18.0",
+  "version": "2.20.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": "ZAMES_NET_DEBUG=1 tsx ./src/index.ts --dev",
+    "dev": "ZAMES_NET_DEBUG=1 tsx ./src/index.ts --dev --headed",
     "build": "tsc -p tsconfig.build.json",
     "typecheck": "tsc --noEmit",
     "prepublishOnly": "npm run build",