chocolatito-code 1.6.11 → 1.6.13

package/dist/agent/cortes.d.ts

@@ -0,0 +1,41 @@
+/**
+ * LA CAJA NEGRA DE LOS CORTES
+ *
+ * DE DONDE SALE
+ *
+ * Cinco respuestas seguidas cortadas a mitad de frase, y de todas ellas no
+ * quedo NADA con lo que trabajar: el aviso salia por pantalla, el usuario
+ * seguia tecleando y el rastro se perdia con el scroll. Al dia siguiente, la
+ * unica pregunta que importaba -"corta siempre por el mismo sitio?"- no se
+ * podia contestar.
+ *
+ * Aqui se apunta lo justo para poder contestarla la proxima vez, que es un
+ * renglon por corte:
+ *
+ *   2026-09-12T14:02:11Z  modelo=deepseek-chat  ms=1840  trozos=37
+ *                          texto=214  razonamiento=0  aviso=motor
+ *
+ * Con eso se distingue lo que hoy no se distingue:
+ *
+ *  - Siempre a los mismos milisegundos -> algo lo esta cortando por tiempo.
+ *  - Siempre en los mismos bytes -> un limite de tamano por el camino.
+ *  - Numeros dispares -> el motor de arriba, que va a rachas.
+ *  - `aviso=motor` -> lo dijo el proxy: el corte viene del motor.
+ *  - `aviso=mudo` -> nadie dijo nada: se murio el proxy por el camino.
+ *
+ * NO se guarda ni una palabra de la conversacion. Solo cuentas: tamanos,
+ * tiempos y el nombre del motor. Un diagnostico no vale una fuga.
+ */
+export interface Corte {
+    modelo: string;
+    ms: number;
+    trozos: number;
+    bytesTexto: number;
+    bytesRazonamiento: number;
+    /** "motor" si el proxy lo anuncio; "mudo" si el stream murio sin decir nada. */
+    aviso: "motor" | "mudo";
+}
+export declare function rutaDelRegistro(home?: string): string;
+export declare function apuntarCorte(corte: Corte, home?: string): string | null;
+/** Lo apuntado, de lo mas nuevo a lo mas viejo. Para /cortes. */
+export declare function leerCortes(limite?: number, home?: string): string[];

package/dist/agent/cortes.js

@@ -0,0 +1,52 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+export function rutaDelRegistro(home = os.homedir()) {
+    return path.join(home, ".chocolatito", "cortes.log");
+}
+/** Cuantos cortes se guardan. Mas atras que esto ya no dice nada nuevo. */
+const MAXIMO_DE_LINEAS = 200;
+export function apuntarCorte(corte, home) {
+    const ruta = rutaDelRegistro(home);
+    const linea = [
+        new Date().toISOString(),
+        `modelo=${corte.modelo}`,
+        `ms=${corte.ms}`,
+        `trozos=${corte.trozos}`,
+        `texto=${corte.bytesTexto}`,
+        `razonamiento=${corte.bytesRazonamiento}`,
+        `aviso=${corte.aviso}`,
+    ].join("  ") + "\n";
+    try {
+        fs.mkdirSync(path.dirname(ruta), { recursive: true });
+        let previo = "";
+        try {
+            previo = fs.readFileSync(ruta, "utf-8");
+        }
+        catch { }
+        // Se recorta al vuelo: un registro que crece sin fin acaba siendo otro
+        // problema, y aqui lo viejo no aporta.
+        const lineas = (previo + linea).split("\n").filter((l) => l.trim().length > 0);
+        const recortado = lineas.slice(-MAXIMO_DE_LINEAS).join("\n") + "\n";
+        fs.writeFileSync(ruta, recortado, "utf-8");
+        return ruta;
+    }
+    catch {
+        // Si no se puede escribir, no pasa nada: esto es un extra, no el aviso.
+        return null;
+    }
+}
+/** Lo apuntado, de lo mas nuevo a lo mas viejo. Para /cortes. */
+export function leerCortes(limite = 20, home) {
+    try {
+        return fs
+            .readFileSync(rutaDelRegistro(home), "utf-8")
+            .split("\n")
+            .filter((l) => l.trim().length > 0)
+            .slice(-limite)
+            .reverse();
+    }
+    catch {
+        return [];
+    }
+}

