chocolatito-code 1.6.5 → 1.6.7

package/dist/ui/ink/transcripcion.js

@@ -0,0 +1,180 @@
+/**
+ * LA CONVERSACIÓN, EN CAMINO AL HISTORIAL DEL TERMINAL
+ *
+ * QUÉ SUSTITUYE, Y POR QUÉ
+ *
+ * Antes esto era `historial.ts`: un buffer en memoria con las últimas 5000
+ * líneas, que hacía falta porque la pantalla alternativa deja al terminal sin
+ * historial propio. Aquí no hay pantalla alternativa. Lo que se escribe entra en
+ * el historial DEL TERMINAL —el de verdad, el de la rueda del ratón— a través de
+ * `<Static>` de Ink, y esto es solo la cinta transportadora que lo lleva hasta
+ * allí.
+ *
+ * POR QUÉ HAY QUE PARTIR EN LÍNEAS
+ *
+ * `<Static>` emite un elemento y lo da por escrito para siempre: una vez fuera,
+ * ni Ink ni nadie puede volver a tocarlo, porque ya es texto del terminal. Así
+ * que solo puede entrar lo que está terminado. El modelo, en cambio, escribe a
+ * chorros que cortan a mitad de palabra.
+ *
+ * Aquí se separan las dos cosas: lo que ya tiene su salto de línea pasa a
+ * `<Static>` y se vuelve permanente; el trozo que cuelga se queda en `resto` y
+ * lo pinta la zona de abajo, que sí se repinta. Cuando llega el salto, el resto
+ * entero cruza al otro lado. Visto desde fuera es una línea que se va
+ * escribiendo, sin saltos ni parpadeos.
+ *
+ * LAS DOS REGLAS DE <STATIC>, QUE NO SON NEGOCIABLES
+ *
+ * Están medidas en `node_modules/ink/build/components/Static.js:11-20`, que es
+ * todo el mecanismo: guarda un índice, renderiza `items.slice(indice)` y en el
+ * commit siguiente adelanta el índice a `items.length`. No compara nada.
+ *
+ *   1. La lista SOLO crece. Un `splice`, un `filter` o un vaciado hacen retroceder
+ *      el índice, y todo lo que se añada por encima se REIMPRIME: la conversación
+ *      sale duplicada en el historial del terminal y ya no hay forma de borrarla.
+ *   2. Cada elemento necesita `key` propia y estable. React reutiliza nodos por
+ *      posición, y la lista que ve cambia de longitud en cada commit; sin `key`
+ *      acabas emitiendo el texto de otro. Por eso cada línea lleva su `id`.
+ *
+ * Y POR QUÉ EXISTE `base`
+ *
+ * Cuando el árbol se desmonta y se vuelve a montar —un diálogo de permisos que
+ * necesita el teclado para él solo— el `<Static>` nuevo empieza de cero y
+ * volvería a escribir la conversación entera. Pero en la pantalla normal esas
+ * líneas siguen ahí, en el terminal, que no se ha borrado. `base` marca por
+ * dónde iba, y el montaje nuevo solo recibe lo que aún no se ha pintado.
+ */
+/** Lo que se ha ido escribiendo, en orden. Solo se añade al final. */
+let lineas = [];
+/** Cuántas de esas ya están escritas en el terminal. Solo cambia al remontar. */
+let base = 0;
+/** El trozo sin terminar. Todavía no puede cruzar a <Static>. */
+let resto = "";
+let siguienteId = 1;
+const oyentes = [];
+function avisar() {
+    for (const cb of oyentes) {
+        try {
+            cb();
+        }
+        catch { }
+    }
+}
+/**
+ * Entra texto del agente. Acepta trozos a media línea, que es lo normal.
+ *
+ * El `\r` suelto se descarta con su línea: en un flujo de markdown no es un
+ * retorno de carro de verdad, viene de un `\r\n` partido por la mitad entre dos
+ * trozos, y dejarlo pasar mete una línea vacía por cada salto.
+ */
+export function anotar(texto) {
+    if (!texto)
+        return;
+    const completo = resto + String(texto).replace(/\r\n/g, "\n");
+    const partes = completo.split("\n");
+    resto = partes.pop() ?? "";
+    for (const l of partes) {
+        lineas.push({ id: siguienteId++, texto: l });
+    }
+    avisar();
+}
+/** Lo último que se entregó, para no rehacerlo en cada dibujado. */
+let entregado = [];
+let entregadoLargo = -1;
+let entregadoBase = -1;
+/**
+ * Las líneas que <Static> todavía no ha escrito.
+ *
+ * DEVUELVE UN ARRAY NUEVO CADA VEZ QUE HAY ALGO NUEVO, Y NO ES UN CAPRICHO
+ *
+ * Este fue el fallo que dejó la conversación entera sin escribirse, y costó
+ * encontrarlo porque no parecía un fallo: la primera versión devolvía el array
+ * interno tal cual, al que `anotar` le hace `push`.
+ *
+ * <Static> memoriza lo que va a emitir con `useMemo(() => items.slice(index),
+ * [items, index])` (Static.js:12-14). Con la MISMA referencia de array y el
+ * mismo índice, React da por buena la memoria y devuelve lo de antes: el `[]`
+ * del primer dibujado. El array crecía, la pantalla no. Nada de emitir de más
+ * ni de menos: sencillamente no se emitía NUNCA.
+ *
+ * Así que la referencia tiene que cambiar cuando cambia el contenido. Se
+ * reconstruye solo cuando ha crecido de verdad —una vez por línea terminada, no
+ * una por dibujado—, que a treinta fotogramas por segundo es la diferencia entre
+ * reconstruirlo treinta veces por segundo o ninguna mientras nadie escribe.
+ */
+export function pendientes() {
+    if (lineas.length !== entregadoLargo || base !== entregadoBase) {
+        entregado = lineas.slice(base);
+        entregadoLargo = lineas.length;
+        entregadoBase = base;
+    }
+    return entregado;
+}
+/** El trozo que cuelga, el que pinta la zona de abajo. */
+export function colgando() {
+    return resto;
+}
+/**
+ * "Lo de hasta aquí ya está en el terminal."
+ *
+ * Se llama SOLO justo antes de desmontar el árbol. Llamarlo con el árbol vivo
+ * encogería la lista que ve <Static>, que es la regla 1 de arriba.
+ */
+export function darPorPintado() {
+    base = lineas.length;
+}
+export function alCambiar(cb) {
+    oyentes.push(cb);
+    return () => {
+        const i = oyentes.indexOf(cb);
+        if (i >= 0)
+            oyentes.splice(i, 1);
+    };
+}
+/** Para las pruebas. En producción la conversación no se tira nunca. */
+export function vaciarTranscripcion() {
+    lineas = [];
+    base = 0;
+    resto = "";
+    siguienteId = 1;
+    entregado = [];
+    entregadoLargo = -1;
+    entregadoBase = -1;
+}
+/** Cuántas líneas terminadas van. Para las pruebas y para medir. */
+export function cuantasLineas() {
+    return lineas.length;
+}
+const SOLO_COLOR = /\x1b\[[0-9;]*m/g;
+/**
+ * Recorta el trozo que cuelga para que quepa en las filas que le tocan.
+ *
+ * NO ES COSMÉTICO, ES LA RED DE SEGURIDAD DEL RENDIMIENTO
+ *
+ * En Windows, si el bloque de abajo llega a medir lo que la ventana, Ink deja de
+ * repintar por diferencias y pasa a `clearTerminal` + reimprimir la conversación
+ * ENTERA en cada fotograma (ink.js:100-102 y 769). Con el spinner a 30 por
+ * segundo eso es parpadeo, historial perdido y coste creciente con la sesión.
+ *
+ * El caso que lo dispara: un párrafo largo sin un solo salto de línea. Mientras
+ * no lo termine, ese párrafo entero es "lo que cuelga".
+ *
+ * Cuando hay que recortar se quitan también los colores: cortar una cadena por
+ * el medio parte los códigos de escape y lo que sale es basura de colores
+ * enganchada al resto de la sesión. Es un trozo que en cuanto llegue su salto de
+ * línea se reemplaza por la línea entera y bien pintada, así que el recorte no
+ * dura ni un parpadeo.
+ */
+export function recortarCola(texto, cols, filas) {
+    if (!texto)
+        return [];
+    const ancho = Math.max(1, cols);
+    const techo = Math.max(0, filas);
+    if (techo === 0)
+        return [];
+    const visible = texto.replace(SOLO_COLOR, "");
+    if (Math.ceil(visible.length / ancho) <= techo)
+        return [texto];
+    const pelado = visible.slice(-(ancho * techo));
+    return [pelado];
+}

package/dist/ui/interrupt.js

@@ -177,7 +177,10 @@ export class InterruptWatcher {
                 }
                 else {
                     this.stop();
-                    process.stdout.write("\n");
+                    // `dibujar` y no `process.stdout.write`: con el arbol montado, una
+                    // escritura cruda es una fila que Ink no cuenta, y el borrado del marco
+                    // al salir se come una linea de la conversacion.
+                    dibujar("\n");
                     process.exit(0);
                 }
                 return;

package/dist/ui/loopPrompt.d.ts

@@ -5,13 +5,12 @@ export interface RespuestaDeBucle {
     indicacion?: string;
 }
 /**
- * Que hacer cuando el agente lleva tres vueltas haciendo exactamente lo mismo.
+ * Se pide el terminal prestado antes de abrir esto.
  *
- * Sin terminal —CI, `chocolatito "tarea"`, un cron— se PARA. Es lo contrario de
- * lo que hace el dialogo de permisos, que ante la duda deniega para no tocar
- * nada, y el motivo es que aqui el riesgo es el opuesto: no hay nada que
- * proteger del agente, hay una cuota que proteger de un bucle que nadie esta
- * mirando. Parar no mata el turno: le devuelve al modelo un mensaje explicando
- * el atasco, y el turno sigue.
+ * Con el árbol de Ink montado hay un dueño de la pantalla, y esta función es de
+ * las que necesitan el teclado para ellas solas: escribe directo a stdout y abre
+ * su propia lectura de teclas. Sin el préstamo, las dos cuentas de filas se pisan
+ * y el marco de Ink no se recupera. Sin árbol, `conElTerminalPrestado` ejecuta la
+ * tarea tal cual y no cuesta nada. Ver ui/ink/prestamo.ts.
  */
 export declare function preguntarPorBucle(aviso: AvisoDeBucle): Promise<RespuestaDeBucle>;

package/dist/ui/loopPrompt.js

@@ -1,6 +1,7 @@
 import readline from "node:readline";
 import process from "node:process";
 import chalk from "chalk";
+import { conElTerminalPrestado } from "./ink/prestamo.js";
 /**
  * Que hacer cuando el agente lleva tres vueltas haciendo exactamente lo mismo.
  *
@@ -11,7 +12,7 @@ import chalk from "chalk";
  * mirando. Parar no mata el turno: le devuelve al modelo un mensaje explicando
  * el atasco, y el turno sigue.
  */
-export async function preguntarPorBucle(aviso) {
+async function preguntarPorBucleDirecto(aviso) {
     const cabecera = chalk.yellow(`\n↻  Parece un bucle: `) +
         chalk.white(`"${aviso.herramienta}"`) +
         chalk.yellow(` lleva ${aviso.repeticiones} llamadas identicas con el mismo resultado.`);
@@ -57,3 +58,15 @@ export async function preguntarPorBucle(aviso) {
         });
     });
 }
