chocolatito-code 1.2.0 → 1.3.1

package/dist/ui/pieFijo.js

@@ -0,0 +1,309 @@
+import process from "node:process";
+import { dibujar } from "./salida.js";
+/**
+ * EL PIE QUE NO SE VA CON EL SCROLL
+ *
+ * EL PROBLEMA
+ *
+ * El spinner y la linea de razonamiento se pintaban donde estuviera el cursor:
+ *
+ *     process.stdout.write(`\r\x1b[2K${glyph} ${verb} (${segundos}s)`);
+ *
+ * Eso escribe en la fila actual y ahi se queda. En cuanto llega la respuesta,
+ * cada linea nueva empuja el contenido hacia arriba y se lleva el spinner con
+ * ella. El usuario lo describio mejor que ninguna documentacion: "la nubecita y
+ * el rayito suben con lo que me respondes". Y lo mismo la barra de escribir.
+ *
+ * El resultado es que mientras el modelo habla no hay NADA fijo en pantalla: ni
+ * cuanto lleva, ni cuantos tokens, ni donde escribir para encolar algo. Todo
+ * queda enterrado unas pantallas mas arriba.
+ *
+ * LA IDEA
+ *
+ * Un terminal no tiene "zonas". Se puede pedir una con la region de scroll
+ * (DECSTBM), pero lo que sale por arriba de una region asi NO entra en el
+ * historial del terminal en la mayoria de emuladores: se pierde. En un agente
+ * de codigo, donde media sesion consiste en subir a releer lo que salio, eso es
+ * inaceptable.
+ *
+ * Asi que se hace al reves, sin regiones: el pie se BORRA antes de cada
+ * escritura permanente y se REPINTA justo despues. El texto permanente se
+ * escribe con saltos de linea normales, entra en el historial como siempre, y
+ * el pie acaba de nuevo abajo del todo. Visto desde fuera, el pie no se mueve.
+ *
+ * LA INVARIANTE QUE LO SOSTIENE
+ *
+ * Tras pintar, el cursor queda al final de la ultima fila del bloque. Con eso
+ * basta para borrarlo entero: subir `filasPintadas - 1` filas, ir a la columna
+ * cero y borrar hacia abajo. Se cuentan filas FISICAS (lo que el terminal parte
+ * al llegar al ancho), no elementos del array: contar lineas logicas es
+ * exactamente el fallo que dejaba barras huerfanas en el prompt.
+ *
+ * Y LA SEGUNDA, LA QUE EVITA CORROMPER LA SALIDA AJENA
+ *
+ * Sin secciones puestas, el pie no pinta nada y la pantalla queda byte a byte
+ * como la habria dejado un `console.log` normal. Por eso el resto del programa
+ * -las herramientas, el renderizador, los avisos- puede seguir escribiendo
+ * directo sin saber que esto existe. Solo hay que pasar por aqui mientras haya
+ * pie, que es justo el rato que el bucle controla toda la salida.
+ */
+const OCULTAR_CURSOR = "\x1b[?25l";
+const MOSTRAR_CURSOR = "\x1b[?25h";
+/**
+ * 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.
+ */
+const ORDEN = ["razonamiento", "spinner", "entrada"];
+const secciones = new Map();
+/**
+ * Texto permanente que aun no ha recibido su salto de linea.
+ *
+ * Un `flush()` de markdown puede dejar media linea escrita. Si el pie se
+ * pintara detras, empezaria en mitad de esa fila. En vez de calcular columnas
+ * -aritmetica que se rompe con cada emoji- se guarda ese resto AQUI y se
+ * repinta como primera linea del bloque. Deja de ser texto permanente hasta que
+ * llegue su salto, y entonces se escribe de verdad.
+ */
+let colaSinSalto = "";
+/** Filas fisicas que ocupo el bloque en el ultimo pintado. Es lo que se borra. */
+let filasPintadas = 0;
+/**
+ * Lo ultimo que escribimos NOSOTROS se quedo a medio renglon.
+ *
+ * Sin secciones puestas, la linea a medias deja de estar protegida y sale como
+ * texto permanente (ver `repintar`). Si despues vuelve a haber pie, tiene que
+ * empezar en un renglon nuevo y no pegado al final de esa frase.
+ */
+let aMediaLinea = false;
+let cursorEscondido = false;
+/** `null` = decidirlo por el terminal. Las pruebas lo fuerzan. */
+let habilitado = null;
+function pieUsable() {
+    return habilitado ?? Boolean(process.stdout.isTTY);
+}
+/**
+ * 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 function habilitarPie(valor) {
+    habilitado = valor;
+}
+function ancho() {
+    return Math.max(20, process.stdout.columns || 80);
+}
+function alto() {
+    return Math.max(4, process.stdout.rows || 24);
+}
+function sinColores(texto) {
+    return texto.replace(/\x1b\[[0-9;]*m/g, "");
+}
+/**
+ * Filas de pantalla que ocupa una linea con este ancho.
+ *
+ * `ceil(largo / cols)` coincide con el ajuste diferido de los terminales: tras
+ * escribir exactamente `cols` caracteres el cursor sigue en esa fila esperando,
+ * y eso es una fila, no dos.
+ */
+function filasFisicas(linea, cols) {
+    return sinColores(linea)
+        .split("\n")
+        .reduce((n, seg) => n + Math.max(1, Math.ceil(seg.length / cols)), 0);
+}
+function lineasDelBloque() {
+    const lineas = [];
+    if (colaSinSalto)
+        lineas.push(colaSinSalto);
+    for (const nombre of ORDEN) {
+        const trozo = secciones.get(nombre);
+        if (trozo && trozo.length > 0)
+            lineas.push(...trozo);
+    }
+    return lineas;
+}
+/** Secuencia que deja el cursor donde empezaba el bloque, con todo borrado debajo. */
+function borrado() {
+    if (filasPintadas === 0)
+        return "";
+    const subir = filasPintadas > 1 ? `\x1b[${filasPintadas - 1}A` : "";
+    return `\r${subir}\x1b[0J`;
+}
+/** Secuencia del bloque nuevo. Actualiza `filasPintadas`. */
+function pintado() {
+    let lineas = lineasDelBloque();
+    if (lineas.length === 0) {
+        filasPintadas = 0;
+        return "";
+    }
+    const cols = ancho();
+    // Un pie mas alto que la ventana no se puede repintar: al pintarlo el
+    // terminal desplaza, y la cuenta de filas -que es lo unico que sabemos para
+    // borrarlo- deja de valer. Se recorta por abajo, que es donde esta lo menos
+    // urgente; la cola sin salto va primera y nunca se cae.
+    const tope = alto() - 1;
+    let filas = lineas.reduce((n, l) => n + filasFisicas(l, cols), 0);
+    while (filas > tope && lineas.length > 1) {
+        lineas = lineas.slice(0, -1);
+        filas = lineas.reduce((n, l) => n + filasFisicas(l, cols), 0);
+    }
+    filasPintadas = filas;
+    return lineas.join("\n");
+}
+/**
+ * El unico sitio que escribe. Borra lo de antes, suelta el texto permanente en
+ * medio, y vuelve a pintar el pie debajo. Todo en UNA escritura: un pie pintado
+ * a trozos es un pie que parpadea.
+ */
+function repintar(permanente) {
+    const fuera = borrado();
+    // Sin secciones ya no hay de que proteger la linea a medias, y retenerla seria
+    // peor que soltarla: el pie seguiria contando esa fila como suya, y el
+    // siguiente repintado borraria lo que hubiera escrito cualquier otro por su
+    // cuenta -las herramientas imprimen con console.log y no pasan por aqui-.
+    // Soltandola, `filasPintadas` vuelve a cero y el pie no debe nada a nadie.
+    let suelto = "";
+    if (secciones.size === 0 && colaSinSalto) {
+        suelto = colaSinSalto;
+        colaSinSalto = "";
+    }
+    let dentro = pintado();
+    const texto = permanente + suelto;
+    if (texto)
+        aMediaLinea = !texto.endsWith("\n");
+    if (dentro && aMediaLinea) {
+        // El salto va DELANTE del bloque, y no cuenta como fila suya: el borrado
+        // sube hasta la primera fila del pie, no hasta la frase de encima.
+        dentro = `\n${dentro}`;
+        aMediaLinea = false;
+    }
+    let salida = fuera + texto + dentro;
+    if (dentro && !cursorEscondido) {
+        // Con el pie repintandose cada 120 ms, un cursor visible salta de sitio sin
+        // parar. Se esconde mientras dure y se devuelve al soltarlo.
+        salida = OCULTAR_CURSOR + salida;
+        cursorEscondido = true;
+    }
+    else if (!dentro && cursorEscondido) {
+        salida += MOSTRAR_CURSOR;
+        cursorEscondido = false;
+    }
+    if (salida)
+        dibujar(salida);
+}
+/** ¿Hay algo pintado abajo que haya que respetar? */
+export function hayPie() {
+    return filasPintadas > 0;
+}
+function iguales(a, b) {
+    if (!a || a.length !== b.length)
+        return false;
+    return a.every((l, i) => l === b[i]);
+}
+/** Guarda la seccion. Devuelve si algo cambio, que es lo que decide repintar. */
+function anotar(nombre, lineas) {
+    if (lineas.length === 0) {
+        return secciones.delete(nombre);
+    }
+    if (iguales(secciones.get(nombre), lineas))
+        return false;
+    secciones.set(nombre, lineas);
+    return true;
+}
+/**
+ * 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 function fijarSeccion(nombre, lineas) {
+    if (!pieUsable())
+        return;
+    if (anotar(nombre, lineas))
+        repintar("");
+}
+/**
+ * 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 function fijarSecciones(entradas) {
+    if (!pieUsable())
+        return;
+    let cambio = false;
+    for (const [nombre, lineas] of entradas) {
+        if (anotar(nombre, lineas))
+            cambio = true;
+    }
+    if (cambio)
+        repintar("");
+}
+export function quitarSeccion(nombre) {
+    fijarSeccion(nombre, []);
+}
+/**
+ * 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 function escribirEncimaDelPie(texto) {
+    if (!texto)
+        return;
+    if (!pieUsable() || (filasPintadas === 0 && !colaSinSalto)) {
+        dibujar(texto);
+        return;
+    }
+    const completo = colaSinSalto + texto;
+    const corte = completo.lastIndexOf("\n");
+    const permanente = corte >= 0 ? completo.slice(0, corte + 1) : "";
+    colaSinSalto = corte >= 0 ? completo.slice(corte + 1) : completo;
+    repintar(permanente);
+}
+/**
+ * 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 function soltarPie() {
+    if (secciones.size === 0 && filasPintadas === 0)
+        return;
+    secciones.clear();
+    repintar("");
+}
+/**
+ * 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 function reiniciarPie() {
+    secciones.clear();
+    colaSinSalto = "";
+    filasPintadas = 0;
+    aMediaLinea = false;
+    if (cursorEscondido) {
+        dibujar(MOSTRAR_CURSOR);
+        cursorEscondido = false;
+    }
+}
+/**
+ * Un cursor escondido sobrevive al proceso: la shell de despues se queda sin
+ * cursor y el usuario no tiene forma de saber por que. Se devuelve pase lo que
+ * pase, tambien si el programa se cae.
+ */
+process.on("exit", () => {
+    if (cursorEscondido) {
+        try {
+            process.stdout.write(MOSTRAR_CURSOR);
+        }
+        catch { }
+        cursorEscondido = false;
+    }
+});

