chocolatito-code 1.0.0 → 1.1.0

package/dist/agent/loop.js

@@ -5,20 +5,79 @@ import { executeToolCall } from "../tools/runner.js";
 import { TokenTracker } from "./tracker.js";
 import { renderToolStart, renderToolSuccess, renderToolError, renderDiff, renderFooter, renderError, } from "../ui/renderer.js";
 import { CONTEXT_WINDOW, MAX_OUTPUT_TOKENS, COMPACT_THRESHOLD_TOKENS, } from "../config/constants.js";
-import { withRetry } from "./retry.js";
+import { withRetry, isContextOverflow } from "./retry.js";
 import { canRunInParallel } from "../tools/safety.js";
-import { createEngineClient, explicarErrorDelMotor } from "../config/engine.js";
+import { createEngineClient, explicarErrorDelMotor, motivoDeParadaDelError, } from "../config/engine.js";
 import { MarkdownStream } from "../ui/markdownStream.js";
 import { checkQuota, recordUsage, mensajeDeCorte, quotaBadge } from "../config/quota.js";
 import { ReasoningStream } from "../ui/reasoningStream.js";
-import { PermissionManager } from "../config/permissions.js";
+import { PermissionManager, commandSignature, isDangerousCommand } from "../config/permissions.js";
 import { askToolPermission } from "../ui/permissionPrompt.js";
 import { DynamicSpinner } from "../ui/spinner.js";
 import { globalUndoManager } from "./undoManager.js";
 import { InterruptWatcher, isAbortError } from "../ui/interrupt.js";
 import { HookManager } from "../hooks/manager.js";
+import { registerToolGate, autorizarHerramienta, notificarPostHerramienta } from "./toolGate.js";
+import { DetectorDeBucle, mensajeDeBucle } from "./loopDetector.js";
+import { preguntarPorBucle } from "../ui/loopPrompt.js";
+import { MAX_REFLEXIONES, detectarComando, mensajeDeRendicion, mensajeDeVerificacion, verificacionAutomaticaActiva, verificar, } from "./verifier.js";
+import { apuntarUso, tomarGastoAuxiliar } from "./usageMeter.js";
+import { leerLimites } from "../config/limits.js";
+import { corteSeguro, estimarTokens, limpiarHuerfanos, vaciarResultadosAntiguos, } from "./compaction.js";
+/** Herramientas cuyo exito deja el proyecto en un estado que vale la pena verificar. */
+const HERRAMIENTAS_QUE_ESCRIBEN = new Set([
+    "edit_file",
+    "write_file",
+    "move_copy_file",
+    "delete_file",
+]);
+/** Cortes por longitud seguidos que se toleran antes de rendirse. */
+const MAX_CORTES_POR_LONGITUD = 2;
+/** Mensajes recientes que la compactacion no resume nunca. */
+const COLA_INTACTA = 4;
+/**
+ * Mensajes recientes cuyas salidas de herramienta se conservan enteras. Las
+ * anteriores se vacian antes de plantearse siquiera resumir.
+ */
+const RESULTADOS_INTACTOS = 12;
+/**
+ * Argumentos de una llamada a herramienta, distinguiendo el caso que importa.
+ *
+ * Un `JSON.parse` que falla no significa "esta herramienta no lleva
+ * argumentos": significa que el modelo se quedo sin presupuesto de salida a
+ * mitad de escribirlos. Tratar las dos cosas igual —que es lo que se hacia,
+ * con un `catch { fnArgs = {} }`— ejecuta la herramienta con las manos vacias:
+ * un write_file sin ruta ni contenido, un run_command sin comando. Y responde
+ * como si nada.
+ */
+function parsearArgumentos(bruto) {
+    const texto = (bruto ?? "").trim();
+    // Sin argumentos de verdad: hay herramientas que no llevan ninguno.
+    if (!texto || texto === "{}")
+        return { ok: true, args: {} };
+    try {
+        const args = JSON.parse(texto);
+        if (args && typeof args === "object" && !Array.isArray(args))
+            return { ok: true, args };
+    }
+    catch { }
+    return { ok: false, args: {} };
+}
+/** 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.`);
+}
 export class AgentLoop {
     client;
+    /**
+     * Cliente aparte para resumir el historial. No es cosmetico: la cabecera
+     * X-Chocolatito-Route es lo que le permite al proxy saber en que se le va la
+     * cuota al usuario, y con un unico cliente las compactaciones —que son las
+     * llamadas mas caras que hace el agente— llegaban etiquetadas como "loop".
+     */
+    compactClient;
     currentEspectro;
     messages = [];
     tracker;
