@saulwade/swl-ses 1.0.0

package/habilidades/validacion-ci-sistema/recursos/validadores-completos.md

@@ -0,0 +1,369 @@
+# Validación CI Sistema — Validadores y Scripts Completos
+
+Código fuente completo de los validadores y el script ejecutable.
+
+---
+
+## Validador de Agentes
+
+```javascript
+// validation/validators/agente.validator.js
+import { parse } from 'yaml';
+import { readFileSync } from 'fs';
+
+const CAMPOS_AGENTE = {
+  obligatorios: ['name', 'description'],
+  opcionales: {
+    model:          ['claude-opus-4-5', 'claude-sonnet-4-6', 'claude-haiku-3-5'],
+    permissionMode: ['default', 'acceptEdits', 'bypassPermissions', 'plan'],
+    color:          ['red', 'orange', 'yellow', 'green', 'blue', 'purple', 'cyan', 'white'],
+  },
+  condicionales: {
+    tools: {
+      valoresPermitidos: [
+        'Read', 'Write', 'Edit', 'Bash', 'Grep', 'Glob',
+        'WebSearch', 'WebFetch', 'TodoRead', 'TodoWrite',
+        'Task', 'Skill', 'mcp__context7__resolve-library-id',
+        'mcp__context7__get-library-docs',
+      ],
+    },
+  },
+};
+
+export function validarAgente(rutaArchivo) {
+  const contenido = readFileSync(rutaArchivo, 'utf8');
+  const errores = [];
+
+  const match = contenido.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) {
+    return [{ campo: 'frontmatter', error: 'No se encontró frontmatter YAML' }];
+  }
+
+  let frontmatter;
+  try {
+    frontmatter = parse(match[1]);
+  } catch (e) {
+    return [{ campo: 'frontmatter', error: `YAML inválido: ${e.message}` }];
+  }
+
+  for (const campo of CAMPOS_AGENTE.obligatorios) {
+    if (!frontmatter[campo] || String(frontmatter[campo]).trim() === '') {
+      errores.push({ campo, error: `Campo obligatorio ausente o vacío: '${campo}'` });
+    }
+  }
+
+  if (frontmatter.description && frontmatter.description.length < 20) {
+    errores.push({
+      campo: 'description',
+      error: `Description demasiado corta (${frontmatter.description.length} chars, mínimo 20)`,
+    });
+  }
+
+  for (const [campo, valoresPermitidos] of Object.entries(CAMPOS_AGENTE.opcionales)) {
+    if (frontmatter[campo] !== undefined) {
+      if (!valoresPermitidos.includes(frontmatter[campo])) {
+        errores.push({
+          campo,
+          error: `Valor inválido '${frontmatter[campo]}'. Permitidos: ${valoresPermitidos.join(', ')}`,
+        });
+      }
+    }
+  }
+
+  if (frontmatter.tools) {
+    const toolsArray = String(frontmatter.tools).split(',').map(t => t.trim());
+    for (const tool of toolsArray) {
+      if (!CAMPOS_AGENTE.condicionales.tools.valoresPermitidos.includes(tool)) {
+        errores.push({ campo: 'tools', error: `Tool desconocida: '${tool}'` });
+      }
+    }
+  }
+
+  const nombreEsperado = path.basename(rutaArchivo, '.md');
+  if (frontmatter.name && frontmatter.name !== nombreEsperado) {
+    errores.push({
+      campo: 'name',
+      error: `name '${frontmatter.name}' no coincide con nombre de archivo '${nombreEsperado}'`,
+    });
+  }
+
+  return errores;
+}
+```
+
+---
+
+## Validador de Skills
+
+```javascript
+// validation/validators/skill.validator.js
+import { statSync, readFileSync } from 'fs';
+import path from 'path';
+
+export function validarSkill(directorioSkill) {
+  const errores = [];
+  const rutaSkill = path.join(directorioSkill, 'SKILL.md');
+
+  try { statSync(rutaSkill); } catch {
+    errores.push({ skill: path.basename(directorioSkill), error: 'SKILL.md no encontrado' });
+    return errores;
+  }
+
+  const contenido = readFileSync(rutaSkill, 'utf8');
+
+  if (contenido.trim().length === 0) {
+    errores.push({ skill: path.basename(directorioSkill), error: 'SKILL.md está vacío' });
+    return errores;
+  }
+
+  const match = contenido.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) {
+    errores.push({ skill: path.basename(directorioSkill), error: 'Sin frontmatter YAML' });
+    return errores;
+  }
+
+  let frontmatter;
+  try { frontmatter = parse(match[1]); } catch (e) {
+    errores.push({ skill: path.basename(directorioSkill), error: `Frontmatter inválido: ${e.message}` });
+    return errores;
+  }
+
+  if (!frontmatter.name) errores.push({ skill: path.basename(directorioSkill), error: "Falta 'name'" });
+  if (!frontmatter.description) errores.push({ skill: path.basename(directorioSkill), error: "Falta 'description'" });
+
+  const lineas = contenido.split('\n').length;
+  if (lineas < 50) {
+    errores.push({ skill: path.basename(directorioSkill), error: `Muy corto (${lineas} líneas)`, severidad: 'advertencia' });
+  }
+
+  return errores;
+}
+```
+
+---
+
+## Validador de Hooks
+
+```javascript
+// validation/validators/hook.validator.js
+import { execSync } from 'child_process';
+
+export function validarHook(rutaHook) {
+  const errores = [];
+  const contenido = readFileSync(rutaHook, 'utf8');
+
+  try {
+    execSync(`node --check "${rutaHook}"`, { stdio: 'pipe' });
+  } catch (e) {
+    errores.push({ hook: path.basename(rutaHook), error: `Sintaxis inválida: ${e.stderr?.toString().split('\n')[0]}` });
+    return errores;
+  }
+
+  if (!contenido.includes('process.exit(')) {
+    errores.push({ hook: path.basename(rutaHook), error: 'No tiene process.exit() explícito' });
+  }
+
+  const esObservacion = rutaHook.includes('observe');
+  if (esObservacion && contenido.includes('process.exit(1)')) {
+    errores.push({ hook: path.basename(rutaHook), error: 'Hook de observación no debe usar exit(1)' });
+  }
+
+  const esToolHook = rutaHook.match(/pre-|post-|observe/i);
+  if (esToolHook && !contenido.includes('stdin') && !contenido.includes('readFileSync')) {
+    errores.push({ hook: path.basename(rutaHook), error: 'No lee stdin', severidad: 'advertencia' });
+  }
+
+  if (contenido.includes('execSync') && !contenido.includes('timeout')) {
+    errores.push({ hook: path.basename(rutaHook), error: 'execSync sin timeout', severidad: 'advertencia' });
+  }
+
+  return errores;
+}
+```
+
+---
+
+## Validador de Comandos
+
+```javascript
+// validation/validators/comando.validator.js
+export function validarComando(directorioComando) {
+  const errores = [];
+  const nombreComando = path.basename(directorioComando);
+
+  const archivosPermitidos = ['command.md', `${nombreComando}.md`, 'index.md'];
+  const archivosEncontrados = archivosPermitidos.filter(f =>
+    existsSync(path.join(directorioComando, f))
+  );
+
+  if (archivosEncontrados.length === 0) {
+    errores.push({ comando: nombreComando, error: `Sin archivo de comando. Esperado: ${archivosPermitidos.join(' o ')}` });
+    return errores;
+  }
+
+  const rutaArchivo = path.join(directorioComando, archivosEncontrados[0]);
+  const contenido = readFileSync(rutaArchivo, 'utf8');
+
+  if (!/^[a-z][a-z0-9-]*[a-z0-9]$/.test(nombreComando)) {
+    errores.push({ comando: nombreComando, error: `No está en kebab-case` });
+  }
+
+  if (contenido.startsWith('---')) {
+    const match = contenido.match(/^---\n([\s\S]*?)\n---/);
+    if (!match) errores.push({ comando: nombreComando, error: 'Frontmatter sin cerrar' });
+  }
+
+  const sinFrontmatter = contenido.replace(/^---[\s\S]*?---\n/, '').trim();
+  if (sinFrontmatter.length < 10) {
+    errores.push({ comando: nombreComando, error: 'Sin contenido de instrucciones' });
+  }
+
+  return errores;
+}
+```
+
+---
+
+## Validador de Reglas
+
+```javascript
+export function validarReglas(directorioReglas) {
+  const errores = [];
+  const archivos = globSync('**/*.md', { cwd: directorioReglas, absolute: true });
+
+  for (const ruta of archivos) {
+    const contenido = readFileSync(ruta, 'utf8').trim();
+    if (contenido.length < 20) {
+      errores.push({ regla: path.relative(directorioReglas, ruta), error: 'Vacía o muy corta' });
+    }
+  }
+
+  const contenidos = archivos.map(f => ({
+    nombre: path.basename(f, '.md'),
+    texto: readFileSync(f, 'utf8').toLowerCase(),
+  }));
+
+  for (let i = 0; i < contenidos.length; i++) {
+    for (let j = i + 1; j < contenidos.length; j++) {
+      const a = contenidos[i], b = contenidos[j];
+      const siempresA = extraerTerminosSiempre(a.texto);
+      const nuncasB = extraerTerminosNunca(b.texto);
+      const conflictos = siempresA.filter(t => nuncasB.includes(t));
+      if (conflictos.length > 0) {
+        errores.push({
+          regla: `${a.nombre} <-> ${b.nombre}`,
+          error: `Posible contradicción: SIEMPRE vs NUNCA ${conflictos[0]}`,
+          severidad: 'advertencia',
+        });
+      }
+    }
+  }
+  return errores;
+}
+```
+
+---
+
+## Catálogo Automático
+
+```javascript
+export async function generarCatalogo(raizSistema) {
+  const ahora = new Date().toISOString();
+  const agentes  = globSync('agentes/**/*.md', { cwd: raizSistema });
+  const skills   = globSync('habilidades/*/SKILL.md', { cwd: raizSistema });
+  const hooks    = globSync('hooks/**/*.js', { cwd: raizSistema });
+  const comandos = globSync('comandos/*/', { cwd: raizSistema });
+  const reglas   = globSync('reglas/**/*.md', { cwd: raizSistema });
+
+  return {
+    generado_en: ahora,
+    totales: { agentes: agentes.length, skills: skills.length, hooks: hooks.length, comandos: comandos.length, reglas: reglas.length },
+    agentes: agentes.map(a => ({ nombre: path.basename(a, '.md'), ruta: a, tamano_bytes: statSync(path.join(raizSistema, a)).size })),
+    skills: skills.map(s => ({ nombre: path.basename(path.dirname(s)), ruta: s, lineas: readFileSync(path.join(raizSistema, s), 'utf8').split('\n').length })),
+  };
+}
+```
+
+---
+
+## Script de Validación Ejecutable
+
+```javascript
+#!/usr/bin/env node
+// scripts/validar-sistema.js
+// Uso: node scripts/validar-sistema.js [--fix] [--catalog]
+
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { globSync } from 'glob';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const RAIZ = path.resolve(__dirname, '..');
+
+const args = process.argv.slice(2);
+const MODO_FIX     = args.includes('--fix');
+const GENERAR_CAT  = args.includes('--catalog');
+
+let totalErrores = 0;
+let totalAdvert  = 0;
+
+function reporte(tipo, items, validador) {
+  console.log(`\n${'='.repeat(50)}`);
+  console.log(`Validando ${tipo} (${items.length})...`);
+
+  for (const item of items) {
+    const errores = validador(item);
+    const criticos = errores.filter(e => e.severidad !== 'advertencia');
+    const advert   = errores.filter(e => e.severidad === 'advertencia');
+
+    if (criticos.length > 0) {
+      console.error(`  FAIL ${path.basename(item)}`);
+      criticos.forEach(e => console.error(`       ERROR: ${e.error}`));
+      totalErrores += criticos.length;
+    }
+    if (advert.length > 0) {
+      console.warn(`  WARN ${path.basename(item)}`);
+      advert.forEach(e => console.warn(`       WARN: ${e.error}`));
+      totalAdvert += advert.length;
+    }
+    if (criticos.length === 0 && advert.length === 0) {
+      console.log(`  OK   ${path.basename(item)}`);
+    }
+  }
+}
+
+reporte('Agentes',   globSync('agentes/**/*.md', { cwd: RAIZ, absolute: true }), validarAgente);
+reporte('Skills',    globSync('habilidades/*', { cwd: RAIZ, absolute: true }),   validarSkill);
+reporte('Hooks',     globSync('hooks/**/*.js', { cwd: RAIZ, absolute: true }),   validarHook);
+reporte('Comandos',  globSync('comandos/*', { cwd: RAIZ, absolute: true }),      validarComando);
+
+console.log(`\n${'='.repeat(50)}`);
+console.log(`RESUMEN: ${totalErrores} errores, ${totalAdvert} advertencias`);
+
+if (GENERAR_CAT) {
+  const catalogo = await generarCatalogo(RAIZ);
+  writeFileSync(path.join(RAIZ, '.claude', 'catalogo.json'), JSON.stringify(catalogo, null, 2));
+  console.log('Catálogo generado en .claude/catalogo.json');
+}
+
+process.exit(totalErrores > 0 ? 1 : 0);
+```
+
+### Uso en CI (GitHub Actions)
+
+```yaml
+name: Validar integridad del sistema SWL
+on:
+  push:
+    branches: [main]
+  pull_request:
+jobs:
+  validate:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with: { node-version: '20' }
+      - run: npm ci
+      - run: npm run validate:catalog
+```

