zames_pro 2.90.18 → 2.92.0

package/CHANGELOG.md

@@ -7,6 +7,23 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.92.0] - 2026-11-01
+
+### Changed
+
+- Internal improvements.
+
+## [2.91.0] - 2026-11-01
+
+### Added
+
+- **retry:** infinite incremental retries with escalating backoff
+
+### Fixed
+
+- **qwen,glm:** headless login probe and headed runs
+- **ui:** same no-flicker phase rule for qwen and glm
+
 ## [2.90.18] - 2026-10-30
 
 ### Fixed

package/dist/agent-loop.js

@@ -1,3 +1,4 @@
+import { backoffWaitMs } from './retry-backoff.js';
 import { buildSystemPrompt } from './system-prompt.js';
 import { isContextLimitText } from './browser-pure.js';
 import { providerLabel as providerHumanLabel } from './providers.js';
@@ -12,7 +13,7 @@ import { shouldRunDiagnostics, runDiagnostics, } from './diagnostics.js';
 // The tools that WRITE/EDIT a file (and take a `path`). The completion nudge
 // only cares about these — `Bash`/`Git*` in MUTATING_TOOLS are not edits.
 const EDIT_TOOLS = new Set(['Write', 'Edit', 'MultiEdit', 'ApplyPatch']);
-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 = DEFAULT_LOCALE, askDeadlineMs = 240_000, maxAfterToolRetries = 6, onAutoCompact = null, onContextLimit = null, onProviderExhausted = 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 = DEFAULT_LOCALE, askDeadlineMs = 240_000, maxAfterToolRetries = 6, infiniteRetries = true, maxRetryWaitMs = 30 * 60_000, onAutoCompact = null, onContextLimit = null, onProviderExhausted = 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
@@ -292,6 +293,15 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
     // The nudge is sent at most ONCE per task: it is a hint, not a guard.
     let completionNudgeSent = false;
     const MAX_AFTER_TOOL_RETRIES = Math.max(0, Math.floor(maxAfterToolRetries));
+    // The watchdog and the transient send families share ONE backoff
+    // (src/retry-backoff.ts): with infiniteRetries on (default) the wait grows
+    // 5s -> 10s -> ... up to maxRetryWaitMs instead of giving up.
+    const watchdogBackoff = {
+        infiniteRetries,
+        maxRetries: MAX_AFTER_TOOL_RETRIES,
+        baseWaitMs: 5000,
+        maxWaitMs: maxRetryWaitMs,
+    };
     // One-time hint when the context nears full while auto-compact is OFF:
     // the operator is told about /compact instead of silently degrading. Set
     // once per task so the terminal is not spammed.
@@ -384,10 +394,13 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
             // single hiccup from a genuine stall (the budget used to be invisible).
             safeWarning(tr('ds.answer_timeout', {
                 sec: Math.round(askDeadlineMs / 1000),
-                attempt: Math.min(afterToolRetries + 1, MAX_AFTER_TOOL_RETRIES),
-                max: MAX_AFTER_TOOL_RETRIES,
+                attempt: infiniteRetries
+                    ? afterToolRetries + 1
+                    : Math.min(afterToolRetries + 1, MAX_AFTER_TOOL_RETRIES),
+                max: infiniteRetries ? '∞' : MAX_AFTER_TOOL_RETRIES,
             }));
