chocolatito-code 1.2.0 → 1.3.1

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.
 `;
 }

package/dist/tools/browserExtension.js

@@ -1,6 +1,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import os from "node:os";
+import { fileURLToPath } from "node:url";
 import { WebSocketServer, WebSocket } from "ws";
 import { describeScreen } from "./visionBridge.js";
 /**
@@ -278,6 +279,55 @@ function emparejar(objetivo, origen, destino) {
         return candidatos[pos].ref;
     return null;
 }
+/**
+ * Avisar cuando la extension de Chrome se quedo atras.
+ *
+ * POR QUE HACE FALTA
+ *
+ * El CLI se actualiza solo, y la extension viaja DENTRO del paquete npm. Asi
+ * que al actualizarse, los archivos de la extension en el disco pasan a ser
+ * nuevos... pero Chrome sigue ejecutando los que cargo en su dia. No se entera
+ * hasta que alguien pulsa "recargar" en chrome://extensions.
+ *
+ * Eso deja al usuario con una version del CLI que espera cosas que su extension
+ * no sabe hacer, y los fallos que salen de ahi no se parecen en nada a su causa:
+ * una captura que llega en PNG cuando el CLI ya cuenta con JPEG, una accion que
+ * contesta distinto de lo que se espera. Sintomas raros, causa invisible.
+ *
+ * La extension ya decia su version en cada `status` y nadie la miraba. Ahora se
+ * compara con la que trae este CLI, y si no cuadran se dice una vez.
+ */
+let yaAvisadoDeVersion = false;
+/** La version de extension que trae ESTE CLI, leida del paquete instalado. */
+function versionEsperadaDeExtension() {
+    try {
+        const aqui = path.dirname(fileURLToPath(import.meta.url));
+        const manifiesto = path.resolve(aqui, "..", "..", "extension", "manifest.json");
+        return String(JSON.parse(fs.readFileSync(manifiesto, "utf-8")).version || "");
+    }
+    catch {
+        // Sin manifiesto no se puede comparar, y adivinar seria peor que callar.
+        return "";
+    }
+}
+/**
+ * Aviso si la extension va por detras. Cadena vacia si todo cuadra o no se sabe.
+ *
+ * Solo se avisa UNA vez por sesion: repetirlo en cada accion seria ruido que
+ * acaba ignorandose, que es como se pierden los avisos que importan.
+ */
+function avisoDeVersion(deLaExtension) {
+    if (yaAvisadoDeVersion)
+        return "";
+    const esperada = versionEsperadaDeExtension();
+    if (!esperada || !deLaExtension || esperada === deLaExtension)
+        return "";
+    yaAvisadoDeVersion = true;
+    return (`\n\nAVISO: tu extension de Chrome es la v${deLaExtension} y este Chocolatito trae la v${esperada}. ` +
+        `Chrome sigue ejecutando la que cargo en su dia aunque los archivos del disco ya sean nuevos. ` +
+        `Recargala en chrome://extensions (boton de recargar en la tarjeta de Chocolatito Code) o ` +
+        `veras fallos raros que no se parecen a su causa.`);
+}
 class CatalogoDeRefs {
     /** Lo que vio el modelo: los numeros en los que habla. */
     vista = [];
@@ -315,6 +365,10 @@ class CatalogoDeRefs {
         return this.filtroVista;
     }
     /** Nombre que tenia ese ref cuando el modelo lo vio. */
+    /** Huella de lo que vio el modelo, para poder comparar despues de actuar. */
+    huellaVista() {
+        return this.vista.map((e) => `${e.role}::${e.name}`);
+    }
     nombreDe(ref) {
         return this.vista.find((e) => e.ref === ref)?.name || "";
     }
@@ -353,6 +407,61 @@ async function refrescarCatalogo(filtro) {
     catalogo.verInterno(fresh.data.elements || []);
     return true;
 }
+/**
+ * Comprobar que el clic hizo ALGO, en vez de dar por hecho que si.
+ *
+ * EL FALLO, VISTO EN UNA SESION REAL
+ *
+ * En Google Flow, el agente pulso el boton de generar y la herramienta contesto:
+ *
+ *     Pulsado [19] "Iniciar generación". Pagina ahora: "Google Flow: sept 06..."
+ *
+ * El modelo leyo eso como "hecho" y se puso a esperar el resultado. Pero el clic
+ * no habia disparado nada: la pagina seguia igual. Espero, no vio nada, volvio a
+ * pulsar, volvio a esperar, gasto una captura de pantalla, y solo se desatasco
+ * cuando el usuario le dijo a mano "dale al boton de la flechita".
+ *
+ * El problema no fue del modelo: la herramienta le habia dicho que el clic se
+ * habia dado. Y "se envio el evento" no es lo mismo que "la pagina reacciono".
+ * Una web puede ignorar un clic sintetico por mil motivos -el manejador esta en
+ * otro elemento, hay un overlay delante, el framework escucha pointerdown y no
+ * click-, y ninguno de esos se ve desde fuera.
+ *
+ * QUE SE HACE AHORA
+ *
+ * Se mira la pagina antes y despues. Si no cambio absolutamente nada, se dice —
+ * que es informacion util y no un error: significa "el evento salio pero nadie
+ * lo recogio, prueba otra cosa". Es la diferencia entre que el agente se quede
+ * quince segundos esperando algo que no va a pasar, y que cambie de estrategia
+ * en el turno siguiente.
+ */
+async function reaccionAlClic(filtro, antes) {
+    let fresh;
+    try {
+        fresh = await extensionBridge.send("snapshot", { filter: filtro || "", max: 200 });
+    }
+    catch {
+        return "";
+    }
+    if (!fresh?.ok)
+        return "";
+    const els = fresh.data.elements || [];
+    catalogo.verInterno(els);
+    const ahora = els.map((e) => `${e.role}::${e.name}`);
+    const nuevos = ahora.filter((k) => !antes.includes(k));
+    const idos = antes.filter((k) => !ahora.includes(k));
+    if (nuevos.length === 0 && idos.length === 0) {
+        return (`\nOJO: el clic se envio, pero la pagina NO cambio en nada. Eso suele significar que ` +
+            `el elemento pulsado no es el que dispara la accion (el manejador esta en otro, hay algo ` +
+            `delante, o el framework escucha otro evento). No esperes un resultado: haz snapshot y ` +
+            `busca el control de verdad, o usa computer_use para un clic real del sistema.`);
+    }
+    const resumen = [
+        ...nuevos.slice(0, 6).map((k) => `  + ${k.replace("::", " ")}`),
+        ...idos.slice(0, 4).map((k) => `  - ${k.replace("::", " ")} (ya no esta)`),
+    ].join("\n");
+    return `\nLa pagina reacciono (${nuevos.length} nuevos, ${idos.length} fuera):\n${resumen}`;
+}
 /**
  * Ejecuta una accion sobre un ref del snapshot del modelo, traduciendolo al
  * numero que la extension tiene vivo ahora mismo. Si el ref ha caducado (el
@@ -421,7 +530,8 @@ export async function chromeExtension(params, cwd = process.cwd(), apiKey) {
                         `Si no la reconoces, revisala en chrome://extensions.`
                     : "";
                 return (`Extension conectada (v${res.data.version}), emparejada con ${origin}. ` +
-                    `Puedo trabajar en tus pestanas en segundo plano, sin robarte el foco.${aviso}`);
+                    `Puedo trabajar en tus pestanas en segundo plano, sin robarte el foco.${aviso}` +
+                    avisoDeVersion(String(res.data.version || "")));
             }
             case "tabs": {
                 const res = await extensionBridge.send("tabs");
@@ -500,6 +610,9 @@ export async function chromeExtension(params, cwd = process.cwd(), apiKey) {
             case "click": {
                 if (params.ref === undefined)
                     return fail(action, 'indica el "ref" del snapshot.');
+                // Se apunta como estaba la pagina ANTES: sin eso no hay con que comparar
+                // despues, y "se envio el clic" seguiria pasando por "la pagina reacciono".
+                const antesDelClic = catalogo.huellaVista();
                 const res = await accionSobreRef("click", {}, params.ref, params.filter);
                 if (!res.ok)
                     return fail(action, res.error);
@@ -512,7 +625,9 @@ export async function chromeExtension(params, cwd = process.cwd(), apiKey) {
                 const aviso = mismoElemento(pedido, pulsado)
                     ? ""
                     : `\nAVISO: pediste "${pedido}" y se pulso "${pulsado}". Haz snapshot y comprueba en que estado quedo la pagina.`;
-                return (`Pulsado [${params.ref}] "${pulsado}". Pagina ahora: "${res.data.title}" (${res.data.url})${aviso}`);
+                // Y lo que de verdad importa: si la pagina hizo algo o no. Ver reaccionAlClic.
+                const reaccion = antesDelClic.length > 0 ? await reaccionAlClic(params.filter || "", antesDelClic) : "";
+                return (`Pulsado [${params.ref}] "${pulsado}". Pagina ahora: "${res.data.title}" (${res.data.url})${aviso}${reaccion}`);
             }
             case "type": {
                 if (params.ref === undefined)
@@ -651,7 +766,7 @@ export async function chromeExtension(params, cwd = process.cwd(), apiKey) {
                     ? path.isAbsolute(params.outputPath)
                         ? params.outputPath
                         : path.resolve(cwd, params.outputPath)
-                    : path.join(dir, "chrome_tab.png");
+                    : path.join(dir, "chrome_tab.jpg");
                 const outDir = path.dirname(out);
                 if (!fs.existsSync(outDir))
                     fs.mkdirSync(outDir, { recursive: true });