chocolatito-code 1.6.6 → 1.6.8

package/dist/tools/runner.js

@@ -25,6 +25,7 @@ import { globalUndoManager } from "../agent/undoManager.js";
 import { validateFileSyntax } from "../agent/syntaxValidator.js";
 import { fileTracker } from "../agent/fileTracker.js";
 import { mcpManager } from "../mcp/manager.js";
+import { taskManager } from "./backgroundTask.js";
 import fs from "node:fs";
 import path from "node:path";
 /**
@@ -82,10 +83,12 @@ export async function executeToolCall(name, args, cwd = process.cwd(), apiKey, m
                 break;
             }
             case "save_memory":
-                rawResult = memoryManager.saveMemory(args.topic, args.fact);
+                memoryManager.setCwd(cwd);
+                rawResult = memoryManager.saveMemory(args.topic, args.fact, args.scope);
                 break;
             case "read_memory":
-                rawResult = memoryManager.readMemory(args.topic);
+                memoryManager.setCwd(cwd);
+                rawResult = memoryManager.readMemory(args.topic, args.scope);
                 break;
             case "spawn_agent": {
                 if (!apiKey) {
@@ -201,6 +204,37 @@ export async function executeToolCall(name, args, cwd = process.cwd(), apiKey, m
             case "run_command":
                 rawResult = await runCommand(args.command, cwd, args.timeout);
                 break;
+            case "start_background_task": {
+                const res = await taskManager.startTask(args.command, args.cwd || cwd, args.description);
+                rawResult = `Tarea iniciada en segundo plano:\n- ID: ${res.taskId}\n- PID: ${res.pid}\n- Estado: ${res.status}\n- Log: ${res.logPath}`;
+                break;
+            }
+            case "read_task_output": {
+                const res = taskManager.readTaskOutput(args.taskId, args.lines, args.offset);
+                if (res.status === "not_found") {
+                    rawResult = res.output;
+                }
+                else {
+                    rawResult = `[Tarea ${res.taskId}] Estado: ${res.status} (Exit Code: ${res.exitCode !== null ? res.exitCode : "N/A"})\nTotal de líneas: ${res.totalLines}\n--- Salida ---\n${res.output || "(sin salida aún)"}`;
+                }
+                break;
+            }
+            case "list_background_tasks": {
+                const tasks = taskManager.listTasks();
+                if (tasks.length === 0) {
+                    rawResult = "No hay tareas en segundo plano registradas.";
+                }
+                else {
+                    const lines = tasks.map((t) => `- [${t.taskId}] PID ${t.pid} | ${t.status.toUpperCase()} | Ejecución: ${t.runtimeSeconds}s | Comando: "${t.command}"${t.description ? ` (${t.description})` : ""}${t.exitCode !== null ? ` | Exit code: ${t.exitCode}` : ""}`);
+                    rawResult = `Tareas en segundo plano (${tasks.length}):\n${lines.join("\n")}`;
+                }
+                break;
+            }
+            case "stop_background_task": {
+                const res = await taskManager.stopTask(args.taskId, args.force);
+                rawResult = res.message;
+                break;
+            }
             case "list_dir":
                 rawResult = await listDir(args.dirPath || ".", cwd);
                 break;

package/dist/tools/safety.d.ts

@@ -7,6 +7,7 @@
  * estado. En cambio dos escrituras seguidas SI pueden pisarse, y el orden
  * importa, asi que esas van una detras de otra.
  */
