chocolatito-code 1.1.0 → 1.2.0

package/dist/tools/writeFile.d.ts

@@ -1 +1,16 @@
-export declare function writeFile(filePath: string, content: string, cwd?: string): Promise<string>;
+/**
+ * Escribe un archivo, entero o por partes.
+ *
+ * POR QUE EXISTE "anadir"
+ *
+ * La respuesta del modelo tiene un techo de salida. Cuando le piden una pagina
+ * entera, el contenido no cabe, la respuesta se corta a mitad de los argumentos
+ * y no se escribe nada. Se le decia "hazlo en varias llamadas mas pequenas"...
+ * y no habia forma de hacerlo: write_file solo sabia sobrescribir, asi que la
+ * segunda llamada borraba la primera. Le pediamos algo imposible y luego le
+ * echabamos la culpa.
+ *
+ * Con `modo: "anadir"` la instruccion pasa a ser ejecutable: primera llamada
+ * con el principio, las siguientes anadiendo, y el archivo sale entero.
+ */
+export declare function writeFile(filePath: string, content: string, cwd?: string, modo?: "sobrescribir" | "anadir"): Promise<string>;

package/dist/tools/writeFile.js

@@ -1,7 +1,22 @@
 import fs from "node:fs";
 import path from "node:path";
 import { binaryExtensionLabel, fileLooksBinary } from "./binary.js";
