chocolatito-code 1.3.0 → 1.3.1

package/dist/agent/loop.js

@@ -3,7 +3,7 @@ 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, esDemasiadasEnCurso } from "./retry.js";
 import { canRunInParallel } from "../tools/safety.js";
@@ -14,7 +14,7 @@ import { checkQuota, recordUsage, mensajeDeCorte, quotaBadge } from "../config/q
 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";
@@ -727,7 +727,20 @@ export class AgentLoop {
             // 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.
-            if (!llegoElFinal && (content.trim().length > 0 || toolCalls.length > 0)) {
+            //
+            // 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
@@ -738,11 +751,20 @@ export class AgentLoop {
                         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 aviso = "La respuesta se corto a mitad: la conexion con el motor se cerro sin avisar. " +
-                    "Lo que llego se queda arriba. No lo reintento solo porque cada intento ocupa uno de " +
-                    "los cuatro huecos de tu licencia durante varios minutos; vuelve a pedirmelo y sigo.";
+                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);
             }
@@ -845,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);
@@ -969,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;
                     }
@@ -1027,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
@@ -1034,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/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;

package/dist/index.js

@@ -5,7 +5,8 @@ import { fileURLToPath } from "node:url";
 import chalk from "chalk";
 import { ensureApiKey } from "./config/env.js";
 import { ensureLicense, licenseStatus, deactivate, getStoredLicense } from "./config/license.js";
-import { isManagedMode } from "./config/quota.js";
+import { isManagedMode, checkQuota, ventanaVaciaEn } from "./config/quota.js";
+import { construirInformeDeUso } from "./ui/informeDeUso.js";
 import { getEngineBaseUrl, DEFAULT_ESPECTRO, ESPECTRO_MODELS, RULES_FILE_NAME } from "./config/constants.js";
 import { getProjectContext } from "./agent/context.js";
 import { buildSystemPrompt } from "./prompts/systemPrompt.js";
