chocolatito-code 1.1.0 → 1.2.0

package/README.md

@@ -85,6 +85,55 @@ Si repite tres veces la misma llamada con el mismo resultado, se para y pregunta
 seguir, o le dices que cambie de enfoque. Sin terminal (CI, `chocolatito "haz X"`) se corta
 solo, para que un bucle que nadie está mirando no se coma la cuota.
 
+## 🧩 VSCode
+
+Si tienes la extensión instalada y abres `chocolatito` en la terminal integrada, **se conecta
+solo**. No hay nada que configurar.
+
+El truco está al revés de lo que parece: la extensión es un **servidor MCP** y el agente es el
+cliente. Cada ventana de VSCode levanta un servidor en `127.0.0.1` y deja una ficha en
+`~/.chocolatito/ide/` con su puerto, su token y la carpeta que tiene abierta. El agente busca la
+ficha cuya carpeta contiene su directorio de trabajo.
+
+Lo que gana el agente (lo único que no puede tener por su cuenta):
+
+| Herramienta | Para qué |
+| --- | --- |
+| `diagnosticos` | Los errores del servidor de lenguaje. Los subrayados rojos, sin esperar a compilar. |
+| `seleccion_actual` | Qué archivo tienes abierto y qué has seleccionado. Hace que «arregla esto» signifique algo. |
+| `archivos_abiertos` | Las pestañas abiertas, en orden. |
+| `mostrar_diff` | Abre el visor de diferencias nativo. No escribe nada: es para que lo veas antes. |
+
+**Con varias ventanas abiertas se elige la correcta**, no la primera: gana la carpeta más
+específica que contenga el directorio de trabajo, y si ninguna lo contiene **no se conecta a
+nada**. Conectarse a la ventana de otro proyecto sería peor que no conectarse: los diffs saldrían
+en el sitio equivocado.
+
+El servidor escucha solo en `127.0.0.1` y exige un token de 32 bytes que va en la ficha, dentro de
+tu carpeta personal. Sin eso, cualquier programa de la máquina podría manejar tu editor.
+
+Para apagarlo: `CHOCOLATITO_SIN_EDITOR=1`, o la opción `chocolatito.puente` en VSCode.
+
+### Instalarla
+
+Mientras no esté en el marketplace, se instala desde el paquete:
+
+```bash
+cd extension-vscode
+npx @vscode/vsce package --allow-missing-repository --skip-license
+code --install-extension chocolatito-code-vscode-0.1.1.vsix
+```
+
+**Con VSCode cerrado**, y reiniciándolo después. Copiar la carpeta a mano a `~/.vscode/extensions`
+**no funciona**: falta el `.vsixmanifest` y VSCode la lista pero no la carga nunca, sin dar ningún
+error. Para desarrollar, `F5` sobre la carpeta abre una ventana con la extensión cargada al vuelo.
+
+En la barra de estado, abajo a la derecha, pone **Chocolatito** con el estado del puente. Si algo
+falla —sin carpeta abierta, puente apagado, puerto ocupado— lo dice ahí, y al pulsarlo se abre el
+detalle.
+
+---
+
 ## 🔌 MCP (Model Context Protocol)
 
 Conecta cualquier servidor MCP y sus herramientas quedan disponibles para el agente.
@@ -141,6 +190,23 @@ solo lectura de verdad: ni comandos, ni clics, ni escrituras.
 
 `--yes` aprueba todo sin preguntar: es para CI, no para el día a día.
 
+## 📋 Pegar texto largo
+
+Pegar un log de 300 líneas ya no mete 300 líneas en el recuadro. Se guarda aparte y en el prompt
+queda una marca corta:
+
+```
+❯ arregla esto [pegado #1 · 347 lineas]
+```
+
+**El modelo recibe el texto entero**, no la marca: al enviar se sustituye por lo que pegaste. Y un
+solo `backspace` con el cursor detrás de la marca se la lleva completa — lo que ocupa una línea se
+borra como una línea.
+
+Por debajo de 5 líneas o 400 caracteres se pega normal, entero y a la vista.
+
+---
+
 ## ⌨️ Escribir mientras trabaja
 
 No hace falta esperar a que termine. Lo que escribas durante una generación aparece bajo

package/dist/agent/loop.js

@@ -15,6 +15,7 @@ import { PermissionManager, commandSignature, isDangerousCommand } from "../conf
 import { askToolPermission } from "../ui/permissionPrompt.js";
 import { DynamicSpinner } from "../ui/spinner.js";
 import { globalUndoManager } from "./undoManager.js";
