zames_pro 2.81.22 → 2.82.1

package/CHANGELOG.md

@@ -7,6 +7,24 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.82.1] - 2026-10-22
+
+### Fixed
+
+- **shell:** an empty command answers instead of throwing
+
+## [2.82.0] - 2026-10-22
+
+### Fixed
+
+- **compact:** recover from an exhausted chat context on every provider
+
+## [2.81.23] - 2026-10-22
+
+### Fixed
+
+- **resume:** a respond message carrying the safety block is hidden
+
 ## [2.81.22] - 2026-10-22
 
 ### Fixed

package/dist/agent-loop.js

@@ -1,4 +1,5 @@
 import { buildSystemPrompt } from './system-prompt.js';
+import { isContextLimitText } from './browser-pure.js';
 import { providerLabel as providerHumanLabel } from './providers.js';
 import { loadProjectContext } from './context.js';
 import { getGitContext, formatGitContext } from './gitTools.js';
@@ -7,7 +8,7 @@ import { substituteAttachmentMarkers } from './commands.js';
 import { loadHooks, runPreToolUse, runPostToolUse, runLifecycleHooks, } from './hooks.js';
 import { loadPermissions, decidePermission, } from './permissions.js';
 import { shouldRunDiagnostics, runDiagnostics, } from './diagnostics.js';