-export async function writeFile(filePath, content, cwd = process.cwd()) {
+/**
+ * Escribe un archivo, entero o por partes.
+ *
+ * POR QUE EXISTE "anadir"
+ *
+ * La respuesta del modelo tiene un techo de salida. Cuando le piden una pagina
+ * entera, el contenido no cabe, la respuesta se corta a mitad de los argumentos
+ * y no se escribe nada. Se le decia "hazlo en varias llamadas mas pequenas"...
+ * y no habia forma de hacerlo: write_file solo sabia sobrescribir, asi que la
+ * segunda llamada borraba la primera. Le pediamos algo imposible y luego le
+ * echabamos la culpa.
+ *
+ * Con `modo: "anadir"` la instruccion pasa a ser ejecutable: primera llamada
+ * con el principio, las siguientes anadiendo, y el archivo sale entero.
+ */
+export async function writeFile(filePath, content, cwd = process.cwd(), modo = "sobrescribir") {
     const resolved = path.isAbsolute(filePath) ? filePath : path.resolve(cwd, filePath);
     const dir = path.dirname(resolved);
     const isNew = !fs.existsSync(resolved);
@@ -24,6 +39,12 @@ export async function writeFile(filePath, content, cwd = process.cwd()) {
     if (!fs.existsSync(dir)) {
         fs.mkdirSync(dir, { recursive: true });
     }
+    if (modo === "anadir") {
+        fs.appendFileSync(resolved, content, "utf-8");
+        const total = fs.statSync(resolved).size;
+        return (`✔ Anadido a "${filePath}" (${content.length} caracteres nuevos, ${total} en total). ` +
+            `Sigue con otra llamada en modo "anadir" si falta contenido.`);
+    }
     fs.writeFileSync(resolved, content, "utf-8");
     const action = isNew ? "creado" : "sobreescrito";
     return `✔ Archivo "${filePath}" ${action} exitosamente (${content.length} caracteres).`;

package/dist/ui/interrupt.js

@@ -3,6 +3,7 @@ import process from "node:process";
 import chalk from "chalk";
 import { cycleMode, modeAnnouncement } from "./modes.js";
 import { pushTyped, backspaceTyped, commitTyped } from "./typeAhead.js";
+import { dibujar } from "./salida.js";
 /**
  * Interrupcion con Esc mientras el agente trabaja.
  *
@@ -112,7 +113,7 @@ export class InterruptWatcher {
                 Boolean(key && key.sequence === "\x1b[Z");
             if (isShiftTab) {
                 cycleMode();
-                process.stdout.write(`\r\x1b[2K${modeAnnouncement()}\n`);
+                dibujar(`\r\x1b[2K${modeAnnouncement()}\n`);
                 return;
             }
             // Ignorar secuencias de escape multi-byte (flechas, inicio, fin, etc.) para que no aborten
@@ -130,7 +131,7 @@ export class InterruptWatcher {
                 const texto = commitTyped();
                 if (texto) {
                     const corto = texto.length > 70 ? `${texto.slice(0, 67)}...` : texto;
-                    process.stdout.write(`\r\x1b[2K${chalk.gray("↳ en cola:")} ${chalk.white(corto)}\n`);
+                    dibujar(`\r\x1b[2K${chalk.gray("↳ en cola:")} ${chalk.white(corto)}\n`);
                 }
                 return;
             }

package/dist/ui/keyboardGuard.d.ts

@@ -53,3 +53,24 @@ export interface EntradaDeTeclado {
 export declare function repararTeclado(entrada: EntradaDeTeclado): string[];
 /** Cada cuanto se comprueba. Cuatro veces por segundo se nota como instantaneo. */
 export declare const MS_ENTRE_COMPROBACIONES = 250;
+/**
+ * Vuelve a poner el modo crudo DE VERDAD, no solo en la cuenta de Node.
+ *
+ * EL AGUJERO QUE TAPA
+ *
+ * `setRawMode(true)` no siempre llega al terminal. Por debajo, libuv guarda el
+ * modo que cree tener y empieza con `if (tty->mode == mode) return 0;`. Asi que
+ * si algo cambia el modo de la consola por fuera de Node -un proceso hijo, la
+ * propia shell, el terminal- Node sigue creyendo que esta en crudo, y a partir
+ * de ahi TODOS los `setRawMode(true)` se convierten en no-op. Incluido el que
+ * hace el prompt al abrirse.
+ *
+ * Se veia asi, y se reporto cuatro veces: el usuario teclea, su texto sale al
+ * final de la linea de ayuda -lo esta haciendo el eco del terminal, no el
+ * prompt- y el recuadro no se entera de nada. El vigilante tampoco reparaba
+ * nada, porque preguntaba a Node y Node decia que todo estaba bien.
+ *
+ * Pasar por `false` primero rompe esa cache: la segunda llamada ya ve un cambio
+ * de verdad y lo aplica sobre la consola.
+ */
+export declare function reafirmarModoCrudo(entrada: EntradaDeTeclado): void;

package/dist/ui/keyboardGuard.js

@@ -49,7 +49,7 @@ export function repararTeclado(entrada) {
         return [];
     const reparado = [];
     if (entrada.isRaw !== true) {
-        entrada.setRawMode(true);
+        reafirmarModoCrudo(entrada);
         reparado.push("modo crudo");
     }
     // `pause()` corta el flujo sin avisar a nadie: el oyente de `keypress` sigue
@@ -63,3 +63,32 @@ export function repararTeclado(entrada) {
 }
 /** Cada cuanto se comprueba. Cuatro veces por segundo se nota como instantaneo. */
 export const MS_ENTRE_COMPROBACIONES = 250;
+/**
+ * Vuelve a poner el modo crudo DE VERDAD, no solo en la cuenta de Node.
+ *
+ * EL AGUJERO QUE TAPA
+ *
+ * `setRawMode(true)` no siempre llega al terminal. Por debajo, libuv guarda el
+ * modo que cree tener y empieza con `if (tty->mode == mode) return 0;`. Asi que
+ * si algo cambia el modo de la consola por fuera de Node -un proceso hijo, la
+ * propia shell, el terminal- Node sigue creyendo que esta en crudo, y a partir
+ * de ahi TODOS los `setRawMode(true)` se convierten en no-op. Incluido el que
+ * hace el prompt al abrirse.
+ *
+ * Se veia asi, y se reporto cuatro veces: el usuario teclea, su texto sale al
+ * final de la linea de ayuda -lo esta haciendo el eco del terminal, no el
+ * prompt- y el recuadro no se entera de nada. El vigilante tampoco reparaba
+ * nada, porque preguntaba a Node y Node decia que todo estaba bien.
+ *
+ * Pasar por `false` primero rompe esa cache: la segunda llamada ya ve un cambio
+ * de verdad y lo aplica sobre la consola.
+ */
+export function reafirmarModoCrudo(entrada) {
+    if (!entrada || typeof entrada.setRawMode !== "function")
+        return;
+    try {
+        entrada.setRawMode(false);
+    }
+    catch { }
+    entrada.setRawMode(true);
+}

package/dist/ui/pegados.d.ts

@@ -0,0 +1,50 @@
+/**
+ * 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 declare const MINIMO_LINEAS = 5;
+export declare const MINIMO_CARACTERES = 400;
+/** Si merece la pena guardarlo aparte, o es lo bastante corto para verlo entero. */
+export declare function esGrande(texto: string): boolean;
+/** Guarda el texto y devuelve la marca que va en el recuadro. */
+export declare function guardarPegado(texto: string): string;
+/** Devuelve el texto de verdad, con las marcas sustituidas. Es lo que ve el modelo. */
+export declare function expandirPegados(entrada: string): string;
+/**
+ * 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 declare function marcaQueTerminaEn(buffer: string, cursor: number): {
+    inicio: number;
+} | null;
+/** Se olvidan al cerrar el prompt: cada turno empieza con su propia cuenta. */
+export declare function limpiarPegados(): void;
+/** Cuantos hay guardados ahora mismo. Solo para las pruebas. */
+export declare function cuantosPegados(): number;

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/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,42 @@ 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 { 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" },
@@ -257,6 +291,8 @@ export async function askInteractivePrompt(promptSymbol = "❯", cwd = process.c
         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 +320,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 +355,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 +438,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 +457,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 +505,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 +513,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 +548,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 +576,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 +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();
                 }
@@ -674,12 +727,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();
     });

package/dist/ui/salida.d.ts

@@ -0,0 +1,10 @@
+/** Pinta encima del terminal. En produccion es `process.stdout.write` y nada mas. */
+export declare function dibujar(texto: string): void;
+/**
+ * Desvia el dibujo. Con `null` vuelve al terminal.
+ *
+ * Solo lo usan las pruebas, y siempre devolviendolo en un `finally`: si se
+ * queda desviado, las pruebas que vengan detras dibujan en el vacio sin
+ * enterarse.
+ */
+export declare function redirigirDibujo(destino: ((texto: string) => void) | null): void;

package/dist/ui/salida.js

@@ -0,0 +1,50 @@
+import process from "node:process";
+/**
+ * Por donde sale lo que se pinta encima del terminal.
+ *
+ * Aqui va SOLO el dibujo que ocupa el terminal a la fuerza: el marco del
+ * prompt, los avisos que se escriben pisando la linea actual con \r y \x1b[2K.
+ * Un `console.log` normal no pasa por aqui y no tiene por que.
+ *
+ * POR QUE EXISTE
+ *
+ * `npm publish` corre `prepublishOnly` -> `npm test`, y las pruebas del teclado
+ * abren el prompt de verdad. Con un terminal delante, el prompt mueve el
+ * cursor, borra lineas y repinta su marco encima de la sesion de quien esta
+ * publicando. En un `npm publish` real se vio esto:
+ *
+ *     ❯ hola mundo
+ *     ↳ en cola: y ahora los tests
+ *
+ * El terminal dejaba de ser suyo y la publicacion no arrancaba. Hubo que
+ * publicar con --ignore-scripts, saltandose las 488 pruebas; una red de
+ * seguridad que hay que apagar para trabajar no es una red.
+ *
+ * POR QUE NO SE SILENCIA `process.stdout` DESDE FUERA
+ *
+ * Se intento de las dos formas y las dos rompen algo peor. `node --test`
+ * instrumenta process.stdout para asociar cada linea a la prueba que la
+ * produjo: al sustituir el objeto -o solo su `write`- las pruebas se ejecutan
+ * pero desaparecen del informe, sin fallar y sin dejar rastro. Medido: de 6
+ * pruebas pasaban a contarse 2, en verde. Una prueba que se evapora es peor que
+ * una que falla.
+ *
+ * Con un conducto propio, process.stdout no se toca nunca.
+ */
+let conducto = (texto) => {
+    process.stdout.write(texto);
+};
+/** Pinta encima del terminal. En produccion es `process.stdout.write` y nada mas. */
+export function dibujar(texto) {
+    conducto(texto);
+}
+/**
+ * Desvia el dibujo. Con `null` vuelve al terminal.
+ *
+ * Solo lo usan las pruebas, y siempre devolviendolo en un `finally`: si se
+ * queda desviado, las pruebas que vengan detras dibujan en el vacio sin
+ * enterarse.
+ */
+export function redirigirDibujo(destino) {
+    conducto = destino ?? ((texto) => { process.stdout.write(texto); });
+}