package/habilidades/validacion-ci-sistema/scripts/validar-sistema.sh

@@ -0,0 +1,286 @@
+#!/usr/bin/env bash
+# Validador de integridad del sistema swl-software-engineering-system
+# Ejecutar desde la raíz del repositorio:
+#   bash habilidades/validacion-ci-sistema/scripts/validar-sistema.sh
+#
+# Opciones:
+#   --solo-errores   Suprime las líneas OK, muestra solo fallos y advertencias
+#   --no-color       Desactiva colores (útil en CI sin TTY)
+#
+# Exit code: 0 si todo pasa, 1 si hay fallos críticos
+
+set -euo pipefail
+
+# ─── Colores ───────────────────────────────────────────────────────────────────
+if [[ "${NO_COLOR:-}" == "1" ]] || [[ " $* " == *" --no-color "* ]]; then
+  C_OK=""  C_FAIL=""  C_WARN=""  C_BOLD=""  C_RESET=""
+else
+  C_OK="\033[0;32m"
+  C_FAIL="\033[0;31m"
+  C_WARN="\033[0;33m"
+  C_BOLD="\033[1m"
+  C_RESET="\033[0m"
+fi
+
+SOLO_ERRORES=0
+[[ " $* " == *" --solo-errores "* ]] && SOLO_ERRORES=1
+
+# ─── Contadores globales ────────────────────────────────────────────────────────
+TOTAL_ERRORES=0
+TOTAL_ADVERTENCIAS=0
+TOTAL_OK=0
+
+# ─── Helpers ────────────────────────────────────────────────────────────────────
+ok()   { TOTAL_OK=$((TOTAL_OK+1));          [[ $SOLO_ERRORES -eq 0 ]] && printf "  ${C_OK}OK${C_RESET}   %s\n" "$1"; }
+fail() { TOTAL_ERRORES=$((TOTAL_ERRORES+1));  printf "  ${C_FAIL}FAIL${C_RESET} %s\n        ERROR: %s\n" "$1" "$2"; }
+warn() { TOTAL_ADVERTENCIAS=$((TOTAL_ADVERTENCIAS+1)); printf "  ${C_WARN}WARN${C_RESET} %s\n        WARN: %s\n" "$1" "$2"; }
+section() { printf "\n${C_BOLD}%s${C_RESET}\n%s\n" "$1" "$(printf '═%.0s' {1..60})"; }
+
+# ─── Detectar raíz del repositorio ─────────────────────────────────────────────
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+RAIZ="$(cd "${SCRIPT_DIR}/../../.." && pwd)"
+
+if [[ ! -d "${RAIZ}/agentes" ]] || [[ ! -d "${RAIZ}/habilidades" ]]; then
+  printf "${C_FAIL}ERROR${C_RESET}: No se encontró la estructura esperada del repositorio SWL.\n"
+  printf "       Ejecuta el script desde la raíz: bash habilidades/validacion-ci-sistema/scripts/validar-sistema.sh\n"
+  exit 1
+fi
+
+printf "${C_BOLD}Validador de integridad — swl-software-engineering-system${C_RESET}\n"
+printf "Raíz detectada: %s\n" "${RAIZ}"
+printf "Fecha: %s\n" "$(date '+%Y-%m-%d %H:%M:%S')"
+
+# ══════════════════════════════════════════════════════════════════════════════
+# 1. AGENTES — Validar frontmatter con campos obligatorios
+# ══════════════════════════════════════════════════════════════════════════════
+section "1. Agentes (frontmatter)"
+
+CAMPOS_OBLIGATORIOS_AGENTE=("name" "description")
+# Campos opcionales pero que deben tener valores válidos si están presentes
+MODELOS_VALIDOS=("claude-opus-4-5" "claude-sonnet-4-6" "claude-haiku-3-5")
+PERMISOS_VALIDOS=("default" "acceptEdits" "bypassPermissions" "plan")
+COLORES_VALIDOS=("red" "orange" "yellow" "green" "blue" "purple" "cyan" "white")
+
+AGENTES_TOTAL=0
+while IFS= read -r -d '' archivo; do
+  AGENTES_TOTAL=$((AGENTES_TOTAL+1))
+  nombre="$(basename "${archivo}" .md)"
+  errores_agente=0
+
+  # Extraer frontmatter
+  if ! grep -q '^---' "${archivo}"; then
+    fail "${nombre}" "No se encontró frontmatter YAML (falta ---)"
+    continue
+  fi
+
+  frontmatter="$(awk '/^---/{found++; if(found==2) exit} found==1{print}' "${archivo}" | tail -n +1)"
+
+  # Verificar campos obligatorios
+  for campo in "${CAMPOS_OBLIGATORIOS_AGENTE[@]}"; do
+    valor="$(echo "${frontmatter}" | grep "^${campo}:" | sed 's/^[^:]*: *//' | tr -d '"'"'" | xargs)"
+    if [[ -z "${valor}" ]]; then
+      fail "${nombre}" "Campo obligatorio ausente o vacío: '${campo}'"
+      errores_agente=$((errores_agente+1))
+    fi
+  done
+
+  # Verificar description mínima (20 chars)
+  desc="$(echo "${frontmatter}" | grep "^description:" | sed 's/^description: *//')"
+  if [[ ${#desc} -lt 20 ]] && [[ -n "${desc}" ]]; then
+    warn "${nombre}" "description demasiado corta (${#desc} chars, mínimo 20)"
+  fi
+
+  # Verificar model si está presente
+  model="$(echo "${frontmatter}" | grep "^model:" | sed 's/^model: *//' | tr -d '"'"'" | xargs)"
+  if [[ -n "${model}" ]]; then
+    valido=0
+    for m in "${MODELOS_VALIDOS[@]}"; do [[ "${model}" == "${m}" ]] && valido=1 && break; done
+    if [[ $valido -eq 0 ]]; then
+      warn "${nombre}" "model '${model}' no está en la lista de modelos conocidos"
+    fi
+  fi
+
+  # Verificar permissionMode si está presente
+  pmode="$(echo "${frontmatter}" | grep "^permissionMode:" | sed 's/^permissionMode: *//' | tr -d '"'"'" | xargs)"
+  if [[ -n "${pmode}" ]]; then
+    valido=0
+    for p in "${PERMISOS_VALIDOS[@]}"; do [[ "${pmode}" == "${p}" ]] && valido=1 && break; done
+    if [[ $valido -eq 0 ]]; then
+      fail "${nombre}" "permissionMode '${pmode}' no es válido. Permitidos: ${PERMISOS_VALIDOS[*]}"
+      errores_agente=$((errores_agente+1))
+    fi
+  fi
+
+  # Verificar color si está presente
+  color="$(echo "${frontmatter}" | grep "^color:" | sed 's/^color: *//' | tr -d '"'"'" | xargs)"
+  if [[ -n "${color}" ]]; then
+    valido=0
+    for c in "${COLORES_VALIDOS[@]}"; do [[ "${color}" == "${c}" ]] && valido=1 && break; done
+    if [[ $valido -eq 0 ]]; then
+      warn "${nombre}" "color '${color}' no es un color reconocido. Conocidos: ${COLORES_VALIDOS[*]}"
+    fi
+  fi
+
+  [[ $errores_agente -eq 0 ]] && ok "${nombre}"
+done < <(find "${RAIZ}/agentes" -name "*.md" -print0 2>/dev/null)
+
+printf "  Total agentes encontrados: %d\n" "${AGENTES_TOTAL}"
+
+# ══════════════════════════════════════════════════════════════════════════════
+# 2. HABILIDADES — SKILL.md presente y no vacío
+# ══════════════════════════════════════════════════════════════════════════════
+section "2. Habilidades (SKILL.md)"
+
+SKILLS_TOTAL=0
+KEBAB_REGEX='^[a-z][a-z0-9-]*[a-z0-9]$'
+
+while IFS= read -r -d '' dir; do
+  SKILLS_TOTAL=$((SKILLS_TOTAL+1))
+  nombre="$(basename "${dir}")"
+  errores_skill=0
+
+  # Regla: nombre en kebab-case, máximo 64 chars
+  if ! echo "${nombre}" | grep -qE "${KEBAB_REGEX}"; then
+    fail "${nombre}" "Nombre no está en kebab-case: '${nombre}'"
+    errores_skill=$((errores_skill+1))
+  fi
+  if [[ ${#nombre} -gt 64 ]]; then
+    fail "${nombre}" "Nombre demasiado largo (${#nombre} chars, máximo 64)"
+    errores_skill=$((errores_skill+1))
+  fi
+
+  # Regla: SKILL.md debe existir
+  skill_md="${dir}/SKILL.md"
+  if [[ ! -f "${skill_md}" ]]; then
+    fail "${nombre}" "SKILL.md no encontrado en el directorio"
+    continue
+  fi
+
+  # Regla: SKILL.md no debe estar vacío
+  contenido="$(cat "${skill_md}" | tr -d '[:space:]')"
+  if [[ -z "${contenido}" ]]; then
+    fail "${nombre}" "SKILL.md está vacío"
+    errores_skill=$((errores_skill+1))
+    continue
+  fi
+
+  # Regla: debe tener frontmatter con name y description
+  if ! head -1 "${skill_md}" | grep -q '^---'; then
+    fail "${nombre}" "SKILL.md sin frontmatter YAML"
+    errores_skill=$((errores_skill+1))
+  else
+    frontmatter_skill="$(awk '/^---/{found++; if(found==2) exit} found==1{print}' "${skill_md}")"
+    for campo in "name" "description"; do
+      valor="$(echo "${frontmatter_skill}" | grep "^${campo}:" | sed 's/^[^:]*: *//' | tr -d '"'"'" | xargs)"
+      if [[ -z "${valor}" ]]; then
+        fail "${nombre}" "Falta campo '${campo}' en frontmatter de SKILL.md"
+        errores_skill=$((errores_skill+1))
+      fi
+    done
+
+    # Advertencia: SKILL.md muy corto
+    lineas="$(wc -l < "${skill_md}")"
+    if [[ "${lineas}" -lt 50 ]]; then
+      warn "${nombre}" "SKILL.md demasiado corto (${lineas} líneas, mínimo recomendado 50)"
+    fi
+  fi
+
+  [[ $errores_skill -eq 0 ]] && ok "${nombre}"
+done < <(find "${RAIZ}/habilidades" -mindepth 1 -maxdepth 1 -type d -print0 2>/dev/null)
+
+# También verificar skills/ si existe
+if [[ -d "${RAIZ}/skills" ]]; then
+  while IFS= read -r -d '' dir; do
+    SKILLS_TOTAL=$((SKILLS_TOTAL+1))
+    nombre="$(basename "${dir}")"
+    skill_md="${dir}/SKILL.md"
+    [[ -f "${skill_md}" ]] && ok "skills/${nombre}" || fail "skills/${nombre}" "SKILL.md no encontrado"
+  done < <(find "${RAIZ}/skills" -mindepth 1 -maxdepth 1 -type d -print0 2>/dev/null)
+fi
+
+printf "  Total habilidades encontradas: %d\n" "${SKILLS_TOTAL}"
+
+# ══════════════════════════════════════════════════════════════════════════════
+# 3. HOOKS — Sintaxis Node.js válida
+# ══════════════════════════════════════════════════════════════════════════════
+section "3. Hooks (sintaxis Node.js)"
+
+HOOKS_TOTAL=0
+
+if [[ ! -d "${RAIZ}/hooks" ]]; then
+  printf "  (directorio hooks/ no encontrado — omitiendo)\n"
+else
+  while IFS= read -r -d '' hook; do
+    HOOKS_TOTAL=$((HOOKS_TOTAL+1))
+    nombre="$(basename "${hook}")"
+    errores_hook=0
+
+    # Regla 1: Sintaxis Node.js válida
+    if ! node --check "${hook}" 2>/dev/null; then
+      error_msg="$(node --check "${hook}" 2>&1 | head -1)"
+      fail "${nombre}" "Sintaxis Node.js inválida: ${error_msg}"
+      errores_hook=$((errores_hook+1))
+    fi
+
+    # Regla 2: Debe tener process.exit()
+    if ! grep -q 'process\.exit(' "${hook}"; then
+      warn "${nombre}" "No tiene process.exit() explícito — puede quedar colgado"
+    fi
+
+    # Regla 3: Hooks de observación no deben usar exit(1)
+    if echo "${nombre}" | grep -qi 'observe' && grep -q 'process\.exit(1)' "${hook}"; then
+      fail "${nombre}" "Hook de observación usa exit(1) — bloquearía el flujo del agente"
+      errores_hook=$((errores_hook+1))
+    fi
+
+    # Regla 4: execSync sin timeout es peligroso
+    if grep -q 'execSync' "${hook}" && ! grep -q 'timeout' "${hook}"; then
+      warn "${nombre}" "execSync sin timeout — puede bloquear indefinidamente"
+    fi
+
+    [[ $errores_hook -eq 0 ]] && ok "${nombre}"
+  done < <(find "${RAIZ}/hooks" -name "*.js" -print0 2>/dev/null)
+  printf "  Total hooks encontrados: %d\n" "${HOOKS_TOTAL}"
+fi
+
+# ══════════════════════════════════════════════════════════════════════════════
+# 4. NOMBRES DE SKILLS — Estándar kebab-case, ≤64 chars
+# ══════════════════════════════════════════════════════════════════════════════
+# (ya incluido en la sección 2, pero aquí verificamos también agents/ y skills/)
+section "4. Nombres de agentes (kebab-case)"
+
+NOMBRES_TOTAL=0
+while IFS= read -r -d '' archivo; do
+  NOMBRES_TOTAL=$((NOMBRES_TOTAL+1))
+  nombre="$(basename "${archivo}" .md)"
+
+  if ! echo "${nombre}" | grep -qE "${KEBAB_REGEX}"; then
+    fail "${nombre}" "Nombre de agente no está en kebab-case: '${nombre}'"
+  elif [[ ${#nombre} -gt 64 ]]; then
+    fail "${nombre}" "Nombre de agente demasiado largo (${#nombre} chars, máximo 64)"
+  else
+    ok "${nombre}"
+  fi
+done < <(find "${RAIZ}/agentes" -name "*.md" -print0 2>/dev/null)
+printf "  Total nombres verificados: %d\n" "${NOMBRES_TOTAL}"
+
+# ══════════════════════════════════════════════════════════════════════════════
+# 5. RESUMEN FINAL
+# ══════════════════════════════════════════════════════════════════════════════
+printf "\n${C_BOLD}%s${C_RESET}\n" "$(printf '═%.0s' {1..60})"
+printf "${C_BOLD}RESUMEN DE VALIDACIÓN${C_RESET}\n"
+printf "  OK            : ${C_OK}%d${C_RESET}\n" "${TOTAL_OK}"
+printf "  Advertencias  : ${C_WARN}%d${C_RESET}\n" "${TOTAL_ADVERTENCIAS}"
+printf "  Errores       : ${C_FAIL}%d${C_RESET}\n" "${TOTAL_ERRORES}"
+
+if [[ ${TOTAL_ERRORES} -gt 0 ]]; then
+  printf "\n${C_FAIL}RESULTADO: FAIL${C_RESET} — %d error(es) crítico(s) encontrado(s)\n" "${TOTAL_ERRORES}"
+  exit 1
+else
+  printf "\n${C_OK}RESULTADO: PASS${C_RESET} — Sistema íntegro"
+  if [[ ${TOTAL_ADVERTENCIAS} -gt 0 ]]; then
+    printf " (${C_WARN}%d advertencia(s) no crítica(s)${C_RESET})" "${TOTAL_ADVERTENCIAS}"
+  fi
+  printf "\n"
+  exit 0
+fi