chocolatito-code 1.6.12 → 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/loop.js

@@ -10,6 +10,7 @@ import { canRunInParallel } from "../tools/safety.js";
 import { createEngineClient, explicarErrorDelMotor, motivoDeParadaDelError, } from "../config/engine.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";
@@ -630,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
@@ -641,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) {
@@ -714,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(`
@@ -807,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/extension/manifest.json

@@ -2,7 +2,7 @@
   "manifest_version": 3,
   "minimum_chrome_version": "102",
   "name": "Chocolatito Code",
-  "version": "1.6.12",
+  "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.12",
+  "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": {