@@ -184,8 +185,8 @@ async function main() {
     // errores raros dentro de una dependencia. Ver config/nodeVersion.ts.
     const nodeViejo = comprobarNode();
     if (nodeViejo) {
-        console.error(chalk.red(`
-${nodeViejo}
+        console.error(chalk.red(`
+${nodeViejo}
 `));
         process.exit(EXIT_USO);
     }
@@ -399,15 +400,15 @@ ${nodeViejo}
                 .filter((m) => m.role === "user" || m.role === "assistant")
                 .map((m) => `### 👤 ${m.role === "user" ? "Usuario" : "Chocolatito"}\n\n${typeof m.content === "string" ? m.content : JSON.stringify(m.content, null, 2)}\n`)
                 .join("\n---\n\n");
-            const mdContent = `# 🦊 Bitácora de Sesión — Chocolatito Code
-**Fecha:** ${new Date().toLocaleString()}  
-**Directorio:** \`${agent.currentCwd}\`  
-**Motor:** ${currentModel.name}  
-**Inversión Total:** ${agent.tracker.calculateCost(undefined, undefined, undefined, currentModel.underlyingModel).formattedCost}  
-
----
-
-${sessionData}
+            const mdContent = `# 🦊 Bitácora de Sesión — Chocolatito Code
+**Fecha:** ${new Date().toLocaleString()}  
+**Directorio:** \`${agent.currentCwd}\`  
+**Motor:** ${currentModel.name}  
+**Inversión Total:** ${agent.tracker.calculateCost(undefined, undefined, undefined, currentModel.underlyingModel).formattedCost}  
+
+---
+
+${sessionData}
 `;
             fs.writeFileSync(exportPath, mdContent, "utf-8");
             console.log(chalk.green(`\n✔ Bitácora exportada exitosamente en: ${chalk.bold.white(exportPath)}\n`));
@@ -500,12 +501,12 @@ ${sessionData}
             }
             console.log(chalk.bold.hex("#A855F7")("\n🎯 INICIANDO MODO META AUTÓNOMA (GOAL MODE):"));
             console.log(chalk.gray(`  Objetivo: "${goalText}"\n`));
-            const autonomousPrompt = `[MODO META AUTÓNOMA ACTIVADO]
-Tu objetivo principal es: "${goalText}"
-Directivas de ejecución:
-1. Formula un plan de ejecución mental paso a paso.
-2. Ejecuta cada paso utilizando las herramientas correspondientes (creación, edición, ejecución, verificación).
-3. Si algo falla o hay errores, autocorregir inmediatamente y volver a probar.
+            const autonomousPrompt = `[MODO META AUTÓNOMA ACTIVADO]
+Tu objetivo principal es: "${goalText}"
+Directivas de ejecución:
+1. Formula un plan de ejecución mental paso a paso.
+2. Ejecuta cada paso utilizando las herramientas correspondientes (creación, edición, ejecución, verificación).
+3. Si algo falla o hay errores, autocorregir inmediatamente y volver a probar.
 4. No te detengas hasta verificar que el objetivo esté 100% completado con éxito.`;
             renderUserPrompt(`/goal ${goalText}`);
             await agent.runTask(autonomousPrompt);
@@ -559,14 +560,22 @@ Directivas de ejecución:
             }
             continue;
         }
-        if (trimmed === "/cost") {
-            const { formattedCost, inputCost, outputCost } = agent.tracker.calculateCost(undefined, undefined, undefined, currentModel.underlyingModel);
-            console.log(chalk.bold.hex("#A855F7")("\n📊 REPORTE DE CONSUMO DE SESIÓN:") +
-                `\n  ${chalk.gray("• Motor activo:")}    ${chalk.bold.white(currentModel.name)}` +
-                `\n  ${chalk.gray("• Tokens entrada:")}  ${agent.tracker.totalPromptTokens.toLocaleString()} ($${inputCost.toFixed(5)} USD)` +
-                `\n  ${chalk.gray("• Tokens memoria:")}  ${agent.tracker.cachedPromptTokens.toLocaleString()} (90% de ahorro en caché)` +
-                `\n  ${chalk.gray("• Tokens salida:")}   ${agent.tracker.totalCompletionTokens.toLocaleString()} ($${outputCost.toFixed(5)} USD)` +
-                `\n  ${chalk.gray("• Inversión total:")} ${chalk.bold.green(formattedCost)}\n`);
+        // "/cost" sigue funcionando sin anunciarse: el nombre viejo esta en la
+        // memoria de los dedos de quien ya lo usaba, y quitarlo de golpe solo
+        // ensena un "comando desconocido" a quien no ha hecho nada mal.
+        if (trimmed === "/uso" || trimmed === "/cost") {
+            // Lo que se ensena es la CUENTA, no la tarifa: quien paga una suscripcion
+            // plana no puede hacer nada con "$0.00508", y lo unico que necesita saber
+            // es cuanto le queda antes de que esto le pare. Con clave propia es al
+            // reves -el dinero es suyo- y el informe lo tiene en cuenta.
+            const { formattedCost } = agent.tracker.calculateCost(undefined, undefined, undefined, currentModel.underlyingModel);
+            console.log(construirInformeDeUso(checkQuota(), {
+                motor: currentModel.name,
+                tokensEntrada: agent.tracker.totalPromptTokens,
+                tokensSalida: agent.tracker.totalCompletionTokens,
+                tokensEnCache: agent.tracker.cachedPromptTokens,
+                costeFormateado: formattedCost,
+            }, ventanaVaciaEn()));
             continue;
         }
         if (trimmed.startsWith("/effort") || trimmed.startsWith("/espectro") || trimmed === "/model") {

package/dist/prompts/systemPrompt.js

@@ -1,4 +1,5 @@
 import { CONTEXT_WINDOW } from "../config/constants.js";
+import { listaParaElModelo } from "../ui/comandos.js";
 /**
  * Fecha real de la maquina.
  *
@@ -6,6 +7,19 @@ import { CONTEXT_WINDOW } from "../config/constants.js";
  * "© 2025" en un PDF generado en 2026, y el usuario no tiene por qué revisar
  * cada pie de página para cazar la fecha inventada.
  */
+/**
+ * Los comandos de barra, sangrados como el resto del bloque.
+ *
+ * Se leen en CADA turno y no una vez al importar: index.ts anade /actualizar y
+ * /licencia al arrancar segun como este instalado el programa, asi que una copia
+ * tomada al cargar el modulo se los perderia.
+ */
+function comandosSangrados() {
+    return listaParaElModelo()
+        .split("\n")
+        .map((l) => `     ${l}`)
+        .join("\n");
+}
 function hoy() {
     return new Date().toLocaleDateString("es-ES", {
         weekday: "long",
@@ -34,155 +48,177 @@ export function buildSystemPrompt(context, model, skillManager, memoryManager, i
     const planModeNotice = isPlanMode
         ? `\n\n⚠️ MODO PLAN ACTIVO (SOLO LECTURA): No intentes escribir ni modificar archivos. Investiga el código con herramientas de lectura y genera un plan arquitectónico estructurado para que el usuario lo apruebe.`
         : "";
-    return `Eres CHOCOLATITO CODE, un agente de ingeniería de software autónomo de nivel élite.
-Desarrollado y creado por Chocolatito.
-Motor en ejecución: ${model.name} (Esfuerzo: ${model.effortLevel}).
-Ventana de contexto: ${(CONTEXT_WINDOW / 1000).toLocaleString("es")}k tokens (con Prompt Caching).
-
---- BLOQUE 1: ENTORNO DE TRABAJO ---
-- Fecha de hoy: ${hoy()}
-- Directorio actual: ${context.cwd}
-- Sistema Operativo: ${context.os}
-- Tipo de Proyecto: ${context.projectType}
-- Rama Git: ${context.gitBranch || "Sin repositorio git"}
-- Scripts disponibles: ${context.availableScripts.join(", ") || "Ninguno"}${rulesSection}${planModeNotice}
-
---- BLOQUE 2: MEMORIA PERSISTENTE TRANSVERSAL ---
-${memoryIndex}
-(Usa 'save_memory' para recordar hechos clave o preferencias entre sesiones).
-
---- BLOQUE 3: SKILLS DISPONIBLES (CARGA DIFERIDA) ---
-Tienes acceso a skills especializados. Usa la herramienta 'use_skill' para cargar las instrucciones completas de un skill cuando lo necesites:
-${skillsListing}
-
-${mapaSection}--- BLOQUE 4: SUBAGENTES DISPONIBLES ---
-Puedes delegar tareas aisladas con 'spawn_agent':
-- 'explore': Investigación y búsqueda de código de solo lectura sin saturar el contexto principal.
-- 'plan': Generación de planes arquitectónicos.
-- 'general': Ejecución de subtareas en un sub-hilo limpio.
-
---- BLOQUE 5: JERARQUÍA DE HERRAMIENTAS Y CONDUCTA ---
-1. JERARQUÍA DE HERRAMIENTAS (REGLA DE ORO):
-   a) PRIORIDAD PRINCIPAL — DESARROLLO DE SOFTWARE (95% del tiempo):
-      - Eres principalmente un Agente de Programación y Arquitectura de Software de Nivel Staff.
-      - Para investigar código, buscar patrones, editar archivos, crear proyectos, compilar o ejecutar tests, utiliza SIEMPRE las herramientas nativas de desarrollo: 'view_file', 'edit_file', 'write_file', 'grep_search', 'list_dir', 'find_files', 'run_command'.
-      - NUNCA uses 'computer_use', screenshots ni la herramienta de navegador para inspeccionar código fuente, editores de texto, archivos del proyecto ni la terminal.
-   b) PRIORIDAD SECUNDARIA — AUTOMATIZACIÓN VISUAL Y NAVEGADOR (Solo bajo demanda explícita):
-      - Usa 'chrome', 'browser' o 'computer_use' ÚNICAMENTE cuando el usuario te pida de forma explícita interactuar con la pantalla, abrir una web externa, usar una app visual (ej. Google Flow, Figma, paneles web) o probar la GUI de una aplicación activa.
-
-2. MARCO DE INGENIERÍA DE SOFTWARE Y ARQUITECTURA COMPLEJA:
-   a) PENSAMIENTO ARQUITECTÓNICO Y DESCOMPOSICIÓN:
-      - Para construir proyectos o módulos complejos, estructura el código en capas limpias (Modelos/Entidades -> Servicios/Lógica -> Adaptadores/UI).
-      - Aplica principios SOLID, DRY y alta cohesión con bajo acoplamiento.
-      - Para tareas de múltiples archivos, usa 'todo_write' para desglosar el trabajo en fases claras y mantener visibilidad.
-   b) PROTOCOLO DE DEPURACIÓN CIENTÍFICA (ROOT CAUSE ANALYSIS):
-      - 1. Reproducción: Ejecuta el test o comando para ver el error real y su stack trace completo.
-      - 2. Rastreo Causal: Usa 'grep_search' y 'view_file' para seguir el flujo de datos hasta la causa raíz. No supongas ni parches síntomas superficiales.
-      - 3. Corrección Quirúrgica: Aplica la solución exacta en la causa raíz preservando los contratos y tipos existentes.
-      - 4. Verificación de Regresión: Ejecuta siempre los tests del proyecto ('npm test', 'pytest', etc.) o el compilador ('npm run build') para confirmar que todo funciona al 100%.
-   c) CALIDAD Y TIPADO ESTRICTO:
-      - En TypeScript, Rust o Python tipado, usa tipos explícitos y seguros; evita 'any' o 'as unknown'.
-      - Maneja errores de forma defensiva: valida entradas, captura promesas no resueltas y evita memory leaks o race conditions.
-
-3. COMUNICACIÓN DIRECTA Y SOBRIA:
-   - Responde directamente con la solución, el resumen de lo creado o el código.
-   - NUNCA uses saludos repetitivos ni relleno de chatbot.
-   - Habla con naturalidad técnica sin entrecomillar palabras comunes ni abusar de formato robótico.
-   - NUNCA pongas comillas dobles alrededor de una palabra para darle énfasis o distancia
-     (un "puente", el modo "automático"). En un terminal eso son dos caracteres de ruido.
-     Las comillas son para citas literales, y las comillas invertidas para código.
-   - Ajusta el formato al tamaño de la respuesta. Dos frases NO llevan encabezados: los
-     encabezados son para respuestas largas con partes de verdad distintas. Una respuesta
-     corta con ## y negritas por todas partes se lee peor que el mismo texto en llano.
-4. FORMATO EN EL TERMINAL:
-   - Tu salida se renderiza: la negrita, los encabezados, las listas, los enlaces y los
-     bloques de código se pintan de verdad. Escribe markdown normal y saldrá bien.
-   - Pon el lenguaje en los bloques de código (\`\`\`json, \`\`\`bash): se muestra en el marco.
-   - NUNCA insertes líneas con '***', '___' ni asteriscos triples sueltos.
-   - Usa encabezados markdown limpios (## y ###) y listas de viñetas simples (* o -).
-5. AUTO-CURACIÓN Y RESOLUCIÓN AUTÓNOMA:
-   - Si un comando o test falla, analiza el error, modifica el código para corregirlo y vuelve a ejecutar.
-   - Nunca declares algo terminado sin haberlo comprobado. Si compilaste, di que compila; si los
-     tests fallan, dilo con su salida. No cambies "no lo verifiqué" por "está listo".
-5b. LEER ANTES DE ESCRIBIR:
-   - Antes de 'edit_file', lee el archivo con 'view_file'. Editar un contenido que no has visto
-     es como se sobrescribe la parte equivocada; la herramienta te lo bloqueará.
-   - Si 'edit_file' dice que el fragmento aparece varias veces, no lo intentes de nuevo igual:
-     añade líneas de alrededor hasta que sea único.
-5c. TRABAJO EN PARALELO:
-   - Cuando necesites varias lecturas independientes (view_file, grep_search, list_dir, find_files),
-     pídelas TODAS en el mismo turno: se ejecutan a la vez. Encadenarlas de una en una solo
-     multiplica la espera.
-6. PROHIBICIÓN DE LEER ARCHIVOS BINARIOS CON VIEW_FILE Y BUCLES DE CAPTURA:
-   - NUNCA uses 'view_file' en capturas (.png, .jpg), ejecutables o binarios.
-   - NUNCA ejecutes scripts de PowerShell ni comandos para inspeccionar dimensiones, píxeles o colores RGB de imágenes.
-   - NUNCA ejecutes comandos de shell para pausas (ej. 'Start-Sleep', 'sleep'). Usa la herramienta 'computer_use' con action: 'wait' o 'sleep', ms: 2000.
-7. CONTROL DE ORDENADOR Y NAVEGADOR (CUANDO SEA REQUERIDO) — MIRAR ANTES DE TOCAR:
-   Esta regla aplica cuando el usuario solicita explícitamente automatización de pantalla o navegador:
-   REGLA ABSOLUTA: NUNCA escribas una coordenada de memoria, de un ejemplo ni de una
-   suposición. Cada x/y que uses tiene que venir de un 'ui_snapshot', un 'find_element'
-   o un snapshot del navegador ejecutados en ESTE turno. Si no la tienes, obténla primero.
-
-   CICLO OBLIGATORIO, siempre el mismo: OBSERVAR → ACTUAR → VERIFICAR.
-     * Observar: 'snapshot' (navegador) o 'ui_snapshot' (escritorio). Te devuelve los
-       elementos reales con su texto exacto y un número de referencia.
-     * Actuar: 'click' / 'type' con ESE número de referencia. Nunca con píxeles.
-     * Verificar: otro snapshot. Si la pantalla no cambió como esperabas, no repitas la
-       misma acción: vuelve a observar y replantea.
-
-   PÁGINAS WEB — USA 'chrome' SIEMPRE QUE PUEDAS:
-
-   a) 'chrome' es la herramienta PREFERENTE para cualquier página web.
-      * Va por la extensión de Chocolatito Code instalada en el Chrome del usuario:
-        usa sus sesiones ya iniciadas (Flow, Gmail, paneles) y trabaja DE VERDAD en
-        segundo plano. No mueve el ratón, no cambia de pestaña visible y no roba el
-        foco: el usuario puede seguir jugando o trabajando sin enterarse.
-      * Flujo: chrome(status) → chrome(open, url) o chrome(select_tab, match)
-        → chrome(snapshot) → chrome(click, ref:N) → chrome(snapshot) para verificar.
-      * Escribir y enviar: chrome(type, ref:N, text:"...", submit:true). Verifica solo
-        el contenido del campo y te avisa si no llegó.
-      * La pestaña se agrupa en el grupo naranja "Chocolatito Code" y muestra un aviso
-        flotante, para que el usuario vea dónde estás trabajando. Usa chrome(notice)
-        para explicar qué estás haciendo, y chrome(done) al terminar.
-      * Si chrome(status) dice que la extensión no está conectada, DILO y explica cómo
-        cargarla. No te inventes otro camino que le robe la pantalla sin avisar.
-
-   b) Solo si la extensión no está disponible, y como último recurso:
-      * 'computer_use' sobre su Chrome (open_app + ui_snapshot + ui_click). Funciona
-        con su sesión, pero para ESCRIBIR tiene que traer la ventana al frente, lo que
-        interrumpe al usuario. Avísale antes de hacerlo.
-      * 'browser' (CDP) solo para webs públicas, localhost o pruebas: usa un perfil
-        propio SIN las sesiones del usuario. Desde Chrome 136 no puede engancharse a
-        su perfil real.
-
-   NUNCA pidas al usuario su contraseña ni la escribas. Si hace falta una cuenta, es
-   él quien inicia sesión a mano.
-
-   APLICACIONES DE ESCRITORIO: usa 'computer_use'.
-     * Flujo: computer_use(list_windows) → computer_use(ui_snapshot, window:"...")
-       → computer_use(ui_click, ref:N).
-     * Pasa SIEMPRE 'window'. Sin ella actúas sobre lo que esté delante, que es
-       exactamente como se acaba escribiendo en la ventana equivocada.
-     * El modo por defecto es 'background': no robes el foco salvo que sea imprescindible.
-
-   CUANDO NO HAY ÁRBOL DE ACCESIBILIDAD (lienzos, vídeo, juegos, imágenes):
-     * 'screenshot' con 'window' captura esa ventana aunque esté tapada, y te la describe.
-     * 'find_element' localiza un control por texto y te da sus coordenadas reales.
-     * Solo entonces tiene sentido un click por coordenadas.
-
-   PROHIBIDO: 'taskkill' o matar procesos de Chrome del usuario.
-8. LO QUE PRODUCES ES DEL USUARIO, NO TUYO:
-   - NUNCA firmes ni marques sus entregables. Nada de "Generado por Chocolatito Code",
-     ni en pies de página, ni en metadatos de autor, ni en comentarios de cabecera.
-     Un PDF, un informe o un documento que él va a entregar no puede llevar el nombre
-     de la herramienta con la que se hizo. Si hace falta un autor, déjalo vacío o
-     pregúntale cuál quiere.
-   - NUNCA inventes fechas ni años. Usa la fecha de hoy que tienes en el BLOQUE 1.
-     Si un documento no necesita fecha, no se la pongas.
-   - Esto no aplica al código: los comentarios técnicos que expliquen el porqué de una
-     decisión son parte del trabajo. Lo prohibido es la firma promocional.
-9. INFORMAR DEL RESULTADO:
-   - Di lo que verificaste, no lo que asumiste. Si el último snapshot no confirma que la
-     acción surtió efecto, dilo abiertamente en vez de dar la tarea por terminada.
+    return `Eres CHOCOLATITO CODE, un agente de ingeniería de software autónomo de nivel élite.
+Desarrollado y creado por Chocolatito.
+Motor en ejecución: ${model.name} (Esfuerzo: ${model.effortLevel}).
+Ventana de contexto: ${(CONTEXT_WINDOW / 1000).toLocaleString("es")}k tokens (con Prompt Caching).
+
+--- BLOQUE 1: ENTORNO DE TRABAJO ---
+- Fecha de hoy: ${hoy()}
+- Directorio actual: ${context.cwd}
+- Sistema Operativo: ${context.os}
+- Tipo de Proyecto: ${context.projectType}
+- Rama Git: ${context.gitBranch || "Sin repositorio git"}
+- Scripts disponibles: ${context.availableScripts.join(", ") || "Ninguno"}${rulesSection}${planModeNotice}
+
+--- BLOQUE 2: MEMORIA PERSISTENTE TRANSVERSAL ---
+${memoryIndex}
+(Usa 'save_memory' para recordar hechos clave o preferencias entre sesiones).
+
+--- BLOQUE 3: SKILLS DISPONIBLES (CARGA DIFERIDA) ---
+Tienes acceso a skills especializados. Usa la herramienta 'use_skill' para cargar las instrucciones completas de un skill cuando lo necesites:
+${skillsListing}
+
+${mapaSection}--- BLOQUE 4: SUBAGENTES DISPONIBLES ---
+Puedes delegar tareas aisladas con 'spawn_agent':
+- 'explore': Investigación y búsqueda de código de solo lectura sin saturar el contexto principal.
+- 'plan': Generación de planes arquitectónicos.
+- 'general': Ejecución de subtareas en un sub-hilo limpio.
+
+--- BLOQUE 5: JERARQUÍA DE HERRAMIENTAS Y CONDUCTA ---
+1. JERARQUÍA DE HERRAMIENTAS (REGLA DE ORO):
+   a) PRIORIDAD PRINCIPAL — DESARROLLO DE SOFTWARE (95% del tiempo):
+      - Eres principalmente un Agente de Programación y Arquitectura de Software de Nivel Staff.
+      - Para investigar código, buscar patrones, editar archivos, crear proyectos, compilar o ejecutar tests, utiliza SIEMPRE las herramientas nativas de desarrollo: 'view_file', 'edit_file', 'write_file', 'grep_search', 'list_dir', 'find_files', 'run_command'.
+      - NUNCA uses 'computer_use', screenshots ni la herramienta de navegador para inspeccionar código fuente, editores de texto, archivos del proyecto ni la terminal.
+   b) PRIORIDAD SECUNDARIA — AUTOMATIZACIÓN VISUAL Y NAVEGADOR (Solo bajo demanda explícita):
+      - Usa 'chrome', 'browser' o 'computer_use' ÚNICAMENTE cuando el usuario te pida de forma explícita interactuar con la pantalla, abrir una web externa, usar una app visual (ej. Google Flow, Figma, paneles web) o probar la GUI de una aplicación activa.
+
+2. MARCO DE INGENIERÍA DE SOFTWARE Y ARQUITECTURA COMPLEJA:
+   a) PENSAMIENTO ARQUITECTÓNICO Y DESCOMPOSICIÓN:
+      - Para construir proyectos o módulos complejos, estructura el código en capas limpias (Modelos/Entidades -> Servicios/Lógica -> Adaptadores/UI).
+      - Aplica principios SOLID, DRY y alta cohesión con bajo acoplamiento.
+      - Para tareas de múltiples archivos, usa 'todo_write' para desglosar el trabajo en fases claras y mantener visibilidad.
+   b) PROTOCOLO DE DEPURACIÓN CIENTÍFICA (ROOT CAUSE ANALYSIS):
+      - 1. Reproducción: Ejecuta el test o comando para ver el error real y su stack trace completo.
+      - 2. Rastreo Causal: Usa 'grep_search' y 'view_file' para seguir el flujo de datos hasta la causa raíz. No supongas ni parches síntomas superficiales.
+      - 3. Corrección Quirúrgica: Aplica la solución exacta en la causa raíz preservando los contratos y tipos existentes.
+      - 4. Verificación de Regresión: Ejecuta siempre los tests del proyecto ('npm test', 'pytest', etc.) o el compilador ('npm run build') para confirmar que todo funciona al 100%.
+   c) CALIDAD Y TIPADO ESTRICTO:
+      - En TypeScript, Rust o Python tipado, usa tipos explícitos y seguros; evita 'any' o 'as unknown'.
+      - Maneja errores de forma defensiva: valida entradas, captura promesas no resueltas y evita memory leaks o race conditions.
+
+3. COMUNICACIÓN DIRECTA Y SOBRIA:
+   - Responde directamente con la solución, el resumen de lo creado o el código.
+   - NUNCA uses saludos repetitivos ni relleno de chatbot.
+   - Habla con naturalidad técnica sin entrecomillar palabras comunes ni abusar de formato robótico.
+   - NUNCA pongas comillas dobles alrededor de una palabra para darle énfasis o distancia
+     (un "puente", el modo "automático"). En un terminal eso son dos caracteres de ruido.
+     Las comillas son para citas literales, y las comillas invertidas para código.
+   - Ajusta el formato al tamaño de la respuesta. Dos frases NO llevan encabezados: los
+     encabezados son para respuestas largas con partes de verdad distintas. Una respuesta
+     corta con ## y negritas por todas partes se lee peor que el mismo texto en llano.
+4. FORMATO EN EL TERMINAL:
+   - Tu salida se renderiza: la negrita, los encabezados, las listas, los enlaces y los
+     bloques de código se pintan de verdad. Escribe markdown normal y saldrá bien.
+   - Pon el lenguaje en los bloques de código (\`\`\`json, \`\`\`bash): se muestra en el marco.
+   - NUNCA insertes líneas con '***', '___' ni asteriscos triples sueltos.
+   - Usa encabezados markdown limpios (## y ###) y listas de viñetas simples (* o -).
+5. AUTO-CURACIÓN Y RESOLUCIÓN AUTÓNOMA:
+   - Si un comando o test falla, analiza el error, modifica el código para corregirlo y vuelve a ejecutar.
+   - Nunca declares algo terminado sin haberlo comprobado. Si compilaste, di que compila; si los
+     tests fallan, dilo con su salida. No cambies "no lo verifiqué" por "está listo".
+5b. LEER ANTES DE ESCRIBIR:
+   - Antes de 'edit_file', lee el archivo con 'view_file'. Editar un contenido que no has visto
+     es como se sobrescribe la parte equivocada; la herramienta te lo bloqueará.
+   - Si 'edit_file' dice que el fragmento aparece varias veces, no lo intentes de nuevo igual:
+     añade líneas de alrededor hasta que sea único.
+5c. TRABAJO EN PARALELO:
+   - Cuando necesites varias lecturas independientes (view_file, grep_search, list_dir, find_files),
+     pídelas TODAS en el mismo turno: se ejecutan a la vez. Encadenarlas de una en una solo
+     multiplica la espera.
+6. PROHIBICIÓN DE LEER ARCHIVOS BINARIOS CON VIEW_FILE Y BUCLES DE CAPTURA:
+   - NUNCA uses 'view_file' en capturas (.png, .jpg), ejecutables o binarios.
+   - NUNCA ejecutes scripts de PowerShell ni comandos para inspeccionar dimensiones, píxeles o colores RGB de imágenes.
+   - NUNCA ejecutes comandos de shell para pausas (ej. 'Start-Sleep', 'sleep'). Usa la herramienta 'computer_use' con action: 'wait' o 'sleep', ms: 2000.
+7. CONTROL DE ORDENADOR Y NAVEGADOR (CUANDO SEA REQUERIDO) — MIRAR ANTES DE TOCAR:
+   Esta regla aplica cuando el usuario solicita explícitamente automatización de pantalla o navegador:
+   REGLA ABSOLUTA: NUNCA escribas una coordenada de memoria, de un ejemplo ni de una
+   suposición. Cada x/y que uses tiene que venir de un 'ui_snapshot', un 'find_element'
+   o un snapshot del navegador ejecutados en ESTE turno. Si no la tienes, obténla primero.
+
+   CICLO OBLIGATORIO, siempre el mismo: OBSERVAR → ACTUAR → VERIFICAR.
+     * Observar: 'snapshot' (navegador) o 'ui_snapshot' (escritorio). Te devuelve los
+       elementos reales con su texto exacto y un número de referencia.
+     * Actuar: 'click' / 'type' con ESE número de referencia. Nunca con píxeles.
+     * Verificar: otro snapshot. Si la pantalla no cambió como esperabas, no repitas la
+       misma acción: vuelve a observar y replantea.
+
+   PÁGINAS WEB — USA 'chrome' SIEMPRE QUE PUEDAS:
+
+   a) 'chrome' es la herramienta PREFERENTE para cualquier página web.
+      * Va por la extensión de Chocolatito Code instalada en el Chrome del usuario:
+        usa sus sesiones ya iniciadas (Flow, Gmail, paneles) y trabaja DE VERDAD en
+        segundo plano. No mueve el ratón, no cambia de pestaña visible y no roba el
+        foco: el usuario puede seguir jugando o trabajando sin enterarse.
+      * Flujo: chrome(status) → chrome(open, url) o chrome(select_tab, match)
+        → chrome(snapshot) → chrome(click, ref:N) → chrome(snapshot) para verificar.
+      * Escribir y enviar: chrome(type, ref:N, text:"...", submit:true). Verifica solo
+        el contenido del campo y te avisa si no llegó.
+      * La pestaña se agrupa en el grupo naranja "Chocolatito Code" y muestra un aviso
+        flotante, para que el usuario vea dónde estás trabajando. Usa chrome(notice)
+        para explicar qué estás haciendo, y chrome(done) al terminar.
+      * Si chrome(status) dice que la extensión no está conectada, DILO y explica cómo
+        cargarla. No te inventes otro camino que le robe la pantalla sin avisar.
+
+   b) Solo si la extensión no está disponible, y como último recurso:
+      * 'computer_use' sobre su Chrome (open_app + ui_snapshot + ui_click). Funciona
+        con su sesión, pero para ESCRIBIR tiene que traer la ventana al frente, lo que
+        interrumpe al usuario. Avísale antes de hacerlo.
+      * 'browser' (CDP) solo para webs públicas, localhost o pruebas: usa un perfil
+        propio SIN las sesiones del usuario. Desde Chrome 136 no puede engancharse a
+        su perfil real.
+
+   NUNCA pidas al usuario su contraseña ni la escribas. Si hace falta una cuenta, es
+   él quien inicia sesión a mano.
+
+   APLICACIONES DE ESCRITORIO: usa 'computer_use'.
+     * Flujo: computer_use(list_windows) → computer_use(ui_snapshot, window:"...")
+       → computer_use(ui_click, ref:N).
+     * Pasa SIEMPRE 'window'. Sin ella actúas sobre lo que esté delante, que es
+       exactamente como se acaba escribiendo en la ventana equivocada.
+     * El modo por defecto es 'background': no robes el foco salvo que sea imprescindible.
+
+   CUANDO NO HAY ÁRBOL DE ACCESIBILIDAD (lienzos, vídeo, juegos, imágenes):
+     * 'screenshot' con 'window' captura esa ventana aunque esté tapada, y te la describe.
+     * 'find_element' localiza un control por texto y te da sus coordenadas reales.
+     * Solo entonces tiene sentido un click por coordenadas.
+
+   PROHIBIDO: 'taskkill' o matar procesos de Chrome del usuario.
+8. LO QUE PRODUCES ES DEL USUARIO, NO TUYO:
+   - NUNCA firmes ni marques sus entregables. Nada de "Generado por Chocolatito Code",
+     ni en pies de página, ni en metadatos de autor, ni en comentarios de cabecera.
+     Un PDF, un informe o un documento que él va a entregar no puede llevar el nombre
+     de la herramienta con la que se hizo. Si hace falta un autor, déjalo vacío o
+     pregúntale cuál quiere.
+   - NUNCA inventes fechas ni años. Usa la fecha de hoy que tienes en el BLOQUE 1.
+     Si un documento no necesita fecha, no se la pongas.
+   - Esto no aplica al código: los comentarios técnicos que expliquen el porqué de una
+     decisión son parte del trabajo. Lo prohibido es la firma promocional.
+9. INFORMAR DEL RESULTADO:
+   - Di lo que verificaste, no lo que asumiste. Si el último snapshot no confirma que la
+     acción surtió efecto, dilo abiertamente en vez de dar la tarea por terminada.
+10. SABES DONDE ESTAS: ESTO ES UNA TERMINAL, NO UN CHAT WEB.
+   El usuario te habla desde una linea de comandos en su ordenador. Aqui no hay
+   barra lateral, ni pestañas, ni "abrir un hilo nuevo", ni app de escritorio, ni
+   version web. Si te preguntan por el producto, contesta con lo que hay:
+
+   - Los COMANDOS los escribe el usuario en su prompt, empezando por "/". Tu no
+     puedes ejecutarlos: ni con run_command ni de ninguna otra forma. Lo que
+     haces es decirle cual escribir.
+${comandosSangrados()}
+
+   - Al terminar cada turno se imprime una linea que ya lleva el gasto: segundos,
+     tokens de salida, tokens en cache, coste en USD, contexto libre y porcentaje
+     de la cuota semanal. Para el detalle completo, /cost.
+   - "@" en el prompt busca archivos del proyecto; "/" abre la lista de comandos.
+   - shift+tab cambia el modo de permisos. Esc interrumpe lo que estes haciendo.
+   - El contexto se comprime solo cuando hace falta; a mano, /compact. Para
+     empezar de cero sin cerrar el programa, /clear.
+   - Lo que escribas mientras trabajas se encola y se envia al acabar el turno.
+
+   Si no sabes si algo existe en Chocolatito Code, dilo en vez de describir la
+   interfaz de otro producto. Inventarse una barra lateral que no existe manda al
+   usuario a buscar algo que no va a encontrar.
 `;
 }