-            if (afterToolRetries < MAX_AFTER_TOOL_RETRIES) {
+            const watchdogWaitMs = backoffWaitMs(watchdogBackoff, afterToolRetries + 1);
+            if (infiniteRetries || afterToolRetries < MAX_AFTER_TOOL_RETRIES) {
                 afterToolRetries++;
                 // The retry used to `continue` with the UNCHANGED `message`: a bare
                 // re-send of the same task text. The model then saw the task arrive a
@@ -401,7 +414,7 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
                         'no text before or after, for example: ' +
                         '{"tool": "Bash", "args": {"command": "..."}}. ' +
                         'If the task is really done — call respond with the final message.';
-                await new Promise((r) => setTimeout(r, 1500));
+                await new Promise((r) => setTimeout(r, watchdogWaitMs));
                 continue;
             }
             transcript?.log('ask_timeout_exhausted', {

package/dist/ask-retry.js

@@ -1,49 +1,10 @@
-// N1 stage 4: the retry POLICY of a provider's `ask()` as a PURE function.
+// N1 stage 4: the retry POLICY of a provider's ask() as a PURE function.
 //
-// The three providers ran the same loop — call `_askOnce`, classify the thrown
-// error into a family (rate limit / server busy / incomplete / context limit /
-// provider-specific fatal), retry that family within its own budget, otherwise
-// fall through to a generic attempt counter — and each copy had its own order
-// of checks and its own wording. The loop itself (sends, throttling, aborts)
-// stays in the browser class; only the DECISION is here, so every branch is
-// unit-tested without a browser.
-/**
- * Decide what to do after a failed attempt.
- *
- * `classify` maps the thrown error to a family; it lives in the provider
- * because the backend-specific markers (guest limit, age gate, captcha) are
- * provider knowledge. A `null` classification falls through to the generic
- * attempt budget.
- */
-export function decideRetry(family, state, budgets, waits) {
-    switch (family) {
-        case 'fatal':
-            return { kind: 'give-up', family };
-        case 'context-limit':
-            if (state.contextLimitRetries >= budgets.maxContextLimitRetries) {
-                return { kind: 'give-up', family };
-            }
-            return { kind: 'compact', family };
-        case 'rate-limit':
-            if (state.rateLimitRetries >= budgets.maxRateLimitRetries) {
-                return { kind: 'give-up', family };
-            }
-            return { kind: 'wait', family, waitMs: waits.rateLimitMs };
-        case 'server-busy':
-            if (state.serverBusyRetries >= budgets.maxServerBusyRetries) {
-                return { kind: 'give-up', family };
-            }
-            return { kind: 'wait', family, waitMs: waits.serverBusyMs };
-        case 'incomplete':
-            if (state.incompleteRetries >= budgets.maxIncompleteRetries) {
-                return { kind: 'give-up', family };
-            }
-            return { kind: 'wait', family, waitMs: waits.incompleteMs };
-        default:
-            // A generic failure is retried while the TOTAL attempt budget lasts.
-            if (state.attempt >= budgets.askRetries - 1) {
-                return { kind: 'give-up', family: 'generic' };
-            }
-            return { kind: 'generic', waitMs: 2000 * (state.attempt + 1) };
-    }
-}
+// The real implementation now lives in src/retry-policy.ts (it grew the
+// incremental-backoff mode); this module stays as the historical import
+// point so the providers and the tests do not churn.
+//
+// WHY the split: the DECISION (family -> wait / compact / give-up) is pure
+// and unit-tested, while the loop (sends, throttling, aborts) stays in the
+// browser class. A new backend only supplies the `classify` function.
+export { decideRetry } from './retry-policy.js';

package/dist/browser-login.js

@@ -53,8 +53,14 @@ export async function interactiveBrowserLogin(deps) {
         await deps.persistSession().catch(() => { });
         return 'auto';
     }
-    // 3) A guest is usable and no window is needed.
-    if (deps.guestAllowed)
+    // 3) A guest is usable and no window is needed — but ONLY on a non-
+    //    interactive run. MEASURED live (Qwen): a saved session that the
+    //    probe cannot read yet (the app hydrates slowly, or the session lives
+    //    in a cookie the probe does not look at) turned into "guest" while an
+    //    OPERATOR was right there, and the run then died on the age gate.
+    //    With a terminal we open the window instead: the human either sees
+    //    his session already there or signs in once.
+    if (deps.guestAllowed && !deps.interactive)
         return 'guest';
     // 4) Non-interactive: fail fast instead of hanging on a window nobody sees.
     if (!deps.interactive)

package/dist/browser.js

@@ -24,6 +24,7 @@ export { STOP_NAME_RE, CONTINUE_NAME_RE };
 // module is unchanged (tests and other modules import these names from
 // './browser.js').
 import { askPassword, USER_DATA_DIR, parseHeadlessUACache, headlessEngineKey, readCachedHeadlessUA, writeCachedHeadlessUA, headlessUACacheReady, sanitizeHeadlessUA, needsHeadlessUaFix, writeAuthMarker, isGenerationIncompleteText, isRateLimitText, isServerBusyText, isContextLimitNotice, isContextLimitText, normText, cleanAnswer, RateLimitError, ServerBusyError, GenerationIncompleteError, ContextLimitError, cleanSingletonFiles, profileLooksLocked, nukeProfile, } from './browser-pure.js';
+import { backoffWaitMs } from './retry-backoff.js';
 export { askPassword, parseHeadlessUACache, headlessUACacheReady, sanitizeHeadlessUA, isGenerationIncompleteText, isRateLimitText, isServerBusyText, isContextLimitText, normText, RateLimitError, ServerBusyError, GenerationIncompleteError, ContextLimitError, };
 export class DeepSeekBrowser {
     providerName = 'deepseek';
@@ -32,6 +33,8 @@ export class DeepSeekBrowser {
     channel;
     answerTimeoutMs;
     askRetries;
+    infiniteRetries;
+    maxRetryWaitMs;
     stabilityChecks;
     stabilityDelayMs;
     minSendIntervalMs;
@@ -178,12 +181,14 @@ 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, maxContextLimitRetries = 1, onContextLimit, 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, infiniteRetries = true, maxRetryWaitMs = 1800000, 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;
         this.answerTimeoutMs = answerTimeoutMs;
         this.askRetries = askRetries;
+        this.infiniteRetries = infiniteRetries;
+        this.maxRetryWaitMs = maxRetryWaitMs;
         this.stabilityChecks = stabilityChecks;
         this.stabilityDelayMs = stabilityDelayMs;
         this.minSendIntervalMs = minSendIntervalMs;
@@ -1690,6 +1695,15 @@ export class DeepSeekBrowser {
     async ask(prompt, { timeout = this.answerTimeoutMs, agent = false, attachments = [], } = {}) {
         let lastErr = null;
         let attempt = 0;
+        // The transient families share ONE incremental backoff (retry-backoff.ts):
+        // with infiniteRetries on, the wait escalates instead of running out of
+        // attempts while the server is still asking us to wait.
+        const backoffCfg = {
+            infiniteRetries: this.infiniteRetries,
+            maxRetries: Math.max(1, this.maxRateLimitRetries),
+            baseWaitMs: 5000,
+            maxWaitMs: this.maxRetryWaitMs,
+        };
         let rateLimitRetries = 0;
         let serverBusyRetries = 0;
         // N8: the fallback switch is tried ONCE per ask(), not per family.
@@ -1723,9 +1737,9 @@ export class DeepSeekBrowser {
                     // The answer has settled (the finish loop returned it): mark the
                     // lifecycle state so the status line shows "settled" instead of
                     // still looking like generation.
-                    if (answer !== '(прервано пользователем)') {
-                        this._emitSendState('settled');
-                    }
+                    // No 'settled' badge here: the next send flips the state right
+                    // back to 'generating', and that add/remove pair is what makes the
+                    // status row flicker. 'generating' is cleared by the caller.
                     return answer;
                 }
                 catch (e) {
@@ -1735,7 +1749,8 @@ export class DeepSeekBrowser {
                     // context is lost). The waits don't consume the regular ask() attempts.
                     if (e instanceof RateLimitError) {
                         rateLimitRetries++;
-                        if (rateLimitRetries > this.maxRateLimitRetries) {
+                        if (!this.infiniteRetries &&
+                            rateLimitRetries > this.maxRateLimitRetries) {
                             this._notice(theme.error(this._t('ds.rate_limit_give_up', {
                                 attempt: rateLimitRetries,
                                 min: Math.ceil(this.rateLimitWaitMs / 60000),
@@ -1743,16 +1758,17 @@ export class DeepSeekBrowser {
                             throw e;
                         }
                         this._notice(theme.warn(this._t('ds.rate_limit_wait', {
-                            min: Math.ceil(this.rateLimitWaitMs / 60000),
+                            min: Math.ceil(backoffWaitMs(backoffCfg, rateLimitRetries) / 60000),
                             attempt: rateLimitRetries,
-                            max: this.maxRateLimitRetries,
+                            max: this.infiniteRetries ? '∞' : this.maxRateLimitRetries,
                         })));
                         // Interruptible: Esc/Ctrl+C must cancel this long wait too,
                         // otherwise "stop" stays frozen for up to 5 minutes.
                         // The wait is ANIMATED through onSendPause (a live countdown), so the
                         // operator sees the agent is waiting on the rate limit instead of a
                         // frozen spinner. `_lastSentAt` is bumped so the countdown renders.
-                        const waitSec = Math.ceil(this.rateLimitWaitMs / 1000);
+                        const waitMs = backoffWaitMs(backoffCfg, rateLimitRetries);
+                        const waitSec = Math.ceil(waitMs / 1000);
                         const aborted = await this._waitRateLimit(waitSec);
                         if (aborted)
                             return '(прервано пользователем)';
@@ -1764,18 +1780,20 @@ export class DeepSeekBrowser {
                     // explanation of what DeepSeek is doing.
                     if (e instanceof ServerBusyError) {
                         serverBusyRetries++;
-                        if (serverBusyRetries > this.maxServerBusyRetries) {
+                        if (!this.infiniteRetries &&
+                            serverBusyRetries > this.maxServerBusyRetries) {
                             this._notice(theme.error(this._t('ds.server_busy_give_up', {
                                 attempt: serverBusyRetries,
                             })));
                             throw e;
                         }
+                        const busyWaitMs = backoffWaitMs(backoffCfg, serverBusyRetries);
                         this._notice(theme.warn(this._t('ds.server_busy_wait', {
-                            sec: Math.ceil(this.serverBusyWaitMs / 1000),
+                            sec: Math.ceil(busyWaitMs / 1000),
                             attempt: serverBusyRetries,
-                            max: this.maxServerBusyRetries,
+                            max: this.infiniteRetries ? '∞' : this.maxServerBusyRetries,
                         })));
-                        const aborted = await this._sleepInterruptible(this.serverBusyWaitMs);
+                        const aborted = await this._sleepInterruptible(busyWaitMs);
                         if (aborted)
                             return '(прервано пользователем)';
                         continue;
@@ -1787,7 +1805,8 @@ export class DeepSeekBrowser {
                     // button does) instead of waiting for an answer that will never come.
                     if (e instanceof GenerationIncompleteError) {
                         incompleteRetries++;
-                        if (incompleteRetries > this.maxIncompleteRetries) {
+                        if (!this.infiniteRetries &&
+                            incompleteRetries > this.maxIncompleteRetries) {
                             this._notice(theme.error(this._t('ds.incomplete_give_up', {
                                 attempt: incompleteRetries,
                             })));
@@ -1795,9 +1814,10 @@ export class DeepSeekBrowser {
                         }
                         this._notice(theme.warn(this._t('ds.incomplete_retry', {
                             attempt: incompleteRetries,
-                            max: this.maxIncompleteRetries,
+                            max: this.infiniteRetries ? '∞' : this.maxIncompleteRetries,
                         })));
-                        const aborted = await this._sleepInterruptible(this.incompleteWaitMs);
+                        const incompleteWaitMs = backoffWaitMs(backoffCfg, incompleteRetries);
+                        const aborted = await this._sleepInterruptible(incompleteWaitMs);
                         if (aborted)
                             return '(прервано пользователем)';
                         continue;
@@ -2025,7 +2045,12 @@ export class DeepSeekBrowser {
         };
         this._emitSendState('paused');
         tick(totalSec * 1000);
-        return await this._sleepInterruptible(totalSec * 1000, tick);
+        const aborted = await this._sleepInterruptible(totalSec * 1000, tick);
+        // The wait is over and the send is about to go out: leave the badge on
+        // 'generating' ('paused' left it showing a paused dot forever).
+        if (!aborted)
+            this._emitSendState('generating');
+        return aborted;
     }
     // Pause between sends. Applied ONLY to agent messages
     // (tool-result, system-prompt) so we don't hit the rate limit.
@@ -2075,8 +2100,10 @@ export class DeepSeekBrowser {
         report(gap);
         this._emitSendState('paused');
         await this._sleepInterruptible(gap, report);
+        // Back to GENERATING, not settled: nothing has been sent yet, so a
+        // "✓ done" badge here showed up before the question even left the page.
         if (!this._abort && !this._askCancelled)
-            this._emitSendState('settled');
+            this._emitSendState('generating');
     }
     // Sleep in small slices so Esc/Ctrl+C can cancel the wait promptly.
     // Returns true if the sleep was cut short by _abort.

package/dist/config-live.js

@@ -22,6 +22,8 @@ export const BROWSER_LIVE_CONFIG = {
     'browser.continueMinGapMs': 'continueMinGapMs',
     'browser.askDeadlineMs': 'askDeadlineMs',
     'browser.maxAfterToolRetries': 'maxAfterToolRetries',
+    'browser.infiniteRetries': 'infiniteRetries',
+    'browser.maxRetryWaitMs': 'maxRetryWaitMs',
 };
 /** Push a browser.* change onto the live instance. Returns true when a
  *  field was written (false = not a browser timing knob, or absent on this
@@ -33,6 +35,12 @@ export function applyBrowserLiveConfig(path, value, browser) {
     // A timing value must be a FINITE NON-NEGATIVE number: a NaN reached a live
     // field (a timer with NaN fires immediately) and a negative one is nonsense.
     // Reject the value instead of corrupting the field.
+    // A BOOLEAN toggle (browser.infiniteRetries) is a different shape: accept
+    // it as-is, otherwise every live toggle of it would be rejected here.
+    if (typeof value === 'boolean') {
+        browser[field] = value;
+        return true;
+    }
     if (typeof value !== 'number' || !Number.isFinite(value) || value < 0) {
         return false;
     }

package/dist/config-schema.js

@@ -130,6 +130,22 @@ export const CONFIG_SCHEMA = [
         topKey: 'cfg.top.browser',
         groupKey: 'cfg.group.chat',
     },
+    {
+        path: 'browser.infiniteRetries',
+        type: 'boolean',
+        labelKey: 'cfg.f.browser_infiniteRetries',
+        topKey: 'cfg.top.browser',
+        groupKey: 'cfg.group.recovery',
+    },
+    {
+        path: 'browser.maxRetryWaitMs',
+        type: 'number',
+        min: 0,
+        max: 7200000,
+        labelKey: 'cfg.f.browser_maxRetryWaitMs',
+        topKey: 'cfg.top.browser',
+        groupKey: 'cfg.group.recovery',
+    },
     {
         path: 'browser.deepThinking',
         type: 'boolean',

package/dist/config.js

@@ -110,6 +110,13 @@ export const DEFAULTS = {
         // not waited out. 240s used to mean a 4-minute spinner per dead turn.
         askDeadlineMs: 120000,
         maxAfterToolRetries: 6,
+        // Infinite incremental retries for the transient families (rate limit,
+        // server busy, truncated turn, watchdog): the wait escalates 5m -> 10m
+        // -> 20m -> the ceiling instead of a hard attempt cap. Set false to get
+        // the old counted budget (maxRateLimitRetries / maxIncompleteRetries).
+        infiniteRetries: true,
+        // Ceiling for ONE retry wait (ms). 0 = no ceiling.
+        maxRetryWaitMs: 1800000,
         // Auto-compact is ON by default: a provider's context window is small and
         // per-model (GLM: 32k-128k), and running out of it mid-task is a hard stop
         // that loses the work, while a compaction at a safe seam only costs one

package/dist/glm-browser.js

@@ -1,3 +1,4 @@
+import { backoffWaitMs } from './retry-backoff.js';
 // GLM (chat.z.ai) provider — the third chat backend zames can drive.
 //
 // WHY a separate class (the same reason QwenBrowser exists): the backends
@@ -57,6 +58,8 @@ export class GlmBrowser {
     channel;
     answerTimeoutMs;
     askRetries;
+    infiniteRetries;
+    maxRetryWaitMs;
     stabilityChecks;
     stabilityDelayMs;
     minSendIntervalMs;
@@ -131,12 +134,14 @@ 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, 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, } = {}) {
+    constructor({ headless = false, debug = false, channel = null, answerTimeoutMs = 300000, askRetries = 3, infiniteRetries = true, maxRetryWaitMs = 1800000, 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;
         this.answerTimeoutMs = answerTimeoutMs;
         this.askRetries = askRetries;
+        this.infiniteRetries = infiniteRetries;
+        this.maxRetryWaitMs = maxRetryWaitMs;
         this.stabilityChecks = stabilityChecks;
         this.stabilityDelayMs = stabilityDelayMs;
         this.minSendIntervalMs = minSendIntervalMs;
@@ -653,7 +658,7 @@ export class GlmBrowser {
      */
     async waitForLogin() {
         const interactive = loginIsInteractive({
-            isTTY: !!process.stdin.isTTY,
+            isTTY: !!process.stdin.isTTY || !this.headless,
             oneShot: false,
             scheduled: false,
             env: process.env,
@@ -1426,6 +1431,10 @@ export class GlmBrowser {
         report(gap);
         this._emitSendState('paused');
         await this._sleepInterruptible(gap, report);
+        // Back to GENERATING: nothing has been sent yet, so a "done" badge here
+        // would show up before the question even left the page.
+        if (!this._abort && !this._askCancelled)
+            this._emitSendState('generating');
     }
     async _sleepInterruptible(ms, onTick) {
         const step = 100;
@@ -1455,6 +1464,12 @@ export class GlmBrowser {
     async ask(prompt, { timeout = this.answerTimeoutMs, agent = false, attachments = [], } = {}) {
         let lastErr = null;
         let attempt = 0;
+        const backoffCfg = {
+            infiniteRetries: this.infiniteRetries,
+            maxRetries: Math.max(1, this.maxRateLimitRetries),
+            baseWaitMs: 5000,
+            maxWaitMs: this.maxRetryWaitMs,
+        };
         let rateLimitRetries = 0;
         let serverBusyRetries = 0;
         let incompleteRetries = 0;
@@ -1465,16 +1480,16 @@ export class GlmBrowser {
         let fallbackAttempted = false;
         this._askInFlight++;
         try {
-            while (attempt < this.askRetries) {
+            while (this.infiniteRetries || attempt < this.askRetries) {
                 try {
                     const answer = await this._askOnce(prompt, {
                         timeout,
                         agent,
                         attachments,
                     });
-                    if (answer !== '(прервано пользователем)') {
-                        this._emitSendState('settled');
-                    }
+                    // No transient 'settled' here: the next send flips the state
+                    // back to 'generating' and that add/remove pair is the status-row
+                    // flicker (same fix as the DeepSeek provider).
                     return answer;
                 }
                 catch (e) {
@@ -1517,42 +1532,45 @@ export class GlmBrowser {
                     }
                     if (/rate limit|too frequent/i.test(msg)) {
                         this.sendRuntime.onOutcome('rate_limit', { errorText: msg });
-                        if (rateLimitRetries >= this.maxRateLimitRetries)
+                        if (!this.infiniteRetries &&
+                            rateLimitRetries >= this.maxRateLimitRetries)
                             break;
                         rateLimitRetries++;
                         this._notice(this._t('glm.rate_limit_wait', {
-                            min: Math.ceil(this.rateLimitWaitMs / 60000),
+                            min: Math.ceil(backoffWaitMs(backoffCfg, rateLimitRetries) / 60000),
                             attempt: rateLimitRetries,
-                            max: this.maxRateLimitRetries,
+                            max: this.infiniteRetries ? '∞' : this.maxRateLimitRetries,
                         }));
-                        if (await this._sleepInterruptible(this.rateLimitWaitMs))
+                        if (await this._sleepInterruptible(backoffWaitMs(backoffCfg, rateLimitRetries)))
                             return '(прервано пользователем)';
                         continue;
                     }
                     if (e instanceof GlmServerBusyError || /server busy/i.test(msg)) {
                         this.sendRuntime.onOutcome('busy', { errorText: msg });
-                        if (serverBusyRetries >= this.maxServerBusyRetries)
+                        if (!this.infiniteRetries &&
+                            serverBusyRetries >= this.maxServerBusyRetries)
                             break;
                         serverBusyRetries++;
                         this._notice(this._t('glm.server_busy_wait', {
-                            sec: Math.ceil(this.serverBusyWaitMs / 1000),
+                            sec: Math.ceil(backoffWaitMs(backoffCfg, serverBusyRetries) / 1000),
                             attempt: serverBusyRetries,
-                            max: this.maxServerBusyRetries,
+                            max: this.infiniteRetries ? '∞' : this.maxServerBusyRetries,
                         }));
-                        if (await this._sleepInterruptible(this.serverBusyWaitMs))
+                        if (await this._sleepInterruptible(backoffWaitMs(backoffCfg, serverBusyRetries)))
                             return '(прервано пользователем)';
                         continue;
                     }
                     if (e instanceof GlmIncompleteError) {
                         this.sendRuntime.onOutcome('incomplete', { errorText: msg });
-                        if (incompleteRetries >= this.maxIncompleteRetries)
+                        if (!this.infiniteRetries &&
+                            incompleteRetries >= this.maxIncompleteRetries)
                             break;
                         incompleteRetries++;
                         this._notice(this._t('glm.incomplete_retry', {
                             attempt: incompleteRetries,
-                            max: this.maxIncompleteRetries,
+                            max: this.infiniteRetries ? '∞' : this.maxIncompleteRetries,
                         }));
-                        if (await this._sleepInterruptible(this.incompleteWaitMs))
+                        if (await this._sleepInterruptible(backoffWaitMs(backoffCfg, incompleteRetries)))
                             return '(прервано пользователем)';
                         continue;
                     }

package/dist/i18n/config.js

@@ -230,6 +230,14 @@ export const configMessages = {
         ru: 'Повторов после таймаута',
         en: 'Retries after a timeout',
     },
+    'cfg.f.browser_infiniteRetries': {
+        ru: 'Повторять бесконечно (с растущей паузой)',
+        en: 'Retry forever (with an escalating wait)',
+    },
+    'cfg.f.browser_maxRetryWaitMs': {
+        ru: 'Потолок одной паузы перед повтором, мс',
+        en: 'Ceiling for one retry wait, ms',
+    },
     'cfg.f.browser_continueMinGapMs': {
         ru: 'Мин. пауза перед нажатием Continue, мс',
         en: 'Min gap before a Continue click, ms',

package/dist/index.js

@@ -1362,6 +1362,8 @@ async function main() {
             maxSubagents: config.browser.maxSubagents,
             askDeadlineMs: providerAskDeadlineMs(config),
             maxAfterToolRetries: config.browser.maxAfterToolRetries,
+            infiniteRetries: config.browser.infiniteRetries,
+            maxRetryWaitMs: config.browser.maxRetryWaitMs,
             // An `ask` permission rule must also gate the subagent: otherwise a
             // guarded tool (e.g. a dangerous Bash command) would run inside the
             // subagent WITHOUT the operator's confirmation.

package/dist/qwen-browser.js

@@ -28,6 +28,7 @@ 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, needsHeadlessUaFix, cleanSingletonFiles, profileLooksLocked, nukeProfile, writeAuthMarker, } from './browser-pure.js';
+import { backoffWaitMs } from './retry-backoff.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';
@@ -71,6 +72,8 @@ export class QwenBrowser {
     channel;
     answerTimeoutMs;
     askRetries;
+    infiniteRetries;
+    maxRetryWaitMs;
     stabilityChecks;
     stabilityDelayMs;
     minSendIntervalMs;
@@ -148,12 +151,14 @@ export class QwenBrowser {
     onContextLimit;
     /** N8: switch to an authorized fallback provider (see agent-loop). */
     onProviderExhausted = null;
-    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, } = {}) {
+    constructor({ headless = false, debug = false, channel = null, answerTimeoutMs = 180000, askRetries = 3, infiniteRetries = true, maxRetryWaitMs = 1800000, 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;
         this.answerTimeoutMs = answerTimeoutMs;
         this.askRetries = askRetries;
+        this.infiniteRetries = infiniteRetries;
+        this.maxRetryWaitMs = maxRetryWaitMs;
         this.stabilityChecks = stabilityChecks;
         this.stabilityDelayMs = stabilityDelayMs;
         this.minSendIntervalMs = minSendIntervalMs;
@@ -586,29 +591,44 @@ export class QwenBrowser {
     async probeLogin() {
         if (!this.page)
             return 'unknown';
-        try {
-            const r = await this.page.evaluate(() => {
-                const hasToken = (() => {
+        // MEASURED live: on a freshly navigated page the React app has not
+        // hydrated yet, so localStorage is still EMPTY and the guest CTA is
+        // painted. That made a genuinely signed-in session report "out"; the
+        // headless run continued as a GUEST and every send hit Qwen's
+        // "Confirm your age" gate. Wait for the app to write its tokens
+        // (`token` / `qwen_access_token_state`, seen on the live profile).
+        const hydrationDeadline = Date.now() + 20_000;
+        while (Date.now() < hydrationDeadline) {
+            try {
+                const hasToken = await this.page.evaluate(() => {
                     try {
-                        return !!localStorage.getItem('token');
+                        return !!(localStorage.getItem('token') ||
+                            localStorage.getItem('qwen_access_token_state'));
                     }
                     catch {
                         return false;
                     }
-                })();
+                });
+                if (hasToken)
+                    return 'in';
+            }
+            catch {
+                // the page may be mid-navigation: retry on the next tick
+            }
+            await this.page.waitForTimeout(500);
+        }
+        try {
+            const signInVisible = await this.page.evaluate(() => {
                 const body = document.body ? document.body.innerText : '';
-                const signInVisible = /\b(log ?in|sign ?in)\b/i.test(body);
-                return { hasToken, signInVisible };
+                return /\b(log ?in|sign ?in)\b/i.test(body);
             });
-            if (r.hasToken)
-                return 'in';
-            if (r.signInVisible)
+            if (signInVisible)
                 return 'out';
-            return 'unknown';
         }
         catch {
-            return 'unknown';
+            // fall through to unknown
         }
+        return 'unknown';
     }
     /**
      * A human signs in inside a VISIBLE window (a one-time code cannot be typed
@@ -769,7 +789,10 @@ export class QwenBrowser {
         // guest, so no error) the guest notice. The visible window and the return
         // to headless are the SHARED interactiveBrowserLogin path.
         const interactive = loginIsInteractive({
-            isTTY: !!(process.stdin.isTTY && process.stdout.isTTY),
+            // A HEADED run IS interactive: the visible window is exactly what the
+            // human needs for the one-time code, even when stdin is a pipe (a smoke
+            // script). Requiring a TTY there failed the run with LoginRequired.
+            isTTY: !!(process.stdin.isTTY && process.stdout.isTTY) || !this.headless,
             oneShot: false,
             scheduled: false,
             env: process.env,
@@ -811,15 +834,19 @@ export class QwenBrowser {
             now: () => Date.now(),
             interactive,
             stayHeaded: !this.headless,
-            // A guest is usable, but a real session is strongly recommended; the
-            // notice tells the operator why.
-            guestAllowed: true,
+            // A guest is usable ONLY when nobody can sign in: with a terminal the
+            // window is opened instead (a slow-hydrating session must not be
+            // mistaken for a guest — that turned a signed-in run into a guest and
+            // Qwen's age gate then blocked every send).
+            guestAllowed: false,
             canShowWindow: canShowWindow(process.env, process.platform),
             tuiLogin: this.onLoginPrompt
                 ? async () => await this._promptAndLogin()
                 : undefined,
             timeoutMs: this.loginTimeoutMs,
         });
+        if (process.env.ZAMES_LOGIN_DEBUG)
+            console.error('qwen outcome=' + outcome);
         if (outcome === 'guest')
             this._notice(this._t('qwen.guest_mode'));
         await this._persistSessionIfNeeded().catch(() => { });
@@ -1680,6 +1707,10 @@ export class QwenBrowser {
         report(gap);
         this._emitSendState('paused');
         await this._sleepInterruptible(gap, report);
+        // Back to GENERATING: nothing has been sent yet, so a "done" badge here
+        // would show up before the question even left the page.
+        if (!this._abort && !this._askCancelled)
+            this._emitSendState('generating');
     }
     async _sleepInterruptible(ms, onTick) {
         const step = 100;
@@ -1711,6 +1742,12 @@ export class QwenBrowser {
     async ask(prompt, { timeout = this.answerTimeoutMs, agent = false, attachments = [], } = {}) {
         let lastErr = null;
         let attempt = 0;
+        const backoffCfg = {
+            infiniteRetries: this.infiniteRetries,
+            maxRetries: Math.max(1, this.maxRateLimitRetries),
+            baseWaitMs: 5000,
+            maxWaitMs: this.maxRetryWaitMs,
+        };
         let rateLimitRetries = 0;
         let serverBusyRetries = 0;
         let incompleteRetries = 0;
@@ -1721,16 +1758,16 @@ export class QwenBrowser {
         let fallbackAttempted = false;
         this._askInFlight++;
         try {
-            while (attempt < this.askRetries) {
+            while (this.infiniteRetries || attempt < this.askRetries) {
                 try {
                     const answer = await this._askOnce(prompt, {
                         timeout,
                         agent,
                         attachments,
                     });
-                    if (answer !== '(прервано пользователем)') {
-                        this._emitSendState('settled');
-                    }
+                    // No transient 'settled' here: the next send flips the state
+                    // back to 'generating' and that add/remove pair is the status-row
+                    // flicker (same fix as the DeepSeek provider).
                     return answer;
                 }
                 catch (e) {
@@ -1773,40 +1810,43 @@ export class QwenBrowser {
                         continue;
                     }
                     if (/rate limit|too frequent/i.test(msg)) {
-                        if (rateLimitRetries >= this.maxRateLimitRetries)
+                        if (!this.infiniteRetries &&
+                            rateLimitRetries >= this.maxRateLimitRetries)
                             break;
                         rateLimitRetries++;
                         this._notice(this._t('qwen.rate_limit_wait', {
-                            min: Math.ceil(this.rateLimitWaitMs / 60000),
+                            min: Math.ceil(backoffWaitMs(backoffCfg, rateLimitRetries) / 60000),
                             attempt: rateLimitRetries,
-                            max: this.maxRateLimitRetries,
+                            max: this.infiniteRetries ? '∞' : this.maxRateLimitRetries,
                         }));
-                        if (await this._sleepInterruptible(this.rateLimitWaitMs))
+                        if (await this._sleepInterruptible(backoffWaitMs(backoffCfg, rateLimitRetries)))
                             return '(прервано пользователем)';
                         continue;
                     }
                     if (e instanceof QwenServerBusyError || /server busy/i.test(msg)) {
-                        if (serverBusyRetries >= this.maxServerBusyRetries)
+                        if (!this.infiniteRetries &&
+                            serverBusyRetries >= this.maxServerBusyRetries)
                             break;
                         serverBusyRetries++;
                         this._notice(this._t('qwen.server_busy_wait', {
-                            sec: Math.ceil(this.serverBusyWaitMs / 1000),
+                            sec: Math.ceil(backoffWaitMs(backoffCfg, serverBusyRetries) / 1000),
                             attempt: serverBusyRetries,
-                            max: this.maxServerBusyRetries,
+                            max: this.infiniteRetries ? '∞' : this.maxServerBusyRetries,
                         }));
-                        if (await this._sleepInterruptible(this.serverBusyWaitMs))
+                        if (await this._sleepInterruptible(backoffWaitMs(backoffCfg, serverBusyRetries)))
                             return '(прервано пользователем)';
                         continue;
                     }
                     if (e instanceof QwenIncompleteError) {
-                        if (incompleteRetries >= this.maxIncompleteRetries)
+                        if (!this.infiniteRetries &&
+                            incompleteRetries >= this.maxIncompleteRetries)
                             break;
                         incompleteRetries++;
                         this._notice(theme.warn(this._t('qwen.incomplete_retry', {
                             attempt: incompleteRetries,
-                            max: this.maxIncompleteRetries,
+                            max: this.infiniteRetries ? '∞' : this.maxIncompleteRetries,
                         })));
-                        if (await this._sleepInterruptible(this.incompleteWaitMs))
+                        if (await this._sleepInterruptible(backoffWaitMs(backoffCfg, incompleteRetries)))
                             return '(прервано пользователем)';
                         continue;
                     }

package/dist/restore-history.js

@@ -120,6 +120,31 @@ export function normalizeRestoredMessage(m) {
         // copies after a flaky run), so drop it like the other nudges.
         if (/^The previous turn was cut off/.test(text))
             return null;
+        // The OTHER loop nudges (a malformed call, a plain-text answer, "the work
+        // is NOT finished", "you stopped mid-task", a repeated call) are written by
+        // the agent to itself in the same way. A flaky run left a wall of these in
+        // /chats: the operator saw them as their OWN messages ("❯ Вы: Your previous
+        // answer was not recognized…") and thought the terminal history was wrong.
+        if (/^Your previous answer was not recognized as a tool call/.test(text))
+            return null;
+        if (/^Plain text is a PROTOCOL VIOLATION/.test(text))
+            return null;
+        if (/^You wrote plain text without a tool call/.test(text))
+            return null;
+        if (/^You stopped after a tool call and wrote plain text/.test(text))
+            return null;
+        if (/^You stopped mid-task without finishing/.test(text))
+            return null;
+        if (/^Last step: call the respond tool/.test(text))
+            return null;
+        if (/^You have called the SAME tool with the SAME arguments/.test(text))
+            return null;
+        if (/^It looks like you meant to call a tool but did not/.test(text))
+            return null;
+        if (/^Continue the task\. If you need a tool/.test(text))
+            return null;
+        if (/^Before finishing: you wrote\/edited a runnable code file/.test(text))
+            return null;
         if (/^\[system\]/.test(text))
             return null;
         if (/^The user ran \//.test(text))

package/dist/retry-backoff.js

@@ -0,0 +1,89 @@
+// Incremental RETRY BACKOFF — how long to wait before a retry of a
+// transient failure (rate limit / server busy / truncated turn / watchdog
+// timeout).
+//
+// WHY: the old per-provider loop had a FIXED pause per family and a hard
+// retry ceiling. A long block (DeepSeek answers "too frequent" for minutes)
+// then failed the very first retry at the same fixed pause, burned the whole
+// budget on cheap retries and surrendered while the block was still active —
+// the operator's «лимит повторов исчерпан». Every retry must wait LONGER than
+// the previous one (up to a ceiling), and the budget must not run out while
+// the server is still asking us to wait.
+//
+// PURE: the caller owns the counter and the clock; this module only decides
+// the next wait and whether the family may be retried again.
+export const DEFAULT_BACKOFF = {
+    infiniteRetries: true,
+    maxRetries: 6,
+    baseWaitMs: 5 * 60_000,
+    // Half an hour is where a wait stops being a pause and becomes a dead run:
+    // the operator can restart instead of watching a spinner for an hour.
+    maxWaitMs: 30 * 60_000,
+};
+/** A wait never drops below this: a server-busy wait of 0 would retry in a
+ *  tight loop against a server that just told us it is overloaded. */
+const MIN_WAIT_MS = 500;
+/** Double on every retry: 5m, 10m, 20m, 30m, 30m, 30m... */
+export const BACKOFF_FACTOR = 2;
+// +/-10% jitter: several agents (or several families in one agent) must not
+// retry in the same second and trip the server's burst detector again.
+const JITTER_RATIO = 0.1;
+/** A ceiling of 0 or Infinity means "no ceiling" (a hand-edited config). */
+export function normalizeMaxWait(maxWaitMs) {
+    return Number.isFinite(maxWaitMs) && maxWaitMs > 0 ? maxWaitMs : 0;
+}
+/** Clamp one wait to the configured ceiling. */
+export function clampWait(waitMs, maxWaitMs) {
+    if (!(Number.isFinite(waitMs) && waitMs > 0))
+        return 0;
+    const cap = normalizeMaxWait(maxWaitMs);
+    return cap ? Math.min(waitMs, cap) : waitMs;
+}
+/** Shortest acceptable pause. */
+export function floorWait(waitMs) {
+    if (!(Number.isFinite(waitMs) && waitMs > 0))
+        return 0;
+    return Math.max(MIN_WAIT_MS, waitMs);
+}
+/**
+ * PURE: the wait before the next retry, `attempt` being 1-based (1 = the
+ * first retry, i.e. after the first failure).
+ *
+ * `serverWaitMs` (a Retry-After) WINS over the learned curve: when the server
+ * names its own pause, guessing a shorter one only burns another attempt.
+ * It is still clamped to the ceiling, and it never goes below the curve, so
+ * a tiny Retry-After cannot shorten the escalation.
+ */
+export function backoffWaitMs(cfg, attempt, opts = {}) {
+    const n = Math.max(1, Math.floor(attempt));
+    const base = Number.isFinite(cfg.baseWaitMs) && cfg.baseWaitMs > 0
+        ? cfg.baseWaitMs
+        : DEFAULT_BACKOFF.baseWaitMs;
+    let wait = base * Math.pow(BACKOFF_FACTOR, n - 1);
+    if (!Number.isFinite(wait))
+        wait = Number.MAX_SAFE_INTEGER;
+    const server = opts.serverWaitMs;
+    if (typeof server === 'number' && Number.isFinite(server) && server > 0) {
+        wait = Math.max(wait, server);
+    }
+    wait = clampWait(wait, cfg.maxWaitMs);
+    if (opts.jitter !== false) {
+        const spread = Math.round(wait * JITTER_RATIO);
+        if (spread > 0)
+            wait += Math.round((Math.random() * 2 - 1) * spread);
+    }
+    return Math.max(MIN_WAIT_MS, Math.round(wait));
+}
+/**
+ * PURE: may the family be retried once more after `attemptsMade` failures?
+ * With `infiniteRetries` on the answer is always yes — the escalation and
+ * the cancel path are what keep an endless wait honest, not a counter.
+ */
+export function canRetry(cfg, attemptsMade) {
+    if (cfg.infiniteRetries === true)
+        return true;
+    const max = Math.max(0, Math.floor(cfg.maxRetries));
+    if (max === 0)
+        return true;
+    return attemptsMade < max;
+}

package/dist/retry-policy.js

@@ -0,0 +1,98 @@
+// The retry POLICY of a provider's ask() as a PURE function.
+//
+// WHY: the three providers ran the same loop — call _askOnce, classify the
+// thrown error into a family, retry that family within its own budget — and
+// each copy had its own order of checks and its own wording. The loop itself
+// (sends, throttling, aborts) stays in the browser class; only the DECISION is
+// here, so every branch is unit-tested without a browser.
+//
+// Incremental retries (default): the three transient families (and the
+// agent-loop watchdog) no longer count their attempts; the WAIT grows from the
+// family's base (rate limit: 5m, busy: 3s, incomplete: 2s) up to the ceiling
+// (browser.maxRetryWaitMs, default 30m), and the only way out is a cancel
+// (Esc/Ctrl+C) or a FATAL error (bad login, captcha, guest limit) — the same
+// place it was before.
+//
+// One thing matters for understanding this module: a retry that waits the
+// SAME fixed pause forever is not endless, it is a busy loop that never lets
+// the block expire. The escalation is what makes "infinite" safe.
+import { backoffWaitMs, canRetry, } from './retry-backoff.js';
+/**
+ * Decide what to do after a failed attempt.
+ *
+ * classify maps the thrown error to a family; it lives in the provider
+ * because the backend-specific markers (guest limit, age gate, captcha) are
+ * provider knowledge. A null classification falls through to the generic
+ * attempt budget.
+ *
+ * backoff carries the retry mode (infiniteRetries, the ceiling) — see
+ * src/retry-backoff.ts.
+ */
+export function decideRetry(family, state, budgets, waits, backoff, opts = {}) {
+    // Strict === true: the infinite mode is opt-in by an EXPLICIT config field.
+    // A caller that omits it keeps the historical counted budget, so a
+    // partially built config can never silently retry forever.
+    const infinite = backoff?.infiniteRetries === true; // strict
+    const cfg = {
+        infiniteRetries: infinite,
+        maxRetries: backoff?.maxRetries ?? 6,
+        baseWaitMs: waits.rateLimitMs,
+        maxWaitMs: backoff?.maxWaitMs ?? 0,
+    };
+    // The cause of a transient failure decides the FIRST wait — a rate block is
+    // waited out for minutes, a transient busy notice for seconds — and the
+    // escalation adds to it from there.
+    const baseWait = (f) => f === 'server-busy'
+        ? waits.serverBusyMs
+        : f === 'incomplete'
+            ? waits.incompleteMs
+            : waits.rateLimitMs;
+    const waitFor = (f, attempts) => backoffWaitMs({ ...cfg, baseWaitMs: baseWait(f) }, attempts, {
+        // A server Retry-After is the best clock we have; it is still clamped
+        // to the ceiling and never shortens the escalation.
+        serverWaitMs: f === 'rate-limit' ? waits.retryAfterMs : undefined,
+        jitter: opts.jitter,
+    });
+    switch (family) {
+        case 'fatal':
+            return { kind: 'give-up', family };
+        case 'context-limit':
+            if (state.contextLimitRetries >= budgets.maxContextLimitRetries) {
+                return { kind: 'give-up', family };
+            }
+            return { kind: 'compact', family };
+        case 'rate-limit':
+            if (!canRetry(cfg, state.rateLimitRetries)) {
+                return { kind: 'give-up', family };
+            }
+            return {
+                kind: 'wait',
+                family,
+                waitMs: waitFor('rate-limit', state.rateLimitRetries + 1),
+            };
+        case 'server-busy':
+            if (!canRetry(cfg, state.serverBusyRetries)) {
+                return { kind: 'give-up', family };
+            }
+            return {
+                kind: 'wait',
+                family,
+                waitMs: waitFor('server-busy', state.serverBusyRetries + 1),
+            };
+        case 'incomplete':
+            if (!canRetry(cfg, state.incompleteRetries)) {
+                return { kind: 'give-up', family };
+            }
+            return {
+                kind: 'wait',
+                family,
+                waitMs: waitFor('incomplete', state.incompleteRetries + 1),
+            };
+        default:
+            // A generic failure is retried while the TOTAL attempt budget lasts.
+            if (state.attempt >= budgets.askRetries - 1) {
+                return { kind: 'give-up', family: 'generic' };
+            }
+            return { kind: 'generic', waitMs: 2000 * (state.attempt + 1) };
+    }
+}

package/dist/run-task.js

@@ -406,6 +406,8 @@ export async function runTask(deps, browser, tools, taskText, workdir, opts, att
                 locale,
                 askDeadlineMs: providerAskDeadlineMs(config),
                 maxAfterToolRetries: config.browser.maxAfterToolRetries,
+                infiniteRetries: config.browser.infiniteRetries,
+                maxRetryWaitMs: config.browser.maxRetryWaitMs,
                 // Auto-compact between tool calls when the context nears the window
                 // limit. The callback is provided by the caller so it can refresh the
                 // outer currentChatId; it serializes with the throttle because the

package/dist/subagent.js

@@ -65,7 +65,7 @@ function subagentPersona(type) {
  * returns only the report.
  */
 export function createSubagentRunner(opts) {
-    const { browser, workdir, locale, runAgentLoop, buildTools, transcript = null, maxSubagents, askDeadlineMs, maxAfterToolRetries, onAskPermission, } = opts;
+    const { browser, workdir, locale, runAgentLoop, buildTools, transcript = null, maxSubagents, askDeadlineMs, maxAfterToolRetries, infiniteRetries, maxRetryWaitMs, onAskPermission, } = opts;
     let used = 0;
     return async (req) => {
         if (used >= maxSubagents) {
@@ -133,6 +133,8 @@ export function createSubagentRunner(opts) {
                 locale,
                 askDeadlineMs,
                 maxAfterToolRetries,
+                infiniteRetries,
+                maxRetryWaitMs,
                 // A subagent NEVER touches BACKLOG.md, even in the operator's dev
                 // mode: its sub-task is scoped, and a general subagent appending
                 // "improvement" notes would be unrelated, unsupervised edits.

package/package.json

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