chocolatito-code 1.0.0 → 1.2.0

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 { dibujar } from "./salida.js";
 /**
  * Interrupcion con Esc mientras el agente trabaja.
  *
@@ -32,6 +33,42 @@ import { pushTyped, backspaceTyped, commitTyped } from "./typeAhead.js";
  */
 const activos = new Set();
 /** Suelta el teclado de cualquier vigilante que lo tenga. Lo llama el prompt. */
+/**
+ * Como estaba el terminal ANTES de que ningun vigilante lo tocara.
+ *
+ * Cada vigilante se guardaba su propio `wasRaw` leyendo el estado en el momento
+ * de arrancar. Con un vigilante suelto -y el bucle tiene veinte salidas, basta
+ * que una se escape- el siguiente leia el modo crudo que habia dejado el
+ * anterior y se lo apuntaba como "lo de antes". Al soltarlos todos, cada uno
+ * restauraba su version y ganaba el ultimo: el terminal acababa en un estado que
+ * no era el de nadie.
+ *
+ * Con una sola marca, tomada por el primero y devuelta por el ultimo, el numero
+ * de vigilantes deja de importar.
+ */
+let modoCrudoOriginal = null;
+/**
+ * Hay un prompt dibujado ahora mismo.
+ *
+ * Un vigilante puede pararse TARDE: el bucle vuelve, el prompt se dibuja y coge
+ * el modo crudo, y solo entonces una promesa rezagada del turno anterior llama a
+ * su `stop()`. Ese stop restauraba "como estaba antes del turno" —modo cocido—
+ * y se lo quitaba al prompt recien abierto. Desde fuera se veia como el fallo
+ * que se reporto tres veces: tecleas y tu texto sale en la linea de ayuda, no
+ * en el recuadro, porque quien hace el eco es el terminal.
+ *
+ * Con esta marca, el ultimo vigilante en irse solo devuelve el terminal si no
+ * hay nadie esperandolo.
+ */
+let promptConElTeclado = false;
+/** Lo llama el prompt al abrirse, despues de coger el modo crudo. */
+export function tomarTecladoParaPrompt() {
+    promptConElTeclado = true;
+}
+/** Lo llama el prompt al cerrarse, para que el siguiente turno pueda restaurar. */
+export function devolverTecladoDelPrompt() {
+    promptConElTeclado = false;
+}
 export function releaseKeyboard() {
     for (const w of Array.from(activos)) {
         w.stop();
@@ -62,7 +99,11 @@ export class InterruptWatcher {
             return this.controller.signal;
         }
         readline.emitKeypressEvents(process.stdin);
-        this.wasRaw = process.stdin.isRaw || false;
+        // Solo el primero apunta como estaba: los que vengan detras verian el modo
+        // crudo que dejo este, no el del usuario.
+        if (activos.size === 0)
+            modoCrudoOriginal = process.stdin.isRaw || false;
+        this.wasRaw = modoCrudoOriginal ?? false;
         process.stdin.setRawMode(true);
         process.stdin.resume();
         this.onKey = (str, key) => {
@@ -72,7 +113,7 @@ export class InterruptWatcher {
                 Boolean(key && key.sequence === "\x1b[Z");
             if (isShiftTab) {
                 cycleMode();
-                process.stdout.write(`\r\x1b[2K${modeAnnouncement()}\n`);
+                dibujar(`\r\x1b[2K${modeAnnouncement()}\n`);
                 return;
             }
             // Ignorar secuencias de escape multi-byte (flechas, inicio, fin, etc.) para que no aborten
@@ -90,7 +131,7 @@ export class InterruptWatcher {
                 const texto = commitTyped();
                 if (texto) {
                     const corto = texto.length > 70 ? `${texto.slice(0, 67)}...` : texto;
-                    process.stdout.write(`\r\x1b[2K${chalk.gray("↳ en cola:")} ${chalk.white(corto)}\n`);
+                    dibujar(`\r\x1b[2K${chalk.gray("↳ en cola:")} ${chalk.white(corto)}\n`);
                 }
                 return;
             }
@@ -137,12 +178,23 @@ export class InterruptWatcher {
             process.stdin.removeListener("keypress", this.onKey);
             this.onKey = null;
         }
-        if (this.listening && process.stdin.setRawMode) {
-            // Se devuelve el terminal como estaba, o el prompt siguiente queda roto.
-            process.stdin.setRawMode(this.wasRaw);
-        }
+        const escuchaba = this.listening;
         this.listening = false;
         activos.delete(this);
+        // El terminal se devuelve cuando se va el ULTIMO, no cada vez que se va
+        // uno: si quedan vigilantes vivos, restaurar aqui les quita el teclado a
+        // ellos a mitad de turno.
+        if (escuchaba && activos.size === 0) {
+            if (promptConElTeclado) {
+                // Llegamos tarde: el prompt ya esta abierto y el modo crudo es suyo.
+                // Solo se olvida la marca, que ya no describe nada.
+                modoCrudoOriginal = null;
+            }
+            else if (process.stdin.setRawMode) {
+                process.stdin.setRawMode(modoCrudoOriginal ?? this.wasRaw);
+                modoCrudoOriginal = null;
+            }
+        }
     }
 }
 /** Un error de aborto no es un fallo: es el usuario diciendo "para". */

package/dist/ui/keyboardGuard.d.ts

@@ -0,0 +1,76 @@
+/**
+ * El prompt no suelta el teclado mientras esta abierto.
+ *
+ * EL FALLO QUE CIERRA ESTE ARCHIVO
+ *
+ * Reportado tres veces desde el uso real, siempre igual: "escribi 2 prompts y
+ * al siguiente ya no me deja escribir nada, teclee lo que teclee". La sesion
+ * pegada por el usuario tenia la pista buena, escondida en la ultima linea:
+ *
+ *     ? /help para atajos · esc cancelar    ⇥ modo normal · Espectro 1.0 (Agil) estaba haciendo y denuevo...
+ *
+ * Lo que escribia SI aparecia, pero pegado al final de la linea de ayuda en vez
+ * de dentro del recuadro. Eso solo pasa de una forma: el modo crudo estaba
+ * apagado, asi que quien hacia el eco era PowerShell —en el sitio donde estuviera
+ * el cursor— y el prompt no se enteraba de ninguna tecla, porque en modo cocido
+ * no llega nada hasta que se pulsa Enter. El teclado no estaba muerto: estaba
+ * en manos del terminal.
+ *
+ * POR QUE NO SE ARREGLA EN EL SITIO QUE LO ROMPE
+ *
+ * Hay demasiados sitios que lo rompen, y todos con razon:
+ *
+ *   - `InterruptWatcher.stop()` devuelve el modo crudo a como estaba. Si un
+ *     vigilante se para TARDE —despues de que el prompt ya se haya dibujado—
+ *     restaura un estado que ya no toca y se lo quita al prompt.
+ *   - `readline.createInterface(...).close()` hace por dentro `pause()` y
+ *     `setRawMode(false)`. Lo usan el dialogo de "¿que prefieres que haga?" y la
+ *     pregunta del detector de bucles.
+ *   - Cualquier salida del bucle que se escape sin parar lo suyo.
+ *
+ * Ya hubo dos intentos de arreglarlo apretando tuercas una por una, y el fallo
+ * volvio las dos veces, porque basta que UNA de las veinte salidas se escape.
+ * Asi que el prompt deja de confiar: mientras esta abierto, comprueba cuatro
+ * veces por segundo que el teclado sigue siendo suyo y lo recupera si no.
+ *
+ * Cuesta cuatro comparaciones cada 250 ms. El fallo costaba cerrar el terminal.
+ */
+/** Lo minimo de `process.stdin` que hace falta, para poder probarlo con uno falso. */
+export interface EntradaDeTeclado {
+    isTTY?: boolean;
+    isRaw?: boolean;
+    setRawMode?: (flag: boolean) => unknown;
+    isPaused?: () => boolean;
+    resume?: () => unknown;
+}
+/**
+ * Devuelve el teclado al prompt si alguien se lo ha quitado.
+ *
+ * Devuelve la lista de lo que ha tenido que reparar. Vacia es lo normal: si
+ * alguna vez devuelve algo, hay un fallo de verdad en quien solto el teclado, y
+ * por eso `CHOCOLATITO_TECLADO=debug` lo saca por pantalla en vez de callarselo.
+ */
+export declare function repararTeclado(entrada: EntradaDeTeclado): string[];
+/** Cada cuanto se comprueba. Cuatro veces por segundo se nota como instantaneo. */
+export declare const MS_ENTRE_COMPROBACIONES = 250;
+/**
+ * Vuelve a poner el modo crudo DE VERDAD, no solo en la cuenta de Node.
+ *
+ * EL AGUJERO QUE TAPA
+ *
+ * `setRawMode(true)` no siempre llega al terminal. Por debajo, libuv guarda el
+ * modo que cree tener y empieza con `if (tty->mode == mode) return 0;`. Asi que
+ * si algo cambia el modo de la consola por fuera de Node -un proceso hijo, la
+ * propia shell, el terminal- Node sigue creyendo que esta en crudo, y a partir
+ * de ahi TODOS los `setRawMode(true)` se convierten en no-op. Incluido el que
+ * hace el prompt al abrirse.
+ *
+ * Se veia asi, y se reporto cuatro veces: el usuario teclea, su texto sale al
+ * final de la linea de ayuda -lo esta haciendo el eco del terminal, no el
+ * prompt- y el recuadro no se entera de nada. El vigilante tampoco reparaba
+ * nada, porque preguntaba a Node y Node decia que todo estaba bien.
+ *
+ * Pasar por `false` primero rompe esa cache: la segunda llamada ya ve un cambio
+ * de verdad y lo aplica sobre la consola.
+ */
+export declare function reafirmarModoCrudo(entrada: EntradaDeTeclado): void;

package/dist/ui/keyboardGuard.js

@@ -0,0 +1,94 @@
+/**
+ * El prompt no suelta el teclado mientras esta abierto.
+ *
+ * EL FALLO QUE CIERRA ESTE ARCHIVO
+ *
+ * Reportado tres veces desde el uso real, siempre igual: "escribi 2 prompts y
+ * al siguiente ya no me deja escribir nada, teclee lo que teclee". La sesion
+ * pegada por el usuario tenia la pista buena, escondida en la ultima linea:
+ *
+ *     ? /help para atajos · esc cancelar    ⇥ modo normal · Espectro 1.0 (Agil) estaba haciendo y denuevo...
+ *
+ * Lo que escribia SI aparecia, pero pegado al final de la linea de ayuda en vez
+ * de dentro del recuadro. Eso solo pasa de una forma: el modo crudo estaba
+ * apagado, asi que quien hacia el eco era PowerShell —en el sitio donde estuviera
+ * el cursor— y el prompt no se enteraba de ninguna tecla, porque en modo cocido
+ * no llega nada hasta que se pulsa Enter. El teclado no estaba muerto: estaba
+ * en manos del terminal.
+ *
+ * POR QUE NO SE ARREGLA EN EL SITIO QUE LO ROMPE
+ *
+ * Hay demasiados sitios que lo rompen, y todos con razon:
+ *
+ *   - `InterruptWatcher.stop()` devuelve el modo crudo a como estaba. Si un
+ *     vigilante se para TARDE —despues de que el prompt ya se haya dibujado—
+ *     restaura un estado que ya no toca y se lo quita al prompt.
+ *   - `readline.createInterface(...).close()` hace por dentro `pause()` y
+ *     `setRawMode(false)`. Lo usan el dialogo de "¿que prefieres que haga?" y la
+ *     pregunta del detector de bucles.
+ *   - Cualquier salida del bucle que se escape sin parar lo suyo.
+ *
+ * Ya hubo dos intentos de arreglarlo apretando tuercas una por una, y el fallo
+ * volvio las dos veces, porque basta que UNA de las veinte salidas se escape.
+ * Asi que el prompt deja de confiar: mientras esta abierto, comprueba cuatro
+ * veces por segundo que el teclado sigue siendo suyo y lo recupera si no.
+ *
+ * Cuesta cuatro comparaciones cada 250 ms. El fallo costaba cerrar el terminal.
+ */
+/**
+ * Devuelve el teclado al prompt si alguien se lo ha quitado.
+ *
+ * Devuelve la lista de lo que ha tenido que reparar. Vacia es lo normal: si
+ * alguna vez devuelve algo, hay un fallo de verdad en quien solto el teclado, y
+ * por eso `CHOCOLATITO_TECLADO=debug` lo saca por pantalla en vez de callarselo.
+ */
+export function repararTeclado(entrada) {
+    // Sin terminal delante (una tuberia, CI, `chocolatito "tarea"`) no hay modo
+    // crudo que defender y forzarlo seria un error.
+    if (!entrada || !entrada.isTTY || typeof entrada.setRawMode !== "function")
+        return [];
+    const reparado = [];
+    if (entrada.isRaw !== true) {
+        reafirmarModoCrudo(entrada);
+        reparado.push("modo crudo");
+    }
+    // `pause()` corta el flujo sin avisar a nadie: el oyente de `keypress` sigue
+    // apuntado y no recibe ni una tecla. Es lo que deja detras un readline al
+    // cerrarse.
+    if (typeof entrada.isPaused === "function" && entrada.isPaused() && typeof entrada.resume === "function") {
+        entrada.resume();
+        reparado.push("entrada en pausa");
+    }
+    return reparado;
+}
+/** Cada cuanto se comprueba. Cuatro veces por segundo se nota como instantaneo. */
+export const MS_ENTRE_COMPROBACIONES = 250;
+/**
+ * Vuelve a poner el modo crudo DE VERDAD, no solo en la cuenta de Node.
+ *
+ * EL AGUJERO QUE TAPA
+ *
+ * `setRawMode(true)` no siempre llega al terminal. Por debajo, libuv guarda el
+ * modo que cree tener y empieza con `if (tty->mode == mode) return 0;`. Asi que
+ * si algo cambia el modo de la consola por fuera de Node -un proceso hijo, la
+ * propia shell, el terminal- Node sigue creyendo que esta en crudo, y a partir
+ * de ahi TODOS los `setRawMode(true)` se convierten en no-op. Incluido el que
+ * hace el prompt al abrirse.
+ *
+ * Se veia asi, y se reporto cuatro veces: el usuario teclea, su texto sale al
+ * final de la linea de ayuda -lo esta haciendo el eco del terminal, no el
+ * prompt- y el recuadro no se entera de nada. El vigilante tampoco reparaba
+ * nada, porque preguntaba a Node y Node decia que todo estaba bien.
+ *
+ * Pasar por `false` primero rompe esa cache: la segunda llamada ya ve un cambio
+ * de verdad y lo aplica sobre la consola.
+ */
+export function reafirmarModoCrudo(entrada) {
+    if (!entrada || typeof entrada.setRawMode !== "function")
+        return;
+    try {
+        entrada.setRawMode(false);
+    }
+    catch { }
+    entrada.setRawMode(true);
+}

package/dist/ui/loopPrompt.d.ts

@@ -0,0 +1,17 @@
+import { AvisoDeBucle } from "../agent/loopDetector.js";
+export interface RespuestaDeBucle {
+    /** "seguir" deja al agente repetir; "parar" corta esa llamada y le obliga a cambiar. */
+    accion: "seguir" | "parar";
+    indicacion?: string;
+}
+/**
+ * Que hacer cuando el agente lleva tres vueltas haciendo exactamente lo mismo.
+ *
+ * Sin terminal —CI, `chocolatito "tarea"`, un cron— se PARA. Es lo contrario de
+ * lo que hace el dialogo de permisos, que ante la duda deniega para no tocar
+ * nada, y el motivo es que aqui el riesgo es el opuesto: no hay nada que
+ * proteger del agente, hay una cuota que proteger de un bucle que nadie esta
+ * mirando. Parar no mata el turno: le devuelve al modelo un mensaje explicando
+ * el atasco, y el turno sigue.
+ */
+export declare function preguntarPorBucle(aviso: AvisoDeBucle): Promise<RespuestaDeBucle>;

package/dist/ui/loopPrompt.js

@@ -0,0 +1,59 @@
+import readline from "node:readline";
+import process from "node:process";
+import chalk from "chalk";
+/**
+ * Que hacer cuando el agente lleva tres vueltas haciendo exactamente lo mismo.
+ *
+ * Sin terminal —CI, `chocolatito "tarea"`, un cron— se PARA. Es lo contrario de
+ * lo que hace el dialogo de permisos, que ante la duda deniega para no tocar
+ * nada, y el motivo es que aqui el riesgo es el opuesto: no hay nada que
+ * proteger del agente, hay una cuota que proteger de un bucle que nadie esta
+ * mirando. Parar no mata el turno: le devuelve al modelo un mensaje explicando
+ * el atasco, y el turno sigue.
+ */
+export async function preguntarPorBucle(aviso) {
+    const cabecera = chalk.yellow(`\n↻  Parece un bucle: `) +
+        chalk.white(`"${aviso.herramienta}"`) +
+        chalk.yellow(` lleva ${aviso.repeticiones} llamadas identicas con el mismo resultado.`);
+    if (!process.stdin.isTTY) {
+        console.log(cabecera + chalk.gray("\n   Sin terminal interactiva: se corta la repeticion para no gastar cuota.\n"));
+        return { accion: "parar" };
+    }
+    console.log(cabecera);
+    console.log(chalk.gray("   ¿Le dejo seguir intentandolo, o le digo que cambie de enfoque?\n"));
+    return new Promise((resolve) => {
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        // Como en el dialogo de permisos: 'close' llega tambien tras una respuesta
+        // normal, y sin guarda el mensaje de corte pisaria lo que el usuario acaba
+        // de escribir. Manda quien llegue primero.
+        let asentada = false;
+        const asentar = (r) => {
+            if (asentada)
+                return;
+            asentada = true;
+            resolve(r);
+        };
+        // Ctrl+C, Ctrl+D o stdin cerrandose significan lo mismo: no hay respuesta.
+        // Aqui eso es "para", que es la opcion que no cuesta dinero.
+        rl.on("close", () => {
+            // readline duerme su entrada al cerrarse (`close()` llama a `pause()`).
+            // Aqui estamos a mitad de turno: si se queda dormida, el vigilante que
+            // sigue no recibe ni una tecla y el Esc deja de cancelar.
+            process.stdin.resume();
+            if (asentada)
+                return;
+            process.stdout.write("\n");
+            asentar({ accion: "parar" });
+        });
+        rl.question(chalk.hex("#A855F7")("   [enter] que cambie de enfoque · [s] dejale seguir · o escribe una indicacion ❯ "), (respuesta) => {
+            const texto = respuesta.trim();
+            if (texto.toLowerCase() === "s" || texto.toLowerCase() === "si") {
+                asentar({ accion: "seguir" });
+            }
+            else {
+                asentar({ accion: "parar", indicacion: texto || undefined });
+            }
+            rl.close();
+        });
+    });
+}

package/dist/ui/pegados.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Un pegado grande no se mete entero en el recuadro.
+ *
+ * EL PROBLEMA
+ *
+ * Pegar un error de compilacion de 300 lineas metia las 300 lineas dentro del
+ * prompt. El recuadro crecia hasta llenar la pantalla, el marco se volvia
+ * inutil, y para deshacerlo habia que pulsar borrar trescientas veces. Es el
+ * caso normal de usar un agente: uno pega un log, una traza, un archivo entero.
+ *
+ * COMO QUEDA
+ *
+ * El texto se guarda aparte y en el recuadro solo aparece una marca corta:
+ *
+ *     ❯ arregla esto [pegado #1 · 347 lineas]
+ *
+ * Al enviar, la marca se sustituye por el texto completo, asi que el modelo
+ * recibe exactamente lo que se pego. Y un solo borrar se lleva la marca entera:
+ * lo que ocupa una linea se borra como una linea.
+ *
+ * POR QUE UNA MARCA DE TEXTO Y NO UNA ESTRUCTURA APARTE
+ *
+ * Porque el buffer del prompt es una cadena y todo lo demas -el cursor, el
+ * historial, el recorte del marco, la busqueda de menciones- cuenta caracteres.
+ * Meter ahi un objeto obligaria a tocar las seis cosas. Una marca de texto se
+ * lleva bien con todo lo que ya funciona.
+ */
+/** A partir de aqui, un pegado se guarda aparte en vez de llenar el recuadro. */
+export declare const MINIMO_LINEAS = 5;
+export declare const MINIMO_CARACTERES = 400;
+/** Si merece la pena guardarlo aparte, o es lo bastante corto para verlo entero. */
+export declare function esGrande(texto: string): boolean;
+/** Guarda el texto y devuelve la marca que va en el recuadro. */
+export declare function guardarPegado(texto: string): string;
+/** Devuelve el texto de verdad, con las marcas sustituidas. Es lo que ve el modelo. */
+export declare function expandirPegados(entrada: string): string;
+/**
+ * Si justo antes del cursor termina una marca, dice donde empieza.
+ *
+ * Es lo que hace que un solo borrar se lleve el pegado entero. Sin esto habria
+ * que borrar la marca letra a letra, que es un poco menos absurdo que borrar
+ * las 347 lineas pero sigue siendo absurdo.
+ */
+export declare function marcaQueTerminaEn(buffer: string, cursor: number): {
+    inicio: number;
+} | null;
+/** Se olvidan al cerrar el prompt: cada turno empieza con su propia cuenta. */
+export declare function limpiarPegados(): void;
+/** Cuantos hay guardados ahora mismo. Solo para las pruebas. */
+export declare function cuantosPegados(): number;

package/dist/ui/pegados.js

@@ -0,0 +1,83 @@
+/**
+ * Un pegado grande no se mete entero en el recuadro.
+ *
+ * EL PROBLEMA
+ *
+ * Pegar un error de compilacion de 300 lineas metia las 300 lineas dentro del
+ * prompt. El recuadro crecia hasta llenar la pantalla, el marco se volvia
+ * inutil, y para deshacerlo habia que pulsar borrar trescientas veces. Es el
+ * caso normal de usar un agente: uno pega un log, una traza, un archivo entero.
+ *
+ * COMO QUEDA
+ *
+ * El texto se guarda aparte y en el recuadro solo aparece una marca corta:
+ *
+ *     ❯ arregla esto [pegado #1 · 347 lineas]
+ *
+ * Al enviar, la marca se sustituye por el texto completo, asi que el modelo
+ * recibe exactamente lo que se pego. Y un solo borrar se lleva la marca entera:
+ * lo que ocupa una linea se borra como una linea.
+ *
+ * POR QUE UNA MARCA DE TEXTO Y NO UNA ESTRUCTURA APARTE
+ *
+ * Porque el buffer del prompt es una cadena y todo lo demas -el cursor, el
+ * historial, el recorte del marco, la busqueda de menciones- cuenta caracteres.
+ * Meter ahi un objeto obligaria a tocar las seis cosas. Una marca de texto se
+ * lleva bien con todo lo que ya funciona.
+ */
+/** A partir de aqui, un pegado se guarda aparte en vez de llenar el recuadro. */
+export const MINIMO_LINEAS = 5;
+export const MINIMO_CARACTERES = 400;
+const guardados = new Map();
+let siguiente = 1;
+/** Reconoce una marca. El id es lo unico que hace falta para recuperar el texto. */
+const MARCA = /\[pegado #(\d+) · [^\]]*\]/g;
+function resumen(texto) {
+    const lineas = texto.split("\n").length;
+    if (lineas > 1)
+        return `${lineas.toLocaleString("es")} lineas`;
+    return `${texto.length.toLocaleString("es")} caracteres`;
+}
+/** Si merece la pena guardarlo aparte, o es lo bastante corto para verlo entero. */
+export function esGrande(texto) {
+    return texto.length >= MINIMO_CARACTERES || texto.split("\n").length > MINIMO_LINEAS;
+}
+/** Guarda el texto y devuelve la marca que va en el recuadro. */
+export function guardarPegado(texto) {
+    const id = siguiente++;
+    guardados.set(id, texto);
+    return `[pegado #${id} · ${resumen(texto)}]`;
+}
+/** Devuelve el texto de verdad, con las marcas sustituidas. Es lo que ve el modelo. */
+export function expandirPegados(entrada) {
+    // Una marca de un id que ya no existe se deja tal cual: es texto que el
+    // usuario escribio a mano, y borrarselo seria peor que dejarlo.
+    return entrada.replace(MARCA, (todo, id) => guardados.get(Number(id)) ?? todo);
+}
+/**
+ * Si justo antes del cursor termina una marca, dice donde empieza.
+ *
+ * Es lo que hace que un solo borrar se lleve el pegado entero. Sin esto habria
+ * que borrar la marca letra a letra, que es un poco menos absurdo que borrar
+ * las 347 lineas pero sigue siendo absurdo.
+ */
+export function marcaQueTerminaEn(buffer, cursor) {
+    if (cursor <= 0 || buffer[cursor - 1] !== "]")
+        return null;
+    const trozo = buffer.slice(0, cursor);
+    const inicio = trozo.lastIndexOf("[pegado #");
+    if (inicio < 0)
+        return null;
+    // Que lo que hay entre los corchetes sea de verdad una marca y no un
+    // "[pegado #" que el usuario escribiera a mano.
+    return /^\[pegado #\d+ · [^\]]*\]$/.test(trozo.slice(inicio)) ? { inicio } : null;
+}
+/** Se olvidan al cerrar el prompt: cada turno empieza con su propia cuenta. */
+export function limpiarPegados() {
+    guardados.clear();
+    siguiente = 1;
+}
+/** Cuantos hay guardados ahora mismo. Solo para las pruebas. */
+export function cuantosPegados() {
+    return guardados.size;
+}

package/dist/ui/permissionPrompt.js

@@ -2,6 +2,7 @@ import readline from "node:readline";
 import process from "node:process";
 import chalk from "chalk";
 import { cycleMode, describeMode, getMode, modeAnnouncement } from "./modes.js";
+import { isOutsideProject, isSvgSource } from "../config/permissions.js";
 /**
  * Aprobacion automatica: se activa con --yes / -y o con la variable de entorno
  * CHOCOLATITO_AUTO_APPROVE. Pensada para modo no interactivo y CI.
@@ -77,9 +78,45 @@ export async function askToolPermission(toolName, args, cwd = process.cwd()) {
                     input: process.stdin,
                     output: process.stdout,
                 });
+                // Guarda de resolucion unica: 'close' llega tambien despues de una
+                // respuesta normal, y sin ella el mensaje de cancelado pisaria al texto
+                // que el usuario acaba de escribir. Manda quien llegue primero.
+                let asentada = false;
+                const asentar = (texto) => {
+                    if (asentada)
+                        return;
+                    asentada = true;
+                    resFeedback(texto);
+                };
+                // Ctrl+C aqui dentro no llama al callback de 'line': readline cierra la
+                // interfaz y punto. Sin este oyente la promesa no se asentaba nunca, el
+                // `await` de askToolPermission no volvia y el bucle del agente se
+                // quedaba vivo pero inerte: ni ejecutaba, ni cancelaba, ni devolvia el
+                // prompt. La unica salida era un segundo Ctrl+C, que ya llegaba con el
+                // terminal en modo cocido y mataba la sesion entera.
+                //
+                // Vale igual para Ctrl+D y para stdin cerrandose por su cuenta: todo lo
+                // que cierre la interfaz sin linea significa lo mismo, que no hay
+                // respuesta, y eso se traduce en cancelar la accion.
+                rl.on("close", () => {
+                    if (asentada)
+                        return;
+                    // El cursor se queda a medio renglon, pegado al "❯": se cierra la
+                    // linea para que lo siguiente no salga encima del prompt.
+                    process.stdout.write("\n");
+                    asentar("Cancelado por el usuario con Ctrl+C.");
+                });
+                // Un readline, al cerrarse, hace por dentro `pause()` sobre su entrada
+                // ademas de apagar el modo crudo. Quien venga detras —el vigilante del
+                // resto del turno— da por hecho que la entrada fluye, se apunta como
+                // oyente y no recibe ni una tecla: el Esc deja de cancelar y lo que se
+                // teclee no se encola. Se despierta aqui, que es donde se durmio.
+                rl.on("close", () => {
+                    process.stdin.resume();
+                });
                 rl.question(chalk.hex("#A855F7")("\n¿Qué prefieres que haga? ❯ "), (answer) => {
+                    asentar(answer.trim() || "El usuario canceló la acción sin dar detalles adicionales.");
                     rl.close();
-                    resFeedback(answer.trim() || "El usuario canceló la acción sin dar detalles adicionales.");
                 });
             });
         }
@@ -235,6 +272,10 @@ function classify(toolName, args) {
         return { title: "  Controlar tu ordenador", color: "#A855F7" };
     return { title: "  Permiso de ejecución", color: "#D97757" };
 }
+/** Herramientas que conducen pestanas del navegador del usuario. */
+function esNavegador(toolName) {
+    return toolName === "chrome" || toolName === "browser" || toolName === "browser_live";
+}
 /** Las lineas de detalle, ya recortadas para que quepan dentro del marco. */
 function details(toolName, args, cwd, width) {
     const max = width - 8;
@@ -258,14 +299,55 @@ function details(toolName, args, cwd, width) {
             add(plain, `${chalk.green(`+${mas} líneas`)}  ${chalk.red(`-${menos} líneas`)}`);
         }
     }
+    else if (typeof args.outputPath === "string") {
+        // create_image no trae ni `command` ni `path`, asi que el dialogo caia en el
+        // caso de abajo y pedia aprobar la palabra "create_image" a secas: ni el
+        // destino ni el detalle de que el generatorScript se ejecuta con python.
+        add(args.outputPath, chalk.bold.white(args.outputPath));
+        const script = typeof args.generatorScript === "string" ? args.generatorScript : "";
+        const lineas = script.split("\n").length;
+        if (isSvgSource(script)) {
+            add(`SVG, ${lineas} líneas`, chalk.gray(`SVG, ${lineas} líneas`));
+        }
+        else {
+            const plain = `ejecuta ${lineas} líneas de Python`;
+            add(plain, chalk.hex("#F59E0B")(plain));
+        }
+    }
+    else if (typeof args.sourcePath === "string") {
+        // move_copy_file no trae `path` ni `outputPath`, asi que caia en el caso de
+        // abajo y el dialogo pedia aprobar la palabra "move_copy_file" a secas. Lo
+        // que hay que ver aqui es justo lo contrario: que archivo se pisa.
+        add(args.sourcePath, chalk.bold.white(args.sourcePath));
+        const destino = String(args.destinationPath ?? "");
+        add(`-> ${destino}`, `${chalk.gray("->")} ${chalk.bold.white(destino)}`);
+        if (args.overwrite === true) {
+            const aviso = "el destino ya existe y su contenido se pierde";
+            add(aviso, chalk.hex("#EF4444")(aviso));
+        }
+    }
     else if (typeof args.action === "string") {
-        const extra = args.url || args.appName || args.window || args.text || "";
+        // Sobre QUE actua importa tanto como la accion. Un "close_tab" a secas no
+        // decia que pestana moria, asi que aprobarlo era aprobar a ciegas.
+        const objetivo = args.url || args.appName || args.window || args.text ||
+            (typeof args.tabId === "number" ? `pestaña ${args.tabId}` : "") ||
+            (typeof args.ref === "number" ? `elemento [${args.ref}]` : "") ||
+            "";
+        const extra = objetivo || (esNavegador(toolName) ? "en la pestaña de trabajo" : "");
         const plain = extra ? `${args.action}  ${String(extra)}` : String(args.action);
         add(plain, extra ? `${chalk.bold.white(args.action)}  ${chalk.gray(String(extra))}` : chalk.bold.white(args.action));
     }
     else {
         add(toolName, chalk.bold.white(toolName));
     }
+    // Una ruta larga se lee igual venga de donde venga: "C:\Users\yo\proyecto\src"
+    // y "C:\Windows\System32" ocupan lo mismo en el marco. Este es justo el
+    // dialogo que se aprueba de un vistazo, asi que el motivo por el que aparece
+    // va escrito con letras.
+    if ([args.path, args.outputPath, args.sourcePath, args.destinationPath].some((r) => isOutsideProject(cwd, r))) {
+        const aviso = "fuera del proyecto";
+        add(aviso, chalk.hex("#EF4444")(aviso));
+    }
     out.push({ text: "", length: 0 });
     return out;
 }

package/dist/ui/prompt.d.ts

@@ -1,7 +1,47 @@
+/**
+ * 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>;