chocolatito-code 1.2.0 → 1.3.1

package/dist/ui/comandos.js

@@ -0,0 +1,49 @@
+/**
+ * LOS COMANDOS DE BARRA, EN UN SOLO SITIO
+ *
+ * Vivian dentro de prompt.ts, que es quien los autocompleta. Ahora tambien los
+ * necesita el prompt de sistema, y prompt.ts arrastra readline, el historial en
+ * disco y el escaneo del proyecto: no es algo que deba cargar quien solo quiere
+ * la lista.
+ *
+ * POR QUE LE HACEN FALTA AL MODELO
+ *
+ * Sesion real. El usuario pregunta como ver su consumo y el agente contesta
+ * hablando de "la barra lateral", "la app de escritorio" y "empezar un hilo
+ * nuevo". Ninguna de esas cosas existe aqui: esto es una terminal. El modelo
+ * sabia que se llamaba Chocolatito Code -se lo dice el prompt- pero no sabia
+ * NADA de su propio producto, asi que contestaba con lo que sabe de los chats
+ * web. Y la respuesta correcta era una palabra: /cost.
+ *
+ * Con la lista en un modulo aparte, la que ve el usuario al escribir "/" y la
+ * que se le cuenta al modelo son la misma. Duplicarla habria durado hasta el
+ * primer comando nuevo.
+ *
+ * OJO: esta lista SE MODIFICA EN CALIENTE. index.ts anade /actualizar y
+ * /licencia al arrancar, segun como este instalado el programa. Por eso el
+ * prompt de sistema la lee en cada turno y no una vez al importar.
+ */
+export const SLASH_COMMANDS = [
+    { name: "/mcp", description: "Ver servidores MCP conectados y sus herramientas" },
+    { name: "/undo", description: "Deshacer las últimas modificaciones de archivos de la sesión" },
+    { name: "/export", description: "Exportar bitácora de la sesión a archivo Markdown", args: "[nombre.md]" },
+    { name: "/plan", description: "Alternar Modo Plan (solo lectura e investigación previa)" },
+    { name: "/resume", description: "Reanudar una sesión anterior guardada", args: "[id]" },
+    { name: "/skills", description: "Ver skills disponibles y cómo usarlos" },
+    { name: "/memory", description: "Consultar la memoria persistente transversal (~/.chocolatito/memory/)" },
+    { name: "/effort", description: "Regular potencia del motor (1.0, 1.5, 2.0, 2.5)", args: "[nivel]" },
+    { 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: "/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" },
+    { name: "/clear", description: "Limpiar historial y reiniciar contexto" },
+    { name: "/init", description: "Crear archivo de directivas CHOCOLATITO.md" },
+    { name: "/help", description: "Mostrar guía completa de comandos y ayuda" },
+    { name: "/exit", description: "Cerrar sesión de Chocolatito Code" },
+];
+/** La lista tal y como se le cuenta al modelo. Una linea por comando. */
+export function listaParaElModelo() {
+    return SLASH_COMMANDS.map((c) => `- ${c.name}${c.args ? ` ${c.args}` : ""}: ${c.description}`).join("\n");
+}

package/dist/ui/informeDeUso.d.ts

@@ -0,0 +1,17 @@
+import { QuotaStatus } from "../config/quota.js";
+export interface DatosDeSesion {
+    motor: string;
+    tokensEntrada: number;
+    tokensSalida: number;
+    tokensEnCache: number;
+    /** Coste de la sesion, ya formateado. Solo se usa con clave propia. */
+    costeFormateado: string;
+}
+/**
+ * Arma el informe. Puro y exportado para poder comprobarlo: lo que importa aqui
+ * es lo que NO sale, y eso a ojo en un terminal no se revisa.
+ *
+ * `vaciaEn` es cuando la ventana corta vuelve a cero (quota.ventanaVaciaEn).
+ * `null` cuando no hay nada dentro de ella.
+ */
+export declare function construirInformeDeUso(estado: QuotaStatus, sesion: DatosDeSesion, vaciaEn: Date | null, ahora?: number, gestionado?: boolean): string;

package/dist/ui/informeDeUso.js