package/dist/ui/prompt.d.ts

@@ -1,47 +1,10 @@
+export { buildPromptFrame } from "./marco.js";
+export type { DropdownItem, PromptFrame, PromptFrameOptions } from "./marco.js";
+export { SLASH_COMMANDS } from "./comandos.js";
+export type { SlashCommandItem } from "./comandos.js";
 /**
  * Imprime sin romper el prompt. Uselo en vez de `console.log` para todo lo que
  * pueda llegar TARDE: conexiones en segundo plano, avisos, temporizadores.
  */
 export declare function imprimirSobreElPrompt(texto: string): void;
-export interface SlashCommandItem {
-    name: string;
-    description: string;
-    args?: string;
-}
-export declare const SLASH_COMMANDS: SlashCommandItem[];
-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;
 export declare function askInteractivePrompt(promptSymbol?: string, cwd?: string): Promise<string>;

package/dist/ui/prompt.js

@@ -4,11 +4,21 @@ import fs from "node:fs";
 import path from "node:path";
 import os from "node:os";
 import chalk from "chalk";
-import { cycleMode, describeMode, getMode } from "./modes.js";
+import { cycleMode } from "./modes.js";
 import { releaseKeyboard, tomarTecladoParaPrompt, devolverTecladoDelPrompt } from "./interrupt.js";
 import { repararTeclado, reafirmarModoCrudo, MS_ENTRE_COMPROBACIONES } from "./keyboardGuard.js";
 import { clearTyped } from "./typeAhead.js";
 import { dibujar } from "./salida.js";
