micro-models-agent 0.60.1 → 0.61.1

package/dist/ui/line-editor.js

@@ -0,0 +1,822 @@
+import * as readline from "readline";
+import stringWidth from "string-width";
+import { buildLayout, layoutIndexFor, visualColAt, charOffsetFor, charLen, stripAnsi, } from "./line-math";
+export class LineEditor {
+    input;
+    output;
+    /** Host hook: return true to swallow the key before the editor handles it. */
+    onKeyInput;
+    onInterrupt;
+    promptStr;
+    completer;
+    history;
+    historySize;
+    lines = [""];
+    row = 0;
+    col = 0;
+    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. */
+    pasteBuffer = "";
+    /** Whether the last paste keypress was a bare CR — used to collapse a
+     *  CRLF pair into a single newline (Windows clipboard text). */
+    pasteLastWasCR = false;
+    lastWasCR = false;
+    questionCb = null;
+    rawMode = false;
+    listeners = {};
+    /** 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). */
+    frameTopAbs = null;
+    /** True while waiting for a DSR reply (exactly one outstanding query). */
+    dsrPending = false;
+    /** Buffer for partial DSR escape sequences split across data chunks. */
+    dsrTail = "";
+    constructor(opts) {
+        this.input = opts.input;
+        this.output = opts.output;
+        this.promptStr = opts.prompt ?? "";
+        this.completer = opts.completer;
+        this.onInterrupt = opts.onInterrupt;
+        this.history = opts.history ?? [];
+        this.historySize = opts.historySize ?? 50;
+        if (this.history.length > this.historySize) {
+            this.history = this.history.slice(-this.historySize);
+        }
+        if (this.input.isTTY) {
+            this.rawMode = typeof this.input.setRawMode === "function";
+            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.
+            this.input.on("data", (buf) => this.consumeDsrReplies(buf.toString("utf-8")));
+            readline.emitKeypressEvents(this.input);
+            this.input.on("keypress", (str, key) => this.onKey(str, key));
+        }
+        else {
+            this.input.on("data", (buf) => this.onData(buf));
+            this.input.on("end", () => {
+                const last = this.lines.join("\n");
+                this.lines = [""];
+                this.row = 0;
+                this.col = 0;
+                if (last)
+                    this.emitLine(last);
+                this.emitClose();
+            });
+        }
+    }
+    on(event, listener) {
+        if (event === "line") {
+            this.listeners.line = listener;
+        }
+        else {
+            this.listeners.close = listener;
+        }
+        return this;
+    }
+    setPrompt(prompt) {
+        this.promptStr = prompt;
+        if (this.input.isTTY)
+            this.render();
+    }
+    prompt(_preserveCursor) {
+        if (this.input.isTTY)
+            this.render();
+    }
+    write(s) {
+        this.insertText(s);
+    }
+    reset() {
+        this.lines = [""];
+        this.row = 0;
+        this.col = 0;
+        this.historyIndex = -1;
+        this.stash = null;
+        this.invalidateAnchor();
+        if (this.input.isTTY)
+            this.render();
+    }
+    question(query, cb) {
+        this.questionCb = cb;
+        this.promptStr = query;
+        this.lines = [""];
+        this.row = 0;
+        this.col = 0;
+        this.invalidateAnchor();
+        if (this.input.isTTY)
+            this.render();
+    }
+    close() {
+        if (this.isDone)
+            return;
+        this.isDone = true;
+        this.disableTerminalProtocols();
+        if (this.rawMode && this.input.setRawMode) {
+            this.input.setRawMode(false);
+        }
+        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;
+            }
+        }
+    }
+    onKey(str, key) {
+        if (this.isDone)
+            return;
+        if (this.onKeyInput && this.onKeyInput(str, key))
+            return;
+        const k = key;
+        const name = k?.name ?? "undefined";
+        const seq = k?.sequence ?? str ?? "";
+        if (name === "undefined" && /^\x1b\[\d+(?:;\d+)?u$/.test(seq)) {
+            const m = seq.match(/^\x1b\[(\d+)(?:;(\d+))?u$/);
+            if (m && Number(m[1]) === 13 && Number(m[2] ?? 0) !== 0) {
+                this.insertNewline();
+            }
+            return;
+        }
+        if (name === "paste-start" || seq === "\x1b[200~") {
+            this.isPaste = true;
+            this.pasteBuffer = "";
+            this.pasteLastWasCR = false;
+            return;
+        }
+        if (name === "paste-end" || seq === "\x1b[201~") {
+            this.isPaste = false;
+            if (this.pasteBuffer) {
+                this.insertPaste(this.pasteBuffer);
+            }
+            else {
+                this.render();
+            }
+            this.pasteBuffer = "";
+            this.pasteLastWasCR = false;
+            return;
+        }
+        if (this.isPaste) {
+            if (name === "return" || seq === "\r") {
+                this.pasteBuffer += "\n";
+                this.pasteLastWasCR = true;
+            }
+            else if (name === "enter" || seq === "\n") {
+                if (this.pasteLastWasCR) {
+                    this.pasteLastWasCR = false;
+                }
+                else {
+                    this.pasteBuffer += "\n";
+                }
+            }
+            else if (str) {
+                this.pasteLastWasCR = false;
+                this.pasteBuffer += str;
+            }
+            return;
+        }
+        if (name === "return" && (seq === "\x1b\r" || k.meta)) {
+            this.insertNewline();
+            return;
+        }
+        if (name === "undefined" && seq === "\x1b\r") {
+            this.insertNewline();
+            return;
+        }
+        if (k?.ctrl && name === "j") {
+            this.insertNewline();
+            return;
+        }
+        if (name === "escape")
+            return;
+        switch (name) {
+            case "return":
+                this.lastWasCR = true;
+                this.submit();
+                return;
+            case "enter":
+                if (this.lastWasCR) {
+                    this.lastWasCR = false;
+                    return;
+                }
+                // In question mode, LF should also submit (script/pipes send
+                // \n without preceding \r, unlike real terminals).
+                if (this.questionCb) {
+                    this.submit();
+                    return;
+                }
+                this.insertNewline();
+                return;
+            case "backspace":
+                this.lastWasCR = false;
+                this.backspace();
+                return;
+            case "delete":
+                this.lastWasCR = false;
+                this.deleteForward();
+                return;
+            case "left":
+                this.lastWasCR = false;
+                this.moveLeft();
+                return;
+            case "right":
+                this.lastWasCR = false;
+                this.moveRight();
+                return;
+            case "up":
+                this.lastWasCR = false;
+                this.moveUp();
+                return;
+            case "down":
+                this.lastWasCR = false;
+                this.moveDown();
+                return;
+            case "home":
+                this.lastWasCR = false;
+                this.moveHome();
+                return;
+            case "end":
+                this.lastWasCR = false;
+                this.moveEnd();
+                return;
+            case "pageup":
+                this.lastWasCR = false;
+                this.moveToStart();
+                return;
+            case "pagedown":
+                this.lastWasCR = false;
+                this.moveToEnd();
+                return;
+            case "tab":
+                this.lastWasCR = false;
+                this.tabComplete();
+                return;
+        }
+        if (k?.ctrl) {
+            this.lastWasCR = false;
+            switch (name) {
+                case "c":
+                    this.ctrlC();
+                    return;
+                case "d":
+                    this.ctrlD();
+                    return;
+                case "a":
+                    this.moveHome();
+                    return;
+                case "e":
+                    this.moveEnd();
+                    return;
+                case "u":
+                    this.killToStart();
+                    return;
+                case "k":
+                    this.killToEnd();
+                    return;
+                case "w":
+                    this.killWordBefore();
+                    return;
+                case "l":
+                    this.clearScreen();
+                    return;
+                default:
+                    return;
+            }
+        }
+        if (k?.meta) {
+            this.lastWasCR = false;
+            switch (name) {
+                case "b":
+                    this.moveWordLeft();
+                    return;
+                case "f":
+                    this.moveWordRight();
+                    return;
+                case "d":
+                    this.killWordAfter();
+                    return;
+                default:
+                    return;
+            }
+        }
+        if (str && !/^[\u0000-\u001f\u007f]/.test(str)) {
+            this.lastWasCR = false;
+            this.insertText(str);
+        }
+    }
+    submit() {
+        if (this.questionCb) {
+            const cb = this.questionCb;
+            this.questionCb = null;
+            const answer = this.lines.join("\n").trim();
+            this.commitFrame();
+            this.output.write("\r\n");
+            this.invalidateAnchor();
+            this.lines = [""];
+            this.row = 0;
+            this.col = 0;
+            cb(answer);
+            return;
+        }
+        const text = this.lines.join("\n");
+        if (text.trim()) {
+            this.history.push(text);
+            if (this.history.length > this.historySize) {
+                this.history = this.history.slice(-this.historySize);
+            }
+        }
+        this.historyIndex = -1;
+        this.stash = null;
+        this.commitFrame();
+        this.output.write("\r\n");
+        this.invalidateAnchor();
+        this.lines = [""];
+        this.row = 0;
+        this.col = 0;
+        this.emitLine(text);
+    }
+    /** Move the cursor to the end of the buffer's last visual row so the
+     *  submitted text stays on screen (commit), without erasing the frame.
+     *  Uses the absolute anchor when known — relative moves land short once
+     *  a tall frame has scrolled the terminal. */
+    commitFrame() {
+        const layout = this.visibleLayout();
+        const lastLen = charLen(stripAnsi(layout[layout.length - 1].text));
+        if (this.frameTopAbs !== null) {
+            this.output.write(`\x1b[${this.frameTopAbs + layout.length - 1};${lastLen + 1}H`);
+            return;
+        }
+        const idx = layoutIndexFor(layout, this.row, this.col);
+        const rowsDown = layout.length - 1 - idx;
+        const out = [];
+        if (rowsDown > 0)
+            out.push(`\x1b[${rowsDown}B`);
+        out.push("\r");
+        if (lastLen > 0)
+            out.push(`\x1b[${lastLen}C`);
+        this.output.write(out.join(""));
+    }
+    ctrlC() {
+        this.lines = [""];
+        this.row = 0;
+        this.col = 0;
+        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.
+        if (process.listenerCount("SIGINT") > 0) {
+            process.emit("SIGINT");
+        }
+    }
+    ctrlD() {
+        if (this.lines.length === 1 && this.lines[0] === "") {
+            this.emitClose();
+        }
+        else {
+            this.deleteForward();
+        }
+    }
+    // ---- editing primitives ----
+    currentChars() {
+        return Array.from(this.lines[this.row]);
+    }
+    setCurrentChars(chars) {
+        this.lines[this.row] = chars.join("");
+    }
+    insertText(text) {
+        const sanitized = text.replace(/\r\n/g, "\n").replace(/\r/g, "");
+        const chars = this.currentChars();
+        const t = Array.from(sanitized);
+        chars.splice(this.col, 0, ...t);
+        this.setCurrentChars(chars);
+        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. */
+    insertPaste(text) {
+        const segments = text.split("\n");
+        if (segments.length === 1) {
+            this.insertText(segments[0]);
+            return;
+        }
+        const chars = this.currentChars();
+        const head = chars.slice(0, this.col).join("");
+        const tail = chars.slice(this.col).join("");
+        const lines = [head + segments[0]];
+        for (let i = 1; i < segments.length - 1; i++)
+            lines.push(segments[i]);
+        lines.push(segments[segments.length - 1] + tail);
+        this.lines.splice(this.row, 1, ...lines);
+        this.row += segments.length - 1;
+        this.col = charLen(segments[segments.length - 1]);
+        this.render();
+    }
+    insertNewline() {
+        const chars = this.currentChars();
+        const rest = chars.slice(this.col).join("");
+        this.setCurrentChars(chars.slice(0, this.col));
+        this.lines.splice(this.row + 1, 0, rest);
+        this.row++;
+        this.col = 0;
+        this.render();
+    }
+    backspace() {
+        const chars = this.currentChars();
+        if (this.col > 0) {
+            chars.splice(this.col - 1, 1);
+            this.setCurrentChars(chars);
+            this.col--;
+        }
+        else if (this.row > 0) {
+            const prevLen = charLen(this.lines[this.row - 1]);
+            this.lines[this.row - 1] = this.lines[this.row - 1] + this.lines[this.row];
+            this.lines.splice(this.row, 1);
+            this.row--;
+            this.col = prevLen;
+        }
+        this.render();
+    }
+    deleteForward() {
+        const chars = this.currentChars();
+        if (this.col < chars.length) {
+            chars.splice(this.col, 1);
+            this.setCurrentChars(chars);
+        }
+        else if (this.row < this.lines.length - 1) {
+            this.lines[this.row] = this.lines[this.row] + this.lines[this.row + 1];
+            this.lines.splice(this.row + 1, 1);
+        }
+        this.render();
+    }
+    killToStart() {
+        const chars = this.currentChars();
+        this.setCurrentChars(chars.slice(this.col));
+        this.col = 0;
+        this.render();
+    }
+    killToEnd() {
+        const chars = this.currentChars();
+        this.setCurrentChars(chars.slice(0, this.col));
+        this.render();
+    }
+    killWordBefore() {
+        const chars = this.currentChars();
+        let i = this.col;
+        while (i > 0 && /\s/.test(chars[i - 1]))
+            i--;
+        while (i > 0 && !/\s/.test(chars[i - 1]))
+            i--;
+        chars.splice(i, this.col - i);
+        this.setCurrentChars(chars);
+        this.col = i;
+        this.render();
+    }
+    killWordAfter() {
+        const chars = this.currentChars();
+        const n = chars.length;
+        let i = this.col;
+        while (i < n && /\s/.test(chars[i]))
+            i++;
+        while (i < n && !/\s/.test(chars[i]))
+            i++;
+        chars.splice(this.col, i - this.col);
+        this.setCurrentChars(chars);
+        this.render();
+    }
+    // ---- navigation ----
+    moveLeft() {
+        if (this.col > 0) {
+            this.col--;
+        }
+        else if (this.row > 0) {
+            this.row--;
+            this.col = charLen(this.lines[this.row]);
+        }
+        this.render();
+    }
+    moveRight() {
+        if (this.col < charLen(this.lines[this.row])) {
+            this.col++;
+        }
+        else if (this.row < this.lines.length - 1) {
+            this.row++;
+            this.col = 0;
+        }
+        this.render();
+    }
+    moveUp() {
+        const layout = this.layout();
+        const idx = layoutIndexFor(layout, this.row, this.col);
+        const vcol = visualColAt(layout, idx, this.col);
+        if (idx > 0) {
+            const target = layout[idx - 1];
+            this.row = target.bufRow;
+            this.col = charOffsetFor(layout, idx - 1, vcol);
+            this.render();
+        }
+        else {
+            this.historyPrev();
+        }
+    }
+    moveDown() {
+        const layout = this.layout();
+        const idx = layoutIndexFor(layout, this.row, this.col);
+        const vcol = visualColAt(layout, idx, this.col);
+        if (idx < layout.length - 1) {
+            const target = layout[idx + 1];
+            this.row = target.bufRow;
+            this.col = charOffsetFor(layout, idx + 1, vcol);
+            this.render();
+        }
+        else {
+            this.historyNext();
+        }
+    }
+    moveHome() {
+        this.col = 0;
+        this.render();
+    }
+    moveEnd() {
+        this.col = charLen(this.lines[this.row]);
+        this.render();
+    }
+    moveToStart() {
+        this.row = 0;
+        this.col = 0;
+        this.render();
+    }
+    moveToEnd() {
+        this.row = this.lines.length - 1;
+        this.col = charLen(this.lines[this.row]);
+        this.render();
+    }
+    moveWordLeft() {
+        const chars = this.currentChars();
+        let i = this.col;
+        while (i > 0 && /\s/.test(chars[i - 1]))
+            i--;
+        while (i > 0 && !/\s/.test(chars[i - 1]))
+            i--;
+        this.col = i;
+        this.render();
+    }
+    moveWordRight() {
+        const chars = this.currentChars();
+        const n = chars.length;
+        let i = this.col;
+        while (i < n && !/\s/.test(chars[i]))
+            i++;
+        while (i < n && /\s/.test(chars[i]))
+            i++;
+        this.col = i;
+        this.render();
+    }
+    historyPrev() {
+        if (this.history.length === 0)
+            return;
+        if (this.historyIndex === -1) {
+            this.stash = {
+                lines: this.lines.slice(),
+                row: this.row,
+                col: this.col,
+            };
+            this.historyIndex = 0;
+        }
+        else if (this.historyIndex < this.history.length - 1) {
+            this.historyIndex++;
+        }
+        else {
+            return;
+        }
+        this.applyHistoryEntry();
+    }
+    historyNext() {
+        if (this.historyIndex === -1)
+            return;
+        if (this.historyIndex > 0) {
+            this.historyIndex--;
+            this.applyHistoryEntry();
+        }
+        else if (this.stash) {
+            this.lines = this.stash.lines.slice();
+            this.row = this.stash.row;
+            this.col = this.stash.col;
+            this.historyIndex = -1;
+            this.stash = null;
+            this.render();
+        }
+    }
+    applyHistoryEntry() {
+        const entry = this.history[this.history.length - 1 - this.historyIndex];
+        this.lines = entry.split("\n");
+        if (this.lines.length === 0)
+            this.lines = [""];
+        this.row = this.lines.length - 1;
+        this.col = charLen(this.lines[this.row]);
+        this.render();
+    }
+    // ---- completion / misc ----
+    tabComplete() {
+        if (!this.completer)
+            return;
+        const line = this.lines[this.row];
+        const [matches, partial] = this.completer(line);
+        if (matches.length === 0) {
+            this.output.write("\x07");
+            return;
+        }
+        if (matches.length === 1) {
+            const from = line.lastIndexOf(partial);
+            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.render();
+            return;
+        }
+        const lines = matches.map((m) => "  " + m);
+        this.output.write("\r\n" + lines.join("\r\n") + "\r\n");
+        this.output.write(`\x1b[${lines.length + 1}A`);
+        this.render();
+    }
+    clearScreen() {
+        this.output.write("\x1b[2J\x1b[H");
+        this.invalidateAnchor();
+        this.render();
+    }
+    // ---- rendering ----
+    columns() {
+        return this.output.columns || 80;
+    }
+    layout() {
+        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). */
+    screenRows() {
+        const r = this.output.rows;
+        return typeof r === "number" && r > 3 ? r : null;
+    }
+    /** 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();
+        const maxRows = H ? H - 2 : 0;
+        if (maxRows > 0 && layout.length > maxRows) {
+            return layout.slice(layout.length - maxRows);
+        }
+        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. */
+    invalidateAnchor() {
+        this.frameTopAbs = null;
+        this.dsrPending = false;
+        this.dsrTail = "";
+        this.prevCursorRow = 0;
+    }
+    /** 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. */
+    consumeDsrReplies(chunk) {
+        this.dsrTail = (this.dsrTail + chunk).slice(-80);
+        const m = /\x1b\[(\d+);(\d+)R/.exec(this.dsrTail);
+        if (!m)
+            return;
+        this.dsrTail = "";
+        if (!this.dsrPending)
+            return;
+        this.dsrPending = false;
+        const row = Number(m[1]);
+        const idx = Number(m[2]);
+        // idx is not the layout index — it's the column from the reply; ignore it.
+        // We compute frameTop from the reply row minus the cursor's visual row
+        // at query time.  The visual row was stored in `prevCursorRow` when the
+        // query was sent (right after render).
+        const top = row - this.prevCursorRow;
+        if (top >= 1)
+            this.frameTopAbs = top;
+    }
+    render() {
+        if (!this.input.isTTY || this.isDone)
+            return;
+        const layout = this.visibleLayout();
+        const promptWidth = stringWidth(stripAnsi(this.promptStr));
+        const idx = layoutIndexFor(layout, this.row, this.col);
+        const vcol = visualColAt(layout, idx, this.col);
+        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.
+        if (this.frameTopAbs !== null) {
+            out.push(`\x1b[${this.frameTopAbs};1H`);
+        }
+        else if (this.prevCursorRow > 0) {
+            out.push(`\x1b[${this.prevCursorRow}A`);
+            out.push("\r");
+        }
+        else {
+            out.push("\r");
+        }
+        for (let i = 0; i < layout.length; i++) {
+            out.push("\x1b[2K");
+            if (i === 0)
+                out.push(this.promptStr);
+            out.push(layout[i].text);
+            if (i < layout.length - 1)
+                out.push("\r\n");
+        }
+        out.push("\x1b[J");
+        if (rowsAfter > 0)
+            out.push(`\x1b[${rowsAfter}A`);
+        out.push("\r");
+        if (ccol > 0)
+            out.push(`\x1b[${ccol}C`);
+        this.output.write(out.join(""));
+        // 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.
+        if (this.frameTopAbs !== null) {
+            const H = this.screenRows();
+            if (H) {
+                const T = this.frameTopAbs;
+                const L = layout.length;
+                if (T + L - 1 > H)
+                    this.frameTopAbs = H - L + 1;
+                // else: no scroll, anchor unchanged
+            }
+        }
+        else if (!this.dsrPending) {
+            // First render after prompt — send exactly ONE DSR query.
+            // Disabled for now: ConPTY may buffer stdout while processing
+            // the DSR reply, hiding agent responses.  Will revisit once
+            // scroll-proof rendering is solved via deterministic tracking.
+            //
+            // this.dsrPending = true;
+            // this.output.write("\x1b[6n");
+        }
+        this.prevCursorRow = idx;
+    }
+    enableTerminalProtocols() {
+        this.output.write("\x1b[?2004h");
+        this.output.write("\x1b[>1u");
+    }
+    disableTerminalProtocols() {
+        this.output.write("\x1b[?2004l");
+        this.output.write("\x1b[<u");
+    }
+    emitLine(line) {
+        this.listeners.line?.(line);
+    }
+    emitClose() {
+        this.listeners.close?.();
+    }
+}