chocolatito-code 1.2.0 → 1.3.1

package/dist/agent/huecos.d.ts

@@ -0,0 +1,58 @@
+/**
+ * NO GASTAR UN HUECO DE PETICION QUE YA SABEMOS QUE NO HAY
+ *
+ * DE DONDE SALE
+ *
+ * Sesion real. Una respuesta se corto a mitad, el bucle reintento, y en cuatro
+ * mensajes el usuario se quedo sin servicio:
+ *
+ *     ⏸  Tienes 4 peticiones en curso. Reintenta en 197s.
+ *     ❯ q paso?
+ *     ⏸  Tienes 4 peticiones en curso. Reintenta en 189s.
+ *
+ * Fijate en la segunda. El agente ya SABIA que no habia huecos y que faltaban
+ * 197 segundos; ocho segundos despues volvio a llamar al motor para que se lo
+ * repitiera. Esa llamada no podia salir bien por definicion, y ademas es la
+ * clase de peticion que puede refrescar la reserva del proxy y alargar la
+ * espera. El usuario tecleaba, esperaba, y se llevaba la misma pared.
+ *
+ * LO QUE HACE
+ *
+ * Se apunta hasta cuando no hay huecos y se responde desde aqui, sin red. Deja
+ * de gastarse una peticion por cada intento y el usuario ve la cuenta atras
+ * bajar de verdad en lugar de quedarse clavada.
+ *
+ * POR QUE NO SE FIA DEL RELOJ A CIEGAS
+ *
+ * Un reloj que se adelanta desbloquea antes de tiempo -inofensivo, la siguiente
+ * peticion dira la verdad-. Pero uno que se atrasa dejaria `ocupadoHasta` en un
+ * futuro lejano y el agente se negaria a llamar al motor durante horas sin que
+ * nada lo despierte. Por eso la espera nunca puede pasar de la ventana que se
+ * anoto: en el peor caso se espera de mas una vez, no para siempre.
+ */
+/** Cuando el proxy no dice cuanto falta. Un minuto es su reserva mas corta. */
+export declare const SEGUNDOS_POR_DEFECTO = 60;
+/** Techo de la espera. Ninguna reserva del proxy dura mas de unos minutos. */
+export declare const SEGUNDOS_MAXIMOS = 300;
+/**
+ * Apunta que los huecos estan llenos.
+ *
+ * `retryAfterS` es lo que dice el proxy en `error.retry_after_s`. Si no viene,
+ * o viene con un valor absurdo, se usa un minuto: adivinar de mas encierra al
+ * usuario y adivinar de menos le devuelve a la misma pared.
+ */
+export declare function anotarHuecosOcupados(retryAfterS?: unknown): void;
+/** Segundos que faltan para volver a tener hueco. 0 si ya lo hay. */
+export declare function segundosDeEspera(): number;
+/**
+ * Olvida la espera. Se llama en cuanto el motor concede una peticion: si
+ * contesta, es que habia hueco, y seguir bloqueando seria mentir.
+ */
+export declare function liberarHuecos(): void;
+/**
+ * Lo que se le dice al usuario en vez de llamar al motor.
+ *
+ * Dice de donde sale la cuenta -no es una invencion del cliente- y que no tiene
+ * que hacer nada: es lo unico que se arregla solo con esperar.
+ */
+export declare function mensajeDeEspera(segundos: number): string;

package/dist/agent/huecos.js

