+
+**Language / 语言 / 語言 / Dil / Язык / Ngôn ngữ / Idioma**
+
+[**English**](../../README.md) | [Português (Brasil)](../pt-BR/README.md) | [简体中文](../../README.zh-CN.md) | [繁體中文](../zh-TW/README.md) | [日本語](../ja-JP/README.md) | [한국어](../ko-KR/README.md)
+ | [Türkçe](../tr/README.md) | [Русский](../ru/README.md) | [Tiếng Việt](../vi-VN/README.md) | [ไทย](../th/README.md) | [Deutsch](../de-DE/README.md) | **Español**
+
+
+
+---
+
+**El sistema operativo nativo del harness para trabajo agentivo. Construido a partir de flujos de trabajo de ingeniería multi-harness del mundo real.**
+
+No son solo configuraciones. Es un sistema completo: skills, instintos, optimización de memoria, aprendizaje continuo, análisis de seguridad y desarrollo orientado a la investigación. Agentes listos para producción, skills, hooks, reglas, configuraciones de MCP y comandos legados, evolucionados durante más de 10 meses de uso diario intensivo construyendo productos reales.
+
+Funciona en **Codex**, **Claude Code**, **Cursor**, **OpenCode**, **Gemini**, **Zed**, **GitHub Copilot** y otros harnesses de agentes de IA.
+
+ECC v2.0.0-rc.1 añade la historia pública del operador Hermes sobre esa capa reutilizable: comienza con la [guía de configuración de Hermes](../HERMES-SETUP.md), luego revisa las [notas de la versión rc.1](../releases/2.0.0-rc.1/release-notes.md) y la [arquitectura multi-harness](../architecture/cross-harness.md).
+
+---
+
+patrocinadores y los suscriptores Pro financian el trabajo — por eso un solo mantenedor publica semanalmente en 7 harnesses.
+
+---
+
+## Las Guías
+
+Este repositorio contiene solo el código. Las guías explican todo.
+
+
+
+
+
+ |
+
+
+
+
+ |
+
+
+
+
+ |
+
| Guía Resumida Configuración, fundamentos, filosofía. Empieza aquí. |
+Guía Extensa Optimización de tokens, persistencia de memoria, evaluaciones, paralelización. |
+Guía de Seguridad Vectores de ataque, sandboxing, sanitización, CVEs, AgentShield. |
+
+
+
+¿Cómo veo qué agentes/comandos están instalados?
+ +```bash +/plugin list ecc@ecc +``` + +Muestra todos los agentes, comandos y skills disponibles del plugin. +
+
+
+Mis hooks no funcionan / Veo errores de "Duplicate hooks file"
+ +Este es el problema más común. **NO añadas un campo `"hooks"` a `.claude-plugin/plugin.json`.** Claude Code v2.1+ carga automáticamente `hooks/hooks.json` de los plugins instalados. Declararlo explícitamente provoca errores de detección de duplicados. Consulta [#29](https://github.com/affaan-m/ECC/issues/29), [#52](https://github.com/affaan-m/ECC/issues/52), [#103](https://github.com/affaan-m/ECC/issues/103). +
+
+
+¿Puedo usar ECC con Claude Code en un endpoint de API personalizado o un gateway de modelos?
+ +Sí. ECC no tiene configuraciones de transporte alojadas en Anthropic. Se ejecuta localmente a través de la superficie CLI/plugin normal de Claude Code, por lo que funciona con: + +- Claude Code alojado en Anthropic +- Configuraciones de gateway oficial de Claude Code usando `ANTHROPIC_BASE_URL` y `ANTHROPIC_AUTH_TOKEN` +- Endpoints personalizados compatibles que hablen la API de Anthropic que espera Claude Code + +Ejemplo mínimo: + +```bash +export ANTHROPIC_BASE_URL=https://your-gateway.example.com +export ANTHROPIC_AUTH_TOKEN=your-token +claude +``` + +Si tu gateway reasigna nombres de modelos, configúralo en Claude Code en lugar de en ECC. Los hooks, skills, comandos y reglas de ECC son agnósticos al proveedor de modelos una vez que el CLI `claude` ya funciona. + +Referencias oficiales: +- [Documentación del gateway LLM de Claude Code](https://docs.anthropic.com/en/docs/claude-code/llm-gateway) +- [Documentación de configuración de modelos de Claude Code](https://docs.anthropic.com/en/docs/claude-code/model-config) + +
+
+
+Mi ventana de contexto se está reduciendo / Claude se queda sin contexto
+ +Demasiados servidores MCP consumen tu contexto. Cada descripción de herramienta MCP consume tokens de tu ventana de 200k, potencialmente reduciéndola a ~70k. El contexto de SessionStart está limitado a 8000 caracteres por defecto; redúcelo con `ECC_SESSION_START_MAX_CHARS=4000` o desactívalo con `ECC_SESSION_START_CONTEXT=off` para configuraciones de bajo contexto o modelo local. + +**Solución:** Deshabilita los MCPs no utilizados desde Claude Code con `/mcp`. Claude Code escribe esas opciones en tiempo de ejecución en `~/.claude.json`; `.claude/settings.json` y `.claude/settings.local.json` no son interruptores confiables para servidores MCP ya cargados. + +Mantén menos de 10 MCPs habilitados y menos de 80 herramientas activas. +
+
+
+¿Puedo usar solo algunos componentes (por ejemplo, solo los agentes)?
+ +Sí. Usa la Opción 2 (instalación manual) y copia solo lo que necesites: + +```bash +# Solo agentes +cp agents/*.md ~/.claude/agents/ + +# Solo reglas +mkdir -p ~/.claude/rules/ecc/ +cp -r rules/common ~/.claude/rules/ecc/ +``` + +Cada componente es completamente independiente. +
+
+
+¿Funciona con Cursor / OpenCode / Codex / Antigravity / GitHub Copilot?
+ +Sí. ECC es multiplataforma: +- **Cursor**: Configuraciones pre-traducidas en `.cursor/`. Consulta [Soporte para Cursor IDE](#soporte-para-cursor-ide). +- **Gemini CLI**: Soporte experimental local al proyecto mediante `.gemini/GEMINI.md` y conexiones compartidas del instalador. +- **OpenCode**: Soporte completo del plugin en `.opencode/`. Consulta [Soporte para OpenCode](#soporte-para-opencode). +- **Codex**: Soporte de primera clase para la app macOS y CLI, con guardias de deriva del adaptador y fallback de SessionStart. Consulta PR [#257](https://github.com/affaan-m/ECC/pull/257). +- **GitHub Copilot (VS Code)**: Capa de instrucciones y prompts mediante `.github/copilot-instructions.md`, `.vscode/settings.json` y `.github/prompts/`. Consulta [Soporte para GitHub Copilot](#soporte-para-github-copilot). +- **Antigravity**: Configuración estrechamente integrada para flujos de trabajo, skills y reglas aplanadas en `.agent/`. Consulta la [Guía de Antigravity](../ANTIGRAVITY-GUIDE.md). +- **JoyCode / CodeBuddy**: Adaptadores de instalación selectiva locales al proyecto para comandos, agentes, skills y reglas aplanadas. Consulta la [Guía del Adaptador JoyCode](../JOYCODE-GUIDE.md). +- **Qwen CLI**: Adaptador de instalación selectiva en el directorio home para comandos, agentes, skills, reglas y configuración de Qwen. Consulta la [Guía del Adaptador Qwen CLI](../QWEN-GUIDE.md). +- **Zed**: Adaptador de instalación selectiva local al proyecto para `.zed/settings.json`, reglas aplanadas, comandos, agentes y skills. +- **Harnesses no nativos**: Ruta de respaldo manual para Grok e interfaces similares. Consulta la [Guía de Adaptación Manual](../MANUAL-ADAPTATION-GUIDE.md). +- **Claude Code**: Nativo — este es el objetivo principal. +
+
+
+---
+
+## Ejecutar Pruebas
+
+El plugin incluye una suite de pruebas completa:
+
+```bash
+# Ejecutar todas las pruebas
+node tests/run-all.js
+
+# Ejecutar archivos de prueba individuales
+node tests/lib/utils.test.js
+node tests/lib/package-manager.test.js
+node tests/hooks/hooks.test.js
+```
+
+---
+
+## Contribuir
+
+**Las contribuciones son bienvenidas y fomentadas.**
+
+Este repo está pensado para ser un recurso comunitario. Si tienes:
+- Agentes o skills útiles
+- Hooks ingeniosos
+- Mejores configuraciones de MCP
+- Reglas mejoradas
+
+¡Contribuye! Consulta [CONTRIBUTING.md](CONTRIBUTING.md) para las directrices.
+
+### Ideas para Contribuciones
+
+- Skills específicas de lenguaje (Rust, C#, Kotlin, Java) — Go, Python, Perl, Swift, TypeScript y HarmonyOS/ArkTS ya están incluidos
+- Configs específicas de frameworks (Rails, FastAPI) — Django, NestJS, Spring Boot y Laravel ya están incluidos
+- Agentes de DevOps (Kubernetes, Terraform, AWS, Docker)
+- Estrategias de prueba (diferentes frameworks, regresión visual)
+- Conocimiento de dominio específico (ML, ingeniería de datos, móvil)
+
+### Notas del Ecosistema Comunitario
+
+Estos no están empaquetados con ECC y no son auditados por este repo, pero vale la pena conocerlos si estás explorando el ecosistema más amplio de skills de Claude Code:
+
+- [claude-seo](https://github.com/AgriciDaniel/claude-seo) — Colección de skills y agentes centrados en SEO
+- [claude-ads](https://github.com/AgriciDaniel/claude-ads) — Colección de flujos de trabajo de auditoría de anuncios y crecimiento de pago
+- [claude-cybersecurity](https://github.com/AgriciDaniel/claude-cybersecurity) — Colección de skills y agentes orientados a seguridad
+
+---
+
+## Soporte para Cursor IDE
+
+ECC proporciona soporte para Cursor IDE con hooks, reglas, agentes, skills, comandos y configuraciones de MCP adaptados para el diseño de proyecto de Cursor.
+
+### Inicio Rápido (Cursor)
+
+```bash
+# macOS/Linux
+./install.sh --target cursor typescript
+./install.sh --target cursor python golang swift php
+```
+
+```powershell
+# Windows PowerShell
+.\install.ps1 --target cursor typescript
+.\install.ps1 --target cursor python golang swift php
+```
+
+### Qué Incluye
+
+| Componente | Cantidad | Detalles |
+|------------|---------|---------|
+| Eventos de Hook | 15 | sessionStart, beforeShellExecution, afterFileEdit, beforeMCPExecution, beforeSubmitPrompt, y 10 más |
+| Scripts de Hook | 16 | Scripts Node.js delgados que delegan a `scripts/hooks/` mediante adaptador compartido |
+| Reglas | 34 | 9 comunes (alwaysApply) + 25 específicas de lenguaje (TypeScript, Python, Go, Swift, PHP) |
+| Agentes | 48 | `.cursor/agents/ecc-*.md` cuando se instala; con prefijo para evitar colisiones con agentes de usuario o marketplace |
+| Skills | Compartidas + Empaquetadas | `.cursor/skills/` para adiciones traducidas |
+| Comandos | Compartidos | `.cursor/commands/` si se instala |
+| Configuración MCP | Compartida | `.cursor/mcp.json` si se instala |
+
+### Notas de Carga en Cursor
+
+ECC no instala el `AGENTS.md` raíz en `.cursor/`. Cursor trata los archivos `AGENTS.md` anidados como contexto de directorio, por lo que copiar la identidad del repo de ECC en un proyecto host contaminaría ese proyecto.
+
+El comportamiento de carga nativo de Cursor puede variar según la versión. ECC instala agentes como `.cursor/agents/ecc-*.md`; si tu versión de Cursor no expone los agentes del proyecto, esos archivos siguen funcionando como definiciones de referencia explícitas en lugar de contexto de prompt global oculto.
+
+### Arquitectura de Hooks (Patrón de Adaptador DRY)
+
+Cursor tiene **más eventos de hook que Claude Code** (20 vs 8). El módulo `.cursor/hooks/adapter.js` transforma el JSON de stdin de Cursor al formato de Claude Code, permitiendo reutilizar los `scripts/hooks/*.js` existentes sin duplicación.
+
+```
+JSON de stdin de Cursor → adapter.js → transforma → scripts/hooks/*.js
+ (compartido con Claude Code)
+```
+
+Hooks clave:
+- **beforeShellExecution** — Bloquea servidores de desarrollo fuera de tmux (exit 2), revisión de git push
+- **afterFileEdit** — Auto-formato + verificación de TypeScript + advertencia de console.log
+- **beforeSubmitPrompt** — Detecta secretos (sk-, ghp_, patrones AKIA) en prompts
+- **beforeTabFileRead** — Bloquea a Tab de leer archivos .env, .key, .pem (exit 2)
+- **beforeMCPExecution / afterMCPExecution** — Registro de auditoría de MCP
+
+### Formato de Reglas
+
+Las reglas de Cursor usan frontmatter YAML con `description`, `globs` y `alwaysApply`:
+
+```yaml
+---
+description: "TypeScript coding style extending common rules"
+globs: ["**/*.ts", "**/*.tsx", "**/*.js", "**/*.jsx"]
+alwaysApply: false
+---
+```
+
+---
+
+## Soporte para Codex macOS App + CLI
+
+ECC proporciona **soporte de primera clase para Codex** tanto para la app macOS como para el CLI, con una configuración de referencia, un suplemento AGENTS.md específico de Codex y skills compartidas.
+
+### Inicio Rápido (Codex App + CLI)
+
+```bash
+# Ejecutar Codex CLI en el repo — AGENTS.md y .codex/ se detectan automáticamente
+codex
+
+# Configuración automática: sincronizar activos de ECC (AGENTS.md, skills, servidores MCP) en ~/.codex
+npm install && bash scripts/sync-ecc-to-codex.sh
+
+# O manualmente: copiar la configuración de referencia a tu directorio home
+cp .codex/config.toml ~/.codex/config.toml
+```
+
+El script de sincronización fusiona de forma segura los servidores MCP de ECC en tu `~/.codex/config.toml` existente usando una estrategia **solo de adición** — nunca elimina ni modifica tus servidores existentes. Ejecuta con `--dry-run` para previsualizar los cambios, o `--update-mcp` para forzar la actualización de los servidores ECC a la configuración recomendada más reciente.
+
+### Qué Incluye
+
+| Componente | Cantidad | Detalles |
+|------------|---------|---------|
+| Configuración | 1 | `.codex/config.toml` — aprobaciones de nivel superior/sandbox/web_search, servidores MCP, notificaciones, perfiles |
+| AGENTS.md | 2 | Raíz (universal) + `.codex/AGENTS.md` (suplemento específico de Codex) |
+| Skills | 32 | `.agents/skills/` — SKILL.md + agents/openai.yaml por skill |
+| Servidores MCP | 6 | GitHub, Context7, Exa, Memory, Playwright, Sequential Thinking |
+| Perfiles | 2 | `strict` (sandbox de solo lectura) y `yolo` (auto-aprobación completa) |
+| Roles de Agente | 3 | `.codex/agents/` — explorer, reviewer, docs-researcher |
+
+---
+
+## Soporte para OpenCode
+
+ECC proporciona **soporte completo para OpenCode** incluyendo plugins y hooks.
+
+### Inicio Rápido
+
+```bash
+# Instalar OpenCode
+npm install -g opencode
+
+# Ejecutar en la raíz del repositorio
+opencode
+```
+
+La configuración se detecta automáticamente desde `.opencode/opencode.json`.
+
+### Paridad de Características
+
+| Característica | Claude Code | OpenCode | Estado |
+|----------------|---------------------|----------|--------|
+| Agentes | 63 agentes | 12 agentes | **Claude Code lidera** |
+| Comandos | 79 comandos | 35 comandos | **Claude Code lidera** |
+| Skills | 249 skills | 37 skills | **Claude Code lidera** |
+| Hooks | 8 tipos de eventos | 11 eventos | **¡OpenCode tiene más!** |
+| Reglas | 29 reglas | 13 instrucciones | **Claude Code lidera** |
+| Servidores MCP | 14 servidores | Completo | **Paridad completa** |
+| Herramientas Personalizadas | Mediante hooks | 6 nativas | **OpenCode es mejor** |
+
+---
+
+## Soporte para GitHub Copilot
+
+ECC proporciona **soporte para GitHub Copilot** para VS Code mediante el sistema nativo de archivos de instrucciones y prompts de Copilot Chat — sin herramientas adicionales necesarias.
+
+### Qué Incluye
+
+| Componente | Archivo | Propósito |
+|------------|---------|-----------|
+| Instrucciones principales | `.github/copilot-instructions.md` | Reglas siempre cargadas: estilo de código, seguridad, pruebas, flujo de git |
+| Configuración de VS Code | `.vscode/settings.json` | Archivos de instrucciones por tarea para generación de código, pruebas, revisión y mensajes de commit |
+| Prompt de plan | `.github/prompts/plan.prompt.md` | Planificación de implementación por fases |
+| Prompt de TDD | `.github/prompts/tdd.prompt.md` | Ciclo Rojo-Verde-Mejorar |
+| Prompt de revisión de código | `.github/prompts/code-review.prompt.md` | Revisión de calidad y seguridad |
+| Prompt de revisión de seguridad | `.github/prompts/security-review.prompt.md` | Análisis de seguridad profundo alineado con OWASP |
+| Prompt de corrección de build | `.github/prompts/build-fix.prompt.md` | Resolución sistemática de errores de build y CI |
+| Prompt de refactorización | `.github/prompts/refactor.prompt.md` | Limpieza de código muerto y simplificación |
+
+### Inicio Rápido (GitHub Copilot)
+
+Los archivos ya están en su lugar — abre cualquier repo que contenga este proyecto y GitHub Copilot Chat recogerá automáticamente `.github/copilot-instructions.md`.
+El `.vscode/settings.json` confirmado habilita `chat.promptFiles` para que VS Code pueda cargar los prompts reutilizables de `.github/prompts/`.
+
+Para usar los prompts de flujo de trabajo en Copilot Chat:
+1. Abre el panel de Copilot Chat en VS Code.
+2. Haz clic en el icono de **clip / adjuntar** y selecciona **Prompt...**, o escribe `/` y elige un prompt.
+3. Selecciona el prompt (por ejemplo, `plan`, `tdd`, `code-review`).
+
+---
+
+## Compatibilidad Cross-Tool
+
+ECC es el **primer plugin que maximiza todas las principales herramientas de codificación con IA**. Así se compara cada harness:
+
+| Característica | Claude Code | Cursor IDE | Codex CLI | OpenCode | GitHub Copilot |
+|----------------|-----------------------|------------|-----------|----------|----------------|
+| **Agentes** | 63 | Compartidos (AGENTS.md) | Compartidos (AGENTS.md) | 12 | N/A |
+| **Comandos** | 79 | Compartidos | Basados en instrucciones | 35 | 6 prompts |
+| **Skills** | 249 | Compartidas | 10 (formato nativo) | 37 | Mediante instrucciones |
+| **Eventos de Hook** | 8 tipos | 15 tipos | Ninguno aún | 11 tipos | Ninguno |
+| **Scripts de Hook** | 20+ scripts | 16 scripts (adaptador DRY) | N/A | Hooks de plugin | N/A |
+| **Reglas** | 34 (común + lenguaje) | 34 (frontmatter YAML) | Basadas en instrucciones | 13 instrucciones | 1 archivo siempre activo |
+| **Herramientas Personalizadas** | Mediante hooks | Mediante hooks | N/A | 6 herramientas nativas | N/A |
+| **Servidores MCP** | 14 | Compartidos (mcp.json) | 7 (fusión automática vía parser TOML) | Completo | N/A |
+| **Formato de Configuración** | settings.json | hooks.json + rules/ | config.toml | opencode.json | copilot-instructions.md + settings.json |
+| **Archivo de Contexto** | CLAUDE.md + AGENTS.md | AGENTS.md | AGENTS.md | AGENTS.md | copilot-instructions.md |
+
+---
+
+## Antecedentes
+
+He estado usando Claude Code desde el lanzamiento experimental. Gané el hackathon de Anthropic x Forum Ventures en sep 2025 con [@DRodriguezFX](https://x.com/DRodriguezFX) — construí [zenith.chat](https://zenith.chat) completamente usando Claude Code.
+
+Estas configuraciones han sido probadas en múltiples aplicaciones de producción.
+
+---
+
+## Optimización de Tokens
+
+El uso de Claude Code puede ser costoso si no gestionas el consumo de tokens. Estas configuraciones reducen significativamente los costos sin sacrificar calidad.
+
+### Configuración Recomendada
+
+Añade a `~/.claude/settings.json`:
+
+```json
+{
+ "model": "sonnet",
+ "env": {
+ "MAX_THINKING_TOKENS": "10000",
+ "CLAUDE_AUTOCOMPACT_PCT_OVERRIDE": "50"
+ }
+}
+```
+
+| Configuración | Por defecto | Recomendado | Impacto |
+|--------------|-------------|-------------|---------|
+| `model` | opus | **sonnet** | ~60% de reducción de costos; maneja más del 80% de las tareas de codificación |
+| `MAX_THINKING_TOKENS` | 31,999 | **10,000** | ~70% de reducción en el costo de pensamiento oculto por solicitud |
+| `CLAUDE_AUTOCOMPACT_PCT_OVERRIDE` | 95 | **50** | Compacta antes — mejor calidad en sesiones largas |
+| `ECC_CONTEXT_MONITOR_COST_WARNINGS` | on | **off para suscriptores** | Suprime las advertencias de estimación de tasa de API frente al agente manteniendo las advertencias de contexto/alcance/bucle |
+
+Cambia a Opus solo cuando necesites razonamiento arquitectónico profundo:
+```
+/model opus
+```
+
+### Comandos del Flujo de Trabajo Diario
+
+| Comando | Cuándo usarlo |
+|---------|---------------|
+| `/model sonnet` | Por defecto para la mayoría de las tareas |
+| `/model opus` | Arquitectura compleja, depuración, razonamiento profundo |
+| `/clear` | Entre tareas no relacionadas (gratis, restablecimiento instantáneo) |
+| `/compact` | En puntos de quiebre lógicos de tareas |
+| `/cost` | Monitorear el gasto de tokens durante la sesión |
+
+### Compactación Estratégica
+
+La skill `strategic-compact` (incluida en este plugin) sugiere `/compact` en puntos de quiebre lógicos en lugar de depender de la auto-compactación al 95% del contexto.
+
+**Cuándo compactar:**
+- Después de investigación/exploración, antes de la implementación
+- Después de completar un hito, antes de empezar el siguiente
+- Después de depurar, antes de continuar con el trabajo de features
+- Después de un enfoque fallido, antes de probar uno nuevo
+
+**Cuándo NO compactar:**
+- A mitad de la implementación (perderás nombres de variables, rutas de archivos, estado parcial)
+
+---
+
+## ADVERTENCIA: Notas Importantes
+
+### Optimización de Tokens
+
+¿Alcanzando los límites diarios? Consulta la **[Guía de Optimización de Tokens](../token-optimization.md)** para configuraciones recomendadas y consejos de flujo de trabajo.
+
+Ganancias rápidas:
+
+```json
+// ~/.claude/settings.json
+{
+ "model": "sonnet",
+ "env": {
+ "MAX_THINKING_TOKENS": "10000",
+ "CLAUDE_AUTOCOMPACT_PCT_OVERRIDE": "50",
+ "CLAUDE_CODE_SUBAGENT_MODEL": "haiku"
+ }
+}
+```
+
+### Personalización
+
+Estas configuraciones funcionan para mi flujo de trabajo. Deberías:
+1. Empezar con lo que resuene
+2. Modificar para tu stack
+3. Eliminar lo que no uses
+4. Añadir tus propios patrones
+
+---
+
+## Proyectos de la Comunidad
+
+Proyectos construidos sobre o inspirados en ECC:
+
+| Proyecto | Descripción |
+|----------|-------------|
+| [EVC](https://github.com/SaigonXIII/evc) | Espacio de trabajo para agentes de marketing — 42 comandos para operadores de contenido, gobernanza de marca y publicación multicanal. [Resumen visual](https://saigonxiii.github.io/evc). |
+| [trading-skills](https://github.com/VictorVVedtion/trading-skills) | 68 skills de Claude Code temáticas de trading con prompts de revisión pre-trade y puertas de riesgo inspiradas en operadores de mercado. |
+
+¿Construiste algo con ECC? Abre un PR para añadirlo aquí.
+
+---
+
+## Patrocinadores
+
+Este proyecto es gratuito y de código abierto. Los patrocinadores ayudan a mantenerlo y hacerlo crecer.
+
+[**Conviértete en Patrocinador**](https://github.com/sponsors/affaan-m) | [Niveles de Patrocinio](SPONSORS.md) | [Programa de Patrocinio](SPONSORING.md)
+
+---
+
+## Historial de Estrellas
+
+[](https://star-history.com/#affaan-m/ECC&Date)
+
+---
+
+## Enlaces
+
+- **Guía Resumida (Empieza aquí):** [La Guía Resumida de Everything Claude Code](https://x.com/affaanmustafa/status/2012378465664745795)
+- **Guía Extensa (Avanzado):** [La Guía Extensa de Everything Claude Code](https://x.com/affaanmustafa/status/2014040193557471352)
+- **Guía de Seguridad:** [Guía de Seguridad](../../the-security-guide.md) | [Hilo](https://x.com/affaanmustafa/status/2033263813387223421)
+- **Seguir:** [@affaanmustafa](https://x.com/affaanmustafa)
+
+---
+
+## Licencia
+
+MIT - Úsalo libremente, modifícalo según tus necesidades, contribuye de vuelta si puedes.
+
+---
+
+**Dale una estrella al repo si te ayuda. Lee las dos guías. Construye algo grandioso.**
diff --git a/docs/es/SECURITY.md b/docs/es/SECURITY.md
new file mode 100644
index 00000000..ba549c06
--- /dev/null
+++ b/docs/es/SECURITY.md
@@ -0,0 +1,101 @@
+# Política de Seguridad
+
+## Versiones Soportadas
+
+| Versión | Soportada |
+| ------- | ------------------ |
+| 1.9.x | :white_check_mark: |
+| 1.8.x | :white_check_mark: |
+| < 1.8 | :x: |
+
+## Reportar una Vulnerabilidad
+
+Si descubres una vulnerabilidad de seguridad en ECC, por favor repórtala de forma responsable.
+
+**No abras un issue público de GitHub para vulnerabilidades de seguridad.**
+
+En cambio, envía un correo a **¿Cómo contribuyo con una nueva skill o agente?
+ +Consulta [CONTRIBUTING.md](CONTRIBUTING.md). La versión corta: +1. Haz fork del repo +2. Crea tu skill en `skills/tu-nombre-de-skill/SKILL.md` (con frontmatter YAML) +3. O crea un agente en `agents/tu-agente.md` +4. Envía un PR con una descripción clara de qué hace y cuándo usarlo +
| 2026 |
+
+*[Conviértete en patrocinador Business](https://github.com/sponsors/affaan-m) para aparecer aquí con logo en el hero del README principal y un caso de estudio trimestral.*
+
+## Patrocinadores Team — $200/mes
+
+| Patrocinador | Desde |
+|---------|-------|
+| [Mike Morgan](https://github.com/mikejmorgan-ai) | 2026 |
+
+*[Conviértete en patrocinador Team](https://github.com/sponsors/affaan-m) para obtener un logo pequeño y 5 asientos de ECC Pro.*
+
+## Patrocinadores Pro — $50/mes
+
+*[Conviértete en patrocinador Pro](https://github.com/sponsors/affaan-m) para aparecer aquí con tu nombre en la fila de patrocinadores del README principal.*
+
+## Patrocinadores Builder — $25/mes
+
+- @jasonwu513 (precio heredado en $10)
+- @1anter (precio heredado en $10)
+- @massimotodaro (precio heredado en $10)
+- @meadmccabe (precio heredado en $10)
+
+*[Conviértete en patrocinador Builder](https://github.com/sponsors/affaan-m) para apoyar el proyecto y aparecer en esta lista + una nota mensual privada de progreso.*
+
+## Supporters — $5/mes
+
+*[Conviértete en Supporter](https://github.com/sponsors/affaan-m) para respaldar el proyecto con una insignia de perfil y un agradecimiento en nuestras notas de versión.*
+
+---
+
+## Niveles de Patrocinio
+
+| Nivel | Mensual | Beneficios |
+|-------|--------:|-------|
+| Supporter | $5 | Insignia de patrocinador en el perfil, agradecimiento en las notas de versión |
+| Builder | $25 | Lo anterior + nombre en SPONSORS.md + nota mensual privada de progreso |
+| Pro Sponsor | $50 | Lo anterior + nombre en el README principal + 1 voto trimestral en el roadmap |
+| Team | $200 | Lo anterior + pequeño logo de org en el README + 5 asientos de ECC Pro |
+| Business | $500 | Lo anterior + logo destacado en el hero del README + caso de estudio trimestral + acceso al lounge de sponsors en Discord |
+| Enterprise | $2,500 | Lo anterior + asientos Pro ilimitados + 30 min/mes con el fundador + SLA + canal dedicado |
+
+[**Conviértete en Patrocinador →**](https://github.com/sponsors/affaan-m)
+
+Para consultas de patrocinio corporativo, colaboraciones personalizadas o integraciones de PR, envía un correo a **[affaan@ecc.tools](mailto:affaan@ecc.tools)** con el nombre de tu empresa y el nivel deseado. Respondemos rápido — la mayoría de los acuerdos se cierran en 48 horas.
+
+---
+
+## ¿Por Qué Patrocinar?
+
+Tu patrocinio financia directamente:
+
+- **Trabajo OSS que se mantiene gratuito** — el repo principal, AgentShield, los scripts de instalación y la biblioteca de skills permanecen MIT
+- **Lanzamientos semanales** — trabajo a tiempo completo en el harness, no un proyecto paralelo
+- **Mantenimiento independiente** — sin presión de adquisición, sin rug pulls, sin degradación
+- **Roadmap impulsado por sponsors** — los sponsors Pro+ votan en la dirección, los Business+ obtienen casos de estudio y soporte de integración
+
+## Los Sponsors Existentes Tienen Precios Heredados
+
+Si patrocinaste antes de mayo de 2026, conservas tus beneficios originales a tu precio original. Los nuevos niveles se aplican solo a los nuevos sponsors.
+
+---
+
+*Actualizado automáticamente por Hermes en cada versión. Última sincronización: 2026-05-14*
diff --git a/docs/es/TERMINOLOGY.md b/docs/es/TERMINOLOGY.md
new file mode 100644
index 00000000..41cac4ca
--- /dev/null
+++ b/docs/es/TERMINOLOGY.md
@@ -0,0 +1,63 @@
+# Glosario de Terminología (Terminology Glossary)
+
+Este documento registra las correspondencias terminológicas de las traducciones al español para garantizar la coherencia.
+
+## Estado de las Entradas
+
+- **Confirmado**: Traducción aprobada
+- **Pendiente**: Traducción en revisión
+
+---
+
+## Tabla de Terminología
+
+| Inglés (English) | Español | Estado | Notas |
+|---------|---------|------|------|
+| Agent | Agente | Confirmado | Se traduce |
+| Hook | Hook | Confirmado | Se mantiene en inglés |
+| Plugin | Plugin | Confirmado | Se mantiene en inglés |
+| Token | Token | Confirmado | Se mantiene en inglés |
+| Skill | Skill | Confirmado | Se mantiene en inglés |
+| Command | Comando | Confirmado | Se traduce |
+| Rule | Regla | Confirmado | Se traduce |
+| Harness | Harness | Confirmado | Se mantiene en inglés (término técnico específico) |
+| TDD (Test-Driven Development) | TDD (Desarrollo Guiado por Pruebas) | Confirmado | Se expande en el primer uso |
+| E2E (End-to-End) | E2E (Extremo a Extremo) | Confirmado | Se expande en el primer uso |
+| API | API | Confirmado | Se mantiene en inglés |
+| CLI | CLI | Confirmado | Se mantiene en inglés |
+| IDE | IDE | Confirmado | Se mantiene en inglés |
+| MCP (Model Context Protocol) | MCP | Confirmado | Se mantiene en inglés |
+| Workflow | Flujo de trabajo | Confirmado | Se traduce |
+| Codebase | Código base / Codebase | Confirmado | Según contexto |
+| Coverage | Cobertura | Confirmado | En contexto de pruebas |
+| Build | Build | Confirmado | Se mantiene en inglés |
+| Debug | Depuración / Debug | Confirmado | Según contexto |
+| Deploy | Despliegue / Deploy | Confirmado | Según contexto |
+| Commit | Commit | Confirmado | Término de Git, se mantiene en inglés |
+| PR (Pull Request) | PR | Confirmado | Se mantiene en inglés |
+| Branch | Rama / Branch | Confirmado | Según contexto |
+| Merge | Fusionar / Merge | Confirmado | Según contexto |
+| Repository | Repositorio | Confirmado | Se traduce |
+| Fork | Fork | Confirmado | Se mantiene en inglés |
+| Instinct | Instinto | Confirmado | Se traduce |
+| Subagent | Subagente | Confirmado | Se traduce |
+| Sandbox | Sandbox | Confirmado | Se mantiene en inglés |
+| Supabase | Supabase | — | Nombre de producto, se conserva |
+| Redis | Redis | — | Nombre de producto, se conserva |
+| Playwright | Playwright | — | Nombre de producto, se conserva |
+| TypeScript | TypeScript | — | Nombre de lenguaje, se conserva |
+| JavaScript | JavaScript | — | Nombre de lenguaje, se conserva |
+| Go/Golang | Go | — | Nombre de lenguaje, se conserva |
+| Python | Python | — | Nombre de lenguaje, se conserva |
+| Java | Java | — | Nombre de lenguaje, se conserva |
+| Kotlin | Kotlin | — | Nombre de lenguaje, se conserva |
+| Swift | Swift | — | Nombre de lenguaje, se conserva |
+| Rust | Rust | — | Nombre de lenguaje, se conserva |
+| PHP | PHP | — | Nombre de lenguaje, se conserva |
+| Perl | Perl | — | Nombre de lenguaje, se conserva |
+| React | React | — | Nombre de framework, se conserva |
+| Next.js | Next.js | — | Nombre de framework, se conserva |
+| Vue | Vue | — | Nombre de framework, se conserva |
+| Django | Django | — | Nombre de framework, se conserva |
+| Laravel | Laravel | — | Nombre de framework, se conserva |
+| PostgreSQL | PostgreSQL | — | Nombre de producto, se conserva |
diff --git a/docs/es/TROUBLESHOOTING.md b/docs/es/TROUBLESHOOTING.md
new file mode 100644
index 00000000..614d36a8
--- /dev/null
+++ b/docs/es/TROUBLESHOOTING.md
@@ -0,0 +1,432 @@
+# Guía de Resolución de Problemas
+
+Problemas comunes y soluciones para el plugin Everything Claude Code (ECC).
+
+## Tabla de Contenidos
+
+- [Problemas de Memoria y Contexto](#problemas-de-memoria-y-contexto)
+- [Fallos del Harness de Agentes](#fallos-del-harness-de-agentes)
+- [Errores de Hooks y Flujos de Trabajo](#errores-de-hooks-y-flujos-de-trabajo)
+- [Instalación y Configuración](#instalación-y-configuración)
+- [Problemas de Rendimiento](#problemas-de-rendimiento)
+- [Mensajes de Error Comunes](#mensajes-de-error-comunes)
+- [Obtener Ayuda](#obtener-ayuda)
+
+---
+
+## Problemas de Memoria y Contexto
+
+### Desbordamiento de la Ventana de Contexto
+
+**Síntoma:** Errores de "Context too long" o respuestas incompletas
+
+**Causas:**
+- Archivos grandes que superan los límites de tokens
+- Historial de conversación acumulado
+- Múltiples salidas grandes de herramientas en una sola sesión
+
+**Soluciones:**
+```bash
+# 1. Borrar el historial de conversación y empezar de nuevo
+# Usa Claude Code: "New Chat" o Cmd/Ctrl+Shift+N
+
+# 2. Reducir el tamaño del archivo antes del análisis
+head -n 100 large-file.log > sample.log
+
+# 3. Usar streaming para salidas grandes
+head -n 50 large-file.txt
+
+# 4. Dividir las tareas en fragmentos más pequeños
+# En lugar de: "Analiza los 50 archivos"
+# Usa: "Analiza los archivos en el directorio src/components/"
+```
+
+### Fallos en la Persistencia de Memoria
+
+**Síntoma:** El agente no recuerda el contexto u observaciones previas
+
+**Causas:**
+- Hooks de continuous-learning deshabilitados
+- Archivos de observaciones corruptos
+- Fallos en la detección del proyecto
+
+**Soluciones:**
+```bash
+# Verificar si las observaciones se están registrando
+ls ~/.claude/homunculus/projects/*/observations.jsonl
+
+# Encontrar el hash id del proyecto actual
+python3 - <<'PY'
+import json, os
+registry_path = os.path.expanduser("~/.claude/homunculus/projects.json")
+with open(registry_path) as f:
+ registry = json.load(f)
+for project_id, meta in registry.items():
+ if meta.get("root") == os.getcwd():
+ print(project_id)
+ break
+else:
+ raise SystemExit("Hash del proyecto no encontrado en ~/.claude/homunculus/projects.json")
+PY
+
+# Ver observaciones recientes para ese proyecto
+tail -20 ~/.claude/homunculus/projects/{children}
+}
+
+export function CardHeader({ children }: { children: React.ReactNode }) {
+ return {children}
+}
+
+export function CardBody({ children }: { children: React.ReactNode }) {
+ return {children}
+}
+
+// Uso
+{children}
+}
+
+export function Tab({ id, children }: { id: string, children: React.ReactNode }) {
+ const context = useContext(TabsContext)
+ if (!context) throw new Error('Tab must be used within Tabs')
+
+ return (
+
+ )
+}
+
+// Uso
+
+
+ )
+})
+```
+
+### Code Splitting y Carga Diferida
+
+```typescript
+import { lazy, Suspense } from 'react'
+
+// PASS: Carga diferida de componentes pesados
+const HeavyChart = lazy(() => import('./HeavyChart'))
+const ThreeJsBackground = lazy(() => import('./ThreeJsBackground'))
+
+export function Dashboard() {
+ return (
+ {market.name}
+{market.description}
+
+
+
+
+ )
+}
+```
+
+### Virtualización para Listas Largas
+
+```typescript
+import { useVirtualizer } from '@tanstack/react-virtual'
+
+export function VirtualMarketList({ markets }: { markets: Market[] }) {
+ const parentRef = useRef
+
+ )
+}
+```
+
+## Patrones de Manejo de Formularios
+
+### Formulario Controlado con Validación
+
+```typescript
+interface FormData {
+ name: string
+ description: string
+ endDate: string
+}
+
+interface FormErrors {
+ name?: string
+ description?: string
+ endDate?: string
+}
+
+export function CreateMarketForm() {
+ const [formData, setFormData] = useState
+ {virtualizer.getVirtualItems().map(virtualRow => (
+
+
+
+ ))}
+
+
+ )
+ }
+
+ return this.props.children
+ }
+}
+
+// Uso
+Something went wrong
+{this.state.error?.message}
+ +
+ {/* Implementación del Dropdown */}
+
+ )
+}
+```
+
+### Gestión de Foco
+
+```typescript
+export function Modal({ isOpen, onClose, children }: ModalProps) {
+ const modalRef = useRef e.key === 'Escape' && onClose()}
+ >
+ {children}
+
+ ) : null
+}
+```
+
+**Recuerda**: Los patrones modernos de frontend permiten interfaces de usuario mantenibles y de alto rendimiento. Elige los patrones que se ajusten a la complejidad de tu proyecto.
diff --git a/docs/es/skills/golang-patterns/SKILL.md b/docs/es/skills/golang-patterns/SKILL.md
new file mode 100644
index 00000000..e123751e
--- /dev/null
+++ b/docs/es/skills/golang-patterns/SKILL.md
@@ -0,0 +1,674 @@
+---
+name: golang-patterns
+description: Patrones idiomáticos de Go, buenas prácticas y convenciones para construir aplicaciones Go robustas, eficientes y mantenibles.
+origin: ECC
+---
+
+# Patrones de Desarrollo Go
+
+Patrones idiomáticos de Go y buenas prácticas para construir aplicaciones robustas, eficientes y mantenibles.
+
+## Cuándo Activar
+
+- Escribir nuevo código Go
+- Revisar código Go
+- Refactorizar código Go existente
+- Diseñar paquetes/módulos Go
+
+## Principios Fundamentales
+
+### 1. Simplicidad y Claridad
+
+Go favorece la simplicidad sobre la astucia. El código debe ser obvio y fácil de leer.
+
+```go
+// Bien: Claro y directo
+func GetUser(id string) (*User, error) {
+ user, err := db.FindUser(id)
+ if err != nil {
+ return nil, fmt.Errorf("get user %s: %w", id, err)
+ }
+ return user, nil
+}
+
+// Mal: Demasiado ingenioso
+func GetUser(id string) (*User, error) {
+ return func() (*User, error) {
+ if u, e := db.FindUser(id); e == nil {
+ return u, nil
+ } else {
+ return nil, e
+ }
+ }()
+}
+```
+
+### 2. Hacer que el Valor Cero Sea Útil
+
+Diseñar tipos para que su valor cero sea inmediatamente usable sin inicialización.
+
+```go
+// Bien: El valor cero es útil
+type Counter struct {
+ mu sync.Mutex
+ count int // el valor cero es 0, listo para usar
+}
+
+func (c *Counter) Inc() {
+ c.mu.Lock()
+ c.count++
+ c.mu.Unlock()
+}
+
+// Bien: bytes.Buffer funciona con el valor cero
+var buf bytes.Buffer
+buf.WriteString("hello")
+
+// Mal: Requiere inicialización
+type BadCounter struct {
+ counts map[string]int // el mapa nil causará panic
+}
+```
+
+### 3. Aceptar Interfaces, Retornar Structs
+
+Las funciones deben aceptar parámetros de interfaz y retornar tipos concretos.
+
+```go
+// Bien: Acepta interfaz, retorna tipo concreto
+func ProcessData(r io.Reader) (*Result, error) {
+ data, err := io.ReadAll(r)
+ if err != nil {
+ return nil, err
+ }
+ return &Result{Data: data}, nil
+}
+
+// Mal: Retorna interfaz (oculta detalles de implementación innecesariamente)
+func ProcessData(r io.Reader) (io.Reader, error) {
+ // ...
+}
+```
+
+## Patrones de Manejo de Errores
+
+### Wrapping de Errores con Contexto
+
+```go
+// Bien: Envolver errores con contexto
+func LoadConfig(path string) (*Config, error) {
+ data, err := os.ReadFile(path)
+ if err != nil {
+ return nil, fmt.Errorf("load config %s: %w", path, err)
+ }
+
+ var cfg Config
+ if err := json.Unmarshal(data, &cfg); err != nil {
+ return nil, fmt.Errorf("parse config %s: %w", path, err)
+ }
+
+ return &cfg, nil
+}
+```
+
+### Tipos de Error Personalizados
+
+```go
+// Definir errores específicos del dominio
+type ValidationError struct {
+ Field string
+ Message string
+}
+
+func (e *ValidationError) Error() string {
+ return fmt.Sprintf("validation failed on %s: %s", e.Field, e.Message)
+}
+
+// Errores centinela para casos comunes
+var (
+ ErrNotFound = errors.New("resource not found")
+ ErrUnauthorized = errors.New("unauthorized")
+ ErrInvalidInput = errors.New("invalid input")
+)
+```
+
+### Verificación de Errores con errors.Is y errors.As
+
+```go
+func HandleError(err error) {
+ // Verificar error específico
+ if errors.Is(err, sql.ErrNoRows) {
+ log.Println("No records found")
+ return
+ }
+
+ // Verificar tipo de error
+ var validationErr *ValidationError
+ if errors.As(err, &validationErr) {
+ log.Printf("Validation error on field %s: %s",
+ validationErr.Field, validationErr.Message)
+ return
+ }
+
+ // Error desconocido
+ log.Printf("Unexpected error: %v", err)
+}
+```
+
+### Nunca Ignorar Errores
+
+```go
+// Mal: Ignorar error con identificador en blanco
+result, _ := doSomething()
+
+// Bien: Manejar o documentar explícitamente por qué es seguro ignorar
+result, err := doSomething()
+if err != nil {
+ return err
+}
+
+// Aceptable: Cuando el error realmente no importa (raro)
+_ = writer.Close() // Limpieza de mejor esfuerzo, error registrado en otro lugar
+```
+
+## Patrones de Concurrencia
+
+### Worker Pool
+
+```go
+func WorkerPool(jobs <-chan Job, results chan<- Result, numWorkers int) {
+ var wg sync.WaitGroup
+
+ for i := 0; i < numWorkers; i++ {
+ wg.Add(1)
+ go func() {
+ defer wg.Done()
+ for job := range jobs {
+ results <- process(job)
+ }
+ }()
+ }
+
+ wg.Wait()
+ close(results)
+}
+```
+
+### Context para Cancelación y Timeouts
+
+```go
+func FetchWithTimeout(ctx context.Context, url string) ([]byte, error) {
+ ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
+ defer cancel()
+
+ req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
+ if err != nil {
+ return nil, fmt.Errorf("create request: %w", err)
+ }
+
+ resp, err := http.DefaultClient.Do(req)
+ if err != nil {
+ return nil, fmt.Errorf("fetch %s: %w", url, err)
+ }
+ defer resp.Body.Close()
+
+ return io.ReadAll(resp.Body)
+}
+```
+
+### Apagado Graceful
+
+```go
+func GracefulShutdown(server *http.Server) {
+ quit := make(chan os.Signal, 1)
+ signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
+
+ <-quit
+ log.Println("Shutting down server...")
+
+ ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+ defer cancel()
+
+ if err := server.Shutdown(ctx); err != nil {
+ log.Fatalf("Server forced to shutdown: %v", err)
+ }
+
+ log.Println("Server exited")
+}
+```
+
+### errgroup para Goroutines Coordinadas
+
+```go
+import "golang.org/x/sync/errgroup"
+
+func FetchAll(ctx context.Context, urls []string) ([][]byte, error) {
+ g, ctx := errgroup.WithContext(ctx)
+ results := make([][]byte, len(urls))
+
+ for i, url := range urls {
+ i, url := i, url // Capturar variables del bucle
+ g.Go(func() error {
+ data, err := FetchWithTimeout(ctx, url)
+ if err != nil {
+ return err
+ }
+ results[i] = data
+ return nil
+ })
+ }
+
+ if err := g.Wait(); err != nil {
+ return nil, err
+ }
+ return results, nil
+}
+```
+
+### Evitar Goroutine Leaks
+
+```go
+// Mal: Goroutine leak si el context es cancelado
+func leakyFetch(ctx context.Context, url string) <-chan []byte {
+ ch := make(chan []byte)
+ go func() {
+ data, _ := fetch(url)
+ ch <- data // Bloquea para siempre si no hay receptor
+ }()
+ return ch
+}
+
+// Bien: Maneja correctamente la cancelación
+func safeFetch(ctx context.Context, url string) <-chan []byte {
+ ch := make(chan []byte, 1) // Canal con buffer
+ go func() {
+ data, err := fetch(url)
+ if err != nil {
+ return
+ }
+ select {
+ case ch <- data:
+ case <-ctx.Done():
+ }
+ }()
+ return ch
+}
+```
+
+## Diseño de Interfaces
+
+### Interfaces Pequeñas y Enfocadas
+
+```go
+// Bien: Interfaces de un solo método
+type Reader interface {
+ Read(p []byte) (n int, err error)
+}
+
+type Writer interface {
+ Write(p []byte) (n int, err error)
+}
+
+type Closer interface {
+ Close() error
+}
+
+// Componer interfaces según se necesite
+type ReadWriteCloser interface {
+ Reader
+ Writer
+ Closer
+}
+```
+
+### Definir Interfaces Donde Se Usan
+
+```go
+// En el paquete consumidor, no en el proveedor
+package service
+
+// UserStore define lo que este servicio necesita
+type UserStore interface {
+ GetUser(id string) (*User, error)
+ SaveUser(user *User) error
+}
+
+type Service struct {
+ store UserStore
+}
+
+// La implementación concreta puede estar en otro paquete
+// No necesita conocer esta interfaz
+```
+
+### Comportamiento Opcional con Type Assertions
+
+```go
+type Flusher interface {
+ Flush() error
+}
+
+func WriteAndFlush(w io.Writer, data []byte) error {
+ if _, err := w.Write(data); err != nil {
+ return err
+ }
+
+ // Hacer flush si está soportado
+ if f, ok := w.(Flusher); ok {
+ return f.Flush()
+ }
+ return nil
+}
+```
+
+## Organización de Paquetes
+
+### Layout Estándar del Proyecto
+
+```text
+myproject/
+├── cmd/
+│ └── myapp/
+│ └── main.go # Punto de entrada
+├── internal/
+│ ├── handler/ # Handlers HTTP
+│ ├── service/ # Lógica de negocio
+│ ├── repository/ # Acceso a datos
+│ └── config/ # Configuración
+├── pkg/
+│ └── client/ # Cliente de API pública
+├── api/
+│ └── v1/ # Definiciones de API (proto, OpenAPI)
+├── testdata/ # Fixtures de prueba
+├── go.mod
+├── go.sum
+└── Makefile
+```
+
+### Nomenclatura de Paquetes
+
+```go
+// Bien: Corto, minúsculas, sin guiones bajos
+package http
+package json
+package user
+
+// Mal: Verboso, mayúsculas mixtas, o redundante
+package httpHandler
+package json_parser
+package userService // Sufijo 'Service' redundante
+```
+
+### Evitar Estado a Nivel de Paquete
+
+```go
+// Mal: Estado global mutable
+var db *sql.DB
+
+func init() {
+ db, _ = sql.Open("postgres", os.Getenv("DATABASE_URL"))
+}
+
+// Bien: Inyección de dependencias
+type Server struct {
+ db *sql.DB
+}
+
+func NewServer(db *sql.DB) *Server {
+ return &Server{db: db}
+}
+```
+
+## Diseño de Structs
+
+### Patrón de Opciones Funcionales
+
+```go
+type Server struct {
+ addr string
+ timeout time.Duration
+ logger *log.Logger
+}
+
+type Option func(*Server)
+
+func WithTimeout(d time.Duration) Option {
+ return func(s *Server) {
+ s.timeout = d
+ }
+}
+
+func WithLogger(l *log.Logger) Option {
+ return func(s *Server) {
+ s.logger = l
+ }
+}
+
+func NewServer(addr string, opts ...Option) *Server {
+ s := &Server{
+ addr: addr,
+ timeout: 30 * time.Second, // por defecto
+ logger: log.Default(), // por defecto
+ }
+ for _, opt := range opts {
+ opt(s)
+ }
+ return s
+}
+
+// Uso
+server := NewServer(":8080",
+ WithTimeout(60*time.Second),
+ WithLogger(customLogger),
+)
+```
+
+### Embedding para Composición
+
+```go
+type Logger struct {
+ prefix string
+}
+
+func (l *Logger) Log(msg string) {
+ fmt.Printf("[%s] %s\n", l.prefix, msg)
+}
+
+type Server struct {
+ *Logger // Embedding - Server obtiene el método Log
+ addr string
+}
+
+func NewServer(addr string) *Server {
+ return &Server{
+ Logger: &Logger{prefix: "SERVER"},
+ addr: addr,
+ }
+}
+
+// Uso
+s := NewServer(":8080")
+s.Log("Starting...") // Llama al Logger.Log embebido
+```
+
+## Memoria y Rendimiento
+
+### Pre-asignar Slices Cuando Se Conoce el Tamaño
+
+```go
+// Mal: El slice crece múltiples veces
+func processItems(items []Item) []Result {
+ var results []Result
+ for _, item := range items {
+ results = append(results, process(item))
+ }
+ return results
+}
+
+// Bien: Asignación única
+func processItems(items []Item) []Result {
+ results := make([]Result, 0, len(items))
+ for _, item := range items {
+ results = append(results, process(item))
+ }
+ return results
+}
+```
+
+### Usar sync.Pool para Asignaciones Frecuentes
+
+```go
+var bufferPool = sync.Pool{
+ New: func() interface{} {
+ return new(bytes.Buffer)
+ },
+}
+
+func ProcessRequest(data []byte) []byte {
+ buf := bufferPool.Get().(*bytes.Buffer)
+ defer func() {
+ buf.Reset()
+ bufferPool.Put(buf)
+ }()
+
+ buf.Write(data)
+ // Procesar...
+ return buf.Bytes()
+}
+```
+
+### Evitar Concatenación de Strings en Bucles
+
+```go
+// Mal: Crea muchas asignaciones de string
+func join(parts []string) string {
+ var result string
+ for _, p := range parts {
+ result += p + ","
+ }
+ return result
+}
+
+// Bien: Asignación única con strings.Builder
+func join(parts []string) string {
+ var sb strings.Builder
+ for i, p := range parts {
+ if i > 0 {
+ sb.WriteString(",")
+ }
+ sb.WriteString(p)
+ }
+ return sb.String()
+}
+
+// Mejor: Usar la librería estándar
+func join(parts []string) string {
+ return strings.Join(parts, ",")
+}
+```
+
+## Integración con Herramientas Go
+
+### Comandos Esenciales
+
+```bash
+# Build y ejecutar
+go build ./...
+go run ./cmd/myapp
+
+# Pruebas
+go test ./...
+go test -race ./...
+go test -cover ./...
+
+# Análisis estático
+go vet ./...
+staticcheck ./...
+golangci-lint run
+
+# Gestión de módulos
+go mod tidy
+go mod verify
+
+# Formato
+gofmt -w .
+goimports -w .
+```
+
+### Configuración Recomendada de Linter (.golangci.yml)
+
+```yaml
+linters:
+ enable:
+ - errcheck
+ - gosimple
+ - govet
+ - ineffassign
+ - staticcheck
+ - unused
+ - gofmt
+ - goimports
+ - misspell
+ - unconvert
+ - unparam
+
+linters-settings:
+ errcheck:
+ check-type-assertions: true
+ govet:
+ check-shadowing: true
+
+issues:
+ exclude-use-default: false
+```
+
+## Referencia Rápida: Modismos de Go
+
+| Modismo | Descripción |
+|-------|-------------|
+| Aceptar interfaces, retornar structs | Las funciones aceptan parámetros de interfaz, retornan tipos concretos |
+| Los errores son valores | Tratar errores como valores de primera clase, no como excepciones |
+| No comunicarse compartiendo memoria | Usar canales para coordinación entre goroutines |
+| Hacer que el valor cero sea útil | Los tipos deben funcionar sin inicialización explícita |
+| Un poco de copia es mejor que una pequeña dependencia | Evitar dependencias externas innecesarias |
+| Claro es mejor que inteligente | Priorizar legibilidad sobre astucia |
+| gofmt no es favorito de nadie pero sí amigo de todos | Siempre formatear con gofmt/goimports |
+| Retornar temprano | Manejar errores primero, mantener el camino feliz sin indentar |
+
+## Anti-Patrones a Evitar
+
+```go
+// Mal: Retornos naked en funciones largas
+func process() (result int, err error) {
+ // ... 50 líneas ...
+ return // ¿Qué se está retornando?
+}
+
+// Mal: Usar panic para control de flujo
+func GetUser(id string) *User {
+ user, err := db.Find(id)
+ if err != nil {
+ panic(err) // No hacer esto
+ }
+ return user
+}
+
+// Mal: Pasar context en struct
+type Request struct {
+ ctx context.Context // El context debería ser el primer parámetro
+ ID string
+}
+
+// Bien: Context como primer parámetro
+func ProcessRequest(ctx context.Context, id string) error {
+ // ...
+}
+
+// Mal: Mezclar receptores de valor y puntero
+type Counter struct{ n int }
+func (c Counter) Value() int { return c.n } // Receptor de valor
+func (c *Counter) Increment() { c.n++ } // Receptor de puntero
+// Elegir un estilo y ser consistente
+```
+
+**Recuerda**: El código Go debe ser aburrido de la mejor manera — predecible, consistente y fácil de entender. Ante la duda, mantenerlo simple.
diff --git a/docs/es/skills/golang-testing/SKILL.md b/docs/es/skills/golang-testing/SKILL.md
new file mode 100644
index 00000000..d23fd681
--- /dev/null
+++ b/docs/es/skills/golang-testing/SKILL.md
@@ -0,0 +1,720 @@
+---
+name: golang-testing
+description: Patrones de pruebas Go incluyendo pruebas basadas en tablas, subpruebas, benchmarks, fuzzing y cobertura de código. Sigue la metodología TDD con prácticas idiomáticas de Go.
+origin: ECC
+---
+
+# Patrones de Pruebas Go
+
+Patrones completos de pruebas Go para escribir pruebas confiables y mantenibles siguiendo la metodología TDD.
+
+## Cuándo Activar
+
+- Escribir nuevas funciones o métodos Go
+- Agregar cobertura de pruebas a código existente
+- Crear benchmarks para código crítico en rendimiento
+- Implementar pruebas fuzz para validación de entradas
+- Seguir el flujo de trabajo TDD en proyectos Go
+
+## Flujo de Trabajo TDD para Go
+
+### El Ciclo RED-GREEN-REFACTOR
+
+```
+RED → Escribir una prueba que falle primero
+GREEN → Escribir el código mínimo para pasar la prueba
+REFACTOR → Mejorar el código manteniendo las pruebas en verde
+REPEAT → Continuar con el siguiente requisito
+```
+
+### TDD Paso a Paso en Go
+
+```go
+// Paso 1: Definir la interfaz/firma
+// calculator.go
+package calculator
+
+func Add(a, b int) int {
+ panic("not implemented") // Marcador de posición
+}
+
+// Paso 2: Escribir prueba que falle (RED)
+// calculator_test.go
+package calculator
+
+import "testing"
+
+func TestAdd(t *testing.T) {
+ got := Add(2, 3)
+ want := 5
+ if got != want {
+ t.Errorf("Add(2, 3) = %d; want %d", got, want)
+ }
+}
+
+// Paso 3: Ejecutar prueba - verificar FALLO
+// $ go test
+// --- FAIL: TestAdd (0.00s)
+// panic: not implemented
+
+// Paso 4: Implementar código mínimo (GREEN)
+func Add(a, b int) int {
+ return a + b
+}
+
+// Paso 5: Ejecutar prueba - verificar PASA
+// $ go test
+// PASS
+
+// Paso 6: Refactorizar si es necesario, verificar que las pruebas sigan pasando
+```
+
+## Pruebas Basadas en Tablas
+
+El patrón estándar para pruebas Go. Permite cobertura comprensiva con código mínimo.
+
+```go
+func TestAdd(t *testing.T) {
+ tests := []struct {
+ name string
+ a, b int
+ expected int
+ }{
+ {"positive numbers", 2, 3, 5},
+ {"negative numbers", -1, -2, -3},
+ {"zero values", 0, 0, 0},
+ {"mixed signs", -1, 1, 0},
+ {"large numbers", 1000000, 2000000, 3000000},
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ got := Add(tt.a, tt.b)
+ if got != tt.expected {
+ t.Errorf("Add(%d, %d) = %d; want %d",
+ tt.a, tt.b, got, tt.expected)
+ }
+ })
+ }
+}
+```
+
+### Pruebas Basadas en Tablas con Casos de Error
+
+```go
+func TestParseConfig(t *testing.T) {
+ tests := []struct {
+ name string
+ input string
+ want *Config
+ wantErr bool
+ }{
+ {
+ name: "valid config",
+ input: `{"host": "localhost", "port": 8080}`,
+ want: &Config{Host: "localhost", Port: 8080},
+ },
+ {
+ name: "invalid JSON",
+ input: `{invalid}`,
+ wantErr: true,
+ },
+ {
+ name: "empty input",
+ input: "",
+ wantErr: true,
+ },
+ {
+ name: "minimal config",
+ input: `{}`,
+ want: &Config{}, // Valor cero de Config
+ },
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ got, err := ParseConfig(tt.input)
+
+ if tt.wantErr {
+ if err == nil {
+ t.Error("expected error, got nil")
+ }
+ return
+ }
+
+ if err != nil {
+ t.Fatalf("unexpected error: %v", err)
+ }
+
+ if !reflect.DeepEqual(got, tt.want) {
+ t.Errorf("got %+v; want %+v", got, tt.want)
+ }
+ })
+ }
+}
+```
+
+## Subpruebas y Sub-benchmarks
+
+### Organizar Pruebas Relacionadas
+
+```go
+func TestUser(t *testing.T) {
+ // Configuración compartida por todas las subpruebas
+ db := setupTestDB(t)
+
+ t.Run("Create", func(t *testing.T) {
+ user := &User{Name: "Alice"}
+ err := db.CreateUser(user)
+ if err != nil {
+ t.Fatalf("CreateUser failed: %v", err)
+ }
+ if user.ID == "" {
+ t.Error("expected user ID to be set")
+ }
+ })
+
+ t.Run("Get", func(t *testing.T) {
+ user, err := db.GetUser("alice-id")
+ if err != nil {
+ t.Fatalf("GetUser failed: %v", err)
+ }
+ if user.Name != "Alice" {
+ t.Errorf("got name %q; want %q", user.Name, "Alice")
+ }
+ })
+
+ t.Run("Update", func(t *testing.T) {
+ // ...
+ })
+
+ t.Run("Delete", func(t *testing.T) {
+ // ...
+ })
+}
+```
+
+### Subpruebas en Paralelo
+
+```go
+func TestParallel(t *testing.T) {
+ tests := []struct {
+ name string
+ input string
+ }{
+ {"case1", "input1"},
+ {"case2", "input2"},
+ {"case3", "input3"},
+ }
+
+ for _, tt := range tests {
+ tt := tt // Capturar variable del rango
+ t.Run(tt.name, func(t *testing.T) {
+ t.Parallel() // Ejecutar subpruebas en paralelo
+ result := Process(tt.input)
+ // aserciones...
+ _ = result
+ })
+ }
+}
+```
+
+## Helpers de Prueba
+
+### Funciones Helper
+
+```go
+func setupTestDB(t *testing.T) *sql.DB {
+ t.Helper() // Marca esta como función helper
+
+ db, err := sql.Open("sqlite3", ":memory:")
+ if err != nil {
+ t.Fatalf("failed to open database: %v", err)
+ }
+
+ // Limpieza cuando la prueba termina
+ t.Cleanup(func() {
+ db.Close()
+ })
+
+ // Ejecutar migraciones
+ if _, err := db.Exec(schema); err != nil {
+ t.Fatalf("failed to create schema: %v", err)
+ }
+
+ return db
+}
+
+func assertNoError(t *testing.T, err error) {
+ t.Helper()
+ if err != nil {
+ t.Fatalf("unexpected error: %v", err)
+ }
+}
+
+func assertEqual[T comparable](t *testing.T, got, want T) {
+ t.Helper()
+ if got != want {
+ t.Errorf("got %v; want %v", got, want)
+ }
+}
+```
+
+### Archivos y Directorios Temporales
+
+```go
+func TestFileProcessing(t *testing.T) {
+ // Crear directorio temporal - se limpia automáticamente
+ tmpDir := t.TempDir()
+
+ // Crear archivo de prueba
+ testFile := filepath.Join(tmpDir, "test.txt")
+ err := os.WriteFile(testFile, []byte("test content"), 0644)
+ if err != nil {
+ t.Fatalf("failed to create test file: %v", err)
+ }
+
+ // Ejecutar prueba
+ result, err := ProcessFile(testFile)
+ if err != nil {
+ t.Fatalf("ProcessFile failed: %v", err)
+ }
+
+ // Aserciones...
+ _ = result
+}
+```
+
+## Golden Files
+
+Probar contra archivos de salida esperada almacenados en `testdata/`.
+
+```go
+var update = flag.Bool("update", false, "update golden files")
+
+func TestRender(t *testing.T) {
+ tests := []struct {
+ name string
+ input Template
+ }{
+ {"simple", Template{Name: "test"}},
+ {"complex", Template{Name: "test", Items: []string{"a", "b"}}},
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ got := Render(tt.input)
+
+ golden := filepath.Join("testdata", tt.name+".golden")
+
+ if *update {
+ // Actualizar golden file: go test -update
+ err := os.WriteFile(golden, got, 0644)
+ if err != nil {
+ t.Fatalf("failed to update golden file: %v", err)
+ }
+ }
+
+ want, err := os.ReadFile(golden)
+ if err != nil {
+ t.Fatalf("failed to read golden file: %v", err)
+ }
+
+ if !bytes.Equal(got, want) {
+ t.Errorf("output mismatch:\ngot:\n%s\nwant:\n%s", got, want)
+ }
+ })
+ }
+}
+```
+
+## Mocking con Interfaces
+
+### Mocking Basado en Interfaces
+
+```go
+// Definir interfaz para dependencias
+type UserRepository interface {
+ GetUser(id string) (*User, error)
+ SaveUser(user *User) error
+}
+
+// Implementación de producción
+type PostgresUserRepository struct {
+ db *sql.DB
+}
+
+func (r *PostgresUserRepository) GetUser(id string) (*User, error) {
+ // Consulta real a base de datos
+}
+
+// Implementación mock para pruebas
+type MockUserRepository struct {
+ GetUserFunc func(id string) (*User, error)
+ SaveUserFunc func(user *User) error
+}
+
+func (m *MockUserRepository) GetUser(id string) (*User, error) {
+ return m.GetUserFunc(id)
+}
+
+func (m *MockUserRepository) SaveUser(user *User) error {
+ return m.SaveUserFunc(user)
+}
+
+// Prueba usando mock
+func TestUserService(t *testing.T) {
+ mock := &MockUserRepository{
+ GetUserFunc: func(id string) (*User, error) {
+ if id == "123" {
+ return &User{ID: "123", Name: "Alice"}, nil
+ }
+ return nil, ErrNotFound
+ },
+ }
+
+ service := NewUserService(mock)
+
+ user, err := service.GetUserProfile("123")
+ if err != nil {
+ t.Fatalf("unexpected error: %v", err)
+ }
+ if user.Name != "Alice" {
+ t.Errorf("got name %q; want %q", user.Name, "Alice")
+ }
+}
+```
+
+## Benchmarks
+
+### Benchmarks Básicos
+
+```go
+func BenchmarkProcess(b *testing.B) {
+ data := generateTestData(1000)
+ b.ResetTimer() // No contar el tiempo de configuración
+
+ for i := 0; i < b.N; i++ {
+ Process(data)
+ }
+}
+
+// Ejecutar: go test -bench=BenchmarkProcess -benchmem
+// Salida: BenchmarkProcess-8 10000 105234 ns/op 4096 B/op 10 allocs/op
+```
+
+### Benchmark con Diferentes Tamaños
+
+```go
+func BenchmarkSort(b *testing.B) {
+ sizes := []int{100, 1000, 10000, 100000}
+
+ for _, size := range sizes {
+ b.Run(fmt.Sprintf("size=%d", size), func(b *testing.B) {
+ data := generateRandomSlice(size)
+ b.ResetTimer()
+
+ for i := 0; i < b.N; i++ {
+ // Hacer una copia para evitar ordenar datos ya ordenados
+ tmp := make([]int, len(data))
+ copy(tmp, data)
+ sort.Ints(tmp)
+ }
+ })
+ }
+}
+```
+
+### Benchmarks de Asignación de Memoria
+
+```go
+func BenchmarkStringConcat(b *testing.B) {
+ parts := []string{"hello", "world", "foo", "bar", "baz"}
+
+ b.Run("plus", func(b *testing.B) {
+ for i := 0; i < b.N; i++ {
+ var s string
+ for _, p := range parts {
+ s += p
+ }
+ _ = s
+ }
+ })
+
+ b.Run("builder", func(b *testing.B) {
+ for i := 0; i < b.N; i++ {
+ var sb strings.Builder
+ for _, p := range parts {
+ sb.WriteString(p)
+ }
+ _ = sb.String()
+ }
+ })
+
+ b.Run("join", func(b *testing.B) {
+ for i := 0; i < b.N; i++ {
+ _ = strings.Join(parts, "")
+ }
+ })
+}
+```
+
+## Fuzzing (Go 1.18+)
+
+### Prueba Fuzz Básica
+
+```go
+func FuzzParseJSON(f *testing.F) {
+ // Agregar corpus semilla
+ f.Add(`{"name": "test"}`)
+ f.Add(`{"count": 123}`)
+ f.Add(`[]`)
+ f.Add(`""`)
+
+ f.Fuzz(func(t *testing.T, input string) {
+ var result map[string]interface{}
+ err := json.Unmarshal([]byte(input), &result)
+
+ if err != nil {
+ // JSON inválido es esperado para entrada aleatoria
+ return
+ }
+
+ // Si el parseo tuvo éxito, la re-codificación debería funcionar
+ _, err = json.Marshal(result)
+ if err != nil {
+ t.Errorf("Marshal failed after successful Unmarshal: %v", err)
+ }
+ })
+}
+
+// Ejecutar: go test -fuzz=FuzzParseJSON -fuzztime=30s
+```
+
+### Prueba Fuzz con Múltiples Entradas
+
+```go
+func FuzzCompare(f *testing.F) {
+ f.Add("hello", "world")
+ f.Add("", "")
+ f.Add("abc", "abc")
+
+ f.Fuzz(func(t *testing.T, a, b string) {
+ result := Compare(a, b)
+
+ // Propiedad: Compare(a, a) siempre debe ser igual a 0
+ if a == b && result != 0 {
+ t.Errorf("Compare(%q, %q) = %d; want 0", a, b, result)
+ }
+
+ // Propiedad: Compare(a, b) y Compare(b, a) deben tener signos opuestos
+ reverse := Compare(b, a)
+ if (result > 0 && reverse >= 0) || (result < 0 && reverse <= 0) {
+ if result != 0 || reverse != 0 {
+ t.Errorf("Compare(%q, %q) = %d, Compare(%q, %q) = %d; inconsistent",
+ a, b, result, b, a, reverse)
+ }
+ }
+ })
+}
+```
+
+## Cobertura de Código
+
+### Ejecutar Cobertura
+
+```bash
+# Cobertura básica
+go test -cover ./...
+
+# Generar perfil de cobertura
+go test -coverprofile=coverage.out ./...
+
+# Ver cobertura en el navegador
+go tool cover -html=coverage.out
+
+# Ver cobertura por función
+go tool cover -func=coverage.out
+
+# Cobertura con detección de condiciones de carrera
+go test -race -coverprofile=coverage.out ./...
+```
+
+### Objetivos de Cobertura
+
+| Tipo de Código | Objetivo |
+|-----------|--------|
+| Lógica de negocio crítica | 100% |
+| APIs públicas | 90%+ |
+| Código general | 80%+ |
+| Código generado | Excluir |
+
+### Excluir Código Generado de la Cobertura
+
+```go
+//go:generate mockgen -source=interface.go -destination=mock_interface.go
+
+// En el perfil de cobertura, excluir con build tags:
+// go test -cover -tags=!generate ./...
+```
+
+## Pruebas de Handlers HTTP
+
+```go
+func TestHealthHandler(t *testing.T) {
+ // Crear request
+ req := httptest.NewRequest(http.MethodGet, "/health", nil)
+ w := httptest.NewRecorder()
+
+ // Llamar handler
+ HealthHandler(w, req)
+
+ // Verificar respuesta
+ resp := w.Result()
+ defer resp.Body.Close()
+
+ if resp.StatusCode != http.StatusOK {
+ t.Errorf("got status %d; want %d", resp.StatusCode, http.StatusOK)
+ }
+
+ body, _ := io.ReadAll(resp.Body)
+ if string(body) != "OK" {
+ t.Errorf("got body %q; want %q", body, "OK")
+ }
+}
+
+func TestAPIHandler(t *testing.T) {
+ tests := []struct {
+ name string
+ method string
+ path string
+ body string
+ wantStatus int
+ wantBody string
+ }{
+ {
+ name: "get user",
+ method: http.MethodGet,
+ path: "/users/123",
+ wantStatus: http.StatusOK,
+ wantBody: `{"id":"123","name":"Alice"}`,
+ },
+ {
+ name: "not found",
+ method: http.MethodGet,
+ path: "/users/999",
+ wantStatus: http.StatusNotFound,
+ },
+ {
+ name: "create user",
+ method: http.MethodPost,
+ path: "/users",
+ body: `{"name":"Bob"}`,
+ wantStatus: http.StatusCreated,
+ },
+ }
+
+ handler := NewAPIHandler()
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ var body io.Reader
+ if tt.body != "" {
+ body = strings.NewReader(tt.body)
+ }
+
+ req := httptest.NewRequest(tt.method, tt.path, body)
+ req.Header.Set("Content-Type", "application/json")
+ w := httptest.NewRecorder()
+
+ handler.ServeHTTP(w, req)
+
+ if w.Code != tt.wantStatus {
+ t.Errorf("got status %d; want %d", w.Code, tt.wantStatus)
+ }
+
+ if tt.wantBody != "" && w.Body.String() != tt.wantBody {
+ t.Errorf("got body %q; want %q", w.Body.String(), tt.wantBody)
+ }
+ })
+ }
+}
+```
+
+## Comandos de Prueba
+
+```bash
+# Ejecutar todas las pruebas
+go test ./...
+
+# Ejecutar pruebas con salida detallada
+go test -v ./...
+
+# Ejecutar prueba específica
+go test -run TestAdd ./...
+
+# Ejecutar pruebas que coincidan con patrón
+go test -run "TestUser/Create" ./...
+
+# Ejecutar pruebas con detector de condiciones de carrera
+go test -race ./...
+
+# Ejecutar pruebas con cobertura
+go test -cover -coverprofile=coverage.out ./...
+
+# Ejecutar solo pruebas cortas
+go test -short ./...
+
+# Ejecutar pruebas con timeout
+go test -timeout 30s ./...
+
+# Ejecutar benchmarks
+go test -bench=. -benchmem ./...
+
+# Ejecutar fuzzing
+go test -fuzz=FuzzParse -fuzztime=30s ./...
+
+# Contar ejecuciones de prueba (para detección de pruebas inestables)
+go test -count=10 ./...
+```
+
+## Buenas Prácticas
+
+**HACER:**
+- Escribir pruebas PRIMERO (TDD)
+- Usar pruebas basadas en tablas para cobertura comprensiva
+- Probar comportamiento, no implementación
+- Usar `t.Helper()` en funciones helper
+- Usar `t.Parallel()` para pruebas independientes
+- Limpiar recursos con `t.Cleanup()`
+- Usar nombres de prueba significativos que describan el escenario
+
+**NO HACER:**
+- Probar funciones privadas directamente (probar a través de la API pública)
+- Usar `time.Sleep()` en pruebas (usar canales o condiciones)
+- Ignorar pruebas inestables (corregirlas o eliminarlas)
+- Mockear todo (preferir pruebas de integración cuando sea posible)
+- Omitir pruebas de rutas de error
+
+## Integración con CI/CD
+
+```yaml
+# Ejemplo de GitHub Actions
+test:
+ runs-on: ubuntu-latest
+ steps:
+ - uses: actions/checkout@v4
+ - uses: actions/setup-go@v5
+ with:
+ go-version: '1.22'
+
+ - name: Run tests
+ run: go test -race -coverprofile=coverage.out ./...
+
+ - name: Check coverage
+ run: |
+ go tool cover -func=coverage.out | grep total | awk '{print $3}' | \
+ awk -F'%' '{if ($1 < 80) exit 1}'
+```
+
+**Recuerda**: Las pruebas son documentación. Muestran cómo se pretende usar tu código. Escríbelas con claridad y mantenlas actualizadas.
diff --git a/docs/es/skills/jpa-patterns/SKILL.md b/docs/es/skills/jpa-patterns/SKILL.md
new file mode 100644
index 00000000..7555ee21
--- /dev/null
+++ b/docs/es/skills/jpa-patterns/SKILL.md
@@ -0,0 +1,151 @@
+---
+name: jpa-patterns
+description: Patrones JPA/Hibernate para diseño de entidades, relaciones, optimización de consultas, transacciones, auditoría, indexación, paginación y pooling en Spring Boot.
+origin: ECC
+---
+
+# Patrones JPA/Hibernate
+
+Usar para modelado de datos, repositorios y ajuste de rendimiento en Spring Boot.
+
+## Cuándo Activar
+
+- Diseñar entidades JPA y mapeos de tablas
+- Definir relaciones (@OneToMany, @ManyToOne, @ManyToMany)
+- Optimizar consultas (prevención de N+1, estrategias de fetch, proyecciones)
+- Configurar transacciones, auditoría o soft deletes
+- Configurar paginación, ordenamiento o métodos de repositorio personalizados
+- Ajustar el connection pool (HikariCP) o caché de segundo nivel
+
+## Diseño de Entidades
+
+```java
+@Entity
+@Table(name = "markets", indexes = {
+ @Index(name = "idx_markets_slug", columnList = "slug", unique = true)
+})
+@EntityListeners(AuditingEntityListener.class)
+public class MarketEntity {
+ @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
+ private Long id;
+
+ @Column(nullable = false, length = 200)
+ private String name;
+
+ @Column(nullable = false, unique = true, length = 120)
+ private String slug;
+
+ @Enumerated(EnumType.STRING)
+ private MarketStatus status = MarketStatus.ACTIVE;
+
+ @CreatedDate private Instant createdAt;
+ @LastModifiedDate private Instant updatedAt;
+}
+```
+
+Habilitar auditoría:
+```java
+@Configuration
+@EnableJpaAuditing
+class JpaConfig {}
+```
+
+## Relaciones y Prevención de N+1
+
+```java
+@OneToMany(mappedBy = "market", cascade = CascadeType.ALL, orphanRemoval = true)
+private List