zames_pro 2.16.0 → 2.17.0

package/README.md

@@ -9,7 +9,42 @@ directory, reads and edits files, runs commands, and commits to git.
 ## Requirements
 
 - Node.js >= 18
-- A DeepSeek account (you log in manually in the browser window that opens on first launch)
+- A DeepSeek account. On first launch zames asks for your DeepSeek
+  login/password in the terminal (and stores them in `~/.zames/config.json`
+  after a successful sign-in, so a later logout is handled automatically
+  without asking you again). You can also sign in manually in the browser
+  window when the browser is headed.
+
+## Signing in
+
+The browser runs **headless by default**. When DeepSeek requires a sign-in,
+zames:
+
+1. reuses the session stored in the persistent profile (`~/.zames/profile`)
+   if it is still valid;
+2. otherwise signs in automatically with the saved credentials
+   (`browser.auth.username` / `browser.auth.password`);
+3. otherwise asks you for the login/password in the terminal (in a TTY) and,
+   after a successful sign-in, remembers them for next time;
+4. otherwise falls back to a manual sign-in hint.
+
+To sign in by hand (for example, if DeepSeek shows a captcha), run with a
+visible window:
+
+```bash
+zames --headed
+```
+
+The `--headless` flag (the default) and `headless: true` in the config keep
+the browser without a window; `--headed` / `headless: false` show it.
+
+Headless works out of the box: a headless Chrome normally advertises a
+`HeadlessChrome/...` User-Agent that DeepSeek's CDN blocks with a 403, so
+zames strips that marker before loading the page (keeping the real engine
+version). You do not need `--headed` just to log in.
+
+Credentials and toggles can also be edited from `/config`
+(`browser.auth.username`, `browser.auth.password`, `browser.auth.saveSession`).
 
 ## Installation
 
@@ -71,6 +106,7 @@ zames --new-chat
 zames --resend-prompt
 zames --dir <path>
 zames --headless
+zames --headed
 zames --debug
 zames --version
 zames --help

package/dist/agent-loop.js

@@ -4,7 +4,7 @@ import { getGitContext, formatGitContext } from './gitTools.js';
 import { parseXmlToolCalls } from './xml-toolcall.js';
 import { translate } from './i18n.js';
 import { normText } from './browser.js';