+import { salida } from "./salidaDelAgente.js";
 import { InterruptWatcher, isAbortError } from "../ui/interrupt.js";
 import { HookManager } from "../hooks/manager.js";
 import { registerToolGate, autorizarHerramienta, notificarPostHerramienta } from "./toolGate.js";
@@ -33,6 +34,15 @@ const HERRAMIENTAS_QUE_ESCRIBEN = new Set([
 ]);
 /** Cortes por longitud seguidos que se toleran antes de rendirse. */
 const MAX_CORTES_POR_LONGITUD = 2;
+/**
+ * Respuestas vacias seguidas que se toleran antes de rendirse.
+ *
+ * Dos, no una: una respuesta vacia suelta es casi siempre un hipo del motor y
+ * el reintento la resuelve sin que el usuario se entere. Tres seguidas ya no es
+ * un hipo, y seguir reintentando en silencio es lo que hacia que pareciera que
+ * el agente te ignora.
+ */
+const MAX_RESPUESTAS_VACIAS = 1;
 /** Mensajes recientes que la compactacion no resume nunca. */
 const COLA_INTACTA = 4;
 /**
@@ -66,8 +76,43 @@ function parsearArgumentos(bruto) {
 /** Lo que se le dice al modelo cuando sus argumentos llegaron a medias. */
 function mensajeDeArgumentosRotos(herramienta) {
     return (`No se ejecuto "${herramienta}": los argumentos llegaron incompletos, seguramente porque la ` +
-        `respuesta se corto por longitud. No se ha hecho nada. Vuelve a pedirlo, y si el contenido es ` +
-        `largo, escribelo en varias llamadas mas pequenas en vez de una sola.`);
+        `respuesta se corto por longitud. No se ha hecho nada.
+
+` +
+        `Si era un archivo largo, hazlo por partes: una primera llamada a write_file con el principio ` +
+        `y las siguientes con modo="anadir" para ir pegando el resto. Cada trozo, por debajo de unas ` +
+        `400 lineas.`);
+}
+/**
+ * Deja una llamada a herramienta en un estado que la API acepte.
+ *
+ * EL FALLO QUE CIERRA ESTO
+ *
+ * Cuando la respuesta se corta a mitad de un `write_file` con un HTML largo
+ * dentro, los argumentos llegan asi:
+ *
+ *     {"path":"index.html","content":"<!doctype html><html><head><style>body{ma
+ *
+ * La herramienta ya no se ejecutaba -eso se arreglo antes-, pero la llamada se
+ * guardaba en el historial TAL CUAL, y el historial se reenvia entero en cada
+ * peticion. La API valida que los argumentos sean JSON, no lo son, y contesta
+ * 400. Desde ese momento la sesion queda inservible: todo lo que escriba el
+ * usuario falla igual, la unica salida es /clear, y nadie lo sabe.
+ *
+ * Se vio en una sesion real, y encima el 400 se llevo por delante los cuatro
+ * huecos de peticion de la licencia, asi que al fallo se le sumo un "Tienes 4
+ * peticiones en curso" de dos minutos y medio.
+ *
+ * Guardando "{}" el historial sigue siendo valido y la pareja llamada/respuesta
+ * cuadra. Al modelo no se le oculta nada: el resultado de esa herramienta ya le
+ * dice que sus argumentos llegaron a medias y que no se hizo nada.
+ */
+function sanearLlamada(tc) {
+    const bruto = tc?.function?.arguments;
+    const texto = typeof bruto === "string" ? bruto.trim() : "";
+    if (texto && parsearArgumentos(texto).ok)
+        return tc;
+    return { ...tc, function: { ...tc.function, arguments: "{}" } };
 }
 export class AgentLoop {
     client;
@@ -223,7 +268,7 @@ export class AgentLoop {
             const proyectado = antes > 0 ? Math.round(tokensActuales * (despues / antes)) : tokensActuales;
             this.lastTurnTokens = proyectado;
             if (proyectado < COMPACT_THRESHOLD_TOKENS * 0.8) {
-                console.log(chalk.hex("#D97757")("\n⚡ [Auto-Compact]: ") +
+                salida.linea(chalk.hex("#D97757")("\n⚡ [Auto-Compact]: ") +
                     chalk.gray(`Liberados ~${(antes - despues).toLocaleString()} tokens de salidas de herramientas antiguas. ` +
                         "La conversacion se conserva entera.\n"));
                 return true;
@@ -278,7 +323,7 @@ export class AgentLoop {
             // Queda una estimacion hasta la siguiente respuesta de la API: mejor eso
             // que arrastrar la cifra vieja, que dispararia otra compactacion seguida.
             this.lastTurnTokens = estimarTokens(this.messages);
-            console.log(chalk.hex("#D97757")("\n⚡ [Auto-Compact]: ") +
+            salida.linea(chalk.hex("#D97757")("\n⚡ [Auto-Compact]: ") +
                 chalk.gray(`Contexto optimizado automáticamente (${this.messages.length} mensajes limpios) para mantener alta velocidad y mínimo consumo de API.\n`));
             return true;
         }
@@ -286,7 +331,7 @@ export class AgentLoop {
             spinner.stop();
             // El catch mudo era medio fallo: si el resumen no sale, el turno sigue con
             // el contexto entero y el error de despues llega sin explicacion.
-            console.log(chalk.gray(`  (no se pudo compactar el contexto: ${err?.message || String(err)})`));
+            salida.linea(chalk.gray(`  (no se pudo compactar el contexto: ${err?.message || String(err)})`));
             return false;
         }
     }
@@ -307,7 +352,7 @@ export class AgentLoop {
         if (!cmd)
             return null;
         if (reflexiones >= MAX_REFLEXIONES) {
-            console.log(chalk.yellow(`\n⚠ ${mensajeDeRendicion(cmd.comando)}\n`));
+            salida.linea(chalk.yellow(`\n⚠ ${mensajeDeRendicion(cmd.comando)}\n`));
             return null;
         }
         const spinner = new DynamicSpinner();
@@ -320,13 +365,13 @@ export class AgentLoop {
             spinner.stop();
         }
         if (resultado.ok) {
-            console.log(chalk.gray(`  ✔ Verificado con ${cmd.comando}\n`));
+            salida.linea(chalk.gray(`  ✔ Verificado con ${cmd.comando}\n`));
             // Lo verificado deja de estar pendiente: si el modelo vuelve a editar,
             // se vuelve a comprobar; si no, no se comprueba dos veces lo mismo.
             this.archivosTocados.clear();
             return null;
         }
-        console.log(chalk.yellow(`\n⚠ La verificacion fallo (${cmd.comando}). Se lo devuelvo al agente.\n`));
+        salida.linea(chalk.yellow(`\n⚠ La verificacion fallo (${cmd.comando}). Se lo devuelvo al agente.\n`));
         return mensajeDeVerificacion(cmd.comando, resultado.salida, reflexiones + 1);
     }
     /**
@@ -415,7 +460,7 @@ export class AgentLoop {
         const cuota = checkQuota();
         if (!cuota.allowed) {
             const corte = mensajeDeCorte(cuota);
-            console.log(chalk.yellow(`\n⏸  ${corte}`) +
+            salida.linea(chalk.yellow(`\n⏸  ${corte}`) +
                 chalk.gray("\n   Tu trabajo y tu contexto siguen aqui: al liberarse, continuas donde lo dejaste.\n"));
             return parada("cuota", corte);
         }
@@ -438,6 +483,8 @@ export class AgentLoop {
         let reflexiones = 0;
         /** Veces seguidas que la respuesta se corto por longitud sin hacer nada. */
         let cortesPorLongitud = 0;
+        /** Veces seguidas que el turno acabo sin una sola letra que ensenar. */
+        let respuestasVacias = 0;
         // Se limpia aqui: lo que se edito en el turno anterior ya se verifico (o no
         // se iba a verificar nunca).
         this.archivosTocados.clear();
@@ -479,7 +526,7 @@ export class AgentLoop {
                 }, { signal }), {
                     onRetry: (attempt, delay, reason) => {
                         spinner.stop();
-                        console.log(chalk.yellow(`\n⟳ El motor respondio ${reason}. Reintento ${attempt} en ${(delay / 1000).toFixed(1)}s...`));
+                        salida.linea(chalk.yellow(`\n⟳ El motor respondio ${reason}. Reintento ${attempt} en ${(delay / 1000).toFixed(1)}s...`));
                         spinner.start();
                     },
                 });
@@ -488,7 +535,7 @@ export class AgentLoop {
                 spinner.stop();
                 watcher.stop();
                 if (isAbortError(err) || watcher.interrupted) {
-                    console.log(chalk.yellow("\n⏸  Interrumpido. Dime como seguir."));
+                    salida.linea(chalk.yellow("\n⏸  Interrumpido. Dime como seguir."));
                     return parada("interrumpido");
                 }
                 // El contexto no cabe. Reintentar la misma peticion es imposible por
@@ -497,7 +544,7 @@ export class AgentLoop {
                 // sola vez: si tras compactar sigue sin caber, el problema es otro.
                 if (isContextOverflow(err) && !yaCompactadoPorDesbordamiento) {
                     yaCompactadoPorDesbordamiento = true;
-                    console.log(chalk.yellow("\n⚠ La peticion no cabia en el contexto. Compactando y reintentando..."));
+                    salida.linea(chalk.yellow("\n⚠ La peticion no cabia en el contexto. Compactando y reintentando..."));
                     const activo = this.messages[0]?.role === "system" ? this.messages[0].content : "";
                     await this.compactHistory(activo);
                     iterations--; // este intento no llego al modelo: no cuenta como vuelta
@@ -508,8 +555,8 @@ export class AgentLoop {
                 // hace que el usuario piense que el producto esta roto.
                 const claro = explicarErrorDelMotor(err);
                 if (claro) {
-                    console.log(chalk.yellow(`
-⏸  ${claro}
+                    salida.linea(chalk.yellow(`
+⏸  ${claro}
 `));
                     return parada(motivoDeParadaDelError(err), claro);
                 }
@@ -589,13 +636,13 @@ export class AgentLoop {
                     if (content.trim()) {
                         this.messages.push({ role: "assistant", content });
                     }
-                    console.log(chalk.yellow("\n⏸  Interrumpido. Dime como seguir."));
+                    salida.linea(chalk.yellow("\n⏸  Interrumpido. Dime como seguir."));
                     return parada("interrumpido");
                 }
                 const claroStream = explicarErrorDelMotor(streamErr);
                 if (claroStream) {
-                    console.log(chalk.yellow(`
-⏸  ${claroStream}
+                    salida.linea(chalk.yellow(`
+⏸  ${claroStream}
 `));
                     return parada(motivoDeParadaDelError(streamErr), claroStream);
                 }
@@ -610,7 +657,7 @@ export class AgentLoop {
                 watcher.stop();
                 if (content.trim())
                     this.messages.push({ role: "assistant", content });
-                console.log(chalk.yellow("\n⏸  Interrumpido antes de ejecutar las herramientas. Dime como seguir."));
+                salida.linea(chalk.yellow("\n⏸  Interrumpido antes de ejecutar las herramientas. Dime como seguir."));
                 return parada("interrumpido");
             }
             // Filter valid accumulated tool calls
@@ -630,19 +677,20 @@ export class AgentLoop {
                 if (cortesPorLongitud > MAX_CORTES_POR_LONGITUD) {
                     const aviso = `La respuesta se corto por longitud ${cortesPorLongitud} veces seguidas sin llegar a ` +
                         `hacer nada. Prueba a pedirlo por partes.`;
-                    console.log(chalk.yellow(`\n  ⚠ ${aviso}\n`));
+                    salida.linea(chalk.yellow(`\n  ⚠ ${aviso}\n`));
                     if (content.trim())
                         this.messages.push({ role: "assistant", content });
                     return parada("limite-iteraciones", aviso);
                 }
-                console.log(chalk.yellow("\n  ⚠ La respuesta se corto por longitud antes de hacer nada. Pidiendole que vaya al grano...\n"));
+                salida.linea(chalk.yellow("\n  ⚠ La respuesta se corto por longitud antes de hacer nada. Pidiendole que vaya al grano...\n"));
                 if (content.trim())
                     this.messages.push({ role: "assistant", content });
                 this.messages.push({
                     role: "user",
                     content: "Tu respuesta anterior se corto porque agoto el presupuesto de salida mientras razonabas, " +
                         "y no llegaste a usar ninguna herramienta: no se ha hecho nada todavia. Deja de planificar " +
-                        "y actua ya. Si lo que hay que escribir es largo, hazlo en varias llamadas mas pequenas.",
+                        "y actua ya. Si lo que hay que escribir es largo, empieza con write_file y sigue con " +
+                        'write_file en modo="anadir", en trozos de menos de 400 lineas.',
                 });
                 // Sin esto se queda un vigilante de teclado vivo por cada corte, y cada
                 // uno vuelve a apuntarse como oyente: la misma tecla se procesa tantas
@@ -655,7 +703,10 @@ export class AgentLoop {
                 this.messages.push({
                     role: "assistant",
                     content: content || null,
-                    tool_calls: toolCalls,
+                    // Sanear NO es cosmetico: unos argumentos cortados guardados tal cual
+                    // hacen que la API conteste 400 en TODAS las peticiones siguientes, y
+                    // la sesion queda inservible hasta un /clear. Ver sanearLlamada().
+                    tool_calls: toolCalls.map(sanearLlamada),
                 });
                 const toolResults = [];
                 // Las llamadas independientes de solo lectura se lanzan a la vez. Cuando
@@ -733,7 +784,7 @@ export class AgentLoop {
                     toolResults.forEach((r) => this.messages.push(r));
                     watcher.stop();
                     if (watcher.interrupted) {
-                        console.log(chalk.yellow("\n⏸  Interrumpido. Dime como seguir."));
+                        salida.linea(chalk.yellow("\n⏸  Interrumpido. Dime como seguir."));
                         return parada("interrumpido");
                     }
                     continue;
@@ -781,7 +832,7 @@ export class AgentLoop {
                         fnArgs = { ...fnArgs, ...pre.updatedInput };
                     }
                     if (pre.systemMessage) {
-                        console.log(chalk.yellow(`\n⚑ ${pre.systemMessage}`));
+                        salida.linea(chalk.yellow(`\n⚑ ${pre.systemMessage}`));
                     }
                     // Modo plan: bloqueo duro, no un dialogo. Lo que el modo promete es
                     // solo lectura, asi que aqui no hay nada que preguntar.
@@ -848,7 +899,7 @@ export class AgentLoop {
                     // El systemMessage de PreToolUse si se imprimia y el de PostToolUse
                     // no: el mismo campo, del mismo hook, se veia o no segun el evento.
                     if (post.systemMessage) {
-                        console.log(chalk.yellow(`\n⚑ ${post.systemMessage}`));
+                        salida.linea(chalk.yellow(`\n⚑ ${post.systemMessage}`));
                     }
                     // El dialogo del bucle usa stdin, igual que el de permisos: hay que
                     // soltarle el terminal al vigilante de Esc. Pero solo si de verdad se
@@ -859,7 +910,7 @@ export class AgentLoop {
                     toolResults.push({
                         role: "tool",
                         tool_call_id: tc.id,
-                        content: post.additionalContext ? `${texto}\n\n
+                        content: post.additionalContext ? `${texto}\n\n
 [Hook PostToolUse]: ${post.additionalContext}` : texto,
                     });
                 }
@@ -867,20 +918,62 @@ export class AgentLoop {
                 toolResults.forEach((r) => this.messages.push(r));
                 watcher.stop();
                 if (watcher.interrupted) {
-                    console.log(chalk.yellow("\n⏸  Interrumpido. Dime como seguir."));
+                    salida.linea(chalk.yellow("\n⏸  Interrumpido. Dime como seguir."));
                     return parada("interrumpido");
                 }
                 continue;
             }
             watcher.stop();
-            // If text content was printed, ensure newline and record assistant message
-            if (content.trim()) {
-                process.stdout.write("\n\n");
+            // EL TURNO ACABA SIN UNA SOLA LETRA QUE ENSENAR
+            //
+            // Salio de un caso real: cuatro ordenes seguidas ("puedes conectarte a mi
+            // vscode?", "si?", "puedes?", "a mi vscode") contestadas todas con esto:
+            //
+            //     💭 penso 1s
+            //     ⚡ 4.8s · 0 tokens salida · $0.00000 USD · 100% contexto libre
+            //
+            // Ni un caracter en pantalla, ni un error, ni un aviso. Desde fuera es
+            // identico a que el agente te ignore, y el usuario reescribe la orden
+            // pensando que no llego. Encima cada una de esas cuatro se llevo por
+            // delante un hueco de peticion en el proxy, asi que la quinta choco con
+            // "Tienes 4 peticiones en curso": el silencio no solo confunde, ademas
+            // deja al usuario sin servicio.
+            //
+            // Es el mismo agujero que el corte por longitud, en su otra cara: el
+            // codigo no distingue "el modelo termino" de "no vino nada". Sin
+            // herramientas y sin texto, el bucle daba el turno por hecho, imprimia el
+            // pie y volvia al prompt.
+            if (!content.trim()) {
+                respuestasVacias++;
+                // Se reintenta UNA vez, no mas, y aqui la moderacion importa: cada
+                // intento consume un hueco de peticion de la licencia, y solo hay
+                // cuatro. Insistir con un motor que no contesta es la forma mas rapida
+                // de quedarse sin ninguno.
+                if (respuestasVacias > MAX_RESPUESTAS_VACIAS) {
+                    const aviso = `El motor devolvio ${respuestasVacias} respuestas vacias seguidas. ` +
+                        "No es tu conexion ni tu orden: no esta llegando nada del modelo. " +
+                        "Espera un momento y reintenta, o /clear si venias de una conversacion larga.";
+                    salida.linea(chalk.yellow(`\n  ⚠ ${aviso}\n`));
+                    return parada("error-motor", aviso);
+                }
+                salida.linea(chalk.gray("\n  ⚠ El motor no devolvio nada. Reintentando una vez…\n"));
                 this.messages.push({
-                    role: "assistant",
-                    content,
+                    role: "user",
+                    content: "Tu respuesta anterior llego vacia: ni texto ni llamadas a herramienta. " +
+                        "El usuario no ha visto absolutamente nada. Contesta a lo que te pidio, " +
+                        "aunque sea para decir que no puedes hacerlo o que no lo has entendido.",
                 });
+                continue;
             }
+            // Una respuesta con contenido cierra la racha: lo que cuenta son las
+            // vacias SEGUIDAS, no las de toda la sesion.
+            respuestasVacias = 0;
+            // If text content was printed, ensure newline and record assistant message
+            salida.crudo("\n\n");
+            this.messages.push({
+                role: "assistant",
+                content,
+            });
             // El modelo da el turno por cerrado. Si toco archivos y el proyecto tiene
             // verificacion automatica activada, se comprueba ANTES de creerselo: un
             // error de tipos que nadie mira se queda en el disco y los turnos
@@ -914,19 +1007,19 @@ export class AgentLoop {
         const tras = checkQuota();
         renderFooter(formattedCost, turnCompletionTokens, turnCachedTokens, this.currentEspectro.name, durationMs, contextPercent, quotaBadge(tras));
         if (auxiliar.total > 0) {
-            console.log(chalk.gray(`  + $${auxiliar.total.toFixed(4)} USD fuera del bucle (${auxiliar.rutas}), ya contados en la cuota.\n`));
+            salida.linea(chalk.gray(`  + $${auxiliar.total.toFixed(4)} USD fuera del bucle (${auxiliar.rutas}), ya contados en la cuota.\n`));
         }
         // Aviso al acercarse, no solo al chocar: quedarse a medias sin previo aviso
         // es lo que hace que la gente cancele.
         if (tras.allowed && tras.spentWeekUsd >= tras.config.weeklyBudgetUsd * 0.8) {
             const queda = Math.max(0, tras.config.weeklyBudgetUsd - tras.spentWeekUsd);
-            console.log(chalk.yellow(`  ⚠ Te queda poca cuota semanal (${((queda / tras.config.weeklyBudgetUsd) * 100).toFixed(0)}%).\n`));
+            salida.linea(chalk.yellow(`  ⚠ Te queda poca cuota semanal (${((queda / tras.config.weeklyBudgetUsd) * 100).toFixed(0)}%).\n`));
         }
         if (!completado) {
             // Se agotaron las iteraciones con trabajo a medias. En interactivo se ve
             // porque el ultimo mensaje queda cortado; en CI no lo ve nadie.
             const aviso = `El turno se agoto en el limite de ${this.maxIterations} iteraciones sin cerrar la tarea.`;
-            console.log(chalk.yellow(`  ⚠ ${aviso}\n`));
+            salida.linea(chalk.yellow(`  ⚠ ${aviso}\n`));
             return parada("limite-iteraciones", aviso);
         }
         return parada("completado");
@@ -948,7 +1041,7 @@ export class AgentLoop {
         const command = typeof fnArgs?.command === "string" ? fnArgs.command : "";
         if (command) {
             if (isDangerousCommand(command)) {
-                console.log(chalk.gray("  (este comando es destructivo: se seguira preguntando cada vez, no se puede recordar)\n"));
+                salida.linea(chalk.gray("  (este comando es destructivo: se seguira preguntando cada vez, no se puede recordar)\n"));
                 return;
             }
             const firma = commandSignature(command);

package/dist/agent/salidaDelAgente.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Por donde habla el bucle del agente.
+ *
+ * POR QUE
+ *
+ * El bucle escribia con `console.log` en diecisiete sitios. Mientras el unico
+ * sitio donde se ve al agente sea una terminal eso no molesta, pero ata el
+ * motor a su pantalla: para poner el agente en un panel de VSCode, en una web o
+ * en una app, hay que arrancarle esos diecisiete `console.log` uno a uno, y
+ * cada uno es una ocasion de romper algo.
+ *
+ * Con esto en medio, el bucle deja de saber donde acaba lo que dice. La
+ * terminal pasa a ser UNA implementacion, no LA implementacion.
+ *
+ * POR QUE RECIBE EL TEXTO YA COLOREADO
+ *
+ * Es a proposito, y es lo que hace que este cambio no pueda romper nada: lo que
+ * el bucle manda es exactamente la misma cadena que antes le pasaba a
+ * `console.log`, colores incluidos. La salida por terminal queda byte a byte
+ * igual que ayer, y las 538 pruebas siguen valiendo como red.
+ *
+ * Un panel que quiera pintarlo a su manera quita los codigos de color con
+ * `sinColores()` y se queda con el texto. Cuando haga falta distinguir un aviso
+ * de una nota, se anaden metodos con significado; hoy no hace falta y adivinarlo
+ * seria inventar trabajo.
+ */
+export interface SalidaDelAgente {
+    /** Un mensaje suelto, con su salto de linea al final. Equivale a console.log. */
+    linea(texto: string): void;
+    /** Escritura sin salto, para separar bloques. Equivale a process.stdout.write. */
+    crudo(texto: string): void;
+}
+/** Lo que usa el bucle. No sabe ni le importa quien esta al otro lado. */
+export declare const salida: SalidaDelAgente;
+/**
+ * Cambia a donde habla el agente. Con `null` vuelve a la terminal.
+ *
+ * Lo usara el panel de VSCode. Devolver siempre a la terminal al terminar: un
+ * agente que habla a un panel cerrado no habla con nadie.
+ */
+export declare function dirigirSalidaDelAgente(destino: SalidaDelAgente | null): void;
+/** Quita los codigos de color, para quien pinte el texto a su manera. */
+export declare function sinColores(texto: string): string;

package/dist/agent/salidaDelAgente.js

@@ -0,0 +1,53 @@
+/**
+ * Por donde habla el bucle del agente.
+ *
+ * POR QUE
+ *
+ * El bucle escribia con `console.log` en diecisiete sitios. Mientras el unico
+ * sitio donde se ve al agente sea una terminal eso no molesta, pero ata el
+ * motor a su pantalla: para poner el agente en un panel de VSCode, en una web o
+ * en una app, hay que arrancarle esos diecisiete `console.log` uno a uno, y
+ * cada uno es una ocasion de romper algo.
+ *
+ * Con esto en medio, el bucle deja de saber donde acaba lo que dice. La
+ * terminal pasa a ser UNA implementacion, no LA implementacion.
+ *
+ * POR QUE RECIBE EL TEXTO YA COLOREADO
+ *
+ * Es a proposito, y es lo que hace que este cambio no pueda romper nada: lo que
+ * el bucle manda es exactamente la misma cadena que antes le pasaba a
+ * `console.log`, colores incluidos. La salida por terminal queda byte a byte
+ * igual que ayer, y las 538 pruebas siguen valiendo como red.
+ *
+ * Un panel que quiera pintarlo a su manera quita los codigos de color con
+ * `sinColores()` y se queda con el texto. Cuando haga falta distinguir un aviso
+ * de una nota, se anaden metodos con significado; hoy no hace falta y adivinarlo
+ * seria inventar trabajo.
+ */
+const A_LA_TERMINAL = {
+    linea: (texto) => {
+        console.log(texto);
+    },
+    crudo: (texto) => {
+        process.stdout.write(texto);
+    },
+};
+let actual = A_LA_TERMINAL;
+/** Lo que usa el bucle. No sabe ni le importa quien esta al otro lado. */
+export const salida = {
+    linea: (texto) => actual.linea(texto),
+    crudo: (texto) => actual.crudo(texto),
+};
+/**
+ * Cambia a donde habla el agente. Con `null` vuelve a la terminal.
+ *
+ * Lo usara el panel de VSCode. Devolver siempre a la terminal al terminar: un
+ * agente que habla a un panel cerrado no habla con nadie.
+ */
+export function dirigirSalidaDelAgente(destino) {
+    actual = destino ?? A_LA_TERMINAL;
+}
+/** Quita los codigos de color, para quien pinte el texto a su manera. */
+export function sinColores(texto) {
+    return String(texto).replace(/\x1b\[[0-9;]*m/g, "");
+}

package/dist/config/nodeVersion.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Un Node viejo se dice claro, no se descubre a base de errores raros.
+ *
+ * `engines` en el package.json solo hace que npm suelte un aviso que nadie lee:
+ * la instalacion termina bien y el fallo aparece despues, al arrancar, con un
+ * "fetch is not defined" o un error de sintaxis dentro de una dependencia. El
+ * que acaba de pagar da por hecho que el producto esta roto, y no le falta
+ * razon desde donde el lo ve.
+ *
+ * Se comprueba antes que nada: antes de la licencia, antes de leer la
+ * configuracion y antes de importar nada que pueda reventar por esto mismo.
+ */
+export declare function comprobarNode(version?: string): string | null;

package/dist/config/nodeVersion.js

@@ -0,0 +1,26 @@
+/** La version de Node mas antigua con la que esto funciona. */
+const NODE_MINIMO = 20;
+/**
+ * Un Node viejo se dice claro, no se descubre a base de errores raros.
+ *
+ * `engines` en el package.json solo hace que npm suelte un aviso que nadie lee:
+ * la instalacion termina bien y el fallo aparece despues, al arrancar, con un
+ * "fetch is not defined" o un error de sintaxis dentro de una dependencia. El
+ * que acaba de pagar da por hecho que el producto esta roto, y no le falta
+ * razon desde donde el lo ve.
+ *
+ * Se comprueba antes que nada: antes de la licencia, antes de leer la
+ * configuracion y antes de importar nada que pueda reventar por esto mismo.
+ */
+export function comprobarNode(version = process.version) {
+    const mayor = Number.parseInt(String(version).replace(/^v/, "").split(".")[0], 10);
+    // Si no se entiende la version, no es motivo para no dejar trabajar a nadie.
+    if (!Number.isFinite(mayor))
+        return null;
+    if (mayor >= NODE_MINIMO)
+        return null;
+    return (`Chocolatito Code necesita Node ${NODE_MINIMO} o superior, y estas con ${version}.\n\n` +
+        `  Descargalo en https://nodejs.org (la version LTS vale).\n` +
+        `  Despues, vuelve a instalarlo:  npm i -g chocolatito-code\n\n` +
+        `No es un problema de tu licencia ni de tu conexion.`);
+}

package/dist/index.js

@@ -29,6 +29,8 @@ import { releaseKeyboard } from "./ui/interrupt.js";
 import { takeQueued, resetTypeAhead } from "./ui/typeAhead.js";
 import { mcpManager } from "./mcp/manager.js";
 import { comprobarActualizacion } from "./config/updater.js";
+import { comprobarNode } from "./config/nodeVersion.js";
+import { imprimirSobreElPrompt } from "./ui/prompt.js";
 /**
  * Version leida del package.json instalado, no escrita a mano: una constante
  * duplicada aqui se queda vieja en cuanto se publica una version nueva.
@@ -178,6 +180,15 @@ async function dispararStop(hooks, datos) {
     return null;
 }
 async function main() {
+    // Lo primero de todo: un Node viejo se dice claro, no se descubre a base de
+    // errores raros dentro de una dependencia. Ver config/nodeVersion.ts.
+    const nodeViejo = comprobarNode();
+    if (nodeViejo) {
+        console.error(chalk.red(`
+${nodeViejo}
+`));
+        process.exit(EXIT_USO);
+    }
     const rawArgs = process.argv.slice(2);
     if (handleFlags(rawArgs))
         return;
@@ -237,9 +248,13 @@ async function main() {
     // Si tardan, el primer turno los espera; el usuario ya puede escribir.
     const mcpReady = mcpManager.loadAll().then((resumen) => {
         if (resumen) {
-            console.log(chalk.hex("#D97757")("\n🔌 Servidores MCP:"));
-            console.log(resumen);
-            console.log(chalk.gray(`   ${mcpManager.toolCount} herramientas MCP disponibles.\n`));
+            // Con `console.log` esto se escribia ENCIMA del marco del prompt y lo
+            // destrozaba: los servidores tardan, y para cuando contestan el prompt ya
+            // esta dibujado. Se vio asi en una sesion real del usuario:
+            //     ✔ ide (http): 4 herramientasb modo · esc cancelar
+            imprimirSobreElPrompt(chalk.hex("#D97757")("\n🔌 Servidores MCP:") +
+                `\n${resumen}\n` +
+                chalk.gray(`   ${mcpManager.toolCount} herramientas MCP disponibles.\n`));
         }
         return resumen;
     });
@@ -256,11 +271,11 @@ async function main() {
     })
         .then((aviso) => {
         avisoDeActualizacion = aviso;
-        // Se escribe solo si hay algo que decir y el usuario no esta a mitad de
-        // frase: el prompt se redibuja entero en la siguiente tecla, asi que una
-        // linea de mas aqui no rompe el marco.
+        // Llega tarde a proposito, y para entonces el prompt ya suele estar
+        // dibujado: por eso NO se usa console.log, que lo pisaria. Ver
+        // imprimirSobreElPrompt en ui/prompt.ts.
         if (aviso)
-            console.log(chalk.gray(`\n  ⬆ ${aviso}\n`));
+            imprimirSobreElPrompt(chalk.gray(`\n  ⬆ ${aviso}\n`));
         return aviso;
     })
         .catch(() => "");