@@ -0,0 +1,81 @@
+/**
+ * NO GASTAR UN HUECO DE PETICION QUE YA SABEMOS QUE NO HAY
+ *
+ * DE DONDE SALE
+ *
+ * Sesion real. Una respuesta se corto a mitad, el bucle reintento, y en cuatro
+ * mensajes el usuario se quedo sin servicio:
+ *
+ *     ⏸  Tienes 4 peticiones en curso. Reintenta en 197s.
+ *     ❯ q paso?
+ *     ⏸  Tienes 4 peticiones en curso. Reintenta en 189s.
+ *
+ * Fijate en la segunda. El agente ya SABIA que no habia huecos y que faltaban
+ * 197 segundos; ocho segundos despues volvio a llamar al motor para que se lo
+ * repitiera. Esa llamada no podia salir bien por definicion, y ademas es la
+ * clase de peticion que puede refrescar la reserva del proxy y alargar la
+ * espera. El usuario tecleaba, esperaba, y se llevaba la misma pared.
+ *
+ * LO QUE HACE
+ *
+ * Se apunta hasta cuando no hay huecos y se responde desde aqui, sin red. Deja
+ * de gastarse una peticion por cada intento y el usuario ve la cuenta atras
+ * bajar de verdad en lugar de quedarse clavada.
+ *
+ * POR QUE NO SE FIA DEL RELOJ A CIEGAS
+ *
+ * Un reloj que se adelanta desbloquea antes de tiempo -inofensivo, la siguiente
+ * peticion dira la verdad-. Pero uno que se atrasa dejaria `ocupadoHasta` en un
+ * futuro lejano y el agente se negaria a llamar al motor durante horas sin que
+ * nada lo despierte. Por eso la espera nunca puede pasar de la ventana que se
+ * anoto: en el peor caso se espera de mas una vez, no para siempre.
+ */
+/** Cuando el proxy no dice cuanto falta. Un minuto es su reserva mas corta. */
+export const SEGUNDOS_POR_DEFECTO = 60;
+/** Techo de la espera. Ninguna reserva del proxy dura mas de unos minutos. */
+export const SEGUNDOS_MAXIMOS = 300;
+let ocupadoHasta = 0;
+let ventanaMs = 0;
+/**
+ * Apunta que los huecos estan llenos.
+ *
+ * `retryAfterS` es lo que dice el proxy en `error.retry_after_s`. Si no viene,
+ * o viene con un valor absurdo, se usa un minuto: adivinar de mas encierra al
+ * usuario y adivinar de menos le devuelve a la misma pared.
+ */
+export function anotarHuecosOcupados(retryAfterS) {
+    const dicho = Number(retryAfterS);
+    const segundos = Number.isFinite(dicho) && dicho > 0 ? Math.min(dicho, SEGUNDOS_MAXIMOS) : SEGUNDOS_POR_DEFECTO;
+    ventanaMs = segundos * 1000;
+    ocupadoHasta = Date.now() + ventanaMs;
+}
+/** Segundos que faltan para volver a tener hueco. 0 si ya lo hay. */
+export function segundosDeEspera() {
+    if (ocupadoHasta === 0)
+        return 0;
+    const faltan = Math.min(ocupadoHasta - Date.now(), ventanaMs);
+    if (faltan <= 0) {
+        liberarHuecos();
+        return 0;
+    }
+    return Math.ceil(faltan / 1000);
+}
+/**
+ * Olvida la espera. Se llama en cuanto el motor concede una peticion: si
+ * contesta, es que habia hueco, y seguir bloqueando seria mentir.
+ */
+export function liberarHuecos() {
+    ocupadoHasta = 0;
+    ventanaMs = 0;
+}
+/**
+ * Lo que se le dice al usuario en vez de llamar al motor.
+ *
+ * Dice de donde sale la cuenta -no es una invencion del cliente- y que no tiene
+ * que hacer nada: es lo unico que se arregla solo con esperar.
+ */
+export function mensajeDeEspera(segundos) {
+    return (`Los huecos de peticion de tu licencia siguen ocupados. Faltan ${segundos}s. ` +
+        "No llamo al motor porque la respuesta seria la misma y cada intento puede alargar la espera. " +
+        "No hace falta que hagas nada: el hueco se libera solo.");
+}

package/dist/agent/loop.js

@@ -3,17 +3,18 @@ import process from "node:process";
 import { getAllTools } from "../tools/definitions.js";
 import { executeToolCall } from "../tools/runner.js";
 import { TokenTracker } from "./tracker.js";
