@saulwade/swl-ses 1.0.0

package/comandos/swl/revisar.md

@@ -0,0 +1,330 @@
+---
+name: swl:revisar
+description: >
+  Ejecuta revisión de código especializada por tecnología. Detecta automáticamente
+  el stack del proyecto o acepta argumento explícito. Delega al agente revisor
+  correspondiente con el skill de lenguaje cargado. Produce reporte con severidades.
+allowed_tools: ["Read", "Write", "Edit", "Bash", "Glob", "Grep", "Agent"]
+---
+
+# /swl:revisar — Revisión de código por tecnología
+
+Comando unificado de revisión que detecta la tecnología y delega al revisor especializado.
+Soporta revisión genérica, por lenguaje, por stack y por archivo específico.
+
+## Uso
+
+```
+/swl:revisar                    — Auto-detecta stack y revisa todo
+/swl:revisar python             — Revisión Python (FastAPI, Django, patrones)
+/swl:revisar java               — Revisión Java (Spring Boot, JPA, streams)
+/swl:revisar go                 — Revisión Go (concurrency, error handling, interfaces)
+/swl:revisar rust               — Revisión Rust (ownership, unsafe, async)
+/swl:revisar csharp             — Revisión C# (ASP.NET Core, EF Core, async)
+/swl:revisar kotlin             — Revisión Kotlin (coroutines, Compose, null safety)
+/swl:revisar swift              — Revisión Swift (SwiftUI, actors, concurrency)
+/swl:revisar php                — Revisión PHP (Laravel, Eloquent, seguridad)
+/swl:revisar nextjs             — Revisión Next.js (RSC, Server Actions, caching)
+/swl:revisar react              — Revisión React (hooks, state, performance)
+/swl:revisar angular            — Revisión Angular (signals, standalone, OnPush)
+/swl:revisar typescript         — Revisión TypeScript (tipos, patrones, testing)
+/swl:revisar sql                — Revisión SQL/PostgreSQL (queries, indices, N+1)
+/swl:revisar seguridad          — Revisión de seguridad OWASP (todos los lenguajes)
+/swl:revisar <archivo>          — Revisa un archivo específico (detecta lenguaje por extensión)
+```
+
+## Paso 0 — Detección de tecnología
+
+Si no se proporciona argumento, detectar automáticamente:
+
+```bash
+ls package.json pyproject.toml requirements.txt go.mod Cargo.toml \
+   *.csproj *.sln build.gradle.kts Package.swift composer.json 2>/dev/null
+```
+
+Reglas de detección:
+- `package.json` con `"next"` → nextjs
+- `package.json` con `"@angular/core"` → angular
+- `package.json` con `"react"` (sin next ni angular) → react
+- `package.json` sin frameworks conocidos → typescript
+- `pyproject.toml` o `requirements.txt` → python
+- `go.mod` → go
+- `Cargo.toml` → rust
+- `*.csproj` o `*.sln` → csharp
+- `build.gradle.kts` → kotlin
+- `Package.swift` → swift
+- `composer.json` → php
+- Múltiples detectados → revisión en paralelo (ver Paso 3b)
+
+Si se proporciona un archivo como argumento, detectar por extension:
+`.py` → python | `.go` → go | `.rs` → rust | `.cs` → csharp |
+`.kt` → kotlin | `.swift` → swift | `.php` → php |
+`.ts` / `.tsx` → typescript | `.sql` → sql |
+`.js` / `.jsx` → typescript
+
+## Paso 1 — Determinar alcance
+
+```bash
+# Archivos cambiados respecto a main (preferido)
+git diff --name-only main...HEAD 2>/dev/null
+
+# O archivos staged
+git diff --cached --name-only 2>/dev/null
+
+# O commits recientes si lo anterior esta vacio
+git diff --name-only HEAD~10 2>/dev/null
+```
+
+Filtrar por extensión del lenguaje detectado. Anunciar al usuario:
+
+```
+Revisión [tecnología]: [N] archivos en alcance
+Agente: [nombre-del-revisor]
+Skills: [lista de skills que cargará]
+```
+
+## Paso 2 — Tabla de delegación
+
+| Argumento    | Agente                     | Skills principales                                              |
+|--------------|---------------------------|-----------------------------------------------------------------|
+| `python`     | `revisor-codigo-swl`      | `patrones-python`, `fastapi-experto`, `testing-python`          |
+| `java`       | `revisor-java-swl`        | `java-experto`, `java-testing`, `java-patrones`                 |
+| `go`         | `revisor-go-swl`          | `go-experto`, `go-testing`, `go-patrones`                       |
+| `rust`       | `revisor-rust-swl`        | `rust-experto`, `rust-testing`, `rust-patrones`                 |
+| `csharp`     | `revisor-csharp-swl`      | `csharp-experto`, `csharp-testing`, `csharp-patrones`           |
+| `kotlin`     | `revisor-kotlin-swl`      | `kotlin-experto`, `kotlin-testing`, `kotlin-compose`            |
+| `swift`      | `revisor-swift-swl`       | `swift-experto`, `swift-testing`, `swift-patrones`              |
+| `php`        | `revisor-php-swl`         | `php-experto`, `php-testing`, `php-patrones`                    |
+| `nextjs`     | `revisor-nextjs-swl`      | `nextjs-experto`, `nextjs-testing`, `nextjs-patrones`           |
+| `react`      | `revisor-react-swl`       | `react-experto`, `react-optimizacion`, `typescript-avanzado`    |
+| `angular`    | `revisor-angular-swl`     | `angular-moderno`, `angular-avanzado`, `typescript-avanzado`    |
+| `typescript` | `revisor-typescript-swl`  | `typescript-avanzado`, `node-experto`                           |
+| `sql`        | `revisor-codigo-swl`      | `postgresql-experto`, `sql-optimizacion`                        |
+| `seguridad`  | `revisor-seguridad-swl`   | `checklist-seguridad`, `auth-patrones`, `iam-secretos`          |
+
+## Paso 3a — Revisión de un solo stack
+
+Construir la instrucción al agente y delegarla con `Agent()`:
+
+```
+Revisa el código [tecnología] del proyecto.
+
+Archivos a revisar:
+[lista de archivos filtrados por extension]
+
+Carga antes de empezar:
+[skills segun tabla del Paso 2]
+
+Aplica revision en dos capas:
+
+CAPA 1 — Correctitud y spec compliance:
+- La implementación cumple los requisitos visibles (PLAN.md, criterios de aceptación)
+- No hay scope creep ni código muerto
+- Los casos borde están manejados
+
+CAPA 2 — Calidad idiomática del lenguaje [tecnología]:
+- Patrones idiomáticos del lenguaje (no anti-patrones)
+- Error handling correcto y explícito
+- Sin código de debug (console.log, print, breakpoints)
+- Cobertura de tests básica
+- Performance obvios: N+1, loops anidados O(n²), carga innecesaria en memoria
+- Seguridad básica: inputs validados, sin secrets hardcodeados, sin SQL crudo
+
+Reporta cada hallazgo con:
+- Archivo y línea exacta
+- Severidad: CRITICO | IMPORTANTE | MENOR
+- Descripción clara del problema
+- Corrección recomendada con fragmento de código cuando aplique
+
+Al final, produce un veredicto: APROBADO | CON OBSERVACIONES | RECHAZADO
+```
+
+## Paso 3b — Revisión de múltiples stacks (auto-detect)
+
+Si el proyecto tiene varios lenguajes, lanzar los revisores en paralelo en un mismo mensaje:
+
+```
+Agent("revisor-python",     description="Revisar archivos Python del proyecto")
+Agent("revisor-frontend",   description="Revisar archivos TypeScript/React/Angular del proyecto")
+Agent("revisor-sql",        description="Revisar queries SQL y migraciones del proyecto")
+```
+
+Consolidar los reportes de todos los agentes en un solo reporte final al usuario.
+
+## Paso 4 — Verificaciones automáticas por tecnología
+
+Ejecutar ANTES de la revisión manual del agente. Los resultados se incluyen en el reporte.
+
+### Python
+```bash
+ruff check . --output-format=concise 2>/dev/null
+mypy . --ignore-missing-imports --no-error-summary 2>/dev/null
+pytest --tb=short -q 2>/dev/null
+```
+
+### Go
+```bash
+go vet ./... 2>/dev/null
+go test -race ./... 2>/dev/null
+```
+
+### Rust
+```bash
+cargo clippy -- -D warnings 2>/dev/null
+cargo test 2>/dev/null
+```
+
+### C#
+```bash
+dotnet build -warnaserror 2>/dev/null
+dotnet test 2>/dev/null
+```
+
+### TypeScript / React / Angular / Next.js
+```bash
+npx tsc --noEmit 2>/dev/null
+npx eslint src/ --format=compact 2>/dev/null
+npm test -- --watchAll=false --passWithNoTests 2>/dev/null
+```
+
+### PHP
+```bash
+vendor/bin/phpstan analyse 2>/dev/null
+php artisan test 2>/dev/null
+```
+
+### Kotlin
+```bash
+./gradlew detekt 2>/dev/null
+./gradlew test 2>/dev/null
+```
+
+### Swift
+```bash
+swift build 2>/dev/null
+swift test 2>/dev/null
+```
+
+### SQL / PostgreSQL
+```bash
+# Buscar queries dentro de loops (potencial N+1)
+grep -rn "execute\|query\|SELECT" --include="*.py" --include="*.ts" . 2>/dev/null | head -40
+# Buscar SQL crudo sin parametrizar
+grep -rn 'f"SELECT\|f"INSERT\|f"UPDATE\|"SELECT.*+\|"INSERT.*+' . 2>/dev/null
+```
+
+### Seguridad (todos los lenguajes)
+```bash
+# Secrets potenciales
+git grep -i "password\|secret\|api_key\|token\s*=" -- "*.py" "*.ts" "*.js" "*.go" 2>/dev/null | grep -v "test\|spec\|\.example" | head -20
+# Funciones peligrosas
+grep -rn "eval(\|exec(\|shell=True\|pickle.loads\|yaml.load(" . 2>/dev/null | grep -v "test\|spec" | head -20
+```
+
+## Paso 5 — Reporte consolidado
+
+Produce el reporte directamente en la conversación con este formato:
+
+```markdown
+# Revisión de Código — [tecnología]
+
+**Proyecto**: [nombre del directorio raíz]
+**Fecha**: [fecha actual]
+**Archivos revisados**: [N]
+
+## Resumen
+
+| Severidad  | Cantidad |
+|------------|----------|
+| Crítico    | N        |
+| Importante | N        |
+| Menor      | N        |
+
+## Verificaciones automáticas
+
+| Verificación | Resultado              |
+|--------------|------------------------|
+| Linter       | PASA / N errores       |
+| Type check   | PASA / N errores       |
+| Tests        | N pasan, N fallan      |
+| Build        | PASA / FALLA           |
+
+## Hallazgos
+
+### Crítico
+
+1. **[archivo:línea]** — [descripción]
+   ```[lang]
+   // código problemático
+   ```
+   **Corrección:**
+   ```[lang]
+   // código corregido
+   ```
+
+### Importante
+
+[idem]
+
+### Menor
+
+[idem]
+
+## Veredicto
+
+**[APROBADO | CON OBSERVACIONES | RECHAZADO]**
+
+[Una línea explicando el veredicto]
+```
+
+## Paso 6 — Revisión multi-agente en paralelo (modo profundo)
+
+Cuando el usuario dice `/swl:revisar profundo`, `/swl:revisar --profundo` o
+"revisión completa con todos los agentes":
+
+Lanzar **en paralelo** hasta 5 revisores especializados (además del revisor de stack):
+
+```
+Agent("revisor-seguridad-swl", "Auditar seguridad OWASP de archivos cambiados")
+Agent("revisor-codigo-swl",    "Auditar errores silenciosos: catch vacíos, except:pass, error checks sin log")
+Agent("tdd-qa-swl",            "Evaluar cobertura de tests: gaps críticos, tests faltantes para código nuevo")
+Agent("documentador-swl",      "Verificar documentación afectada por los cambios: README, CHANGELOG, docstrings")
+Agent("rendimiento-swl",       "Detectar N+1, loops O(n²), carga innecesaria en memoria en archivos cambiados")
+```
+
+Cada agente recibe:
+- Lista de archivos en alcance (del Paso 1)
+- Instrucción de reportar SOLO hallazgos con confianza >= 80%
+- Formato de salida: severidad + archivo:línea + descripción + corrección
+
+Consolidar todos los reportes en un solo reporte con secciones por agente:
+
+```markdown
+## Revisión multi-agente — [N] agentes, [M] hallazgos
+
+### Seguridad (revisor-seguridad-swl)
+[hallazgos o "Sin hallazgos"]
+
+### Errores silenciosos (revisor-codigo-swl)
+[hallazgos o "Sin hallazgos"]
+
+### Cobertura de tests (tdd-qa-swl)
+[hallazgos o "Sin hallazgos"]
+
+### Documentación afectada (documentador-swl)
+[hallazgos o "Sin hallazgos"]
+
+### Rendimiento (rendimiento-swl)
+[hallazgos o "Sin hallazgos"]
+```
+
+## Reglas de comportamiento
+
+- NUNCA corregir código directamente — solo identificar y recomendar.
+- SIEMPRE ejecutar las verificaciones automáticas del Paso 4 antes de delegar al agente.
+- Si los tests fallan es CRITICO sin excepción, independientemente del lenguaje.
+- Para SQL: buscar siempre N+1 queries y SQL crudo sin parametrizar.
+- Para seguridad: aplicar `Skill("checklist-seguridad")` y verificar OWASP Top 10.
+- Si el argumento es un archivo que no existe, informar y terminar.
+- El reporte se emite siempre en la conversación. No crear archivo a menos que el usuario lo pida.
+- En modo profundo: lanzar los 5 agentes en paralelo para máxima eficiencia.