-export async function runAgentLoop({ browser, tools, task, workdir, maxIterations = 0, freshChat = false, sendSystemPrompt = false, transcript = null, attachments = [], onThinking = () => { }, onAssistantThought = () => { }, onToolCall = () => { }, onToolResult = () => { }, onAssistantMessage = () => { }, onChatReady = () => { }, onWarning = () => { }, debugLog = false, locale = 'ru', }) {
+export async function runAgentLoop({ browser, tools, task, workdir, maxIterations = 0, freshChat = false, sendSystemPrompt = false, transcript = null, attachments = [], onThinking = () => { }, onSendPause = () => { }, onAssistantThought = () => { }, onToolCall = () => { }, onToolResult = () => { }, onAssistantMessage = () => { }, onChatReady = () => { }, onWarning = () => { }, debugLog = false, locale = 'ru', }) {
     // UI callbacks must NEVER break the agent loop. A rendering error (a huge
     // tool result, a broken markdown frame, a closed terminal) used to throw
     // out of the loop right after a tool call — the session looked "stopped
@@ -26,6 +26,10 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
     // Previously safeThinking() fired before browser.ask(), so the spinner ran
     // through the whole throttle pause / chat-open phase with nothing in flight.
     browser.onSendStart = safeThinking;
+    // Animate the send-interval pause too: the browser reports the remaining
+    // seconds, the UI shows an animated status instead of a frozen line.
+    const safeSendPause = safe(onSendPause);
+    browser.onSendPause = safeSendPause;
     const safeAssistantThought = safe(onAssistantThought);
     const safeToolCall = safe(onToolCall);
     const safeToolResult = safe(onToolResult);

package/dist/browser.js

@@ -5,8 +5,134 @@ import os from 'os';
 import fs from 'fs/promises';
 import { execSync } from 'child_process';
 import { theme } from './theme.js';
+import { translate, DEFAULT_LOCALE } from './i18n.js';
+// Muted terminal input for passwords. We do NOT use readline here: readline
+// echoes the typed text through its own internal _writeToOutput, which cannot
+// be reliably overridden from outside (a real bug: the login prompt swallowed
+// the password step). Instead we read raw keystrokes from stdin and echo one
+// `*` per typed character. In a non-TTY (pipe/redirect) we fall back to a
+// plain line read.
+export function askPassword(question) {
+    return new Promise((resolve) => {
+        process.stdout.write(question);
+        // Non-interactive: read a single line from stdin as-is.
+        if (!process.stdin.isTTY) {
+            void import('readline').then(({ createInterface }) => {
+                const rl = createInterface({
+                    input: process.stdin,
+                    output: process.stdout,
+                });
+                rl.question('', (answer) => {
+                    rl.close();
+                    resolve(answer);
+                });
+            });
+            return;
+        }
+        const stdin = process.stdin;
+        const wasRaw = stdin.isRaw;
+        stdin.setRawMode(true);
+        stdin.resume();
+        let value = '';
+        const onData = (buf) => {
+            const s = buf.toString('utf8');
+            for (const ch of s) {
+                const code = ch.charCodeAt(0);
+                // Enter / Ctrl+J -> done.
+                if (ch === '\r' || ch === '\n') {
+                    done();
+                    return;
+                }
+                // Ctrl+C -> abort the whole process (same as elsewhere in the CLI).
+                if (code === 3) {
+                    cleanup();
+                    process.stdout.write('\n');
+                    process.exit(130);
+                }
+                // Ctrl+D -> finish with whatever we have.
+                if (code === 4) {
+                    done();
+                    return;
+                }
+                // Backspace (0x7f or 0x08): remove the last char and one star.
+                if (code === 127 || code === 8) {
+                    if (value.length > 0) {
+                        value = value.slice(0, -1);
+                        process.stdout.write('\b \b');
+                    }
+                    continue;
+                }
+                // Ignore other control characters (arrows, etc.).
+                if (code < 32)
+                    continue;
+                value += ch;
+                process.stdout.write('*');
+            }
+        };
+        const cleanup = () => {
+            stdin.removeListener('data', onData);
+            try {
+                stdin.setRawMode(wasRaw || false);
+            }
+            catch { }
+            stdin.pause();
+        };
+        const done = () => {
+            cleanup();
+            process.stdout.write('\n');
+            resolve(value);
+        };
+        stdin.on('data', onData);
+    });
+}
 const USER_DATA_DIR = path.join(os.homedir(), '.zames', 'profile');
 const CHAT_URL = 'https://chat.deepseek.com/';
+// A headless Chrome advertises "HeadlessChrome/..." in its User-Agent, and
+// DeepSeek's CDN (CloudFront/WAF) rejects that UA with a plain "403 ERROR"
+// page before the app is even served — so a headless login looked broken while
+// a headed one worked (headed Chrome sends "Chrome/..."). We keep the real
+// engine version and only drop the "Headless" marker. When the operator
+// explicitly set a UA in the config, that one wins (see _launchOnce).
+export function sanitizeHeadlessUA(ua) {
+    return String(ua || '').replace(/HeadlessChrome/g, 'Chrome');
+}
+// Written after a successful sign-in so the next launch knows a session was
+// stored in the persistent profile (used by /doctor and diagnostics).
+const AUTH_MARKER_FILE = path.join(os.homedir(), '.zames', 'auth.json');
+// DeepSeek sign-in form. The login page is served on the same origin and
+// swaps in a password field; the exact classes change, so we match loosely on
+// input types and the known placeholder/autocomplete attributes.
+const PASSWORD_SELECTORS = [
+    'input[type="password"]',
+    'input[autocomplete="current-password"]',
+    'input[autocomplete="new-password"]',
+];
+const LOGIN_SELECTORS = [
+    'input[type="email"]',
+    'input[type="tel"]',
+    'input[name="email"]',
+    'input[name="phone"]',
+    'input[name="username"]',
+    'input[placeholder*="email" i]',
+    'input[placeholder*="phone" i]',
+    'input[placeholder*="телефон" i]',
+    'input[placeholder*="почт" i]',
+    'input[autocomplete="username"]',
+    'input[autocomplete="email"]',
+];
+const LOGIN_SUBMIT_SELECTORS = [
+    // DeepSeek's real button: a div[role=button] with these classes and a
+    // <span class="ds-button__content">Log in</span> inside.
+    'div[role="button"].ds-button--primary.ds-button--filled',
+    'div[role="button"].ds-button--primary',
+    'button[type="submit"]',
+    'button:has-text("Log in")',
+    'button:has-text("Sign in")',
+    'button:has-text("Войти")',
+    'div[role="button"]:has-text("Log in")',
+    'div[role="button"]:has-text("Sign in")',
+    'div[role="button"]:has-text("Войти")',
+];
 const INPUT_SELECTORS = [
     'textarea',
     'div[contenteditable="true"]',
@@ -130,6 +256,16 @@ export class DeepSeekBrowser {
     // is never read/shown). webSearch: the "Smart search" toggle.
     deepThinking;
     webSearch;
+    // Credentials for automatic sign-in. The password is stored in the config
+    // file (~/.zames/config.json) and is used only when DeepSeek has logged the
+    // session out. `saveSession` keeps the profile (cookies) so a fresh launch
+    // reuses the session instead of asking the operator every time.
+    auth;
+    // Interface language for the login prompts printed by the browser itself.
+    locale;
+    // Called after a successful interactive login so index.ts can persist the
+    // credentials into the user config (the browser does not write config).
+    onAuthSave;
     _lastSentAt;
     _abort;
     // The user pressed Esc/Ctrl+C — a "stop" for the WHOLE current batch of
@@ -149,7 +285,15 @@ export class DeepSeekBrowser {
     // a generation really begins, not during the pre-send phase (chat open,
     // throttle wait), which used to show a spinner with no work in flight.
     onSendStart;
-    constructor({ headless = false, debug = false, channel = 'chrome', answerTimeoutMs = 180000, askRetries = 3, stabilityChecks = 2, stabilityDelayMs = 400, minSendIntervalMs = 15000, rateLimitWaitMs = 300000, maxRateLimitRetries = 6, maxServerBusyRetries = 5, serverBusyWaitMs = 3000, deepThinking = false, webSearch = true, } = {}) {
+    // Fired when the agent starts waiting out the send-interval pause, with the
+    // remaining seconds. Lets the UI animate the pause status instead of
+    // printing a static line (the dots used to be frozen during the pause).
+    onSendPause;
+    // User-Agent sent by the browser. In headless mode the "Headless" marker
+    // must be stripped (DeepSeek's CDN answers 403 to it); computed in the
+    // constructor, overridable by an explicit UA in the options/config.
+    userAgent;
+    constructor({ headless = false, debug = false, channel = 'chrome', answerTimeoutMs = 180000, askRetries = 3, stabilityChecks = 2, stabilityDelayMs = 400, minSendIntervalMs = 15000, rateLimitWaitMs = 300000, maxRateLimitRetries = 6, maxServerBusyRetries = 5, serverBusyWaitMs = 3000, deepThinking = false, webSearch = true, auth, locale, onAuthSave, userAgent, } = {}) {
         this.headless = headless;
         this.debug = debug;
         this.channel = channel;
@@ -164,6 +308,13 @@ export class DeepSeekBrowser {
         this.serverBusyWaitMs = serverBusyWaitMs;
         this.deepThinking = deepThinking;
         this.webSearch = webSearch;
+        this.auth = {
+            username: (auth?.username || '').trim(),
+            password: auth?.password || '',
+            saveSession: auth?.saveSession !== false,
+        };
+        this.locale = locale || DEFAULT_LOCALE;
+        this.onAuthSave = onAuthSave || null;
         this._lastSentAt = 0;
         this._abort = false;
         this._stopped = false;
@@ -174,6 +325,16 @@ export class DeepSeekBrowser {
         this._netSniffLimit = 5;
         this._netHookInstalled = false;
         this.onSendStart = null;
+        this.onSendPause = null;
+        // An explicit UA (config/options) is respected as-is. Otherwise it stays
+        // empty here and is derived from the real engine UA after launch — see
+        // _fixHeadlessUserAgent (a headless "HeadlessChrome/..." UA gets 403 from
+        // DeepSeek's CDN).
+        this.userAgent = userAgent ? sanitizeHeadlessUA(userAgent) : '';
+    }
+    /** Translation bound to this browser's locale. */
+    _t(key, params) {
+        return translate(this.locale)(key, params);
     }
     async launch() {
         await killStaleChrome();
@@ -183,6 +344,35 @@ export class DeepSeekBrowser {
             await cleanSingletonFiles();
         }
         await this._launchOnce();
+        await this._fixHeadlessUserAgent();
+    }
+    /**
+     * A headless Chromium advertises "HeadlessChrome/<v>" in its User-Agent, and
+     * DeepSeek's CDN (CloudFront/WAF) answers that UA with a plain "403 ERROR"
+     * page before the app is served — so sign-in worked with a visible window and
+     * silently failed headless. Read the UA the engine really reports and, when
+     * it carries the "Headless" marker, relaunch once with a sanitized
+     * `--user-agent` (the marker removed, the real version kept). A UA passed
+     * explicitly in the options/config is never touched.
+     */
+    async _fixHeadlessUserAgent() {
+        if (!this.headless)
+            return;
+        try {
+            const ua = await this.page.evaluate(() => navigator.userAgent);
+            const fixed = sanitizeHeadlessUA(ua);
+            if (fixed === ua)
+                return;
+            this.userAgent = fixed;
+            if (this.debug)
+                console.error('profile: headless UA → перезапуск с обычным Chrome UA');
+            await this.context.close().catch(() => { });
+            await this._launchOnce();
+        }
+        catch (e) {
+            if (this.debug)
+                console.error('profile: UA-фикс не удался:', e.message);
+        }
     }
     async _launchOnce() {
         const options = {
@@ -195,6 +385,8 @@ export class DeepSeekBrowser {
         };
         if (this.channel)
             options.channel = this.channel;
+        if (this.userAgent)
+            options.userAgent = this.userAgent;
         try {
             this.context = await chromium.launchPersistentContext(USER_DATA_DIR, options);
         }
@@ -273,11 +465,47 @@ export class DeepSeekBrowser {
         await this.launch();
     }
     async waitForLogin() {
-        const loggedIn = await this.isLoggedIn();
-        if (loggedIn)
+        // 1) Already signed in (session cookie in the persistent profile)?
+        if (await this.isLoggedIn()) {
+            if (this.debug)
+                console.error('auth: сессия уже активна');
+            return;
+        }
+        // 2) Try to sign in automatically with the saved credentials. The
+        //    password lives in the config (~/.zames/config.json) and is only used
+        //    when the session is logged out — i.e. exactly the "re-login without
+        //    asking" case. If the login form is absent (e.g. DeepSeek uses a
+        //    captcha / another provider), this fails and we fall through.
+        if (this.auth.username && this.auth.password) {
+            console.log(theme.system(this._t('auth.auto_login')));
+            const ok = await this._autoLogin().catch((e) => {
+                console.log(theme.warn(this._t('auth.auto_login_failed', { v: e.message })));
+                return false;
+            });
+            if (ok) {
+                console.log(theme.assistant(this._t('auth.auto_login_ok')));
+                return;
+            }
+        }
+        // 3) Ask the operator for credentials in the terminal, try them, and
+        //    only then fall back to the manual hint. Interactive only: in a
+        //    pipe/redirect (or headless without credentials) we print a hint.
+        const asked = await this._promptAndLogin().catch((e) => {
+            if (this.debug)
+                console.error('auth: prompt error:', e.message);
+            return false;
+        });
+        if (asked)
             return;
-        console.log('\n🔐 Залогиньтесь в DeepSeek в открытом браузере.');
-        console.log('   После входа нажмите Enter в терминале...\n');
+        // 4) Last resort: manual sign-in in the browser window.
+        console.log('\n' + theme.warn(this._t('auth.need_login')));
+        if (this.headless) {
+            console.log('   ' + this._t('auth.manual_hint_headless'));
+        }
+        else {
+            console.log('   ' + this._t('auth.manual_hint'));
+        }
+        console.log('\n');
         const readline = await import('readline');
         const rl = readline.createInterface({
             input: process.stdin,
@@ -289,20 +517,286 @@ export class DeepSeekBrowser {
                 resolve();
             });
         });
+        if (await this.isLoggedIn()) {
+            await this._persistSessionIfNeeded();
+            console.log(theme.assistant(this._t('auth.auto_login_ok')));
+        }
     }
-    async isLoggedIn() {
-        for (const sel of INPUT_SELECTORS) {
-            try {
-                await this.page.locator(sel).first().waitFor({
-                    state: 'visible',
-                    timeout: 3000,
-                });
+    /**
+     * Try to sign in with this.auth. Returns true when the login form was
+     * filled and the session became active. Never throws for a missing form —
+     * the caller decides whether to fall back.
+     */
+    async _autoLogin() {
+        const filled = await this._fillLoginForm(this.auth.username, this.auth.password);
+        if (!filled)
+            return false;
+        const ok = await this._waitLoggedIn(20_000);
+        if (ok)
+            await this._persistSessionIfNeeded();
+        return ok;
+    }
+    /**
+     * Ask the operator for login/password in the terminal (only in a TTY) and
+     * try them. An empty password falls back to the saved one. Returns true
+     * when the sign-in succeeded.
+     */
+    async _promptAndLogin() {
+        if (!process.stdin.isTTY || !process.stdout.isTTY)
+            return false;
+        const hasSaved = !!(this.auth.username && this.auth.password);
+        // Prompt only when we have a login field to fill.
+        if (!(await this._loginFormVisible())) {
+            if (this.debug)
+                console.error('auth: форма входа не найдена');
+            return false;
+        }
+        console.log('\n' + theme.warn(this._t('auth.need_login')));
+        // Username via a normal readline question (echoed).
+        let user = this.auth.username;
+        if (!user) {
+            const readline = await import('readline');
+            const rl = readline.createInterface({
+                input: process.stdin,
+                output: process.stdout,
+                terminal: true,
+            });
+            user = (await new Promise((resolve) => rl.question(this._t('auth.prompt_login'), (a) => resolve(a)))).trim();
+            rl.close();
+        }
+        // Password via raw keystroke reading, echoed as `*` (readline would echo
+        // it in clear or swallow the prompt — see askPassword).
+        const passPromptKey = hasSaved
+            ? 'auth.prompt_password_saved'
+            : 'auth.prompt_password';
+        const pass = await askPassword(this._t(passPromptKey));
+        const password = pass || this.auth.password;
+        if (!user || !password)
+            return false;
+        console.log(theme.system(this._t('auth.auto_login')));
+        const filled = await this._fillLoginForm(user, password);
+        if (!filled) {
+            console.log(theme.warn(this._t('auth.form_not_found')));
+            return false;
+        }
+        const ok = await this._waitLoggedIn(20_000);
+        if (ok) {
+            // Remember the credentials so the next launch can re-login silently.
+            this.auth.username = user;
+            this.auth.password = password;
+            await this._persistSessionIfNeeded();
+            this.onAuthSave?.(user, password);
+            console.log(theme.assistant(this._t('auth.auto_login_ok')));
+        }
+        else {
+            // Detect a credentials error shown by DeepSeek, otherwise report a
+            // generic failure with the page hint so the operator can react.
+            const reason = await this._readLoginError();
+            if (reason) {
+                console.log(theme.error(this._t('auth.login_rejected', { v: reason })));
+            }
+            else {
+                console.log(theme.warn(this._t('auth.auto_login_failed', { v: this._t('auth.no_reason') })));
+            }
+        }
+        return ok;
+    }
+    /**
+     * Read a visible login/credentials error message from the page, if any.
+     * Best-effort: returns '' when nothing recognizable is found.
+     */
+    async _readLoginError() {
+        try {
+            const txt = await this.page.evaluate(() => {
+                const sels = [
+                    '[role="alert"]',
+                    '[class*="error" i]',
+                    '[class*="toast" i]',
+                    '[class*="notification" i]',
+                ];
+                let out = '';
+                for (const s of sels) {
+                    for (const el of Array.from(document.querySelectorAll(s))) {
+                        const e = el;
+                        const st = getComputedStyle(e);
+                        if (st.display === 'none' || st.visibility === 'hidden')
+                            continue;
+                        const t = (e.innerText || '').trim();
+                        if (t)
+                            out += ' ' + t;
+                    }
+                }
+                return out.replace(/\s+/g, ' ').trim();
+            });
+            return txt.slice(0, 200);
+        }
+        catch {
+            return '';
+        }
+    }
+    /** Is a login form (password field) present on the page? */
+    async _loginFormVisible() {
+        return await this.page
+            .locator(PASSWORD_SELECTORS.join(', '))
+            .first()
+            .isVisible({ timeout: 2000 })
+            .catch(() => false);
+    }
+    /**
+     * Fill the DeepSeek sign-in form with the given credentials and submit it.
+     * Returns false if the form (or the submit button) is not found.
+     */
+    async _fillLoginForm(username, password) {
+        const pwd = await this._findVisible(PASSWORD_SELECTORS, 4000);
+        if (!pwd)
+            return false;
+        // The email/phone field is the text input above the password field. Try
+        // the known selectors first, then fall back to the nearest text input.
+        let userInput = await this._findVisible(LOGIN_SELECTORS, 2000);
+        if (!userInput) {
+            // Find the index of the password input and use the closest preceding
+            // text/email/tel input as the login field.
+            const idx = await this.page.evaluate((pwdSel) => {
+                const p = document.querySelector(pwdSel);
+                if (!p)
+                    return -1;
+                const inputs = Array.from(document.querySelectorAll('input'));
+                const pi = inputs.indexOf(p);
+                for (let i = pi - 1; i >= 0; i--) {
+                    const t = (inputs[i].type || 'text').toLowerCase();
+                    if (t === 'text' || t === 'email' || t === 'tel')
+                        return i;
+                }
+                return -1;
+            }, PASSWORD_SELECTORS[0]);
+            if (idx >= 0)
+                userInput = this.page.locator('input').nth(idx);
+        }
+        if (!userInput)
+            return false;
+        await this._setInputText(userInput, username);
+        await this._setInputText(pwd, password);
+        await this.page.waitForTimeout(150);
+        // Submit. DeepSeek's login form is a React form; the button text is
+        // localized and classes change, so we try, in order:
+        //   1. known submit selectors;
+        //   2. a submit/primary button inside the same <form> as the password;
+        //   3. pressing Enter in the password field;
+        //   4. clicking the password field's closest button sibling.
+        // After each attempt we give the login a short window and stop as soon as
+        // it succeeds, so a stray click does not fire on an already-logged-in page.
+        const tryLogin = async () => {
+            if (await this._waitLoggedIn(3000))
                 return true;
+            return false;
+        };
+        // Precise first attempt: DeepSeek's button is
+        // <div role="button" class="ds-button ds-button--primary ...">
+        //   <span class="ds-button__content">Log in</span></div>
+        // Click exactly the one whose visible label is a login word, so we never
+        // hit "Log in with Google" or another primary button by mistake.
+        const precise = this.page
+            .locator('div[role="button"].ds-button--primary, button')
+            .filter({ hasText: /^\s*(log ?in|sign ?in|войти)\s*$/i });
+        const pc = await precise.count().catch(() => 0);
+        if (pc > 0) {
+            try {
+                await precise.last().click({ timeout: 2000 });
+                if (await tryLogin())
+                    return true;
+            }
+            catch { }
+        }
+        for (const sel of LOGIN_SUBMIT_SELECTORS) {
+            const btn = this.page.locator(sel).last();
+            try {
+                if ((await btn.count()) === 0)
+                    continue;
+                if (!(await btn.isVisible().catch(() => false)))
+                    continue;
+                await btn.click({ timeout: 2000 });
+                if (await tryLogin())
+                    return true;
             }
             catch { }
         }
+        // Button inside the same form as the password field.
+        const formClicked = await this.page
+            .evaluate((pwdSel) => {
+            const p = document.querySelector(pwdSel);
+            if (!p)
+                return false;
+            const form = p.closest('form');
+            const scope = form || document;
+            const btns = Array.from(scope.querySelectorAll('button[type="submit"], button, div[role="button"]'));
+            for (const b of btns) {
+                const txt = (b.textContent || '').trim().toLowerCase();
+                const aria = (b.getAttribute('aria-label') || '').toLowerCase();
+                if (/log ?in|sign ?in|войти|continue|продолж/.test(txt + ' ' + aria)) {
+                    b.click();
+                    return true;
+                }
+            }
+            // Fallback: the primary-looking button in the scope.
+            const primary = btns.find((b) => {
+                const cls = (b.className || '').toString();
+                return /primary|submit|ds-button--primary/i.test(cls);
+            });
+            if (primary) {
+                primary.click();
+                return true;
+            }
+            return false;
+        }, PASSWORD_SELECTORS[0])
+            .catch(() => false);
+        if (formClicked && (await tryLogin()))
+            return true;
+        // Enter in the password field.
+        await pwd.press('Enter').catch(() => { });
+        return true;
+    }
+    /** Poll isLoggedIn until it succeeds or the deadline passes. */
+    async _waitLoggedIn(timeoutMs) {
+        const deadline = Date.now() + timeoutMs;
+        while (Date.now() < deadline) {
+            if (await this.isLoggedIn().catch(() => false))
+                return true;
+            await this.page.waitForTimeout(500);
+        }
         return false;
     }
+    /**
+     * Persist the authenticated session. The persistent profile already keeps
+     * cookies on disk; `saveSession` (config) is kept as an explicit toggle for
+     * the operator. We additionally save a small marker so /doctor and the next
+     * launch can tell that a session exists.
+     */
+    async _persistSessionIfNeeded() {
+        if (!this.auth.saveSession)
+            return;
+        if (!(await this.isLoggedIn().catch(() => false)))
+            return;
+        try {
+            await fs.mkdir(path.join(os.homedir(), '.zames'), { recursive: true });
+            await fs.writeFile(AUTH_MARKER_FILE, JSON.stringify({ at: new Date().toISOString() }, null, 2), 'utf-8');
+        }
+        catch { }
+    }
+    async isLoggedIn() {
+        // Single combined query with a short timeout: the old loop waited up to
+        // 3s PER selector (9s total), and _waitLoggedIn calls this repeatedly,
+        // which made login feel like it "hangs".
+        try {
+            await this.page
+                .locator(INPUT_SELECTORS.join(', '))
+                .first()
+                .waitFor({ state: 'visible', timeout: 2000 });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
     async newChat() {
         const newChatBtn = this.page
             .locator('button, a')
@@ -690,20 +1184,47 @@ export class DeepSeekBrowser {
         const gap = this.minSendIntervalMs - (Date.now() - this._lastSentAt);
         if (gap <= 0)
             return;
-        console.error(theme.warn(`⏳ пауза ${Math.ceil(gap / 1000)}с перед отправкой`));
-        await this._sleepInterruptible(gap);
+        // Report the pause to the UI as an ANIMATED status (with the remaining
+        // seconds) instead of the old static console line — the dots used to be
+        // frozen here, which looked like the spinner had hung. The seconds are
+        // refreshed once per second, so the status visibly counts down.
+        const report = (leftMs) => {
+            const secs = Math.max(0, Math.ceil(leftMs / 1000));
+            if (this.onSendPause) {
+                try {
+                    this.onSendPause(secs);
+                }
+                catch { }
+            }
+            else {
+                console.error(theme.warn(`⏳ send pause ${secs}s`));
+            }
+        };
+        report(gap);
+        await this._sleepInterruptible(gap, report);
     }
     // Sleep in small slices so Esc/Ctrl+C can cancel the wait promptly.
     // Returns true if the sleep was cut short by _abort.
-    async _sleepInterruptible(ms) {
+    //
+    // onTick (optional) is called about once per second with the remaining time,
+    // so the UI can show a live countdown during the pause.
+    async _sleepInterruptible(ms, onTick) {
         const step = 100;
         let left = ms;
+        let sinceTick = 0;
         while (left > 0) {
             if (this._abort)
                 return true;
             const chunk = Math.min(step, left);
             await this.page.waitForTimeout(chunk);
             left -= chunk;
+            if (onTick) {
+                sinceTick += chunk;
+                if (sinceTick >= 1000) {
+                    sinceTick = 0;
+                    onTick(left);
+                }
+            }
         }
         return this._abort;
     }

package/dist/commands.js

@@ -153,6 +153,7 @@ export function renderDoctor(d) {
     row(d.gitOk, 'git', d.gitOk ? 'repo (' + (d.gitBranch || 'detached') + ')' : 'not a repository');
     row(d.configOk, 'config', d.configOk ? 'loaded' : 'error: ' + (d.configError || 'unknown'));
     row(true, 'browser', d.browserChannel ? d.browserChannel : 'bundled chromium');
+    row(!!d.authSaved, 'auth', d.authSaved ? 'session saved (auto re-login ready)' : 'no saved session');
     row(!!d.clipboardTool, 'clipboard', d.clipboardTool || 'no tool found (image paste disabled)');
     row(true, 'mcp', d.mcpServers + ' server(s), ' + d.mcpTools + ' tool(s)');
     row(d.transcriptOk, 'transcript', d.transcriptOk ? 'on' : 'off');

package/dist/config-menu.js

@@ -19,6 +19,10 @@ function displayValue(field, value, t) {
         return t('cfg.menu.default');
     if (typeof value === 'boolean')
         return value ? t('common.on') : t('common.off');
+    // Never print a password in clear text: show a fixed mask when set.
+    if (/password/i.test(field.path) && String(value).length > 0) {
+        return '********';
+    }
     return String(value);
 }
 function groupLabel(field, t) {

package/dist/config.js

@@ -7,7 +7,9 @@ const HOME_CONFIG = path.join(ZAMES_HOME, 'config.json');
 const PROJECT_CONFIG = path.join(process.cwd(), '.zamesrc.json');
 export const DEFAULTS = {
     maxIterations: 0,
-    headless: false,
+    // Headless by default: the browser runs without a visible window. Set
+    // headless: false (or pass --headed) to watch/debug the DeepSeek page.
+    headless: true,
     debug: false,
     browserChannel: null,
     confirmation: {
@@ -43,6 +45,11 @@ export const DEFAULTS = {
         maxRateLimitRetries: 6,
         deepThinking: false,
         webSearch: true,
+        auth: {
+            username: '',
+            password: '',
+            saveSession: true,
+        },
     },
     ui: {
         locale: DEFAULT_LOCALE,
@@ -81,6 +88,9 @@ export const CONFIG_SCHEMA = [
     { path: 'ui.locale', type: 'enum', values: ['ru', 'en'], labelKey: 'cfg.f.ui_locale', groupKey: 'cfg.group.ui' },
     { path: 'maxIterations', type: 'number', min: 0, max: 100000, labelKey: 'cfg.f.maxIterations', groupKey: 'cfg.group.agent' },
     { path: 'headless', type: 'boolean', labelKey: 'cfg.f.headless', groupKey: 'cfg.group.agent' },
+    { path: 'browser.auth.username', type: 'string', labelKey: 'cfg.f.browser_authUsername', groupKey: 'cfg.group.browser' },
+    { path: 'browser.auth.password', type: 'string', labelKey: 'cfg.f.browser_authPassword', groupKey: 'cfg.group.browser' },
+    { path: 'browser.auth.saveSession', type: 'boolean', labelKey: 'cfg.f.browser_authSaveSession', groupKey: 'cfg.group.browser' },
     { path: 'debug', type: 'boolean', labelKey: 'cfg.f.debug', groupKey: 'cfg.group.agent' },
     { path: 'hotReload', type: 'boolean', labelKey: 'cfg.f.hotReload', groupKey: 'cfg.group.agent' },
     { path: 'confirmation.write', type: 'boolean', labelKey: 'cfg.f.confirmation_write', groupKey: 'cfg.group.confirmation' },

package/dist/i18n.js

@@ -46,7 +46,8 @@ const CATALOG = {
     'help.opt.new_chat': { ru: 'начать новый чат (по умолчанию)', en: 'start a new chat (default)' },
     'help.opt.resend_prompt': { ru: 'дослать system-prompt в существующий чат', en: 'resend system-prompt into an existing chat' },
     'help.opt.max_iter': { ru: 'лимит итераций, 0 = без лимита ({n})', en: 'iteration limit, 0 = unlimited ({n})' },
-    'help.opt.headless': { ru: 'браузер без UI', en: 'headless browser' },
+    'help.opt.headless': { ru: 'браузер без UI (по умолчанию)', en: 'headless browser (default)' },
+    'help.opt.headed': { ru: 'показать окно браузера (отладка/вход)', en: 'show the browser window (debug/sign-in)' },
     'help.opt.debug': { ru: 'подробный лог', en: 'verbose log' },
     'help.opt.calibrate': { ru: 'режим калибровки селекторов', en: 'selector calibration mode' },
     'help.opt.dev': { ru: 'режим разработки: авто-перечитывание модулей', en: 'dev mode: auto-reload modules' },
@@ -132,6 +133,9 @@ const CATALOG = {
         en: 'Mixing the slurry…|Whipping it to a smooth paste…|Stirring logic into it…|Shaking it into a cocktail…|Whisking it around…|Blending it with caffeine…|Kneading dough out of it…|Whipping it into foam…|Tossing it with a spatula…|Kneading clay out of it…|Homogenizing it into concrete…|Shaking it until clear…|Blending it into a smoothie…|Mixing cement out of it…|Whipping porridge out of it…|Stirring it with hope…|Swirling the sediment…|Running the blender over it…|Mixing it beyond recognition…|Mixing mortar out of it…|Whipping a cocktail of it…|Stirring it with the deadline spatula…|Whipping foam out of it…|Homogenizing it evenly…|Tumbling it in a cement mixer…|Beating it into a uniform mass…|Stirring it until clear…|Mixing it from whatever is around…',
     },
     'spinner.hint': { ru: 'Esc — стоп', en: 'Esc — stop' },
+    'spinner.pause': { ru: '⏳ пауза {n}с перед отправкой', en: '⏳ pause {n}s before send' },
+    'editor.more': { ru: '…ещё {n}', en: '…{n} more' },
+    'editor.answer': { ru: '● Ответ', en: '● Answer' },
     // ---------- status ----------
     'status.workdir': { ru: 'Рабочая директория: {v}', en: 'Working directory: {v}' },
     'status.review_mode': { ru: 'Режим ревью: {v}', en: 'Review mode: {v}' },
@@ -295,6 +299,37 @@ const CATALOG = {
     'cfg.f.browser_maxRateLimitRetries': { ru: 'Число повторов при лимите', en: 'Rate-limit retry count' },
     'cfg.f.browser_deepThinking': { ru: 'Глубокое мышление (долго; размышления не выводятся)', en: 'Deep thinking (slow; reasoning is hidden)' },
     'cfg.f.browser_webSearch': { ru: 'Умный поиск в интернете', en: 'Smart web search' },
+    'cfg.f.browser_authUsername': { ru: 'Логин DeepSeek для авто-входа', en: 'DeepSeek login for auto sign-in' },
+    'cfg.f.browser_authPassword': { ru: 'Пароль DeepSeek для авто-входа', en: 'DeepSeek password for auto sign-in' },
+    'cfg.f.browser_authSaveSession': { ru: 'Сохранять сессию входа в профиле', en: 'Persist the login session in the profile' },
+    // ---------- login / auth ----------
+    'auth.need_login': { ru: '🔐 Требуется вход в DeepSeek.', en: '🔐 DeepSeek sign-in required.' },
+    'auth.prompt_login': { ru: 'Логин DeepSeek (телефон/email): ', en: 'DeepSeek login (phone/email): ' },
+    'auth.prompt_password': { ru: 'Пароль DeepSeek: ', en: 'DeepSeek password: ' },
+    'auth.prompt_password_saved': {
+        ru: 'Пароль DeepSeek (Enter — использовать сохранённый): ',
+        en: 'DeepSeek password (Enter — use the saved one): ',
+    },
+    'auth.auto_login': { ru: 'Авто-вход в DeepSeek...', en: 'Signing in to DeepSeek...' },
+    'auth.auto_login_ok': { ru: 'Вход выполнен.', en: 'Signed in.' },
+    'auth.auto_login_failed': { ru: 'Авто-вход не удался: {v}', en: 'Auto sign-in failed: {v}' },
+    'auth.login_rejected': { ru: 'DeepSeek отклонил вход: {v}', en: 'DeepSeek rejected the sign-in: {v}' },
+    'auth.form_not_found': {
+        ru: 'Форма входа не распознана. Запустите с --headed и войдите вручную.',
+        en: 'Login form not recognized. Run with --headed and sign in manually.',
+    },
+    'auth.no_reason': {
+        ru: 'причина не определена (возможно, неверный логин/пароль или капча)',
+        en: 'no reason detected (possibly wrong login/password or a captcha)',
+    },
+    'auth.manual_hint': { ru: 'Войдите в DeepSeek в открытом браузере, затем нажмите Enter.', en: 'Sign in to DeepSeek in the open browser, then press Enter.' },
+    'auth.manual_hint_headless': {
+        ru: 'Войдите в DeepSeek: откройте https://chat.deepseek.com/ в своём браузере. Если включён headless — задайте логин/пароль через /config или запустите с --headed.',
+        en: 'Sign in to DeepSeek: open https://chat.deepseek.com/ in your browser. If headless is on — set the login/password via /config or run with --headed.',
+    },
+    'auth.session_saved': { ru: 'Сессия DeepSeek сохранена.', en: 'DeepSeek session saved.' },
+    'auth.session_restored': { ru: 'Сессия DeepSeek восстановлена.', en: 'DeepSeek session restored.' },
+    'auth.enter_to_continue': { ru: 'Нажмите Enter, чтобы продолжить...', en: 'Press Enter to continue...' },
     'cfg.menu.title': { ru: '⚙ Настройки — выбери параметр', en: '⚙ Settings — choose a parameter' },
     'cfg.menu.hint': { ru: '↑/↓ — выбор, Enter — изменить, q/Esc — выйти', en: '↑/↓ select, Enter edit, q/Esc quit' },
     'cfg.menu.edit_hint': { ru: 'Введи значение и Enter (пусто — отмена)', en: 'Enter a value and press Enter (empty — cancel)' },

package/dist/index.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 import path from 'path';
 import fs from 'fs/promises';
+import { existsSync } from 'fs';
 import { fileURLToPath } from 'url';
 import { theme } from './theme.js';
 import { DeepSeekBrowser } from './browser.js';
@@ -19,6 +20,16 @@ import { formatDiff, diffGitArgs, parseTranscript, summarizeTranscript, renderCo
 import { closeWeb } from './web.js';
 import { saveSession, loadLastSession, listSessions, sessionsDir, } from './sessions.js';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
+// True when a DeepSeek session/credentials were stored earlier (auth.json).
+// Used by /doctor to report that auto re-login is ready.
+function authMarkerExists() {
+    try {
+        return existsSync(path.join(ZAMES_HOME, 'auth.json'));
+    }
+    catch {
+        return false;
+    }
+}
 // ---------- CLI parsing ----------
 const args = process.argv.slice(2);
 function getArg(flag, fallback = null) {
@@ -50,7 +61,11 @@ let currentLocale = isLocale(config.ui?.locale)
 // Translation: reads currentLocale at call time, so a language change takes
 // effect immediately, without a restart (for lines printed afterwards).
 const t = (key, params) => translate(currentLocale)(key, params);
-const headless = hasFlag('--headless') || config.headless;
+// Headless is the default. --headed forces a visible window (useful for the
+// first sign-in or debugging the DOM). --headless keeps it explicit.
+const headless = hasFlag('--headed')
+    ? false
+    : hasFlag('--headless') || config.headless;
 const debug = hasFlag('--debug') || config.debug;
 const calibrate = hasFlag('--calibrate');
 const maxIterArg = getArg('--max-iter', null);
@@ -189,6 +204,7 @@ ${theme.bold(t('help.options'))}
   --resend-prompt    ${t('help.opt.resend_prompt')}
   --max-iter <n>     ${t('help.opt.max_iter', { n: config.maxIterations })}
   --headless         ${t('help.opt.headless')}
+  --headed           ${t('help.opt.headed')}
   --debug            ${t('help.opt.debug')}
   --calibrate        ${t('help.opt.calibrate')}
   --dev              ${t('help.opt.dev')}
@@ -828,6 +844,7 @@ async function runTask(browser, tools, taskText, workdir, opts, attachments = []
                 attachments: next.attachments || [],
                 transcript,
                 onThinking: () => ui.thinking(),
+                onSendPause: (seconds) => ui.sendPause(seconds),
                 onToolCall: (name, toolArgs) => ui.toolCall(name, toolArgs),
                 onToolResult: (result) => ui.toolResult(result),
                 onAssistantMessage: (msg) => ui.assistant(msg),
@@ -881,9 +898,10 @@ async function runTask(browser, tools, taskText, workdir, opts, attachments = []
     finally {
         stopWatching();
         ui.stop();
-        // Detach the send hook so a later browser.ask() outside this task cannot
+        // Detach the send hooks so a later browser.ask() outside this task cannot
         // start a stale spinner.
         browser.onSendStart = null;
+        browser.onSendPause = null;
     }
 }
 // ---------- main ----------
@@ -944,6 +962,18 @@ async function main() {
         debug,
         channel: config.browserChannel,
         ...config.browser,
+        locale: currentLocale,
+        // Persist credentials the operator typed in the terminal so the next
+        // launch can re-login silently after a logout.
+        onAuthSave: (username, password) => {
+            config.browser.auth.username = username;
+            config.browser.auth.password = password;
+            try {
+                writeConfigValue('home', 'browser.auth.username', username);
+                writeConfigValue('home', 'browser.auth.password', password);
+            }
+            catch { }
+        },
     });
     const bootSpinner = mod.createSpinner(currentLocale);
     bootSpinner.thinking();
@@ -1096,6 +1126,7 @@ async function main() {
         const ed = new LineEditor({
             prompt: buildPrompt(),
             commands: buildSlashCommands(),
+            locale: currentLocale,
         });
         editor = ed;
         ed.setTmpDir(TMP_DIR);
@@ -1259,6 +1290,7 @@ async function main() {
             currentLocale = value;
             config.ui.locale = value;
             if (editor) {
+                editor.setLocale(value);
                 editor.setCommands(buildSlashCommands());
                 editor.setPrompt(buildPrompt());
             }
@@ -1304,7 +1336,9 @@ async function main() {
                     ? cur
                         ? t('common.on')
                         : t('common.off')
-                    : JSON.stringify(cur);
+                    : /password/i.test(f.path) && String(cur).length > 0
+                        ? '********'
+                        : JSON.stringify(cur);
             const extra = f.values ? '  [' + f.values.join('|') + ']' : '';
             console.log('    ' +
                 theme.user(f.path) +
@@ -1395,7 +1429,11 @@ async function main() {
             const cur = getByPath(config, key);
             console.log(theme.system(t('cfg.value', {
                 v: key,
-                value: cur === undefined ? t('cfg.menu.default') : JSON.stringify(cur),
+                value: cur === undefined
+                    ? t('cfg.menu.default')
+                    : /password/i.test(key) && String(cur).length > 0
+                        ? '********'
+                        : JSON.stringify(cur),
             })));
             return;
         }
@@ -2101,6 +2139,7 @@ async function main() {
                 mcpServers: mcpStatus.servers.length,
                 mcpTools: mcpStatus.toolCount,
                 transcriptOk: !!transcript.file,
+                authSaved: authMarkerExists(),
             })));
             continue;
         }

package/dist/input.js

@@ -1,6 +1,7 @@
 import { theme } from './theme.js';
 import { renderMarkdown } from './markdown.js';
 import { randomThinkingPhrase, stripEllipsis } from './spinner.js';
+import { translate } from './i18n.js';
 import { AttachmentStore, parseImagePaste, looksLikeFilePath, } from './attachments.js';
 // A permanent input line at the bottom of the terminal + a status/output area above it.
 //
@@ -70,7 +71,6 @@ export function expandPastes(pastes, text) {
 // We align the width to the maximum (3) so the hint doesn't shift.
 const DOTS = ['', '.', '..', '...'];
 const DOTS_PAD = '   ';
-const HINT = theme.dim('  ·  Esc — стоп');
 function safeJson(v) {
     try {
         return JSON.stringify(v);
@@ -184,6 +184,9 @@ export class LineEditor {
     onCtrlC;
     _inPaste;
     _dotTimer;
+    // True while the dot-animation timer is running. Lets sendPause() update
+    // only the base text (remaining seconds) without restarting the timer.
+    _animating;
     _dotPhase;
     _thinkBase;
     _wasRaw;
@@ -212,7 +215,11 @@ export class LineEditor {
     // user could type and send a message mid-operation, and it would be queued
     // and sent right after the operation, breaking the restored session.
     locked;
-    constructor({ prompt = '> ', commands = [] } = {}) {
+    // Interface language for the editor's own labels (hint, answer marker,
+    // pause status). Everything the OPERATOR sees must be localized.
+    locale;
+    constructor({ prompt = '> ', commands = [], locale = 'ru' } = {}) {
+        this.locale = locale;
         this.promptStr = prompt;
         this.buf = '';
         this.cursor = 0;
@@ -226,6 +233,7 @@ export class LineEditor {
         this.onCtrlC = null;
         this._inPaste = false;
         this._dotTimer = null;
+        this._animating = false;
         this._dotPhase = 0;
         this._thinkBase = '';
         this._wasRaw = false;
@@ -362,6 +370,11 @@ export class LineEditor {
         this.promptStr = str;
         this._render();
     }
+    // Update the interface language (labels: hint, answer marker, pause).
+    setLocale(locale) {
+        this.locale = locale;
+        this._render();
+    }
     // Update slash-command descriptions (interface language change).
     setCommands(commands) {
         this.slashCommands = commands;
@@ -412,7 +425,7 @@ export class LineEditor {
             out += NL + lines.join(NL);
             const hidden = sugg.length - shown.length;
             if (hidden > 0)
-                out += NL + theme.dim('   …ещё ' + hidden);
+                out += NL + theme.dim('   ' + translate(this.locale)('editor.more', { n: hidden }));
         }
         process.stdout.write(out);
         const lastRow = lay.rows.length - 1;
@@ -449,36 +462,65 @@ export class LineEditor {
             clearInterval(this._dotTimer);
             this._dotTimer = null;
         }
+        this._animating = false;
     }
     _dots(n) {
         // The dots are the same color as the base and of fixed width — otherwise
         // the hint on the right "jumps" when the animation phase changes.
         return theme.brown(DOTS[n] + DOTS_PAD.slice(DOTS[n].length));
     }
+    // Status-line hint ("Esc — stop"), localized.
+    _hint() {
+        return theme.dim('  ·  ' + translate(this.locale)('spinner.hint'));
+    }
     _startThinking() {
         if (this.pendingText) {
-            this.setStatus(theme.prompt('✎ ') + this.pendingText + HINT);
+            this.setStatus(theme.prompt('✎ ') + this.pendingText + this._hint());
             return;
         }
-        this._thinkBase = theme.brown(stripEllipsis(randomThinkingPhrase()));
+        this._startAnimated(randomThinkingPhrase());
+    }
+    // Animated status: a brown base text plus a growing "running" dot sequence.
+    // Shared by the thinking spinner and the send-pause indicator, so the pause
+    // is animated too (previously the pause was a static console line and the
+    // dots stayed frozen).
+    _startAnimated(baseText) {
+        this._thinkBase = theme.brown(stripEllipsis(baseText));
         this._dotPhase = 0;
-        this.setStatus(this._thinkBase + this._dots(0) + HINT);
+        this.setStatus(this._thinkBase + this._dots(0) + this._hint());
         this._stopDots();
         this._dotTimer = setInterval(() => {
             this._dotPhase = (this._dotPhase + 1) % DOTS.length;
-            this.setStatus(this._thinkBase + this._dots(this._dotPhase) + HINT);
+            this.setStatus(this._thinkBase + this._dots(this._dotPhase) + this._hint());
         }, 400);
+        this._animating = true;
         if (this._dotTimer.unref)
             this._dotTimer.unref();
     }
     thinking() {
         this._startThinking();
     }
+    // The agent is waiting out the send-interval pause before a real send.
+    // Show it as an ANIMATED status with the remaining seconds. The browser
+    // calls this repeatedly (once per second), so we update only the base text
+    // and keep the running dot timer — otherwise the dots would restart from
+    // zero on every update and look frozen on a single dot.
+    sendPause(seconds) {
+        if (this.pendingText)
+            return;
+        const label = translate(this.locale)('spinner.pause', { n: seconds });
+        if (this._animating && this._dotTimer) {
+            this._thinkBase = theme.brown(stripEllipsis(label));
+            this.setStatus(this._thinkBase + this._dots(this._dotPhase) + this._hint());
+            return;
+        }
+        this._startAnimated(label);
+    }
     setPending(text) {
         this.pendingText = text && String(text).length ? String(text) : null;
         if (this.pendingText) {
             this._stopDots();
-            this.setStatus(theme.prompt('✎ ') + this.pendingText + HINT);
+            this.setStatus(theme.prompt('✎ ') + this.pendingText + this._hint());
         }
         else {
             this._startThinking();
@@ -500,7 +542,7 @@ export class LineEditor {
     assistant(msg) {
         this.stop();
         const rendered = renderMarkdown(msg);
-        this.printAbove(NL + theme.assistant('● Ответ') + NL + rendered + NL + theme.dim('─'.repeat(60)));
+        this.printAbove(NL + theme.assistant(translate(this.locale)('editor.answer')) + NL + rendered + NL + theme.dim('─'.repeat(60)));
     }
     // Warning to the operator (e.g. the agent stopped suspiciously).
     // Printed above the input line without overwriting it.

package/dist/spinner.js

@@ -20,6 +20,12 @@ export function createSpinner(locale = 'ru') {
     let dotTimer = null;
     let dotPhase = 0;
     let pending = null;
+    // Current animated base text and its dot renderer. Kept in variables (not
+    // captured in the interval closure) so sendPause() can update the text
+    // without restarting the dot animation — otherwise the dots would reset to
+    // zero every second and look frozen on a single dot.
+    let animBase = '';
+    let animating = false;
     // Dot animation: start from an empty string (0 dots), then grow.
     // We align the width to the maximum (3) so the hint doesn't shift.
     const DOTS = ['', '.', '..', '...'];
@@ -35,19 +41,23 @@ export function createSpinner(locale = 'ru') {
             clearInterval(dotTimer);
             dotTimer = null;
         }
+        animating = false;
         if (spinner)
             spinner.stop();
     };
     // Hint in the status line: while the agent works the terminal is live,
     // so you can type the next message. Without it this is not obvious.
     const HINT = theme.dim('  ·  ' + translate(locale)('spinner.hint'));
-    // Start the animated status: brown text + "running" dots.
-    const startThinking = () => {
-        const base = theme.brown(stripEllipsis(randomThinkingPhrase(locale)));
+    // Run the animated status line: a brown base text plus a growing/shrinking
+    // "running" dot sequence. Shared by the thinking spinner and the send-pause
+    // indicator, so the pause is animated too (before, it was a static line and
+    // the dots did not move — the operator saw a frozen spinner).
+    const startAnimated = (baseText) => {
+        animBase = theme.brown(stripEllipsis(baseText));
         // The dots are the same color as the base and of fixed width — otherwise
         // the hint on the right "jumps" when the animation phase changes.
         const dots = (n) => theme.brown(DOTS[n] + DOTS_PAD.slice(DOTS[n].length));
-        start(base + dots(0) + HINT);
+        start(animBase + dots(0) + HINT);
         dotPhase = 0;
         if (dotTimer)
             clearInterval(dotTimer);
@@ -55,11 +65,16 @@ export function createSpinner(locale = 'ru') {
             if (!spinner)
                 return;
             dotPhase = (dotPhase + 1) % DOTS.length;
-            spinner.text = base + dots(dotPhase) + HINT;
+            spinner.text = animBase + dots(dotPhase) + HINT;
         }, 400);
+        animating = true;
         if (dotTimer.unref)
             dotTimer.unref();
     };
+    // Start the animated status: brown text + "running" dots.
+    const startThinking = () => {
+        startAnimated(randomThinkingPhrase(locale));
+    };
     // Show the typed but not yet sent text instead of the spinner.
     // Lets you type a message right while the agent is working.
     const showPending = () => {
@@ -67,6 +82,7 @@ export function createSpinner(locale = 'ru') {
             clearInterval(dotTimer);
             dotTimer = null;
         }
+        animating = false;
         if (!spinner)
             spinner = ora('');
         spinner.start();
@@ -80,6 +96,23 @@ export function createSpinner(locale = 'ru') {
             }
             startThinking();
         },
+        // The agent is waiting out the send-interval pause before a real send.
+        // Show it as an ANIMATED status line with the remaining seconds, so the
+        // spinner keeps moving during the pause (previously a static console line
+        // was printed and the dots stayed frozen).
+        sendPause: (seconds) => {
+            if (pending)
+                return;
+            const label = translate(locale)('spinner.pause', { n: seconds });
+            // Update only the base text while the dot animation is already running,
+            // so the countdown refreshes without resetting the dots.
+            if (animating && dotTimer && spinner) {
+                animBase = theme.brown(stripEllipsis(label));
+                spinner.text = animBase + theme.brown(DOTS[dotPhase] + DOTS_PAD.slice(DOTS[dotPhase].length)) + HINT;
+                return;
+            }
+            startAnimated(label);
+        },
         // The text the user types while the agent is working.
         // Empty string / null — restore the regular spinner.
         setPending: (text) => {
@@ -106,7 +139,7 @@ export function createSpinner(locale = 'ru') {
             const rendered = renderMarkdown(msg);
             // Model answer marker: helps visually separate it from the user's input
             // (which is highlighted by the prompt with a golden arrow).
-            console.log(NL + theme.assistant('● Ответ') + NL);
+            console.log(NL + theme.assistant(translate(locale)('editor.answer')) + NL);
             console.log(rendered);
             console.log(theme.dim('─'.repeat(60)) + NL);
         },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zames_pro",
-  "version": "2.16.0",
+  "version": "2.17.0",
   "description": "Terminal coding agent over chat.deepseek.com via Playwright",
   "type": "module",
   "bin": {