chocolatito-code 1.1.0 → 1.3.0

package/dist/ui/pegados.js

@@ -0,0 +1,83 @@
+/**
+ * Un pegado grande no se mete entero en el recuadro.
+ *
+ * EL PROBLEMA
+ *
+ * Pegar un error de compilacion de 300 lineas metia las 300 lineas dentro del
+ * prompt. El recuadro crecia hasta llenar la pantalla, el marco se volvia
+ * inutil, y para deshacerlo habia que pulsar borrar trescientas veces. Es el
+ * caso normal de usar un agente: uno pega un log, una traza, un archivo entero.
+ *
+ * COMO QUEDA
+ *
+ * El texto se guarda aparte y en el recuadro solo aparece una marca corta:
+ *
+ *     ❯ arregla esto [pegado #1 · 347 lineas]
+ *
+ * Al enviar, la marca se sustituye por el texto completo, asi que el modelo
+ * recibe exactamente lo que se pego. Y un solo borrar se lleva la marca entera:
+ * lo que ocupa una linea se borra como una linea.
+ *
+ * POR QUE UNA MARCA DE TEXTO Y NO UNA ESTRUCTURA APARTE
+ *
+ * Porque el buffer del prompt es una cadena y todo lo demas -el cursor, el
+ * historial, el recorte del marco, la busqueda de menciones- cuenta caracteres.
+ * Meter ahi un objeto obligaria a tocar las seis cosas. Una marca de texto se
+ * lleva bien con todo lo que ya funciona.
+ */
+/** A partir de aqui, un pegado se guarda aparte en vez de llenar el recuadro. */
+export const MINIMO_LINEAS = 5;
+export const MINIMO_CARACTERES = 400;
+const guardados = new Map();
+let siguiente = 1;
+/** Reconoce una marca. El id es lo unico que hace falta para recuperar el texto. */
+const MARCA = /\[pegado #(\d+) · [^\]]*\]/g;
+function resumen(texto) {
+    const lineas = texto.split("\n").length;
+    if (lineas > 1)
+        return `${lineas.toLocaleString("es")} lineas`;
+    return `${texto.length.toLocaleString("es")} caracteres`;
+}
+/** Si merece la pena guardarlo aparte, o es lo bastante corto para verlo entero. */
+export function esGrande(texto) {
+    return texto.length >= MINIMO_CARACTERES || texto.split("\n").length > MINIMO_LINEAS;
+}
+/** Guarda el texto y devuelve la marca que va en el recuadro. */
+export function guardarPegado(texto) {
+    const id = siguiente++;
+    guardados.set(id, texto);
+    return `[pegado #${id} · ${resumen(texto)}]`;
+}
+/** Devuelve el texto de verdad, con las marcas sustituidas. Es lo que ve el modelo. */
+export function expandirPegados(entrada) {
+    // Una marca de un id que ya no existe se deja tal cual: es texto que el
+    // usuario escribio a mano, y borrarselo seria peor que dejarlo.
+    return entrada.replace(MARCA, (todo, id) => guardados.get(Number(id)) ?? todo);
+}
+/**
+ * Si justo antes del cursor termina una marca, dice donde empieza.
+ *
+ * Es lo que hace que un solo borrar se lleve el pegado entero. Sin esto habria
+ * que borrar la marca letra a letra, que es un poco menos absurdo que borrar
+ * las 347 lineas pero sigue siendo absurdo.
+ */
+export function marcaQueTerminaEn(buffer, cursor) {
+    if (cursor <= 0 || buffer[cursor - 1] !== "]")
+        return null;
+    const trozo = buffer.slice(0, cursor);
+    const inicio = trozo.lastIndexOf("[pegado #");
+    if (inicio < 0)
+        return null;
+    // Que lo que hay entre los corchetes sea de verdad una marca y no un
+    // "[pegado #" que el usuario escribiera a mano.
+    return /^\[pegado #\d+ · [^\]]*\]$/.test(trozo.slice(inicio)) ? { inicio } : null;
+}
+/** Se olvidan al cerrar el prompt: cada turno empieza con su propia cuenta. */
+export function limpiarPegados() {
+    guardados.clear();
+    siguiente = 1;
+}
+/** Cuantos hay guardados ahora mismo. Solo para las pruebas. */
+export function cuantosPegados() {
+    return guardados.size;
+}

package/dist/ui/pieFijo.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Las secciones, de arriba abajo. El orden es fijo a proposito: si cada quien
+ * pintara donde le tocara, dos productores independientes -el razonamiento y el
+ * spinner llegan por caminos distintos- se turnarian el sitio y el pie bailaria.
+ */
+declare const ORDEN: readonly ["razonamiento", "spinner", "entrada"];
+export type SeccionDelPie = (typeof ORDEN)[number];
+/**
+ * Enciende o apaga el pie a mano. Con `null` vuelve a mandar el terminal.
+ *
+ * Las pruebas lo encienden porque en `node --test` no hay TTY y sin esto el pie
+ * seria un no-op silencioso: pasarian todas sin comprobar nada.
+ */
+export declare function habilitarPie(valor: boolean | null): void;
+/** ¿Hay algo pintado abajo que haya que respetar? */
+export declare function hayPie(): boolean;
+/**
+ * Pone (o reemplaza) una seccion del pie y repinta.
+ *
+ * Con la lista vacia la seccion desaparece, que es lo mismo que quitarla. Si el
+ * contenido es identico al que ya habia, no se repinta: el spinner llama ocho
+ * veces por segundo y la barra de escribir casi nunca cambia entre dos.
+ */
+export declare function fijarSeccion(nombre: SeccionDelPie, lineas: string[]): void;
+/**
+ * Varias secciones de una vez, con UN solo repintado.
+ *
+ * El spinner cambia su linea y la barra de escribir en el mismo tick. Puestas
+ * por separado se pintaba el bloque dos veces cada 120 ms, y la segunda pasada
+ * borraba y reescribia lo que la primera acababa de dejar: el doble de bytes
+ * para el mismo resultado, y un parpadeo que se nota en un terminal lento.
+ */
+export declare function fijarSecciones(entradas: Array<[SeccionDelPie, string[]]>): void;
+export declare function quitarSeccion(nombre: SeccionDelPie): void;
+/**
+ * Escribe texto permanente sin que el pie se lo lleve por delante.
+ *
+ * Sin pie es un write normal y no cuesta nada; por eso puede sustituir a
+ * `console.log` en el camino del agente sin pensarlo dos veces.
+ */
+export declare function escribirEncimaDelPie(texto: string): void;
+/**
+ * Quita el pie entero y deja el terminal como si nunca hubiera estado.
+ *
+ * Lo que quede a medias de linea se conserva en pantalla: es texto del agente,
+ * no adorno, y borrarlo seria perder salida.
+ */
+export declare function soltarPie(): void;
+/**
+ * Olvida el estado sin tocar la pantalla.
+ *
+ * Para las pruebas y para la salida del proceso: ahi no queda terminal al que
+ * repintar, pero el cursor escondido si sobrevive y hay que devolverlo.
+ */
+export declare function reiniciarPie(): void;
+export {};

package/dist/ui/pieFijo.js

@@ -0,0 +1,309 @@
+import process from "node:process";
+import { dibujar } from "./salida.js";
+/**
+ * EL PIE QUE NO SE VA CON EL SCROLL
+ *
+ * EL PROBLEMA
+ *
+ * El spinner y la linea de razonamiento se pintaban donde estuviera el cursor:
+ *
+ *     process.stdout.write(`\r\x1b[2K${glyph} ${verb} (${segundos}s)`);
+ *
+ * Eso escribe en la fila actual y ahi se queda. En cuanto llega la respuesta,
+ * cada linea nueva empuja el contenido hacia arriba y se lleva el spinner con
+ * ella. El usuario lo describio mejor que ninguna documentacion: "la nubecita y
+ * el rayito suben con lo que me respondes". Y lo mismo la barra de escribir.
+ *
+ * El resultado es que mientras el modelo habla no hay NADA fijo en pantalla: ni
+ * cuanto lleva, ni cuantos tokens, ni donde escribir para encolar algo. Todo
+ * queda enterrado unas pantallas mas arriba.
+ *
+ * LA IDEA
+ *
+ * Un terminal no tiene "zonas". Se puede pedir una con la region de scroll
+ * (DECSTBM), pero lo que sale por arriba de una region asi NO entra en el
+ * historial del terminal en la mayoria de emuladores: se pierde. En un agente
+ * de codigo, donde media sesion consiste en subir a releer lo que salio, eso es
+ * inaceptable.
+ *
+ * Asi que se hace al reves, sin regiones: el pie se BORRA antes de cada
+ * escritura permanente y se REPINTA justo despues. El texto permanente se
+ * escribe con saltos de linea normales, entra en el historial como siempre, y
+ * el pie acaba de nuevo abajo del todo. Visto desde fuera, el pie no se mueve.
+ *
+ * LA INVARIANTE QUE LO SOSTIENE
+ *
+ * Tras pintar, el cursor queda al final de la ultima fila del bloque. Con eso
+ * basta para borrarlo entero: subir `filasPintadas - 1` filas, ir a la columna
+ * cero y borrar hacia abajo. Se cuentan filas FISICAS (lo que el terminal parte
+ * al llegar al ancho), no elementos del array: contar lineas logicas es
+ * exactamente el fallo que dejaba barras huerfanas en el prompt.
+ *
+ * Y LA SEGUNDA, LA QUE EVITA CORROMPER LA SALIDA AJENA
+ *
+ * Sin secciones puestas, el pie no pinta nada y la pantalla queda byte a byte
+ * como la habria dejado un `console.log` normal. Por eso el resto del programa
+ * -las herramientas, el renderizador, los avisos- puede seguir escribiendo
+ * directo sin saber que esto existe. Solo hay que pasar por aqui mientras haya
+ * pie, que es justo el rato que el bucle controla toda la salida.
+ */
+const OCULTAR_CURSOR = "\x1b[?25l";
+const MOSTRAR_CURSOR = "\x1b[?25h";
+/**
+ * Las secciones, de arriba abajo. El orden es fijo a proposito: si cada quien
+ * pintara donde le tocara, dos productores independientes -el razonamiento y el
+ * spinner llegan por caminos distintos- se turnarian el sitio y el pie bailaria.
+ */
+const ORDEN = ["razonamiento", "spinner", "entrada"];
+const secciones = new Map();
+/**
+ * Texto permanente que aun no ha recibido su salto de linea.
+ *
+ * Un `flush()` de markdown puede dejar media linea escrita. Si el pie se
+ * pintara detras, empezaria en mitad de esa fila. En vez de calcular columnas
+ * -aritmetica que se rompe con cada emoji- se guarda ese resto AQUI y se
+ * repinta como primera linea del bloque. Deja de ser texto permanente hasta que
+ * llegue su salto, y entonces se escribe de verdad.
+ */
+let colaSinSalto = "";
+/** Filas fisicas que ocupo el bloque en el ultimo pintado. Es lo que se borra. */
+let filasPintadas = 0;
+/**
+ * Lo ultimo que escribimos NOSOTROS se quedo a medio renglon.
+ *
+ * Sin secciones puestas, la linea a medias deja de estar protegida y sale como
+ * texto permanente (ver `repintar`). Si despues vuelve a haber pie, tiene que
+ * empezar en un renglon nuevo y no pegado al final de esa frase.
+ */
+let aMediaLinea = false;
+let cursorEscondido = false;
+/** `null` = decidirlo por el terminal. Las pruebas lo fuerzan. */
+let habilitado = null;
+function pieUsable() {
+    return habilitado ?? Boolean(process.stdout.isTTY);
+}
+/**
+ * Enciende o apaga el pie a mano. Con `null` vuelve a mandar el terminal.
+ *
+ * Las pruebas lo encienden porque en `node --test` no hay TTY y sin esto el pie
+ * seria un no-op silencioso: pasarian todas sin comprobar nada.
+ */
+export function habilitarPie(valor) {
+    habilitado = valor;
+}
+function ancho() {
+    return Math.max(20, process.stdout.columns || 80);
+}
+function alto() {
+    return Math.max(4, process.stdout.rows || 24);
+}
+function sinColores(texto) {
+    return texto.replace(/\x1b\[[0-9;]*m/g, "");
+}
+/**
+ * Filas de pantalla que ocupa una linea con este ancho.
+ *
+ * `ceil(largo / cols)` coincide con el ajuste diferido de los terminales: tras
+ * escribir exactamente `cols` caracteres el cursor sigue en esa fila esperando,
+ * y eso es una fila, no dos.
+ */
+function filasFisicas(linea, cols) {
+    return sinColores(linea)
+        .split("\n")
+        .reduce((n, seg) => n + Math.max(1, Math.ceil(seg.length / cols)), 0);
+}
+function lineasDelBloque() {
+    const lineas = [];
+    if (colaSinSalto)
+        lineas.push(colaSinSalto);
+    for (const nombre of ORDEN) {
+        const trozo = secciones.get(nombre);
+        if (trozo && trozo.length > 0)
+            lineas.push(...trozo);
+    }
+    return lineas;
+}
+/** Secuencia que deja el cursor donde empezaba el bloque, con todo borrado debajo. */
+function borrado() {
+    if (filasPintadas === 0)
+        return "";
+    const subir = filasPintadas > 1 ? `\x1b[${filasPintadas - 1}A` : "";
+    return `\r${subir}\x1b[0J`;
+}
+/** Secuencia del bloque nuevo. Actualiza `filasPintadas`. */
+function pintado() {
+    let lineas = lineasDelBloque();
+    if (lineas.length === 0) {
+        filasPintadas = 0;
+        return "";
+    }
+    const cols = ancho();
+    // Un pie mas alto que la ventana no se puede repintar: al pintarlo el
+    // terminal desplaza, y la cuenta de filas -que es lo unico que sabemos para
+    // borrarlo- deja de valer. Se recorta por abajo, que es donde esta lo menos
+    // urgente; la cola sin salto va primera y nunca se cae.
+    const tope = alto() - 1;
+    let filas = lineas.reduce((n, l) => n + filasFisicas(l, cols), 0);
+    while (filas > tope && lineas.length > 1) {
+        lineas = lineas.slice(0, -1);
+        filas = lineas.reduce((n, l) => n + filasFisicas(l, cols), 0);
+    }
+    filasPintadas = filas;
+    return lineas.join("\n");
+}
+/**
+ * El unico sitio que escribe. Borra lo de antes, suelta el texto permanente en
+ * medio, y vuelve a pintar el pie debajo. Todo en UNA escritura: un pie pintado
+ * a trozos es un pie que parpadea.
+ */
+function repintar(permanente) {
+    const fuera = borrado();
+    // Sin secciones ya no hay de que proteger la linea a medias, y retenerla seria
+    // peor que soltarla: el pie seguiria contando esa fila como suya, y el
+    // siguiente repintado borraria lo que hubiera escrito cualquier otro por su
+    // cuenta -las herramientas imprimen con console.log y no pasan por aqui-.
+    // Soltandola, `filasPintadas` vuelve a cero y el pie no debe nada a nadie.
+    let suelto = "";
+    if (secciones.size === 0 && colaSinSalto) {
+        suelto = colaSinSalto;
+        colaSinSalto = "";
+    }
+    let dentro = pintado();
+    const texto = permanente + suelto;
+    if (texto)
+        aMediaLinea = !texto.endsWith("\n");
+    if (dentro && aMediaLinea) {
+        // El salto va DELANTE del bloque, y no cuenta como fila suya: el borrado
+        // sube hasta la primera fila del pie, no hasta la frase de encima.
+        dentro = `\n${dentro}`;
+        aMediaLinea = false;
+    }
+    let salida = fuera + texto + dentro;
+    if (dentro && !cursorEscondido) {
+        // Con el pie repintandose cada 120 ms, un cursor visible salta de sitio sin
+        // parar. Se esconde mientras dure y se devuelve al soltarlo.
+        salida = OCULTAR_CURSOR + salida;
+        cursorEscondido = true;
+    }
+    else if (!dentro && cursorEscondido) {
+        salida += MOSTRAR_CURSOR;
+        cursorEscondido = false;
+    }
+    if (salida)
+        dibujar(salida);
+}
+/** ¿Hay algo pintado abajo que haya que respetar? */
+export function hayPie() {
+    return filasPintadas > 0;
+}
+function iguales(a, b) {
+    if (!a || a.length !== b.length)
+        return false;
+    return a.every((l, i) => l === b[i]);
+}
+/** Guarda la seccion. Devuelve si algo cambio, que es lo que decide repintar. */
+function anotar(nombre, lineas) {
+    if (lineas.length === 0) {
+        return secciones.delete(nombre);
+    }
+    if (iguales(secciones.get(nombre), lineas))
+        return false;
+    secciones.set(nombre, lineas);
+    return true;
+}
+/**
+ * Pone (o reemplaza) una seccion del pie y repinta.
+ *
+ * Con la lista vacia la seccion desaparece, que es lo mismo que quitarla. Si el
+ * contenido es identico al que ya habia, no se repinta: el spinner llama ocho
+ * veces por segundo y la barra de escribir casi nunca cambia entre dos.
+ */
+export function fijarSeccion(nombre, lineas) {
+    if (!pieUsable())
+        return;
+    if (anotar(nombre, lineas))
+        repintar("");
+}
+/**
+ * Varias secciones de una vez, con UN solo repintado.
+ *
+ * El spinner cambia su linea y la barra de escribir en el mismo tick. Puestas
+ * por separado se pintaba el bloque dos veces cada 120 ms, y la segunda pasada
+ * borraba y reescribia lo que la primera acababa de dejar: el doble de bytes
+ * para el mismo resultado, y un parpadeo que se nota en un terminal lento.
+ */
+export function fijarSecciones(entradas) {
+    if (!pieUsable())
+        return;
+    let cambio = false;
+    for (const [nombre, lineas] of entradas) {
+        if (anotar(nombre, lineas))
+            cambio = true;
+    }
+    if (cambio)
+        repintar("");
+}
+export function quitarSeccion(nombre) {
+    fijarSeccion(nombre, []);
+}
+/**
+ * Escribe texto permanente sin que el pie se lo lleve por delante.
+ *
+ * Sin pie es un write normal y no cuesta nada; por eso puede sustituir a
+ * `console.log` en el camino del agente sin pensarlo dos veces.
+ */
+export function escribirEncimaDelPie(texto) {
+    if (!texto)
+        return;
+    if (!pieUsable() || (filasPintadas === 0 && !colaSinSalto)) {
+        dibujar(texto);
+        return;
+    }
+    const completo = colaSinSalto + texto;
+    const corte = completo.lastIndexOf("\n");
+    const permanente = corte >= 0 ? completo.slice(0, corte + 1) : "";
+    colaSinSalto = corte >= 0 ? completo.slice(corte + 1) : completo;
+    repintar(permanente);
+}
+/**
+ * Quita el pie entero y deja el terminal como si nunca hubiera estado.
+ *
+ * Lo que quede a medias de linea se conserva en pantalla: es texto del agente,
+ * no adorno, y borrarlo seria perder salida.
+ */
+export function soltarPie() {
+    if (secciones.size === 0 && filasPintadas === 0)
+        return;
+    secciones.clear();
+    repintar("");
+}
+/**
+ * Olvida el estado sin tocar la pantalla.
+ *
+ * Para las pruebas y para la salida del proceso: ahi no queda terminal al que
+ * repintar, pero el cursor escondido si sobrevive y hay que devolverlo.
+ */
+export function reiniciarPie() {
+    secciones.clear();
+    colaSinSalto = "";
+    filasPintadas = 0;
+    aMediaLinea = false;
+    if (cursorEscondido) {
+        dibujar(MOSTRAR_CURSOR);
+        cursorEscondido = false;
+    }
+}
+/**
+ * Un cursor escondido sobrevive al proceso: la shell de despues se queda sin
+ * cursor y el usuario no tiene forma de saber por que. Se devuelve pase lo que
+ * pase, tambien si el programa se cae.
+ */
+process.on("exit", () => {
+    if (cursorEscondido) {
+        try {
+            process.stdout.write(MOSTRAR_CURSOR);
+        }
+        catch { }
+        cursorEscondido = false;
+    }
+});

package/dist/ui/prompt.d.ts

@@ -1,3 +1,8 @@
+/**
+ * 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 declare function imprimirSobreElPrompt(texto: string): void;
 export interface SlashCommandItem {
     name: string;
     description: string;

package/dist/ui/prompt.js

@@ -6,8 +6,45 @@ import os from "node:os";
 import chalk from "chalk";
 import { cycleMode, describeMode, getMode } from "./modes.js";
 import { releaseKeyboard, tomarTecladoParaPrompt, devolverTecladoDelPrompt } from "./interrupt.js";
-import { repararTeclado, MS_ENTRE_COMPROBACIONES } from "./keyboardGuard.js";
+import { repararTeclado, reafirmarModoCrudo, MS_ENTRE_COMPROBACIONES } from "./keyboardGuard.js";
 import { clearTyped } from "./typeAhead.js";
+import { dibujar } from "./salida.js";
+import { escribirEncimaDelPie, reiniciarPie } from "./pieFijo.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;
+    }
+    // Sin prompt abierto puede haber pie: el spinner y la linea de razonamiento
+    // viven ahi. Un aviso que llegue tarde tiene que pasar por encima igual.
+    escribirEncimaDelPie(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" },
@@ -251,12 +288,19 @@ export function buildPromptFrame(opts) {
 }
 export async function askInteractivePrompt(promptSymbol = "❯", cwd = process.cwd()) {
     return new Promise((resolve) => {
+        // A partir de aqui el terminal es del prompt, que lleva su propia cuenta de
+        // filas. El pie fijo tiene que olvidar la suya SIN borrar nada: lo que dejo
+        // en pantalla es respuesta del agente, no adorno. Y devuelve el cursor, que
+        // lo escondia mientras se repintaba.
+        reiniciarPie();
         let inputBuffer = "";
         let cursorIndex = 0;
         let selectedIndex = 0;
         let isFinished = false;
         // 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
@@ -284,9 +328,10 @@ 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,
@@ -318,7 +363,7 @@ export async function askInteractivePrompt(promptSymbol = "❯", cwd = process.c
         // 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) {
-            process.stdout.write(PASTE_START_REQUEST);
+            dibujar(PASTE_START_REQUEST);
         }
         function getAtMention() {
             const textBeforeCursor = inputBuffer.slice(0, cursorIndex);
@@ -401,12 +446,14 @@ export async function askInteractivePrompt(promptSymbol = "❯", cwd = process.c
             out.push("\r");
             if (frame.cursorCol > 0)
                 out.push(`\x1b[${frame.cursorCol}C`);
-            process.stdout.write(out.join(""));
+            dibujar(out.join(""));
             hasRendered = true;
             lastCursorRow = frame.cursorRow;
         }
         function cleanup() {
             isFinished = true;
+            limpiarPegados();
+            escribirEncimaDelPrompt = null;
             clearInterval(vigilanteTeclado);
             devolverTecladoDelPrompt();
             if (pendingSubmit) {
@@ -418,7 +465,7 @@ export async function askInteractivePrompt(promptSymbol = "❯", cwd = process.c
                 process.stdin.setRawMode(wasRaw || false);
             }
             if (process.stdout.isTTY) {
-                process.stdout.write(PASTE_STOP_REQUEST);
+                dibujar(PASTE_STOP_REQUEST);
             }
         }
         /** Mete texto donde esta el cursor. Un solo sitio para no repetir el corte del buffer. */
@@ -466,7 +513,7 @@ export async function askInteractivePrompt(promptSymbol = "❯", cwd = process.c
                 out.push("\r\x1b[0J");
             }
             out.push(`${bar}\n${symbolStr}${chalk.bold.white(submittedText)}\n${bar}\n\n`);
-            process.stdout.write(out.join(""));
+            dibujar(out.join(""));
             hasRendered = false;
             lastCursorRow = 0;
         }
@@ -474,10 +521,14 @@ export async function askInteractivePrompt(promptSymbol = "❯", cwd = process.c
             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(inputBuffer);
+            resolve(completo);
         }
         /**
          * Apunta el envio para el final del tick. Todo el chunk de stdin se emite
@@ -505,10 +556,17 @@ export async function askInteractivePrompt(promptSymbol = "❯", cwd = process.c
             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;
             }
@@ -526,10 +584,9 @@ export async function askInteractivePrompt(promptSymbol = "❯", cwd = process.c
             const items = getDropdownItems();
             // Enter key
             if (isEnter) {
-                // Dentro de un pegado, un salto de linea es texto y no envia nada.
+                // Dentro de un pegado, el salto va al buffer aparte, no al recuadro.
                 if (isPasting) {
-                    insertText("\n");
-                    render();
+                    loPegado += "\n";
                     return;
                 }
                 // Segundo Enter del mismo tick: linea en blanco dentro del pegado.
@@ -629,8 +686,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();
                 }
@@ -674,12 +735,44 @@ export async function askInteractivePrompt(promptSymbol = "❯", cwd = process.c
                 if (str.charCodeAt(0) === 0x1b)
                     return;
                 const cleanStr = str.replace(/[\r\n]/g, "");
-                if (cleanStr.length > 0) {
-                    insertText(cleanStr);
+                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();
     });