@@ -0,0 +1,81 @@
+import chalk from "chalk";
+import { faltaPara, isManagedMode } from "../config/quota.js";
+/**
+ * EL INFORME DE /cost
+ *
+ * QUE ENSENABA ANTES
+ *
+ *     • Tokens entrada:  11,553 ($0.00508 USD)
+ *     • Tokens salida:   332 ($0.00044 USD)
+ *     • Inversion total: $0.0055 USD
+ *
+ * Tarifas de API en la cara de alguien que paga una suscripcion plana. Dos
+ * problemas, y el segundo es el importante.
+ *
+ * **No le sirve.** Su factura es fija; que un turno costara medio centimo no le
+ * dice nada que pueda usar. Lo que necesita saber es cuanto le queda antes de
+ * que el programa le pare, y eso son las ventanas de uso.
+ *
+ * **Y ensena el margen.** El coste de API por cuenta es informacion del negocio
+ * de quien vende esto, no del cliente. Puesto en pantalla, cualquiera saca la
+ * cuenta de lo que se gana con el.
+ *
+ * CON CLAVE PROPIA ES AL REVES
+ *
+ * Ahi el dinero es del usuario, se lo cobra su proveedor y no hay ventana que
+ * ensenar porque no se le limita nada (ver la nota de quota.ts). Ocultarle el
+ * gasto seria esconderle SU factura. Asi que ese caso mantiene los dolares.
+ */
+const ANCHO_BARRA = 20;
+/** Barra de progreso en texto. Se ve el nivel de un vistazo, sin leer el numero. */
+function barra(porcentaje) {
+    const llenas = Math.max(0, Math.min(ANCHO_BARRA, Math.round((porcentaje / 100) * ANCHO_BARRA)));
+    // Tres colores y no un degradado: lo unico que hay que distinguir es "vas
+    // bien", "ojo" y "estas a punto de quedarte sin".
+    const color = porcentaje >= 90 ? "#EF4444" : porcentaje >= 70 ? "#FFA500" : "#22C55E";
+    return chalk.hex(color)("█".repeat(llenas)) + chalk.gray("░".repeat(ANCHO_BARRA - llenas));
+}
+function porcentaje(gastado, tope) {
+    if (!(tope > 0))
+        return 0;
+    return Math.min(100, Math.round((gastado / tope) * 100));
+}
+/**
+ * Arma el informe. Puro y exportado para poder comprobarlo: lo que importa aqui
+ * es lo que NO sale, y eso a ojo en un terminal no se revisa.
+ *
+ * `vaciaEn` es cuando la ventana corta vuelve a cero (quota.ventanaVaciaEn).
+ * `null` cuando no hay nada dentro de ella.
+ */
+export function construirInformeDeUso(estado, sesion, vaciaEn, ahora = Date.now(), gestionado = isManagedMode()) {
+    const num = (n) => n.toLocaleString("es-ES");
+    const lineas = [];
+    lineas.push(chalk.bold.hex("#A855F7")("\n📊 CONSUMO DE TU CUENTA"));
+    lineas.push("");
+    if (gestionado) {
+        const pctVentana = porcentaje(estado.spentWindowUsd, estado.config.windowBudgetUsd);
+        const pctSemana = porcentaje(estado.spentWeekUsd, estado.config.weeklyBudgetUsd);
+        // La de 5 h va primera: es la que corta antes y la que sorprende.
+        const cuando = vaciaEn
+            ? chalk.gray(`  vuelve a cero en ${faltaPara(vaciaEn, ahora)}`)
+            : chalk.gray("  sin uso reciente");
+        lineas.push(`  ${chalk.gray(`Ventana de ${estado.config.windowHours} h`.padEnd(16))}${barra(pctVentana)} ` +
+            `${chalk.bold.white(`${pctVentana}%`.padStart(4))}${cuando}`);
+        lineas.push(`  ${chalk.gray("Últimos 7 días".padEnd(16))}${barra(pctSemana)} ` +
+            `${chalk.bold.white(`${pctSemana}%`.padStart(4))}`);
+    }
+    else {
+        // Clave propia: no hay cuenta que gestionar, hay una factura que es suya.
+        lineas.push(`  ${chalk.gray("Gasto de API".padEnd(16))}${chalk.bold.green(sesion.costeFormateado)}`);
+        lineas.push(`  ${chalk.gray("".padEnd(16))}${chalk.gray("con tu propia clave: esto te lo cobra tu proveedor")}`);
+    }
+    lineas.push("");
+    lineas.push(`  ${chalk.gray("Esta sesión".padEnd(16))}${chalk.white(num(sesion.tokensEntrada))} de entrada · ` +
+        `${chalk.white(num(sesion.tokensSalida))} de salida`);
+    if (sesion.tokensEnCache > 0) {
+        lineas.push(`  ${chalk.gray("".padEnd(16))}${chalk.gray(`${num(sesion.tokensEnCache)} reaprovechados de la caché`)}`);
+    }
+    lineas.push(`  ${chalk.gray("Motor".padEnd(16))}${chalk.white(sesion.motor)}`);
+    lineas.push("");
+    return lineas.join("\n");
+}