package/comandos/swl/salud.md

@@ -0,0 +1,363 @@
+---
+name: swl:salud
+description: Diagnóstico completo de salud del sistema SWL. Verifica integridad de agentes, skills, comandos, reglas y hooks. Genera un reporte con score por componente y detecta agentes sin versión, skills huérfanos, comandos rotos y reglas contradictorias.
+allowed_tools: ["Read", "Write", "Bash", "Glob", "Grep"]
+---
+
+# /swl:salud — Diagnóstico de salud del sistema SWL
+
+Inspector de salud del sistema SWL. Verifica integridad de todos los componentes
+usando **verificaciones deterministas** (conteos, existencia de campos, sintaxis).
+Genera SALUD.md con score objetivo y reproducible.
+
+**Carga**: `Skill("validacion-ci-sistema")` — contiene las reglas de validación por componente (agentes, skills, hooks, comandos, reglas), tabla de exit codes para hooks y checklist de integridad. Delega toda lógica de verificación al skill.
+
+Este comando es de **solo lectura**. No modifica archivos — solo genera SALUD.md. Para corregir problemas, usar `swl:evolucionar`.
+
+## Cuándo usar
+
+- Antes de iniciar proyecto nuevo con SWL
+- Después de agregar o modificar agentes/skills manualmente
+- Cuando un agente produce outputs inesperados
+- Después de merge o pull de cambios al repositorio
+- Periódicamente como mantenimiento (mensual)
+
+## Paso 0 — Inventario con Bash (determinista)
+
+```bash
+echo "=== INVENTARIO ===" && \
+echo "Agentes: $(ls agentes/*.md 2>/dev/null | wc -l)" && \
+echo "Skills: $(ls -d habilidades/*/ 2>/dev/null | wc -l)" && \
+echo "Comandos: $(ls comandos/swl/*.md 2>/dev/null | wc -l)" && \
+echo "Reglas: $(ls reglas/*.md 2>/dev/null | wc -l)" && \
+echo "Hooks: $(ls hooks/*.js 2>/dev/null | wc -l)"
+```
+
+## Paso 1 — Diagnóstico de agentes (determinista)
+
+Ejecutar script Bash que verifica cada agente mecánicamente:
+
+```bash
+errors=0; warns=0; ok=0
+for f in agentes/*.md; do
+  name=$(basename "$f" .md)
+  has_name=$(head -30 "$f" | grep -c "^name:")
+  has_desc=$(head -30 "$f" | grep -c "^description:")
+  has_version=$(head -30 "$f" | grep -c "^version:")
+  has_riesgo=$(head -30 "$f" | grep -c "^nivelRiesgo:")
+  placeholders=$(grep -cE '\[TODO\]|\[COMPLETAR\]|\[TBD\]' "$f" || true)
+
+  if [ "$has_name" -eq 0 ] || [ "$has_desc" -eq 0 ]; then
+    echo "ERROR: $name — falta name o description"
+    errors=$((errors+1))
+  elif [ "$has_version" -eq 0 ] || [ "$has_riesgo" -eq 0 ]; then
+    echo "ADVERTENCIA: $name — falta version o nivelRiesgo"
+    warns=$((warns+1))
+  elif [ "$placeholders" -gt 0 ]; then
+    echo "ADVERTENCIA: $name — placeholders sin reemplazar"
+    warns=$((warns+1))
+  else
+    ok=$((ok+1))
+  fi
+done
+echo "Agentes: $ok OK, $warns advertencias, $errors errores"
+```
+
+Score de agentes = `(ok / total) * 100`
+
+## Paso 2 — Diagnóstico de skills (determinista)
+
+```bash
+errors=0; warns=0; ok=0
+for d in habilidades/*/; do
+  name=$(basename "$d")
+  skill="$d/SKILL.md"
+  if [ ! -f "$skill" ]; then
+    echo "ERROR: $name — sin SKILL.md"
+    errors=$((errors+1)); continue
+  fi
+  lines=$(wc -l < "$skill")
+  has_name=$(head -10 "$skill" | grep -c "^name:")
+  has_desc=$(head -10 "$skill" | grep -c "^description:")
+  content_chars=$(sed -n '/^---$/,/^---$/d; p' "$skill" | wc -c)
+  abs_paths=$(grep -cE 'C:\\|/home/|/Users/' "$skill" || true)
+
+  if [ "$has_name" -eq 0 ] || [ "$has_desc" -eq 0 ]; then
+    echo "ERROR: $name — frontmatter sin name o description"
+    errors=$((errors+1))
+  elif [ "$lines" -gt 300 ]; then
+    echo "ADVERTENCIA: $name — $lines lineas (max 300)"
+    warns=$((warns+1))
+  elif [ "$content_chars" -lt 500 ]; then
+    echo "ADVERTENCIA: $name — contenido muy corto ($content_chars chars)"
+    warns=$((warns+1))
+  elif [ "$abs_paths" -gt 0 ]; then
+    echo "ADVERTENCIA: $name — paths absolutos detectados"
+    warns=$((warns+1))
+  else
+    ok=$((ok+1))
+  fi
+done
+echo "Skills: $ok OK, $warns advertencias, $errors errores"
+```
+
+Detectar skills huérfanos (no referenciados):
+
+```bash
+grep -r "Skill(" agentes/ comandos/ 2>/dev/null | grep -o '"[^"]*"' | sort | uniq
+```
+
+Score de skills = `((total - errors*10 - warns*2) / total) * 100`, mínimo 0
+
+## Paso 3 — Diagnóstico de comandos (determinista)
+
+```bash
+errors=0; warns=0; ok=0
+for f in comandos/swl/*.md; do
+  name=$(basename "$f" .md)
+  lines=$(wc -l < "$f")
+  has_name=$(head -10 "$f" | grep -c "^name:")
+  has_desc=$(head -10 "$f" | grep -c "^description:")
+  desc_len=$(head -5 "$f" | grep "^description:" | wc -c)
+
+  if [ "$has_name" -eq 0 ] || [ "$has_desc" -eq 0 ]; then
+    echo "ERROR: $name — frontmatter sin name o description"
+    errors=$((errors+1))
+  elif [ "$desc_len" -lt 30 ]; then
+    echo "ADVERTENCIA: $name — description muy breve"
+    warns=$((warns+1))
+  elif [ "$lines" -gt 300 ]; then
+    echo "ADVERTENCIA: $name — $lines lineas (considerar delegar a skill)"
+    warns=$((warns+1))
+  else
+    ok=$((ok+1))
+  fi
+done
+echo "Comandos: $ok OK, $warns advertencias, $errors errores"
+```
+
+## Paso 4 — Diagnóstico de reglas (determinista)
+
+```bash
+errors=0; warns=0; ok=0
+for f in reglas/*.md; do
+  name=$(basename "$f" .md)
+  lines=$(wc -l < "$f")
+  has_h1=$(grep -c "^# " "$f" || true)
+  has_checklist=$(grep -c "\- \[ \]" "$f" || true)
+
+  if [ "$lines" -lt 20 ]; then
+    echo "ERROR: $name — regla muy corta ($lines lineas)"
+    errors=$((errors+1))
+  elif [ "$has_h1" -eq 0 ]; then
+    echo "ADVERTENCIA: $name — sin titulo H1"
+    warns=$((warns+1))
+  elif [ "$has_checklist" -eq 0 ]; then
+    echo "ADVERTENCIA: $name — sin checklist"
+    warns=$((warns+1))
+  else
+    ok=$((ok+1))
+  fi
+done
+echo "Reglas: $ok OK, $warns advertencias, $errors errores"
+```
+
+## Paso 5 — Diagnóstico de hooks (determinista)
+
+```bash
+errors=0; warns=0; ok=0
+for f in hooks/*.js; do
+  name=$(basename "$f")
+  if node --check "$f" 2>/dev/null; then
+    if grep -q "$name" .claude/settings.json 2>/dev/null; then
+      ok=$((ok+1))
+    else
+      echo "ADVERTENCIA: $name — no registrado en settings.json"
+      warns=$((warns+1))
+    fi
+  else
+    echo "ERROR: $name — error de sintaxis Node.js"
+    errors=$((errors+1))
+  fi
+done
+echo "Hooks: $ok OK, $warns advertencias, $errors errores"
+```
+
+## Paso 5b — Auditoría opcional de skills (opt-in)
+
+Si la variable de entorno `SWL_AUDIT_SKILLS=1` está presente, ejecutar:
+
+```bash
+bash scripts/audit-skills.sh
+```
+
+Este paso es **no bloqueante**: si el comando falla por cualquier causa (red,
+dependencia faltante, paquete no publicado), el diagnóstico continúa normalmente.
+
+**Qué detecta**:
+- Prompt injection en contenido de SKILL.md (instrucciones que intentan manipular el modelo).
+- Secretos hardcodeados (API keys, tokens, contraseñas en ejemplos).
+- URLs sospechosas embebidas en los skills.
+- Estructura inválida de SKILL.md (frontmatter incompleto, ausencia de secciones requeridas).
+
+**Requisito**: `pip install uv` (o `pipx install uv`) antes de activar.
+
+**Activación manual**:
+```bash
+SWL_AUDIT_SKILLS=1 bash scripts/audit-skills.sh
+```
+
+Si `SWL_AUDIT_SKILLS` no está definida, el script imprime instrucciones y sale
+con código 0 — no afecta el score ni el diagnóstico general.
+
+## Paso 6 — Score global ponderado
+
+```
+Score = agentes x 0.30 + skills x 0.25 + comandos x 0.20 + reglas x 0.15 + hooks x 0.10
+
+90-100: Excelente
+75-89:  Saludable con mejoras menores
+60-74:  Funcional con problemas
+<60:    Estado crítico
+```
+
+## Paso 5c — Reporte de cobertura de frameworks de seguridad (opt-in)
+
+Si la variable de entorno `SWL_AUDIT_FRAMEWORKS=1` está presente, ejecutar el
+auditor de cobertura:
+
+```bash
+node scripts/auditar-cobertura-frameworks.js --resumen
+```
+
+Propósito: reportar cuántos skills declaran mapeos a los 5 frameworks de
+seguridad (NIST CSF 2.0, NIST AI RMF 1.0, MITRE ATLAS v5.4, ATT&CK v18,
+D3FEND v1.3) y qué controles están cubiertos. Útil para:
+
+- Verificar que los skills de dominio seguridad declaran mapeos antes de un
+  audit de compliance
+- Detectar gaps en la cobertura (ej: ningún skill cubre `PR.DS-11` — data
+  integrity — si eso importa para el proyecto)
+- Producir evidencia para auditores (SOC 2, ISO 27001) sobre controles
+  implementados
+
+El reporte NO marca skills sin mapeos como error — solo skills de dominio
+seguridad necesitan declararlos. Ver `reglas/skills-estandar.md` sección
+"Mapeo a frameworks de seguridad (REC-C01)" para criterios de cuándo declarar
+cada framework.
+
+**Filtrado por framework**:
+
+```bash
+SWL_AUDIT_FRAMEWORKS=1 node scripts/auditar-cobertura-frameworks.js --framework=nist_ai_rmf --resumen
+```
+
+**Persistir snapshot**:
+
+```bash
+node scripts/auditar-cobertura-frameworks.js --save
+```
+
+Persiste en `.planning/evolucion/cobertura-frameworks.json` para comparación
+histórica tras incorporar nuevos skills de seguridad.
+
+Si `SWL_AUDIT_FRAMEWORKS` no está definida, este paso se omite sin mensaje
+— los reportes son opt-in por diseño (CLAUDE.md: "Variables de entorno
+opt-in para integraciones enterprise").
+
+## Paso 5d — Auditoría SAP-Agents (opt-in)
+
+Si la variable de entorno `SWL_AUDIT_AGENTES=1` está presente, ejecutar el
+auditor de agentes:
+
+```bash
+node scripts/auditar-agentes-gaps.js --resumen
+```
+
+Propósito: reportar cuántos agentes carecen de Exclusion Clause (campo
+`exclusiones` o sección `## Cuándo NO invocarme`) y Gotchas explícitos.
+Previene agent hijacking por activación tangencial de agentes por similitud
+superficial en `description`.
+
+El reporte incluye conteo de excepciones documentadas por ADR (si las hay)
+para separar gaps reales de excepciones por diseño.
+
+Si `SWL_AUDIT_AGENTES` no está definida, este paso se omite — los reportes
+son opt-in por diseño (CLAUDE.md: "Variables de entorno opt-in para
+integraciones enterprise").
+
+## Paso 6b — Formato de salida enriquecido (HealthRow)
+
+El módulo `scripts/lib/health-row.js` genera filas de salud con formato visual enriquecido
+para la salida de terminal. Cada fila sigue el patrón:
+
+```
+Label              valor/max |████████████████████| indicador
+```
+
+Ejemplo visual (modo con color ANSI):
+
+```
+Agentes              59/59 |████████████████████| ✓ ok
+Skills               52/55 |███████████████████░| ✓ ok
+Comandos             37/38 |███████████████████░| ✓ ok
+Reglas               18/18 |████████████████████| ✓ ok
+Hooks                22/25 |█████████████████░░░| ⚠ warn
+Score Global         88/100 |█████████████████░░░| ✓ ok
+```
+
+### Umbrales automáticos
+
+| Rango de porcentaje | Estado | Color ANSI  |
+|---------------------|--------|-------------|
+| >= 80%              | good   | Verde `\x1b[32m` |
+| >= 50% y < 80%      | warn   | Amarillo `\x1b[33m` |
+| < 50%               | bad    | Rojo `\x1b[31m` |
+
+Respetar `NO_COLOR` (https://no-color.org) y la variable `SWL_ASCII_SIMPLE=1`
+para entornos sin soporte Unicode.
+
+### Uso para generar el bloque de salud
+
+```javascript
+const { formatearBloqueHealth } = require('./scripts/lib/health-row');
+
+const filas = [
+  { label: 'Agentes',      valor: 59,  maximo: 59  },
+  { label: 'Skills',       valor: 52,  maximo: 55  },
+  { label: 'Comandos',     valor: 37,  maximo: 38  },
+  { label: 'Reglas',       valor: 18,  maximo: 18  },
+  { label: 'Hooks',        valor: 22,  maximo: 25  },
+  { label: 'Score Global', valor: 88,  maximo: 100 },
+];
+
+console.log(formatearBloqueHealth(filas));
+```
+
+Para override de estado (forzar bad aunque el valor sea alto):
+
+```javascript
+const { formatearHealthRow } = require('./scripts/lib/health-row');
+const fila = formatearHealthRow({ label: 'Seguridad', valor: 100, maximo: 100, estado: 'bad' });
+```
+
+La integración real del formato en la ejecución del comando se implementará en el
+código de salida de `/swl:salud`. Este paso solo define la API disponible y la muestra visual.
+
+## Paso 7 — Generar SALUD.md
+
+Escribe el reporte con tabla resumen, errores, advertencias y recomendaciones. Usa los datos exactos de los scripts. Si el script dice 73%, reportar 73%.
+
+## Paso 8 — Resumen en terminal
+
+Presenta resumen con los problemas más críticos. Si hay errores, listarlos todos. Si solo advertencias, listar las top 5.
+
+## Reglas de comportamiento
+
+- SOLO LECTURA. NUNCA modifica archivos excepto SALUD.md.
+- Las verificaciones de Pasos 1-5 son scripts Bash deterministas. NO usar juicio subjetivo.
+- Los scripts miden: existencia de campos, conteo de líneas, sintaxis. NO miden calidad de redacción.
+- Si un check requiere juicio (contradicciones entre reglas), documentar como "requiere revisión manual".
+- Los scores son aritmética pura. No ajustar el score "porque parece un sistema sano".
+- Si no hay git, omitir verificaciones dependientes y notar la omisión.
+- Si detectas un patrón sistémico (mismo error en múltiples componentes), mencionarlo en recomendaciones.