chocolatito-code 1.6.6 → 1.6.7

package/dist/index.js

@@ -15,8 +15,8 @@ import { codigoDeSalida, EXIT_OK, EXIT_FALLO, EXIT_USO, EXIT_LICENCIA } from "./
 import { showBanner, animateStartupBanner, showHelp, showEffortMenu } from "./ui/banner.js";
 import { fijarMotor } from "./ui/motorActual.js";
 import { elegirDeLista } from "./ui/selector.js";
-import { entrarEnPantallaFija, pantallaFijaPedida } from "./ui/pantalla.js";
-import { montarArbol } from "./ui/ink/montarApp.js";
+import { entrarEnPantallaFija, pantallaFijaPedida, salirDePantallaFija } from "./ui/pantalla.js";
+import { montarArbol, desmontarArbol } from "./ui/ink/montarApp.js";
 import { reafirmarModoCrudo } from "./ui/keyboardGuard.js";
 import { askInteractivePrompt, SLASH_COMMANDS } from "./ui/prompt.js";
 import { changeDir } from "./tools/changeDir.js";
@@ -89,6 +89,7 @@ function handleFlags(argv) {
             "CONFIGURACION",
             "  API key: variable CHOCOLATITO_API_KEY, un .env del proyecto o ~/.chocolatitorc.",
             "  Reglas del proyecto: CHOCOLATITO.md. Permisos y hooks: .chocolatito/settings.json.",
+            "  Interfaz clasica (sin la caja pegada abajo): variable CHOCOLATITO_PANTALLA=normal.",
             "",
             "CODIGOS DE SALIDA (modo orden unica)",
             "  0   La tarea se completo.",
@@ -136,9 +137,29 @@ function instalarRedDeSeguridad() {
     });
     // Una excepcion no capturada si es terminal, pero al menos se sale con la
     // terminal usable y con un mensaje legible en vez de una traza cruda.
