zames_pro 2.95.4 → 2.95.6

package/CHANGELOG.md

@@ -7,6 +7,36 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.95.6] - 2026-11-05
+
+### Added
+
+- **compact:** carry the todo checklist and the /goal condition into the new chat
+- **site:** a generated changelog page and one source for RU/EN layout strings
+
+### Fixed
+
+- **changelog:** keep a drafted group heading off the previous bullet
+
+## [2.95.5] - 2026-11-05
+
+### Added
+
+- **site:** a 404 page, hreflang alternates and cache-busted assets
+
+### Fixed
+
+- **tui:** keep the AskUser question and answer in the log
+- **changelog:** keep a manual Unreleased note inside its group
+- **site:** stop the landing title repeating the site name in og:title
+- **site:** give the social preview its own static image
+
+### Changed
+
+- **tui:** paint the AskUser question in the tool color
+- drop dead provider-unification modules and stale doc text
+- **site:** a deeper palette, bigger type and calmer cards
+
 ## [2.95.4] - 2026-11-05
 
 ### Fixed

package/README.md

@@ -72,7 +72,7 @@ and runs right after it, in the same chat. `Esc` aborts the current generation,
 - [Why zames?](#why-zames) · [Requirements](#requirements) · [Signing in](#signing-in)
 - [Switching providers (DeepSeek / Qwen / GLM)](#switching-providers-deepseek--qwen--glm)
 - [Installation](#installation) · [Usage](#usage) · [FAQ](#faq)
-- Reference: [Commands and tools](docs/commands.md) · [MCP](docs/mcp.md) · [Configuration and themes](docs/configuration.md) · [Troubleshooting](docs/troubleshooting.md)
+- Reference: [Commands and tools](docs/commands.md) · [MCP](docs/mcp.md) · [Configuration and themes](docs/configuration.md) · [Troubleshooting](docs/troubleshooting.md) · [Changelog](https://viqto0r.github.io/zames_pro/changelog.html)
 - [Keywords and alternatives](#keywords-and-alternatives) · [Links](#links) · [License](#license)
 
 ## How it works
@@ -534,7 +534,7 @@ zames                      # один раз войти, дальше прост
 - [Почему zames?](#почему-zames) · [Требования](#требования) · [Вход в аккаунт](#вход-в-аккаунт)
 - [Переключение провайдера (DeepSeek / Qwen / GLM)](#переключение-провайдера-deepseek--qwen--glm)
 - [Установка](#установка) · [Использование](#использование) · [FAQ](#faq)
-- Справочник: [Команды и инструменты](docs/commands-ru.md) · [MCP](docs/mcp-ru.md) · [Конфигурация и темы](docs/configuration-ru.md) · [Troubleshooting](docs/troubleshooting-ru.md)
+- Справочник: [Команды и инструменты](docs/commands-ru.md) · [MCP](docs/mcp-ru.md) · [Конфигурация и темы](docs/configuration-ru.md) · [Troubleshooting](docs/troubleshooting-ru.md) · [История изменений](https://viqto0r.github.io/zames_pro/changelog-ru.html)
 - [Ключевые слова и аналоги](#ключевые-слова-и-аналоги) · [Ссылки](#ссылки) · [Лицензия](#лицензия)
 
 ## Как это работает

package/dist/changelog.js

@@ -97,13 +97,25 @@ export function syncUnreleased(changelog, body) {
         // carries several groups (`## Added` … `## Fixed`) without a blank line
         // between them, the next group used to stay glued to the last bullet
         // (`- a### Fixed`) — it was not a heading at all, so the item vanished
-        // from the rendered changelog.
-        .replace(/([^\n])\n?(?=## )/g, '$1' + nl + nl)
+        // from the rendered changelog. The lookahead is what keeps a CONTINUATION
+        // line of a multi-line bullet in place: gluing on `\n` as well joined the
+        // indent line to the next bullet and truncated the note.
+        // The draft's groups are still `## ` at this point (they become `### `
+        // below), and the FIRST group is already preceded by the blank line of
+        // the draft — so a group always starts a line, and this rule only has to
+        // punch in the missing blank line after a bullet.
+        .replace(/([^\n])(?=## )/g, '$1' + nl + nl)
         .trim()
         // The draft renders groups as `## Added` (top-level), but INSIDE the file
         // a version's groups are `### Added` (a subsection of the version heading).
-        // `## [` (the next version) is left alone.
-        .replace(/^## (?!\[)/gm, '### ');
+        // `## [` (the next version) is left alone. The FIRST group follows the
+        // version heading directly (no bullet before it), so the blank-line rule
+        // above never fired for it — `## [Unreleased]` came out as a bare `#`
+        // followed by `# Added`. The heading owns a blank line, always.
+        .replace(/^## (?!\[)/gm, '### ')
+        // One blank line between the version heading and its first group, not
+        // the three the rules above can stack up.
+        .replace(/^\n+(?=### )/gm, '');
     const section = cleanBody ? nl + nl + cleanBody + nl : nl;
     return changelog.slice(0, afterAnchor) + section + tail;
 }

package/dist/commands.js

@@ -512,20 +512,80 @@ export function isUsableCompactSummary(text) {
         return false;
     return true;
 }
+function todoMark(s) {
+    return s === 'completed' ? '[x]' : s === 'in_progress' ? '[~]' : '[ ]';
+}
+/** The TODO block carried into the new chat. Empty when there are no tasks. */
+export function renderCompactTodos(todos = []) {
+    const items = Array.isArray(todos) ? todos : [];
+    if (!items.length)
+        return '';
+    const lines = items.map((x, i) => String(i + 1) +
+        '. ' +
+        todoMark(String(x.status)) +
+        ' ' +
+        String(x.content));
+    const done = items.filter((x) => x.status === 'completed').length;
+    return ('## Task checklist (carried over by the agent, still in force)' +
+        NL +
+        'This list is SESSION state: it survived the compaction unchanged. ' +
+        'Do NOT recreate it from the summary — keep it up to date with ' +
+        'TodoWrite instead.' +
+        NL +
+        'Todo list (' +
+        String(done) +
+        '/' +
+        String(items.length) +
+        ' done):' +
+        NL +
+        lines.join(NL));
+}
+/** The goal block carried into the new chat. Empty when no goal is set. */
+export function renderCompactGoal(goal) {
+    const g = String(goal?.goal ?? '').trim();
+    if (!g)
+        return '';
+    const head = goal?.isCondition
+        ? '## Completion goal (carried over, still in force)'
+        : '## Session goal (carried over, still in force)';
+    return (head +
+        NL +
+        'This goal is still active in this session; the compaction did not ' +
+        'cancel it. Keep working toward it.' +
+        NL +
+        NL +
+        g);
+}
+/**
+ * Re-pin the SESSION state after a compaction. The chat is new, but the todo
+ * store and the /goal file live in the process and on disk, so they survive —
+ * only the model's KNOWLEDGE of them does not. Sent as its own message right
+ * after the carryover, so it reads as current state, not as history.
+ */
+export function buildCompactToolResult(todos = [], goal = null) {
+    return [renderCompactTodos(todos), renderCompactGoal(goal)]
+        .filter(Boolean)
+        .join(NL + NL);
+}
 /**
  * Wrap the model's summary into the text posted as the first message of the
  * NEW chat. The system prompt is sent separately (sendSystemPrompt), so here
  * we only mark the block as a carried-over context and add the operator's
- * original goal so the model does not lose it.
+ * original task. The todo checklist and the /goal condition are appended too:
+ * they are session state the model-written summary is not guaranteed to keep.
  */
-export function buildCompactCarryover(summary, task) {
+export function buildCompactCarryover(summary, task, todos = [], goal = null) {
     const body = String(summary ?? '').trim();
-    const goal = String(task ?? '').trim();
+    const goalText = String(task ?? '').trim();
     let out = 'Context carried over from a previous chat (compacted). ' +
         'Treat it as the history of our work so far and continue from the current state.';
     out += NL + NL + body;
-    if (goal) {
-        out += NL + NL + 'Original task: ' + goal;
+    if (goalText) {
+        out += NL + NL + 'Original task: ' + goalText;
+    }
+    for (const extra of [renderCompactTodos(todos), renderCompactGoal(goal)]) {
+        if (extra)
+            out += NL + NL + extra;
     }
     return out;
 }

package/dist/compact.js

@@ -16,7 +16,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, contextExhausted = 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, todos = [], goal = null, } = opts;
     const t = translate(locale);
     // The active provider's LABEL for operator-facing text: performCompact is
     // shared by every backend, so it cannot hardcode "DeepSeek". `providerArg`
@@ -189,7 +189,14 @@ export async function performCompact(opts) {
                 timeout: 60_000,
                 agent: false,
             });
-            await browser.ask(buildCompactCarryover(summary, task), {
+            // The checklist and the goal are SESSION state (todoStore /
+            // .zames-goal), not chat state: they survive a compaction by themselves,
+            // but the model must be told they are still in force, otherwise it
+            // re-creates the tasks or treats the goal as gone because the summary
+            // does not mention it. They ride INSIDE the carryover, not as a separate
+            // turn: an extra send is another rate-limit pause AND every extra
+            // message of the new chat is another turn the model may answer.
+            await browser.ask(buildCompactCarryover(summary, task, todos, goal), {
                 timeout: 60_000,
                 agent: false,
             });

package/dist/index.js

@@ -1302,6 +1302,8 @@ async function main() {
             skipUiLock: true,
             selfImprovement: devMode,
             contextExhausted: true,
+            todos: getTodos(todoStore),
+            goal: sessionGoal ? { goal: sessionGoal, isCondition: true } : null,
         });
         if (!res.ok)
             return false;
@@ -3125,6 +3127,8 @@ async function main() {
             answerTimeoutMs: providerAnswerTimeoutMs(),
             fallbackLimit: COMPACT_FALLBACK_LIMIT,
             selfImprovement: devMode,
+            todos: getTodos(todoStore),
+            goal: sessionGoal ? { goal: sessionGoal, isCondition: true } : null,
         });
         if (res.ok) {
             currentChatId = res.chatId;
@@ -4730,6 +4734,10 @@ async function main() {
                             quiet: true,
                             skipUiLock: true,
                             selfImprovement: devMode,
+                            todos: getTodos(todoStore),
+                            goal: sessionGoal
+                                ? { goal: sessionGoal, isCondition: true }
+                                : null,
                         });
                         if (res.ok) {
                             currentChatId = res.chatId;

package/dist/run-task.js

@@ -2,8 +2,35 @@ import { theme } from './theme.js';
 import { withGoal, mergeMessages, isSlashCommand, formatDuration, } from './commands.js';
 import { buildEvaluatorPrompt, buildContinuationDirective, parseGoalVerdict, GOAL_MAX_TURNS, } from './goal.js';
 import { formatCompactTokens, pasteReplacement, expandPastes } from './input.js';
-import { DEFAULT_LOCALE } from './i18n.js';
+import { DEFAULT_LOCALE, translate } from './i18n.js';
 import { providerAskDeadlineMs } from './config.js';
+// The two log lines an `AskUser` turn leaves behind: the question with its
+// options (the recommended one starred) and the operator's answer. PURE, so the
+// wording is unit-tested without a live modal; `runTask` prints them through
+// the editor after the modal closes (the modal's own frame is erased on
+// unmount, and without these lines the question would leave no trace in the
+// terminal or the chat history).
+const ASK_NL = String.fromCharCode(10);
+export function formatAskUserLog(question, options, recommended, answer, t) {
+    const qLines = question
+        .split(ASK_NL)
+        .map((l) => '  ' + l.trim())
+        .join(ASK_NL);
+    const optLines = options
+        .map((o, i) => {
+        const mark = i === recommended ? '* ' : '- ';
+        const tag = i === recommended ? ' (' + t('askuser.recommended') + ')' : '';
+        return '  ' + mark + o + tag;
+    })
+        .join(ASK_NL);
+    return {
+        question: '◆ ' + t('askuser.title') + ASK_NL + qLines + ASK_NL + optLines,
+        answer: '❯ ' +
+            t('askuser.your_answer') +
+            ' ' +
+            (answer === null || answer === '' ? t('askuser.hint_dismiss') : answer),
+    };
+}
 // Ask the operator to approve a tool call flagged by an `ask` permission rule
 // While the LineEditor owns the terminal it must be paused first, or the
 // confirmation prompt and the input line fight for the same keys. A non-TTY run
@@ -429,18 +456,34 @@ export async function runTask(deps, browser, tools, taskText, workdir, opts, att
                     ? async (req) => {
                         if (!editor)
                             return null;
+                        // The modal is a SEPARATE Ink app: its frame is erased when it
+                        // unmounts, so without this the question and the operator's
+                        // answer leave no trace — neither in the terminal nor in the
+                        // chat history. Print them as a normal log turn instead.
+                        const tr = translate(locale);
                         editor.pause();
+                        let answer = null;
                         try {
                             const { askQuestionInk } = await import('./tui/run-ask.js');
-                            return await askQuestionInk({
+                            answer = await askQuestionInk({
                                 question: req.question,
                                 options: req.options,
                                 recommended: req.recommended,
                                 allowText: req.allowText,
                             });
+                            return answer;
                         }
                         finally {
+                            // Print AFTER resume, never before pause: on the alternate
+                            // screen the modal unmount wipes everything painted into the
+                            // old app, so the question and the answer would vanish.
                             editor.resume();
+                            const logged = formatAskUserLog(req.question, req.options, req.recommended, answer, tr);
+                            // The question block is painted in the TOOL color (the warm
+                            // one tool calls use) so it reads as a distinct event, not
+                            // as another grey service line next to the agent's answers.
+                            editor.printAbove(theme.tool(logged.question));
+                            editor.printAbove(theme.user(logged.answer));
                         }
                     }
                     : onAskUser,

package/llms-full.txt

@@ -57,7 +57,7 @@ and runs right after it, in the same chat. `Esc` aborts the current generation,
 - [Why zames?](#why-zames) · [Requirements](#requirements) · [Signing in](#signing-in)
 - [Switching providers (DeepSeek / Qwen / GLM)](#switching-providers-deepseek--qwen--glm)
 - [Installation](#installation) · [Usage](#usage) · [FAQ](#faq)
-- Reference: [Commands and tools](docs/commands.md) · [MCP](docs/mcp.md) · [Configuration and themes](docs/configuration.md) · [Troubleshooting](docs/troubleshooting.md)
+- Reference: [Commands and tools](docs/commands.md) · [MCP](docs/mcp.md) · [Configuration and themes](docs/configuration.md) · [Troubleshooting](docs/troubleshooting.md) · [Changelog](https://viqto0r.github.io/zames_pro/changelog.html)
 - [Keywords and alternatives](#keywords-and-alternatives) · [Links](#links) · [License](#license)
 
 ## How it works

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zames_pro",
-  "version": "2.95.4",
+  "version": "2.95.6",
   "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": {
@@ -44,9 +44,12 @@
     "render-how": "tsx scripts/render-how-it-works.mts",
     "build:readme": "tsx scripts/build-readme.mts",
     "build:llms": "tsx scripts/build-llms.mts",
+    "build:changelog": "tsx scripts/build-changelog.mts",
+    "build:site-data": "tsx scripts/build-site-data.mts",
     "postinstall": "node scripts/postinstall.mjs",
     "prepare": "husky",
     "glm-smoke": "tsx scripts/glm-smoke.mts",
+    "glm-warmup": "tsx scripts/glm-warmup.mts",
     "seo:topics": "tsx scripts/seo-topics.mts",
     "ui-smoke": "tsx scripts/ui-smoke.mts"
   },
@@ -169,5 +172,10 @@
   "funding": {
     "type": "github",
     "url": "https://github.com/sponsors/Viqto0r"
+  },
+  "overrides": {
+    "@typescript-eslint/typescript-estree": {
+      "minimatch": "^11.0.4"
+    }
   }
 }

package/dist/ask-retry.js

@@ -1,10 +0,0 @@
-// N1 stage 4: the retry POLICY of a provider's ask() as a PURE function.
-//
-// 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/ask-state.js

@@ -1,80 +0,0 @@
-// N3: the PHASE DECISION of DeepSeek's `_askOnce()` as a pure state machine.
-//
-// `_askOnce` (src/browser.ts) is the most fragile function of the project: a
-// start-wait loop, a finish loop, the Continue button, the stability window
-// and four detectors (rate limit / context limit / truncated / finished
-// without answer). Until now it was covered only by live smoke runs, and a
-// wrong ordering of the checks kept reappearing (the "Stopped" hang, the
-// "agent stopped with a Continue button", the 15-minute spinner on a dead
-// turn). The Playwright part keeps COLLECTING an observation; the TRANSITION
-// below is pure and unit-tested against the real cases from DESIGN-NOTES.
-/** Grace ticks before a FINISHED-with-answer turn is returned (default 2). */
-export const NET_FINISHED_TICKS = 2;
-/** Ticks a dead (FINISHED, no answer, no Continue) turn waits before giving up. */
-export const DEAD_TURN_TICKS = 6;
-/**
- * One transition of the ask() state machine.
- *
- * ORDER MATTERS and is the whole point of this function:
- *  1. an abort wins over everything (the operator stopped);
- *  2. the CONTEXT limit is checked BEFORE the rate limit — both look like a
- *     toast, and retrying an exhausted chat is useless;
- *  3. rate limit / server busy are retryable errors;
- *  4. a truncated turn PREFERS the Continue button (it RESUMES the turn) and
- *     only falls back to a resend when there is no button;
- *  5. a PAUSED generation (`continueVisible`) is never "settled": the
- *     stability early-return must be checked AFTER it, otherwise a partial
- *     answer is returned with Continue still on screen.
- */
-export function nextPhase(phase, o, opts) {
-    if (o.aborted)
-        return { kind: 'return', text: 'dom' };
-    if (o.contextLimit)
-        return { kind: 'throw', error: 'context-limit' };
-    if (o.rateLimited)
-        return { kind: 'throw', error: 'rate-limit' };
-    if (o.serverBusy)
-        return { kind: 'throw', error: 'server-busy' };
-    // A truncated / answer-less turn: click Continue when possible (it resumes
-    // the SAME turn); otherwise resend.
-    if (o.truncated || o.noAnswer) {
-        if (opts.autoContinue && o.continueVisible) {
-            return { kind: 'click-continue' };
-        }
-        return { kind: 'throw', error: 'incomplete' };
-    }
-    if (phase === 'start') {
-        if (o.isNew)
-            return { kind: 'started' };
-        if (o.hasText && o.notGenerating && !o.continueVisible) {
-            return { kind: 'return', text: 'dom' };
-        }
-        // A reasoning pause during the THINK phase: click Continue so the answer
-        // starts flowing instead of waiting for the start deadline.
-        if (opts.autoContinue && opts.deepThinking && o.continueVisible) {
-            return { kind: 'click-continue' };
-        }
-        return { kind: 'wait' };
-    }
-    // --- finish loop ---------------------------------------------------------
-    // The SSE body is ground truth: FINISHED with an answer, after a short grace
-    // window, is complete.
-    if (o.finishedWithAnswer && opts.netFinishedTicks >= NET_FINISHED_TICKS) {
-        return { kind: 'return', text: 'net' };
-    }
-    // A dead turn (the server ended it with nothing and there is no Continue to
-    // resume): give up quickly so ask() resends instead of a long spinner.
-    if (opts.deadTicks >= DEAD_TURN_TICKS && !o.continueVisible) {
-        return { kind: 'throw', error: 'incomplete' };
-    }
-    // A PAUSED generation looks stable: check it BEFORE the stability return.
-    if (opts.autoContinue && opts.deepThinking && o.continueVisible) {
-        return { kind: 'click-continue' };
-    }
-    if (o.isNew && opts.stableReached) {
-        if (o.notGenerating)
-            return { kind: 'return', text: 'dom' };
-        return { kind: 'wait' };
-    }
-    return { kind: 'wait' };
-}

package/dist/browser-base.js

@@ -1,69 +0,0 @@
-// N1 stage 1: the helpers that were byte-identical in DeepSeekBrowser,
-// QwenBrowser and GlmBrowser. Composition, not inheritance: every provider
-// class owns a page and calls these with it, so the provider-specific logic
-// stays where it is and only the shared mechanics live here.
-/** Best-effort: a page error while marking the tab title must never break a
- *  send loop, so every failure is swallowed. */
-export async function setBusyTitle(page, busy, setInDom) {
-    try {
-        await page.evaluate(setInDom, busy);
-    }
-    catch { }
-}
-/**
- * The first selector that has a VISIBLE element. `timeout` is a per-selector
- * budget, not a total one (the providers rely on that: a login form is tried
- * with a long budget while optional probes use a short one).
- *
- * Two probe styles exist in the providers (`waitFor({state:'visible'})` in
- * DeepSeek/Qwen and `count()` + `isVisible()` in GLM). `style: 'wait'` keeps
- * the first (it also covers a late-mounting element); `style: 'check'` keeps
- * the second (no waiting state, a cheap poll).
- */
-export async function findVisible(page, selectors, timeout = 1000, style = 'wait') {
-    for (const sel of selectors) {
-        const loc = page.locator(sel).last();
-        if (style === 'wait') {
-            try {
-                await loc.waitFor({ state: 'visible', timeout });
-                return loc;
-            }
-            catch { }
-            continue;
-        }
-        try {
-            if ((await loc.count()) === 0)
-                continue;
-            if (await loc.isVisible({ timeout }).catch(() => false))
-                return loc;
-        }
-        catch { }
-    }
-    return null;
-}
-/**
- * Sleep in 100 ms chunks so Esc and the ask() watchdog stay responsive.
- * Returns true when the wait was INTERRUPTED (abort / cancelled ask), so the
- * caller can stop early. `onTick` fires about once a second with the time
- * left — that is what animates the throttle countdown.
- */
-export async function sleepInterruptible(page, ms, isInterrupted, onTick) {
-    const step = 100;
-    let left = ms;
-    let sinceTick = 0;
-    while (left > 0) {
-        if (isInterrupted())
-            return true;
-        const chunk = Math.min(step, left);
-        await page.waitForTimeout(chunk);
-        left -= chunk;
-        if (onTick) {
-            sinceTick += chunk;
-            if (sinceTick >= 1000) {
-                sinceTick = 0;
-                onTick(left);
-            }
-        }
-    }
-    return isInterrupted();
-}

package/dist/provider-errors.js

@@ -1,53 +0,0 @@
-// N1 stage 2: the error families shared by the chat providers.
-//
-// Each provider used to declare its own copy (`QwenRateLimitError`,
-// `GlmRateLimitError`, ...), so the retry policy in every `ask()` re-listed the
-// same six families and a new one had to be added three times. The classes
-// here are the SHARED vocabulary; the provider keeps its own pre-check
-// (`instanceof`) only where the semantics genuinely differ (guest limits and
-// the age gate exist on one backend only).
-//
-// `provider` is carried for the operator-facing message only — the retry
-// decision is per CLASS, never per string.
-export class ProviderRateLimitError extends Error {
-    constructor(detail) {
-        super('rate limit: ' + detail);
-        this.name = 'ProviderRateLimitError';
-    }
-}
-export class ProviderServerBusyError extends Error {
-    constructor(detail) {
-        super('server busy: ' + detail);
-        this.name = 'ProviderServerBusyError';
-    }
-}
-export class ProviderContextLimitError extends Error {
-    constructor(detail) {
-        super('context limit: ' + detail);
-        this.name = 'ProviderContextLimitError';
-    }
-}
-export class ProviderIncompleteError extends Error {
-    constructor(detail) {
-        super('generation incomplete: ' + detail);
-        this.name = 'ProviderIncompleteError';
-    }
-}
-export class ProviderGuestLimitError extends Error {
-    constructor(detail) {
-        super('guest limit: ' + detail);
-        this.name = 'ProviderGuestLimitError';
-    }
-}
-export class ProviderAgeGateError extends Error {
-    constructor(detail) {
-        super('age gate: ' + detail);
-        this.name = 'ProviderAgeGateError';
-    }
-}
-export class ProviderCaptchaError extends Error {
-    constructor(detail) {
-        super('captcha: ' + detail);
-        this.name = 'ProviderCaptchaError';
-    }
-}

package/dist/retry-policy.js

@@ -1,98 +0,0 @@
-// 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/send-slot.js

@@ -1,36 +0,0 @@
-// N1 stage 3: the SEND SLOT — the pause before a send that keeps the chat's
-// rate limit happy.
-//
-// Every provider had its own `_waitForSendSlot()` with the same shape (skip a
-// non-agent send, compute the remaining gap, report the animated countdown,
-// mark the state 'paused', sleep interruptibly) and each computed the gap its
-// own way (DeepSeek: interval + thinking bonus; Qwen: interval; GLM: the
-// adaptive sendRuntime). The MECHANICS are shared here; the provider injects
-// the gap and the plumbing.
-/**
- * Wait for the send slot. Returns true when the wait was INTERRUPTED (the
- * caller must then abort the send).
- */
-export async function waitForSendSlot(agent, deps) {
-    if (!agent)
-        return false;
-    const gap = deps.gapMs();
-    if (gap <= 0)
-        return false;
-    const report = (leftMs) => {
-        const secs = Math.max(0, Math.ceil(leftMs / 1000));
-        if (deps.onPause) {
-            try {
-                deps.onPause(secs);
-            }
-            catch { }
-        }
-        else if (deps.onPauseText) {
-            deps.onPauseText(secs);
-        }
-    };
-    report(gap);
-    if (deps.emitState)
-        deps.emitState('paused');
-    return await deps.sleep(gap, report);
-}