+export declare const READ_ONLY_TOOLS: Set<string>;
 export declare function isReadOnly(toolName: string): boolean;
 /**
  * Un lote solo se paraleliza si TODAS sus llamadas son de solo lectura y hay

package/dist/tools/safety.js

@@ -18,7 +18,10 @@ const READ_ONLY = new Set([
     "web_search",
     "read_memory",
     "use_skill",
+    "read_task_output",
+    "list_background_tasks",
 ]);
+export const READ_ONLY_TOOLS = READ_ONLY;
 export function isReadOnly(toolName) {
     return READ_ONLY.has(toolName);
 }

package/dist/tools/todoTool.d.ts

@@ -5,4 +5,6 @@ export interface TaskItem {
 }
 export declare function setSessionTasks(tasks: TaskItem[]): string;
 export declare function getSessionTasks(): TaskItem[];
+export declare function renderTaskWidget(tasks?: TaskItem[]): string | null;
+export declare function sincronizarTareasConPie(tasks?: TaskItem[]): void;
 export declare function renderTaskList(tasks: TaskItem[]): string;

package/dist/tools/todoTool.js

@@ -1,12 +1,41 @@
 import chalk from "chalk";
+import { fijarSeccion, quitarSeccion } from "../ui/pieFijo.js";
 let sessionTasks = [];
 export function setSessionTasks(tasks) {
     sessionTasks = tasks;
+    sincronizarTareasConPie(sessionTasks);
     return renderTaskList(sessionTasks);
 }
 export function getSessionTasks() {
     return sessionTasks;
 }
+export function renderTaskWidget(tasks) {
+    const list = tasks !== undefined ? tasks : sessionTasks;
+    if (!list || list.length === 0)
+        return null;
+    const total = list.length;
+    const completed = list.filter((t) => t.status === "completed").length;
+    const inProgress = list.find((t) => t.status === "in_progress");
+    return (chalk.hex("#D97757")("⎿") +
+        " " +
+        chalk.green("✔") +
+        ` ${completed}/${total} tareas` +
+        (inProgress
+            ? chalk.gray(" · ") + chalk.hex("#D97757")("En curso: ") + chalk.bold.white(inProgress.text)
+            : completed === total
+                ? chalk.green(" · Completado")
+                : ""));
+}
+export function sincronizarTareasConPie(tasks) {
+    const list = tasks !== undefined ? tasks : sessionTasks;
+    const widget = renderTaskWidget(list);
+    if (widget) {
+        fijarSeccion("tareas", [widget]);
+    }
+    else {
+        quitarSeccion("tareas");
+    }
+}
 export function renderTaskList(tasks) {
     if (tasks.length === 0)
         return "No hay tareas registradas.";

package/dist/tools/toolDefsComputer.js

@@ -111,6 +111,8 @@ export const COMPUTER_USE_TOOL = {
                         "scroll",
                         "type",
                         "key",
+                        "hotkey",
+                        "press",
                         "wait",
                         "wait_change",
                         "cursor_position",
@@ -183,11 +185,14 @@ export const CHROME_TOOL = {
                         "status", "tabs", "open", "select_tab", "navigate", "snapshot",
                         "click", "type", "press", "get_text", "eval", "wait_for",
                         "screenshot", "notice", "close_tab", "done",
+                        "console_logs", "network_errors",
                     ],
                     description: "status: comprueba que la extension esta conectada. tabs: lista las pestanas del usuario. " +
                         "open: abre una pestana nueva SIN quitarle la pantalla al usuario. select_tab: elige una ya abierta. " +
                         "snapshot: LEE la pagina y numera los elementos. click/type: actuan sobre un ref. " +
                         "wait_for: espera un texto o unos ms. screenshot: captura la pestana aunque no este visible y la describe. " +
+                        "console_logs: obtiene errores y advertencias de consola y excepciones no controladas de la pagina. " +
+                        "network_errors: obtiene peticiones de red HTTP fallidas (4xx/5xx o errores de conexion). " +
                         "notice: cambia el texto del aviso flotante. close_tab: cierra una pestaña que abriste. done: cierra el trabajo y quita el aviso.",
                 },
                 url: { type: "string", description: "URL para open o navigate." },
@@ -212,6 +217,10 @@ export const CHROME_TOOL = {
                 analyze: { type: "boolean", description: "false para no gastar tokens de vision." },
                 outputPath: { type: "string", description: "Ruta donde guardar la captura." },
                 note: { type: "string", description: "Texto inicial del aviso flotante al abrir la pestana." },
+                clear: {
+                    type: "boolean",
+                    description: "true para limpiar el buffer tras consultar (en console_logs o network_errors).",
+                },
             },
             required: ["action"],
         },

package/dist/tools/win/hostScript.js

@@ -283,9 +283,14 @@ public static class Choco
         double scale = 1.0;
         int longEdge = Math.Max(w, h);
         if (maxLongEdge > 0 && longEdge > maxLongEdge) scale = (double)maxLongEdge / (double)longEdge;
+        ImageFormat fmt = ImageFormat.Png;
+        if (path.EndsWith(".jpg", StringComparison.OrdinalIgnoreCase) || path.EndsWith(".jpeg", StringComparison.OrdinalIgnoreCase))
+        {
+            fmt = ImageFormat.Jpeg;
+        }
         if (scale >= 0.999)
         {
-            bmp.Save(path, ImageFormat.Png);
+            bmp.Save(path, fmt);
             return 1.0;
         }
         int nw = (int)Math.Round(w * scale), nh = (int)Math.Round(h * scale);
@@ -294,7 +299,7 @@ public static class Choco
         {
             g.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.HighQualityBicubic;
             g.DrawImage(bmp, 0, 0, nw, nh);
-            dst.Save(path, ImageFormat.Png);
+            dst.Save(path, fmt);
         }
         return scale;
     }

package/dist/ui/comandos.js

@@ -35,6 +35,8 @@ export const SLASH_COMMANDS = [
     { name: "/goal", description: "Ejecutar meta compleja autónoma con auto-corrección", args: "<meta>" },
     { name: "/compact", description: "Comprimir contexto y optimizar memoria de la sesión" },
     { name: "/diff", description: "Ver diferencias de código (Git diff) del proyecto" },
+    { name: "/audit", description: "Auditar git diff en busca de secretos, logs residuales y sugerir commit", args: "[review]" },
+    { name: "/review", description: "Revisar cambios pendientes de git (alias de /audit)" },
     { name: "/commit", description: "Crear un commit en Git con mensaje semántico", args: "<mensaje>" },
     { name: "/cd", description: "Cambiar el directorio de trabajo activo", args: "<ruta>" },
     { name: "/uso", description: "Ver cuánto llevas consumido de tu cuenta" },

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;