+    //
+    // NO SE USA `console.log` AQUI, Y ES A PROPOSITO
+    //
+    // Con el arbol montado la consola esta interceptada: un `console.log` va a la
+    // transcripcion, que la pinta el arbol... en el proximo dibujado, que ya no
+    // llega porque la linea siguiente cierra el proceso. El mensaje se escribe en
+    // un sitio que nadie va a leer nunca.
+    //
+    // Es exactamente el fallo que impidio diagnosticar la pantalla en negro dos
+    // veces: el programa se cerraba "sin decir nada" y si lo decia, pero a una
+    // pantalla que se iba con el. Aqui se suelta el arbol primero -que devuelve la
+    // consola de verdad- y se escribe directo a stderr, que no lo intercepta nadie.
     process.on("uncaughtException", (err) => {
         restaurarTerminal();
-        console.log(chalk.red(`\n✖ Error inesperado: ${err?.message || String(err)}\n`) +
+        try {
+            desmontarArbol();
+        }
+        catch { }
+        try {
+            salirDePantallaFija();
+        }
+        catch { }
+        process.stderr.write(chalk.red(`\n✖ Error inesperado: ${err?.message || String(err)}\n`) +
             chalk.gray(`${(err?.stack || "").split("\n").slice(1, 4).join("\n")}\n`));
         process.exit(EXIT_FALLO);
     });
@@ -190,8 +211,8 @@ async function main() {
     // errores raros dentro de una dependencia. Ver config/nodeVersion.ts.
     const nodeViejo = comprobarNode();
     if (nodeViejo) {
-        console.error(chalk.red(`
-${nodeViejo}
+        console.error(chalk.red(`
+${nodeViejo}
 `));
         process.exit(EXIT_USO);
     }
@@ -237,16 +258,6 @@ ${nodeViejo}
     const hookManager = new HookManager(context.cwd);
     const sessionManager = new SessionManager();
     const sessionId = `session_${Date.now()}`;
-    // La barra de abajo solo puede quedarse clavada si el programa toma la
-    // pantalla entera. Se pide con CHOCOLATITO_PANTALLA=fija y se paga con el
-    // historial del terminal: ver ui/pantalla.ts.
-    if (pantallaFijaPedida()) {
-        entrarEnPantallaFija();
-        // Entrar y empezar a dibujar son la misma decision: entrar sin montar el
-        // arbol deja una consola en blanco de la que solo se sale cerrando la
-        // ventana.
-        montarArbol();
-    }
     let currentModel = DEFAULT_ESPECTRO;
     // La barra de estado lo lee de aqui. Fijarlo al arrancar y no solo al
     // cambiarlo: si no, hasta el primer /effort la barra no dice nada.
@@ -350,6 +361,27 @@ ${nodeViejo}
     chalk.gray("  shift+tab cambia el modo de permisos · puedes escribir mientras trabaja y se encola\n\n"));
     if (getMode() !== "default")
         console.log(`  ${modeAnnouncement()}\n`);
+    // EL ARBOL SE MONTA AQUI Y NO ANTES
+    //
+    // Va de serie. CHOCOLATITO_PANTALLA=normal devuelve la clasica. Ver ui/pantalla.ts.
+    //
+    // Estaba montado mucho mas arriba, antes del zorro. Y el zorro se dibuja con
+    // animacion: mueve el cursor y repinta. Dos cosas moviendo el cursor a la vez
+    // descuadran la cuenta de filas de Ink desde el primer fotograma, y lo que se
+    // ve es "sale una barra y lo demas negro".
+    //
+    // Aqui no queda nada por animar: el zorro ya salio, y lo que venga sale por el
+    // arbol o por el parche de console de Ink.
+    //
+    // Y el arbol solo se monta si se entro de VERDAD: sin terminal -salida a un
+    // archivo, un script, CI- no se entra, e Ink sin terminal escribe su marco
+    // como texto suelto. La salida del programa saldria con la caja de escribir
+    // metida dentro.
+    if (pantallaFijaPedida() && entrarEnPantallaFija()) {
+        // Entrar y empezar a dibujar son la misma decision: desviar el dibujo sin
+        // que haya nadie pintandolo deja la consola muda.
+        montarArbol();
+    }
     // Lo que el usuario escribio mientras el agente trabajaba entra como siguiente
     // orden, sin tener que volver a teclearlo.
     let pendiente = null;
@@ -421,15 +453,15 @@ ${nodeViejo}
                 .filter((m) => m.role === "user" || m.role === "assistant")
                 .map((m) => `### 👤 ${m.role === "user" ? "Usuario" : "Chocolatito"}\n\n${typeof m.content === "string" ? m.content : JSON.stringify(m.content, null, 2)}\n`)
                 .join("\n---\n\n");
-            const mdContent = `# 🦊 Bitácora de Sesión — Chocolatito Code
-**Fecha:** ${new Date().toLocaleString()}  
-**Directorio:** \`${agent.currentCwd}\`  
-**Motor:** ${currentModel.name}  
-**Inversión Total:** ${agent.tracker.calculateCost(undefined, undefined, undefined, currentModel.underlyingModel).formattedCost}  
-
----
-
-${sessionData}
+            const mdContent = `# 🦊 Bitácora de Sesión — Chocolatito Code
+**Fecha:** ${new Date().toLocaleString()}  
+**Directorio:** \`${agent.currentCwd}\`  
+**Motor:** ${currentModel.name}  
+**Inversión Total:** ${agent.tracker.calculateCost(undefined, undefined, undefined, currentModel.underlyingModel).formattedCost}  
+
+---
+
+${sessionData}
 `;
             fs.writeFileSync(exportPath, mdContent, "utf-8");
             console.log(chalk.green(`\n✔ Bitácora exportada exitosamente en: ${chalk.bold.white(exportPath)}\n`));
@@ -523,12 +555,12 @@ ${sessionData}
             }
             console.log(chalk.bold.hex("#A855F7")("\n🎯 INICIANDO MODO META AUTÓNOMA (GOAL MODE):"));
             console.log(chalk.gray(`  Objetivo: "${goalText}"\n`));
-            const autonomousPrompt = `[MODO META AUTÓNOMA ACTIVADO]
-Tu objetivo principal es: "${goalText}"
-Directivas de ejecución:
-1. Formula un plan de ejecución mental paso a paso.
-2. Ejecuta cada paso utilizando las herramientas correspondientes (creación, edición, ejecución, verificación).
-3. Si algo falla o hay errores, autocorregir inmediatamente y volver a probar.
+            const autonomousPrompt = `[MODO META AUTÓNOMA ACTIVADO]
+Tu objetivo principal es: "${goalText}"
+Directivas de ejecución:
+1. Formula un plan de ejecución mental paso a paso.
+2. Ejecuta cada paso utilizando las herramientas correspondientes (creación, edición, ejecución, verificación).
+3. Si algo falla o hay errores, autocorregir inmediatamente y volver a probar.
 4. No te detengas hasta verificar que el objetivo esté 100% completado con éxito.`;
             renderUserPrompt(`/goal ${goalText}`);
             await agent.runTask(autonomousPrompt);
@@ -632,12 +664,12 @@ Directivas de ejecución:
             const refreshedContext = await getProjectContext(agent.currentCwd);
             const updatedPrompt = buildSystemPrompt(refreshedContext, currentModel, skillManager, memoryManager, isPlanMode);
             agent.setEspectroModel(currentModel, updatedPrompt);
-            console.log(chalk.green(`
+            console.log(chalk.green(`
 ✔ Nivel actualizado a `) +
                 chalk.bold.hex("#A855F7")(currentModel.name) +
                 chalk.gray(` (${currentModel.effortLevel})`) +
-                `
-  ${chalk.italic.gray(currentModel.description)}
+                `
+  ${chalk.italic.gray(currentModel.description)}
 `);
             // EL TECLADO SE QUEDABA TRABADO AL CAMBIAR DE MOTOR
             //

package/dist/ui/ink/App.d.ts

@@ -1,25 +1,2 @@
 import React from "react";
-/**
- * EL ÁRBOL ÚNICO
- *
- * POR QUE EXISTE
- *
- * Antes Ink solo era dueño del prompt: se montaba para pedir una orden y se
- * desmontaba al enviarla. Mientras el agente trabajaba, el terminal volvía a ser
- * de siempre y la barra de abajo la pintaba `pieFijo` borrando y repintando a
- * mano.
- *
- * Eso son DOS dueños del mismo trozo de pantalla turnándose, y de ahí salían
- * casi todas las quejas: la barra que sube con el scroll, el hueco que aparece,
- * el marco que se descuadra. Cada arreglo era coordinar mejor a los dos dueños.
- *
- * Aquí hay uno solo, y vive toda la sesión. Lo que sale del agente entra en el
- * historial (historial.ts) y se pinta arriba; abajo va SIEMPRE la barra, sea la
- * de escribir o la de trabajar. Nadie tiene que ponerse de acuerdo con nadie.
- *
- * Y POR ESO LA BARRA SE QUEDA QUIETA
- *
- * No porque se repinte rápido, sino porque es la última fila de un árbol que
- * ocupa la ventana entera. No hay nada que pueda moverla, ni la rueda del ratón.
- */
 export declare function App(): React.ReactElement;

package/dist/ui/ink/App.js

@@ -1,79 +1,108 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useEffect, useState } from "react";
-import { Box, Text, useStdout } from "ink";
+import { Box, Static, Text, useApp, useStdout } from "ink";
 import { Prompt } from "./Prompt.js";
-import { alEscribir, tope, ventana } from "../historial.js";
+import { colgando, pendientes, recortarCola } from "./transcripcion.js";
+import { alCambiar } from "./transcripcion.js";
 import { cuandoCambieElPie, lineasDelPie } from "../pieFijo.js";
 import { alCambiarElTurno, estadoDelTurno } from "./control.js";
+import { registrarPrestamo } from "./prestamo.js";
+import { useTecladoSiempreNuestro } from "./teclado.js";
 /**
- * EL ÁRBOL ÚNICO
+ * EL ÁRBOL ÚNICO, EN LA PANTALLA DE SIEMPRE
  *
- * POR QUE EXISTE
+ * DE DÓNDE VIENE ESTE ARCHIVO
  *
- * Antes Ink solo era dueño del prompt: se montaba para pedir una orden y se
- * desmontaba al enviarla. Mientras el agente trabajaba, el terminal volvía a ser
- * de siempre y la barra de abajo la pintaba `pieFijo` borrando y repintando a
- * mano.
+ * La versión anterior tomaba la pantalla alternativa —la de vim o htop— para
+ * clavar la barra de abajo. Funcionaba en el emulador y se publicó rota dos
+ * veces. Y sobre todo: no era lo que hace Claude Code, que era lo que se pedía.
  *
- * Eso son DOS dueños del mismo trozo de pantalla turnándose, y de ahí salían
- * casi todas las quejas: la barra que sube con el scroll, el hueco que aparece,
- * el marco que se descuadra. Cada arreglo era coordinar mejor a los dos dueños.
+ * Claude Code renderiza en el buffer NORMAL. La conversación se emite una sola
+ * vez con `<Static>` y pasa al historial del terminal; debajo queda una zona que
+ * se repinta con el spinner y la caja de escribir. Por eso allí la rueda del
+ * ratón funciona y se puede releer la sesión entera.
  *
- * Aquí hay uno solo, y vive toda la sesión. Lo que sale del agente entra en el
- * historial (historial.ts) y se pinta arriba; abajo va SIEMPRE la barra, sea la
- * de escribir o la de trabajar. Nadie tiene que ponerse de acuerdo con nadie.
+ * LO QUE ESO SIGNIFICA, DICHO CLARO
  *
- * Y POR ESO LA BARRA SE QUEDA QUIETA
+ * La barra está siempre pegada al final de lo que ha salido, y cualquier línea
+ * nueva te devuelve ahí. Pero si subes con la rueda, la barra sube con el resto:
+ * es texto del terminal, no una capa encima. En Claude Code pasa exactamente lo
+ * mismo. Clavarla de verdad solo se consigue tomando la pantalla entera, y el
+ * precio es quedarse sin historial ni rueda del ratón.
  *
- * No porque se repinte rápido, sino porque es la última fila de un árbol que
- * ocupa la ventana entera. No hay nada que pueda moverla, ni la rueda del ratón.
+ * LAS TRES ZONAS
+ *
+ *   <Static>   la conversación, escrita una vez y para siempre
+ *   cola       el trozo de línea que el modelo está escribiendo ahora mismo
+ *   barra      el spinner, o la caja de escribir
+ *
+ * Las dos últimas se repintan; la primera no puede.
+ */
+/** Filas que se reservan para la caja cuando el prompt está puesto. */
+const ALTO_DE_LA_CAJA = 6;
+/**
+ * UNA LÍNEA VACÍA TIENE QUE OCUPAR SU FILA
+ *
+ * Un `<Text>` sin contenido mide cero y desaparece. Y las líneas en blanco de la
+ * respuesta no son adorno: son lo que separa un párrafo del siguiente, y lo que
+ * deja aire entre el mensaje que mandaste y lo que contesta el modelo.
+ *
+ * Sin esto, la conversación sale apelmazada: los párrafos pegados unos a otros y
+ * la lista de herramientas encima del texto sin un respiro. Se vio al mirar la
+ * pantalla emulada; ninguna prueba lo cazaba, porque todas comprobaban qué
+ * líneas salen y ninguna cuántas.
  */
+function conCuerpo(texto) {
+    return texto.length > 0 ? texto : " ";
+}
 export function App() {
     const { stdout } = useStdout();
-    // UNA FILA MENOS QUE LA VENTANA, Y ES LA CLAVE
-    //
-    // Ink escribe su arbol y detras un salto de linea. Si el arbol mide justo lo
-    // que la ventana, ese salto la desborda: el terminal desplaza una fila, y como
-    // Ink repinta subiendo el numero de filas que escribio, a partir de ahi borra
-    // una fila que ya no es la suya. En la pantalla alternativa, que no tiene
-    // historial al que recurrir, eso degenera en pantalla en negro.
-    //
-    // Es lo que se publico roto en la 1.6.0: "esta fallando, no sale nada". Las
-    // pruebas no lo cazan porque el terminal de mentira de la libreria no desplaza.
-    const filas = Math.max(6, (stdout?.rows || 24) - 1);
+    const { suspendTerminal } = useApp();
     const [, setRedibujar] = useState(0);
-    const [subido, setSubido] = useState(0);
     const [turno, setTurno] = useState(estadoDelTurno());
     const repintar = () => setRedibujar((n) => n + 1);
-    // Tres fuentes de cambio, todas fuera de React: lo que escribe el agente, lo
-    // que publica el spinner, y el paso de "esperando orden" a "trabajando".
-    useEffect(() => alEscribir(repintar), []);
+    // Tres fuentes de cambio, las tres fuera de React: lo que escribe el agente,
+    // lo que publica el spinner, y el paso de "esperando orden" a "trabajando".
+    useEffect(() => alCambiar(repintar), []);
     useEffect(() => cuandoCambieElPie(repintar), []);
     useEffect(() => alCambiarElTurno((nuevo) => setTurno(nuevo)), []);
-    // Al empezar un turno se vuelve al final: lo interesante es lo que va a salir,
-    // no donde estabas mirando.
+    // El diálogo de permisos y los menús necesitan el teclado para ellos solos, y
+    // se abren con el árbol vivo. Aquí se deja apuntado el préstamo que Ink ya
+    // trae para eso; ver ink/prestamo.ts.
     useEffect(() => {
-        if (turno.esperando)
-            return;
-        setSubido(0);
-    }, [turno.esperando]);
-    const barraDeTrabajo = turno.esperando ? [] : lineasDelPie();
-    const altoBarra = turno.esperando ? 0 : barraDeTrabajo.length;
-    const altoAviso = subido > 0 ? 1 : 0;
-    // Cuando espera orden, el hueco de abajo lo ocupa el prompt y su alto lo
-    // decide él; se le pasa cuánto sitio hay para lo de arriba.
-    const altoDelTexto = Math.max(1, filas - altoBarra - altoAviso - (turno.esperando ? 5 : 0));
-    const visible = ventana(altoDelTexto, subido);
-    const huecos = Math.max(0, altoDelTexto - visible.length);
-    return (_jsxs(Box, { flexDirection: "column", height: filas, children: [Array.from({ length: huecos }, (_, i) => (_jsx(Text, { children: " " }, `hueco-${i}`))), visible.map((linea, i) => (_jsx(Text, { children: linea }, `h-${i}`))), subido > 0 && (_jsx(Text, { dimColor: true, children: `  ↑ ${subido} lineas mas arriba · Av Pag para volver al final` })), turno.esperando ? (_jsx(Prompt, { alEnviar: turno.responder, alCancelar: () => turno.responder("/exit"), cwd: turno.cwd, promptSymbol: turno.promptSymbol, avisos: [], sinHistorial: true, alDesplazar: (direccion) => setSubido((n) => {
-                    // El salto sale del alto SIN el aviso de "estas mirando atras".
-                    // Si se contara, subir y bajar usarian bases distintas -el aviso
-                    // solo existe cuando ya has subido- y bajar no deshacia lo que
-                    // acababas de subir: el scroll derivaba solo.
-                    const base = Math.max(1, filas - altoBarra - 5);
-                    const salto = Math.max(1, Math.floor(base / 2));
-                    return direccion > 0
-                        ? Math.min(tope(base), n + salto)
-                        : Math.max(0, n - salto);
-                }) })) : (barraDeTrabajo.map((linea, i) => _jsx(Text, { children: linea }, `t-${i}`)))] }));
+        registrarPrestamo(suspendTerminal);
+        return () => registrarPrestamo(null);
+    }, [suspendTerminal]);
+    // El teclado tiene que seguir siendo de la caja aunque un diálogo, un menú o
+    // un proceso hijo lo suelten por el camino. Ver ink/teclado.ts: es el fallo
+    // del "no puedo escribir hasta que pulso Enter".
+    useTecladoSiempreNuestro(turno.esperando);
+    const cols = Math.max(20, stdout?.columns || 80);
+    const filas = Math.max(6, stdout?.rows || 24);
+    const permanentes = pendientes();
+    const barra = turno.esperando ? [] : lineasDelPie();
+    // EL TECHO DE LA ZONA DE ABAJO, Y POR QUÉ SE MIDE TAN DE CERCA
+    //
+    // En Windows basta con que el bloque dinámico MIDA lo que la ventana —no que
+    // se pase, que lo iguale— para que Ink cambie de repintado por diferencias a
+    // `clearTerminal` + reimprimir toda la conversación acumulada, en cada
+    // fotograma (ink.js:100-102). Con el spinner a 30 por segundo eso es la
+    // pantalla entera parpadeando y el coste creciendo con la sesión.
+    //
+    // Así que la zona de abajo se queda SIEMPRE por debajo de las filas de la
+    // ventana. Una fila de margen, y quien se pasa es la cola, que se recorta.
+    const techo = Math.max(1, filas - 1);
+    const sitioParaLaCola = Math.max(0, techo - (turno.esperando ? ALTO_DE_LA_CAJA : barra.length));
+    const cola = recortarCola(colgando(), cols, sitioParaLaCola);
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Static, { items: permanentes, children: (linea) => _jsx(Text, { children: conCuerpo(linea.texto) }, linea.id) }), _jsxs(Box, { flexDirection: "column", children: [cola.map((linea, i) => (_jsx(Text, { children: conCuerpo(linea) }, `cola-${i}`))), turno.esperando ? (_jsx(Prompt, { alEnviar: turno.responder, alCancelar: () => turno.responder("/exit"), cwd: turno.cwd, promptSymbol: turno.promptSymbol, avisos: [], 
+                        // NO SE DESMONTA EL ÁRBOL AL ENVIAR
+                        //
+                        // El prompt nació montándose y desmontándose en cada vuelta, y para
+                        // eso llamaba a `exit()` de Ink al enviar. Dentro del árbol único ese
+                        // `exit()` no cierra un prompt: cierra la aplicación ENTERA.
+                        //
+                        // Es el fallo que se publicó como "escribo y se cierra": la primera
+                        // vez que pulsabas Enter el árbol moría, ya no quedaba nadie
+                        // pintando, y la promesa que esperaba la orden no se resolvía jamás.
+                        cerrarAlEnviar: false, alto: Math.max(3, techo - cola.length) })) : (barra.map((linea, i) => _jsx(Text, { children: conCuerpo(linea) }, `t-${i}`)))] })] }));
 }

package/dist/ui/ink/Prompt.d.ts

@@ -39,12 +39,22 @@ export interface PromptProps {
     /** Mensajes que llegaron tarde y hay que dejar por encima del marco. */
     avisos: string[];
     /**
-     * El historial lo pinta otro (el arbol de App). Aqui solo la barra.
+     * ¿Al enviar hay que cerrar el árbol de Ink?
      *
-     * Sin esto se pintaria dos veces: una desde App y otra desde aqui.
+     * Sí cuando el prompt ES el árbol —se monta para pedir una orden y se
+     * desmonta al recibirla— y NO cuando vive dentro del árbol único de App: allí
+     * `exit()` no cierra el prompt, cierra la aplicación entera y deja la promesa
+     * de la orden colgada para siempre. Ese fue el "escribo y se cierra".
      */
-    sinHistorial?: boolean;
-    /** Re Pag / Av Pag: +1 sube, -1 baja. El salto lo decide quien recibe. */
-    alDesplazar?: (direccion: number) => void;
+    cerrarAlEnviar?: boolean;
+    /**
+     * Filas de las que puede disponer el marco.
+     *
+     * App se lo dice porque ahí arriba hay más cosas —el trozo de línea que el
+     * modelo está escribiendo— y el bloque de abajo entero tiene que quedarse por
+     * debajo del alto de la ventana. Sin esto, el marco se mide contra la ventana
+     * como si estuviera solo.
+     */
+    alto?: number;
 }
-export declare function Prompt({ alEnviar, alCancelar, cwd, promptSymbol, avisos, sinHistorial, alDesplazar, }: PromptProps): React.ReactElement;
+export declare function Prompt({ alEnviar, alCancelar, cwd, promptSymbol, avisos, cerrarAlEnviar, alto, }: PromptProps): React.ReactElement;

package/dist/ui/ink/Prompt.js

@@ -1,15 +1,27 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useEffect, useMemo, useRef, useState } from "react";
+import { useMemo, useRef, useState } from "react";
 import { Box, Text, useApp, useInput, useStdout } from "ink";
 import { buildPromptFrame } from "../marco.js";
 import { cycleMode } from "../modes.js";
 import { aplicarOpcion, archivosDelProyecto, leerHistorial, mencionEnCurso, opcionesDelDesplegable, } from "../entrada.js";
 import { esGrande, guardarPegado, marcaQueTerminaEn } from "../pegados.js";
-import { alEscribir, tope, ventana } from "../historial.js";
-import { enPantallaFija } from "../pantalla.js";
 /** Marca del cursor. Ink esconde el de verdad, así que este se dibuja. */
 const CARET = "█";
-export function Prompt({ alEnviar, alCancelar, cwd, promptSymbol, avisos, sinHistorial = false, alDesplazar, }) {
+/**
+ * UNA LÍNEA VACÍA TIENE QUE OCUPAR SU FILA
+ *
+ * Un `<Text>` sin contenido mide cero y desaparece. Y el marco empieza con dos
+ * líneas en blanco a propósito: es el aire entre la conversación y la caja, que
+ * se pidió expresamente ("pon más espacio ahí para que se vea exacto y chévere",
+ * y después "que sea bien pues").
+ *
+ * Sin esto el aire se lo come Ink y la caja queda pegada a la última frase. No
+ * lo cazaba ninguna prueba: todas miraban QUÉ líneas salen, ninguna CUÁNTAS.
+ */
+function conCuerpo(texto) {
+    return texto.length > 0 ? texto : " ";
+}
+export function Prompt({ alEnviar, alCancelar, cwd, promptSymbol, avisos, cerrarAlEnviar = true, alto, }) {
     const { stdout } = useStdout();
     const { exit } = useApp();
     const [texto, setTexto] = useState("");
@@ -19,18 +31,6 @@ export function Prompt({ alEnviar, alCancelar, cwd, promptSymbol, avisos, sinHis
     const [, setRedibujar] = useState(0);
     const historial = useRef(leerHistorial());
     const [posHistorial, setPosHistorial] = useState(historial.current.length);
-    // Cuanto se ha subido con Re Pag. Cero es el fondo, que es donde se esta
-    // mientras se trabaja. Solo se usa en pantalla fija.
-    const [subido, setSubido] = useState(0);
-    const fija = enPantallaFija();
-    // En pantalla fija el terminal ya no guarda nada: lo que sale lo pintamos
-    // nosotros, asi que hay que repintar en cada escritura del agente. El
-    // historial vive fuera de React y React no puede adivinar que ha crecido.
-    useEffect(() => {
-        if (!fija)
-            return;
-        return alEscribir(() => setRedibujar((n) => n + 1));
-    }, [fija]);
     // Se escanea UNA vez por prompt, no en cada tecla: recorrer el proyecto entero
     // por cada letra se nota en cuanto el proyecto pasa de mediano.
     const archivos = useMemo(() => {
@@ -44,7 +44,9 @@ export function Prompt({ alEnviar, alCancelar, cwd, promptSymbol, avisos, sinHis
     const opciones = opcionesDelDesplegable(texto, cursor, archivos);
     const indice = opciones.length > 0 ? ((elegido % opciones.length) + opciones.length) % opciones.length : 0;
     const cols = Math.max(20, stdout?.columns || 80);
-    const rows = stdout?.rows || 24;
+    // El alto que da App ya viene descontado de lo que hay por encima; sin él, la
+    // ventana entera.
+    const rows = Math.max(6, alto ?? stdout?.rows ?? 24);
     // El cursor se dibuja: Ink esconde el del terminal.
     const conCaret = texto.slice(0, cursor) + CARET + texto.slice(cursor);
     const marco = buildPromptFrame({
@@ -56,51 +58,33 @@ export function Prompt({ alEnviar, alCancelar, cwd, promptSymbol, avisos, sinHis
         items: opciones,
         selectedIndex: indice,
     });
-    // Filas que le quedan a la conversacion una vez puesta la barra. En pantalla
-    // fija es lo que se pinta; en la normal no se usa, que ahi el historial es del
-    // terminal.
-    // Cuando se ha subido, una fila se va en el aviso de que se esta mirando
-    // atras. Sin descontarla, el arbol mide una fila mas que la ventana y el
-    // terminal desplaza: la barra dejaria de estar clavada justo al usar el scroll,
-    // que es para lo que existe este modo.
-    // El alto SIN el aviso de "estas mirando atras". El salto se calcula sobre
-    // esto y no sobre el alto real: el aviso solo existe cuando ya has subido, asi
-    // que contarlo hacia que bajar no deshiciera lo que acababas de subir y el
-    // scroll derivara solo.
-    const baseDelSalto = Math.max(1, rows - marco.lines.length);
-    const altoDelTexto = Math.max(1, baseDelSalto - (subido > 0 ? 1 : 0));
+    // CERRAR EL ARBOL O NO
+    //
+    // Dentro del arbol unico, `exit()` de Ink desmonta la aplicacion entera. Ver
+    // la nota larga en la prop `cerrarAlEnviar`.
+    function cerrar() {
+        if (cerrarAlEnviar)
+            exit();
+    }
     function enviar() {
         const orden = texto.trim();
         if (!orden)
             return;
         alEnviar(orden);
-        exit();
+        cerrar();
     }
     useInput((entrada, tecla) => {
-        // ----------------------------------------------- recorrer lo que salio
+        // RE PAG Y AV PAG NO SE TOCAN, Y ESO ES LO CORRECTO
         //
-        // Solo Re Pag y Av Pag. Las flechas y los caracteres son para escribir:
-        // robarselos aqui dejaria al usuario sin poder teclear.
-        if (tecla.pageUp || tecla.pageDown) {
-            const salto = Math.max(1, Math.floor(baseDelSalto / 2));
-            // Con el arbol de App al mando se le manda la DIRECCION, no el salto:
-            // aqui no se sabe cuanto sitio hay arriba, y calcular el salto en los dos
-            // sitios con alturas distintas hacia que bajar no deshiciera lo que
-            // acababa de subir. Con la direccion, el salto sale de un solo sitio y las
-            // dos teclas son simetricas.
-            if (alDesplazar) {
-                alDesplazar(tecla.pageUp ? 1 : -1);
-                return;
-            }
-            if (fija) {
-                setSubido((n) => tecla.pageUp ? Math.min(tope(baseDelSalto), n + salto) : Math.max(0, n - salto));
-                return;
-            }
-        }
+        // Las llevaba este componente cuando la conversacion vivia en memoria y la
+        // pintabamos nosotros. Ahora la conversacion es del terminal: la rueda del
+        // raton, Re Pag y la barra de scroll de la ventana funcionan solas y mejor
+        // que cualquier cosa que hicieramos aqui. Interceptarlas seria quitarle al
+        // usuario un scroll que ya tiene.
         // ------------------------------------------------------------- salir
         if (tecla.ctrl && entrada === "c") {
             alCancelar();
-            exit();
+            cerrar();
             return;
         }
         // ------------------------------------------- cambiar el modo de permisos
@@ -141,7 +125,7 @@ export function Prompt({ alEnviar, alCancelar, cwd, promptSymbol, avisos, sinHis
                         if (arroba || soloLaBarra)
                             return;
                         alEnviar(aplicado.texto.trim());
-                        exit();
+                        cerrar();
                         return;
                     }
                 }
@@ -231,14 +215,5 @@ export function Prompt({ alEnviar, alCancelar, cwd, promptSymbol, avisos, sinHis
             setElegido(0);
         }
     });
-    if (!fija || sinHistorial) {
-        return (_jsxs(Box, { flexDirection: "column", children: [avisos.map((a, i) => (_jsx(Text, { children: a }, `aviso-${i}`))), marco.lines.map((linea, i) => (_jsx(Text, { children: linea }, i)))] }));
-    }
-    // PANTALLA FIJA: el arbol ocupa la ventana entera y la barra va la ultima, asi
-    // que no puede moverse. Lo de arriba se rellena con huecos cuando hay poca
-    // conversacion; sin eso la barra subiria a media pantalla, que es justo la
-    // queja que este modo viene a resolver.
-    const visible = ventana(altoDelTexto, subido);
-    const huecos = Math.max(0, altoDelTexto - visible.length);
-    return (_jsxs(Box, { flexDirection: "column", height: rows, children: [Array.from({ length: huecos }, (_, i) => (_jsx(Text, { children: " " }, `hueco-${i}`))), visible.map((linea, i) => (_jsx(Text, { children: linea }, `h-${i}`))), subido > 0 && (_jsx(Text, { dimColor: true, children: `  ↑ ${subido} lineas mas arriba · Av Pag para volver al final` })), marco.lines.map((linea, i) => (_jsx(Text, { children: linea }, `b-${i}`)))] }));
+    return (_jsxs(Box, { flexDirection: "column", children: [avisos.map((a, i) => (_jsx(Text, { children: conCuerpo(a) }, `aviso-${i}`))), marco.lines.map((linea, i) => (_jsx(Text, { children: conCuerpo(linea) }, i)))] }));
 }

package/dist/ui/ink/montarApp.d.ts

@@ -1,2 +1,36 @@
 export declare function montarArbol(): void;
+/**
+ * Suelta el árbol.
+ *
+ * `darPorPintado()` ANTES de desmontar, y el orden importa: si el árbol se
+ * vuelve a montar —un diálogo que necesita el teclado para él solo—, el
+ * `<Static>` nuevo empieza su cuenta de cero y reimprimiría la conversación
+ * entera. En la pantalla normal esas líneas siguen ahí, en el terminal; la marca
+ * dice por dónde iba para que el montaje nuevo solo escriba lo que falta.
+ *
+ * `clear()` borra el marco de abajo antes de irse. Sin eso queda una copia
+ * muerta de la barra en mitad del historial, y en la próxima sesión de scroll el
+ * usuario se encuentra dos.
+ */
 export declare function desmontarArbol(): void;
+export declare function hayArbol(): boolean;
+/**
+ * Borra la pantalla de verdad. Es lo que hacen /clear, /cd y Ctrl+L.
+ *
+ * POR QUE NO VALE UN `console.clear()`
+ *
+ * `console.clear()` escribe la secuencia de borrado directa al terminal, y no
+ * pasa por la interceptación de consola: ahí solo van `log`, `error`, `warn` e
+ * `info`. Con el árbol montado eso borra filas que Ink cree suyas, y a partir de
+ * ahí Ink borra y repinta sobre un sitio que ya no existe. Lo que se ve es
+ * basura, o nada.
+ *
+ * Aquí se hace en el orden que no rompe nada: se borra el marco con la cuenta
+ * todavía buena, se suelta el árbol, se limpia la pantalla —y el historial del
+ * terminal con `3J`, que es lo que el usuario espera de un /clear— y se vuelve a
+ * montar de cero.
+ *
+ * Y se vacía la transcripción: si no, el <Static> nuevo tendría por delante toda
+ * la conversación que se acaba de borrar.
+ */
+export declare function limpiarLaPantalla(): void;