zames_pro 2.29.0 → 2.29.2

package/dist/browser.js

@@ -160,6 +160,16 @@ const STOP_SELECTORS = [
     'button:has-text("Остановить")',
     'button[aria-label*="Stop" i]',
 ];
+// DeepSeek's "Continue" button. With the reasoning ("Deep thinking") toggle
+// on, the server caps the THINK phase: the reasoning stops mid-way and the UI
+// offers a Continue button (this is NOT the same as a truncated turn with
+// generation_err — there the answer failed; here the model simply paused).
+// The agent must click it so the reasoning/answer keeps flowing, otherwise the
+// turn sits idle until the operator presses Continue by hand.
+//
+// The button is found by scanning every div[role=button]/button and matching
+// an EXACT short label ("Continue" / "Продолжить"), because the class names
+// change and :has-text is not valid in a page-side querySelectorAll.
 // DeepSeek UI service statuses that are NOT the model's answer.
 // Otherwise the agent takes a status (Reading...) for an answer and breaks parsing.
 const STATUS_RE = /^(reading|thinking|searching|analyzing|generating|stop|остановить|читаю|думаю|поиск|анализ)[\s.…]*$/i;
@@ -177,6 +187,19 @@ const RATE_LIMIT_RE = /(messages? too frequent|too many requests|rate limit|сл
 // rate limit, these usually clear in seconds, so we retry quickly instead of
 // waiting minutes. "Server busy", 503, "temporarily unavailable", etc.
 const SERVER_BUSY_RE = /(server (is )?busy|server error|service (is )?unavailable|temporarily unavailable|internal server error|502|503|504|server overloaded|сервер занят|сервер перегружен|сервис недоступен|внутренняя ошибка|попробуйте позже)/i;
+// DeepSeek turns a generation that FAILED mid-way into a truncated turn
+// (`quasi_status: INCOMPLETE` + `finish_reason: generation_err`) and shows a
+// "Continue" button in the UI. The failure is invisible to the answer text:
+// the DOM keeps the partial answer (often the previous one), so the finish
+// loop used to wait out the whole timeout and throw ds.send_no_new_answer.
+// The SSE body IS available (net-capture keeps it as `_netCapture`), so we
+// recognize the failed/truncated turn from it and retry instead of hanging.
+const GENERATION_ERR_RE = /"finish_reason":\s*"generation_err"/i;
+const INCOMPLETE_STATUS_RE = /"quasi_status","v":"INCOMPLETE"/i;
+export function isGenerationIncompleteText(text) {
+    const t = String(text || '');
+    return GENERATION_ERR_RE.test(t) || INCOMPLETE_STATUS_RE.test(t);
+}
 export function isRateLimitText(text) {
     return RATE_LIMIT_RE.test(String(text || ''));
 }
@@ -210,6 +233,20 @@ export class ServerBusyError extends Error {
         this.name = 'ServerBusyError';
     }
 }
