zames_pro 2.95.4 → 2.95.5

package/CHANGELOG.md

@@ -7,6 +7,25 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zames_pro",
-  "version": "2.95.4",
+  "version": "2.95.5",
   "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": {
@@ -47,6 +47,7 @@
     "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"
   },

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);
-}