-import { renderToolStart, renderToolSuccess, renderToolError, renderDiff, renderFooter, renderError, } from "../ui/renderer.js";
+import { renderToolStart, renderToolSuccess, renderToolError, renderDiff, renderFooter, renderError, formatToolName, } from "../ui/renderer.js";
 import { CONTEXT_WINDOW, MAX_OUTPUT_TOKENS, COMPACT_THRESHOLD_TOKENS, } from "../config/constants.js";
-import { withRetry, isContextOverflow } from "./retry.js";
+import { withRetry, isContextOverflow, esDemasiadasEnCurso } from "./retry.js";
 import { canRunInParallel } from "../tools/safety.js";
 import { createEngineClient, explicarErrorDelMotor, motivoDeParadaDelError, } from "../config/engine.js";
+import { anotarHuecosOcupados, liberarHuecos, mensajeDeEspera, segundosDeEspera } from "./huecos.js";
 import { MarkdownStream } from "../ui/markdownStream.js";
 import { checkQuota, recordUsage, mensajeDeCorte, quotaBadge } from "../config/quota.js";
 import { ReasoningStream } from "../ui/reasoningStream.js";
 import { PermissionManager, commandSignature, isDangerousCommand } from "../config/permissions.js";
 import { askToolPermission } from "../ui/permissionPrompt.js";
-import { DynamicSpinner } from "../ui/spinner.js";
+import { DynamicSpinner, conSpinner } from "../ui/spinner.js";
 import { globalUndoManager } from "./undoManager.js";
 import { salida } from "./salidaDelAgente.js";
 import { InterruptWatcher, isAbortError } from "../ui/interrupt.js";
@@ -76,8 +77,8 @@ 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.
-
+        `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 ` +
@@ -455,6 +456,15 @@ export class AgentLoop {
                 tokensSalida: turnCompletionTokens,
             };
         };
+        // Los huecos de peticion, ANTES de gastar uno. El proxy ya nos dijo cuanto
+        // falta; volver a preguntarselo no puede salir bien por definicion, y esa
+        // llamada es justo la que puede refrescar la reserva y alargar la espera.
+        const espera = segundosDeEspera();
+        if (espera > 0) {
+            const aviso = mensajeDeEspera(espera);
+            salida.linea(chalk.yellow(`\n⏸  ${aviso}\n`));
+            return parada("ocupado", aviso);
+        }
         // Cuota ANTES de gastar. Si no queda margen, se dice y no se llama al motor:
         // avisar despues de haber gastado no sirve de nada.
         const cuota = checkQuota();
