claudient 0.1.0

package/guides/de/token-optimization.md

@@ -0,0 +1,156 @@
+# Token-Optimierungsleitfaden
+
+Wie Sie Claude Code-Kosten reduzieren und die Antwortgeschwindigkeit verbessern, ohne die Ausgabequalität zu opfern.
+
+---
+
+## Das Grundprinzip
+
+Jeder Token im Kontextfenster von Claude Code kostet Geld und verlangsamt Antworten. Das Ziel ist, das Kontextfenster schlank zu halten — nur das, was Claude braucht, um die aktuelle Aufgabe gut zu erledigen.
+
+Es gibt vier Hebel:
+1. **Modellauswahl** — die richtige Modell-Aufgaben-Zuordnung
+2. **Kontextverwaltung** — Kontrolle über den Fensterinhalt
+3. **MCP-Disziplin** — Begrenzung des Tool-Overheads
+4. **Komprimierungsstrategie** — wann und wie der Verlauf komprimiert wird
+
+---
+
+## 1. Modellauswahl
+
+Claude Code unterstützt mehrere Modelle. Das falsche Modell für eine Aufgabe zu wählen ist der teuerste einzelne Fehler.
+
+| Modell | Am besten für | Relative Kosten |
+|---|---|---|
+| Claude Haiku 4.5 | Einfache Bearbeitungen, Einzeldatei-Aufgaben, repetitive Operationen, Zusammenfassung | Niedrigste |
+| Claude Sonnet 4.6 | Die meiste Entwicklungsarbeit — Multi-Datei-Änderungen, Debugging, Code-Review | Mittel |
+| Claude Opus 4.7 | Komplexe Architekturentscheidungen, Sicherheitsanalyse, Multi-Agent-Orchestrierung | Höchste |
+
+**Faustregeln:**
+- Standard: Sonnet 4.6 für allgemeine Entwicklung
+- Wechseln Sie zu Haiku 4.5 für: Linting-Korrekturen, Formatierung, einfache Umbenennungen, Einzelfunktions-Bearbeitungen, Boilerplate-Generierung aus einer Vorlage
+- Eskalieren Sie zu Opus 4.7 nur wenn: das Problem tiefes Reasoning über viele Dateien erfordert, Sicherheitsentscheidungen involviert sind, oder Sie mehrere Sub-Agenten orchestrieren
+
+**Haiku spart ~60 % gegenüber Sonnet bei geeigneten Aufgaben.**
+
+---
+
+## 2. Kontextfensterverwaltung
+
+Das Kontextfenster von Claude Code ist groß (bis zu 1M Tokens bei Opus 4.7 und Sonnet 4.6), aber das **nutzbare** Fenster ist kleiner, sobald der Overhead berücksichtigt wird.
+
+### Was Kontext verbraucht
+
+| Quelle | Ungefähre Kosten |
+|---|---|
+| MCP-Tools (10 aktiviert) | ~30k Tokens |
+| CLAUDE.md (Projekt + Benutzer) | 1k–10k Tokens |
+| Konversationsverlauf | Wächst mit jedem Turn |
+| Dateiinhalte im Kontext | Variiert — oft der größte Faktor |
+| System-Prompt | ~5k–10k Tokens |
+
+### Kontext schlank halten
+
+**CLAUDE.md:**
+- Halten Sie Projekt-CLAUDE.md unter 500 Zeilen
+- Entfernen Sie Regeln, die nicht mehr für den aktuellen Projektzustand gelten
+- Duplizieren Sie keine Inhalte aus Benutzer-CLAUDE.md in Projekt-CLAUDE.md
+
+**Dateilesungen:**
+- Bitten Sie Claude, spezifische Zeilenbereiche statt vollständiger Dateien zu lesen
+- Vermeiden Sie es, dieselbe große Datei mehrmals in einer Sitzung zu lesen
+- Verwenden Sie Sub-Agenten für isolierte Aufgaben — sie erhalten ein frisches Kontextfenster
+
+**Konversationsverlauf:**
+- Lange Sitzungen sammeln toten Kontext an
+- Lösen Sie die Komprimierung proaktiv aus, anstatt auf den automatischen Schwellenwert zu warten
+
+---
+
+## 3. MCP-Disziplin
+
+Jeder aktivierte MCP-Server lädt seine Tool-Definitionen beim Sitzungsstart in den Kontext. Mit 10 MCP-Servern und ~8 Tools pro Server verbrauchen Sie ~80 Tool-Slots — etwa 30k Tokens, bevor Sie ein Wort getippt haben.
+
+**Auditieren Sie Ihre aktiven MCPs:**
+- Aktivieren Sie nur MCPs, die Sie im aktuellen Projekt verwenden
+- Deaktivieren Sie domänenspezifische MCPs (z.B. Datenbank, Cloud), wenn Sie nicht in diesem Bereich arbeiten
+- Überprüfen Sie `.claude/settings.json` und `~/.claude/settings.json` auf aktivierte Server
+
+---
+
+## 4. Komprimierungsstrategie
+
+Claude Code komprimiert den Konversationsverlauf automatisch, wenn der Kontext seine Grenze erreicht. Der Standardschwellenwert ist spät — er wird bei ~95 % Kapazität ausgelöst.
+
+### Komprimierung früher auslösen
+
+Verwenden Sie den Befehl `/compact` manuell, bevor Sie eine neue größere Aufgabe beginnen.
+
+**Wann manuell komprimieren:**
+- Vor dem Wechsel von einer großen Aufgabe zu einer anderen in derselben Sitzung
+- Nach einer langen Debugging-Sitzung mit vielen fehlgeschlagenen Versuchen im Verlauf
+- Vor dem Start einer Aufgabe, die das Lesen vieler großer Dateien erfordert
+
+### Was Komprimierung bewirkt
+
+Die Komprimierung fasst den Konversationsverlauf zusammen und ersetzt ihn durch eine komprimierte Darstellung. Sie verlieren den genauen turn-by-turn Verlauf, behalten aber Entscheidungen, geschriebenen Code und Schlüsselkontext.
+
+**Pre-Compact-Hook:** Verwenden Sie einen `PreCompact`-Hook, um kritischen Sitzungszustand in eine Datei zu speichern, bevor die Komprimierung ausgelöst wird.
+
+---
+
+## 5. Prompt-Effizienz
+
+**Seien Sie spezifisch bezüglich des Umfangs:**
+
+Statt: "Behebe die Authentifizierung"
+Verwenden Sie: "Behebe die JWT-Ablaufprüfung in `auth/middleware.py:45` — sie lehnt keine Tokens mit `exp` in der Vergangenheit ab"
+
+**Begrenzen Sie die Antwortlänge wenn angemessen:**
+
+Für Aufgaben, bei denen Sie eine Code-Änderung, aber keine Erklärung benötigen: "Nehmen Sie die Änderung vor, keine Erklärung nötig."
+
+**Bündeln Sie verwandte Anfragen:**
+
+Statt fünf separater "füge einen Test für X hinzu"-Anfragen sagen Sie: "Füge Tests für alle fünf Funktionen in `utils.py` hinzu."
+
+---
+
+## 6. Sub-Agent-Kontextisolierung
+
+Sub-Agenten erhalten ein frisches Kontextfenster. Dies ist eine der am meisten unterschätzten Optimierungstechniken.
+
+**Verwenden Sie Sub-Agenten wenn:**
+- Eine Aufgabe in sich abgeschlossen ist (klare Eingaben, klare Ausgaben)
+- Die Aufgabe das Lesen vieler Dateien erfordert, die für den Rest der Sitzung nicht relevant sind
+- Sie etwas Repetitives über mehrere Dateien hinweg tun
+
+---
+
+## 7. Kostenverfolgung
+
+Verwenden Sie einen `PostToolUse`-Hook, um Tool-Nutzung zu protokollieren und Kosten pro Sitzung zu schätzen.
+
+Siehe `hooks/lifecycle/cost-tracker.sh` für eine fertige Implementierung.
+
+---
+
+## Schnellreferenz
+
+| Situation | Aktion |
+|---|---|
+| Einfache Einzeldatei-Bearbeitung | Zu Haiku 4.5 wechseln |
+| Lange Sitzung wird langsam | Manuell komprimieren (`/compact`) |
+| Neue große Aufgabe beginnen | Zuerst komprimieren, dann beginnen |
+| Arbeit in einem Bereich, den Sie nicht anfassen werden | Domain-MCPs deaktivieren |
+| Aufgabe ist in sich abgeschlossen | Sub-Agent verwenden |
+| Vage Anfrage produziert lange Antworten | Als spezifischen, abgegrenzten Prompt neu schreiben |
+| CLAUDE.md über 500 Zeilen | Auditieren und veraltete Regeln entfernen |
+
+---
+
+## Arbeiten Sie mit uns
+
+Claudient wird unterstützt von [Uitbreiden](https://uitbreiden.com/) — wir entwickeln KI-Produkte mit Entwickler-Communities und liefern B2B-KI-Lösungen. Wenn Sie KI-Kosten in großem Maßstab reduzieren, Claude Code-Tooling für Ihr Team aufbauen oder B2B-KI-Produkte liefern möchten — lassen Sie uns sprechen.
+
+**[uitbreiden.com](https://uitbreiden.com/)**

package/guides/es/agent-orchestration.md

@@ -0,0 +1,174 @@
+# Guía de orquestación de agentes
+
+Cómo delegar, paralelizar y especializar trabajo usando el sistema de sub-agentes de Claude Code.
+
+---
+
+## Qué son los sub-agentes
+
+Un sub-agente es una instancia Claude separada iniciada por la sesión padre para manejar una tarea específica y acotada. Obtiene:
+- Una ventana de contexto fresca (sin historial de sesión)
+- Un subconjunto específico de herramientas (si está configurado)
+- Una selección de modelo (puede diferir del padre)
+- Un prompt que escribes explícitamente
+
+Los sub-agentes no son magia — son una herramienta específica para problemas específicos.
+
+---
+
+## Cuándo usar un sub-agente
+
+Usa un sub-agente cuando la tarea tiene **entradas claras** y **salidas claras** y es **independiente del estado de sesión actual**.
+
+**Buenos candidatos:**
+- Revisar 10 archivos en busca de problemas de seguridad
+- Ejecutar una búsqueda específica en el código para localizar un patrón
+- Generar boilerplate para un nuevo módulo dado un spec
+- Analizar un archivo de log y devolver un resumen
+
+**Malos candidatos:**
+- Tareas que requieren el contexto completo de la sesión
+- Tareas que requieren ida y vuelta — los sub-agentes son de una sola pasada
+- Tareas donde el overhead de lanzamiento supera el trabajo
+
+---
+
+## 1. Patrón de delegación
+
+La sesión padre identifica una tarea acotada y la entrega.
+
+**Regla clave:** El prompt del sub-agente debe ser autónomo. No tiene acceso a lo que la sesión padre ha estado haciendo. Briéfalo como un colega que acaba de entrar a la sala.
+
+**Qué incluir en el prompt del sub-agente:**
+- Qué estás intentando lograr y por qué
+- Los archivos o directorios específicos
+- El formato de resultado deseado
+- Decisiones ya tomadas
+
+---
+
+## 2. Patrón de paralelización
+
+Múltiples sub-agentes ejecutándose simultáneamente en tareas independientes.
+
+**Cuándo paralelizar:**
+- La misma operación debe aplicarse a muchos archivos/módulos
+- Dos tareas genuinamente independientes deben completarse ambas
+- Tareas de investigación que cubren diferentes áreas
+
+**Usando git worktrees para cambios de código paralelos:**
+```bash
+git worktree add ../feature-branch-a feature-a
+git worktree add ../feature-branch-b feature-b
+```
+
+**Anti-patrones de paralelización:**
+- Paralelizar tareas que comparten estado (conflictos de escritura)
+- Tareas paralelas donde una depende de la salida de la otra
+
+---
+
+## 3. Patrón de especialización (cavecrew)
+
+Adapta el modelo y las herramientas del sub-agente a la naturaleza de la tarea. Inspirado en el patrón **cavecrew** (fuente: [JuliusBrussee/caveman](https://github.com/JuliusBrussee/caveman)) — ahorra ~60% de tokens comparado con usar Opus para cada sub-agente.
+
+| Rol | Modelo | Herramientas | Usar cuando |
+|---|---|---|---|
+| Investigador | Haiku 4.5 | Read, Bash (solo grep/find) | Localizar cosas en el código — solo lectura, rápido |
+| Constructor | Sonnet 4.6 | Read, Edit, Write, Bash | Cambios quirúrgicos de 1–2 archivos |
+| Revisor | Haiku 4.5 | Read | Revisar un diff o conjunto de archivos |
+| Orquestador | Opus 4.7 | Todos | Coordinación compleja multi-paso, decisiones de arquitectura |
+
+---
+
+## 4. Patrón de traspaso de contexto
+
+Cuando una sesión ha acumulado contexto significativo y necesitas traspasar el trabajo a un nuevo agente.
+
+**Estructura del prompt de traspaso:**
+```
+## Context
+[Qué hace este proyecto, brevemente]
+[En qué estábamos trabajando]
+[Decisiones tomadas durante esta sesión]
+
+## Files modified
+[Lista con breve razón para cada cambio]
+
+## Current state
+[Qué está hecho, qué no, qué bloquea]
+
+## Your task
+[Tarea específica y acotada para el nuevo agente]
+
+## Constraints
+[Decisiones tomadas que no deben revisarse]
+```
+
+---
+
+## 5. Dependencias duras vs. suaves
+
+**Dependencia dura:** La tarea aguas abajo falla explícitamente sin la configuración aguas arriba.
+- Señálalo explícitamente: "Esta skill requiere configuración — ejecuta `/setup` primero."
+
+**Dependencia suave:** La tarea funciona pero produce salida de menor calidad sin configuración.
+- No detener. Degradar graciosamente y anotar la brecha.
+
+---
+
+## 6. Control de alcance para sub-agentes
+
+Cada sub-agente debe tener un límite de alcance explícito.
+
+**Incluir en cada prompt de sub-agente:**
+```
+## Scope
+- Read: yes
+- Write/Edit: [solo archivos específicos O no]
+- Shell commands: [comandos específicos permitidos O ninguno]
+- Network: [sí/no]
+
+## Do not
+- Do not modify files outside [directory]
+- Do not make git commits
+- Do not install packages
+```
+
+---
+
+## 7. Devolver resultados de sub-agentes
+
+**Preferir archivos para:**
+- Listas de hallazgos sobre las que el padre iterará
+- Código generado que el padre revisará
+- Informes referenciados múltiples veces
+
+**Preferir mensajes de retorno para:**
+- Respuestas simples sí/no
+- Datos estructurados cortos
+- Informes de estado
+
+---
+
+## Referencia rápida
+
+| Objetivo | Patrón |
+|---|---|
+| Tarea acotada y autónoma | Delegación |
+| Misma tarea en muchos archivos | Paralelización |
+| Búsqueda/localización solo lectura | Investigador (Haiku) |
+| Cambio de código quirúrgico | Constructor (Sonnet) |
+| Revisión de diff/archivo | Revisor (Haiku) |
+| Coordinación compleja multi-paso | Orquestador (Opus) |
+| Traspaso de sesión | Patrón de traspaso de contexto |
+| Salida grande de sub-agente | Escribir a archivo, padre lo lee |
+| Resultado estructurado corto | Mensaje de retorno |
+
+---
+
+## Trabaja con nosotros
+
+Claudient está respaldado por [Uitbreiden](https://uitbreiden.com/) — construimos productos de IA con comunidades de desarrolladores y entregamos soluciones de IA B2B. Si estás diseñando sistemas multi-agente, workflows autónomos u orquestación de Claude Code de grado producción — lo hemos construido en producción y podemos ayudarte.
+
+**[uitbreiden.com](https://uitbreiden.com/)**

package/guides/es/getting-started.md

@@ -0,0 +1,164 @@
+# Primeros pasos con Claudient
+
+Esta guía te lleva de cero a un entorno Claude Code funcional con tu primera skill, agente y hook — en menos de 10 minutos.
+
+---
+
+## Requisitos previos
+
+- [Claude Code](https://claude.ai/code) instalado y autenticado
+- Un directorio de proyecto en el que estés trabajando activamente
+
+---
+
+## Paso 1 — Clonar Claudient
+
+```bash
+git clone https://github.com/Claudient/Claudient.git ~/Claudient
+```
+
+Ahora tienes la biblioteca completa localmente. Nada se ejecuta automáticamente — tú eliges lo que necesitas.
+
+---
+
+## Paso 2 — Configurar el directorio `.claude/` de tu proyecto
+
+Claude Code busca la configuración en `.claude/` en la raíz de tu proyecto.
+
+```bash
+mkdir -p your-project/.claude/skills
+mkdir -p your-project/.claude/hooks
+```
+
+La estructura de tu proyecto debería verse así:
+
+```
+your-project/
+├── .claude/
+│   ├── skills/        ← las skills van aquí (estándar actual)
+│   ├── hooks/         ← los scripts de hooks van aquí
+│   └── settings.json  ← la configuración de hooks va aquí
+├── CLAUDE.md          ← las reglas van aquí
+└── src/
+```
+
+---
+
+## Paso 3 — Añadir tu primera skill
+
+Las skills son comandos slash. Copia cualquier archivo `.md` de `skills/` a `.claude/skills/`:
+
+```bash
+# Ejemplo: añadir la skill de FastAPI
+cp ~/Claudient/skills/backend/python/fastapi.md your-project/.claude/skills/
+```
+
+Ahora abre Claude Code en tu proyecto y escribe `/fastapi` — la skill se activa.
+
+> **Nota:** `.claude/commands/` sigue funcionando (ruta heredada) pero `.claude/skills/` es el estándar actual. Cuando ambos existen, las skills tienen prioridad.
+
+**Cómo elegir una skill:**
+- Navega por `skills/` por categoría
+- Lee la sección "When to activate" al inicio de cada archivo
+- Si coincide con tu tarea actual, cópiala
+
+---
+
+## Paso 4 — Añadir una regla
+
+Las reglas viven en `CLAUDE.md` en la raíz de tu proyecto. Claude lee este archivo al inicio de cada sesión.
+
+```bash
+# Copiar un conjunto de reglas comunes al CLAUDE.md de tu proyecto
+cat ~/Claudient/rules/common/coding-style.md >> your-project/CLAUDE.md
+```
+
+O abre `rules/common/` y copia manualmente las secciones relevantes para tu proyecto.
+
+---
+
+## Paso 5 — Añadir tu primer hook
+
+Los hooks se ejecutan automáticamente en los eventos de Claude Code. Viven en `.claude/settings.json`.
+
+Crea o abre `.claude/settings.json` en tu proyecto:
+
+```json
+{
+  "hooks": {}
+}
+```
+
+Copia un hook de `hooks/` — cada archivo de hook incluye el JSON exacto a pegar. Por ejemplo, el hook de seguimiento de costes:
+
+```json
+{
+  "hooks": {
+    "PostToolUse": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "${CLAUDE_PROJECT_DIR}/.claude/hooks/cost-tracker.sh"
+          }
+        ]
+      }
+    ]
+  }
+}
+```
+
+Luego copia el script correspondiente:
+
+```bash
+cp ~/Claudient/hooks/lifecycle/cost-tracker.sh your-project/.claude/hooks/
+chmod +x your-project/.claude/hooks/cost-tracker.sh
+```
+
+---
+
+## Paso 6 — (Opcional) Añadir un agente
+
+Los agentes son definiciones de sub-agentes que referencias en tus sesiones de Claude. No requieren copiar archivos — los llamas por `subagent_type` en una invocación de la herramienta Agent.
+
+Navega por `agents/` para entender qué está disponible. Cuando quieras que Claude delegue una tarea a un especialista (por ejemplo, un revisor de seguridad, un especialista en bases de datos), referencia la definición del agente para entender qué espera y qué devuelve.
+
+---
+
+## Qué hacer a continuación
+
+| Objetivo | Dónde buscar |
+|---|---|
+| Escribir tu propia skill | [guides/skill-authoring.md](skill-authoring.md) |
+| Reducir costes de tokens | [guides/token-optimization.md](token-optimization.md) |
+| Entender la memoria y el estado de sesión | [guides/memory-management.md](memory-management.md) |
+| Asegurar tu configuración de Claude Code | [guides/security.md](security.md) |
+| Construir workflows automatizados multi-paso | [guides/agent-orchestration.md](agent-orchestration.md) |
+| Automatizar la calidad con hooks | [guides/hooks-cookbook.md](hooks-cookbook.md) |
+
+---
+
+## Solución de problemas
+
+**La skill no aparece como comando slash**
+— Comprueba que el archivo está en `.claude/skills/` (o `.claude/commands/` para la ruta heredada)
+— Comprueba que la extensión del archivo es `.md`
+— Reinicia Claude Code
+
+**El hook no se activa**
+— Verifica que el nombre del evento coincide exactamente: `PreToolUse`, `PostToolUse`, `PreCompact`, `Notification`
+— Comprueba que la ruta del script es relativa a la raíz del proyecto
+— Comprueba que el script es ejecutable (`chmod +x`)
+
+**CLAUDE.md no se lee**
+— Debe estar en la raíz del proyecto (al mismo nivel que `src/`, `package.json`, etc.)
+— Reinicia la sesión de Claude Code después de editarlo
+
+---
+
+## Trabaja con nosotros
+
+Claudient está respaldado por [Uitbreiden](https://uitbreiden.com/) — construimos productos de IA con comunidades de desarrolladores y entregamos soluciones de IA B2B. Si estás construyendo algo serio con Claude Code y quieres ayuda experta, un socio técnico, o simplemente formar parte de la comunidad — ven a buscarnos.
+
+**[uitbreiden.com](https://uitbreiden.com/)**

package/guides/es/hooks-cookbook.md

@@ -0,0 +1,160 @@
+# Libro de recetas de hooks
+
+Patrones de hooks reales y listos para usar para automatizar calidad, seguridad y observabilidad en Claude Code.
+
+---
+
+## Fundamentos de hooks
+
+Los hooks son scripts shell o comandos que Claude Code ejecuta automáticamente en respuesta a eventos. Se ejecutan fuera del contexto de Claude — son procesos shell reales, no instrucciones de Claude.
+
+**Eventos de hook:**
+| Evento | Cuándo se activa |
+|---|---|
+| `SessionStart` | Cuando una sesión de Claude Code comienza |
+| `PreToolUse` | Antes de que se ejecute cualquier llamada a herramienta |
+| `PostToolUse` | Después de que se completa una llamada a herramienta |
+| `PreCompact` | Antes de que se active la compactación de contexto |
+| `PostCompact` | Después de la compactación de contexto |
+| `Stop` | Cuando Claude termina de responder |
+| `Notification` | Cuando Claude envía una notificación de escritorio |
+
+**Códigos de salida:** `0` = permitir, `1` = advertir (Claude ve la salida pero continúa), `2` = bloquear (la llamada a herramienta se cancela).
+
+---
+
+## Receta 1 — Auto-formateo Prettier al escribir
+
+```json
+{
+  "hooks": {
+    "PostToolUse": [
+      {
+        "matcher": "Write|Edit",
+        "hooks": [{ "type": "command", "command": "npx prettier --write ${tool_input.file_path}", "async": true }]
+      }
+    ]
+  }
+}
+```
+
+---
+
+## Receta 2 — Bloquear comandos shell peligrosos
+
+**.claude/hooks/block-dangerous.sh:**
+```bash
+#!/usr/bin/env bash
+INPUT=$(cat)
+COMMAND=$(echo "$INPUT" | python3 -c "import sys,json; print(json.load(sys.stdin).get('command',''))")
+BLOCKED_PATTERNS=("rm -rf" "sudo " "| bash" "| sh" "git push --force" "git reset --hard")
+for pattern in "${BLOCKED_PATTERNS[@]}"; do
+  if echo "$COMMAND" | grep -qi "$pattern"; then
+    echo "BLOQUEADO: el comando coincide con el patrón peligroso '$pattern'" >&2
+    exit 2
+  fi
+done
+exit 0
+```
+
+---
+
+## Receta 3 — Registro de auditoría para cada llamada a herramienta
+
+**.claude/hooks/audit-log.sh:**
+```bash
+#!/usr/bin/env bash
+INPUT=$(cat)
+TOOL_NAME=$(echo "$INPUT" | python3 -c "import sys,json; d=json.load(sys.stdin); print(d.get('tool_name','unknown'))" 2>/dev/null)
+TIMESTAMP=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
+LOG_FILE="${CLAUDE_PROJECT_DIR}/.claude/logs/audit.log"
+mkdir -p "$(dirname "$LOG_FILE")"
+echo "${TIMESTAMP} | ${TOOL_NAME}" >> "$LOG_FILE"
+```
+
+---
+
+## Receta 4 — Guardado de sesión antes de la compactación
+
+Combina con una instrucción CLAUDE.md: "Cuando PreCompact se active, resume: tarea actual, archivos modificados, decisiones abiertas, próximos pasos — añade a `.claude/memory/session-state.md`."
+
+---
+
+## Receta 5 — Rastreador de costes
+
+```json
+{
+  "hooks": {
+    "PostToolUse": [
+      { "matcher": "", "hooks": [{ "type": "command", "command": "${CLAUDE_PROJECT_DIR}/.claude/hooks/cost-tracker.sh", "async": true }] }
+    ]
+  }
+}
+```
+
+---
+
+## Receta 6 — Verificación de tipos TypeScript al editar
+
+```json
+{
+  "hooks": {
+    "PostToolUse": [
+      {
+        "matcher": "Write|Edit",
+        "hooks": [{ "type": "command", "command": "bash -c 'echo \"${tool_input.file_path}\" | grep -q \"\\.tsx\\?$\" && npx tsc --noEmit 2>&1 | head -20 || true'", "async": false, "timeout": 30 }]
+      }
+    ]
+  }
+}
+```
+
+---
+
+## Receta 7 — Recordatorio de git push
+
+```bash
+#!/usr/bin/env bash
+INPUT=$(cat)
+COMMAND=$(echo "$INPUT" | python3 -c "import sys,json; print(json.load(sys.stdin).get('command',''))" 2>/dev/null)
+if echo "$COMMAND" | grep -q "git push"; then
+  echo "⚠️  A punto de hacer push al remoto. Confirma que esto es intencional." >&2
+  exit 1
+fi
+exit 0
+```
+
+---
+
+## Receta 8 — Cargador de contexto al inicio de sesión
+
+```json
+{
+  "hooks": {
+    "SessionStart": [
+      { "matcher": "", "hooks": [{ "type": "command", "command": "${CLAUDE_PROJECT_DIR}/.claude/hooks/session-start.sh" }] }
+    ]
+  }
+}
+```
+
+---
+
+## Solución de problemas con hooks
+
+**El hook no se activa:**
+- Verifica que el nombre del evento sea exacto: `PreToolUse`, `PostToolUse`, `SessionStart`, `PreCompact`
+- Verifica que el script sea ejecutable: `chmod +x .claude/hooks/tu-script.sh`
+
+**Probar un hook manualmente:**
+```bash
+echo '{"tool_name":"Bash","tool_input":{"command":"ls"}}' | bash .claude/hooks/tu-script.sh
+```
+
+---
+
+## Trabaja con nosotros
+
+Claudient está respaldado por [Uitbreiden](https://uitbreiden.com/) — construimos productos de IA con comunidades de desarrolladores y entregamos soluciones de IA B2B. Si necesitas sistemas de hooks personalizados, puertas de calidad automatizadas o automatización de Claude Code de grado producción para tu equipo — lo construimos para clientes.
+
+**[uitbreiden.com](https://uitbreiden.com/)**