+// La lista vive en su propio modulo porque tambien la necesita el prompt de
+// sistema, y este archivo arrastra readline, el historial y el escaneo del
+// proyecto. Se re-exporta para no romper a quien ya la importaba de aqui.
+import { SLASH_COMMANDS } from "./comandos.js";
+// El marco lo comparten el prompt y el spinner: son la MISMA barra, no dos
+// que se parecen. Ver la nota de marco.ts.
+import { buildPromptFrame } from "./marco.js";
+export { buildPromptFrame } from "./marco.js";
+export { SLASH_COMMANDS } from "./comandos.js";
+import { escribirEncimaDelPie, soltarPie } from "./pieFijo.js";
 import { esGrande, guardarPegado, expandirPegados, marcaQueTerminaEn, limpiarPegados } from "./pegados.js";
 /**
  * Escribir algo mientras el prompt esta dibujado.
@@ -40,28 +50,10 @@ export function imprimirSobreElPrompt(texto) {
         escribirEncimaDelPrompt(texto);
         return;
     }
-    dibujar(texto.endsWith("\n") ? texto : `${texto}\n`);
+    // Sin prompt abierto puede haber pie: el spinner y la linea de razonamiento
+    // viven ahi. Un aviso que llegue tarde tiene que pasar por encima igual.
+    escribirEncimaDelPie(texto.endsWith("\n") ? texto : `${texto}\n`);
 }
-export const SLASH_COMMANDS = [
-    { name: "/mcp", description: "Ver servidores MCP conectados y sus herramientas" },
-    { name: "/undo", description: "Deshacer las últimas modificaciones de archivos de la sesión" },
-    { 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: "/cost", description: "Ver consumo detallado de tokens e inversión en USD" },
-    { 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" },
-];
 let isKeypressInitialized = false;
 /**
  * PEGADO DE VARIAS LINEAS
@@ -148,143 +140,18 @@ function scanProjectFiles(dir, maxResults = 40) {
     walk(dir);
     return results;
 }
-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 };
-}
 export async function askInteractivePrompt(promptSymbol = "❯", cwd = process.cwd()) {
     return new Promise((resolve) => {
+        // El relevo de la barra.
+        //
+        // Mientras el agente trabajaba, el pie tenia pintado ESTE MISMO marco. Se
+        // borra -dejando el cursor justo donde empezaba- y acto seguido se dibuja
+        // aqui, en el mismo sitio y con el mismo contenido. Desde fuera la barra no
+        // se ha movido: no hay parpadeo ni salto, que era la queja.
+        //
+        // `soltarPie` y no `reiniciarPie`: hay que BORRAR lo que el pie tenia
+        // pintado. Olvidarlo sin borrar dejaria dos marcos, uno encima del otro.
+        soltarPie();
         let inputBuffer = "";
         let cursorIndex = 0;
         let selectedIndex = 0;

package/dist/ui/reasoningStream.js

@@ -1,5 +1,6 @@
 import chalk from "chalk";
 import process from "node:process";
+import { fijarSeccion, quitarSeccion, escribirEncimaDelPie } from "./pieFijo.js";
 /**
  * Lo que se ve mientras el modelo piensa.
  *
@@ -23,9 +24,17 @@ import process from "node:process";
  * que aparecia justo en las tareas largas -las que mas razonan- y nunca al
  * saludar.
  *
- * Ahora se resume: una sola linea que se reescribe sobre si misma diciendo
- * cuanto lleva pensando y en que anda. Cero avance de scroll, una escritura por
- * trozo recibido en vez de una por letra.
+ * Ahora se resume: una sola linea que dice cuanto lleva pensando y en que anda.
+ * Cero avance de scroll, una escritura por trozo recibido en vez de una por
+ * letra.
+ *
+ * DONDE VIVE ESA LINEA
+ *
+ * En el pie fijo, no en la fila actual. Antes se reescribia sobre si misma con
+ * `\r\x1b[2K`, que la ata a la fila donde nacio: al empezar a llegar la
+ * respuesta, el terminal desplaza y se la lleva hacia arriba. Es la "nubecita
+ * que sube con lo que me respondes". Entregandola al pie, se repinta abajo tras
+ * cada linea de respuesta y se queda quieta.
  *
  * Quien quiera verlo entero: CHOCOLATITO_RAZONAMIENTO=completo.
  */