-export async function runAgentLoop({ browser, tools, task, workdir, maxIterations = 0, freshChat = false, sendSystemPrompt = false, transcript = null, attachments = [], onThinking = () => { }, onSendPause = () => { }, onSendState = () => { }, onNotice = () => { }, onAssistantThought = () => { }, onToolCall = () => { }, onToolResult = () => { }, onAssistantMessage = () => { }, onChatReady = () => { }, onWarning = () => { }, debugLog = false, locale = 'ru', askDeadlineMs = 240_000, maxAfterToolRetries = 6, onAutoCompact = null, autoCompactPct = 95, contextLimit = 1_000_000, getTokenUsage = null, hooks = undefined, permissions = undefined, diagnostics = null, onAskPermission = undefined, selfImprovement = false, onSubagent = null, onAskUser = null, }) {
+export async function runAgentLoop({ browser, tools, task, workdir, maxIterations = 0, freshChat = false, sendSystemPrompt = false, transcript = null, attachments = [], onThinking = () => { }, onSendPause = () => { }, onSendState = () => { }, onNotice = () => { }, onAssistantThought = () => { }, onToolCall = () => { }, onToolResult = () => { }, onAssistantMessage = () => { }, onChatReady = () => { }, onWarning = () => { }, debugLog = false, locale = 'ru', askDeadlineMs = 240_000, maxAfterToolRetries = 6, onAutoCompact = null, onContextLimit = null, autoCompactPct = 95, contextLimit = 1_000_000, getTokenUsage = null, hooks = undefined, permissions = undefined, diagnostics = null, onAskPermission = undefined, selfImprovement = false, onSubagent = null, onAskUser = null, }) {
     // Resolve the hook config ONCE per task: a read per tool call would be
     // wasteful, and a mid-task edit of hooks.json is not something to chase.
     // `undefined` means "read .zames/hooks.json"; an explicit null disables
@@ -48,6 +49,15 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
     // editor's repaint, so the operator only saw the spinner. `onNotice` prints
     // the notice ABOVE the input line.
     browser.onNotice = safe(onNotice);
+    // The chat ran out of context and refuses further sends ("Length limit
+    // reached. Please start a new chat."). The browser cannot recover by itself:
+    // compaction needs the system prompt, the tools and the session bookkeeping
+    // that live above it, so the callback is attached here, where the caller's
+    // hook lives (the same seam pattern as onAutoCompact).
+    if ('onContextLimit' in browser) {
+        ;
+        browser.onContextLimit = onContextLimit;
+    }
     const safeAssistantThought = safe(onAssistantThought);
     const safeToolCall = safe(onToolCall);
     const safeToolResult = safe(onToolResult);
@@ -494,6 +504,10 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
                 // tool-call and not a real final answer — treat it as a service
                 // answer so the loop re-asks instead of stopping on it.
                 /<ds_safety>|<\/ds_safety>/i.test(trimmed) ||
+                // An exhausted-context notice can also arrive as the turn's TEXT (it
+                // is short and carries no tool call). Treat it as a service answer so
+                // the loop re-asks instead of finishing on "start a new chat".
+                isContextLimitText(trimmed) ||
                 (trimmed.length <= 200 &&
                     /(messages? too frequent|too many requests|rate limit|server (is )?busy|service (is )?unavailable|слишком часто|try again later)/i.test(trimmed));
             if (looksService && stallRetries < MAX_STALL_RETRIES) {

package/dist/browser-pure.js

@@ -2,7 +2,7 @@ import path from 'path';
 import os from 'os';
 import fs from 'fs/promises';
 import { chromium } from 'playwright';
-import { GENERATION_ERR_RE, GENERATION_TIMEOUT_RE, INCOMPLETE_STATUS_RE, RATE_LIMIT_RE, SERVER_BUSY_RE, STATUS_RE, } from './deepseek-ui.js';
+import { CONTEXT_LIMIT_RE, GENERATION_ERR_RE, GENERATION_TIMEOUT_RE, INCOMPLETE_STATUS_RE, RATE_LIMIT_RE, SERVER_BUSY_RE, STATUS_RE, } from './deepseek-ui.js';
 // Drop service placeholders ("Reading…", "Thinking…") so they are not mistaken
 // for an answer; keep everything else as-is (including the whitespace the
 // tool-call relies on). Pure: no `this`, no page.
@@ -283,6 +283,13 @@ export function isGenerationIncompleteText(text) {
 export function isRateLimitText(text) {
     return RATE_LIMIT_RE.test(String(text || ''));
 }
+// The chat ran out of context: DeepSeek answers "Length limit reached. Please
+// start a new chat." and will refuse every further send into this chat. Distinct
+// from the rate limit (which clears with time) and from a server hiccup — the
+// only recovery is compaction, so ask() must not retry in the same chat.
+export function isContextLimitText(text) {
+    return CONTEXT_LIMIT_RE.test(String(text || ''));
+}
 export function isServerBusyText(text) {
     const t = String(text || '');
     // Rate limit takes priority (it needs the long wait).
@@ -313,6 +320,16 @@ export class ServerBusyError extends Error {
         this.name = 'ServerBusyError';
     }
 }
+// The chat's context window is exhausted ("Length limit reached. Please start
+// a new chat."). The server rejects EVERY send into this chat, so a retry in
+// place is pointless: the caller must compact (open a NEW chat with a handover
+// summary) and only then resend.
+export class ContextLimitError extends Error {
+    constructor(detail) {
+        super('Chat context limit reached. ' + detail);
+        this.name = 'ContextLimitError';
+    }
+}
 // The generation was truncated by the server (`generation_err` / INCOMPLETE).
 // Distinct from ServerBusyError: the DeepSeek backend answered, but the turn
 // did not finish, and the UI offers a "Continue" button. The agent retries the

package/dist/browser.js

@@ -2,6 +2,7 @@ import { chromium, } from 'playwright';
 import { interactiveBrowserLogin, loginIsInteractive, canShowWindow, } from './browser-login.js';
 import { extractAnswer, extractTokenUsage, dumpNetBody, isFinishedWithoutAnswer, isFinishedWithAnswer, } from './net-capture.js';
 import { rewriteFailedAttachments } from './commands.js';
+import { recoverFromContextLimit } from './context-limit.js';
 import { awaitUploadPreview, readAttachBuffers } from './attach-flow.js';
 import { parseHistoryMessages, extractChatMessages, scrapeChatList, scrapeChatMessages, } from './browser-chats.js';
 import { CHAT_URL, CHAT_ID_RE, chatUrl, HISTORY_MESSAGES_URL, BUTTON_CLASS_RE, INPUT_SELECTORS, SEND_SELECTORS, STOP_SELECTORS, STOP_NAME_RE, CONTINUE_NAME_RE, ANSWER_SELECTORS, THINK_CLASS_RE, MESSAGE_CONTAINER_SELECTORS, RESTORE_ANSWER_SELECTORS, ASSISTANT_CLASS_RE, ASSISTANT_SELECTOR, ANSWER_MARKDOWN_SELECTOR, MARKDOWN_SELECTOR, CHAT_SIGNAL_NODES_SELECTOR, NEW_CHAT_SELECTOR, NEW_CHAT_TEXT_RE, PASSWORD_SELECTORS, LOGIN_SELECTORS, LOGIN_SUBMIT_SELECTORS, MFA_CODE_SELECTORS, MFA_SUBMIT_SELECTORS, MFA_SEND_CODE_SELECTORS, MFA_SEND_CODE_RE, LOGIN_BUTTON_SELECTOR, LOGIN_NAME_RE, LOGIN_FORM_SUBMIT_RE, SIDEBAR_TOGGLE_SELECTORS, TOGGLE_SELECTORS, DEEP_THINKING_RE, WEB_SEARCH_RE, ATTACH_SELECTORS, ANSWER_URL_RE, } from './deepseek-ui.js';
@@ -21,8 +22,8 @@ export { STOP_NAME_RE, CONTINUE_NAME_RE };
 // imported for the class below and RE-EXPORTED here, so the public API of this
 // module is unchanged (tests and other modules import these names from
 // './browser.js').
-import { askPassword, USER_DATA_DIR, parseHeadlessUACache, headlessEngineKey, readCachedHeadlessUA, writeCachedHeadlessUA, headlessUACacheReady, sanitizeHeadlessUA, writeAuthMarker, isGenerationIncompleteText, isRateLimitText, isServerBusyText, normText, cleanAnswer, RateLimitError, ServerBusyError, GenerationIncompleteError, cleanSingletonFiles, profileLooksLocked, nukeProfile, } from './browser-pure.js';
-export { askPassword, parseHeadlessUACache, headlessUACacheReady, sanitizeHeadlessUA, isGenerationIncompleteText, isRateLimitText, isServerBusyText, normText, RateLimitError, ServerBusyError, GenerationIncompleteError, };
+import { askPassword, USER_DATA_DIR, parseHeadlessUACache, headlessEngineKey, readCachedHeadlessUA, writeCachedHeadlessUA, headlessUACacheReady, sanitizeHeadlessUA, writeAuthMarker, isGenerationIncompleteText, isRateLimitText, isServerBusyText, isContextLimitText, normText, cleanAnswer, RateLimitError, ServerBusyError, GenerationIncompleteError, ContextLimitError, cleanSingletonFiles, profileLooksLocked, nukeProfile, } from './browser-pure.js';
+export { askPassword, parseHeadlessUACache, headlessUACacheReady, sanitizeHeadlessUA, isGenerationIncompleteText, isRateLimitText, isServerBusyText, isContextLimitText, normText, RateLimitError, ServerBusyError, GenerationIncompleteError, ContextLimitError, };
 export class DeepSeekBrowser {
     providerName = 'deepseek';
     headless;
@@ -40,6 +41,11 @@ export class DeepSeekBrowser {
     rateLimitWaitMs;
     maxRateLimitRetries;
     maxServerBusyRetries;
+    // Ask() budget for the context-limit recovery. A compaction that does not
+    // free the window leaves the chat just as rejected as before, so the
+    // recovery is capped independently of askRetries.
+    maxContextLimitRetries;
+    onContextLimit;
     serverBusyWaitMs;
     // Retries for a turn the server truncated (generation_err / INCOMPLETE).
     maxIncompleteRetries;
@@ -168,7 +174,7 @@ export class DeepSeekBrowser {
     _windowClosed;
     /** Session cookies captured before a relaunch (no `expires` -> in-memory). */
     _carryCookies;
-    constructor({ headless = false, debug = false, channel = 'chrome', answerTimeoutMs = 180000, askRetries = 3, stabilityChecks = 2, stabilityDelayMs = 400, minSendIntervalMs = 15000, thinkingExtraMs = 2000, rateLimitWaitMs = 300000, maxRateLimitRetries = 6, maxServerBusyRetries = 5, serverBusyWaitMs = 3000, maxIncompleteRetries = 4, incompleteWaitMs = 2000, autoContinue = true, continueMinGapMs = 1500, loginTimeoutMs = 600000, deepThinking = false, webSearch = true, auth, locale, onAuthSave, onLoginPrompt, onMfaPrompt, userAgent, } = {}) {
+    constructor({ headless = false, debug = false, channel = 'chrome', answerTimeoutMs = 180000, askRetries = 3, stabilityChecks = 2, stabilityDelayMs = 400, minSendIntervalMs = 15000, thinkingExtraMs = 2000, rateLimitWaitMs = 300000, maxRateLimitRetries = 6, maxServerBusyRetries = 5, serverBusyWaitMs = 3000, maxIncompleteRetries = 4, incompleteWaitMs = 2000, maxContextLimitRetries = 1, onContextLimit, autoContinue = true, continueMinGapMs = 1500, loginTimeoutMs = 600000, deepThinking = false, webSearch = true, auth, locale, onAuthSave, onLoginPrompt, onMfaPrompt, userAgent, } = {}) {
         this.headless = headless;
         this.debug = debug;
         this.channel = channel;
@@ -184,6 +190,8 @@ export class DeepSeekBrowser {
         this.serverBusyWaitMs = serverBusyWaitMs;
         this.maxIncompleteRetries = maxIncompleteRetries;
         this.incompleteWaitMs = incompleteWaitMs;
+        this.maxContextLimitRetries = maxContextLimitRetries;
+        this.onContextLimit = onContextLimit || null;
         this.autoContinue = autoContinue;
         this.continueMinGapMs = continueMinGapMs;
         this.loginTimeoutMs = loginTimeoutMs;
@@ -1594,6 +1602,10 @@ export class DeepSeekBrowser {
         // hiccup, not a failed send, and it is more likely in the reasoning
         // (deep thinking) mode, where the long THINK phase gets cut off.
         let incompleteRetries = 0;
+        // Bumped when the chat's context window is exhausted. Recovery is a
+        // COMPACTION (a new chat), not a resend, so it has its own budget: a
+        // compaction that frees nothing leaves the chat just as rejected.
+        let contextLimitRetries = 0;
         // Mark that OUR code has an ask in flight. A completion/continue body
         // that arrives with _askInFlight === 0 was the operator's own turn, and
         // _onResponse uses that to bump _lastSentAt so the next agent send waits
@@ -1693,6 +1705,34 @@ export class DeepSeekBrowser {
                             return '(прервано пользователем)';
                         continue;
                     }
+                    // The chat's context window is exhausted: every further send into
+                    // this chat is refused ("Length limit reached. Please start a new
+                    // chat."). Retrying here is useless — the caller compacts the chat
+                    // and opens a fresh one, then the SAME prompt is resent there. The
+                    // resend does not consume a regular ask() attempt.
+                    if (e instanceof ContextLimitError) {
+                        contextLimitRetries++;
+                        const res = await recoverFromContextLimit({
+                            recover: () => this.onContextLimit?.() ?? Promise.resolve(false),
+                            maxRetries: this.maxContextLimitRetries,
+                            attempt: contextLimitRetries,
+                            notice: (text) => this._notice(text),
+                            t: (k, p) => this._t(k, p),
+                            keys: {
+                                compact: 'ds.context_limit_compact',
+                                compactFailed: 'ds.context_limit_compact_failed',
+                                giveUp: 'ds.context_limit_give_up',
+                            },
+                            provider: 'DeepSeek',
+                        }, e);
+                        if (!res.resend)
+                            throw res.error || e;
+                        // The compaction has already typed into the new chat, so the send
+                        // throttle must count from that moment. Leaving `_lastSentAt` at
+                        // the failed send's time adds nothing: that send never went out.
+                        this._lastSentAt = Date.now();
+                        continue;
+                    }
                     this._notice(theme.warn(this._t('ds.ask_retry', {
                         attempt: attempt + 1,
                         max: this.askRetries,
@@ -2085,6 +2125,12 @@ export class DeepSeekBrowser {
             if (this._abort || this._askCancelled)
                 return '(прервано пользователем)';
             const pageText = await this._readPageText();
+            // Checked BEFORE the rate limit and the server hiccup: DeepSeek shows the
+            // context notice INSTEAD of an answer, and both of those branches would
+            // retry the same send into a chat that can never accept it again.
+            if (isContextLimitText(pageText)) {
+                throw new ContextLimitError(pageText.slice(0, 300));
+            }
             if (isRateLimitText(pageText)) {
                 throw new RateLimitError(pageText.slice(0, 300));
             }
@@ -2315,6 +2361,12 @@ export class DeepSeekBrowser {
             if (this._netRateLimited && this._netCaptureAt >= this._lastSentAt) {
                 throw new RateLimitError(this._netBody.slice(0, 300) || 'rate limit (from network)');
             }
+            // The exhausted context can likewise be visible only in the captured
+            // body rather than in a toast, so ask() must see it here as well.
+            if (this._netCaptureAt >= this._lastSentAt &&
+                isContextLimitText(this._netBody)) {
+                throw new ContextLimitError(this._netBody.slice(0, 300));
+            }
             // The server truncated the turn (generation_err / INCOMPLETE) or ended
             // it with only reasoning. PREFER the Continue button: it RESUMES the
             // same turn (`chat/continue`). Resending the prompt creates a NEW turn

package/dist/commands.js

@@ -487,6 +487,11 @@ export function normalizeRestoredMessage(m) {
         const msg = (call.message || '').trim();
         if (!msg)
             return null;
+        // The safety-classification block can sit INSIDE the respond message; the
+        // plain-text path already drops it, and printing the marker as the answer
+        // is the same leak.
+        if (/<\/?ds_safety\b/i.test(msg))
+            return null;
         return { role: 'assistant', text: msg };
     }
     // A plain-text answer (written without the respond wrapper) — show as-is.

package/dist/compact.js

@@ -15,7 +15,7 @@ export const COMPACT_FALLBACK_LIMIT = 40;
  * The caller owns the browser and the throttle; this function only sends.
  */
 export async function performCompact(opts) {
-    const { browser, workdir, locale, task, transcript = null, ui = null, buildSystemPrompt, tools, answerTimeoutMs, fallbackLimit = COMPACT_FALLBACK_LIMIT, skipUiLock = false, quiet = false, selfImprovement = false, } = opts;
+    const { browser, workdir, locale, task, transcript = null, ui = null, buildSystemPrompt, tools, answerTimeoutMs, fallbackLimit = COMPACT_FALLBACK_LIMIT, skipUiLock = false, quiet = false, selfImprovement = false, contextExhausted = false, } = opts;
     const t = translate(locale);
     const log = (msg) => {
         if (!quiet)
@@ -51,10 +51,13 @@ export async function performCompact(opts) {
                 transcript?.log('hook_pre_compact', { output: out });
         }
         catch { }
-        // 1) Ask the OLD chat to summarize itself.
+        // 1) Ask the OLD chat to summarize itself. On an EXHAUSTED chat that send
+        // is refused ("Length limit reached"), so go straight to the local
+        // fallback below — retrying the refused send wastes minutes on the rate
+        // limit and can never produce a summary.
         let summary = '';
         let summaryErr = '';
-        for (let attempt = 1; attempt <= COMPACT_SUMMARY_ATTEMPTS; attempt++) {
+        for (let attempt = 1; !contextExhausted && attempt <= COMPACT_SUMMARY_ATTEMPTS; attempt++) {
             let prompt = buildCompactPrompt(locale);
             if (attempt > 1) {
                 prompt +=
@@ -132,15 +135,33 @@ export async function performCompact(opts) {
             beforeTokens,
         });
         // 2) New chat + system prompt + the summary as the first message.
-        await browser.newChat();
-        await browser.ask(buildSystemPrompt({ workdir, tools, locale, selfImprovement }), {
-            timeout: 60_000,
-            agent: false,
-        });
-        await browser.ask(buildCompactCarryover(summary, task), {
-            timeout: 60_000,
-            agent: false,
-        });
+        // The recovery path (contextExhausted) is RE-ENTRANT: this compaction was
+        // started BY a refused send, so a refusal during these sends would call
+        // back into compaction while it is still running. Drop the callback for
+        // the duration — by now the exhausted chat is behind us and a refusal here
+        // means the compaction itself cannot proceed, which the caller reports.
+        const prevOnContextLimit = browser.onContextLimit;
+        if (contextExhausted && 'onContextLimit' in browser) {
+            ;
+            browser.onContextLimit = null;
+        }
+        try {
+            await browser.newChat();
+            await browser.ask(buildSystemPrompt({ workdir, tools, locale, selfImprovement }), {
+                timeout: 60_000,
+                agent: false,
+            });
+            await browser.ask(buildCompactCarryover(summary, task), {
+                timeout: 60_000,
+                agent: false,
+            });
+        }
+        finally {
+            if (contextExhausted && 'onContextLimit' in browser) {
+                ;
+                browser.onContextLimit = prevOnContextLimit || null;
+            }
+        }
         const newChatId = browser.getCurrentChatId
             ? await browser.getCurrentChatId()
             : null;

package/dist/context-limit.js

@@ -0,0 +1,25 @@
+/**
+ * Run ONE context-limit recovery. The caller resends only on `resend: true`;
+ * on `resend: false` it throws `error`, which is the ORIGINAL failure so the
+ * operator keeps the real reason (a wrapper would hide the server text).
+ */
+export async function recoverFromContextLimit(deps, original) {
+    const { recover, maxRetries, attempt, notice, t, keys, provider } = deps;
+    const giveUp = () => {
+        notice(t(keys.giveUp, { provider }));
+        return { resend: false, error: original };
+    };
+    if (!recover || attempt > maxRetries)
+        return giveUp();
+    notice(t(keys.compact, { provider }));
+    let recovered = false;
+    try {
+        recovered = await recover();
+    }
+    catch (e) {
+        notice(t(keys.compactFailed, { error: e.message }));
+    }
+    if (!recovered)
+        return giveUp();
+    return { resend: true };
+}

package/dist/deepseek-ui.js

@@ -243,6 +243,16 @@ export const RATE_LIMIT_RE = /(messages? too frequent|too many requests|rate lim
 // rate limit, these usually clear in seconds, so we retry quickly instead of
 // waiting minutes.
 export const SERVER_BUSY_RE = /(server (is )?busy|server error|service (is )?unavailable|temporarily unavailable|internal server error|502|503|504|server overloaded|сервер занят|сервер перегружен|сервис недоступен|внутренняя ошибка|попробуйте позже)/i;
+// The chat's CONTEXT WINDOW is exhausted. DeepSeek refuses to continue the
+// conversation and answers with a non-retryable notice instead of a model
+// turn: "Length limit reached. Please start a new chat." (the Russian UI:
+// «Достигнут лимит длины» / «начните новый чат»). Retrying the same send can
+// never succeed and every such attempt burned the askRetries budget, after
+// which the agent stopped with a bare error — the operator had to notice the
+// notice in the chat by hand. The only way out is compaction (a NEW chat with
+// a handover summary), so this must be its own error class, not a rate limit
+// or a server hiccup.
+export const CONTEXT_LIMIT_RE = /(length limit (?:has been )?reached|context (?:window|length) (?:is )?(?:exceeded|full)|maximum context|start a new (?:chat|conversation)|достигнут лимит длин|лимит длин[ыа] (?:достигнут|исчерпан)|начните новый чат|начните нов(ый|ую) (диалог|бесед))/i;
 // ---------- network protocol (SSE) ----------
 export const GENERATION_ERR_RE = /"finish_reason":\s*"generation_err"/i;
 // The server gave up on the turn ("Server busy, please try again later."):

package/dist/glm-browser.js

@@ -21,6 +21,7 @@ import os from 'os';
 import { chromium } from 'playwright';
 import { translate, DEFAULT_LOCALE } from './i18n.js';
 import { rewriteFailedAttachments } from './commands.js';
+import { recoverFromContextLimit } from './context-limit.js';
 import { awaitUploadPreview, readAttachBuffers } from './attach-flow.js';
 import { theme } from './theme.js';
 import { scrapeGlmChatList, scrapeGlmChatMessages, parseGlmChatList, parseGlmHistory, } from './glm-chats.js';
@@ -28,7 +29,7 @@ import { cleanAnswer, headlessEngineKey, readCachedHeadlessUA, writeCachedHeadle
 import { readLastAnswerInDom, readPageToastsInDom, readUserAgentInDom, readInputTrimmedTextInDom, isElementEnabledInDom, setBusyTitleInDom, chatSignalInDom, } from './browser-dom.js';
 import { probeUiHealth, } from './ui-health.js';
 import { CHAT_URL, LOGIN_URL, CHAT_ID_RE, chatUrl, INPUT_SELECTORS, UPLOAD_BUTTON_SELECTOR, SEND_SELECTORS, STOP_SELECTORS, STOP_NAME_RE, NEW_CHAT_SELECTOR, MODELS_URL, MODEL_TRIGGER_SELECTOR, modelIdFromTriggerId, CHAT_LIST_URL, chatHistoryUrl, AUTH_URL, ANSWER_URL_RE, ANSWER_SELECTORS, THINK_CLASS_RE, MESSAGE_CONTAINER_SELECTORS, USER_CLASS_RE, CHAT_SIGNAL_NODES_SELECTOR, MARKDOWN_SELECTOR, } from './glm-ui.js';
-import { extractAnswer, extractTokenUsage, isFinishedWithoutAnswer, isRateLimitText, isQuotaExhaustedText, isServerBusyText, isGuestLimitText, isCaptchaText, extractChatId, } from './glm-net-capture.js';
+import { extractAnswer, extractTokenUsage, isFinishedWithoutAnswer, isRateLimitText, isQuotaExhaustedText, isServerBusyText, isGuestLimitText, isContextLimitText, isCaptchaText, extractChatId, } from './glm-net-capture.js';
 import { SendRuntime } from './send-runtime.js';
 import { readGlmBodyFeatures, unsafeGlmModes, glmFlagsMismatch, } from './glm-flags.js';
 import { interactiveBrowserLogin, loginIsInteractive, canShowWindow, } from './browser-login.js';
@@ -56,6 +57,9 @@ export class GlmBrowser {
     serverBusyWaitMs;
     maxIncompleteRetries;
     incompleteWaitMs;
+    // Ask() budget for the context-limit recovery (a compaction, not a resend).
+    maxContextLimitRetries;
+    onContextLimit;
     startWaitMs;
     sendButtonWaitMs;
     model;
@@ -81,6 +85,9 @@ export class GlmBrowser {
     _netRateLimited;
     _netGuestLimit;
     _netServerBusy;
+    // True when the chat context window is exhausted: it refuses every
+    // further send, so ask() must compact into a fresh chat, not retry here.
+    _netContextLimit;
     _netCaptcha;
     _netChatId;
     _lastTokenUsage;
@@ -112,7 +119,7 @@ export class GlmBrowser {
      * removes most of the wait. Empty = leave the site's default.
      */
     reasoningEffort;
-    constructor({ headless = false, debug = false, channel = null, answerTimeoutMs = 300000, askRetries = 3, stabilityChecks = 2, stabilityDelayMs = 400, minSendIntervalMs = 0, rateLimitWaitMs = 300000, maxRateLimitRetries = 6, maxServerBusyRetries = 5, serverBusyWaitMs = 3000, maxIncompleteRetries = 4, incompleteWaitMs = 2000, startWaitMs = 30000, sendButtonWaitMs = 8000, model = '', deepThinking = false, webSearch = false, auth, locale, onAuthSave, onLoginPrompt, disableAgentRuntime = true, reasoningEffort = 'low', sendTelemetry = true, logsDir, loginTimeoutMs = 600000, userAgent, } = {}) {
+    constructor({ headless = false, debug = false, channel = null, answerTimeoutMs = 300000, askRetries = 3, stabilityChecks = 2, stabilityDelayMs = 400, minSendIntervalMs = 0, rateLimitWaitMs = 300000, maxRateLimitRetries = 6, maxServerBusyRetries = 5, serverBusyWaitMs = 3000, maxIncompleteRetries = 4, incompleteWaitMs = 2000, maxContextLimitRetries = 1, onContextLimit, startWaitMs = 30000, sendButtonWaitMs = 8000, model = '', deepThinking = false, webSearch = false, auth, locale, onAuthSave, onLoginPrompt, disableAgentRuntime = true, reasoningEffort = 'low', sendTelemetry = true, logsDir, loginTimeoutMs = 600000, userAgent, } = {}) {
         this.headless = headless;
         this.debug = debug;
         this.channel = channel;
@@ -127,6 +134,8 @@ export class GlmBrowser {
         this.serverBusyWaitMs = serverBusyWaitMs;
         this.maxIncompleteRetries = maxIncompleteRetries;
         this.incompleteWaitMs = incompleteWaitMs;
+        this.maxContextLimitRetries = maxContextLimitRetries;
+        this.onContextLimit = onContextLimit || null;
         this.startWaitMs = startWaitMs;
         this.sendButtonWaitMs = sendButtonWaitMs;
         this.model = model;
@@ -157,6 +166,7 @@ export class GlmBrowser {
         this._netRateLimited = false;
         this._netGuestLimit = false;
         this._netServerBusy = false;
+        this._netContextLimit = false;
         this._netCaptcha = false;
         this._netChatId = null;
         this._lastTokenUsage = null;
@@ -838,6 +848,10 @@ export class GlmBrowser {
                 if (isServerBusyText(body)) {
                     this._netServerBusy = true;
                 }
+                if (isContextLimitText(body)) {
+                    this._netContextLimit = true;
+                    this._netCapture = '';
+                }
                 this._netCaptureAt = Date.now();
             }
         }
@@ -1364,6 +1378,9 @@ export class GlmBrowser {
         let rateLimitRetries = 0;
         let serverBusyRetries = 0;
         let incompleteRetries = 0;
+        // The exhausted-context recovery is a COMPACTION (a new chat), not a
+        // resend, so it has its own budget.
+        let contextLimitRetries = 0;
         this._askInFlight++;
         try {
             while (attempt < this.askRetries) {
@@ -1390,6 +1407,28 @@ export class GlmBrowser {
                         this.sendRuntime.onOutcome('rate_limit', { errorText: 'quota' });
                         throw new Error(this._t('glm.quota_exhausted'));
                     }
+                    // Checked BEFORE the rate-limit/captcha branches below: those
+                    // retry IN PLACE, which an exhausted chat can never accept.
+                    if (e instanceof GlmContextLimitError) {
+                        contextLimitRetries++;
+                        const res = await recoverFromContextLimit({
+                            recover: () => this.onContextLimit?.() ?? Promise.resolve(false),
+                            maxRetries: this.maxContextLimitRetries,
+                            attempt: contextLimitRetries,
+                            notice: (text) => this._notice(text),
+                            t: (k, p) => this._t(k, p),
+                            keys: {
+                                compact: 'glm.context_limit_compact',
+                                compactFailed: 'glm.context_limit_compact_failed',
+                                giveUp: 'glm.context_limit_give_up',
+                            },
+                            provider: 'GLM',
+                        }, e);
+                        if (!res.resend)
+                            throw res.error || e;
+                        this._lastSentAt = Date.now();
+                        continue;
+                    }
                     if (e instanceof GlmCaptchaError) {
                         this.sendRuntime.onOutcome('guest_limit', { errorText: 'captcha' });
                         throw new Error(this._t('glm.captcha'));
@@ -1573,6 +1612,7 @@ export class GlmBrowser {
         this._netRateLimited = false;
         this._netGuestLimit = false;
         this._netServerBusy = false;
+        this._netContextLimit = false;
         this._netCaptcha = false;
         this._netBody = '';
         await this._applyToggles();
@@ -1656,6 +1696,9 @@ export class GlmBrowser {
             if (isRateLimitText(pageText)) {
                 throw new GlmRateLimitError(pageText.slice(0, 300));
             }
+            if (this._netContextLimit && this._netCaptureAt >= this._lastSentAt) {
+                throw new GlmContextLimitError(this._netBody.slice(0, 300));
+            }
             if (this._netCaptcha && this._netCaptureAt >= this._lastSentAt) {
                 throw new GlmCaptchaError(this._netBody.slice(0, 200));
             }
@@ -1691,6 +1734,9 @@ export class GlmBrowser {
             if (isRateLimitText(pageText)) {
                 throw new GlmRateLimitError(pageText.slice(0, 300));
             }
+            if (this._netContextLimit && this._netCaptureAt >= this._lastSentAt) {
+                throw new GlmContextLimitError(this._netBody.slice(0, 300));
+            }
             if (this._netCaptcha && this._netCaptureAt >= this._lastSentAt) {
                 throw new GlmCaptchaError(this._netBody.slice(0, 200));
             }
@@ -1756,6 +1802,14 @@ class GlmCaptchaError extends Error {
         this.name = 'GlmCaptchaError';
     }
 }
+// The chat context window is exhausted and the turn was refused. NOT
+// retryable in place: ask() compacts into a fresh chat and resends there.
+class GlmContextLimitError extends Error {
+    constructor(detail) {
+        super('context limit: ' + detail);
+        this.name = 'GlmContextLimitError';
+    }
+}
 class GlmIncompleteError extends Error {
     constructor(detail) {
         super('generation incomplete: ' + detail);

package/dist/glm-net-capture.js

@@ -345,3 +345,23 @@ export function extractChatId(body) {
     const m2 = b.match(/"id"\s*:\s*"([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})"/i);
     return m2 ? m2[1] : null;
 }
+/**
+ * True when the RAW body says the chat's CONTEXT WINDOW is exhausted - the
+ * same hard failure as DeepSeek's length limit: every further send into that
+ * chat is refused, so the only recovery is a compaction into a fresh chat.
+ *
+ * Same guard as the other z.ai classifiers: the notice must be an ERROR
+ * payload (or carry no answer text). The model can legitimately WRITE about
+ * context limits, and treating such an answer as a refusal loses a good turn.
+ */
+export function isContextLimitText(body) {
+    const b = String(body || '');
+    if (!b)
+        return false;
+    const explicit = /context (?:length|window) (?:is )?(?:exceeded|too long|limit)|maximum context length|exceeds? the (?:maximum |model'?s )?context|too many (?:input )?tokens|length limit (?:has been )?reached|start a new (?:chat|conversation)|лимит длин|превышен[ао]? (?:максимальн[аяу]? )?(?:длина|контекст)|начните новый чат/i.test(b);
+    if (!explicit)
+        return false;
+    if (!ERROR_PAYLOAD_RE.test(b) && hasAnswerContent(b))
+        return false;
+    return true;
+}

package/dist/i18n/deepseek.js

@@ -56,6 +56,18 @@ export const deepseekMessages = {
         ru: '✖ Не удалось получить ответ от {provider} после {max} попыток: {error}',
         en: '✖ Could not get an answer from {provider} after {max} attempts: {error}',
     },
+    'ds.context_limit_compact': {
+        ru: '🗜️ {provider}: лимит длины чата исчерпан («Length limit reached») — сжимаю историю и продолжаю в новом чате...',
+        en: '🗜️ {provider}: the chat hit its length limit ("Length limit reached") — compacting the history and continuing in a fresh chat...',
+    },
+    'ds.context_limit_compact_failed': {
+        ru: '⚠ Не удалось сжать историю: {error}',
+        en: '⚠ Could not compact the history: {error}',
+    },
+    'ds.context_limit_give_up': {
+        ru: '✖ {provider}: лимит длины чата исчерпан, и сжать историю не удалось — этот чат больше не принимает сообщения. Открой новый чат (/new) и повтори задачу.',
+        en: '✖ {provider}: the chat length limit is reached and the history could not be compacted — this chat no longer accepts messages. Open a new chat (/new) and repeat the task.',
+    },
     'ds.input_missing': {
         ru: '✖ Не найдено поле ввода на странице {provider}. Запусти /debug-dom и поправь INPUT_SELECTORS.',
         en: '✖ The {provider} input field was not found. Run /debug-dom and fix INPUT_SELECTORS.',

package/dist/i18n/glm.js

@@ -43,6 +43,18 @@ export const glmMessages = {
         ru: '⚠ Отправка не удалась (попытка {attempt}/{max} на этот запрос): {error} — повторяю...',
         en: '⚠ Send failed (attempt {attempt}/{max} for this request): {error} — retrying...',
     },
+    'glm.context_limit_compact': {
+        ru: '🗜️ {provider}: лимит длины чата исчерпан — сжимаю историю и продолжаю в новом чате...',
+        en: '🗜️ {provider}: the chat hit its context limit — compacting the history and continuing in a fresh chat...',
+    },
+    'glm.context_limit_compact_failed': {
+        ru: '⚠ Не удалось сжать историю: {error}',
+        en: '⚠ Could not compact the history: {error}',
+    },
+    'glm.context_limit_give_up': {
+        ru: '✖ {provider}: лимит длины чата исчерпан, и сжать историю не удалось. Открой новый чат (/new) и повтори задачу.',
+        en: '✖ {provider}: the chat context limit is reached and the history could not be compacted. Open a new chat (/new) and repeat the task.',
+    },
     'glm.ask_failed': {
         ru: '✖ Не удалось получить ответ от {provider} после {max} попыток: {error}',
         en: '✖ Could not get an answer from {provider} after {max} attempts: {error}',

package/dist/i18n/qwen.js

@@ -145,6 +145,18 @@ export const qwenMessages = {
         ru: '⚠ Отправка не удалась (попытка {attempt}/{max} на этот запрос): {error} — повторяю...',
         en: '⚠ Send failed (attempt {attempt}/{max} for this request): {error} — retrying...',
     },
+    'qwen.context_limit_compact': {
+        ru: '🗜️ {provider}: лимит длины чата исчерпан — сжимаю историю и продолжаю в новом чате...',
+        en: '🗜️ {provider}: the chat hit its context limit — compacting the history and continuing in a fresh chat...',
+    },
+    'qwen.context_limit_compact_failed': {
+        ru: '⚠ Не удалось сжать историю: {error}',
+        en: '⚠ Could not compact the history: {error}',
+    },
+    'qwen.context_limit_give_up': {
+        ru: '✖ {provider}: лимит длины чата исчерпан, и сжать историю не удалось. Открой новый чат (/new) и повтори задачу.',
+        en: '✖ {provider}: the chat context limit is reached and the history could not be compacted. Open a new chat (/new) and repeat the task.',
+    },
     'qwen.ask_failed': {
         ru: '✖ Не удалось получить ответ от {provider} после {max} попыток: {error}',
         en: '✖ Could not get an answer from {provider} after {max} attempts: {error}',

package/dist/index.js

@@ -797,7 +797,7 @@ function applyModelContextLimit(model) {
  * the choice is a class, not a flag; the shared timings live in
  * config.browser and only the provider's own section is overridden.
  */
-function createProviderBrowser(provider) {
+function createProviderBrowser(provider, onContextLimit = null) {
     // Saved credentials go into the ACTIVE provider's section: browser.auth
     // belongs to DeepSeek (so old configs keep working), qwen.auth / glm.auth
     // are their own. Sharing one pair meant a DeepSeek login was typed into the
@@ -840,6 +840,7 @@ function createProviderBrowser(provider) {
                 loginTimeoutMs: config.browser.loginTimeoutMs,
                 locale: currentLocale,
                 onAuthSave: persistAuth,
+                onContextLimit,
             });
         case 'glm':
             return new GlmBrowser({
@@ -860,6 +861,7 @@ function createProviderBrowser(provider) {
                 loginTimeoutMs: config.browser.loginTimeoutMs,
                 locale: currentLocale,
                 onAuthSave: persistAuth,
+                onContextLimit,
             });
         case 'deepseek':
         default:
@@ -870,6 +872,7 @@ function createProviderBrowser(provider) {
                 ...config.browser,
                 locale: currentLocale,
                 onAuthSave: persistAuth,
+                onContextLimit,
             });
     }
 }
@@ -1061,7 +1064,15 @@ async function main() {
     // `let`, not `const`: a live /provider switch disposes this instance and
     // builds the other one IN PLACE (see the /provider block in the main loop),
     // so the URL changes without restarting zames.
-    let browser = createProviderBrowser(asProviderId(config.provider));
+    // The context-limit recovery is a closure over main() session state, but
+    // the browser is built BEFORE that state exists and it needs the callback
+    // at construction. This holder breaks the cycle: the factory reads it
+    // lazily on every recovery, and it is filled right after the session
+    // variables are set up (before the first task). Null = the provider fails
+    // with a clear message instead of retrying into a dead chat.
+    let contextLimitRecovery = null;
+    const onContextLimit = () => contextLimitRecovery ? contextLimitRecovery() : Promise.resolve(false);
+    let browser = createProviderBrowser(asProviderId(config.provider), onContextLimit);
     const bootSpinner = mod.createSpinner(currentLocale);
     bootSpinner.thinking();
     try {
@@ -1188,6 +1199,44 @@ async function main() {
     }
     let freshChatNext = true;
     let sendSystemPromptNext = true;
+    /**
+     * Recover from "Length limit reached. Please start a new chat.": the chat
+     * refuses EVERY further send, so the only way to keep working is compaction
+     * into a fresh chat. Returns true when a new chat holds the system prompt
+     * and the handover, i.e. the browser may resend the refused message there.
+     *
+     * `contextExhausted` skips the summary call inside performCompact: asking the
+     * OLD chat to summarize itself is refused exactly like the send that failed,
+     * so the summary is built from the history endpoint instead.
+     */
+    const recoverFromContextLimit = async () => {
+        const res = await performCompact({
+            browser,
+            currentChatId,
+            workdir: currentWorkdir,
+            locale: currentLocale,
+            transcript,
+            ui: editor,
+            buildSystemPrompt: mod.buildSystemPrompt,
+            tools: mod.createTools(currentWorkdir, { undo, todos: todoStore }),
+            answerTimeoutMs: providerAnswerTimeoutMs(),
+            quiet: true,
+            skipUiLock: true,
+            selfImprovement: devMode,
+            contextExhausted: true,
+        });
+        if (!res.ok)
+            return false;
+        currentChatId = res.chatId;
+        if (currentChatId)
+            saveLastChat(currentChatId, currentWorkdir);
+        // The fresh chat already carries the system prompt and the handover, and
+        // the session continues in it — later tasks must not open yet another chat.
+        freshChatNext = false;
+        sendSystemPromptNext = false;
+        return true;
+    };
+    contextLimitRecovery = recoverFromContextLimit;
     // Resuming an existing chat already has the system-prompt at its start, so
     // resending it is wasteful and pollutes the context. Default: do NOT resend.
     // `--resend-prompt` or `browser.resendPromptOnResume` forces it (e.g. when
@@ -2688,7 +2737,7 @@ async function main() {
                     // If we closed the old browser before the new one launched and the
                     // launch failed, `browser` would point at a dead instance and every
                     // later command would break.
-                    const nextBrowser = createProviderBrowser(arg);
+                    const nextBrowser = createProviderBrowser(arg, onContextLimit);
                     // Wire the Ink login BEFORE waitForLogin(), or the new backend would
                     // fall back to readline and pause the TUI for its sign-in.
                     wireLoginCallbacks(nextBrowser);
@@ -4144,6 +4193,7 @@ async function main() {
                         return res.ok ? res.chatId : null;
                     }
                     : null,
+                onContextLimit: recoverFromContextLimit,
                 autoCompactPct: config.browser.autoCompactPct,
                 contextLimit: effectiveContextLimit(),
                 getTokenUsage: () => browser.getLastTokenUsage(),

package/dist/qwen-browser.js

@@ -24,12 +24,13 @@ import { rewriteFailedAttachments } from './commands.js';
 import { interactiveBrowserLogin, loginIsInteractive, canShowWindow, } from './browser-login.js';
 import { awaitUploadPreview, readAttachBuffers } from './attach-flow.js';
 import { theme } from './theme.js';
+import { recoverFromContextLimit } from './context-limit.js';
 import { scrapeQwenChatList, scrapeQwenChatMessages, parseQwenChatList, parseQwenHistory, } from './qwen-chats.js';
 import { cleanAnswer, headlessEngineKey, readCachedHeadlessUA, writeCachedHeadlessUA, sanitizeHeadlessUA, cleanSingletonFiles, profileLooksLocked, nukeProfile, writeAuthMarker, } from './browser-pure.js';
 import { chatSignalInDom, dumpDomCountsInDom, isElementEnabledInDom, readInputTrimmedTextInDom, readLastAnswerInDom, readPageToastsInDom, readUserAgentInDom, setBusyTitleInDom, clickStopInDom, stopButtonVisibleInDom, } from './browser-dom.js';
 import { probeUiHealth, } from './ui-health.js';
 import { CHAT_URL, CHAT_ID_RE, chatUrl, INPUT_SELECTORS, SEND_SELECTORS, STOP_SELECTORS, STOP_NAME_RE, NEW_CHAT_SELECTOR, MODEL_TRIGGER_SELECTOR, MODELS_URL, CHAT_LIST_URL, chatHistoryUrl, AGE_GATE_MODAL, AGE_GATE_CONTINUE, AGE_GATE_YEAR_SELECT, AGE_GATE_YEAR_OPTION, COOKIE_ACCEPT_RE, ATTACH_SELECTORS, ATTACH_MENU_TRIGGER, ATTACH_MENU_ITEM_RE, THINKING_SELECTOR, THINKING_MODE_RE, FAST_MODE_RE, WEB_SEARCH_MENU_RE, ANSWER_SELECTORS, THINK_CLASS_RE, MESSAGE_CONTAINER_SELECTORS, ASSISTANT_CLASS_RE, CHAT_SIGNAL_NODES_SELECTOR, MARKDOWN_SELECTOR, TOGGLE_SELECTORS, } from './qwen-ui.js';
-import { extractAnswer, extractTokenUsage, isFinishedWithoutAnswer, isRateLimitText, isGuestLimitText, isServerBusyText, } from './qwen-net-capture.js';
+import { extractAnswer, extractTokenUsage, isFinishedWithoutAnswer, isRateLimitText, isGuestLimitText, isContextLimitText, isServerBusyText, } from './qwen-net-capture.js';
 // A SEPARATE profile from DeepSeek's ~/.zames/profile. Two persistent Chromium
 // contexts on ONE --user-data-dir cannot coexist (SingletonLock), and keeping
 // Qwen's cookies apart also means switching providers never logs the other
@@ -104,6 +105,10 @@ export class QwenBrowser {
     // body is the reliable signal. ask() then backs off instead of waiting out
     // the whole answer deadline.
     _netServerBusy;
+    // True when the chat's CONTEXT WINDOW is exhausted. The chat refuses every
+    // further send, so this is NOT retryable in place: the caller compacts into
+    // a fresh chat (onContextLimit) and ask() resends there.
+    _netContextLimit;
     _netChatId;
     _lastTokenUsage;
     _toggles;
@@ -126,7 +131,12 @@ export class QwenBrowser {
     loginTimeoutMs;
     _windowClosed;
     _carryCookies;
-    constructor({ headless = false, debug = false, channel = null, answerTimeoutMs = 180000, askRetries = 3, stabilityChecks = 2, stabilityDelayMs = 400, minSendIntervalMs = 15000, rateLimitWaitMs = 300000, maxRateLimitRetries = 6, maxServerBusyRetries = 5, serverBusyWaitMs = 3000, maxIncompleteRetries = 4, incompleteWaitMs = 2000, startWaitMs = 30000, sendButtonWaitMs = 8000, model = '', deepThinking = false, webSearch = true, auth, locale, onAuthSave, onLoginPrompt, loginTimeoutMs = 600000, userAgent, } = {}) {
+    // Ask() budget for the context-limit recovery. A compaction that frees
+    // nothing leaves the chat just as rejected, so this is independent of
+    // askRetries.
+    maxContextLimitRetries;
+    onContextLimit;
+    constructor({ headless = false, debug = false, channel = null, answerTimeoutMs = 180000, askRetries = 3, stabilityChecks = 2, stabilityDelayMs = 400, minSendIntervalMs = 15000, rateLimitWaitMs = 300000, maxRateLimitRetries = 6, maxServerBusyRetries = 5, serverBusyWaitMs = 3000, maxIncompleteRetries = 4, incompleteWaitMs = 2000, maxContextLimitRetries = 1, onContextLimit, startWaitMs = 30000, sendButtonWaitMs = 8000, model = '', deepThinking = false, webSearch = true, auth, locale, onAuthSave, onLoginPrompt, loginTimeoutMs = 600000, userAgent, } = {}) {
         this.headless = headless;
         this.debug = debug;
         this.channel = channel;
@@ -141,6 +151,8 @@ export class QwenBrowser {
         this.serverBusyWaitMs = serverBusyWaitMs;
         this.maxIncompleteRetries = maxIncompleteRetries;
         this.incompleteWaitMs = incompleteWaitMs;
+        this.maxContextLimitRetries = maxContextLimitRetries;
+        this.onContextLimit = onContextLimit || null;
         this.startWaitMs = startWaitMs;
         this.sendButtonWaitMs = sendButtonWaitMs;
         this.model = model;
@@ -167,6 +179,7 @@ export class QwenBrowser {
         this._netRateLimited = false;
         this._netGuestLimit = false;
         this._netServerBusy = false;
+        this._netContextLimit = false;
         this._netChatId = null;
         this._lastTokenUsage = null;
         this._toggles = { deepThinking, webSearch };
@@ -455,6 +468,10 @@ export class QwenBrowser {
                     this._netNoAnswer = true;
                     this._netCapture = '';
                 }
+                if (isContextLimitText(body)) {
+                    this._netContextLimit = true;
+                    this._netCapture = '';
+                }
                 if (isRateLimitText(body)) {
                     this._netRateLimited = true;
                     this._netCapture = '';
@@ -1604,6 +1621,9 @@ export class QwenBrowser {
         let rateLimitRetries = 0;
         let serverBusyRetries = 0;
         let incompleteRetries = 0;
+        // The exhausted-context recovery is a COMPACTION (a new chat), not a
+        // resend, so it has its own budget.
+        let contextLimitRetries = 0;
         this._askInFlight++;
         try {
             while (attempt < this.askRetries) {
@@ -1631,6 +1651,32 @@ export class QwenBrowser {
                         // clear "sign in" message instead of burning the retry budget.
                         throw new Error(this._t('qwen.age_gate_block'));
                     }
+                    // The chat ran out of context: it refuses every further send, so
+                    // resending in place can never succeed. The injected callback
+                    // compacts the chat into a fresh one and the SAME prompt is
+                    // resent there.
+                    if (e instanceof QwenContextLimitError) {
+                        contextLimitRetries++;
+                        const res = await recoverFromContextLimit({
+                            recover: () => this.onContextLimit?.() ?? Promise.resolve(false),
+                            maxRetries: this.maxContextLimitRetries,
+                            attempt: contextLimitRetries,
+                            notice: (text) => this._notice(text),
+                            t: (k, p) => this._t(k, p),
+                            keys: {
+                                compact: 'qwen.context_limit_compact',
+                                compactFailed: 'qwen.context_limit_compact_failed',
+                                giveUp: 'qwen.context_limit_give_up',
+                            },
+                            provider: 'Qwen',
+                        }, e);
+                        if (!res.resend)
+                            throw res.error || e;
+                        // The compaction already typed into the new chat, so the send
+                        // throttle must count from that moment.
+                        this._lastSentAt = Date.now();
+                        continue;
+                    }
                     if (/rate limit|too frequent/i.test(msg)) {
                         if (rateLimitRetries >= this.maxRateLimitRetries)
                             break;
@@ -1830,6 +1876,7 @@ export class QwenBrowser {
         this._netRateLimited = false;
         this._netGuestLimit = false;
         this._netServerBusy = false;
+        this._netContextLimit = false;
         this._netBody = '';
         await this._applyToggles();
         if (attachments.length) {
@@ -1937,6 +1984,9 @@ export class QwenBrowser {
             if (isRateLimitText(pageText)) {
                 throw new QwenRateLimitError(pageText.slice(0, 300));
             }
+            if (this._netContextLimit && this._netCaptureAt >= this._lastSentAt) {
+                throw new QwenContextLimitError(this._netBody.slice(0, 300));
+            }
             if (this._netGuestLimit && this._netCaptureAt >= this._lastSentAt) {
                 throw new QwenGuestLimitError(this._netBody.slice(0, 200));
             }
@@ -1971,6 +2021,9 @@ export class QwenBrowser {
             if (isRateLimitText(pageText)) {
                 throw new QwenRateLimitError(pageText.slice(0, 300));
             }
+            if (this._netContextLimit && this._netCaptureAt >= this._lastSentAt) {
+                throw new QwenContextLimitError(this._netBody.slice(0, 300));
+            }
             if (this._netGuestLimit && this._netCaptureAt >= this._lastSentAt) {
                 throw new QwenGuestLimitError(this._netBody.slice(0, 200));
             }
@@ -2033,6 +2086,14 @@ class QwenAgeGateError extends Error {
         this.name = 'QwenAgeGateError';
     }
 }
+// The chat hit its CONTEXT LIMIT and refuses the turn. NOT retryable in
+// place: ask() compacts into a fresh chat and resends the prompt there.
+class QwenContextLimitError extends Error {
+    constructor(detail) {
+        super('context limit: ' + detail);
+        this.name = 'QwenContextLimitError';
+    }
+}
 class QwenIncompleteError extends Error {
     constructor(detail) {
         super('generation incomplete: ' + detail);

package/dist/qwen-net-capture.js

@@ -283,3 +283,21 @@ export function isServerBusyText(body) {
         return false;
     return /server is busy|service unavailable|try again later/i.test(b);
 }
+// The chat's CONTEXT WINDOW is exhausted. Qwen refuses the turn and no retry
+// in the same chat can succeed - the only way out is a compaction into a
+// fresh chat. Same guard as the other classifiers: the notice must be an
+// error payload or a body with NO answer content, because the model can
+// legitimately WRITE about context limits and treating that answer as a
+// refusal would lose a good turn.
+export function isContextLimitText(body) {
+    const b = String(body || '');
+    if (!b)
+        return false;
+    const explicit = /context (?:length|window) (?:is )?(?:exceeded|too long|limit)|maximum context length|exceeds? the (?:maximum |model'?s )?context|too many (?:input )?tokens|length limit (?:has been )?reached|start a new (?:chat|conversation)|лимит длин|превышен[ао]? (?:максимальн[аяу]? )?(?:длина|контекст)|начните новый чат/i.test(b);
+    if (!explicit)
+        return false;
+    const errNotice = /event:\s*error|"type"\s*:\s*"error"|"error"\s*:/i.test(b);
+    if (!errNotice && hasAnswerContent(b))
+        return false;
+    return true;
+}

package/dist/run-task.js

@@ -284,7 +284,7 @@ async function evaluateGoal(browser, condition, config, transcript) {
 }
 export async function runTask(deps, browser, tools, taskText, workdir, opts, attachments = []) {
     const { t, locale, debug, maxIter, config, runAgentLoop, createSpinner } = deps;
-    const { transcript, freshChat, sendSystemPrompt, queue = [], ui: editor, onChatReady, onAutoCompact = null, autoCompactPct = 95, contextLimit = 1_000_000, getTokenUsage = null, goal = null, goalIsCondition = false, onGoalCleared = null, goalMaxTurns = GOAL_MAX_TURNS, goalQuery = null, todosQuery = null, selfImprovement = false, onSubagent = null, onAskUser = undefined, } = opts;
+    const { transcript, freshChat, sendSystemPrompt, queue = [], ui: editor, onChatReady, onAutoCompact = null, onContextLimit = null, autoCompactPct = 95, contextLimit = 1_000_000, getTokenUsage = null, goal = null, goalIsCondition = false, onGoalCleared = null, goalMaxTurns = GOAL_MAX_TURNS, goalQuery = null, todosQuery = null, selfImprovement = false, onSubagent = null, onAskUser = undefined, } = opts;
     // The ACTIVE goal for the duration of this run. It is mutable because a
     // completion goal can be cleared mid-run (verdict MET/IMPOSSIBLE, or the
     // operator runs `/goal clear` while the task is in flight). `goalQuery`
@@ -411,6 +411,7 @@ export async function runTask(deps, browser, tools, taskText, workdir, opts, att
                 // outer currentChatId; it serializes with the throttle because the
                 // loop awaits it.
                 onAutoCompact,
+                onContextLimit,
                 autoCompactPct,
                 contextLimit,
                 getTokenUsage,

package/dist/shell.js

@@ -105,6 +105,16 @@ export function runShell(workdir, command, timeout = 30_000, signal) {
     const safeTimeout = typeof timeout === 'number' && Number.isFinite(timeout) && timeout >= 0
         ? Math.floor(timeout)
         : 30_000;
+    // An EMPTY command is rejected by exec SYNCHRONOUSLY
+    // (`ERR_INVALID_ARG_VALUE: The argument 'file' cannot be empty`), so the
+    // throw escaped the promise below and the caller crashed instead of
+    // reporting the problem: the Bash tool after req() accepted a
+    // whitespace-only command, and the operator's `!` escape never passed
+    // through req() at all. Answer with the same wording an empty successful
+    // run uses, so every caller just prints it.
+    if (!String(command ?? '').trim()) {
+        return Promise.resolve('(command produced no output)');
+    }
     return new Promise((resolve) => {
         const options = {
             cwd: workdir,

package/dist/tui/FullScreenApp.js

@@ -12,7 +12,7 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useSyncExternalStore } from 'react';
 import { Box, Text, useWindowSize, useInput } from 'ink';
 import { LogList } from './LogView.js';
-import { windowByRows, totalRows } from './log-window.js';
+import { windowByRows, totalRows, entryRows } from './log-window.js';
 import { StatusBar } from './StatusBar.js';
 import { InputLine } from './InputLine.js';
 import { contentWidth } from '../width.js';
@@ -75,10 +75,22 @@ export function FullScreenApp({ store, inputProps, }) {
     // it half empty. `scroll` is measured in ROWS here (0 = newest at the
     // bottom).
     const all = state.log;
+    // The viewport height is RESERVED with the floor (never more rows than the
+    // pane can hold) and the box is allowed to take the slack: rounding the
+    // reservation UP on every entry made the panel taller than the terminal on a
+    // short window, so the input rows fell below the last screen row and the
+    // caret drifted under the box while a long multi-line buffer was typed.
+    const totalFloor = totalRows(all, cols, 'floor');
     const total = totalRows(all, cols);
     const maxScroll = Math.max(0, total - logHeight);
     const scroll = Math.max(0, Math.min(state.scroll, maxScroll));
     const visible = windowByRows(all, logHeight, scroll, cols);
+    // Rows the WINDOWED content really needs. The reservation above rounds DOWN
+    // per entry (floor), so the difference is the slack the content needs. The
+    // box takes at most `logHeight` and at least one row; never more, because
+    // that is exactly what pushed the input rows off a short screen.
+    const filledRows = visible.reduce((n, e) => n + entryRows(e, cols), 0);
+    const logBoxHeight = Math.max(1, Math.min(logHeight, Math.max(filledRows, 1)));
     // Scroll the log with PgUp/PgDn; Home/End jump to the very top/bottom. The
     // input line OWNS Home/End while its buffer is non-empty (they move the
     // caret), so the jump only applies to an EMPTY buffer — which is exactly
@@ -111,9 +123,17 @@ export function FullScreenApp({ store, inputProps, }) {
         const next = cur + delta * 3;
         store.set({ scroll: Math.max(0, Math.min(maxScroll, next)) });
     }, state.mouseScroll);
-    return (_jsxs(Box, { flexDirection: "column", height: termRows, children: [_jsx(Header, { store: store }), _jsx(Box, { flexDirection: "column", height: logHeight, overflow: "hidden", justifyContent: "flex-end", children: all.length === 0 ? (_jsx(Text, { color: "#5b616e", children: translate(state.locale)('editor.empty_hint') })) : (_jsx(LogList, { entries: visible })) }), _jsx(StatusBar, { state: state, divider: false }), _jsx(InputLine, { ...inputProps, store: store, 
+    return (_jsxs(Box, { flexDirection: "column", height: termRows, children: [_jsx(Header, { store: store }), _jsx(Box, { flexDirection: "column", flexGrow: 1, flexShrink: 1, minHeight: 1, overflow: "hidden", justifyContent: "flex-end", children: all.length === 0 ? (_jsx(Text, { color: "#5b616e", children: translate(state.locale)('editor.empty_hint') })) : (_jsx(LogList, { entries: visible })) }), _jsx(StatusBar, { state: state, divider: false }), _jsx(InputLine, { ...inputProps, store: store, 
                 // Cursor rows above the input box: header + log viewport + status.
-                cursorTop: HEADER_ROWS + logHeight + suggestRows + STATUS_ROWS + 1, prompt: state.prompt, locale: state.locale, commands: state.commands, locked: state.locked }), _jsx(Text, { color: "#5b616e", wrap: "truncate", children: ' ' +
+                // The log pane is FLEXIBLE now, so the panel below it starts right
+                // after everything above: header + as many log rows as fit + the
+                // suggestion popup + status. `cursorTop` counts the rows ABOVE the
+                // input rows; the box border row is added by InputLine.
+                cursorTop: HEADER_ROWS +
+                    Math.max(1, termRows - panelRows) +
+                    suggestRows +
+                    STATUS_ROWS +
+                    1, prompt: state.prompt, locale: state.locale, commands: state.commands, locked: state.locked }), _jsx(Text, { color: "#5b616e", wrap: "truncate", children: ' ' +
                     translate(state.locale)(state.mouseScroll ? 'editor.keys_hint' : 'editor.keys_hint_select') })] }));
 }
 void contentWidth;

package/dist/tui/log-window.js

@@ -41,21 +41,30 @@ function visWidth(s) {
  * How many terminal rows one log entry occupies at `cols` columns. A line
  * longer than the width wraps (Ink uses hard wrapping for these rows). An
  * empty line still takes one row.
+ *
+ * `floor` gives the UNDER-estimate used to RESERVE the log viewport height;
+ * the exact `ceil` is what the content really renders, so the two together let
+ * the log box take the slack (see FullScreenApp) without ever overflowing —
+ * an overflow is what pushed the input rows below the terminal and left the
+ * caret drifting under the box on a short terminal.
  */
-export function entryRows(entry, cols) {
+export function entryRows(entry, cols, mode = 'exact') {
     const width = Math.max(1, cols);
     const lines = String(entry.text ?? '').split(String.fromCharCode(10));
     let rows = 0;
     for (const line of lines) {
-        rows += Math.max(1, Math.ceil(visWidth(line) / width));
+        const w = visWidth(line);
+        const n = mode === 'floor' ? Math.floor(w / width) : Math.ceil(w / width);
+        rows += Math.max(1, n);
     }
     return Math.max(1, rows);
 }
 /**
  * Slice the log so its RENDERED height fits `height` rows, keeping `scroll`
  * rows hidden from the bottom (0 = pinned to the newest). Returns the visible
- * entries. A single entry taller than the viewport is kept whole (its tail is
- * shown) rather than dropped.
+ * entries. A single entry taller than the viewport is kept whole (its tail
+ * is shown) rather than dropped — the pane is overflow="hidden" with
+ * justifyContent="flex-end", so the TAIL is what stays on screen.
  */
 export function windowByRows(entries, height, scroll, cols) {
     const cap = Math.max(1, Math.floor(height));
@@ -85,9 +94,9 @@ export function windowByRows(entries, height, scroll, cols) {
     return picked;
 }
 /** Total rendered rows of a list of entries (for maxScroll). */
-export function totalRows(entries, cols) {
+export function totalRows(entries, cols, mode = 'exact') {
     let n = 0;
     for (const e of entries)
-        n += entryRows(e, cols);
+        n += entryRows(e, cols, mode);
     return n;
 }

package/package.json

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