micro-models-agent 2.11.0 → 2.13.1

package/dist/ui/line-editor.js

@@ -1,10 +1,14 @@
+// Строчный редактор: raw-ввод, история, Tab-комплит, DSR-якорь кадра (см. DSR ниже).
 import * as readline from "readline";
 import stringWidth from "string-width";
+import { pc } from "./colors";
+import { readEnv } from "../config/env";
 import { buildLayout, layoutIndexFor, visualColAt, charOffsetFor, charLen, stripAnsi, } from "./line-math";
+/** Многострочный редактор ввода с историей и Tab-комплитом (raw-режим TTY). */
 export class LineEditor {
     input;
     output;
-    /** Host hook: return true to swallow the key before the editor handles it. */
+    /** Хук хоста: true — поглотить клавишу до обработки редактором. */
     onKeyInput;
     onInterrupt;
     promptStr;
@@ -14,55 +18,59 @@ export class LineEditor {
     lines = [""];
     row = 0;
     col = 0;
+    /** Перенос не-TTY чанкованного ввода (частичная строка между чтениями). */
+    pendingLine = "";
     historyIndex = -1;
     stash = null;
     isDone = false;
     isPaste = false;
-    /** Pasted characters accumulated between `paste-start` and `paste-end`.
-     *  Inserted as a single batch on `paste-end` — one render instead of one
-     *  per keypress, so a paste appears as a paste, not as fast typing. */
+    /** Вставленное копятся между `paste-start` и `paste-end`.
+     *  Вставляется одним батчем на `paste-end`: один рендер вместо рендера на
+     *  клавишу, чтобы вставка выглядела вставкой, а не быстрой печатью. */
     pasteBuffer = "";
-    /** Whether the last paste keypress was a bare CR — used to collapse a
-     *  CRLF pair into a single newline (Windows clipboard text). */
+    /** Была ли последняя вставленная клавиша голым CR: схлопывает CRLF-пару
+     *  в один перевод строки (текст из буфера Windows). */
     pasteLastWasCR = false;
     lastWasCR = false;
     questionCb = null;
+    /** Активная Tab-сессия комплита. Пока стоит, ↑/↓/Tab крутят кандидатов, а
+     *  Esc возвращает `original`; любая другая клавиша сессию роняет. */
+    completionSession = null;
     rawMode = false;
     listeners = {};
-    /** stdin handlers registered in the constructor — removed in close() so
-     *  re-creating the editor never accumulates stale listeners. */
+    /** stdin-хендлеры из конструктора: снимаются в close(), чтобы пересоздание
+     *  редактора не копило протухшие слушатели. */
     dsrDataHandler;
     keypressHandler;
     dataHandler;
     endHandler;
-    /** Visual row (within the drawn frame) where the cursor was placed by the
-     *  last render — fallback for moving back to the frame's first row before
-     *  redrawing when no absolute anchor is known yet. Relative moves break
-     *  once the terminal scrolls (the frame shifts up on screen while the
-     *  relative count does not), which duplicated multi-line input. */
+    /** Визуальный ряд (внутри рисуемого кадра), куда последний рендер поставил
+     *  курсор. Фолбэк для возврата на первую строку кадра перед перерисовкой,
+     *  пока нет абсолютного якоря. Относительные ходы ломаются при скролле
+     *  терминала (кадр уезжает вверх, счётчик — нет), что дублировало
+     *  многострочный ввод. */
     prevCursorRow = 0;
-    /** Absolute 1-based screen row of the frame's first visual row, learned
-     *  from a single DSR cursor-position report (`ESC[6n`) sent once per
-     *  prompt presentation. After the initial query the anchor is updated
-     *  deterministically via scroll math — no further queries are sent,
-     *  avoiding ConPTY desync. Falls back to relative moves when the reply
-     *  never arrives (timeout / broken terminal). */
+    /** Абсолютный 1-based экранный ряд первой визуальной строки кадра. Выучен
+     *  из одного DSR-ответа о позиции курсора (`ESC[6n`), шлётся раз на показ
+     *  промпта. Дальше якорь ведётся детерминированной скролл-математикой, новых
+     *  запросов нет (защита от рассинхрона ConPTY). Без ответа (таймаут/битый
+     *  терминал) — фолбэк на относительные ходы. */
     frameTopAbs = null;
-    /** True while waiting for a DSR reply (exactly one outstanding query). */
+    /** Ждём ли DSR-ответ (ровно один outstanding-запрос). */
     dsrPending = false;
-    /** Buffer for partial DSR escape sequences split across data chunks. */
+    /** Буфер частичных DSR-escape, разрезанных между чанками. */
     dsrTail = "";
-    /** Visual row of the cursor at the exact moment the outstanding DSR query
-     *  was sent. The reply is matched against this, not `prevCursorRow`, which
-     *  later renders overwrite while the query is still pending. */
+    /** Визуальный ряд курсора ровно в момент отправки outstanding DSR-запроса.
+     *  Ответ матчится против него, а не `prevCursorRow`: промежуточные рендеры
+     *  перезаписывают тот, пока запрос ещё летит. */
     dsrQueryRow = 0;
-    /** When false, keystrokes are ignored (except Ctrl+C) while the agent
-     *  streams — the host owns the terminal during that phase. */
+    /** Выкл — клавиши игнорятся (кроме Ctrl+C), пока агент стримит: терминалом
+     *  в этой фазе владеет хост. */
     inputEnabled = true;
-    /** While true the prompt frame is not drawn; the agent owns the screen. */
+    /** Вкл — кадр промпта не рисуется; экраном владеет агент. */
     frameSuspended = false;
-    /** Clears `dsrPending` when no DSR reply arrives, falling back to
-     *  relative cursor moves instead of wedging on a broken terminal. */
+    /** Сбрасывает `dsrPending`, если DSR-ответ не пришёл: фолбэк на относительные
+     *  ходы вместо клина на битом терминале. */
     dsrTimer = null;
     constructor(opts) {
         this.input = opts.input;
@@ -80,17 +88,17 @@ export class LineEditor {
             if (this.rawMode)
                 this.input.setRawMode(true);
             this.enableTerminalProtocols();
-            // Raw data listener for DSR cursor-position replies. Runs alongside
-            // readline's keypress emitter (both receive every chunk); replies may
-            // arrive merged with regular keystrokes, hence the global regex.
+            // Сырой слушатель DSR-ответов о позиции курсора. Живёт рядом с keypress-эмитером
+            // readline (оба получают каждый чанк); ответы могут приходить склеенными с
+            // обычными клавишами — отсюда глобальный regex.
             this.dsrDataHandler = (buf) => this.consumeDsrReplies(buf.toString("utf-8"));
             this.input.on("data", this.dsrDataHandler);
             readline.emitKeypressEvents(this.input);
             this.keypressHandler = (str, key) => this.onKey(str, key);
             this.input.on("keypress", this.keypressHandler);
-            // The editor owns stdin now: ensure it is flowing even if a previous
-            // consumer paused it (e.g. the setup wizard).
-            this.input.resume?.();
+            // Редактор теперь владеет stdin: взводим flowing, даже если прошлый
+            // потребитель его стопил (напр. визард настройки).
+            this.input.resume();
         }
         else {
             this.dataHandler = (buf) => this.onData(buf);
@@ -189,6 +197,7 @@ export class LineEditor {
         this.col = 0;
         this.historyIndex = -1;
         this.stash = null;
+        this.completionSession = null;
         this.invalidateAnchor();
         if (this.input.isTTY)
             this.render();
@@ -199,6 +208,7 @@ export class LineEditor {
         this.lines = [""];
         this.row = 0;
         this.col = 0;
+        this.completionSession = null;
         this.invalidateAnchor();
         if (this.input.isTTY)
             this.render();
@@ -208,15 +218,14 @@ export class LineEditor {
             return;
         this.isDone = true;
         this.disableTerminalProtocols();
-        const inp = this.input;
         if (this.dsrDataHandler)
-            inp.removeListener("data", this.dsrDataHandler);
+            this.input.removeListener("data", this.dsrDataHandler);
         if (this.keypressHandler)
-            inp.removeListener("keypress", this.keypressHandler);
+            this.input.removeListener("keypress", this.keypressHandler);
         if (this.dataHandler)
-            inp.removeListener("data", this.dataHandler);
+            this.input.removeListener("data", this.dataHandler);
         if (this.endHandler)
-            inp.removeListener("end", this.endHandler);
+            this.input.removeListener("end", this.endHandler);
         if (this.rawMode && this.input.setRawMode) {
             this.input.setRawMode(false);
         }
@@ -226,34 +235,30 @@ export class LineEditor {
         }
         this.emitClose();
     }
-    // ---- input handling ----
+    // ── Ввод ──
     onData(buf) {
         if (this.isDone)
             return;
         let text = buf.toString("utf-8");
         text = text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
         const parts = text.split("\n");
-        for (let i = 0; i < parts.length; i++) {
-            if (i < parts.length - 1) {
-                this.emitLine(parts[i]);
-                this.lines = [""];
-                this.row = 0;
-                this.col = 0;
-            }
-            else if (parts[i]) {
-                this.emitLine(parts[i]);
-                this.lines = [""];
-                this.row = 0;
-                this.col = 0;
-            }
+        // Незавершённый хвост — в следующий чанк: немедленный эмит разрезал бы
+        // `"hello wor" + "ld\n"` на две неверные строки.
+        this.pendingLine += parts[0];
+        for (let i = 1; i < parts.length; i++) {
+            this.emitLine(this.pendingLine);
+            this.lines = [""];
+            this.row = 0;
+            this.col = 0;
+            this.pendingLine = parts[i];
         }
     }
     onKey(str, key) {
         if (this.isDone)
             return;
         if (!this.inputEnabled) {
-            // While streaming, only interrupt keys are honored: Ctrl+C aborts the
-            // run, Escape is forwarded so the host can implement double-Esc abort.
+            // На стриме уважаются только прерывающие клавиши: Ctrl+C абортит прогон,
+            // Esc форвардится, чтобы хост реализовал двойной-Esc аборт.
             const k = key;
             if (k?.ctrl && k.name === "c") {
                 this.ctrlC();
@@ -265,7 +270,31 @@ export class LineEditor {
             }
             return;
         }
-        if (this.onKeyInput && this.onKeyInput(str, key))
+        // Сессия комплита приоритетнее хост-хуков: Esc обязан вернуть исходный
+        // partial, а не дёрнуть хостовый Esc-хендлинг; стрелки/Tab — крутить.
+        // Любая другая клавиша роняет сессию и обрабатывается обычно (с хост-хуком).
+        if (this.completionSession) {
+            const ck = key;
+            const plain = !ck.ctrl && !ck.meta;
+            if (ck?.name === "down" && plain) {
+                this.cycleCompletion(1);
+                return;
+            }
+            if (ck?.name === "up" && plain) {
+                this.cycleCompletion(-1);
+                return;
+            }
+            if (ck?.name === "tab") {
+                this.cycleCompletion(1);
+                return;
+            }
+            if (ck?.name === "escape") {
+                this.cancelCompletion();
+                return;
+            }
+            this.completionSession = null;
+        }
+        if (this.onKeyInput?.(str, key))
             return;
         const k = key;
         const name = k?.name ?? "undefined";
@@ -277,10 +306,9 @@ export class LineEditor {
             }
             return;
         }
-        // Never treat a cursor-position report (`ESC[row;colR`) as typed input:
-        // on some Windows/ConPTY + Bun combinations the trailing "R" leaks into
-        // the buffer and corrupts the answer (observed as every prompt answering
-        // "R"). Swallow the whole sequence.
+        // Отчёт о позиции курсора (`ESC[row;colR`) — никогда не ввод: на части связок
+        // Windows/ConPTY + Bun хвостовой "R" протекает в буфер и портит ответ
+        // (каждый промпт отвечал "R"). Глотаем последовательность целиком.
         if (/^\x1b\[\d+;\d+R$/.test(seq))
             return;
         if (name === "paste-start" || seq === "\x1b[200~") {
@@ -344,8 +372,8 @@ export class LineEditor {
                     this.lastWasCR = false;
                     return;
                 }
-                // In question mode, LF should also submit (script/pipes send
-                // \n without preceding \r, unlike real terminals).
+                // В question-режиме LF тоже сабмитит (скрипты/пайпы шлют \n без \r спереди,
+                // в отличие от настоящих терминалов).
                 if (this.questionCb) {
                     this.submit();
                     return;
@@ -450,6 +478,7 @@ export class LineEditor {
         }
     }
     submit() {
+        this.completionSession = null;
         if (this.questionCb) {
             const cb = this.questionCb;
             this.questionCb = null;
@@ -505,15 +534,16 @@ export class LineEditor {
         this.lines = [""];
         this.row = 0;
         this.col = 0;
+        this.completionSession = null;
         this.invalidateAnchor();
         this.render();
         if (this.onInterrupt) {
             this.onInterrupt();
             return;
         }
-        // Default: emit only when someone listens. With zero handlers
-        // process.emit("SIGINT") takes the DEFAULT action (process termination);
-        // the REPL always installs a listener, so production is unaffected.
+        // Дефолт: эмитим, только если слушают. С нулём хендлеров process.emit("SIGINT")
+        // выполняет действие ПО УМОЛЧАНИЮ (смерть процесса); у REPL слушатель всегда
+        // стоит, так что прод не страдает.
         if (process.listenerCount("SIGINT") > 0) {
             process.emit("SIGINT");
         }
@@ -526,7 +556,7 @@ export class LineEditor {
             this.deleteForward();
         }
     }
-    // ---- editing primitives ----
+    // ── Примитивы правки ──
     currentChars() {
         return Array.from(this.lines[this.row]);
     }
@@ -534,6 +564,7 @@ export class LineEditor {
         this.lines[this.row] = chars.join("");
     }
     insertText(text) {
+        this.completionSession = null;
         const sanitized = text.replace(/\r\n/g, "\n").replace(/\r/g, "");
         const chars = this.currentChars();
         const t = Array.from(sanitized);
@@ -542,9 +573,9 @@ export class LineEditor {
         this.col += t.length;
         this.render();
     }
-    /** Bulk-insert pasted text at the cursor. Splits on newlines so the buffer
-     *  keeps one string per line (instead of embedding literal `\n` chars),
-     *  and renders once — a paste must look like a paste, not like typing. */
+    /** Пакетная вставка текста под курсор. Режет по переводам строк, чтобы буфер
+     *  держал строку на элемент (а не литеральные `\n`), и рендерит один раз:
+     *  вставка должна выглядеть вставкой, а не печатью. */
     insertPaste(text) {
         const segments = text.split("\n");
         if (segments.length === 1) {
@@ -759,6 +790,7 @@ export class LineEditor {
         }
     }
     applyHistoryEntry() {
+        this.completionSession = null;
         const entry = this.history[this.history.length - 1 - this.historyIndex];
         this.lines = entry.split("\n");
         if (this.lines.length === 0)
@@ -768,6 +800,53 @@ export class LineEditor {
         this.render();
     }
     // ---- completion / misc ----
+    /** Replace the UTF-16 range `[from, from + removeText.length)` on the
+     *  current buffer line with `insertText`, placing the cursor right after. */
+    replaceCompletionToken(from, removeText, insertText) {
+        const line = this.lines[this.row];
+        const head = line.slice(0, from);
+        const tail = line.slice(from + removeText.length);
+        this.lines[this.row] = head + insertText + tail;
+        this.col = charLen(head) + charLen(insertText);
+    }
+    /** Position of `partial` under the cursor (fallback: last in the line), or
+     *  -1 when not found. */
+    partialStart(line, partial) {
+        const chars = Array.from(line);
+        const beforeCursor = chars.slice(0, this.col).join("");
+        let from = beforeCursor.lastIndexOf(partial);
+        if (from === -1)
+            from = line.lastIndexOf(partial);
+        return from;
+    }
+    applyCompletionCandidate(index) {
+        const s = this.completionSession;
+        if (!s)
+            return;
+        const chosen = s.items[index].value;
+        this.replaceCompletionToken(s.from, s.inserted, chosen);
+        s.index = index;
+        s.inserted = chosen;
+        this.render();
+    }
+    cycleCompletion(delta) {
+        const s = this.completionSession;
+        if (!s)
+            return;
+        const n = s.items.length;
+        if (n === 0)
+            return;
+        const next = (s.index + delta + n) % n;
+        this.applyCompletionCandidate(next);
+    }
+    cancelCompletion() {
+        const s = this.completionSession;
+        if (!s)
+            return;
+        this.replaceCompletionToken(s.from, s.inserted, s.original);
+        this.completionSession = null;
+        this.render();
+    }
     tabComplete() {
         if (!this.completer)
             return;
@@ -778,32 +857,60 @@ export class LineEditor {
             return;
         }
         if (matches.length === 1) {
-            // Complete the partial under the CURSOR, not the last occurrence in
-            // the whole line — with the cursor mid-line, lastIndexOf() inserted
-            // at the line's end instead.
-            const chars = Array.from(line);
-            const beforeCursor = chars.slice(0, this.col).join("");
-            let from = beforeCursor.lastIndexOf(partial);
-            if (from === -1)
-                from = line.lastIndexOf(partial);
+            // Дополняем partial ПОД КУРСОРОМ, а не последнее вхождение в строке: при
+            // курсоре в середине lastIndexOf() вставлял в конец строки.
+            const from = this.partialStart(line, partial);
             if (from === -1) {
                 this.output.write("\x07");
                 return;
             }
-            const head = line.slice(0, from);
-            const tail = line.slice(from + partial.length);
-            this.lines[this.row] = head + matches[0] + tail;
-            this.col = charLen(head) + charLen(matches[0]);
+            this.replaceCompletionToken(from, partial, matches[0].value);
             this.render();
             return;
         }
-        const rows = matches.map((m) => "  " + m);
-        this.output.write("\r\n" + rows.join("\r\n") + "\r\n");
-        // The printed list moved the cursor (rows.length + 1) visual rows down
-        // from its frame position. Account for those rows so the next render
-        // redraws the frame in place — otherwise its relative up-move starts
-        // above the frame and paints garbage over the just-printed list.
-        this.prevCursorRow += rows.length + 1;
+        const from = this.partialStart(line, partial);
+        if (from === -1) {
+            this.output.write("\x07");
+            return;
+        }
+        const width = this.columns();
+        const limit = width - 1;
+        const rows = matches.map((m) => {
+            const plain = m.description ? `  ${m.value}  ${m.description}` : `  ${m.value}`;
+            if (limit <= 0)
+                return "";
+            if (stringWidth(plain) <= limit) {
+                return m.description ? `  ${m.value}  ${pc.dim(m.description)}` : `  ${m.value}`;
+            }
+            // Режем по видимым колонкам (одних кодпоинтов мало для CJK/emoji).
+            let acc = "";
+            let w = 0;
+            for (const ch of plain) {
+                const cw = stringWidth(ch);
+                if (w + cw > limit - 1)
+                    break;
+                acc += ch;
+                w += cw;
+            }
+            return `${acc}…`;
+        });
+        this.output.write(`\r\n${rows.join("\r\n")}\r\n`);
+        // Напечатанный список увёл курсор ниже старого кадра. Сбрасываем абсолютный
+        // якорь, чтобы следующий рендер позиционировался ОТНОСИТЕЛЬНО текущего
+        // курсора (под списком). Сохранение DSR-якоря возвращало кадр на старую
+        // абсолютную строку, и его `\x1b[J` стирал список: на Linux/macOS кандидаты
+        // мигали и исчезали.
+        this.invalidateAnchor();
+        // Старт сессии циклирования с первым кандидатом в буфере:
+        // ↑/↓/Tab крутят напечатанный список на месте.
+        this.completionSession = {
+            items: matches,
+            index: 0,
+            from,
+            original: partial,
+            inserted: matches[0].value,
+        };
+        this.replaceCompletionToken(from, partial, matches[0].value);
         this.render();
     }
     clearScreen() {
@@ -811,7 +918,7 @@ export class LineEditor {
         this.invalidateAnchor();
         this.render();
     }
-    // ---- rendering ----
+    // ── Рендеринг ──
     columns() {
         return this.output.columns || 80;
     }
@@ -819,28 +926,27 @@ export class LineEditor {
         const promptWidth = stringWidth(stripAnsi(this.promptStr));
         return buildLayout(this.lines, this.columns(), Math.max(1, this.columns() - promptWidth));
     }
-    /** 1-based terminal height, or null when unknown (tests / non-TTY). */
+    /** 1-based высота терминала, null — неизвестна (тесты / не-TTY). */
     screenRows() {
         const r = this.output.rows;
         return typeof r === "number" && r > 3 ? r : null;
     }
     /**
-     * Whether the cursor-position query (`ESC[6n`) may be sent. It is opt-in on
-     * Windows: ConPTY can mis-decode the `ESC[row;colR` reply as typed input,
-     * which corrupts answers (the setup wizard answered every prompt "R").
-     * `MMA_DSR=1` forces it on, `MMA_DSR=0` off; elsewhere it defaults on.
+     * Можно ли слать запрос позиции курсора (`ESC[6n`). На Windows — opt-in:
+     * ConPTY может декодировать ответ `ESC[row;colR` как ввод, что портит ответы
+     * (визард настройки отвечал на каждый промпт "R").
+     * `MMA_DSR=1` форсит вкл, `MMA_DSR=0` — выкл; иначе по умолчанию вкл.
      */
     dsrEnabled() {
-        if (process.env.MMA_DSR === "1")
+        if (readEnv("DSR") === "1")
             return true;
-        if (process.env.MMA_DSR === "0")
+        if (readEnv("DSR") === "0")
             return false;
         return process.platform !== "win32";
     }
-    /** Cap the rendered frame to the visible screen. A frame taller than the
-     *  terminal cannot be redrawn in place at all (its top scrolls off), so
-     *  only the tail is drawn; the absolute anchor keeps the next render
-     *  consistent regardless. */
+    /** Режет рисуемый кадр до видимого экрана. Кадр выше терминала нельзя
+     *  перерисовать на месте (верх уехал в скролл), так что рисуется только хвост;
+     *  абсолютный якорь держит следующий рендер консистентным в любом случае. */
     visibleLayout() {
         const layout = this.layout();
         const H = this.screenRows();
@@ -850,9 +956,9 @@ export class LineEditor {
         }
         return layout;
     }
-    /** Forget the learned absolute frame position — the cursor has jumped to
-     *  an unknown location (external output, clear screen, fresh prompt).
-     *  The next render will re-query via DSR. */
+    /** Забывает выученную абсолютную позицию кадра: курсор прыгнул в неизвестное
+     *  место (внешний вывод, чистка экрана, свежий промпт). Следующий рендер
+     *  переспросит через DSR. */
     invalidateAnchor() {
         this.frameTopAbs = null;
         this.dsrPending = false;
@@ -863,10 +969,9 @@ export class LineEditor {
             this.dsrTimer = null;
         }
     }
-    /** Parse `ESC[row;colR` cursor-position replies. Buffers partial escape
-     *  sequences across chunks. Accepts at most one reply (the outstanding
-     *  query); extras are silently dropped. Validates the reported row against
-     *  `screenRows()` to reject implausible ConPTY values. */
+    /** Парсит DSR-ответы `ESC[row;colR`. Буферит разрезанные escape между чанками.
+     *  Принимает максимум один ответ (outstanding-запрос); лишние молча дропаются.
+     *  Строку валидирует против `screenRows()`, отсекая неправдоподобные значения ConPTY. */
     consumeDsrReplies(chunk) {
         this.dsrTail = (this.dsrTail + chunk).slice(-80);
         const m = /\x1b\[(\d+);(\d+)R/.exec(this.dsrTail);
@@ -881,9 +986,9 @@ export class LineEditor {
             clearTimeout(this.dsrTimer);
             this.dsrTimer = null;
         }
-        // The frame top is the reply row minus the cursor's visual row at query
-        // time. `dsrQueryRow` — not `prevCursorRow` — because intermediate
-        // renders may have advanced the cursor while the query was pending.
+        // Верх кадра = строка ответа минус визуальный ряд курсора на момент запроса.
+        // `dsrQueryRow`, а не `prevCursorRow`: промежуточные рендеры могли двинуть
+        // курсор, пока запрос летел.
         const top = row - this.dsrQueryRow;
         const H = this.screenRows();
         if (top >= 1 && (H === null || top <= H))
@@ -899,10 +1004,9 @@ export class LineEditor {
         const rowsAfter = layout.length - idx - 1;
         const ccol = (idx === 0 ? promptWidth : 0) + vcol;
         const out = [];
-        // Return to the frame's first row before redrawing.  Absolute
-        // positioning (learned via a single DSR query per prompt) is
-        // scroll-proof; relative up-moves are the fallback until the
-        // initial reply arrives.
+        // Возврат на первую строку кадра перед перерисовкой. Абсолютное
+        // позиционирование (выученное одним DSR-запросом на промпт) иммунно к
+        // скроллу; относительные ходы вверх — фолбэк до прихода первого ответа.
         if (this.frameTopAbs !== null) {
             out.push(`\x1b[${this.frameTopAbs};1H`);
         }
@@ -929,10 +1033,9 @@ export class LineEditor {
             out.push(`\x1b[${ccol}C`);
         this.output.write(out.join(""));
         this.prevCursorRow = idx;
-        // Deterministic scroll math: update the anchor for the NEXT render.
-        // After writing L rows starting from frameTopAbs, if the frame extends
-        // past the screen bottom the terminal scrolls; the new frame top is
-        // computed locally — no further DSR queries needed.
+        // Детерминированная скролл-математика: обновляем якорь для СЛЕДУЮЩЕГО рендера.
+        // После записи L строк от frameTopAbs терминал скроллится, если кадр вылез за
+        // низ экрана; новый верх кадра считается локально, новых DSR-запросов не надо.
         if (this.frameTopAbs !== null) {
             const H = this.screenRows();
             if (H) {
@@ -944,9 +1047,9 @@ export class LineEditor {
             }
         }
         else if (!this.dsrPending && this.questionCb === null && this.dsrEnabled()) {
-            // One DSR query per frame, then the anchor is maintained by local scroll
-            // math. Never queried in question mode (see dsrEnabled). A timeout clears
-            // dsrPending so a non-responding terminal falls back to relative moves.
+            // Один DSR-запрос на кадр, дальше якорь ведёт локальная скролл-математика.
+            // В question-режиме не спрашиваем (см. dsrEnabled). Таймаут сбрасывает
+            // dsrPending, чтобы неотвечающий терминал откатился на относительные ходы.
             this.dsrPending = true;
             this.dsrQueryRow = idx;
             this.output.write("\x1b[6n");
@@ -970,6 +1073,11 @@ export class LineEditor {
         this.listeners.line?.(line);
     }
     emitClose() {
+        // Сброс финальной строки без перевода из чанкованного не-TTY ввода.
+        if (this.pendingLine) {
+            this.emitLine(this.pendingLine);
+            this.pendingLine = "";
+        }
         this.listeners.close?.();
     }
 }