chocolatito-code 1.0.0 → 1.2.0

package/dist/ui/prompt.js

@@ -5,8 +5,43 @@ import path from "node:path";
 import os from "node:os";
 import chalk from "chalk";
 import { cycleMode, describeMode, getMode } from "./modes.js";
-import { releaseKeyboard } from "./interrupt.js";
+import { releaseKeyboard, tomarTecladoParaPrompt, devolverTecladoDelPrompt } from "./interrupt.js";
+import { repararTeclado, reafirmarModoCrudo, MS_ENTRE_COMPROBACIONES } from "./keyboardGuard.js";
 import { clearTyped } from "./typeAhead.js";
+import { dibujar } from "./salida.js";
+import { esGrande, guardarPegado, expandirPegados, marcaQueTerminaEn, limpiarPegados } from "./pegados.js";
+/**
+ * Escribir algo mientras el prompt esta dibujado.
+ *
+ * Sale de una sesion real del usuario. Los servidores MCP se conectan en
+ * segundo plano para no retrasar el arranque, y cuando terminan sueltan su
+ * resumen con `console.log`. Si para entonces el prompt ya estaba en pantalla,
+ * el resumen se escribe ENCIMA del marco y lo destroza:
+ *
+ *     ❯ Escribe una instruccion...
+ *     🔌 Servidores MCP:────────────────────────────────────
+ *       ✔ ide (http): 4 herramientasb modo · esc cancelar    ⇥ modo normal
+ *
+ * Ese "4 herramientasb modo" es el resumen pisando la linea de ayuda. Le pasa a
+ * cualquier cosa que se imprima tarde: el aviso de actualizacion, un servidor
+ * MCP lento, un hook que tarda.
+ *
+ * La regla es sencilla: si hay un prompt abierto, primero se borra su marco, se
+ * escribe el mensaje donde estaba, y se vuelve a dibujar debajo. Si no lo hay,
+ * es un console.log normal y ya.
+ */
+let escribirEncimaDelPrompt = null;
+/**
+ * Imprime sin romper el prompt. Uselo en vez de `console.log` para todo lo que
+ * pueda llegar TARDE: conexiones en segundo plano, avisos, temporizadores.
+ */
+export function imprimirSobreElPrompt(texto) {
+    if (escribirEncimaDelPrompt) {
+        escribirEncimaDelPrompt(texto);
+        return;
+    }
+    dibujar(texto.endsWith("\n") ? texto : `${texto}\n`);
+}
 export const SLASH_COMMANDS = [
     { name: "/mcp", description: "Ver servidores MCP conectados y sus herramientas" },
     { name: "/undo", description: "Deshacer las últimas modificaciones de archivos de la sesión" },
@@ -28,6 +63,33 @@ export const SLASH_COMMANDS = [
     { name: "/exit", description: "Cerrar sesión de Chocolatito Code" },
 ];
 let isKeypressInitialized = false;
+/**
+ * PEGADO DE VARIAS LINEAS
+ *
+ * Un pegado no llega tecla a tecla: llega como UN chunk de stdin que readline
+ * desmonta en pulsaciones y emite todas en el mismo tick sincrono. El primer
+ * "\r" del texto se emitia como key.name === "return", el manejador de Enter
+ * hacia cleanup() + resolve() y quitaba el oyente MIENTRAS el resto del chunk
+ * se seguia emitiendo: las lineas 2..n salian sin nadie escuchando y se perdian
+ * sin dejar rastro ni en el buffer ni en la cola. El usuario creia haber mandado
+ * la instruccion entera y el agente arrancaba con la primera linea.
+ *
+ * Dos defensas, porque ninguna cubre sola todos los terminales:
+ *
+ * 1. Modo de pegado entre corchetes. El terminal envuelve lo pegado en
+ *    \x1b[200~ ... \x1b[201~, asi que se distingue de lo tecleado aunque el
+ *    pegado venga partido en varios chunks (los grandes lo vienen). Dentro de
+ *    las marcas, un salto de linea es texto y nunca envia.
+ * 2. El Enter no envia en el acto: se apunta y se decide en el setImmediate
+ *    siguiente, cuando el chunk entero ya paso. Si detras venia mas texto, ese
+ *    Enter era un salto del pegado. Esto salva a los terminales que no soportan
+ *    el punto 1 (conhost antiguo, por ejemplo).
+ */
+const PASTE_START = "\x1b[200~";
+const PASTE_END = "\x1b[201~";
+/** Activar/desactivar el modo en el terminal. Se apaga al salir: si se queda puesto, la shell de despues recibe las marcas como texto. */
+const PASTE_START_REQUEST = "\x1b[?2004h";
+const PASTE_STOP_REQUEST = "\x1b[?2004l";
 function stripAnsi(str) {
     return str.replace(/\x1b\[[0-9;]*m/g, "");
 }
@@ -86,14 +148,157 @@ function scanProjectFiles(dir, maxResults = 40) {
     walk(dir);
     return results;
 }
+const PLACEHOLDER = "Escribe una instrucción, '@' para archivos o '/' para comandos...";
+/**
+ * Filas FISICAS que ocupa una linea del marco.
+ *
+ * Aqui estaba el fallo de verdad: el repintado contaba elementos del array del
+ * marco mientras el terminal cuenta filas de pantalla. Cualquier linea que no
+ * cupiera en el ancho se partia en dos filas, el cursor subia una fila de menos
+ * y el marco entero se iba bajando, dejando una barra huerfana por pulsacion.
+ * La entrada ademas puede llevar saltos de linea dentro (continuacion con "\").
+ */
+function physicalRows(line, cols) {
+    return stripAnsi(line)
+        .split("\n")
+        .reduce((n, seg) => n + Math.max(1, Math.ceil(seg.length / cols)), 0);
+}
+/** Recorta a `width` columnas visibles. Texto sin pintar: aqui no hay que cerrar colores. */
+function truncatePlain(text, width) {
+    if (width <= 0)
+        return "";
+    if (text.length <= width)
+        return text;
+    return width <= 1 ? text.slice(0, width) : `${text.slice(0, width - 1)}…`;
+}
+/**
+ * Arma el marco del prompt y dice exactamente donde queda el cursor.
+ *
+ * Va aparte de render() por dos razones: se puede probar sin terminal, y la
+ * aritmetica de filas se hace UNA vez sobre las mismas lineas que se pintan, en
+ * lugar de estimarse por otro lado y descuadrarse.
+ */
+export function buildPromptFrame(opts) {
+    const cols = Math.max(20, opts.cols || 80);
+    const viewportRows = Math.max(6, opts.rows || 24);
+    const promptSymbol = opts.promptSymbol ?? "❯";
+    const input = opts.input ?? "";
+    const cursorIndex = Math.max(0, Math.min(opts.cursorIndex ?? input.length, input.length));
+    const items = opts.items ?? [];
+    const selectedIndex = items.length > 0 ? (((opts.selectedIndex ?? 0) % items.length) + items.length) % items.length : 0;
+    const isPlan = promptSymbol.includes("plan");
+    const symbolStr = isPlan
+        ? `${chalk.cyan.bold("plan ❯")} `
+        : `${chalk.bold.hex("#D97757")("❯")} `;
+    const symbolWidth = isPlan ? 7 : 2;
+    const bar = chalk.gray("─".repeat(cols));
+    // 1. Linea de entrada. Lo que el usuario escribe NO se recorta nunca: se deja
+    // que el terminal la parta y despues se cuentan las filas que ocupa.
+    let formattedInput;
+    if (input.length === 0) {
+        // La pista si se recorta: en una ventana estrecha ocupaba una segunda fila
+        // para no decir nada que el usuario no sepa ya.
+        formattedInput = chalk.gray(truncatePlain(PLACEHOLDER, cols - symbolWidth));
+    }
+    else if (input.startsWith("/")) {
+        const parts = input.split(" ");
+        const cmdPart = chalk.bold.hex("#A855F7")(parts[0]);
+        const restPart = parts.slice(1).join(" ");
+        formattedInput = restPart ? `${cmdPart} ${chalk.white(restPart)}` : cmdPart;
+    }
+    else {
+        formattedInput = input.replace(/(@[^\s]+)/g, (m) => chalk.bold.hex("#D97757")(m));
+    }
+    const inputLine = symbolStr + formattedInput;
+    const inputRows = physicalRows(inputLine, cols);
+    // 2. Desplegable. Un marco mas alto que la ventana obliga al terminal a
+    // desplazar el contenido, y a partir de ahi el repintado ya no sabe donde
+    // esta su primera fila: se muestra solo una ventana alrededor del elegido.
+    const room = Math.max(1, viewportRows - 1 - (1 + inputRows + 1 + 1));
+    const shown = Math.min(items.length, room);
+    const dropdownOffset = shown > 0 && items.length > shown
+        ? Math.min(Math.max(0, selectedIndex - Math.floor(shown / 2)), items.length - shown)
+        : 0;
+    const dropdownLines = [];
+    for (let i = dropdownOffset; i < dropdownOffset + shown; i++) {
+        const item = items[i];
+        const isSelected = i === selectedIndex;
+        const colorHex = item.type === "file" ? "#D97757" : "#A855F7";
+        const pointer = isSelected ? chalk.bold.hex(colorHex)(" ❯ ") : chalk.gray("   ");
+        // El puntero se lleva 3 columnas fijas. De lo que queda manda la etiqueta:
+        // la descripcion es lo primero que se cae, porque una ruta a medias no se
+        // puede ni leer ni elegir.
+        const free = cols - 3;
+        const label = truncatePlain(item.label, free);
+        const roomForDesc = free - label.length - 2;
+        const secondary = item.secondary && roomForDesc >= 8 ? truncatePlain(item.secondary, roomForDesc) : "";
+        const paintedLabel = isSelected ? chalk.bold.white(label) : chalk.hex(colorHex)(label);
+        const paintedDesc = secondary
+            ? isSelected
+                ? chalk.whiteBright(`  ${secondary}`)
+                : chalk.gray(`  ${secondary}`)
+            : "";
+        dropdownLines.push(`${pointer}${paintedLabel}${paintedDesc}`);
+    }
+    // 3. Pie de estado. El relleno se calculaba con Math.max(1, ...): cuando no
+    // cabia, en vez de recortarse se quedaba con un espacio y la linea salia MAS
+    // ancha que el terminal. En una consola de 80 columnas el pie media 87 y se
+    // partia en dos filas desde el primer dibujado.
+    const modeLook = describeMode(getMode());
+    const hintPlain = "? /help para atajos · shift+tab modo · esc cancelar";
+    const modePlain = `⇥ modo ${modeLook.label}`;
+    const enginePlain = "· Espectro 1.0 (Ágil)";
+    const hint = chalk.gray(hintPlain);
+    const modeTag = chalk.hex(modeLook.color)(modePlain);
+    const engine = chalk.gray(enginePlain);
+    let footerLine;
+    if (hintPlain.length + 1 + modePlain.length + 1 + enginePlain.length <= cols) {
+        const padLen = cols - hintPlain.length - modePlain.length - 1 - enginePlain.length;
+        footerLine = `${hint}${" ".repeat(padLen)}${modeTag} ${engine}`;
+    }
+    else if (modePlain.length + 1 + enginePlain.length <= cols) {
+        // Los atajos son opcionales; el modo activo no, que es lo que decide si te
+        // van a preguntar antes de tocar tus archivos.
+        footerLine = `${" ".repeat(cols - modePlain.length - 1 - enginePlain.length)}${modeTag} ${engine}`;
+    }
+    else if (modePlain.length <= cols) {
+        footerLine = `${" ".repeat(cols - modePlain.length)}${modeTag}`;
+    }
+    else {
+        footerLine = chalk.hex(modeLook.color)(truncatePlain(modePlain, cols));
+    }
+    const lines = [bar, inputLine, ...dropdownLines, bar, footerLine];
+    // 4. Donde queda el cursor, en filas fisicas. Antes se hacia cursorCol =
+    // total % cols: aplicaba el modulo pero nunca sumaba la fila, asi que en
+    // cuanto la entrada se partia el acento se iba a escribir a otra linea.
+    const typed = input.length === 0 ? "" : input.slice(0, cursorIndex);
+    const segments = typed.split("\n");
+    let cursorRow = physicalRows(bar, cols);
+    for (let i = 0; i < segments.length - 1; i++) {
+        cursorRow += Math.max(1, Math.ceil(((i === 0 ? symbolWidth : 0) + segments[i].length) / cols));
+    }
+    const lastSegWidth = (segments.length === 1 ? symbolWidth : 0) + segments[segments.length - 1].length;
+    cursorRow += Math.floor(lastSegWidth / cols);
+    const cursorCol = lastSegWidth % cols;
+    const totalRows = lines.reduce((n, l) => n + physicalRows(l, cols), 0);
+    return { lines, totalRows, cursorRow, cursorCol, dropdownOffset };
+}
 export async function askInteractivePrompt(promptSymbol = "❯", cwd = process.cwd()) {
     return new Promise((resolve) => {
         let inputBuffer = "";
         let cursorIndex = 0;
         let selectedIndex = 0;
         let isFinished = false;
-        let lastRenderedLines = [];
-        let lastCursorLineIndex = 1;
+        // Estado del pegado. Ver la nota PEGADO DE VARIAS LINEAS de arriba.
+        let isPasting = false;
+        /** Lo que va llegando del pegado, antes de decidir si cabe o va como marca. */
+        let loPegado = "";
+        let pendingSubmit = null;
+        let lastWasCR = false;
+        // Filas FISICAS, no elementos del array: es la unica cuenta con la que el
+        // terminal esta de acuerdo.
+        let hasRendered = false;
+        let lastCursorRow = 0;
         const history = loadHistory();
         let historyIdx = history.length;
         // Cache project files for @ autocompletion
@@ -115,10 +320,43 @@ export async function askInteractivePrompt(promptSymbol = "❯", cwd = process.c
         // Lo que quedara a medio escribir del turno anterior no es de este prompt.
         clearTyped();
         const wasRaw = process.stdin.isRaw;
-        if (process.stdin.setRawMode) {
-            process.stdin.setRawMode(true);
-        }
+        // Reafirmar y no solo poner: si algo cambio el modo de la consola por fuera
+        // de Node, un setRawMode(true) a secas es un no-op y el prompt se abre sin
+        // teclado sin enterarse. Ver reafirmarModoCrudo().
+        reafirmarModoCrudo(process.stdin);
         process.stdin.resume();
+        // A partir de aqui el teclado es de este prompt: un vigilante que se pare
+        // tarde ya no puede devolver el modo crudo a como estaba antes del turno,
+        // porque "antes del turno" ya no es ahora.
+        tomarTecladoParaPrompt();
+        // Y por si alguien se lo quita igualmente. Ver keyboardGuard.ts: son
+        // demasiados los sitios que apagan el modo crudo con razon, y basta que uno
+        // llegue tarde para que el usuario teclee y su texto salga en la linea de
+        // ayuda en vez de en el recuadro.
+        const vigilanteTeclado = setInterval(() => {
+            if (isFinished)
+                return;
+            const reparado = repararTeclado(process.stdin);
+            if (reparado.length === 0)
+                return;
+            if (process.env.CHOCOLATITO_TECLADO === "debug") {
+                process.stderr.write(`\n[teclado] recuperado: ${reparado.join(" y ")}\n`);
+            }
+            // El terminal ya ha hecho eco de lo que se tecleara mientras tanto, en un
+            // sitio que este dibujo no controla. Intentar borrar el marco anterior
+            // contando filas se comeria ese texto ajeno y dejaria el cursor perdido:
+            // se dibuja uno limpio debajo y se sigue.
+            hasRendered = false;
+            lastCursorRow = 0;
+            render();
+        }, MS_ENTRE_COMPROBACIONES);
+        // Un temporizador de vigilancia no es motivo para que el proceso siga vivo.
+        vigilanteTeclado.unref?.();
+        // Se pide el pegado entre corchetes solo si hay terminal delante; a un
+        // fichero o a una tuberia esto seria basura en la salida.
+        if (process.stdout.isTTY) {
+            dibujar(PASTE_START_REQUEST);
+        }
         function getAtMention() {
             const textBeforeCursor = inputBuffer.slice(0, cursorIndex);
             const match = textBeforeCursor.match(/@([^\s]*)$/);
@@ -163,115 +401,78 @@ export async function askInteractivePrompt(promptSymbol = "❯", cwd = process.c
             if (isFinished)
                 return;
             const cols = Math.max(20, process.stdout.columns || 80);
-            // 1. Top separator line
-            const topBar = chalk.gray("─".repeat(cols));
-            // 2. Prompt symbol & input text
-            const symbolStr = promptSymbol.includes("plan")
-                ? `${chalk.cyan.bold("plan ❯")} `
-                : `${chalk.bold.hex("#D97757")("❯")} `;
-            const rawSymbolLen = promptSymbol.includes("plan") ? 7 : 2;
-            const placeholderText = "Escribe una instrucción, '@' para archivos o '/' para comandos...";
-            let formattedInput = "";
-            if (inputBuffer.length === 0) {
-                formattedInput = chalk.gray(placeholderText);
-            }
-            else if (inputBuffer.startsWith("/")) {
-                const parts = inputBuffer.split(" ");
-                const cmdPart = chalk.bold.hex("#A855F7")(parts[0]);
-                const restPart = parts.slice(1).join(" ");
-                formattedInput = restPart ? `${cmdPart} ${chalk.white(restPart)}` : cmdPart;
-            }
-            else {
-                formattedInput = inputBuffer.replace(/(@[^\s]+)/g, (m) => chalk.bold.hex("#D97757")(m));
-            }
-            // 3. Dropdown items (if any)
             const items = getDropdownItems();
-            const dropdownLines = [];
             if (items.length > 0) {
                 if (selectedIndex >= items.length)
                     selectedIndex = 0;
                 if (selectedIndex < 0)
                     selectedIndex = items.length - 1;
-                items.forEach((item, idx) => {
-                    const isSelected = idx === selectedIndex;
-                    const isFile = item.type === "file";
-                    const colorHex = isFile ? "#D97757" : "#A855F7";
-                    const pointer = isSelected
-                        ? chalk.bold.hex(colorHex)(" ❯ ")
-                        : chalk.gray("   ");
-                    const label = isSelected
-                        ? chalk.bold.white(item.label)
-                        : chalk.hex(colorHex)(item.label);
-                    const desc = isSelected
-                        ? chalk.whiteBright(`  ${item.secondary || ""}`)
-                        : chalk.gray(`  ${item.secondary || ""}`);
-                    dropdownLines.push(`${pointer}${label}${desc}`);
-                });
             }
-            // 4. Bottom separator line
-            const bottomBar = chalk.gray("─".repeat(cols));
-            // 5. Footer status line
-            const modeLook = describeMode(getMode());
-            const leftFooter = chalk.gray("? /help para atajos · shift+tab modo · esc cancelar");
-            const rightFooter = `${chalk.hex(modeLook.color)(`⇥ modo ${modeLook.label}`)} ${chalk.gray("· Espectro 1.0 (Ágil)")}`;
-            const leftLen = stripAnsi(leftFooter).length;
-            const rightLen = stripAnsi(rightFooter).length;
-            const padLen = Math.max(1, cols - leftLen - rightLen);
-            const footerLine = `${leftFooter}${" ".repeat(padLen)}${rightFooter}`;
-            // Build current frame array
-            const currentFrame = [topBar, symbolStr + formattedInput];
-            if (dropdownLines.length > 0) {
-                currentFrame.push(...dropdownLines);
+            const frame = buildPromptFrame({
+                cols,
+                rows: process.stdout.rows || 24,
+                promptSymbol,
+                input: inputBuffer,
+                cursorIndex,
+                items,
+                selectedIndex,
+            });
+            // Todo en una sola escritura: un marco pintado a trozos es un marco que
+            // parpadea.
+            const out = [];
+            if (hasRendered) {
+                // Volver a la primera fila del marco anterior y borrar de ahi hacia
+                // abajo. Antes se repintaba linea a linea con \x1b[2K contando lineas
+                // logicas, asi que lo que el terminal habia partido en dos filas se
+                // quedaba en pantalla para siempre.
+                if (lastCursorRow > 0)
+                    out.push(`\x1b[${lastCursorRow}A`);
+                out.push("\r\x1b[0J");
             }
-            currentFrame.push(bottomBar, footerLine);
-            const inputLineIdx = 1;
-            const totalCharsCursor = rawSymbolLen + (inputBuffer.length === 0 ? 0 : cursorIndex);
-            const cursorCol = totalCharsCursor % cols;
-            if (lastRenderedLines.length === 0) {
-                // First render: write frame and position cursor on input line
-                process.stdout.write(currentFrame.join("\n"));
-                const moveUp = currentFrame.length - 1 - inputLineIdx;
-                process.stdout.write(`\x1b[${moveUp}A\r\x1b[${cursorCol}C`);
-            }
-            else {
-                // Subsequent render: re-draw lines in place with 0 scrolling drift
-                if (lastCursorLineIndex > 0) {
-                    process.stdout.write(`\x1b[${lastCursorLineIndex}A\r`);
-                }
-                else {
-                    process.stdout.write("\r");
-                }
-                const maxLines = Math.max(currentFrame.length, lastRenderedLines.length);
-                for (let i = 0; i < maxLines; i++) {
-                    const content = i < currentFrame.length ? currentFrame[i] : "";
-                    process.stdout.write(`\x1b[2K${content}`);
-                    if (i < maxLines - 1) {
-                        process.stdout.write("\x1b[1E");
-                    }
-                }
-                const moveUp = (maxLines - 1) - inputLineIdx;
-                if (moveUp > 0) {
-                    process.stdout.write(`\x1b[${moveUp}A\r\x1b[${cursorCol}C`);
-                }
-                else {
-                    process.stdout.write(`\r\x1b[${cursorCol}C`);
-                }
-            }
-            lastRenderedLines = currentFrame;
-            lastCursorLineIndex = inputLineIdx;
+            out.push(frame.lines.join("\n"));
+            // El cursor se quedo en la ultima fila pintada; hay que subirlo a la de la
+            // entrada. Ojo con los ceros: \x1b[0A y \x1b[0C mueven UNA posicion.
+            const moveUp = frame.totalRows - 1 - frame.cursorRow;
+            if (moveUp > 0)
+                out.push(`\x1b[${moveUp}A`);
+            out.push("\r");
+            if (frame.cursorCol > 0)
+                out.push(`\x1b[${frame.cursorCol}C`);
+            dibujar(out.join(""));
+            hasRendered = true;
+            lastCursorRow = frame.cursorRow;
         }
         function cleanup() {
             isFinished = true;
+            limpiarPegados();
+            escribirEncimaDelPrompt = null;
+            clearInterval(vigilanteTeclado);
+            devolverTecladoDelPrompt();
+            if (pendingSubmit) {
+                clearImmediate(pendingSubmit);
+                pendingSubmit = null;
+            }
             process.stdin.removeListener("keypress", onKeypress);
             if (process.stdin.setRawMode) {
                 process.stdin.setRawMode(wasRaw || false);
             }
+            if (process.stdout.isTTY) {
+                dibujar(PASTE_STOP_REQUEST);
+            }
+        }
+        /** Mete texto donde esta el cursor. Un solo sitio para no repetir el corte del buffer. */
+        function insertText(text) {
+            inputBuffer = inputBuffer.slice(0, cursorIndex) + text + inputBuffer.slice(cursorIndex);
+            cursorIndex += text.length;
+            selectedIndex = 0;
         }
         function applySelectedDropdownItem() {
             const items = getDropdownItems();
             if (items.length === 0)
                 return false;
             const item = items[selectedIndex];
+            if (!item)
+                return false;
             if (item.type === "command") {
                 inputBuffer = item.insertText;
                 cursorIndex = inputBuffer.length;
@@ -292,38 +493,101 @@ export async function askInteractivePrompt(promptSymbol = "❯", cwd = process.c
             const symbolStr = promptSymbol.includes("plan")
                 ? `${chalk.cyan.bold("plan ❯")} `
                 : `${chalk.bold.hex("#D97757")("❯")} `;
-            // Move cursor to top of frame
-            if (lastCursorLineIndex > 0) {
-                process.stdout.write(`\x1b[${lastCursorLineIndex}A\r`);
-            }
-            else {
-                process.stdout.write("\r");
-            }
-            // Draw clean submitted prompt box in terminal history
-            process.stdout.write(`\x1b[2K${chalk.gray("─".repeat(cols))}\x1b[1E`);
-            process.stdout.write(`\x1b[2K${symbolStr}${chalk.bold.white(submittedText)}\x1b[1E`);
-            process.stdout.write(`\x1b[2K${chalk.gray("─".repeat(cols))}\x1b[1E`);
-            // Clear any leftover rows (dropdown, old footer)
-            const extraLines = Math.max(0, lastRenderedLines.length - 3);
-            for (let i = 0; i < extraLines; i++) {
-                process.stdout.write(`\x1b[2K`);
-                if (i < extraLines - 1)
-                    process.stdout.write("\x1b[1E");
-            }
-            // Move cursor directly below the bottom bar
-            if (extraLines > 0) {
-                process.stdout.write(`\x1b[${extraLines}A\r\x1b[1E\n`);
-            }
-            else {
-                process.stdout.write("\n");
+            const bar = chalk.gray("─".repeat(cols));
+            const out = [];
+            // Subir a la primera fila del marco y borrar de ahi hacia abajo. Antes se
+            // contaban a mano las filas sobrantes (desplegable, pie) y esa cuenta era
+            // en lineas logicas: lo que el terminal habia partido se quedaba debajo
+            // del prompt ya enviado.
+            if (hasRendered) {
+                if (lastCursorRow > 0)
+                    out.push(`\x1b[${lastCursorRow}A`);
+                out.push("\r\x1b[0J");
             }
+            out.push(`${bar}\n${symbolStr}${chalk.bold.white(submittedText)}\n${bar}\n\n`);
+            dibujar(out.join(""));
+            hasRendered = false;
+            lastCursorRow = 0;
+        }
+        function submitNow() {
+            if (isFinished)
+                return;
+            pendingSubmit = null;
+            // El historial guarda la marca, no las 347 lineas: si no, el fichero de
+            // historial crece sin control y recorrerlo con las flechas es inutil.
+            appendHistory(inputBuffer);
+            // Pero el modelo recibe el texto entero, que es lo que el usuario pego.
+            const completo = expandirPegados(inputBuffer);
+            cleanup();
+            finalizePromptOnSubmit(inputBuffer);
+            resolve(completo);
+        }
+        /**
+         * Apunta el envio para el final del tick. Todo el chunk de stdin se emite
+         * antes de que corra el setImmediate, asi que para entonces ya se sabe si
+         * detras del Enter venia mas texto pegado.
+         */
+        function scheduleSubmit() {
+            if (pendingSubmit)
+                return;
+            pendingSubmit = setImmediate(submitNow);
+        }
+        /** El Enter en espera no era una orden de enviar: era un salto del pegado. */
+        function absorbPendingEnter() {
+            if (!pendingSubmit)
+                return;
+            clearImmediate(pendingSubmit);
+            pendingSubmit = null;
+            insertText("\n");
         }
         function onKeypress(str, key) {
             if (isFinished)
                 return;
+            // Marcas del pegado entre corchetes. Node >= 22 las nombra; en versiones
+            // anteriores solo llega la secuencia cruda, asi que se miran las dos.
+            const sequence = (key && key.sequence) || str || "";
+            if ((key && key.name === "paste-start") || sequence === PASTE_START) {
+                isPasting = true;
+                // Se recoge aparte: si resulta ser grande, en el recuadro va una marca
+                // corta en vez de las 347 lineas. Ver pegados.ts.
+                loPegado = "";
+                return;
+            }
+            if ((key && key.name === "paste-end") || sequence === PASTE_END) {
+                isPasting = false;
+                if (loPegado) {
+                    insertText(esGrande(loPegado) ? guardarPegado(loPegado) : loPegado);
+                    loPegado = "";
+                }
+                render();
+                return;
+            }
+            const isEnter = Boolean(key && (key.name === "return" || key.name === "enter"));
+            // CRLF llega como DOS pulsaciones ("\r" y luego "\n") y es un unico salto.
+            // Sin esto, el portapapeles de Windows duplicaba todas las lineas en blanco.
+            const isPairedLF = isEnter && key.name === "enter" && lastWasCR;
+            lastWasCR = isEnter && key.name === "return";
+            if (isPairedLF)
+                return;
+            // Cualquier tecla que no sea el Enter y llegue en su mismo tick delata un
+            // pegado: aquel Enter pasa a ser salto de linea y se sigue con esta tecla.
+            if (!isEnter)
+                absorbPendingEnter();
             const items = getDropdownItems();
             // Enter key
-            if (key && (key.name === "return" || key.name === "enter")) {
+            if (isEnter) {
+                // Dentro de un pegado, el salto va al buffer aparte, no al recuadro.
+                if (isPasting) {
+                    loPegado += "\n";
+                    return;
+                }
+                // Segundo Enter del mismo tick: linea en blanco dentro del pegado.
+                if (pendingSubmit) {
+                    absorbPendingEnter();
+                    scheduleSubmit();
+                    render();
+                    return;
+                }
                 // Multi-line continuation if ends with \
                 if (inputBuffer.endsWith("\\")) {
                     inputBuffer = inputBuffer.slice(0, -1) + "\n";
@@ -337,10 +601,7 @@ export async function askInteractivePrompt(promptSymbol = "❯", cwd = process.c
                         return;
                     }
                 }
-                appendHistory(inputBuffer);
-                cleanup();
-                finalizePromptOnSubmit(inputBuffer);
-                resolve(inputBuffer);
+                scheduleSubmit();
                 return;
             }
             // Shift+Tab: cambia el modo de permisos instantáneamente
@@ -417,8 +678,12 @@ export async function askInteractivePrompt(promptSymbol = "❯", cwd = process.c
             // Backspace
             if (key && (key.name === "backspace" || (key.ctrl && key.name === "h"))) {
                 if (cursorIndex > 0) {
-                    inputBuffer = inputBuffer.slice(0, cursorIndex - 1) + inputBuffer.slice(cursorIndex);
-                    cursorIndex--;
+                    // Lo que ocupa una linea se borra como una linea: sin esto habria que
+                    // pulsar borrar treinta veces para quitar una marca de pegado.
+                    const marca = marcaQueTerminaEn(inputBuffer, cursorIndex);
+                    const desde = marca ? marca.inicio : cursorIndex - 1;
+                    inputBuffer = inputBuffer.slice(0, desde) + inputBuffer.slice(cursorIndex);
+                    cursorIndex = desde;
                     selectedIndex = 0;
                     render();
                 }
@@ -435,14 +700,18 @@ export async function askInteractivePrompt(promptSymbol = "❯", cwd = process.c
                 inputBuffer = "";
                 cursorIndex = 0;
                 selectedIndex = 0;
+                // Salida de emergencia: si un terminal raro mandara la marca de apertura
+                // del pegado y nunca la de cierre, sin esto el Enter no volveria a
+                // enviar en toda la sesion.
+                isPasting = false;
                 render();
                 return;
             }
             // Ctrl + L (clear screen)
             if (key && key.ctrl && key.name === "l") {
                 console.clear();
-                lastRenderedLines = [];
-                lastCursorLineIndex = 1;
+                hasRendered = false;
+                lastCursorRow = 0;
                 render();
                 return;
             }
@@ -451,15 +720,51 @@ export async function askInteractivePrompt(promptSymbol = "❯", cwd = process.c
                 !isShiftTab &&
                 str !== "\x1b[Z" &&
                 (!key || (!key.ctrl && !key.meta) || (key.ctrl && key.meta) || (!key.name && str.length > 0))) {
+                // Una secuencia de escape no es texto. Hoy readline manda str undefined
+                // cuando reconoce la secuencia, asi que este filtro casi nunca salta;
+                // esta para que una marca de pegado o una tecla de funcion que llegue
+                // cruda no acabe escrita como letras sueltas ("\x1b[200~") en el buffer.
+                if (str.charCodeAt(0) === 0x1b)
+                    return;
                 const cleanStr = str.replace(/[\r\n]/g, "");
-                if (cleanStr.length > 0) {
-                    inputBuffer = inputBuffer.slice(0, cursorIndex) + cleanStr + inputBuffer.slice(cursorIndex);
-                    cursorIndex += cleanStr.length;
-                    selectedIndex = 0;
+                if (cleanStr.length === 0)
+                    return;
+                if (isPasting) {
+                    // Va al buffer del pegado, no al recuadro: al cerrarse se decide si
+                    // cabe entero o si merece una marca corta.
+                    loPegado += cleanStr;
+                    return;
+                }
+                // Sin marcas de pegado -conhost antiguo, algun terminal raro- el pegado
+                // llega como un chunk enorme en una sola pulsacion. Tecleando nunca
+                // llega mas de un caracter, asi que esto solo puede ser un pegado.
+                if (esGrande(cleanStr)) {
+                    insertText(guardarPegado(cleanStr));
                     render();
+                    return;
                 }
+                insertText(cleanStr);
+                render();
             }
         }
+        // A partir de aqui, lo que llegue tarde se dibuja SIN romper el marco.
+        escribirEncimaDelPrompt = (texto) => {
+            if (isFinished)
+                return;
+            let salida = "";
+            // Se borra el marco igual que hace render() al repintar.
+            if (hasRendered) {
+                if (lastCursorRow > 0)
+                    salida += `\x1b[${lastCursorRow}A`;
+                salida += "\r\x1b[0J";
+            }
+            salida += texto.endsWith("\n") ? texto : `${texto}\n`;
+            dibujar(salida);
+            // Y el prompt se vuelve a dibujar limpio debajo del mensaje.
+            hasRendered = false;
+            lastCursorRow = 0;
+            render();
+        };
         process.stdin.on("keypress", onKeypress);
         render();
     });