@@ -56,7 +65,7 @@ export class ReasoningStream {
             this.caracteres = 0;
             this.cola = "";
             if (COMPLETO) {
-                process.stdout.write(`\n  ${chalk.bold.hex("#8B5CF6")("💭 Razonando:")}\n`);
+                escribirEncimaDelPie(`\n  ${chalk.bold.hex("#8B5CF6")("💭 Razonando:")}\n`);
             }
         }
         if (COMPLETO) {
@@ -87,22 +96,20 @@ export class ReasoningStream {
         }
         // Un solo write, y el color se aplica una vez al bloque entero en vez de a
         // cada letra: mismo resultado en pantalla, una fraccion de los bytes.
-        process.stdout.write(chalk.gray(salida));
+        escribirEncimaDelPie(chalk.gray(salida));
     }
     refrescar(forzar) {
         const ahora = Date.now();
         if (!forzar && ahora - this.ultimoRefresco < MS_ENTRE_REFRESCOS)
             return;
         this.ultimoRefresco = ahora;
-        if (!process.stdout.isTTY)
-            return;
         const segundos = Math.round((ahora - this.inicio) / 1000);
         const ancho = Math.max(20, (process.stdout.columns || 80) - 4);
         const cabeza = `  ${chalk.hex("#8B5CF6")("💭")} ${chalk.gray(`pensando… ${segundos}s`)}`;
         // La ultima frase a medias da una pista de por donde va sin contarlo todo.
         const pista = unaLinea(this.cola, Math.max(0, ancho - 24));
         const linea = pista ? `${cabeza} ${chalk.dim("·")} ${chalk.dim(pista)}` : cabeza;
-        process.stdout.write(`\r\x1b[2K${unaLinea(linea, ancho + 40)}`);
+        fijarSeccion("razonamiento", [linea]);
         this.lineaPintada = true;
     }
     flush() {
@@ -110,17 +117,20 @@ export class ReasoningStream {
             return;
         if (COMPLETO) {
             if (!this.atLineStart) {
-                process.stdout.write("\n");
+                escribirEncimaDelPie("\n");
                 this.atLineStart = true;
             }
-            process.stdout.write("\n");
+            escribirEncimaDelPie("\n");
             this.hasStarted = false;
             return;
         }
         const segundos = Math.max(1, Math.round((Date.now() - this.inicio) / 1000));
+        // Primero se quita la linea viva del pie y despues se escribe el resumen
+        // como texto permanente. Al reves, el resumen quedaria por encima de una
+        // linea de "pensando…" que ya no viene a cuento.
+        quitarSeccion("razonamiento");
         if (this.lineaPintada) {
-            // Se deja una sola linea de resumen donde estaba la que iba cambiando.
-            process.stdout.write(`\r\x1b[2K  ${chalk.hex("#8B5CF6")("💭")} ${chalk.gray(`pensó ${segundos}s`)}\n`);
+            escribirEncimaDelPie(`  ${chalk.hex("#8B5CF6")("💭")} ${chalk.gray(`pensó ${segundos}s`)}\n`);
         }
         this.lineaPintada = false;
         this.hasStarted = false;

package/dist/ui/renderer.d.ts

@@ -5,6 +5,19 @@ export declare function renderToolError(name: string, errorSummary: string): voi
 export declare function renderDiff(filePath: string, diffText: string): void;
 export declare function renderReasoning(reasoningText: string): void;
 export declare function renderAssistantResponse(markdownText: string): void;
+/**
+ * La linea de cada turno.
+ *
+ * `⚡ 3.0s · 64 tokens salida (10.8k en caché) · Espectro 1.0 (Ágil) · 99%
+ *  contexto libre · 28% de la cuota semanal`
+ *
+ * Con cuenta gestionada NO lleva importe. Se quito primero de /cost y esta se
+ * quedo atras; el usuario lo vio enseguida -"aun sigue saliendo el precio que se
+ * gasta"- y con razon: /cost se mira cuando uno se acuerda, esta linea sale en
+ * TODOS los turnos. De los dos sitios, era el que mas importaba.
+ *
+ * Con clave propia si sale: ahi el dinero es del usuario y es su factura.
+ */
 export declare function renderFooter(costStr: string, outTokens: number, cachedTokens: number, modelName: string, durationMs?: number, contextPercent?: number, quotaStr?: string): void;
 export declare function renderError(message: string): void;
 export declare function formatToolName(name: string): string;