package/dist/agent/huecos.d.ts

@@ -56,3 +56,27 @@ export declare function liberarHuecos(): void;
  * que hacer nada: es lo unico que se arregla solo con esperar.
  */
 export declare function mensajeDeEspera(segundos: number): string;
+/**
+ * Espera a que se libere el hueco, en vez de devolverle la pared al usuario.
+ *
+ * DE DONDE SALE
+ *
+ * La misma sesion, un paso mas alla. Ya no se gastaba una peticion por intento
+ * -eso lo arreglo lo de arriba-, pero el usuario seguia atrapado:
+ *
+ *     > sigue
+ *     ⏸  Faltan 144s.
+ *     > sigoe
+ *     ⏸  Faltan 133s.
+ *
+ * Tecleando contra una pared que el programa sabia medir. Si sabemos que faltan
+ * 133 segundos, esperarlos es trabajo del programa, no del que paga. Se avisa,
+ * se cuenta hacia atras y se sigue solo; con Esc se deja.
+ *
+ * Vuelve `true` si ya hay hueco y `false` si el usuario corto.
+ */
+export declare function esperarAlHueco(opciones: {
+    signal?: AbortSignal;
+    alPasarUnSegundo?: (quedan: number) => void;
+    dormir?: (ms: number) => Promise<void>;
+}): Promise<boolean>;

package/dist/agent/huecos.js

@@ -79,3 +79,37 @@ export function mensajeDeEspera(segundos) {
         "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.");
 }
+/**
+ * Espera a que se libere el hueco, en vez de devolverle la pared al usuario.
+ *
+ * DE DONDE SALE
+ *
+ * La misma sesion, un paso mas alla. Ya no se gastaba una peticion por intento
+ * -eso lo arreglo lo de arriba-, pero el usuario seguia atrapado:
+ *
+ *     > sigue
+ *     ⏸  Faltan 144s.
+ *     > sigoe
+ *     ⏸  Faltan 133s.
+ *
+ * Tecleando contra una pared que el programa sabia medir. Si sabemos que faltan
+ * 133 segundos, esperarlos es trabajo del programa, no del que paga. Se avisa,
+ * se cuenta hacia atras y se sigue solo; con Esc se deja.
+ *
+ * Vuelve `true` si ya hay hueco y `false` si el usuario corto.
+ */
+export async function esperarAlHueco(opciones) {
+    const { signal, alPasarUnSegundo } = opciones;
+    const dormir = opciones.dormir || ((ms) => new Promise((r) => setTimeout(r, ms)));
+    // Se relee en cada vuelta en vez de contar desde un numero fijo: si algo
+    // libera los huecos antes -otra respuesta del motor-, se sale en el acto.
+    let quedan = segundosDeEspera();
+    while (quedan > 0) {
+        if (signal?.aborted)
+            return false;
+        alPasarUnSegundo?.(quedan);
+        await dormir(1000);
+        quedan = segundosDeEspera();
+    }
+    return !signal?.aborted;
+}

package/dist/agent/loop.js

@@ -8,8 +8,9 @@ import { CONTEXT_WINDOW, MAX_OUTPUT_TOKENS, COMPACT_THRESHOLD_TOKENS, } from "..
 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 { anotarHuecosOcupados, esperarAlHueco, liberarHuecos, mensajeDeEspera, segundosDeEspera, } from "./huecos.js";
 import { MarkdownStream } from "../ui/markdownStream.js";
+import { apuntarCorte } from "./cortes.js";
 import { checkQuota, recordUsage, mensajeDeCorte, quotaBadge } from "../config/quota.js";
 import { ReasoningStream } from "../ui/reasoningStream.js";
 import { PermissionManager, commandSignature, isDangerousCommand } from "../config/permissions.js";