@@ -27,17 +86,36 @@ export class AgentLoop {
     hooks;
     apiKey;
     baseURL;
-    maxIterations = 30;
+    // El presupuesto de vueltas ya no esta escrito en el codigo: se lee de la
+    // configuracion del usuario, que es quien conoce su tarea y su cuota.
+    maxIterations = leerLimites().iteracionesPorTurno;
+    /**
+     * Vigila que el agente no se quede dando vueltas. Vive en la instancia y no
+     * en runTask porque el estado tiene que sobrevivir a las iteraciones del
+     * while; se reinicia en cada turno nuevo.
+     */
+    detectorBucle = new DetectorDeBucle();
+    /**
+     * Archivos escritos en el turno. Solo sirve para saber si hay algo que
+     * verificar al cerrarlo: si el turno no toco el disco, no hay nada que
+     * comprobar y correr el compilador seria tiempo del usuario tirado.
+     */
+    archivosTocados = new Set();
     constructor(apiKey, baseURL, initialModel, systemPrompt) {
         this.apiKey = apiKey;
         this.baseURL = baseURL;
         // Un unico sitio construye el cliente: asi la credencial de suscripcion y
         // las cabeceras propias llegan igual desde las cuatro rutas.
         this.client = createEngineClient(apiKey, "loop");
+        this.compactClient = createEngineClient(apiKey, "compact");
         this.currentEspectro = initialModel;
         this.tracker = new TokenTracker();
         this.permissions = new PermissionManager("default", this.currentCwd);
         this.hooks = new HookManager(this.currentCwd);
+        // Los subagentes ejecutan herramientas fuera de este bucle, y estos dos
+        // gestores no les llegan por ninguna firma. Sin registrarlos aqui, corren sin
+        // permisos, sin hooks y sin el bloqueo del modo plan.
+        registerToolGate(this.permissions, this.hooks);
         this.messages.push({
             role: "system",
             content: systemPrompt,
@@ -73,11 +151,14 @@ export class AgentLoop {
                     content: "Genera el resumen ejecutivo del contexto de trabajo hasta el momento.",
                 },
             ];
-            const res = await this.client.chat.completions.create({
+            const res = await this.compactClient.chat.completions.create({
                 model: this.currentEspectro.underlyingModel,
                 messages: summaryPrompt,
                 temperature: 0.1,
             });
+            // Resumir manda el historial ENTERO como prompt. Es dinero real y hasta
+            // ahora no lo apuntaba nadie: el pie seguia marcando el mismo porcentaje.
+            apuntarUso(res.usage, this.currentEspectro.underlyingModel, "compact");
             const summary = res.choices[0]?.message?.content || "Contexto previo compactado.";
             spinner.stop();
             this.messages = [
@@ -98,41 +179,90 @@ export class AgentLoop {
             return `Fallo al compactar historial: ${err?.message || String(err)}`;
         }
     }
+    /**
+     * Tokens que OCUPA el historial ahora mismo, no los que se han gastado en el
+     * turno. Son dos numeros distintos y confundirlos era el fallo de abajo.
+     */
     lastTurnTokens = 0;
-    async autoCompactIfNeeded() {
-        // La ventana real es de 1.000.000 de tokens. Antes se compactaba a los 16
-        // mensajes o 38k tokens, es decir al 4% de su capacidad: el agente perdia
-        // el hilo constantemente y repetia trabajo ya hecho. Ahora solo se comprime
-        // cuando de verdad se acerca el limite.
-        if (this.lastTurnTokens < COMPACT_THRESHOLD_TOKENS) {
+    /**
+     * Compactacion automatica del contexto.
+     *
+     * Habia tres cosas mal, y cada una se comia el contexto por su lado:
+     *
+     *  1. El corte era por posicion fija: slice(1, -4) para lo que se resumia y
+     *     slice(-4) para lo que se conservaba. Un turno que acaba en un bloque de
+     *     cuatro herramientas deja la cola empezando por un mensaje "tool" cuya
+     *     llamada se ha quedado en la mitad resumida. La API contesta 400 y el
+     *     catch mudo lo tapaba: la sesion se rompia sin motivo visible, y siempre
+     *     en las sesiones largas, que son las que llevan mas trabajo encima. El
+     *     corte lo decide ahora la forma del historial, nunca una posicion.
+     *
+     *  2. El umbral solo se miraba al empezar el turno y sobre el dato del turno
+     *     ANTERIOR. Un turno de veinte herramientas puede doblar el contexto sin
+     *     que nadie lo compruebe, y el limite se choca a mitad de camino.
+     *
+     *  3. Resumir cuesta una llamada al modelo y pierde detalle. Vaciar las
+     *     salidas de herramienta viejas no cuesta nada y casi siempre basta, asi
+     *     que va primero.
+     */
+    async autoCompactIfNeeded(tokensActuales = this.lastTurnTokens) {
+        // La ventana real es de 1.000.000 de tokens. Comprimir antes de acercarse
+        // al limite es tirar contexto bueno.
+        if (tokensActuales < COMPACT_THRESHOLD_TOKENS)
             return false;
+        // Paso 1, gratis: vaciar las salidas de herramienta mas viejas. Un view_file
+        // de hace veinte pasos ocupa miles de tokens y ya no dice nada; las
+        // decisiones tomadas, que son lo que hay que conservar, estan en el texto.
+        const antes = estimarTokens(this.messages);
+        const podado = vaciarResultadosAntiguos(this.messages, RESULTADOS_INTACTOS);
+        if (podado.liberados > 0) {
+            this.messages = podado.mensajes;
+            const despues = estimarTokens(this.messages);
+            // La cifra absoluta buena la da la API en prompt_tokens; de la estimacion
+            // solo se usa la proporcion de lo que se acaba de quitar.
+            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]: ") +
+                    chalk.gray(`Liberados ~${(antes - despues).toLocaleString()} tokens de salidas de herramientas antiguas. ` +
+                        "La conversacion se conserva entera.\n"));
+                return true;
+            }
         }
+        const spinner = new DynamicSpinner();
         try {
             const activeSystemPrompt = this.messages[0]?.role === "system" ? this.messages[0].content : "";
-            const toSummarize = this.messages.slice(1, -4);
-            if (toSummarize.length < 4)
+            // El corte respeta siempre los pares llamada-respuesta; si el punto que
+            // tocaba parte un bloque, se conserva de mas.
+            const corte = corteSeguro(this.messages, COLA_INTACTA);
+            const cabeza = limpiarHuerfanos(this.messages.slice(1, corte));
+            if (cabeza.length < 4)
                 return false;
-            const spinner = new DynamicSpinner();
+            const cola = this.messages.slice(corte);
             spinner.start("Auto-optimizando memoria del contexto");
             const summaryPrompt = [
                 {
                     role: "system",
                     content: "Resume de forma ultra concisa los archivos modificados, decisiones tomadas, arquitectura y estado actual del proyecto para continuar trabajando sin perder el hilo.",
                 },
-                ...toSummarize,
+                ...cabeza,
                 {
                     role: "user",
                     content: "Genera el resumen ejecutivo del contexto de trabajo previo.",
                 },
             ];
-            const res = await this.client.chat.completions.create({
+            const res = await this.compactClient.chat.completions.create({
                 model: this.currentEspectro.underlyingModel,
                 messages: summaryPrompt,
                 temperature: 0.1,
             });
+            // La llamada mas cara del agente: entra aqui con el contexto rozando el
+            // umbral (750.000 tokens) y lo manda entero. En Espectro 2.0 son ~0,99 $,
+            // el 85% del presupuesto semanal por defecto, que antes valian 0,00 $ en
+            // el contador local. De ahi el 402 por sorpresa.
+            apuntarUso(res.usage, this.currentEspectro.underlyingModel, "compact");
             const summary = res.choices[0]?.message?.content || "Contexto previo optimizado.";
             spinner.stop();
-            const recentMessages = this.messages.slice(-4);
             this.messages = [
                 { role: "system", content: activeSystemPrompt },
                 {
@@ -143,38 +273,184 @@ export class AgentLoop {
                     role: "assistant",
                     content: "Entendido. He retenido el contexto clave del proyecto y liberado memoria.",
                 },
-                ...recentMessages,
+                ...cola,
             ];
+            // 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]: ") +
                 chalk.gray(`Contexto optimizado automáticamente (${this.messages.length} mensajes limpios) para mantener alta velocidad y mínimo consumo de API.\n`));
             return true;
         }
-        catch {
+        catch (err) {
+            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)})`));
             return false;
         }
     }
+    /**
+     * Verificacion del proyecto al cerrar un turno que escribio en disco.
+     *
+     * Devuelve el mensaje que hay que reinyectarle al modelo, o null si no hay
+     * nada que corregir (o si no toca verificar). El tope de vueltas evita el
+     * otro extremo: un agente peleandose solo con el compilador durante veinte
+     * iteraciones mientras el usuario mira.
+     */
+    async verificarTrasEditar(reflexiones) {
+        if (this.archivosTocados.size === 0)
+            return null;
+        if (!verificacionAutomaticaActiva(this.currentCwd))
+            return null;
+        const cmd = detectarComando(this.currentCwd);
+        if (!cmd)
+            return null;
+        if (reflexiones >= MAX_REFLEXIONES) {
+            console.log(chalk.yellow(`\n⚠ ${mensajeDeRendicion(cmd.comando)}\n`));
+            return null;
+        }
+        const spinner = new DynamicSpinner();
+        spinner.start(`Verificando (${cmd.comando})`);
+        let resultado;
+        try {
+            resultado = await verificar(cmd.comando, this.currentCwd);
+        }
+        finally {
+            spinner.stop();
+        }
+        if (resultado.ok) {
+            console.log(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`));
+        return mensajeDeVerificacion(cmd.comando, resultado.salida, reflexiones + 1);
+    }
+    /**
+     * Comprueba si esta llamada cierra un bucle y, si lo cierra, decide con el
+     * usuario que hacer. Devuelve el texto que se le pasa al modelo: el resultado
+     * tal cual, o la explicacion del atasco.
+     *
+     * Se llama DESPUES de ejecutar, no antes, porque la firma incluye el
+     * resultado: sin el, un sondeo legitimo (releer un log que cambia) parece un
+     * bucle. La tercera llamada repetida ya se ha pagado; lo que se evita son la
+     * cuarta y las veintiseis siguientes.
+     */
+    /** Apunta que este turno ha escrito en disco, para verificarlo al cerrarlo. */
+    apuntarEscritura(herramienta, args, resultado) {
+        if (!HERRAMIENTAS_QUE_ESCRIBEN.has(herramienta))
+            return;
+        // Un edit_file que fallo no ha cambiado nada: verificar por eso seria
+        // hacerle perder tiempo al usuario por un error que ya se conto.
+        if (resultado.startsWith("Error") || resultado.includes("bloqueada:"))
+            return;
+        const ruta = args?.path || args?.destinationPath || args?.sourcePath;
+        if (typeof ruta === "string")
+            this.archivosTocados.add(ruta);
+    }
+    async vigilarBucle(herramienta, argumentos, resultado, antesDePreguntar) {
+        const aviso = this.detectorBucle.registrar(herramienta, argumentos, resultado);
+        if (!aviso)
+            return resultado;
+        antesDePreguntar?.();
+        const respuesta = await preguntarPorBucle(aviso);
+        if (respuesta.accion === "seguir") {
+            this.detectorBucle.perdonar(herramienta);
+            return resultado;
+        }
+        this.detectorBucle.olvidar();
+        return mensajeDeBucle(aviso, respuesta.indicacion);
+    }
+    /**
+     * Ejecuta un turno completo y CUENTA como acabo.
+     *
+     * Antes devolvia void: el motivo del corte se imprimia por pantalla y ahi se
+     * moria. Quien llamaba no podia distinguir "terminado" de "cuota agotada al
+     * primer intento", que es justo lo que necesita el modo no interactivo para
+     * salir con un codigo honesto.
+     */
     async runTask(userPrompt) {
+        let iterations = 0;
+        // COSTE: se paga cada llamada, asi que los prompts se suman.
+        let turnPromptTokens = 0;
+        // CONTEXTO: lo que ocupa el historial es el prompt de la ULTIMA llamada,
+        // no la suma de todas. Con la suma, un turno de diez llamadas parecia diez
+        // veces mas lleno de lo que estaba.
+        let lastCallPromptTokens = 0;
+        let turnCachedTokens = 0;
+        let turnCompletionTokens = 0;
+        /**
+         * Unica salida de runTask, y por eso el sitio donde se cierra el checkpoint
+         * de /undo.
+         *
+         * commitTurn vivia despues del while, asi que ninguna de las salidas
+         * anticipadas —Esc a mitad de turno, error del motor, cuota agotada— pasaba
+         * por el. Consecuencia doble y las dos malas: el usuario que interrumpia un
+         * turno que ya habia reescrito tres archivos leia "no hay acciones previas
+         * para deshacer" con el disco a medias; y esas instantaneas huerfanas se
+         * quedaban en currentTurnSnapshots (snapshotFile hace early-return si la
+         * clave ya existe, asi que ni se refrescaban) hasta colgarse del primer
+         * turno que terminara limpio, que al deshacerse revertia tambien los
+         * archivos del turno interrumpido anunciando otra descripcion.
+         *
+         * El motivo va en la descripcion: en el historial de /undo hay que poder
+         * distinguir un turno terminado de uno cortado.
+         */
+        const parada = (motivo, detalle) => {
+            globalUndoManager.commitTurn(motivo === "completado" ? userPrompt : `${userPrompt} [${motivo}]`);
+            return {
+                exito: motivo === "completado",
+                motivo,
+                detalle,
+                turnos: iterations,
+                tokensEntrada: turnPromptTokens,
+                tokensSalida: turnCompletionTokens,
+            };
+        };
         // 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();
         if (!cuota.allowed) {
-            console.log(chalk.yellow(`\n⏸  ${mensajeDeCorte(cuota)}`) +
+            const corte = mensajeDeCorte(cuota);
+            console.log(chalk.yellow(`\n⏸  ${corte}`) +
                 chalk.gray("\n   Tu trabajo y tu contexto siguen aqui: al liberarse, continuas donde lo dejaste.\n"));
-            return;
+            return parada("cuota", corte);
         }
         // Check and execute auto-compaction if context threshold is exceeded
         await this.autoCompactIfNeeded();
+        // El usuario ha dicho algo nuevo: lo que se repitiera en el turno anterior
+        // ya no cuenta, y lo que perdono tampoco tiene por que valer aqui.
+        this.detectorBucle.reiniciar();
         const startTime = Date.now();
         this.messages.push({
             role: "user",
             content: userPrompt,
         });
-        let iterations = 0;
-        let turnPromptTokens = 0;
-        let turnCachedTokens = 0;
-        let turnCompletionTokens = 0;
+        // Distingue "el modelo cerro su turno" de "se acabaron las iteraciones",
+        // que por fuera se parecen y no valen lo mismo.
+        let completado = false;
+        /** Un desbordamiento de contexto se rescata compactando, pero una sola vez. */
+        let yaCompactadoPorDesbordamiento = false;
+        /** Vueltas gastadas en corregir lo que dijo el verificador del proyecto. */
+        let reflexiones = 0;
+        /** Veces seguidas que la respuesta se corto por longitud sin hacer nada. */
+        let cortesPorLongitud = 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();
         while (iterations < this.maxIterations) {
             iterations++;
+            // El contexto tambien crece dentro del turno: veinte herramientas con
+            // sus salidas pueden pasar del umbral sin que termine el turno. Mirarlo
+            // solo al principio era llegar tarde.
+            if (lastCallPromptTokens > 0) {
+                const compactado = await this.autoCompactIfNeeded(lastCallPromptTokens);
+                if (compactado)
+                    lastCallPromptTokens = this.lastTurnTokens;
+            }
             // Near iteration limit notice
             if (iterations === this.maxIterations - 2) {
                 this.messages.push({
@@ -213,23 +489,37 @@ export class AgentLoop {
                 watcher.stop();
                 if (isAbortError(err) || watcher.interrupted) {
                     console.log(chalk.yellow("\n⏸  Interrumpido. Dime como seguir."));
-                    return;
+                    return parada("interrumpido");
+                }
+                // El contexto no cabe. Reintentar la misma peticion es imposible por
+                // definicion, pero compactar y volver a intentarlo si tiene arreglo, y
+                // es justo lo que el usuario esperaria en vez de perder el turno. Una
+                // 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..."));
+                    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
+                    continue;
                 }
                 // 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.
                 const claro = explicarErrorDelMotor(err);
                 if (claro) {
-                    console.log(chalk.yellow(`
-⏸  ${claro}
+                    console.log(chalk.yellow(`
+⏸  ${claro}
 `));
-                    return;
+                    return parada(motivoDeParadaDelError(err), claro);
                 }
-                renderError(`Error en el motor tras varios reintentos: ${err?.message || String(err)}`);
-                return;
+                const fallo = `Error en el motor tras varios reintentos: ${err?.message || String(err)}`;
+                renderError(fallo);
+                return parada("error-motor", fallo);
             }
             let content = "";
             let reasoning = "";
+            let motivoDeCorte = null;
             const rawToolCalls = [];
             let isFirstChunk = true;
             const reasoningStream = new ReasoningStream();
@@ -272,10 +562,17 @@ export class AgentLoop {
                                 rawToolCalls[idx].function.arguments += tc.function.arguments;
                         }
                     }
+                    // 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)
+                        motivoDeCorte = corte;
                     // Track streaming usage metrics
                     if (chunk.usage) {
                         this.tracker.addUsage(chunk.usage);
                         turnPromptTokens += chunk.usage.prompt_tokens || 0;
+                        if (chunk.usage.prompt_tokens)
+                            lastCallPromptTokens = chunk.usage.prompt_tokens;
                         turnCompletionTokens += chunk.usage.completion_tokens || 0;
                         turnCachedTokens += chunk.usage.prompt_tokens_details?.cached_tokens || 0;
                     }
@@ -293,17 +590,18 @@ export class AgentLoop {
                         this.messages.push({ role: "assistant", content });
                     }
                     console.log(chalk.yellow("\n⏸  Interrumpido. Dime como seguir."));
-                    return;
+                    return parada("interrumpido");
                 }
                 const claroStream = explicarErrorDelMotor(streamErr);
                 if (claroStream) {
-                    console.log(chalk.yellow(`
-⏸  ${claroStream}
+                    console.log(chalk.yellow(`
+⏸  ${claroStream}
 `));
-                    return;
+                    return parada(motivoDeParadaDelError(streamErr), claroStream);
                 }
-                renderError(`Error en streaming: ${streamErr?.message || String(streamErr)}`);
-                return;
+                const falloStream = `Error en streaming: ${streamErr?.message || String(streamErr)}`;
+                renderError(falloStream);
+                return parada("error-motor", falloStream);
             }
             spinner.stop();
             reasoningStream.flush();
@@ -313,10 +611,46 @@ export class AgentLoop {
                 if (content.trim())
                     this.messages.push({ role: "assistant", content });
                 console.log(chalk.yellow("\n⏸  Interrumpido antes de ejecutar las herramientas. Dime como seguir."));
-                return;
+                return parada("interrumpido");
             }
             // Filter valid accumulated tool calls
             const toolCalls = rawToolCalls.filter((tc) => tc && tc.function && tc.function.name);
+            // 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
+            // herramienta, el bucle daba el turno por cerrado, imprimia el pie y
+            // volvia al prompt. El usuario pedia "creame un juego en un archivo html",
+            // el modelo gastaba los 16.384 tokens razonando el diseno, se cortaba a
+            // mitad de frase, y no se creaba ningun archivo ni se decia por que.
+            //
+            // Se le devuelve el aviso y se le pide que actue, con tope: si a la
+            // segunda sigue sin hacer nada, el problema no es el presupuesto.
+            if (motivoDeCorte === "length" && toolCalls.length === 0) {
+                cortesPorLongitud++;
+                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`));
+                    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"));
+                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.",
+                });
+                // 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
+                // veces como vigilantes haya, y el teclado deja de responder como
+                // deberia. La regla es: de este bucle no se sale sin soltar el teclado.
+                watcher.stop();
+                continue;
+            }
             if (toolCalls.length > 0) {
                 this.messages.push({
                     role: "assistant",
@@ -330,40 +664,77 @@ export class AgentLoop {
                 const names = toolCalls.map((tc) => tc.function.name);
                 const parallel = canRunInParallel(names) &&
                     !toolCalls.some((tc) => {
-                        let a = {};
-                        try {
-                            a = JSON.parse(tc.function.arguments);
-                        }
-                        catch { }
-                        return this.permissions.requiresConfirmation(tc.function.name, a);
+                        const parsed = parsearArgumentos(tc.function.arguments);
+                        // Unos argumentos rotos se resuelven en serie, donde hay sitio para
+                        // explicarselo al modelo.
+                        if (!parsed.ok)
+                            return true;
+                        return this.permissions.requiresConfirmation(tc.function.name, parsed.args, this.currentCwd);
                     });
                 if (parallel) {
-                    for (const tc of toolCalls) {
-                        let a = {};
-                        try {
-                            a = JSON.parse(tc.function.arguments);
+                    // Esta rama ejecutaba directamente, sin pasar por hooks ni por deny.
+                    // Un PreToolUse que prohibe leer secretos se saltaba en silencio en
+                    // cuanto el modelo pedia dos lecturas en el mismo turno —cosa que el
+                    // propio prompt del sistema fomenta—, y los PostToolUse (linters,
+                    // politicas) tampoco corrian. Fallaba callado y hacia el lado
+                    // inseguro, con lo que la politica del proyecto valia o no segun
+                    // cuantas herramientas pidiera el modelo a la vez.
+                    //
+                    // La puerta es la misma que usan la via secuencial y los subagentes
+                    // (toolGate.ts). Se autoriza en serie —los hooks son procesos, y un
+                    // dialogo simultaneo por duplicado no se puede ni leer— y se
+                    // paraleliza solo la ejecucion, que es lo que se queria ganar.
+                    const autorizadas = [];
+                    const enOrden = toolCalls.map(() => null);
+                    for (let i = 0; i < toolCalls.length; i++) {
+                        const tc = toolCalls[i];
+                        const parsed = parsearArgumentos(tc.function.arguments);
+                        if (!parsed.ok) {
+                            const motivo = mensajeDeArgumentosRotos(tc.function.name);
+                            renderToolStart(tc.function.name, "argumentos incompletos");
+                            renderToolError(tc.function.name, motivo);
+                            enOrden[i] = { role: "tool", tool_call_id: tc.id, content: motivo };
+                            continue;
                         }
-                        catch { }
-                        renderToolStart(tc.function.name, getToolSummary(tc.function.name, a));
-                    }
-                    const settled = await Promise.all(toolCalls.map(async (tc) => {
-                        let a = {};
-                        try {
-                            a = JSON.parse(tc.function.arguments);
+                        const a = parsed.args;
+                        const decision = await autorizarHerramienta(tc.function.name, a, this.currentCwd);
+                        if (!decision.permitida) {
+                            const motivo = decision.motivo || "Accion no autorizada.";
+                            renderToolStart(tc.function.name, getToolSummary(tc.function.name, a));
+                            renderToolError(tc.function.name, motivo);
+                            enOrden[i] = { role: "tool", tool_call_id: tc.id, content: motivo };
+                            continue;
                         }
-                        catch { }
-                        const r = await executeToolCall(tc.function.name, a, this.currentCwd, this.apiKey, this.currentEspectro.underlyingModel);
-                        return { tc, result: r.result };
+                        autorizadas.push({ tc, args: decision.args, pos: i });
+                    }
+                    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 }) => {
+                        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, result } of settled) {
+                    for (const { tc, args, pos, result } of settled) {
                         renderToolSuccess(tc.function.name, result);
-                        toolResults.push({ role: "tool", tool_call_id: tc.id, content: result });
+                        const aviso = await notificarPostHerramienta(tc.function.name, args, result, this.currentCwd);
+                        this.apuntarEscritura(tc.function.name, args, result);
+                        const texto = await this.vigilarBucle(tc.function.name, tc.function.arguments, result);
+                        enOrden[pos] = {
+                            role: "tool",
+                            tool_call_id: tc.id,
+                            content: aviso ? `${texto}\n\n[Hook PostToolUse]: ${aviso}` : texto,
+                        };
+                    }
+                    // En el orden en que las pidio el modelo, no en el que acabaron.
+                    for (const r of enOrden) {
+                        if (r)
+                            toolResults.push(r);
                     }
                     toolResults.forEach((r) => this.messages.push(r));
                     watcher.stop();
                     if (watcher.interrupted) {
                         console.log(chalk.yellow("\n⏸  Interrumpido. Dime como seguir."));
-                        return;
+                        return parada("interrumpido");
                     }
                     continue;
                 }
@@ -380,12 +751,18 @@ export class AgentLoop {
                     }
                     const fnName = tc.function.name;
                     let fnArgs = {};
-                    try {
-                        fnArgs = JSON.parse(tc.function.arguments);
-                    }
-                    catch {
-                        fnArgs = {};
+                    const parsed = parsearArgumentos(tc.function.arguments);
+                    if (!parsed.ok) {
+                        // Antes esto era `catch { fnArgs = {} }`: la herramienta se
+                        // ejecutaba igual, sin argumentos. Un write_file sin ruta ni
+                        // contenido, y respondiendo como si nada hubiera pasado.
+                        const motivo = mensajeDeArgumentosRotos(fnName);
+                        renderToolStart(fnName, "argumentos incompletos");
+                        renderToolError(fnName, motivo);
+                        toolResults.push({ role: "tool", tool_call_id: tc.id, content: motivo });
+                        continue;
                     }
+                    fnArgs = parsed.args;
                     // PreToolUse: el usuario puede vetar, autorizar o reescribir los
                     // argumentos ANTES de que se ejecute nada. Va antes del dialogo de
                     // permiso porque un veto no deberia ni llegar a preguntarse.
@@ -419,9 +796,25 @@ export class AgentLoop {
                         });
                         continue;
                     }
+                    // Un patron de denyPatterns corta aqui, antes de todo lo demas: no se
+                    // pregunta, no lo salva el --yes, no lo salva el modo bypass y no lo
+                    // salva un hook que diga "allow". Hasta ahora esa lista se cargaba y se
+                    // volvia a guardar sin que nadie la consultara nunca.
+                    const denegado = this.permissions.deniedBy(fnName, fnArgs);
+                    if (denegado) {
+                        const motivo = `Bloqueado por denyPatterns ("${denegado}") en la configuracion del usuario.`;
+                        renderToolStart(fnName, getToolSummary(fnName, fnArgs));
+                        renderToolError(fnName, motivo);
+                        toolResults.push({
+                            role: "tool",
+                            tool_call_id: tc.id,
+                            content: `${motivo} No hay forma de aprobarlo desde aqui: el usuario lo prohibio en su settings.json. Busca otra via o preguntale.`,
+                        });
+                        continue;
+                    }
                     // Permission gate
                     const saltaPermiso = pre.permissionDecision === "allow";
-                    if (!saltaPermiso && this.permissions.requiresConfirmation(fnName, fnArgs)) {
+                    if (!saltaPermiso && this.permissions.requiresConfirmation(fnName, fnArgs, this.currentCwd)) {
                         watcher.stop();
                         const permResult = await askToolPermission(fnName, fnArgs, this.currentCwd);
                         if (!permResult.approved) {
@@ -436,8 +829,7 @@ export class AgentLoop {
                             continue;
                         }
                         if (permResult.rememberPattern) {
-                            const pat = fnArgs.command ? fnArgs.command.split(" ")[0] : fnArgs.path || fnName;
-                            this.permissions.saveAllowPattern(pat);
+                            this.recordarPermiso(fnName, fnArgs);
                         }
                     }
                     const summary = getToolSummary(fnName, fnArgs);
@@ -453,11 +845,22 @@ export class AgentLoop {
                     // PostToolUse: sirve para validar lo que acaba de pasar (linters,
                     // tests, politicas) y devolverle al modelo un aviso accionable.
                     const post = await this.hooks.run("PostToolUse", { tool_name: fnName, tool_input: fnArgs, tool_response: result.slice(0, 4000) }, fnName);
+                    // 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}`));
+                    }
+                    // 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
+                    // va a preguntar: pararlo en cada herramienta dejaria el resto del
+                    // lote sin Esc, que es justo lo que no se quiere.
+                    this.apuntarEscritura(fnName, fnArgs, result);
+                    const texto = await this.vigilarBucle(fnName, tc.function.arguments, result, () => watcher.stop());
                     toolResults.push({
                         role: "tool",
                         tool_call_id: tc.id,
-                        content: post.additionalContext ? `${result}\n\n
-[Hook PostToolUse]: ${post.additionalContext}` : result,
+                        content: post.additionalContext ? `${texto}\n\n
+[Hook PostToolUse]: ${post.additionalContext}` : texto,
                     });
                 }
                 // Push all tool results in a single turn
@@ -465,7 +868,7 @@ export class AgentLoop {
                 watcher.stop();
                 if (watcher.interrupted) {
                     console.log(chalk.yellow("\n⏸  Interrumpido. Dime como seguir."));
-                    return;
+                    return parada("interrumpido");
                 }
                 continue;
             }
@@ -478,27 +881,82 @@ export class AgentLoop {
                     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
+            // siguientes escriben encima.
+            const pendiente = await this.verificarTrasEditar(reflexiones);
+            if (pendiente) {
+                reflexiones++;
+                this.messages.push({ role: "user", content: pendiente });
+                continue;
+            }
+            completado = true;
             break;
         }
         const durationMs = Date.now() - startTime;
         const { formattedCost, totalCost } = this.tracker.calculateCost(turnPromptTokens, turnCachedTokens, turnCompletionTokens, this.currentEspectro.underlyingModel);
         const approxTotalTokens = turnPromptTokens + turnCompletionTokens;
-        this.lastTurnTokens = approxTotalTokens;
-        // El porcentaje libre se calcula sobre los tokens que ocupa el historial
-        // (el prompt del ultimo turno), no sobre prompt+salida, que contaba doble.
-        const used = turnPromptTokens || approxTotalTokens;
+        // Lo que ocupa el historial es el prompt de la ultima llamada. Sumar el de
+        // todas las iteraciones inflaba la cuenta hasta disparar la compactacion
+        // con el contexto medio vacio, y hacia mentir al porcentaje del pie.
+        this.lastTurnTokens = lastCallPromptTokens || approxTotalTokens;
+        const used = lastCallPromptTokens || turnPromptTokens || approxTotalTokens;
         const contextPercent = Math.max(1, 100 - Math.round((used / CONTEXT_WINDOW) * 100));
-        globalUndoManager.commitTurn(userPrompt);
-        // Se apunta lo gastado en este turno para las ventanas deslizantes.
+        // Se apunta lo gastado en este turno para las ventanas deslizantes. El
+        // checkpoint de /undo ya no se cierra aqui, sino en parada(): este punto
+        // solo lo alcanzaban los turnos que terminaban limpios.
         recordUsage(totalCost);
+        // Los subagentes, la vision y la compactacion ya se apuntaron solos segun
+        // gastaban. Se dice en voz alta porque si no el pie parece contradecirse:
+        // marca 0,0012 $ de turno y la insignia semanal sube diez veces mas.
+        const auxiliar = tomarGastoAuxiliar();
         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`));
+        }
         // 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`));
         }
+        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`));
+            return parada("limite-iteraciones", aviso);
+        }
+        return parada("completado");
+    }
+    /**
+     * Guarda lo que el usuario acaba de aprobar con "no preguntar mas".
+     *
+     * Aqui se hacia command.split(" ")[0] y se guardaba solo el binario. Aprobar
+     * un "git status" dejaba el patron "git" escrito en .chocolatito/settings.json
+     * y, como el allow autoriza por prefijo, a partir de ese momento pasaban sin
+     * dialogo "git push --force" y "git reset --hard", en esa sesion y en todas
+     * las siguientes. Un solo si de mas y el proyecto se queda sin barrera.
+     *
+     * Ahora se guarda la firma del comando (binario mas subcomando) y, si el
+     * comando es de los destructivos, no se guarda nada: eso se pregunta siempre,
+     * y decirlo en voz alta es mejor que escribir un patron que no serviria.
+     */
+    recordarPermiso(fnName, fnArgs) {
+        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"));
+                return;
+            }
+            const firma = commandSignature(command);
+            if (firma)
+                this.permissions.saveAllowPattern(`${fnName}:${firma}`);
+            return;
+        }
+        this.permissions.saveAllowPattern(fnArgs?.path || fnName);
     }
 }
 function getToolSummary(name, args) {