chocolatito-code 1.1.0 → 1.3.0

package/dist/tools/toolDefsComputer.js

@@ -82,7 +82,10 @@ export const COMPUTER_USE_TOOL = {
             "REGLA DE ORO: nunca hagas clic en una coordenada que no te haya dado antes una herramienta. " +
             "FLUJO CORRECTO: 'list_windows' para saber que hay abierto -> 'ui_snapshot' con la ventana objetivo para listar sus controles reales -> " +
             "'ui_click' / 'ui_type' con el numero de ref. Eso actua en segundo plano, sin mover el raton ni robar el foco al usuario. " +
-            "Solo si el arbol de accesibilidad no ve el control (lienzos, juegos, imagenes) recurre a 'screenshot' con 'window' y luego a 'find_element'. " +
+            "CUANTO CUESTA CADA COSA, que decide cual usar: ui_snapshot tarda unos 40 ms y te devuelve texto que entiendes directo. "
+            + "screenshot cuesta una llamada entera a otro modelo -varios segundos- mas los tokens de la imagen. "
+            + "O sea que screenshot es unas cien veces mas caro. Usalo SOLO cuando el arbol de accesibilidad no vea el control: lienzos, juegos, imagenes, interfaces dibujadas a mano. "
+            + "Para todo lo demas, ui_snapshot y luego find_element. " +
             "Las coordenadas siempre son pixeles fisicos de pantalla.",
         parameters: {
             type: "object",
@@ -109,6 +112,7 @@ export const COMPUTER_USE_TOOL = {
                         "type",
                         "key",
                         "wait",
+                        "wait_change",
                         "cursor_position",
                         "focus_window",
                         "get_active_window",
@@ -116,7 +120,7 @@ export const COMPUTER_USE_TOOL = {
                     ],
                     description: "list_windows: inventario de ventanas. ui_snapshot: lista los controles reales de una ventana con su ref. " +
                         "ui_click/ui_type/ui_focus: actuan sobre un ref sin tocar el raton. find_element: busca un control por texto y, si hace falta, lo localiza con vision. " +
-                        "screenshot: captura una ventana concreta (aunque este tapada) y la describe. click/type/key: entrada real, solo como ultimo recurso.",
+                        "wait_change: se suscribe a la ventana y vuelve EN CUANTO cambia algo, con el estado nuevo. Usalo en vez de wait siempre que esperes una reaccion: wait duerme un tiempo fijo (corto si la app tarda, desperdiciado si no). " + "screenshot: captura una ventana concreta (aunque este tapada) y la describe con otro modelo; lento y caro, ultimo recurso para lo que el arbol no ve. click/type/key: entrada real, solo como ultimo recurso.",
                 },
                 window: {
                     type: "string",

package/dist/tools/visionBridge.js

@@ -5,15 +5,72 @@ import { apuntarUso } from "../agent/usageMeter.js";
 function client(apiKey) {
     return createEngineClient(apiKey, "vision");
 }
-function toDataUrl(imagePath) {
+/**
+ * Cuanto puede pesar una imagen antes de que la peticion se muera por el camino.
+ *
+ * EL FALLO QUE CIERRA ESTO
+ *
+ * `toDataUrl` leia el archivo entero y lo metia en base64 sin mirar el tamano.
+ * Una captura de pantalla en PNG de un monitor normal son 1,3 MB, que en base64
+ * se convierten en 1,75 MB dentro del JSON de la peticion. Eso no llega: el
+ * Worker del proxy se queda sin margen a mitad de camino, la peticion muere sin
+ * respuesta, y ENCIMA se lleva por delante uno de los cuatro huecos de la
+ * licencia.
+ *
+ * Desde fuera se veia asi, y el usuario lo sufrio una tarde entera:
+ *
+ *     chrome(screenshot) → chrome_tab.png (1314.8 KB)
+ *     💭 penso 4s
+ *     ⚠ El motor no devolvio nada.
+ *     ...
+ *     ⏸ Tienes 4 peticiones en curso. Se libera en 169s.
+ *
+ * Cuatro capturas grandes y la licencia queda bloqueada tres minutos, sin que
+ * nada explique por que. Ahora se para ANTES de mandarla y se dice como
+ * arreglarlo, que cuesta lo mismo y no gasta un hueco.
+ *
+ * El limite no es caprichoso: 900 KB de base64 son ~675 KB de imagen, muy por
+ * encima de lo que ocupa una captura en JPEG (unos 120 KB) y muy por debajo de
+ * donde empiezan los problemas.
+ */
+const MAX_BASE64 = 900_000;
+/** El tipo real de la imagen, mirando sus primeros bytes y no su extension. */
+function tipoDeImagen(buf) {
+    if (buf.length > 3 && buf[0] === 0xff && buf[1] === 0xd8 && buf[2] === 0xff)
+        return "image/jpeg";
+    if (buf.length > 8 && buf[0] === 0x89 && buf[1] === 0x50)
+        return "image/png";
+    if (buf.length > 12 && buf.toString("ascii", 8, 12) === "WEBP")
+        return "image/webp";
+    // Se deja pasar como PNG: equivocarse aqui es un error del servidor, no un
+    // cuelgue silencioso.
+    return "image/png";
+}
+function prepararImagen(imagePath) {
     const buf = fs.readFileSync(imagePath);
-    return `data:image/png;base64,${buf.toString("base64")}`;
+    const b64 = buf.toString("base64");
+    if (b64.length > MAX_BASE64) {
+        const kb = Math.round(buf.length / 1024);
+        return {
+            ok: false,
+            error: `La imagen pesa ${kb} KB y no cabe en una peticion (el tope son ${Math.round(MAX_BASE64 / 1024)} KB de datos). ` +
+                `Mandarla igualmente no falla con un error: la peticion se muere por el camino, no vuelve nada, y se pierde ` +
+                `uno de los cuatro huecos de peticion durante minutos.\n\n` +
+                `Vuelve a capturar en JPEG, o recorta la zona que te interesa en vez de la pantalla entera.`,
+        };
+    }
+    return { ok: true, url: `data:${tipoDeImagen(buf)};base64,${b64}` };
 }
 async function ask(apiKey, prompt, imagePath, maxTokens) {
     if (!apiKey)
         return { ok: false, error: "No hay API key disponible para el modelo de vision." };
     if (!fs.existsSync(imagePath))
         return { ok: false, error: `No existe la imagen "${imagePath}".` };
+    // Se comprueba ANTES de gastar un hueco de peticion: una imagen demasiado
+    // grande no da error, mata la peticion en silencio. Ver prepararImagen().
+    const imagen = prepararImagen(imagePath);
+    if (!imagen.ok)
+        return { ok: false, error: imagen.error };
     try {
         const res = await client(apiKey).chat.completions.create({
             model: VISION_MODEL,
@@ -24,7 +81,7 @@ async function ask(apiKey, prompt, imagePath, maxTokens) {
                     role: "user",
                     content: [
                         { type: "text", text: prompt },
-                        { type: "image_url", image_url: { url: toDataUrl(imagePath) } },
+                        { type: "image_url", image_url: { url: imagen.url } },
                     ],
                 },
             ],

package/dist/tools/win/hostScript.js

@@ -518,6 +518,155 @@ public static class Choco
         return null;
     }
 
+    // Lo que el elemento dice SER AHORA MISMO, con el mismo formato que se
+    // guardo al hacer la foto. Si un elemento murio, aqui salta y se trata como
+    // cambio, que es lo correcto.
+    static string EtiquetaViva(AutomationElement e)
+    {
+        try { return RoleOf(e) + " " + (e.Current.Name == null ? "" : e.Current.Name); }
+        catch { return "(elemento muerto)"; }
+    }
+
+    // Un ref solo vale si sigue siendo lo que era.
+    //
+    // POR QUE
+    //
+    // ui_snapshot guarda los elementos en _snap y su etiqueta en _snapLabel, y
+    // hasta ahora _snapLabel solo servia para INFORMAR: nunca se comparaba. Pero
+    // entre mirar y actuar pasa tiempo, y las interfaces cambian solas -una
+    // lista que se refresca, un menu que se cierra, un dialogo que aparece-. El
+    // elemento guardado en el ref 3 sigue ahi, pero ya no es el boton que el
+    // modelo vio: es otro. Y se pulsa ese otro, sin que nada avise.
+    //
+    // Es la misma familia del fallo que ya mordio dos veces en el navegador
+    // (hallazgos #19 y #20): actuar sobre lo que habia antes creyendo que es lo
+    // de ahora. Alli se arreglo; aqui seguia abierto.
+    //
+    // Comparar la etiqueta cuesta una lectura y convierte un clic en el sitio
+    // equivocado -que el usuario descubre cuando ya se ha borrado algo- en un
+    // mensaje que el modelo puede resolver volviendo a mirar.
+    static string RefCambiado(int id)
+    {
+        AutomationElement e = Ref(id);
+        if (e == null) return "ref inexistente; repite ui_snapshot";
+
+        string antes;
+        if (!_snapLabel.TryGetValue(id, out antes)) return null;
+
+        string ahora = EtiquetaViva(e);
+        if (ahora == antes) return null;
+
+        if (ahora == "(elemento muerto)")
+        {
+            return "el elemento del ref " + N(id) + " (" + antes + ") ya no existe: la ventana cambio. Repite ui_snapshot.";
+        }
+        return "el ref " + N(id) + " ya no es lo que viste: era \"" + antes + "\" y ahora es \"" + ahora +
+               "\". Actuar sobre el seria pulsar otra cosa. Repite ui_snapshot y usa el numero nuevo.";
+    }
+
+    // ------------------------------------------------------------- esperar cambios
+    //
+    // Esperar a que la ventana haga algo, en vez de preguntarle cada tanto.
+    //
+    // POR QUE
+    //
+    // Hasta ahora, para saber si una accion habia surtido efecto se leia el arbol
+    // varias veces seguidas hasta que dos salieran iguales. Funciona, pero tiene
+    // dos costes: se lee el arbol entero N veces, y la respuesta llega en el
+    // siguiente sondeo, no cuando pasa la cosa. Con una ventana que tarda 40 ms en
+    // reaccionar y un sondeo cada 120, se pierden 80 ms de nada; con una que tarda
+    // 2 s, se leyo el arbol veinte veces para nada.
+    //
+    // UI Automation puede avisar. Aqui se suscribe a los cambios de la ventana, se
+    // espera bloqueado, y se vuelve en cuanto ocurre el primero.
+    //
+    // LO QUE HAY QUE HACER BIEN O NO HACERLO
+    //
+    // Los manejadores de UIA viven dentro del proceso de la aplicacion observada.
+    // Si se registran y no se quitan, esa aplicacion se queda mas lenta PARA
+    // SIEMPRE, hasta que el usuario la cierre. Por eso todo va dentro de un
+    // try/finally y se quitan pase lo que pase, incluido si salta una excepcion o
+    // se agota el tiempo.
+    //
+    // El evento llega en un hilo interno de UIA, no en este: por eso lo que se
+    // comparte es un ManualResetEventSlim y una cadena, y nada mas.
+    static string _cambioQue = "";
+    static readonly object _cambioLock = new object();
+
+    static void ApuntarCambio(string texto)
+    {
+        lock (_cambioLock) { if (_cambioQue.Length == 0) _cambioQue = texto; }
+    }
+
+    public static string WaitChange(IntPtr hwnd, int timeoutMs)
+    {
+        if (hwnd == IntPtr.Zero) return "{\"ok\":false,\"error\":\"ventana no encontrada\"}";
+        if (timeoutMs < 100) timeoutMs = 100;
+        if (timeoutMs > 30000) timeoutMs = 30000;
+
+        AutomationElement raiz;
+        try { raiz = AutomationElement.FromHandle(hwnd); }
+        catch (Exception ex) { return "{\"ok\":false,\"error\":" + Q(ex.Message) + "}"; }
+        if (raiz == null) return "{\"ok\":false,\"error\":\"la ventana no expone arbol de accesibilidad\"}";
+
+        lock (_cambioLock) { _cambioQue = ""; }
+        ManualResetEventSlim listo = new ManualResetEventSlim(false);
+
+        AutomationPropertyChangedEventHandler onProp = delegate(object src, AutomationPropertyChangedEventArgs e)
+        {
+            string prop = e.Property == ValuePattern.ValueProperty ? "valor"
+                        : e.Property == AutomationElement.NameProperty ? "nombre"
+                        : e.Property == AutomationElement.IsEnabledProperty ? "habilitado"
+                        : "propiedad";
+            string quien = "";
+            try { AutomationElement el = src as AutomationElement; if (el != null) quien = RoleOf(el) + " " + el.Current.Name; }
+            catch { quien = "un control"; }
+            ApuntarCambio("cambio el " + prop + " de " + quien);
+            listo.Set();
+        };
+
+        StructureChangedEventHandler onStruct = delegate(object src, StructureChangedEventArgs e)
+        {
+            ApuntarCambio("la ventana anadio o quito controles");
+            listo.Set();
+        };
+
+        bool propOk = false, structOk = false;
+        try
+        {
+            AutomationProperty[] props = new AutomationProperty[] {
+                ValuePattern.ValueProperty,
+                AutomationElement.NameProperty,
+                AutomationElement.IsEnabledProperty
+            };
+            try { Automation.AddAutomationPropertyChangedEventHandler(raiz, TreeScope.Subtree, onProp, props); propOk = true; } catch { }
+            try { Automation.AddStructureChangedEventHandler(raiz, TreeScope.Subtree, onStruct); structOk = true; } catch { }
+
+            if (!propOk && !structOk)
+            {
+                return "{\"ok\":false,\"error\":\"esta ventana no admite avisos de cambio; usa ui_snapshot para mirar\"}";
+            }
+
+            bool paso = listo.Wait(timeoutMs);
+            string que;
+            lock (_cambioLock) { que = _cambioQue; }
+
+            if (!paso)
+            {
+                return "{\"ok\":true,\"changed\":false,\"waited\":" + N(timeoutMs) + "}";
+            }
+            return "{\"ok\":true,\"changed\":true,\"what\":" + Q(que.Length > 0 ? que : "algo cambio") + "}";
+        }
+        finally
+        {
+            // Sin esto, la aplicacion observada se queda mas lenta hasta que el
+            // usuario la cierre. Se quitan siempre, aunque haya saltado todo.
+            if (propOk) { try { Automation.RemoveAutomationPropertyChangedEventHandler(raiz, onProp); } catch { } }
+            if (structOk) { try { Automation.RemoveStructureChangedEventHandler(raiz, onStruct); } catch { } }
+            listo.Dispose();
+        }
+    }
+
     public static string RefRect(int id)
     {
         AutomationElement e = Ref(id);
@@ -537,6 +686,8 @@ public static class Choco
     {
         AutomationElement e = Ref(id);
         if (e == null) return "{\"ok\":false,\"error\":\"ref inexistente; repite ui_snapshot\"}";
+        string cambio = RefCambiado(id);
+        if (cambio != null) return "{\"ok\":false,\"error\":" + Q(cambio) + "}";
         string label = _snapLabel.ContainsKey(id) ? _snapLabel[id] : ("ref " + N(id));
         try
         {
@@ -555,6 +706,8 @@ public static class Choco
     {
         AutomationElement e = Ref(id);
         if (e == null) return "{\"ok\":false,\"error\":\"ref inexistente; repite ui_snapshot\"}";
+        string cambio = RefCambiado(id);
+        if (cambio != null) return "{\"ok\":false,\"error\":" + Q(cambio) + "}";
         try
         {
             // ValuePattern.SetValue SUSTITUYE todo el contenido del control. En un
@@ -902,6 +1055,7 @@ while ($true) {
       'ui_snapshot' {
         $res = [Choco]::Snapshot((Resolve-Hwnd $cmd), [int](Get-Prop $cmd 'max' 250), [string](Get-Prop $cmd 'filter' ''), [bool](Get-Prop $cmd 'interactiveOnly' $true))
       }
+      'wait_change'   { $res = [Choco]::WaitChange((Resolve-Hwnd $cmd), [int](Get-Prop $cmd 'timeoutMs' 3000)) }
       'ui_click'      { $res = [Choco]::RefInvoke([int](Get-Prop $cmd 'ref' 0)) }
       'ui_set_value'  { $res = [Choco]::RefSetValue([int](Get-Prop $cmd 'ref' 0), [string](Get-Prop $cmd 'text' ''), [bool](Get-Prop $cmd 'replace' $false)) }
       'ui_focus'      { $res = [Choco]::RefFocus([int](Get-Prop $cmd 'ref' 0)) }

package/dist/tools/writeFile.d.ts

@@ -1 +1,16 @@
-export declare function writeFile(filePath: string, content: string, cwd?: string): Promise<string>;
+/**
+ * Escribe un archivo, entero o por partes.
+ *
+ * POR QUE EXISTE "anadir"
+ *
+ * La respuesta del modelo tiene un techo de salida. Cuando le piden una pagina
+ * entera, el contenido no cabe, la respuesta se corta a mitad de los argumentos
+ * y no se escribe nada. Se le decia "hazlo en varias llamadas mas pequenas"...
+ * y no habia forma de hacerlo: write_file solo sabia sobrescribir, asi que la
+ * segunda llamada borraba la primera. Le pediamos algo imposible y luego le
+ * echabamos la culpa.
+ *
+ * Con `modo: "anadir"` la instruccion pasa a ser ejecutable: primera llamada
+ * con el principio, las siguientes anadiendo, y el archivo sale entero.
+ */
+export declare function writeFile(filePath: string, content: string, cwd?: string, modo?: "sobrescribir" | "anadir"): Promise<string>;

package/dist/tools/writeFile.js

@@ -1,7 +1,22 @@
 import fs from "node:fs";
 import path from "node:path";
 import { binaryExtensionLabel, fileLooksBinary } from "./binary.js";
-export async function writeFile(filePath, content, cwd = process.cwd()) {
+/**
+ * Escribe un archivo, entero o por partes.
+ *
+ * POR QUE EXISTE "anadir"
+ *
+ * La respuesta del modelo tiene un techo de salida. Cuando le piden una pagina
+ * entera, el contenido no cabe, la respuesta se corta a mitad de los argumentos
+ * y no se escribe nada. Se le decia "hazlo en varias llamadas mas pequenas"...
+ * y no habia forma de hacerlo: write_file solo sabia sobrescribir, asi que la
+ * segunda llamada borraba la primera. Le pediamos algo imposible y luego le
+ * echabamos la culpa.
+ *
+ * Con `modo: "anadir"` la instruccion pasa a ser ejecutable: primera llamada
+ * con el principio, las siguientes anadiendo, y el archivo sale entero.
+ */
+export async function writeFile(filePath, content, cwd = process.cwd(), modo = "sobrescribir") {
     const resolved = path.isAbsolute(filePath) ? filePath : path.resolve(cwd, filePath);
     const dir = path.dirname(resolved);
     const isNew = !fs.existsSync(resolved);
@@ -24,6 +39,12 @@ export async function writeFile(filePath, content, cwd = process.cwd()) {
     if (!fs.existsSync(dir)) {
         fs.mkdirSync(dir, { recursive: true });
     }
+    if (modo === "anadir") {
+        fs.appendFileSync(resolved, content, "utf-8");
+        const total = fs.statSync(resolved).size;
+        return (`✔ Anadido a "${filePath}" (${content.length} caracteres nuevos, ${total} en total). ` +
+            `Sigue con otra llamada en modo "anadir" si falta contenido.`);
+    }
     fs.writeFileSync(resolved, content, "utf-8");
     const action = isNew ? "creado" : "sobreescrito";
     return `✔ Archivo "${filePath}" ${action} exitosamente (${content.length} caracteres).`;

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,8 @@ 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.
  *
@@ -68,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;
@@ -112,7 +142,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
@@ -130,7 +160,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;
             }
@@ -163,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;
@@ -175,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/keyboardGuard.d.ts

@@ -53,3 +53,24 @@ export interface EntradaDeTeclado {
 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

@@ -49,7 +49,7 @@ export function repararTeclado(entrada) {
         return [];
     const reparado = [];
     if (entrada.isRaw !== true) {
-        entrada.setRawMode(true);
+        reafirmarModoCrudo(entrada);
         reparado.push("modo crudo");
     }
     // `pause()` corta el flujo sin avisar a nadie: el oyente de `keypress` sigue
@@ -63,3 +63,32 @@ export function repararTeclado(entrada) {
 }
 /** 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/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;