+// The generation was truncated by the server (`generation_err` / INCOMPLETE).
+// Distinct from ServerBusyError: the DeepSeek backend answered, but the turn
+// did not finish, and the UI offers a "Continue" button. The agent retries the
+// same send (a new message into the chat) instead of waiting for an answer
+// that will never arrive. This is what the operator hit with the reasoning
+// (deep thinking) mode on: the long THINK phase makes the truncation far more
+// likely, so with thinking off everything worked and with it on the turn kept
+// stopping and showing "Continue".
+export class GenerationIncompleteError extends Error {
+    constructor(detail) {
+        super('Generation incomplete (server truncated the answer). ' + detail);
+        this.name = 'GenerationIncompleteError';
+    }
+}
 // ---------- profile cleanup ----------
 async function cleanSingletonFiles() {
     const names = ['SingletonLock', 'SingletonCookie', 'SingletonSocket'];
@@ -249,6 +286,12 @@ export class DeepSeekBrowser {
     maxRateLimitRetries;
     maxServerBusyRetries;
     serverBusyWaitMs;
+    // Retries for a turn the server truncated (generation_err / INCOMPLETE).
+    maxIncompleteRetries;
+    incompleteWaitMs;
+    // Click DeepSeek's "Continue" button automatically when the reasoning phase
+    // is paused by the server (deep thinking mode).
+    autoContinue;
     // Desired state of the DeepSeek chat toggles, applied before each send.
     // deepThinking: the "Deep thinking" toggle (reasoning; the reasoning text
     // is never read/shown). webSearch: the "Smart search" toggle.
@@ -307,7 +350,7 @@ export class DeepSeekBrowser {
     // 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, } = {}) {
+    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, maxIncompleteRetries = 4, incompleteWaitMs = 2000, autoContinue = true, deepThinking = false, webSearch = true, auth, locale, onAuthSave, userAgent, } = {}) {
         this.headless = headless;
         this.debug = debug;
         this.channel = channel;
@@ -320,6 +363,9 @@ export class DeepSeekBrowser {
         this.maxRateLimitRetries = maxRateLimitRetries;
         this.maxServerBusyRetries = maxServerBusyRetries;
         this.serverBusyWaitMs = serverBusyWaitMs;
+        this.maxIncompleteRetries = maxIncompleteRetries;
+        this.incompleteWaitMs = incompleteWaitMs;
+        this.autoContinue = autoContinue;
         this.deepThinking = deepThinking;
         this.webSearch = webSearch;
         this.auth = {
@@ -1017,6 +1063,95 @@ export class DeepSeekBrowser {
     async _isGenerating() {
         return await this._stopButtonVisible();
     }
+    // Is DeepSeek's "Continue" button currently visible? Used to BLOCK the
+    // "answer settled" early-return in the finish loop: while Continue is on
+    // screen the generation is PAUSED, not finished, so returning the partial
+    // text there is exactly the "agent stopped with a Continue button" bug.
+    async _continueButtonVisible() {
+        try {
+            return await this.page.evaluate(() => {
+                const labelOf = (b) => ((b.textContent || '') + ' ' + (b.getAttribute('aria-label') || ''))
+                    .replace(/\s+/g, ' ')
+                    .trim();
+                const isExact = (t) => /^(continue|продолжить|продолжение)\s*[.!…]?$/i.test(t);
+                const cands = Array.from(document.querySelectorAll('div[role="button"], button'));
+                for (const e of cands) {
+                    if (!isExact(labelOf(e)))
+                        continue;
+                    const st = getComputedStyle(e);
+                    if (st.display === 'none' || st.visibility === 'hidden')
+                        continue;
+                    if (!e.offsetParent && st.position !== 'fixed')
+                        continue;
+                    return true;
+                }
+                return false;
+            });
+        }
+        catch {
+            return false;
+        }
+    }
+    // Click the DeepSeek "Continue" button when it is visible (reasoning/answer
+    // paused by the server). Returns true when a click happened.
+    //
+    // With the "Deep thinking" toggle on, DeepSeek caps the THINK phase and
+    // shows Continue; the model does NOT resume by itself. Without this, a long
+    // reasoning turn sat idle until the operator pressed Continue by hand. We
+    // only act on an EXACT short label so a random "Continue" in prose (a button
+    // inside a rendered answer, etc.) is never clicked.
+    async _clickContinueIfVisible() {
+        try {
+            const clicked = await this.page.evaluate(() => {
+                // Normalize a label: textContent + aria-label, whitespace collapsed.
+                const labelOf = (b) => ((b.textContent || '') + ' ' + (b.getAttribute('aria-label') || ''))
+                    .replace(/\s+/g, ' ')
+                    .trim();
+                // The button must be a SHORT exact label, otherwise a paragraph or a
+                // rendered "Continue" inside the answer could be clicked by mistake.
+                const isExact = (t) => /^(continue|продолжить|продолжение)\s*[.!…]?$/i.test(t);
+                const cands = Array.from(document.querySelectorAll('div[role="button"], button'));
+                for (const e of cands) {
+                    const t = labelOf(e);
+                    if (!isExact(t))
+                        continue;
+                    const st = getComputedStyle(e);
+                    if (st.display === 'none' || st.visibility === 'hidden')
+                        continue;
+                    if (!e.offsetParent && st.position !== 'fixed')
+                        continue;
+                    // DeepSeek's button is a React component listening for POINTER/mouse
+                    // events, not just a bare click(). A plain e.click() sometimes does
+                    // nothing; dispatching the full sequence is what a real press does.
+                    const rect = e.getBoundingClientRect();
+                    const cx = rect.left + rect.width / 2;
+                    const cy = rect.top + rect.height / 2;
+                    const opts = {
+                        bubbles: true,
+                        cancelable: true,
+                        composed: true,
+                        clientX: cx,
+                        clientY: cy,
+                        button: 0,
+                    };
+                    try {
+                        e.dispatchEvent(new PointerEvent('pointerdown', opts));
+                        e.dispatchEvent(new MouseEvent('mousedown', opts));
+                        e.dispatchEvent(new PointerEvent('pointerup', opts));
+                        e.dispatchEvent(new MouseEvent('mouseup', opts));
+                    }
+                    catch { }
+                    e.click();
+                    return true;
+                }
+                return false;
+            });
+            return !!clicked;
+        }
+        catch {
+            return false;
+        }
+    }
     // DeepSeek exposes two toggle buttons above the input: "Deep thinking"
     // (reasoning) and "Smart search" (web search). Their labels are localized,
     // so we match by a loose regex on the visible text and read the state from
@@ -1125,6 +1260,11 @@ export class DeepSeekBrowser {
         let attempt = 0;
         let rateLimitRetries = 0;
         let serverBusyRetries = 0;
+        // Bumped when DeepSeek truncated the turn (`generation_err`/INCOMPLETE).
+        // The retry does NOT consume a regular ask() attempt: it is a server-side
+        // hiccup, not a failed send, and it is more likely in the reasoning
+        // (deep thinking) mode, where the long THINK phase gets cut off.
+        let incompleteRetries = 0;
         while (attempt < this.askRetries) {
             attempt++;
             try {
@@ -1182,6 +1322,28 @@ export class DeepSeekBrowser {
                         return '(прервано пользователем)';
                     continue;
                 }
+                // The turn was TRUNCATED by the server (`generation_err`, INCOMPLETE):
+                // DeepSeek answered with a partial (often empty) answer and shows a
+                // "Continue" button. In reasoning mode this is much more likely. We
+                // resend the SAME prompt into the chat (that is what the Continue
+                // button does) instead of waiting for an answer that will never come.
+                if (e instanceof GenerationIncompleteError) {
+                    incompleteRetries++;
+                    if (incompleteRetries > this.maxIncompleteRetries) {
+                        console.error(theme.error(this._t('ds.incomplete_give_up', {
+                            attempt: incompleteRetries,
+                        })));
+                        throw e;
+                    }
+                    console.error(theme.warn(this._t('ds.incomplete_retry', {
+                        attempt: incompleteRetries,
+                        max: this.maxIncompleteRetries,
+                    })));
+                    const aborted = await this._sleepInterruptible(this.incompleteWaitMs);
+                    if (aborted)
+                        return '(прервано пользователем)';
+                    continue;
+                }
                 console.error('\n' +
                     theme.warn(this._t('ds.ask_retry', {
                         attempt,
@@ -1527,6 +1689,20 @@ export class DeepSeekBrowser {
             if (isServerBusyText(pageText)) {
                 throw new ServerBusyError(pageText.slice(0, 300));
             }
+            // The turn was truncated by the server: the SSE body carries
+            // finish_reason=generation_err / quasi_status=INCOMPLETE and the UI
+            // shows "Continue". Retry instead of waiting out the whole timeout.
+            if (this._netCapture &&
+                this._netCaptureAt >= this._lastSentAt &&
+                isGenerationIncompleteText(this._netCapture)) {
+                throw new GenerationIncompleteError(this._netCapture.slice(-300));
+            }
+            // Reasoning-mode pause during the THINK phase: click Continue so the
+            // generation resumes (the button appears before any RESPONSE text, so
+            // the start-wait would otherwise spin until the deadline).
+            if (this.autoContinue && (await this._clickContinueIfVisible())) {
+                this._askDebug('CLICKED Continue (start-loop)');
+            }
             const cur = await this._readLastAnswerTextCleanDom().catch(() => '');
             const bodyLen = await this.page
                 .evaluate(() => document.body.innerText.length)
@@ -1562,7 +1738,10 @@ export class DeepSeekBrowser {
             // capture proves a new answer exists. If it stays equal, keep waiting.
             const notGenerating = !(await this._isGenerating());
             const differs = !!cur && normText(cur) !== normText(beforeText);
-            if (differs && cur === lastStartCur && notGenerating) {
+            // Do NOT accept a "settled" answer while Continue is on screen — that
+            // is a paused generation, not a finished one.
+            const paused = this.autoContinue && (await this._continueButtonVisible());
+            if (differs && cur === lastStartCur && notGenerating && !paused) {
                 settledTicks++;
                 if (settledTicks >= 2) {
                     this._askDebug('SETTLED-differs return len=' + cur.length);
@@ -1660,6 +1839,22 @@ export class DeepSeekBrowser {
                     throw new ServerBusyError(pageText.slice(0, 300));
                 }
             }
+            // The server truncated the turn (generation_err / INCOMPLETE). The DOM
+            // keeps the partial answer, so without this check the loop waits out the
+            // whole timeout and throws ds.send_no_new_answer — the operator sees the
+            // agent "stop" with a Continue button in the chat. Retry the send.
+            if (this._netCapture &&
+                this._netCaptureAt >= this._lastSentAt &&
+                isGenerationIncompleteText(this._netCapture)) {
+                throw new GenerationIncompleteError(this._netCapture.slice(-300));
+            }
+            // Reasoning-mode pause: DeepSeek caps the THINK phase and shows a
+            // Continue button; the model does not resume by itself. Click it so the
+            // answer keeps flowing instead of waiting for the operator.
+            if (this.autoContinue && (await this._clickContinueIfVisible())) {
+                this._askDebug('CLICKED Continue (finish-loop)');
+                continue;
+            }
             const netFresh = !!this._netCapture && this._netCaptureAt >= this._lastSentAt;
             // The DOM may be empty while the answer is already in the network
             // capture (a resumed chat re-renders its history, the answer selector
@@ -1687,7 +1882,17 @@ export class DeepSeekBrowser {
                 // so the FIN-loop always cost ~1.6s per answer. Defaults are now
                 // 2 checks x 400ms (~0.8s saved per turn) and the values are honored.
                 if (stable >= Math.max(1, this.stabilityChecks - 1)) {
-                    if (isNew || !(await this._isGenerating())) {
+                    // A PAUSED generation also looks "stable" (the text stops changing
+                    // while Continue is on screen), so the old check returned the
+                    // partial answer here — the "agent stopped with a Continue button"
+                    // symptom. Click Continue and keep waiting instead.
+                    if (this.autoContinue && (await this._continueButtonVisible())) {
+                        if (await this._clickContinueIfVisible()) {
+                            this._askDebug('CLICKED Continue (before early return)');
+                        }
+                        stable = 0;
+                    }
+                    else if (isNew || !(await this._isGenerating())) {
                         this._askDebug('RETURN stable curLen=' + cur.length);
                         return cur;
                     }
@@ -1713,6 +1918,10 @@ export class DeepSeekBrowser {
             await this.page.waitForTimeout(Math.max(0, this.stabilityDelayMs));
         }
         if (last && (normText(last) !== normText(beforeText) || this._netCapture)) {
+            // If Continue is STILL on screen, the turn is paused, not finished:
+            // click once more and report what we have rather than silently stopping.
+            if (this.autoContinue)
+                await this._clickContinueIfVisible();
             this._askDebug('RETURN last len=' + last.length);
             return last;
         }

package/dist/config.js

@@ -43,6 +43,9 @@ export const DEFAULTS = {
         minSendIntervalMs: 15000,
         rateLimitWaitMs: 300000,
         maxRateLimitRetries: 6,
+        maxIncompleteRetries: 4,
+        incompleteWaitMs: 2000,
+        autoContinue: true,
         deepThinking: false,
         webSearch: true,
         auth: {
@@ -230,6 +233,28 @@ export const CONFIG_SCHEMA = [
         labelKey: 'cfg.f.browser_maxRateLimitRetries',
         groupKey: 'cfg.group.browser',
     },
+    {
+        path: 'browser.maxIncompleteRetries',
+        type: 'number',
+        min: 0,
+        max: 100,
+        labelKey: 'cfg.f.browser_maxIncompleteRetries',
+        groupKey: 'cfg.group.browser',
+    },
+    {
+        path: 'browser.incompleteWaitMs',
+        type: 'number',
+        min: 0,
+        max: 600000,
+        labelKey: 'cfg.f.browser_incompleteWaitMs',
+        groupKey: 'cfg.group.browser',
+    },
+    {
+        path: 'browser.autoContinue',
+        type: 'boolean',
+        labelKey: 'cfg.f.browser_autoContinue',
+        groupKey: 'cfg.group.browser',
+    },
     {
         path: 'browser.deepThinking',
         type: 'boolean',

package/dist/i18n.js

@@ -533,6 +533,14 @@ const CATALOG = {
         ru: '⚠ Ответ не получен ({attempt}/{max}): {error} — повторяю...',
         en: '⚠ No answer yet ({attempt}/{max}): {error} — retrying...',
     },
+    'ds.incomplete_retry': {
+        ru: '⏳ DeepSeek оборвал ответ (кнопка Continue в чате) — повторяю отправку ({attempt}/{max})...',
+        en: '⏳ DeepSeek truncated the answer (the Continue button in the chat) — resending ({attempt}/{max})...',
+    },
+    'ds.incomplete_give_up': {
+        ru: '✖ DeepSeek {attempt} раз подряд оборвал ответ, не дойдя до конца. Возможно, включён режим размышления — попробуй выключить его (browser.deepThinking) или повтори позже.',
+        en: '✖ DeepSeek truncated the answer {attempt} times in a row. The reasoning mode (deep thinking) may be on — try turning it off (browser.deepThinking) or retry later.',
+    },
     'ds.ask_restart_browser': {
         ru: '⚠ Браузер потерял страницу — перезапускаю и вхожу заново...',
         en: '⚠ The browser lost the page — restarting and signing in again...',
@@ -858,6 +866,18 @@ const CATALOG = {
         ru: 'Число повторов при лимите',
         en: 'Rate-limit retry count',
     },
+    'cfg.f.browser_maxIncompleteRetries': {
+        ru: 'Повторы при обрыве ответа (Continue)',
+        en: 'Retries when the answer is truncated (Continue)',
+    },
+    'cfg.f.browser_incompleteWaitMs': {
+        ru: 'Пауза перед повтором после обрыва, мс',
+        en: 'Wait before retrying a truncated turn, ms',
+    },
+    'cfg.f.browser_autoContinue': {
+        ru: 'Автонажатие кнопки Continue (режим размышления)',
+        en: 'Auto-click Continue (reasoning mode)',
+    },
     'cfg.f.browser_deepThinking': {
         ru: 'Глубокое мышление (долго; размышления не выводятся)',
         en: 'Deep thinking (slow; reasoning is hidden)',

package/dist/input.js

@@ -233,6 +233,10 @@ export class LineEditor {
     pendingText;
     rendered;
     cursorRowFromTop;
+    // Number of rows occupied by the status/spinner block above the input line,
+    // as computed by the last _writeBlock(). _renderInputOnly() uses it to keep
+    // cursorRowFromTop correct without repainting the status.
+    _statusTop;
     busy;
     onSubmit;
     onEscape;
@@ -309,6 +313,7 @@ export class LineEditor {
         this.pendingText = null;
         this.rendered = false;
         this.cursorRowFromTop = 0;
+        this._statusTop = 0;
         this.busy = false;
         this.onSubmit = null;
         this.onEscape = null;
@@ -642,6 +647,7 @@ export class LineEditor {
         // re-printing the whole block on every keystroke is what made the display
         // flicker on terminals like Tabby. `top` is recovered from the cache so the
         // cursor math stays correct.
+        this._statusTop = top;
         const statusBlock = statusOut;
         const statusUnchanged = this.rendered && statusBlock === this._lastStatusBlock;
         if (statusUnchanged) {
@@ -729,6 +735,52 @@ export class LineEditor {
         this._eraseBlock();
         this._writeBlock();
     }
+    // Repaint ONLY the input rows, leaving the status/spinner block untouched.
+    // Used for buffer/cursor changes (typing, arrows, backspace, …): the status
+    // line has its OWN animation timer, and repainting it on every keystroke
+    // made the whole block blink on terminals like Tabby. When nothing is drawn
+    // yet (rendered === false) fall back to a full render so the very first
+    // paint is correct.
+    _renderInputOnly() {
+        if (!this.rendered) {
+            this._render();
+            return;
+        }
+        const cols = process.stdout.columns || 80;
+        const lay = layoutInput(this.promptStr, this.buf, this.cursor, cols);
+        const inputRows = lay.rows.length;
+        const sugg = this._suggestions();
+        const shown = sugg.slice(0, 8);
+        this._suggestCount = shown.length;
+        const linesBelow = shown.length
+            ? shown.length + (sugg.length > shown.length ? 1 : 0)
+            : 0;
+        this._eraseInputOnly(inputRows + linesBelow);
+        let out = lay.rows.map((r) => r.prefix + r.text).join(NL);
+        if (shown.length) {
+            const maxName = Math.max(...shown.map((c) => c.name.length));
+            const lines = shown.map((c) => {
+                const name = theme.prompt(c.name.padEnd(maxName));
+                const desc = theme.dim('  ' + c.description);
+                return '   ' + name + desc;
+            });
+            out += NL + lines.join(NL);
+            const hidden = sugg.length - shown.length;
+            if (hidden > 0)
+                out +=
+                    NL +
+                        theme.dim('   ' + translate(this.locale)('editor.more', { n: hidden }));
+        }
+        process.stdout.write(out);
+        const up = lay.rows.length - 1 - lay.cursorRow + linesBelow;
+        if (up > 0)
+            process.stdout.write(ESC + '[' + up + 'A');
+        process.stdout.write(CR);
+        if (lay.cursorCol > 0)
+            process.stdout.write(ESC + '[' + lay.cursorCol + 'C');
+        this.rendered = true;
+        this.cursorRowFromTop = this._statusTop + lay.cursorRow;
+    }
     // Print a block ABOVE the input line and put the input line back.
     printAbove(text) {
         this._stopDots();
@@ -1185,7 +1237,7 @@ export class LineEditor {
                     }
                     this._pasteBuf = '';
                 }
-                this._render();
+                this._renderInputOnly();
                 continue;
             }
             const pasteAt = s.indexOf(PASTE_START);
@@ -1196,7 +1248,7 @@ export class LineEditor {
                 this._pasteBuf = '';
                 if (before) {
                     this._insert(before);
-                    this._render();
+                    this._renderInputOnly();
                 }
                 continue;
             }
@@ -1205,31 +1257,31 @@ export class LineEditor {
             if (s.startsWith(ESC + '[13;2u')) {
                 this._insertNewline();
                 s = s.slice(7);
-                this._render();
+                this._renderInputOnly();
                 continue;
             }
             if (s.startsWith(ESC + '[13;5u')) {
                 this._insertNewline();
                 s = s.slice(7);
-                this._render();
+                this._renderInputOnly();
                 continue;
             }
             if (s.startsWith(ESC + '[27;2;13~')) {
                 this._insertNewline();
                 s = s.slice(10);
-                this._render();
+                this._renderInputOnly();
                 continue;
             }
             if (s.startsWith(ESC + '[27;5;13~')) {
                 this._insertNewline();
                 s = s.slice(10);
-                this._render();
+                this._renderInputOnly();
                 continue;
             }
             if (s.startsWith(ESC + NL)) {
                 this._insertNewline();
                 s = s.slice(2);
-                this._render();
+                this._renderInputOnly();
                 continue;
             }
             const ch = s[0];
@@ -1243,7 +1295,7 @@ export class LineEditor {
                 const before = this.cursor > 0 ? Array.from(this.buf)[this.cursor - 1] : '';
                 if (before === '\\') {
                     this._insertNewline();
-                    this._render();
+                    this._renderInputOnly();
                     continue;
                 }
                 this._submit();
@@ -1251,7 +1303,7 @@ export class LineEditor {
             }
             if (code === 10) {
                 this._insertNewline();
-                this._render();
+                this._renderInputOnly();
                 continue;
             }
             if (code === 3) {
@@ -1266,24 +1318,24 @@ export class LineEditor {
             }
             if (code === 1) {
                 this._home();
-                this._render();
+                this._renderInputOnly();
                 continue;
             }
             if (code === 5) {
                 this._end();
-                this._render();
+                this._renderInputOnly();
                 continue;
             }
             if (code === 9) {
                 this._completeCommand();
-                this._render();
+                this._renderInputOnly();
                 continue;
             }
             if (code === 21) {
                 this.buf = '';
                 this.cursor = 0;
                 this.pastes = [];
-                this._render();
+                this._renderInputOnly();
                 continue;
             }
             if (code === 22) {
@@ -1295,7 +1347,7 @@ export class LineEditor {
             }
             if (code === 23) {
                 this._deleteWordLeft();
-                this._render();
+                this._renderInputOnly();
                 continue;
             }
             if (code === 11) {
@@ -1306,12 +1358,12 @@ export class LineEditor {
                     e++;
                 arr.splice(this.cursor, e - this.cursor);
                 this.buf = arr.join('');
-                this._render();
+                this._renderInputOnly();
                 continue;
             }
             if (code === 127 || code === 8) {
                 this._backspace();
-                this._render();
+                this._renderInputOnly();
                 continue;
             }
             if (code === 27) {
@@ -1320,25 +1372,25 @@ export class LineEditor {
                 if (s.startsWith('[1;5D') || s.startsWith('[5D')) {
                     this._wordLeft();
                     s = s.slice(s.startsWith('[1;5D') ? 5 : 3);
-                    this._render();
+                    this._renderInputOnly();
                     continue;
                 }
                 if (s.startsWith('[1;5C') || s.startsWith('[5C')) {
                     this._wordRight();
                     s = s.slice(s.startsWith('[1;5C') ? 5 : 3);
-                    this._render();
+                    this._renderInputOnly();
                     continue;
                 }
                 if (s.startsWith('[D')) {
                     this._left();
                     s = s.slice(2);
-                    this._render();
+                    this._renderInputOnly();
                     continue;
                 }
                 if (s.startsWith('[C')) {
                     this._right();
                     s = s.slice(2);
-                    this._render();
+                    this._renderInputOnly();
                     continue;
                 }
                 if (s.startsWith('[A')) {
@@ -1348,7 +1400,7 @@ export class LineEditor {
                     else
                         this._up();
                     s = s.slice(2);
-                    this._render();
+                    this._renderInputOnly();
                     continue;
                 }
                 if (s.startsWith('[B')) {
@@ -1357,38 +1409,38 @@ export class LineEditor {
                     else
                         this._down();
                     s = s.slice(2);
-                    this._render();
+                    this._renderInputOnly();
                     continue;
                 }
                 if (s.startsWith('[H') || s.startsWith('[1~')) {
                     this._home();
                     s = s.slice(s.startsWith('[1~') ? 3 : 2);
-                    this._render();
+                    this._renderInputOnly();
                     continue;
                 }
                 if (s.startsWith('[F') || s.startsWith('[4~')) {
                     this._end();
                     s = s.slice(s.startsWith('[4~') ? 3 : 2);
-                    this._render();
+                    this._renderInputOnly();
                     continue;
                 }
                 if (s.startsWith('[3~')) {
                     this._delete();
                     s = s.slice(3);
-                    this._render();
+                    this._renderInputOnly();
                     continue;
                 }
                 // Alt+B / Alt+F — word movement.
                 if (s.startsWith('b') || s.startsWith('B')) {
                     this._wordLeft();
                     s = s.slice(1);
-                    this._render();
+                    this._renderInputOnly();
                     continue;
                 }
                 if (s.startsWith('f') || s.startsWith('F')) {
                     this._wordRight();
                     s = s.slice(1);
-                    this._render();
+                    this._renderInputOnly();
                     continue;
                 }
                 let j = 0;
@@ -1400,7 +1452,7 @@ export class LineEditor {
             if (code < 32)
                 continue;
             this._insert(ch);
-            this._render();
+            this._renderInputOnly();
         }
     }
 }

package/package.json

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