+/**
+ * Se pide el terminal prestado antes de abrir esto.
+ *
+ * Con el árbol de Ink montado hay un dueño de la pantalla, y esta función es de
+ * las que necesitan el teclado para ellas solas: escribe directo a stdout y abre
+ * su propia lectura de teclas. Sin el préstamo, las dos cuentas de filas se pisan
+ * y el marco de Ink no se recupera. Sin árbol, `conElTerminalPrestado` ejecuta la
+ * tarea tal cual y no cuesta nada. Ver ui/ink/prestamo.ts.
+ */
+export function preguntarPorBucle(aviso) {
+    return conElTerminalPrestado(() => preguntarPorBucleDirecto(aviso));
+}

package/dist/ui/marco.d.ts

@@ -32,4 +32,6 @@ export interface PromptFrame {
  * aritmetica de filas se hace UNA vez sobre las mismas lineas que se pintan, en
  * lugar de estimarse por otro lado y descuadrarse.
  */
+/** Cuantas sugerencias se ensenan como mucho. Ver la nota en el desplegable. */
+export declare const MAXIMO_DEL_DESPLEGABLE = 8;
 export declare function buildPromptFrame(opts: PromptFrameOptions): PromptFrame;

package/dist/ui/marco.js

@@ -55,6 +55,8 @@ function truncatePlain(text, width) {
  * aritmetica de filas se hace UNA vez sobre las mismas lineas que se pintan, en
  * lugar de estimarse por otro lado y descuadrarse.
  */
+/** Cuantas sugerencias se ensenan como mucho. Ver la nota en el desplegable. */
+export const MAXIMO_DEL_DESPLEGABLE = 8;
 export function buildPromptFrame(opts) {
     const cols = Math.max(20, opts.cols || 80);
     const viewportRows = Math.max(6, opts.rows || 24);
@@ -95,7 +97,22 @@ export function buildPromptFrame(opts) {
     // Sin contarla, el desplegable pide una fila mas de las que caben y el marco
     // se sale por arriba de la ventana.
     const room = Math.max(1, viewportRows - 1 - (2 + 1 + inputRows + 1 + 1));
-    const shown = Math.min(items.length, room);
+    // Y ademas un tope propio, mas bajo que lo que cabe.
+    //
+    // POR QUE NO SE DEJA CRECER HASTA LLENAR LA VENTANA
+    //
+    // Con solo "/" hay dieciocho comandos. En una consola de 24 filas eso hacia un
+    // marco de veinte, o sea que al escribir UNA barra la caja se comia la pantalla
+    // entera y tapaba la conversacion; y a la letra siguiente se encogia a nueve.
+    // Cada tecla movia veinte filas arriba y abajo.
+    //
+    // Eso es feo, y ademas es el terreno donde aparecen los fallos de repintado: un
+    // marco que crece hasta el borde obliga al terminal a desplazar, y a partir de
+    // ahi Ink borra contando filas que ya no son suyas.
+    //
+    // Ocho es lo que se ve de un vistazo sin buscar. Y el desplegable filtra segun
+    // escribes, asi que llegar al que quieres son dos letras, no dieciocho lineas.
+    const shown = Math.min(items.length, room, MAXIMO_DEL_DESPLEGABLE);
     const dropdownOffset = shown > 0 && items.length > shown
         ? Math.min(Math.max(0, selectedIndex - Math.floor(shown / 2)), items.length - shown)
         : 0;

package/dist/ui/pantalla.d.ts

@@ -1,37 +1,58 @@
 /**
- * Fija POR DEFECTO, esta vez con pruebas que lo respaldan.
- *
- * La primera vez que se puso de serie la sesion salia en negro, y las 820
- * pruebas pasaban: comprobaban el ARBOL que Ink quiere pintar, no lo que una
- * consola hace con esos bytes. El terminal de mentira de la libreria no
- * desplaza al pasarse de alto, que era justo el fallo.
- *
- * Ahora hay un emulador de verdad (tests/terminal.test.mjs): se le da a Ink un
- * stdout con tamaño, se capturan sus bytes y se pasan por un interprete que
- * desplaza como lo haria la consola. Con el arreglo puesto, cien repintados no
- * desplazan ni una fila en cinco tamaños de ventana distintos; devolviendo el
- * fallo, tres de esas pruebas se caen. Eso es lo que faltaba la vez anterior.
- *
- * CHOCOLATITO_PANTALLA=normal devuelve el comportamiento de siempre: el
- * historial vuelve a ser del terminal y la rueda del raton a servir, a cambio de
- * que la barra suba con el scroll.
+ * De serie SÍ, desde la 1.6.7, y con salida de emergencia.
+ *
+ * DOS VECES ESTUVO AQUÍ Y DOS VECES SALIÓ ROTO
+ *
+ * La 1.6.0 salió en negro ("no sale nada, se bugea") y la 1.6.5 con "una barra y
+ * lo demás negro, escribo y se cierra". Las dos veces pasaban las 820 pruebas:
+ * un emulador prueba lo que sabe emular, y una consola de verdad hace cosas que
+ * no sabe.
+ *
+ * Esta vez el orden fue el otro: se entregó detrás de la variable, el dueño lo
+ * corrió en SU consola, y solo después pasó a ser lo normal. Lo hizo, y lo
+ * aprobó sabiendo lo que no le iba a gustar: que la caja no se queda clavada al
+ * hacer scroll. No se queda porque es texto del terminal, y en Claude Code
+ * tampoco se queda. Es el precio de recuperar la rueda del ratón y el historial.
+ *
+ * CHOCOLATITO_PANTALLA=normal devuelve la interfaz clásica. Existe porque una
+ * consola rara —una que no sea la suya ni la mía— puede seguir haciendo algo que
+ * no habíamos visto, y entonces el usuario necesita poder trabajar hoy, no
+ * esperar al parche.
  */
 export declare function pantallaFijaPedida(): boolean;
+export declare function forzarPantallaFija(valor: boolean | null): void;
+export declare function enPantallaFija(): boolean;
 /**
- * Enciende o apaga el modo a mano, SIN tocar el terminal.
+ * Enciende el modo de árbol único. Devuelve si de verdad se encendió.
+ *
+ * EL BOOLEANO NO SOBRA, Y SE VOLVIÓ IMPRESCINDIBLE AL PONERLO POR DEFECTO
  *
- * Las pruebas lo necesitan: entrar de verdad escribiría la secuencia de la
- * pantalla alternativa en la consola de quien corre las pruebas y le dejaría el
- * informe en una pantalla que desaparece al acabar.
+ * Sin terminal —una salida redirigida a un archivo, un `chocolatito "tarea"` en
+ * un script, CI— aquí no se entra. Pero quien llama montaba el árbol de todas
+ * formas, y Ink sin terminal escribe su marco como texto suelto: la salida del
+ * programa sale con la caja de escribir dentro.
+ *
+ * Mientras esto iba detrás de una variable no pasaba nunca, porque nadie la pone
+ * en un script. De serie, es el caso normal.
  */
-export declare function forzarPantallaFija(valor: boolean | null): void;
-export declare function enPantallaFija(): boolean;
-export declare function entrarEnPantallaFija(): void;
+export declare function entrarEnPantallaFija(): boolean;
+/**
+ * Manda `console` a la transcripción.
+ *
+ * Se exporta para poder probarlo: `entrarEnPantallaFija` no se puede llamar en
+ * las pruebas porque exige un terminal de verdad, y un parche de consola sin
+ * probar es de las cosas que fallan en silencio —lo que se pierde no se ve, que
+ * es justo el problema—.
+ */
+export declare function interceptarConsola(): void;
+export declare function devolverConsola(): void;
 /**
  * Devuelve el terminal como estaba.
  *
- * Se llama al salir del programa, y también si algo revienta: quedarse en la
- * pantalla alternativa deja al usuario en una consola en blanco sin su prompt,
- * y la única salida es cerrar la ventana.
+ * Aquí ya no hay ninguna pantalla que abandonar —esa era la versión de antes—,
+ * pero sí hay que devolver el conducto de dibujo y el pie: si el proceso sigue
+ * vivo después de esto (una prueba, una sesión que cambia de modo) y el dibujo
+ * se queda desviado, todo lo que se escriba va a una transcripción que ya no
+ * pinta nadie.
  */
 export declare function salirDePantallaFija(): void;

package/dist/ui/pantalla.js

@@ -1,110 +1,197 @@
 import process from "node:process";
+import { format } from "node:util";
 import { redirigirDibujo } from "./salida.js";
-import { apuntar } from "./historial.js";
+import { anotar } from "./ink/transcripcion.js";
 import { habilitarPie } from "./pieFijo.js";
+import { limpiarLaPantalla } from "./ink/montarApp.js";
 /**
- * LA PANTALLA ALTERNATIVA
+ * QUIÉN ES DUEÑO DE LA PANTALLA
  *
- * La barra de abajo sube al hacer scroll porque ES una línea del historial del
- * terminal, no una capa encima. Ninguna secuencia de escape la clava ahí; lo
- * único que lo consigue es que el programa tome la pantalla entera, como hacen
- * vim o htop.
+ * LO QUE HABÍA AQUÍ ANTES, Y POR QUÉ SE FUE
  *
- * QUÉ CAMBIA AL ENTRAR
+ * Este archivo tomaba la pantalla alternativa —la de vim o htop— para clavar la
+ * barra de abajo. Es la única forma de clavarla de verdad, y se pidió cinco
+ * veces, así que se hizo. Se publicó rota dos veces: "no sale nada, se bugea" y
+ * "sale una barra y lo demás negro, escribo y se cierra".
  *
- * El terminal deja de guardar historial: la rueda del ratón no sirve y al salir
- * la sesión desaparece de la consola. Por eso, mientras dura, TODO lo que se
- * imprime se guarda en memoria (historial.ts) y lo pinta el árbol de Ink.
+ * Y resultó que además era la arquitectura equivocada. Claude Code, que era el
+ * ejemplo a copiar, NO usa la pantalla alternativa: renderiza en el buffer
+ * normal y emite la conversación con `<Static>` de Ink, que la escribe una vez y
+ * la deja en el historial del terminal. Por eso allí la rueda del ratón funciona.
+ * Y por eso allí la barra tampoco se queda quieta si subes: se va con el resto.
  *
- * Y por eso hay que interceptar también `console.log`. Aquí no vale con desviar
- * el conducto de dibujo: media docena de sitios —el arranque, la licencia, los
- * avisos— siguen imprimiendo directo, y en la pantalla alternativa eso escribe
- * encima de lo que Ink acaba de dibujar y descuadra el árbol entero.
+ * QUÉ HACE AHORA
  *
- * EL INTERCAMBIO
+ * Enciende el modo de árbol único: un solo componente de Ink vivo toda la
+ * sesión, en la pantalla de siempre. Lo que cambia respecto al modo clásico:
  *
- * Cambiar el historial del terminal por uno propio no es gratis: quien use la
- * rueda del ratón para releer sale perdiendo, y a cambio se recorre con Re Pág
- * y Av Pág. Se pidió así cinco veces, así que va de serie;
- * CHOCOLATITO_PANTALLA=normal devuelve lo de antes.
+ *   - El dibujo del agente deja de ir al terminal y entra en la transcripción,
+ *     que es lo que `<Static>` va escribiendo (ink/transcripcion.ts).
+ *   - `pieFijo` deja de pintar. Sigue guardando el spinner y la línea de
+ *     razonamiento, pero quien los dibuja pasa a ser el árbol. Dos dueños del
+ *     mismo trozo de pantalla es el problema que esto viene a quitar.
+ *
+ * Y SE SIGUE INTERCEPTANDO `console`, PERO POR OTRO MOTIVO
+ *
+ * Ink trae su propio `patchConsole`, y hace lo correcto: borra su marco, escribe
+ * el mensaje y repinta debajo. Aquí no se usa, y no es por desconfianza: es por
+ * el ORDEN.
+ *
+ * Lo que escribe el agente entra en la transcripción y sale cuando React confirma
+ * el dibujado. Un `console.log` con el parche de Ink sale en el acto. Dos caminos
+ * con tiempos distintos para el mismo hilo de conversación, y entonces el aviso
+ * de un hook puede aparecer por encima de la frase que lo provocó. Es de los
+ * fallos que no se notan hasta que confundes a alguien.
+ *
+ * Mandando los dos por la transcripción hay una sola cola y el orden es el de
+ * verdad. Se cubren `log`, `error`, `warn` e `info` —el parche de antes solo
+ * cubría `log`— y se formatea con `util.format`, que es lo que hace `console` de
+ * serie: sin eso, un `console.log("%s pruebas", 12)` sale con el `%s` puesto.
  */
-const ENTRAR = "\x1b[?1049h";
-const SALIR = "\x1b[?1049l";
 let dentro = false;
-let logOriginal = null;
+const original = {};
 /**
- * Fija POR DEFECTO, esta vez con pruebas que lo respaldan.
- *
- * La primera vez que se puso de serie la sesion salia en negro, y las 820
- * pruebas pasaban: comprobaban el ARBOL que Ink quiere pintar, no lo que una
- * consola hace con esos bytes. El terminal de mentira de la libreria no
- * desplaza al pasarse de alto, que era justo el fallo.
- *
- * Ahora hay un emulador de verdad (tests/terminal.test.mjs): se le da a Ink un
- * stdout con tamaño, se capturan sus bytes y se pasan por un interprete que
- * desplaza como lo haria la consola. Con el arreglo puesto, cien repintados no
- * desplazan ni una fila en cinco tamaños de ventana distintos; devolviendo el
- * fallo, tres de esas pruebas se caen. Eso es lo que faltaba la vez anterior.
- *
- * CHOCOLATITO_PANTALLA=normal devuelve el comportamiento de siempre: el
- * historial vuelve a ser del terminal y la rueda del raton a servir, a cambio de
- * que la barra suba con el scroll.
+ * De serie SÍ, desde la 1.6.7, y con salida de emergencia.
+ *
+ * DOS VECES ESTUVO AQUÍ Y DOS VECES SALIÓ ROTO
+ *
+ * La 1.6.0 salió en negro ("no sale nada, se bugea") y la 1.6.5 con "una barra y
+ * lo demás negro, escribo y se cierra". Las dos veces pasaban las 820 pruebas:
+ * un emulador prueba lo que sabe emular, y una consola de verdad hace cosas que
+ * no sabe.
+ *
+ * Esta vez el orden fue el otro: se entregó detrás de la variable, el dueño lo
+ * corrió en SU consola, y solo después pasó a ser lo normal. Lo hizo, y lo
+ * aprobó sabiendo lo que no le iba a gustar: que la caja no se queda clavada al
+ * hacer scroll. No se queda porque es texto del terminal, y en Claude Code
+ * tampoco se queda. Es el precio de recuperar la rueda del ratón y el historial.
+ *
+ * CHOCOLATITO_PANTALLA=normal devuelve la interfaz clásica. Existe porque una
+ * consola rara —una que no sea la suya ni la mía— puede seguir haciendo algo que
+ * no habíamos visto, y entonces el usuario necesita poder trabajar hoy, no
+ * esperar al parche.
  */
 export function pantallaFijaPedida() {
     return process.env.CHOCOLATITO_PANTALLA !== "normal";
 }
 /** `null` = manda el estado real. Las pruebas lo fuerzan. */
 let forzado = null;
-/**
- * Enciende o apaga el modo a mano, SIN tocar el terminal.
- *
- * Las pruebas lo necesitan: entrar de verdad escribiría la secuencia de la
- * pantalla alternativa en la consola de quien corre las pruebas y le dejaría el
- * informe en una pantalla que desaparece al acabar.
- */
 export function forzarPantallaFija(valor) {
     forzado = valor;
 }
 export function enPantallaFija() {
     return forzado ?? dentro;
 }
+/**
+ * Enciende el modo de árbol único. Devuelve si de verdad se encendió.
+ *
+ * EL BOOLEANO NO SOBRA, Y SE VOLVIÓ IMPRESCINDIBLE AL PONERLO POR DEFECTO
+ *
+ * Sin terminal —una salida redirigida a un archivo, un `chocolatito "tarea"` en
+ * un script, CI— aquí no se entra. Pero quien llama montaba el árbol de todas
+ * formas, y Ink sin terminal escribe su marco como texto suelto: la salida del
+ * programa sale con la caja de escribir dentro.
+ *
+ * Mientras esto iba detrás de una variable no pasaba nunca, porque nadie la pone
+ * en un script. De serie, es el caso normal.
+ */
 export function entrarEnPantallaFija() {
-    if (dentro || !process.stdout.isTTY)
-        return;
+    if (dentro)
+        return true;
+    if (!process.stdout.isTTY)
+        return false;
     dentro = true;
-    process.stdout.write(ENTRAR);
-    // Lo que se dibujaba en el terminal pasa a ser historial nuestro.
-    redirigirDibujo((texto) => apuntar(texto));
-    // Y el pie deja de pintar. Sigue guardando sus secciones -el spinner y la
-    // linea de razonamiento publican ahi sin enterarse de nada- pero quien las
-    // dibuja pasa a ser el arbol. Dos dueños del mismo trozo de pantalla es
-    // exactamente el problema que esto viene a quitar.
+    // Lo que el agente dibuja pasa a ser texto de la transcripción. De ahí lo
+    // recoge <Static> y lo escribe en el historial del terminal, una sola vez.
+    redirigirDibujo((texto) => anotar(texto));
     habilitarPie(false);
-    logOriginal = console.log;
-    console.log = (...args) => {
-        apuntar(args.map((a) => (typeof a === "string" ? a : String(a))).join(" ") + "\n");
+    interceptarConsola();
+    return true;
+}
+const CANALES = ["log", "error", "warn", "info"];
+/**
+ * `console.clear` va aparte porque no es un mensaje, es una orden al terminal.
+ *
+ * Y estaba fuera de la lista, que era un agujero de los caros: /clear, /cd y el
+ * Ctrl+L del prompt clásico llaman a `console.clear()`, y con el árbol montado
+ * eso borra filas que Ink cree suyas. A partir de ahí Ink repinta sobre un sitio
+ * que ya no existe y lo que se ve es basura.
+ *
+ * Se manda a `limpiarLaPantalla`, que hace lo mismo pero en el orden que no
+ * rompe nada. Ver ui/ink/montarApp.tsx.
+ */
+let clearOriginal = null;
+/**
+ * Manda `console` a la transcripción.
+ *
+ * Se exporta para poder probarlo: `entrarEnPantallaFija` no se puede llamar en
+ * las pruebas porque exige un terminal de verdad, y un parche de consola sin
+ * probar es de las cosas que fallan en silencio —lo que se pierde no se ve, que
+ * es justo el problema—.
+ */
+export function interceptarConsola() {
+    if (original.log)
+        return;
+    clearOriginal = console.clear;
+    console.clear = () => {
+        limpiarLaPantalla();
     };
+    for (const nombre of CANALES) {
+        original[nombre] = console[nombre];
+        console[nombre] = (...args) => {
+            anotar(`${format(...args)}\n`);
+        };
+    }
+}
+export function devolverConsola() {
+    if (clearOriginal) {
+        console.clear = clearOriginal;
+        clearOriginal = null;
+    }
+    for (const nombre of CANALES) {
+        const previo = original[nombre];
+        if (previo)
+            console[nombre] = previo;
+        delete original[nombre];
+    }
 }
 /**
  * Devuelve el terminal como estaba.
  *
- * Se llama al salir del programa, y también si algo revienta: quedarse en la
- * pantalla alternativa deja al usuario en una consola en blanco sin su prompt,
- * y la única salida es cerrar la ventana.
+ * Aquí ya no hay ninguna pantalla que abandonar —esa era la versión de antes—,
+ * pero sí hay que devolver el conducto de dibujo y el pie: si el proceso sigue
+ * vivo después de esto (una prueba, una sesión que cambia de modo) y el dibujo
+ * se queda desviado, todo lo que se escriba va a una transcripción que ya no
+ * pinta nadie.
  */
 export function salirDePantallaFija() {
     if (!dentro)
         return;
     dentro = false;
-    if (logOriginal) {
-        console.log = logOriginal;
-        logOriginal = null;
-    }
     redirigirDibujo(null);
     habilitarPie(null);
-    try {
-        process.stdout.write(SALIR);
-    }
-    catch { }
+    devolverConsola();
 }
 process.on("exit", salirDePantallaFija);
+/*
+ * AQUÍ HABÍA UN `unhandledRejection` QUE MATABA EL PROGRAMA. SE HA QUITADO.
+ *
+ * Existía para que un error dentro de la pantalla alternativa no se perdiera al
+ * salir de ella. Pero se registraba al importar el módulo, o sea SIEMPRE, con
+ * pantalla fija o sin ella, y hacía `process.exit(1)`.
+ *
+ * index.ts tiene su propia red de seguridad para lo mismo, y su criterio es el
+ * contrario y el bueno: "una promesa sin capturar no debería costarle al usuario
+ * la sesión entera, con todo su contexto. Se avisa y se sigue." Node ejecuta los
+ * dos manejadores, pero el de aquí se registraba antes y salía, así que ganaba
+ * siempre.
+ *
+ * Consecuencia en la versión publicada: cualquier promesa de fondo que fallara
+ * —un servidor MCP que no levanta, el chequeo de licencia, la comprobación de
+ * actualizaciones— cerraba Chocolatito de golpe. Sin mensaje, y sin tener nada
+ * que ver con la interfaz.
+ *
+ * Con el buffer normal el motivo original ya no existe: un error impreso se
+ * queda en pantalla, porque no hay ninguna pantalla que se lleve el mensaje al
+ * cerrarse.
+ */