@@ -553,10 +563,15 @@ export class AgentLoop {
                 // Un 402 (cuota agotada) o un 401 (licencia caida) no son "fallos del
                 // motor" y ademas no se reintentan nunca: decirlo como tal confunde y
                 // hace que el usuario piense que el producto esta roto.
+                // Si el 429 es de huecos ocupados, se apunta hasta cuando: asi el
+                // siguiente mensaje del usuario se responde desde aqui en vez de gastar
+                // otra peticion para que le repitan la misma pared.
+                if (esDemasiadasEnCurso(err))
+                    anotarHuecosOcupados(err?.error?.retry_after_s);
                 const claro = explicarErrorDelMotor(err);
                 if (claro) {
-                    salida.linea(chalk.yellow(`
-⏸  ${claro}
+                    salida.linea(chalk.yellow(`
+⏸  ${claro}
 `));
                     return parada(motivoDeParadaDelError(err), claro);
                 }
@@ -564,19 +579,34 @@ export class AgentLoop {
                 renderError(fallo);
                 return parada("error-motor", fallo);
             }
+            // El motor contesto: habia hueco. Seguir bloqueando por una espera vieja
+            // seria mentirle al usuario y negarle el servicio que si tiene.
+            liberarHuecos();
             let content = "";
             let reasoning = "";
             let motivoDeCorte = null;
+            /**
+             * Si llego la MARCA de final del stream.
+             *
+             * Un stream sano termina diciendo por que termina: un `finish_reason` y,
+             * con `include_usage`, un ultimo trozo con el gasto. Cuando el cuerpo se
+             * corta a mitad no llega ninguno de los dos y el iterador se acaba sin
+             * error, exactamente igual que si hubiera terminado bien. Hacen falta las
+             * dos ausencias: fiarse de una sola convertiria en "cortada" cualquier
+             * respuesta de un motor que no mande esa marca.
+             */
+            let llegoElFinal = false;
             const rawToolCalls = [];
-            let isFirstChunk = true;
             const reasoningStream = new ReasoningStream();
-            const markdown = new MarkdownStream();
+            // Por `salida`, no por stdout: mientras se escribe la respuesta el spinner
+            // sigue puesto abajo, y escribir directo lo pisaria.
+            const markdown = new MarkdownStream((s) => salida.crudo(s));
             try {
                 for await (const chunk of stream) {
-                    if (isFirstChunk) {
-                        spinner.stop();
-                        isFirstChunk = false;
-                    }
+                    // El spinner ya NO se para al llegar el primer trozo. Vive en el pie
+                    // fijo, asi que la respuesta sale por encima sin taparlo y el contador
+                    // de segundos sigue a la vista mientras el modelo habla, que es
+                    // exactamente cuando uno quiere saber cuanto lleva.
                     const delta = chunk.choices?.[0]?.delta;
                     // Handle real-time reasoning stream
                     if (delta?.reasoning_content) {
@@ -590,6 +620,12 @@ export class AgentLoop {
                         content += delta.content;
                         markdown.push(delta.content);
                     }
+                    // El contador del spinner, en vivo. El `usage` de verdad solo llega
+                    // en el ultimo trozo: sin esta estimacion el numero se queda a cero
+                    // durante toda la respuesta y aparece de golpe justo al acabar, que
+                    // es cuando ya no le sirve a nadie.
+                    spinner.tokenCount =
+                        turnCompletionTokens + Math.round((content.length + reasoning.length) / 4);
                     // Accumulate fragmented tool calls by index tc.index
                     if (delta?.tool_calls) {
                         for (const tc of delta.tool_calls) {
@@ -612,10 +648,13 @@ export class AgentLoop {
                     // El motivo por el que el modelo dejo de hablar. Sin esto, quedarse
                     // sin presupuesto de salida es indistinguible de terminar el turno.
                     const corte = chunk.choices?.[0]?.finish_reason;
-                    if (corte)
+                    if (corte) {
                         motivoDeCorte = corte;
+                        llegoElFinal = true;
+                    }
                     // Track streaming usage metrics
                     if (chunk.usage) {
+                        llegoElFinal = true;
                         this.tracker.addUsage(chunk.usage);
                         turnPromptTokens += chunk.usage.prompt_tokens || 0;
                         if (chunk.usage.prompt_tokens)
@@ -639,10 +678,12 @@ export class AgentLoop {
                     salida.linea(chalk.yellow("\n⏸  Interrumpido. Dime como seguir."));
                     return parada("interrumpido");
                 }
+                if (esDemasiadasEnCurso(streamErr))
+                    anotarHuecosOcupados(streamErr?.error?.retry_after_s);
                 const claroStream = explicarErrorDelMotor(streamErr);
                 if (claroStream) {
-                    salida.linea(chalk.yellow(`
-⏸  ${claroStream}
+                    salida.linea(chalk.yellow(`
+⏸  ${claroStream}
 `));
                     return parada(motivoDeParadaDelError(streamErr), claroStream);
                 }
@@ -662,6 +703,71 @@ export class AgentLoop {
             }
             // Filter valid accumulated tool calls
             const toolCalls = rawToolCalls.filter((tc) => tc && tc.function && tc.function.name);
+            // LA RESPUESTA SE CORTO A MITAD Y EL STREAM ACABO COMO SI NADA
+            //
+            // Sesion real. El usuario pregunta por su consumo y ve esto:
+            //
+            //     ¿De cuál consumo me hab
+            //     ⚡ 12.4s · 0 tokens salida · 100% contexto libre
+            //
+            // Media palabra y el pie del turno, sin un solo aviso. El cuerpo de la
+            // respuesta se cerro por el camino -no el modelo: la conexion-, asi que no
+            // llego ni el finish_reason ni el trozo del gasto, y el iterador termino
+            // sin lanzar nada. El bucle no distingue "el modelo termino" de "no vino
+            // mas", asi que dio el turno por bueno.
+            //
+            // Y lo peor no se veia: esa media frase se guardaba en el historial como
+            // respuesta completa del asistente. El turno siguiente salia con un
+            // historial que acaba a mitad de palabra, el modelo contestaba vacio, y el
+            // reintento de las respuestas vacias gastaba otro hueco de peticion.
+            // Cuatro mensajes despues: "Tienes 4 peticiones en curso. Reintenta en
+            // 197s", y el usuario sin servicio durante tres minutos.
+            //
+            // NO SE REINTENTA, A PROPOSITO. Cada intento ocupa uno de los cuatro
+            // huecos de la licencia durante minutos, y los cortes vienen en rachas:
+            // reintentar es justo como se pasa de perder un hueco a perder los cuatro.
+            // Mas vale que el usuario reescriba una linea.
+            //
+            // NO SE EXIGE QUE HAYA LLEGADO TEXTO. La primera version pedia contenido o
+            // herramientas, y se le escapaba el caso mas comun: el corte que pasa
+            // DESPUES del razonamiento y ANTES de la primera palabra. Eso caia en la
+            // rama de "respuesta vacia", que si reintenta, y volvia a gastar huecos:
+            //
+            //     💭 penso 2s
+            //     ⚠ El motor no devolvio nada. Reintentando una vez…
+            //
+            // Sin marca de final, el stream se corto. Da igual cuanto habia llegado.
+            // Una respuesta vacia DE VERDAD trae su finish_reason: el motor cerro el
+            // turno en regla y simplemente no dijo nada, y eso si merece un reintento
+            // porque la conexion estaba bien.
+            if (!llegoElFinal) {
+                watcher.stop();
+                // Lo que llego se guarda, pero MARCADO. Sin la marca, en el turno
+                // siguiente el modelo lee su propia frase a medias como algo que decidio
+                // dejar asi, y responde a un texto que nadie escribio.
+                if (content.trim()) {
+                    this.messages.push({
+                        role: "assistant",
+                        content: `${content}\n\n[Aqui se corto: la conexion con el motor se cerro a mitad de la respuesta.]`,
+                    });
+                }
+                // Se dice HASTA DONDE llego, y no por cortesia: es el unico dato que
+                // distingue un corte antes de empezar de uno a mitad de frase, y en un
+                // pegado del usuario es lo unico con lo que se puede diagnosticar.
+                // Las llamadas a herramienta de un stream cortado NO se ejecutan: sus
+                // argumentos estan tan a medias como el texto.
+                const hastaDonde = content.trim()
+                    ? "Lo que llego se queda arriba."
+                    : reasoning.trim()
+                        ? "Se corto antes de escribir nada: solo llego el razonamiento."
+                        : "Se corto antes de que llegara nada.";
+                const aviso = "La respuesta se corto: la conexion con el motor se cerro sin decir por que (no llego " +
+                    `ni el motivo de fin ni el recuento del gasto). ${hastaDonde} ` +
+                    "No lo reintento solo porque cada intento ocupa uno de los cuatro huecos de tu licencia " +
+                    "durante varios minutos; vuelve a pedirmelo y sigo.";
+                salida.linea(chalk.yellow(`\n  ⚠ ${aviso}\n`));
+                return parada("error-motor", aviso);
+            }
             // El modelo se quedo sin presupuesto de salida y no llego a pedir nada.
             //
             // Esto se veia EXACTAMENTE igual que un turno terminado: sin llamadas a
@@ -761,10 +867,14 @@ export class AgentLoop {
                     for (const { tc, args } of autorizadas) {
                         renderToolStart(tc.function.name, getToolSummary(tc.function.name, args));
                     }
-                    const settled = await Promise.all(autorizadas.map(async ({ tc, args, pos }) => {
+                    // Un solo spinner para el lote entero: uno por herramienta se pisarian
+                    // entre ellos y el pie parpadearia tantas veces como llamadas haya.
+                    const settled = await conSpinner(autorizadas.length === 1
+                        ? formatToolName(autorizadas[0].tc.function.name)
+                        : `${autorizadas.length} herramientas a la vez`, () => Promise.all(autorizadas.map(async ({ tc, args, pos }) => {
                         const r = await executeToolCall(tc.function.name, args, this.currentCwd, this.apiKey, this.currentEspectro.underlyingModel);
                         return { tc, args, pos, result: r.result };
-                    }));
+                    })));
                     for (const { tc, args, pos, result } of settled) {
                         renderToolSuccess(tc.function.name, result);
                         const aviso = await notificarPostHerramienta(tc.function.name, args, result, this.currentCwd);
@@ -885,7 +995,10 @@ export class AgentLoop {
                     }
                     const summary = getToolSummary(fnName, fnArgs);
                     renderToolStart(fnName, summary);
-                    const { result, diffText, newCwd } = await executeToolCall(fnName, fnArgs, this.currentCwd, this.apiKey, this.currentEspectro.underlyingModel);
+                    // El pie se queda puesto mientras dure la herramienta. Un run_command
+                    // de veinte segundos dejaba la pantalla muda: ni cronometro, ni forma
+                    // de saber que seguia vivo, ni donde escribir para encolar algo.
+                    const { result, diffText, newCwd } = await conSpinner(formatToolName(fnName), () => executeToolCall(fnName, fnArgs, this.currentCwd, this.apiKey, this.currentEspectro.underlyingModel));
                     if (newCwd) {
                         this.currentCwd = newCwd;
                     }
@@ -910,7 +1023,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,
                     });
                 }
@@ -943,6 +1056,12 @@ export class AgentLoop {
             // 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.
+            //
+            // Aqui solo se llega con la marca de final puesta: un stream cortado sale
+            // mucho antes, por su propia rama. Asi que esto es lo que parece -el motor
+            // cerro el turno en regla y no dijo nada- y no un corte disfrazado. Esa
+            // separacion es la que hace que reintentar aqui sea razonable: la conexion
+            // estaba bien, y por eso el reintento no es tirar un hueco a la basura.
             if (!content.trim()) {
                 respuestasVacias++;
                 // Se reintenta UNA vez, no mas, y aqui la moderacion importa: cada
@@ -950,13 +1069,14 @@ export class AgentLoop {
                 // 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.";
+                    const aviso = `El motor cerro el turno en regla ${respuestasVacias} veces seguidas sin una sola ` +
+                        "palabra. No es un corte de conexion -eso se avisa aparte y con otras palabras-: la " +
+                        "peticion llego y volvio entera, solo que vacia. 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"));
+                salida.linea(chalk.gray("\n  ⚠ El motor cerro el turno sin decir nada. Reintentando una vez…\n"));
                 this.messages.push({
                     role: "user",
                     content: "Tu respuesta anterior llego vacia: ni texto ni llamadas a herramienta. " +

package/dist/agent/salidaDelAgente.js

@@ -1,35 +1,21 @@
+import { escribirEncimaDelPie } from "../ui/pieFijo.js";
 /**
- * Por donde habla el bucle del agente.
+ * Pasa por `pieFijo` y no por `console.log` a secas.
  *
- * POR QUE
+ * Mientras el spinner esta puesto hay un bloque pintado abajo del todo. Escribir
+ * directo lo pisaria: la respuesta saldria encima de la linea del spinner y el
+ * repintado siguiente ya no sabria donde empieza su bloque. Pasando por aqui, el
+ * pie se aparta, la linea entra en el historial como cualquier otra, y el pie
+ * vuelve a pintarse debajo.
  *
- * 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.
+ * Sin pie puesto -que es casi todo el rato- esto es un `write` normal.
  */
 const A_LA_TERMINAL = {
     linea: (texto) => {
-        console.log(texto);
+        escribirEncimaDelPie(`${texto}\n`);
     },
     crudo: (texto) => {
-        process.stdout.write(texto);
+        escribirEncimaDelPie(texto);
     },
 };
 let actual = A_LA_TERMINAL;

package/dist/agent/toolGate.js

@@ -3,7 +3,7 @@ import chalk from "chalk";
 import { PermissionManager, commandSignature } from "../config/permissions.js";
 import { HookManager } from "../hooks/manager.js";
 import { askToolPermission } from "../ui/permissionPrompt.js";
-import { releaseKeyboard } from "../ui/interrupt.js";
+import { releaseKeyboard, retomarTeclado } from "../ui/interrupt.js";
 let activa = null;
 /** Lo llama el AgentLoop al construirse. */
 export function registerToolGate(permissions, hooks) {
@@ -75,6 +75,11 @@ export async function autorizarHerramienta(toolName, args, cwd = process.cwd(),
         releaseKeyboard();
         console.log(chalk.gray(`\n${origen} pide permiso para usar "${toolName}":`));
         const res = await askToolPermission(toolName, finales, cwd);
+        // Se devuelve el teclado a quien lo tenia. Sin esto, el resto del turno se
+        // queda sin vigilante: Esc deja de cancelar, lo que el usuario escriba no se
+        // encola, y el terminal vuelve al modo cocido -donde lo tecleado no aparece
+        // hasta pulsar Enter, que es como se veia el "se queda trabado".
+        retomarTeclado();
         if (!res.approved) {
             return {
                 permitida: false,

package/dist/config/engine.d.ts

@@ -38,7 +38,27 @@ export declare function engineCredential(fallbackApiKey: string): string;
  * cualquiera apuntando al mismo endpoint.
  */
 export declare function engineHeaders(route: EngineRoute): Record<string, string>;
-/** Cliente del motor ya configurado. Es el unico sitio donde se construye. */
+/**
+ * Cliente del motor ya configurado. Es el unico sitio donde se construye.
+ *
+ * POR QUE `maxRetries: 0`
+ *
+ * El SDK reintenta por su cuenta dos veces mas (su valor por defecto), y encima
+ * de eso el agente pasa cada llamada por `withRetry`. Dos capas apiladas, y solo
+ * una de las dos sabe algo del proxy.
+ *
+ * Medido contra un servidor de mentira: una sola llamada que recibe un 429 de
+ * "tienes 4 peticiones en curso" sale por la red TRES veces antes de que el
+ * error llegue siquiera a nuestro codigo. Y nuestro codigo lo tiene bien
+ * clasificado -`isRetryable` devuelve false para ese 429 justamente porque cada
+ * intento ocupa un hueco-, pero para entonces ya se han gastado los otros dos.
+ *
+ * Asi es como un solo corte de conexion se comia los cuatro huecos de la
+ * licencia y dejaba al usuario tres minutos sin servicio. La politica de
+ * reintentos vive en `withRetry` y en un solo sitio: ahi se sabe que un
+ * desbordamiento de contexto no puede empezar a caber, y que insistir con los
+ * huecos ocupados es la forma mas rapida de quedarse sin ninguno.
+ */
 export declare function createEngineClient(apiKey: string, route: EngineRoute): OpenAI;
 /**
  * De que tipo es el fallo, sin mirar el texto ya traducido.

package/dist/config/engine.js

@@ -55,12 +55,33 @@ export function engineHeaders(route) {
         cabeceras["X-Chocolatito-Instance"] = license.instanceId;
     return cabeceras;
 }
-/** Cliente del motor ya configurado. Es el unico sitio donde se construye. */
+/**
+ * Cliente del motor ya configurado. Es el unico sitio donde se construye.
+ *
+ * POR QUE `maxRetries: 0`
+ *
+ * El SDK reintenta por su cuenta dos veces mas (su valor por defecto), y encima
+ * de eso el agente pasa cada llamada por `withRetry`. Dos capas apiladas, y solo
+ * una de las dos sabe algo del proxy.
+ *
+ * Medido contra un servidor de mentira: una sola llamada que recibe un 429 de
+ * "tienes 4 peticiones en curso" sale por la red TRES veces antes de que el
+ * error llegue siquiera a nuestro codigo. Y nuestro codigo lo tiene bien
+ * clasificado -`isRetryable` devuelve false para ese 429 justamente porque cada
+ * intento ocupa un hueco-, pero para entonces ya se han gastado los otros dos.
+ *
+ * Asi es como un solo corte de conexion se comia los cuatro huecos de la
+ * licencia y dejaba al usuario tres minutos sin servicio. La politica de
+ * reintentos vive en `withRetry` y en un solo sitio: ahi se sabe que un
+ * desbordamiento de contexto no puede empezar a caber, y que insistir con los
+ * huecos ocupados es la forma mas rapida de quedarse sin ninguno.
+ */
 export function createEngineClient(apiKey, route) {
     return new OpenAI({
         apiKey: engineCredential(apiKey),
         baseURL: getEngineBaseUrl(),
         defaultHeaders: engineHeaders(route),
+        maxRetries: 0,
     });
 }
 export function clasificarErrorDelMotor(err) {

package/dist/config/quota.d.ts

@@ -50,6 +50,17 @@ export interface QuotaStatus {
     config: QuotaConfig;
 }
 export declare function checkQuota(ahora?: number): QuotaStatus;
+/**
+ * Cuando la ventana corta se vacia DEL TODO, si no se gasta nada mas.
+ *
+ * `seLiberaEn` dice cuando caduca el gasto mas viejo, que es lo que hace falta
+ * para saber cuando se puede volver a trabajar tras un corte. Para ensenar el
+ * consumo es otra pregunta: cuando vuelve a cero. Y como la ventana es
+ * deslizante, eso es cuando caduca el gasto mas RECIENTE.
+ *
+ * `null` si no hay nada dentro de la ventana: no hay nada que renovar.
+ */
+export declare function ventanaVaciaEn(ahora?: number): Date | null;
 /** Cuanto falta para la hora indicada, en lenguaje llano. */
 export declare function faltaPara(fecha: Date, ahora?: number): string;
 /** Mensaje completo para cuando se agota la cuota. */

package/dist/config/quota.js

@@ -148,6 +148,24 @@ export function checkQuota(ahora = Date.now()) {
     }
     return { allowed: true, spentWindowUsd, spentWeekUsd, config };
 }
+/**
+ * Cuando la ventana corta se vacia DEL TODO, si no se gasta nada mas.
+ *
+ * `seLiberaEn` dice cuando caduca el gasto mas viejo, que es lo que hace falta
+ * para saber cuando se puede volver a trabajar tras un corte. Para ensenar el
+ * consumo es otra pregunta: cuando vuelve a cero. Y como la ventana es
+ * deslizante, eso es cuando caduca el gasto mas RECIENTE.
+ *
+ * `null` si no hay nada dentro de la ventana: no hay nada que renovar.
+ */
+export function ventanaVaciaEn(ahora = Date.now()) {
+    const ventanaMs = getQuotaConfig().windowHours * 60 * 60 * 1000;
+    const dentro = load().filter((e) => e.t >= ahora - ventanaMs);
+    if (dentro.length === 0)
+        return null;
+    const masReciente = dentro.reduce((max, e) => (e.t > max ? e.t : max), dentro[0].t);
+    return new Date(masReciente + ventanaMs);
+}
 /** Cuanto falta para la hora indicada, en lenguaje llano. */
 export function faltaPara(fecha, ahora = Date.now()) {
     const ms = fecha.getTime() - ahora;