@@ -461,9 +462,43 @@ export class AgentLoop {
         // llamada es justo la que puede refrescar la reserva y alargar la espera.
         const espera = segundosDeEspera();
         if (espera > 0) {
+            // ESPERAR ES TRABAJO DEL PROGRAMA, NO DEL QUE PAGA
+            //
+            // Antes esto devolvia el aviso y cortaba el turno. El usuario escribia
+            // "sigue", se llevaba "faltan 144s", escribia otra vez y se llevaba
+            // "faltan 133s": tecleando contra una pared que el programa sabia medir.
+            // Si sabemos cuanto falta, se espera y se sigue solo. Con Esc se deja.
             const aviso = mensajeDeEspera(espera);
-            salida.linea(chalk.yellow(`\n⏸  ${aviso}\n`));
-            return parada("ocupado", aviso);
+            // SOLO SE ESPERA SI HAY ALGUIEN DELANTE.
+            //
+            // Esperar tres minutos es una pausa cuando se ve la cuenta atras y se
+            // puede cortar con Esc. Sin terminal -CI, `chocolatito "haz X"`, una
+            // tuberia- es un cuelgue mudo de tres minutos que nadie puede parar, y
+            // ademas ahi no hay nadie a quien ahorrarle el teclear. Se dice y se
+            // corta, como antes.
+            if (!process.stdin.isTTY) {
+                salida.linea(chalk.yellow(`\n⏸  ${aviso}\n`));
+                return parada("ocupado", aviso);
+            }
+            salida.linea(chalk.yellow(`\n⏸  ${aviso}`));
+            salida.linea(chalk.gray("   Espero y sigo solo cuando se libere. Esc para dejarlo.\n"));
+            const vigilante = new InterruptWatcher();
+            const senal = vigilante.start();
+            const spinnerEspera = new DynamicSpinner();
+            spinnerEspera.start();
+            const hayHueco = await esperarAlHueco({
+                signal: senal,
+                alPasarUnSegundo: (quedan) => {
+                    spinnerEspera.setPrefijo(`Esperando hueco de la licencia (quedan ${quedan}s)`);
+                },
+            });
+            spinnerEspera.stop();
+            vigilante.stop();
+            if (!hayHueco) {
+                salida.linea(chalk.yellow("\n⏸  Interrumpido. Dime como seguir."));
+                return parada("interrumpido");
+            }
+            salida.linea(chalk.green("  ✔ Hueco libre. Sigo.\n"));
         }
         // 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.
@@ -596,6 +631,10 @@ export class AgentLoop {
              * respuesta de un motor que no mande esa marca.
              */
             let llegoElFinal = false;
+            // Para la caja negra: sin estos dos numeros, un corte no se puede
+            // comparar con el siguiente, y comparar es lo unico que da un patron.
+            let trozos = 0;
+            const empezoEn = Date.now();
             const rawToolCalls = [];
             const reasoningStream = new ReasoningStream();
             // Por `salida`, no por stdout: mientras se escribe la respuesta el spinner
@@ -607,6 +646,7 @@ export class AgentLoop {
                     // 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.
+                    trozos++;
                     const delta = chunk.choices?.[0]?.delta;
                     // Handle real-time reasoning stream
                     if (delta?.reasoning_content) {
@@ -680,6 +720,23 @@ export class AgentLoop {
                 }
                 if (esDemasiadasEnCurso(streamErr))
                     anotarHuecosOcupados(streamErr?.error?.retry_after_s);
+                if (String(streamErr?.error?.code ?? "") === "motor_corto_la_respuesta") {
+                    apuntarCorte({
+                        modelo: this.currentEspectro.underlyingModel,
+                        ms: Date.now() - empezoEn,
+                        trozos,
+                        bytesTexto: Buffer.byteLength(content, "utf8"),
+                        bytesRazonamiento: Buffer.byteLength(reasoning, "utf8"),
+                        aviso: "motor",
+                    });
+                    // Lo que llego es trabajo util aunque este a medias.
+                    if (content.trim()) {
+                        this.messages.push({
+                            role: "assistant",
+                            content: `${content}\n\n[Aqui se corto: el motor cerro la respuesta sin terminarla.]`,
+                        });
+                    }
+                }
                 const claroStream = explicarErrorDelMotor(streamErr);
                 if (claroStream) {
                     salida.linea(chalk.yellow(`
@@ -742,6 +799,18 @@ export class AgentLoop {
             // porque la conexion estaba bien.
             if (!llegoElFinal) {
                 watcher.stop();
+                // SE CIERRA LA PETICION MUERTA, Y ESTO NO ES LIMPIEZA: ES EL HUECO.
+                //
+                // El cuerpo se corto, pero por lo que respecta al proxy la peticion
+                // sigue en curso y sigue ocupando uno de los cuatro huecos de la
+                // licencia hasta que ALGO la cierre. Por eso el mensaje del proxy dice
+                // "si acabas de interrumpir una, el hueco se libera solo en 206s": son
+                // tres minutos y medio de servicio perdido por una conexion que ya
+                // estaba muerta de este lado. Abortando aqui se suelta en el momento.
+                try {
+                    stream?.controller?.abort();
+                }
+                catch { }
                 // 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.
@@ -761,11 +830,23 @@ export class AgentLoop {
                     : reasoning.trim()
                         ? "Se corto antes de escribir nada: solo llego el razonamiento."
                         : "Se corto antes de que llegara nada.";
+                // Se apunta antes de hablar: si el usuario vuelve a teclear, el aviso se
+                // pierde con el scroll, pero el renglon se queda.
+                const registro = apuntarCorte({
+                    modelo: this.currentEspectro.underlyingModel,
+                    ms: Date.now() - empezoEn,
+                    trozos,
+                    bytesTexto: Buffer.byteLength(content, "utf8"),
+                    bytesRazonamiento: Buffer.byteLength(reasoning, "utf8"),
+                    aviso: "mudo",
+                });
                 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`));
+                if (registro)
+                    salida.linea(chalk.gray(`     (apuntado en ${registro} — /cortes para verlos)\n`));
                 return parada("error-motor", aviso);
             }
             // El modelo se quedo sin presupuesto de salida y no llego a pedir nada.

package/dist/config/engine.js

@@ -125,6 +125,13 @@ export function explicarErrorDelMotor(err) {
             cuando +
             " No es un problema de tu conexion: si interrumpiste una tarea, su hueco se libera solo.");
     }
+    // El proxy avisa cuando el motor cierra la respuesta sin terminarla. Es el
+    // unico caso en el que se puede decir de QUIEN fue el corte: el cliente, desde
+    // fuera, solo ve un cuerpo que se acaba, igual que uno que termino bien.
+    if (String(err?.error?.code ?? "") === "motor_corto_la_respuesta") {
+        return ((mensaje || "El motor cerro la respuesta antes de terminarla.") +
+            " Lo que llego se queda arriba; vuelve a pedirlo y normalmente sale a la primera.");
+    }
     if (tipo === "cuota") {
         return mensaje || "Has agotado la cuota de uso incluida en tu suscripción.";
     }

package/dist/index.js

@@ -33,6 +33,7 @@ import { SessionManager } from "./sessions/manager.js";
 import { prepararRestauracion, formatearOpcionesDeSesion } from "./sessions/resume.js";
 import { auditGitDiff, formatAuditReport } from "./tools/gitAudit.js";
 import { instalarKit, listarKits, quitarKit, crearKit } from "./kits/manager.js";
+import { leerCortes, rutaDelRegistro } from "./agent/cortes.js";
 import { globalUndoManager } from "./agent/undoManager.js";
 import { setAutoApprove } from "./ui/permissionPrompt.js";
 import { onModeChange, getMode, modeAnnouncement } from "./ui/modes.js";
@@ -616,6 +617,23 @@ ${sessionData}
             console.log("");
             continue;
         }
+        if (trimmed === "/cortes") {
+            const lineas = leerCortes(20);
+            console.log(chalk.bold.hex("#D97757")("\n✂  RESPUESTAS QUE SE CORTARON"));
+            if (lineas.length === 0) {
+                console.log(chalk.gray("  Ninguna. Bien.\n"));
+            }
+            else {
+                console.log(chalk.gray(`  ${rutaDelRegistro()}\n`));
+                for (const l of lineas)
+                    console.log("  " + chalk.gray(l));
+                console.log(chalk.gray("\n  aviso=motor -> lo dijo el proxy: el corte viene del motor de arriba." +
+                    "\n  aviso=mudo  -> nadie dijo nada: se cayo la conexion o el proxy por el camino." +
+                    "\n  Si ms y trozos salen casi iguales en todos, algo corta por tiempo o tamano;" +
+                    "\n  si salen dispares, es el motor y va a rachas.\n"));
+            }
+            continue;
+        }
         if (trimmed === "/kit" || trimmed.startsWith("/kit ")) {
             const partes = trimmed.split(/s+/).slice(1);
             const accion = (partes[0] || "").toLowerCase();

package/dist/ui/comandos.js

@@ -32,6 +32,7 @@ export const SLASH_COMMANDS = [
     { name: "/skills", description: "Ver skills disponibles y cómo usarlos" },
     { name: "/kit", description: "Montar tu Chocolatito: instalar, crear o quitar kits (skills + reglas + MCP)", args: "[instalar|crear|quitar] [nombre]" },
     { name: "/aprende", description: "Guardar lo que acabamos de hacer como skill reutilizable", args: "[en pocas palabras]" },
+    { name: "/cortes", description: "Ver las respuestas que se cortaron y de dónde vino el corte" },
     { name: "/memory", description: "Consultar la memoria persistente transversal (~/.chocolatito/memory/)" },
     { name: "/effort", description: "Regular potencia del motor (1.0, 1.5, 2.0, 2.5)", args: "[nivel]" },
     { name: "/goal", description: "Ejecutar meta compleja autónoma con auto-corrección", args: "<meta>" },

package/dist/ui/spinner.d.ts

@@ -7,6 +7,12 @@ export declare class DynamicSpinner {
     private prefix;
     tokenCount: number;
     constructor(prefix?: string);
+    /**
+     * Cambia el texto mientras gira. Hace falta para las esperas con cuenta
+     * atras: el prefijo se fijaba al arrancar y el numero de segundos que faltan
+     * cambia cada vuelta.
+     */
+    setPrefijo(prefijo: string): void;
     start(initialPrefix?: string): void;
     private tick;
     /**

package/dist/ui/spinner.js

@@ -42,6 +42,14 @@ export class DynamicSpinner {
     constructor(prefix = "") {
         this.prefix = prefix;
     }
+    /**
+     * Cambia el texto mientras gira. Hace falta para las esperas con cuenta
+     * atras: el prefijo se fijaba al arrancar y el numero de segundos que faltan
+     * cambia cada vuelta.
+     */
+    setPrefijo(prefijo) {
+        this.prefix = prefijo;
+    }
     start(initialPrefix) {
         if (this.isRunning)
             return;

package/extension/manifest.json

@@ -2,7 +2,7 @@
   "manifest_version": 3,
   "minimum_chrome_version": "102",
   "name": "Chocolatito Code",
-  "version": "1.6.11",
+  "version": "1.6.13",
   "description": "Deja que Chocolatito Code trabaje dentro de tu Chrome, en segundo plano y con tus sesiones ya iniciadas.",
   "permissions": [
     "tabs",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chocolatito-code",
-  "version": "1.6.11",
+  "version": "1.6.13",
   "description": "Agente autónomo de programación para la terminal, con control real del ordenador y del navegador. Desarrollado por Chocolatito.",
   "type": "module",
   "bin": {