package/dist/ui/interrupt.d.ts

@@ -3,6 +3,14 @@ export declare function tomarTecladoParaPrompt(): void;
 /** Lo llama el prompt al cerrarse, para que el siguiente turno pueda restaurar. */
 export declare function devolverTecladoDelPrompt(): void;
 export declare function releaseKeyboard(): void;
+/**
+ * Devuelve el teclado a quien lo tenia antes del dialogo.
+ *
+ * NO se llama a start(): eso crearia un AbortController nuevo, y la peticion en
+ * curso se quedaria escuchando al viejo. Esc dejaria de cancelar justo lo que el
+ * usuario quiere cancelar.
+ */
+export declare function retomarTeclado(): void;
 export declare class InterruptWatcher {
     private controller;
     private wasRaw;
@@ -13,6 +21,8 @@ export declare class InterruptWatcher {
     get interrupted(): boolean;
     get signal(): AbortSignal | undefined;
     start(): AbortSignal | undefined;
+    /** Vuelve a escuchar despues de un dialogo, sin tocar la senal de aborto. */
+    reanudar(): void;
     private abort;
     stop(): void;
 }

package/dist/ui/interrupt.js

@@ -3,6 +3,7 @@ import process from "node:process";
 import chalk from "chalk";
 import { cycleMode, modeAnnouncement } from "./modes.js";
 import { pushTyped, backspaceTyped, commitTyped } from "./typeAhead.js";
+import { reafirmarModoCrudo } from "./keyboardGuard.js";
 import { dibujar } from "./salida.js";
 /**
  * Interrupcion con Esc mientras el agente trabaja.
@@ -69,11 +70,39 @@ export function tomarTecladoParaPrompt() {
 export function devolverTecladoDelPrompt() {
     promptConElTeclado = false;
 }
+/**
+ * Vigilantes que se soltaron para ensenar un dialogo, y que hay que devolver.
+ *
+ * El dialogo de permisos suelta el teclado antes de dibujarse -si no, el
+ * vigilante se come las teclas y la caja no responde-, pero hasta ahora nadie lo
+ * devolvia despues. El resto del turno se quedaba SIN vigilante: en modo cocido
+ * el terminal hacia el eco por su cuenta, Esc dejaba de cancelar, y lo que el
+ * usuario escribiera no se encolaba.
+ *
+ * Se veia asi, y el usuario dio con la pista sin saberlo: "a veces se queda
+ * trabado y no se puede escribir, pero con darle Enter vuelve a la normalidad".
+ * Claro: en modo cocido el terminal guarda la linea y Enter la suelta de golpe.
+ */
+let soltados = [];
 export function releaseKeyboard() {
-    for (const w of Array.from(activos)) {
+    soltados = Array.from(activos);
+    for (const w of soltados) {
         w.stop();
     }
 }
+/**
+ * Devuelve el teclado a quien lo tenia antes del dialogo.
+ *
+ * NO se llama a start(): eso crearia un AbortController nuevo, y la peticion en
+ * curso se quedaria escuchando al viejo. Esc dejaria de cancelar justo lo que el
+ * usuario quiere cancelar.
+ */
+export function retomarTeclado() {
+    const devolver = soltados;
+    soltados = [];
+    for (const w of devolver)
+        w.reanudar();
+}
 export class InterruptWatcher {
     controller = null;
     wasRaw = false;
@@ -164,6 +193,23 @@ export class InterruptWatcher {
         activos.add(this);
         return this.controller.signal;
     }
+    /** Vuelve a escuchar despues de un dialogo, sin tocar la senal de aborto. */
+    reanudar() {
+        if (this.listening || !this.onKey)
+            return;
+        if (!process.stdin.isTTY || !process.stdin.setRawMode)
+            return;
+        readline.emitKeypressEvents(process.stdin);
+        if (activos.size === 0)
+            modoCrudoOriginal = process.stdin.isRaw || false;
+        // Reafirmar y no solo poner: el readline del dialogo deja la consola en modo
+        // cocido, y un setRawMode(true) a secas puede ser un no-op.
+        reafirmarModoCrudo(process.stdin);
+        process.stdin.resume();
+        process.stdin.on("keypress", this.onKey);
+        this.listening = true;
+        activos.add(this);
+    }
     abort() {
         if (this.aborted)
             return;
@@ -176,7 +222,9 @@ export class InterruptWatcher {
     stop() {
         if (this.onKey) {
             process.stdin.removeListener("keypress", this.onKey);
-            this.onKey = null;
+            // El manejador NO se tira: reanudar() lo vuelve a enganchar tal cual, con
+            // su AbortController intacto. Rehacerlo desde start() romperia el Esc de
+            // la peticion que ya esta en vuelo.
         }
         const escuchaba = this.listening;
         this.listening = false;

package/dist/ui/marco.d.ts

@@ -0,0 +1,35 @@
+export interface DropdownItem {
+    type: "command" | "file";
+    label: string;
+    secondary?: string;
+    insertText: string;
+}
+export interface PromptFrameOptions {
+    cols: number;
+    /** Alto de la ventana; sirve para no dibujar un marco que no quepa. */
+    rows?: number;
+    promptSymbol?: string;
+    input?: string;
+    cursorIndex?: number;
+    items?: DropdownItem[];
+    selectedIndex?: number;
+}
+export interface PromptFrame {
+    /** Lineas LOGICAS. Cualquiera puede ocupar mas de una fila fisica. */
+    lines: string[];
+    /** Filas de pantalla que ocupara el marco entero con este ancho. */
+    totalRows: number;
+    /** Fila fisica del cursor, con 0 en la primera fila del marco. */
+    cursorRow: number;
+    cursorCol: number;
+    /** Primer elemento del desplegable que se muestra (ventana deslizante). */
+    dropdownOffset: number;
+}
+/**
+ * Arma el marco del prompt y dice exactamente donde queda el cursor.
+ *
+ * Va aparte de render() por dos razones: se puede probar sin terminal, y la
+ * aritmetica de filas se hace UNA vez sobre las mismas lineas que se pintan, en
+ * lugar de estimarse por otro lado y descuadrarse.
+ */
+export declare function buildPromptFrame(opts: PromptFrameOptions): PromptFrame;

package/dist/ui/marco.js

@@ -0,0 +1,161 @@
+import chalk from "chalk";
+import { describeMode, getMode } from "./modes.js";
+/**
+ * EL MARCO DE LA BARRA, EN UN SOLO SITIO
+ *
+ * Vivia dentro de prompt.ts. Ahora lo necesitan dos: el prompt cuando espera una
+ * orden, y el spinner mientras el agente trabaja.
+ *
+ * POR QUE COMPARTIDO Y NO COPIADO
+ *
+ * Habia DOS barras distintas turnandose. Al esperar salia el marco entero
+ * -barra, entrada, barra, linea de ayuda-; al trabajar, una version recortada
+ * con otro texto. Se parecian lo justo para que el cambio de una a otra se viera
+ * como un salto, y el usuario lo dijo asi: "aun no es fija... debe ser fija y
+ * por debajo deben pasar los otros mensajes".
+ *
+ * Con el constructor compartido no pueden divergir: si alguien toca el marco, lo
+ * toca en los dos estados a la vez. Copiarlo habria durado hasta el primer
+ * retoque.
+ *
+ * Va aparte tambien por peso: prompt.ts arrastra readline, el historial en disco
+ * y el escaneo del proyecto, y el spinner no tiene por que cargar nada de eso.
+ */
+function stripAnsi(str) {
+    return str.replace(/\x1b\[[0-9;]*m/g, "");
+}
+const PLACEHOLDER = "Escribe una instrucción, '@' para archivos o '/' para comandos...";
+/**
+ * Filas FISICAS que ocupa una linea del marco.
+ *
+ * Aqui estaba el fallo de verdad: el repintado contaba elementos del array del
+ * marco mientras el terminal cuenta filas de pantalla. Cualquier linea que no
+ * cupiera en el ancho se partia en dos filas, el cursor subia una fila de menos
+ * y el marco entero se iba bajando, dejando una barra huerfana por pulsacion.
+ * La entrada ademas puede llevar saltos de linea dentro (continuacion con "\").
+ */
+function physicalRows(line, cols) {
+    return stripAnsi(line)
+        .split("\n")
+        .reduce((n, seg) => n + Math.max(1, Math.ceil(seg.length / cols)), 0);
+}
+/** Recorta a `width` columnas visibles. Texto sin pintar: aqui no hay que cerrar colores. */
+function truncatePlain(text, width) {
+    if (width <= 0)
+        return "";
+    if (text.length <= width)
+        return text;
+    return width <= 1 ? text.slice(0, width) : `${text.slice(0, width - 1)}…`;
+}
+/**
+ * Arma el marco del prompt y dice exactamente donde queda el cursor.
+ *
+ * Va aparte de render() por dos razones: se puede probar sin terminal, y la
+ * aritmetica de filas se hace UNA vez sobre las mismas lineas que se pintan, en
+ * lugar de estimarse por otro lado y descuadrarse.
+ */
+export function buildPromptFrame(opts) {
+    const cols = Math.max(20, opts.cols || 80);
+    const viewportRows = Math.max(6, opts.rows || 24);
+    const promptSymbol = opts.promptSymbol ?? "❯";
+    const input = opts.input ?? "";
+    const cursorIndex = Math.max(0, Math.min(opts.cursorIndex ?? input.length, input.length));
+    const items = opts.items ?? [];
+    const selectedIndex = items.length > 0 ? (((opts.selectedIndex ?? 0) % items.length) + items.length) % items.length : 0;
+    const isPlan = promptSymbol.includes("plan");
+    const symbolStr = isPlan
+        ? `${chalk.cyan.bold("plan ❯")} `
+        : `${chalk.bold.hex("#D97757")("❯")} `;
+    const symbolWidth = isPlan ? 7 : 2;
+    const bar = chalk.gray("─".repeat(cols));
+    // 1. Linea de entrada. Lo que el usuario escribe NO se recorta nunca: se deja
+    // que el terminal la parta y despues se cuentan las filas que ocupa.
+    let formattedInput;
+    if (input.length === 0) {
+        // La pista si se recorta: en una ventana estrecha ocupaba una segunda fila
+        // para no decir nada que el usuario no sepa ya.
+        formattedInput = chalk.gray(truncatePlain(PLACEHOLDER, cols - symbolWidth));
+    }
+    else if (input.startsWith("/")) {
+        const parts = input.split(" ");
+        const cmdPart = chalk.bold.hex("#A855F7")(parts[0]);
+        const restPart = parts.slice(1).join(" ");
+        formattedInput = restPart ? `${cmdPart} ${chalk.white(restPart)}` : cmdPart;
+    }
+    else {
+        formattedInput = input.replace(/(@[^\s]+)/g, (m) => chalk.bold.hex("#D97757")(m));
+    }
+    const inputLine = symbolStr + formattedInput;
+    const inputRows = physicalRows(inputLine, cols);
+    // 2. Desplegable. Un marco mas alto que la ventana obliga al terminal a
+    // desplazar el contenido, y a partir de ahi el repintado ya no sabe donde
+    // esta su primera fila: se muestra solo una ventana alrededor del elegido.
+    const room = Math.max(1, viewportRows - 1 - (1 + inputRows + 1 + 1));
+    const shown = Math.min(items.length, room);
+    const dropdownOffset = shown > 0 && items.length > shown
+        ? Math.min(Math.max(0, selectedIndex - Math.floor(shown / 2)), items.length - shown)
+        : 0;
+    const dropdownLines = [];
+    for (let i = dropdownOffset; i < dropdownOffset + shown; i++) {
+        const item = items[i];
+        const isSelected = i === selectedIndex;
+        const colorHex = item.type === "file" ? "#D97757" : "#A855F7";
+        const pointer = isSelected ? chalk.bold.hex(colorHex)(" ❯ ") : chalk.gray("   ");
+        // El puntero se lleva 3 columnas fijas. De lo que queda manda la etiqueta:
+        // la descripcion es lo primero que se cae, porque una ruta a medias no se
+        // puede ni leer ni elegir.
+        const free = cols - 3;
+        const label = truncatePlain(item.label, free);
+        const roomForDesc = free - label.length - 2;
+        const secondary = item.secondary && roomForDesc >= 8 ? truncatePlain(item.secondary, roomForDesc) : "";
+        const paintedLabel = isSelected ? chalk.bold.white(label) : chalk.hex(colorHex)(label);
+        const paintedDesc = secondary
+            ? isSelected
+                ? chalk.whiteBright(`  ${secondary}`)
+                : chalk.gray(`  ${secondary}`)
+            : "";
+        dropdownLines.push(`${pointer}${paintedLabel}${paintedDesc}`);
+    }
+    // 3. Pie de estado. El relleno se calculaba con Math.max(1, ...): cuando no
+    // cabia, en vez de recortarse se quedaba con un espacio y la linea salia MAS
+    // ancha que el terminal. En una consola de 80 columnas el pie media 87 y se
+    // partia en dos filas desde el primer dibujado.
+    const modeLook = describeMode(getMode());
+    const hintPlain = "? /help para atajos · shift+tab modo · esc cancelar";
+    const modePlain = `⇥ modo ${modeLook.label}`;
+    const enginePlain = "· Espectro 1.0 (Ágil)";
+    const hint = chalk.gray(hintPlain);
+    const modeTag = chalk.hex(modeLook.color)(modePlain);
+    const engine = chalk.gray(enginePlain);
+    let footerLine;
+    if (hintPlain.length + 1 + modePlain.length + 1 + enginePlain.length <= cols) {
+        const padLen = cols - hintPlain.length - modePlain.length - 1 - enginePlain.length;
+        footerLine = `${hint}${" ".repeat(padLen)}${modeTag} ${engine}`;
+    }
+    else if (modePlain.length + 1 + enginePlain.length <= cols) {
+        // Los atajos son opcionales; el modo activo no, que es lo que decide si te
+        // van a preguntar antes de tocar tus archivos.
+        footerLine = `${" ".repeat(cols - modePlain.length - 1 - enginePlain.length)}${modeTag} ${engine}`;
+    }
+    else if (modePlain.length <= cols) {
+        footerLine = `${" ".repeat(cols - modePlain.length)}${modeTag}`;
+    }
+    else {
+        footerLine = chalk.hex(modeLook.color)(truncatePlain(modePlain, cols));
+    }
+    const lines = [bar, inputLine, ...dropdownLines, bar, footerLine];
+    // 4. Donde queda el cursor, en filas fisicas. Antes se hacia cursorCol =
+    // total % cols: aplicaba el modulo pero nunca sumaba la fila, asi que en
+    // cuanto la entrada se partia el acento se iba a escribir a otra linea.
+    const typed = input.length === 0 ? "" : input.slice(0, cursorIndex);
+    const segments = typed.split("\n");
+    let cursorRow = physicalRows(bar, cols);
+    for (let i = 0; i < segments.length - 1; i++) {
+        cursorRow += Math.max(1, Math.ceil(((i === 0 ? symbolWidth : 0) + segments[i].length) / cols));
+    }
+    const lastSegWidth = (segments.length === 1 ? symbolWidth : 0) + segments[segments.length - 1].length;
+    cursorRow += Math.floor(lastSegWidth / cols);
+    const cursorCol = lastSegWidth % cols;
+    const totalRows = lines.reduce((n, l) => n + physicalRows(l, cols), 0);
+    return { lines, totalRows, cursorRow, cursorCol, dropdownOffset };
+}

package/dist/ui/pieFijo.d.ts

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