@saulwade/swl-ses 1.0.0

package/scripts/inferir-herramientas-permitidas.js

@@ -0,0 +1,586 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * inferir-herramientas-permitidas.js
+ *
+ * Infiere el campo `herramientasPermitidas` para cada SKILL.md en habilidades/
+ * y lo inserta en el frontmatter usando escritura atómica.
+ *
+ * Zero-deps (solo Node stdlib). Reutiliza atomic-write de hooks/lib/.
+ *
+ * Uso:
+ *   node scripts/inferir-herramientas-permitidas.js --dry-run
+ *   node scripts/inferir-herramientas-permitidas.js --dry-run --skill=fastapi-experto
+ *   node scripts/inferir-herramientas-permitidas.js --aplicar
+ *   node scripts/inferir-herramientas-permitidas.js --aplicar --solo-faltantes
+ *   node scripts/inferir-herramientas-permitidas.js --aplicar --log=.planning/evolucion/infer-herramientas.log
+ *
+ * @module scripts/inferir-herramientas-permitidas
+ */
+
+const fs   = require('fs');
+const path = require('path');
+
+// ---------------------------------------------------------------------------
+// Rutas base
+// ---------------------------------------------------------------------------
+const RAIZ       = path.resolve(__dirname, '..');
+const RAIZ_SKILLS = path.join(RAIZ, 'habilidades');
+const ATOMIC_WRITE_PATH = path.join(RAIZ, 'hooks', 'lib', 'atomic-write.js');
+
+// Cargar atomic-write (zero-deps externas, pero reutilizamos el lib interno)
+const { atomicWriteSync } = require(ATOMIC_WRITE_PATH);
+
+// ---------------------------------------------------------------------------
+// CLI — parseo de argumentos
+// ---------------------------------------------------------------------------
+const argv = process.argv.slice(2);
+const MODO_DRY_RUN  = argv.includes('--dry-run');
+const MODO_APLICAR  = argv.includes('--aplicar');
+const SOLO_FALTANTES = argv.includes('--solo-faltantes');
+
+const argSkill = argv.find(a => a.startsWith('--skill='));
+const FILTRO_SKILL = argSkill ? argSkill.replace('--skill=', '') : null;
+
+const argLog = argv.find(a => a.startsWith('--log='));
+const RUTA_LOG = argLog ? path.resolve(RAIZ, argLog.replace('--log=', '')) : null;
+
+if (!MODO_DRY_RUN && !MODO_APLICAR) {
+  process.stderr.write('Uso: node inferir-herramientas-permitidas.js --dry-run | --aplicar [--solo-faltantes] [--skill=nombre] [--log=ruta]\n');
+  process.exit(1);
+}
+
+// ---------------------------------------------------------------------------
+// Catálogo de skills especiales (reglas de decisión 3-7 del PLAN)
+// ---------------------------------------------------------------------------
+
+/** Regla 3: meta-SWL workflows → conjunto completo */
+const META_SWL_WORKFLOWS = new Set([
+  'workflow-claude-code',
+  'estructura-proyecto-claude',
+  'nuevo-proyecto',
+  'instalar-sistema',
+  'mapear-codebase',
+  'discutir-fase',
+  'planear-fase',
+  'ejecutar-fase',
+  'verificar-trabajo',
+  'verificacion-evidencia',
+  'checkpoints-verificacion',
+]);
+
+/** Regla 4: skills de patrones y experto por lenguaje → base [Read, Grep, Glob] */
+const SKILLS_PATRONES_EXPERTO = new Set([
+  'patrones-python',
+  'go-patrones',
+  'rust-patrones',
+  'java-patrones',
+  'kotlin-compose',
+  'csharp-patrones',
+  'php-patrones',
+  'swift-patrones',
+  'nextjs-patrones',
+]);
+
+/** Regla 5: build-errors → [Read, Grep, Bash] */
+const PREFIJO_BUILD_ERRORS = 'build-errors-';
+
+/** Regla 6: checklists → [Read, Grep] */
+const SKILLS_CHECKLIST = new Set([
+  'checklist-calidad',
+  'checklist-seguridad',
+]);
+
+/** Regla 7: texto puro → [Read] */
+const SKILLS_TEXTO_PURO = new Set([
+  'estilo-sin-ai-isms',
+  'prompt-engineering',
+]);
+
+// ---------------------------------------------------------------------------
+// Patrones de detección por herramienta (heurística keyword → tool)
+// ---------------------------------------------------------------------------
+
+/**
+ * Detecta si el cuerpo del skill contiene patrones asociados a una herramienta.
+ * Retorna un Set con las herramientas detectadas y las razones para el log.
+ *
+ * @param {string} nombre  nombre del skill (directorio)
+ * @param {string} cuerpo  texto del cuerpo del SKILL.md (sin frontmatter)
+ * @returns {{ herramientas: string[], razones: string[], confianza: string }}
+ */
+function inferirHerramientas(nombre, cuerpo) {
+  const herramientas = new Set();
+  const razones = [];
+
+  // --- Regla 3: meta-SWL completo ---
+  if (META_SWL_WORKFLOWS.has(nombre)) {
+    herramientas.add('Read');
+    herramientas.add('Write');
+    herramientas.add('Edit');
+    herramientas.add('Bash');
+    herramientas.add('Glob');
+    herramientas.add('Grep');
+    razones.push('regla3:meta-swl-workflow');
+    return { herramientas: ordenarHerramientas(herramientas), razones, confianza: 'alta' };
+  }
+
+  // --- Regla 5: build-errors ---
+  if (nombre.startsWith(PREFIJO_BUILD_ERRORS)) {
+    herramientas.add('Read');
+    herramientas.add('Grep');
+    herramientas.add('Bash');
+    razones.push('regla5:build-errors');
+    return { herramientas: ordenarHerramientas(herramientas), razones, confianza: 'alta' };
+  }
+
+  // --- Regla 6: checklists ---
+  if (SKILLS_CHECKLIST.has(nombre)) {
+    herramientas.add('Read');
+    herramientas.add('Grep');
+    razones.push('regla6:checklist');
+    return { herramientas: ordenarHerramientas(herramientas), razones, confianza: 'alta' };
+  }
+
+  // --- Regla 7: texto puro ---
+  if (SKILLS_TEXTO_PURO.has(nombre)) {
+    herramientas.add('Read');
+    razones.push('regla7:texto-puro');
+    return { herramientas: ordenarHerramientas(herramientas), razones, confianza: 'alta' };
+  }
+
+  // --- Regla 4: patrones/experto de lenguaje (base Read+Grep+Glob, Bash si hay bloques) ---
+  if (SKILLS_PATRONES_EXPERTO.has(nombre)) {
+    herramientas.add('Read');
+    herramientas.add('Grep');
+    herramientas.add('Glob');
+    razones.push('regla4:patrones-experto-base');
+    // Bash solo si hay bloques bash
+    if (contarBloquesBash(cuerpo) >= 1) {
+      herramientas.add('Bash');
+      razones.push('regla4+bash:bloque-bash-detectado');
+    }
+    return { herramientas: ordenarHerramientas(herramientas), razones, confianza: 'alta' };
+  }
+
+  // --- Reglas de detección por patrones en cuerpo ---
+
+  // Bash: ≥3 bloques ```bash, o patrones de comandos ejecutables
+  const numBloquesBash = contarBloquesBash(cuerpo);
+  if (numBloquesBash >= 3) {
+    herramientas.add('Bash');
+    razones.push(`bash:${numBloquesBash}-bloques-bash`);
+  } else if (numBloquesBash >= 1 && detectarComandosEjecutables(cuerpo)) {
+    herramientas.add('Bash');
+    razones.push('bash:comandos-ejecutables-detectados');
+  }
+
+  // Read: ≥2 rutas de archivo mencionadas, o patrones de lectura
+  const numRutas = contarRutasArchivo(cuerpo);
+  if (numRutas >= 2) {
+    herramientas.add('Read');
+    razones.push(`read:${numRutas}-rutas-archivo`);
+  } else if (/\bRead\(|\bleer archivo\b|(?<!\w)cat\s+[\w/]|\bcargar archivo\b/i.test(cuerpo)) {
+    herramientas.add('Read');
+    razones.push('read:patron-lectura');
+  }
+
+  // Write: patrones de creación/escritura de archivos
+  if (/\bWrite\(|\bcrear archivo\b|\bescribir en\b|\bgenera(r)? archivo\b|\bgenerado en\b/i.test(cuerpo)) {
+    herramientas.add('Write');
+    razones.push('write:patron-escritura');
+  }
+
+  // Edit: patrones de modificación de archivos (evitar falsos positivos con "editar" en contextos de negocio)
+  if (/\bEdit\(|\bmodificar archivo\b|\beditar archivo\b|\bactualizar archivo\b|\bagregar l[íi]nea a\b/i.test(cuerpo)) {
+    herramientas.add('Edit');
+    razones.push('edit:patron-edicion');
+  }
+
+  // Grep: patrones de búsqueda en contenido
+  if (/\bGrep\(|\brg\s|\bbuscar en\b|\bgrep\s|\b(patr[oó]n|regex).*archivo|\bbuscar.*archivos?\b/i.test(cuerpo)) {
+    herramientas.add('Grep');
+    razones.push('grep:patron-busqueda');
+  }
+
+  // Glob: patrones de búsqueda de archivos por patrón
+  if (/\bGlob\(|\*\*\/\*\.|\bfind\s+[\w./]|\bbuscar archivos\b/i.test(cuerpo)) {
+    herramientas.add('Glob');
+    razones.push('glob:patron-glob');
+  }
+
+  // WebSearch: búsqueda web
+  if (/\bWebSearch\b|\bbuscar en (la )?web\b|\bbuscar documentaci[oó]n actualizada\b|\bStack Overflow\b/i.test(cuerpo)) {
+    herramientas.add('WebSearch');
+    razones.push('websearch:patron-web');
+  }
+
+  // WebFetch: descarga desde URL (solo si no hay Bash ya detectado para curl)
+  if (/\bWebFetch\b|\bdescargar de URL\b|\bfetch https?\b/i.test(cuerpo)) {
+    herramientas.add('WebFetch');
+    razones.push('webfetch:patron-fetch');
+  } else if (!herramientas.has('Bash') && /\bcurl https?\b/i.test(cuerpo)) {
+    herramientas.add('WebFetch');
+    razones.push('webfetch:curl-sin-bash');
+  }
+
+  // --- Garantía mínima: todo skill necesita al menos Read ---
+  if (!herramientas.has('Read')) {
+    herramientas.add('Read');
+    razones.push('fallback:read-minimo');
+  }
+
+  // --- Confianza y fallback a Grep ---
+  const confianza = calcularConfianza(herramientas, razones);
+  if (confianza === 'baja' && !herramientas.has('Grep')) {
+    herramientas.add('Grep');
+    razones.push('fallback:grep-inferencia-debil');
+  }
+
+  return { herramientas: ordenarHerramientas(herramientas), razones, confianza };
+}
+
+// ---------------------------------------------------------------------------
+// Funciones auxiliares de detección
+// ---------------------------------------------------------------------------
+
+function contarBloquesBash(cuerpo) {
+  const matches = cuerpo.match(/```bash/gi);
+  return matches ? matches.length : 0;
+}
+
+function detectarComandosEjecutables(cuerpo) {
+  return /(?:^|\n)\s*\$\s+\S+|\b(?:npx|pip|node|python|curl|git)\s+\S+/m.test(cuerpo);
+}
+
+function contarRutasArchivo(cuerpo) {
+  const matches = cuerpo.match(/\b[\w-]+\.(?:md|py|ts|js|json|ya?ml)\b/gi);
+  if (!matches) return 0;
+  // Deduplica para no contar la misma ruta varias veces
+  return new Set(matches.map(m => m.toLowerCase())).size;
+}
+
+/** Ordena herramientas en orden canónico para output consistente */
+function ordenarHerramientas(set) {
+  const ORDEN = ['Read', 'Write', 'Edit', 'Bash', 'Glob', 'Grep', 'WebSearch', 'WebFetch'];
+  return ORDEN.filter(t => set.has(t));
+}
+
+function calcularConfianza(herramientas, razones) {
+  // Confianza alta: cualquier regla de catálogo (regla3-7) o patrón explícito de tool
+  const tieneReglaEspecifica = razones.some(r =>
+    r.startsWith('regla') || r.startsWith('bash:') || r.startsWith('write:') ||
+    r.startsWith('edit:') || r.startsWith('grep:') || r.startsWith('glob:') ||
+    r.startsWith('websearch:') || r.startsWith('webfetch:')
+  );
+
+  // Confianza media: al menos 2 rutas de archivo detectadas (read:N con N≥2)
+  const tieneReadPorRutas = razones.some(r => {
+    const m = r.match(/^read:(\d+)-rutas-archivo$/);
+    return m && parseInt(m[1], 10) >= 2;
+  });
+
+  // Confianza media: patrón explícito de lectura detectado (no solo fallback)
+  const tienePatronLectura = razones.some(r => r === 'read:patron-lectura');
+
+  if (tieneReglaEspecifica) return 'alta';
+  if (tieneReadPorRutas || tienePatronLectura) return 'media';
+  return 'baja';
+}
+
+// ---------------------------------------------------------------------------
+// Lectura y modificación de frontmatter
+// ---------------------------------------------------------------------------
+
+/**
+ * Lee el SKILL.md y retorna su contenido completo.
+ * @param {string} nombre nombre del skill
+ * @returns {{ ruta: string, contenido: string }|null}
+ */
+function leerSkill(nombre) {
+  const ruta = path.join(RAIZ_SKILLS, nombre, 'SKILL.md');
+  if (!fs.existsSync(ruta)) return null;
+  const contenido = fs.readFileSync(ruta, 'utf8');
+  return { ruta, contenido };
+}
+
+/**
+ * Extrae frontmatter, cuerpo y detecta si ya tiene herramientasPermitidas.
+ * @param {string} contenido
+ * @returns {{ frontmatterRaw: string, cuerpo: string, tieneHerramientas: boolean, fmInicio: number, fmFin: number }|null}
+ */
+function analizarContenido(contenido) {
+  // Regex que maneja \r\n y \n
+  const match = contenido.match(/^(---\s*\r?\n)([\s\S]*?)(\r?\n---\s*(?:\r?\n|$))/);
+  if (!match) return null;
+
+  const fmInicio = match[1].length;           // después del primer ---
+  const frontmatterRaw = match[2];
+  const fmFin = fmInicio + frontmatterRaw.length + match[3].length;
+  const cuerpo = contenido.slice(fmFin);
+
+  const tieneHerramientas = /^(allowed-tools|herramientasPermitidas)\s*:/im.test(frontmatterRaw);
+
+  return { frontmatterRaw, cuerpo, tieneHerramientas, fmInicio, fmFin };
+}
+
+/**
+ * Inserta `herramientasPermitidas: [H1, H2, ...]` en el frontmatter.
+ * Estrategia: insertar DESPUÉS de la última línea que empieza por `version:`,
+ * `description:` (que puede ser multilinea) o del último campo escalar antes
+ * del cierre del frontmatter si esos no existen.
+ *
+ * @param {string} contenido  texto completo del SKILL.md
+ * @param {string[]} herramientas  lista ordenada de herramientas
+ * @returns {string} contenido modificado
+ */
+function insertarCampo(contenido, herramientas) {
+  const analisis = analizarContenido(contenido);
+  if (!analisis) {
+    throw new Error('Frontmatter no encontrado — no se puede insertar campo');
+  }
+
+  const { frontmatterRaw, fmFin } = analisis;
+  const lineaHerramientas = `herramientasPermitidas: [${herramientas.join(', ')}]`;
+
+  // Buscar la posición de inserción: después de `version:` si existe,
+  // si no, después de `description:` (fin del bloque multilinea),
+  // si no, al final del frontmatter.
+  const lineasFm = frontmatterRaw.split(/\r?\n/);
+  let posInsercion = lineasFm.length; // por defecto al final
+
+  // Buscar la línea de version: (puede tener valor inline o vacío)
+  let ultimaVersionIdx = -1;
+  for (let i = 0; i < lineasFm.length; i++) {
+    if (/^version\s*:/i.test(lineasFm[i].trim())) {
+      ultimaVersionIdx = i;
+    }
+  }
+
+  if (ultimaVersionIdx >= 0) {
+    posInsercion = ultimaVersionIdx + 1;
+  } else {
+    // Buscar fin de description: (bloque multilinea con `>`)
+    let enDescription = false;
+    for (let i = 0; i < lineasFm.length; i++) {
+      if (/^description\s*:/i.test(lineasFm[i].trim())) {
+        enDescription = true;
+        posInsercion = i + 1;
+        continue;
+      }
+      if (enDescription) {
+        // Las líneas de continuación del bloque `>` empiezan con espacios
+        if (/^\s+\S/.test(lineasFm[i])) {
+          posInsercion = i + 1;
+        } else {
+          // Fin del bloque description
+          break;
+        }
+      }
+    }
+  }
+
+  // Insertar en la posición encontrada
+  lineasFm.splice(posInsercion, 0, lineaHerramientas);
+
+  // Reconstruir el frontmatter modificado
+  const nuevoFrontmatter = lineasFm.join('\n');
+
+  // Reconstruir el archivo completo
+  // El cuerpo original está desde fmFin (incluye el --- de cierre ya procesado)
+  // Necesitamos reconstruir con los mismos delimitadores
+  const cuerpoOriginal = contenido.slice(fmFin);
+  return `---\n${nuevoFrontmatter}\n---\n${cuerpoOriginal}`;
+}
+
+// ---------------------------------------------------------------------------
+// Lógica principal
+// ---------------------------------------------------------------------------
+
+const advertencias = [];
+const resultados = [];
+
+function procesarSkill(nombre) {
+  const skill = leerSkill(nombre);
+  if (!skill) {
+    advertencias.push({ skill: nombre, tipo: 'ARCHIVO_NO_ENCONTRADO', mensaje: `${nombre}/SKILL.md no existe` });
+    return null;
+  }
+
+  const analisis = analizarContenido(skill.contenido);
+  if (!analisis) {
+    advertencias.push({ skill: nombre, tipo: 'FRONTMATTER_INVALIDO', mensaje: `${nombre}: frontmatter no parseable` });
+    return null;
+  }
+
+  if (SOLO_FALTANTES && analisis.tieneHerramientas) {
+    return { nombre, estado: 'skip', razon: 'ya tiene herramientasPermitidas' };
+  }
+
+  const { herramientas, razones, confianza } = inferirHerramientas(nombre, analisis.cuerpo);
+
+  if (confianza === 'baja') {
+    advertencias.push({
+      skill: nombre,
+      tipo: 'INFERENCIA_DEBIL',
+      mensaje: `${nombre}: confianza baja — default [Read, Grep]. Razones: ${razones.join(', ')}`,
+    });
+  }
+
+  return {
+    nombre,
+    herramientas_inferidas: herramientas,
+    confianza,
+    razones,
+    ya_tiene: analisis.tieneHerramientas,
+    estado: analisis.tieneHerramientas && !SOLO_FALTANTES ? 'actualizar' : 'agregar',
+  };
+}
+
+function ejecutarDryRun(skills) {
+  const propuesta = [];
+  const stats = { alta: 0, media: 0, baja: 0, skip: 0, error: 0 };
+
+  for (const nombre of skills) {
+    const r = procesarSkill(nombre);
+    if (!r) { stats.error++; continue; }
+    if (r.estado === 'skip') { stats.skip++; continue; }
+    stats[r.confianza] = (stats[r.confianza] || 0) + 1;
+    propuesta.push(r);
+  }
+
+  process.stdout.write(JSON.stringify(propuesta, null, 2) + '\n');
+
+  process.stderr.write('\n=== Dry-run completado ===\n');
+  process.stderr.write(`  Skills a modificar:     ${propuesta.length}\n`);
+  process.stderr.write(`  Confianza alta:          ${stats.alta}\n`);
+  process.stderr.write(`  Confianza media:         ${stats.media}\n`);
+  process.stderr.write(`  Confianza baja:          ${stats.baja} (INFERENCIA_DEBIL)\n`);
+  process.stderr.write(`  Skip (ya tienen campo):  ${stats.skip}\n`);
+  process.stderr.write(`  Errores de parseo:       ${stats.error}\n\n`);
+}
+
+function ejecutarAplicar(skills) {
+  const stats = { modificados: 0, skip: 0, error: 0, alta: 0, media: 0, baja: 0 };
+  const errores = [];
+
+  for (const nombre of skills) {
+    const r = procesarSkill(nombre);
+    if (!r) { stats.error++; continue; }
+    if (r.estado === 'skip') { stats.skip++; continue; }
+
+    // Verificar que el skill ya tiene el campo o necesita inserción
+    if (r.ya_tiene && SOLO_FALTANTES) { stats.skip++; continue; }
+
+    const skill = leerSkill(nombre);
+    if (!skill) { stats.error++; continue; }
+
+    let nuevoContenido;
+    try {
+      // Si ya tiene herramientas y no es --solo-faltantes, re-insertar (no es el caso normal)
+      // En modo normal con --aplicar, solo tocamos los que no tienen el campo
+      if (r.ya_tiene) {
+        stats.skip++;
+        continue;
+      }
+      nuevoContenido = insertarCampo(skill.contenido, r.herramientas_inferidas);
+    } catch (err) {
+      stats.error++;
+      errores.push({ nombre, error: err.message });
+      process.stderr.write(`  ERROR ${nombre}: ${err.message}\n`);
+      continue;
+    }
+
+    // Validación: el nuevo contenido debe contener herramientasPermitidas
+    if (!/^herramientasPermitidas\s*:/m.test(nuevoContenido)) {
+      stats.error++;
+      errores.push({ nombre, error: 'herramientasPermitidas no aparece en contenido nuevo' });
+      process.stderr.write(`  ERROR ${nombre}: validación post-inserción falló\n`);
+      continue;
+    }
+
+    // Validación: el frontmatter del nuevo contenido debe ser parseable
+    const analisisPost = analizarContenido(nuevoContenido);
+    if (!analisisPost) {
+      stats.error++;
+      errores.push({ nombre, error: 'frontmatter post-inserción no parseable' });
+      process.stderr.write(`  ERROR ${nombre}: frontmatter corrompido tras inserción\n`);
+      continue;
+    }
+
+    // Escritura atómica
+    try {
+      atomicWriteSync(skill.ruta, nuevoContenido, 'utf8');
+    } catch (err) {
+      stats.error++;
+      errores.push({ nombre, error: `atomicWrite falló: ${err.message}` });
+      process.stderr.write(`  ERROR ${nombre}: escritura atómica falló — ${err.message}\n`);
+      continue;
+    }
+
+    stats.modificados++;
+    stats[r.confianza] = (stats[r.confianza] || 0) + 1;
+    resultados.push(r);
+  }
+
+  process.stderr.write('\n=== Aplicación completada ===\n');
+  process.stderr.write(`  Skills modificados:      ${stats.modificados}\n`);
+  process.stderr.write(`  Skip (ya tenían campo):  ${stats.skip}\n`);
+  process.stderr.write(`  Errores:                 ${stats.error}\n`);
+  process.stderr.write(`  Confianza alta:          ${stats.alta}\n`);
+  process.stderr.write(`  Confianza media:         ${stats.media}\n`);
+  process.stderr.write(`  Confianza baja:          ${stats.baja}\n\n`);
+
+  if (errores.length > 0) {
+    process.stderr.write('=== Skills con error ===\n');
+    for (const e of errores) {
+      process.stderr.write(`  ${e.nombre}: ${e.error}\n`);
+    }
+    process.stderr.write('\n');
+  }
+
+  return stats.error;
+}
+
+function escribirLog(advertencias) {
+  if (!RUTA_LOG || advertencias.length === 0) return;
+  const dir = path.dirname(RUTA_LOG);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  const lineas = advertencias.map(a => `[${new Date().toISOString()}] ${a.tipo} — ${a.mensaje}`);
+  fs.appendFileSync(RUTA_LOG, lineas.join('\n') + '\n', 'utf8');
+  process.stderr.write(`Log escrito en: ${RUTA_LOG} (${advertencias.length} advertencias)\n`);
+}
+
+// ---------------------------------------------------------------------------
+// Ejecución
+// ---------------------------------------------------------------------------
+
+let todosLosSkills = fs.readdirSync(RAIZ_SKILLS, { withFileTypes: true })
+  .filter(d => d.isDirectory())
+  .map(d => d.name)
+  .sort();
+
+// Filtro por --skill si se especificó
+if (FILTRO_SKILL) {
+  if (!todosLosSkills.includes(FILTRO_SKILL)) {
+    process.stderr.write(`Error: skill "${FILTRO_SKILL}" no encontrado en habilidades/\n`);
+    process.exit(1);
+  }
+  todosLosSkills = [FILTRO_SKILL];
+}
+
+let codigoSalida = 0;
+
+if (MODO_DRY_RUN) {
+  ejecutarDryRun(todosLosSkills);
+} else {
+  const numErrores = ejecutarAplicar(todosLosSkills);
+  if (numErrores > 0) {
+    process.stderr.write(`ADVERTENCIA: ${numErrores} skills tuvieron errores. Revisar antes de continuar.\n`);
+    codigoSalida = 1;
+  }
+}
+
+escribirLog(advertencias);
+process.exit(codigoSalida);