@saulwade/swl-ses 2.5.3 → 2.6.1

package/scripts/instalador.js

@@ -21,7 +21,7 @@ const { preguntarSiNo, ES_TTY } = require('./lib/ui');
 const { resolverPerfil, generarPlan } = require('./lib/manifiestos');
 const { crearEstado, registrarArchivo, registrarComponente, guardarEstado, cargarEstado } = require('./lib/estado');
 const { validarRuta, esArchivoSensible, filtrarSecretos } = require('./lib/seguridad');
-const { registrarHooks, registrarOptimizaciones, rutaSettings, cargarHooksConfig } = require('./lib/hooks-settings');
+const { registrarHooks, registrarOptimizaciones, rutaSettings, cargarHooksConfig, hooksSWLRegistrados } = require('./lib/hooks-settings');
 const { obtenerTransformador } = require('./lib/transformadores');
 const {
   esProtegido,
@@ -41,6 +41,7 @@ const { canonicalHash } = require('./lib/canonical-hash');
 const { auditarEscritura } = require('./lib/audit-evolved');
 const { detectarStack, filtrarReglasPorStack } = require('./lib/detectar-stack');
 const { actualizarGitignore, entradasParaRuntime, limpiarTracked, leerManifest, escribirManifest } = require('./lib/gitignore-manifest');
+const { limpiarBasuraGlobal } = require('./lib/limpiar-basura-global');
 
 const RAIZ_PKG = path.resolve(__dirname, '..');
 const VERSION = require('../package.json').version;
@@ -164,6 +165,28 @@ async function install(opciones) {
               || perfilDeState
               || 'completo';
 
+  // DT-MODULOS-OPT-IN: preservar los módulos extra (--with) registrados por
+  // instalaciones previas en el install-state. Corre SIEMPRE (independiente
+  // de si el usuario pasó --profile): sin esto, cada update/reinstalación
+  // perdía en silencio los módulos opt-in (p. ej. reglas-personales).
+  let extrasDeState = [];
+  try {
+    const runtimeParaState = obtenerRuntime(target);
+    const dirDestino = esGlobal ? runtimeParaState.global : path.resolve(runtimeParaState.local);
+    const stateExistente = fs.existsSync(dirDestino) ? cargarEstado(dirDestino) : null;
+    if (stateExistente && Array.isArray(stateExistente.modulosExtra) && stateExistente.modulosExtra.length > 0) {
+      extrasDeState = stateExistente.modulosExtra;
+      console.log(`[install-state] Preservando módulos extra previos: ${extrasDeState.join(', ')}`);
+      console.log(`[install-state] Para quitarlos pasa --without <modulo> explícito.`);
+    }
+  } catch { /* state ilegible: seguir solo con --with del CLI */ }
+
+  // Unión de los extras del CLI (--with) y los preservados del state.
+  const withCombinado = [
+    ...String(opciones.with || '').split(',').map(s => s.trim()).filter(Boolean),
+    ...extrasDeState,
+  ].filter((m, i, arr) => arr.indexOf(m) === i);
+
   console.log(`swl-ses install v${VERSION}`);
   console.log(`${'='.repeat(40)}`);
 
@@ -230,7 +253,7 @@ async function install(opciones) {
   try {
     resolucion = resolverPerfil(perfil, {
       target,
-      with: opciones.with,
+      with: withCombinado.join(',') || undefined,
       without: opciones.without,
     });
   } catch (err) {
@@ -330,6 +353,18 @@ async function install(opciones) {
     }
   }
 
+  // Scope global: purgar directorios basura sembrados en el HOME por versiones
+  // previas: ~/.planning/ scaffold (doctor confundía el HOME con un proyecto por
+  // ~/_userland) y ~/_userland/ vacío. Conservador: solo el .planning con la
+  // huella del scaffold y el _userland sin plugins reales, nunca contenido del
+  // usuario. Ver scripts/lib/limpiar-basura-global.js.
+  if (esGlobal) {
+    const basura = limpiarBasuraGlobal();
+    if (basura.eliminados.length > 0) {
+      console.log(`\n[global] Basura purgada del HOME: ${basura.eliminados.join(', ')}.`);
+    }
+  }
+
   // 4. Detectar _userland/
   const userlandAgentes = path.join(process.cwd(), '_userland', 'agentes');
   const userlandHabilidades = path.join(process.cwd(), '_userland', 'habilidades');
@@ -575,6 +610,9 @@ async function install(opciones) {
     // desde el cwd actual del doctor). Fix v1.4.3.
     allLangs: allLangs === true,
     stackInstalado: stackDetectado instanceof Set ? [...stackDetectado] : null,
+    // Solo los extras que el perfil realmente resolvió (existen y no fueron
+    // excluidos con --without) — DT-MODULOS-OPT-IN.
+    modulosExtra: withCombinado.filter(m => resolucion.modulos.includes(m)),
   });
 
   let instalados = 0;
@@ -727,6 +765,19 @@ async function install(opciones) {
     registrarComponente(estado, modulo);
   }
 
+  // Persistencia INTERMEDIA (DT-INSTALL-STATE-TRANSACCIONAL, nemesis sub1-S3):
+  // todos los archivos ya están en disco. Sin este save, una interrupción
+  // durante el registro de hooks (settings.json) o la generación de
+  // CLAUDE.md/AGENTS.md dejaría archivos copiados que el install-state NO
+  // registra → huérfanos que ni doctor ni uninstall ven. guardarEstado es
+  // atómico e idempotente; el save final (abajo) fija hooksRegistrados.
+  // Best-effort: un fallo aquí no aborta la instalación.
+  try {
+    guardarEstado(estado, rutas.base);
+  } catch (err) {
+    console.error(`  ! Aviso: no se pudo persistir el estado intermedio: ${err.message}`);
+  }
+
   // 7. Registrar hooks en settings.json del runtime
   // Los hooks solo se registran a nivel PROYECTO (no global) para evitar
   // ejecucion duplicada cuando Claude Code combina hooks de ambos scopes.
@@ -738,8 +789,15 @@ async function install(opciones) {
     // No filtrar por tipo de módulo porque hooks como grafo-contexto.js
     // pueden pertenecer a módulos con tipo distinto a "hooks".
     const hooksConfig = cargarHooksConfig();
-    const hookFilesInstalados = resolucion.archivos
-      .filter(a => (a.rutaRelativa || a.origen).endsWith('.js') && hooksConfig[path.basename(a.origen)])
+    // Registrar SOLO los hooks realmente copiados (estado.archivosInstalados),
+    // no los del PLAN (resolucion.archivos) — un hook cuyo .js falló al copiar
+    // (throw, colisión, origen inexistente) no debe quedar en settings.json
+    // apuntando a un archivo ausente: el wrapper traga el MODULE_NOT_FOUND y
+    // el hook muere en silencio (DT-REGISTRAR-HOOKS-PLAN, nemesis sub1-S2).
+    // Los hooks nunca entran a la rama `evolucionado` (no son componentes
+    // evolucionables) → un hook exitoso siempre queda en archivosInstalados.
+    const hookFilesInstalados = (estado.archivosInstalados || [])
+      .filter(a => (a.origen || '').endsWith('.js') && hooksConfig[path.basename(a.origen)])
       .map(a => path.basename(a.origen));
 
     if (hookFilesInstalados.length > 0) {
@@ -748,12 +806,22 @@ async function install(opciones) {
         console.log('    Los hooks se activan al instalar a nivel proyecto con: npx @saulwade/swl-ses@latest install --target claude');
       } else {
         const settingsPath = rutaSettings(runtime, rutas.base);
+        // UNIÓN con los hooks SWL YA registrados cuyo .js sigue en disco:
+        // registrarHooks reconstruye la sección SWL de settings.json, así que
+        // pasar solo lo recién copiado DESREGISTRARÍA los hooks pre-existentes
+        // que colisionaron sin --force pero siguen funcionando (regresión
+        // detectada por la re-auditoría nemesis iter-2). El plan-base ya no se
+        // usa: solo entra lo copiado ∪ lo pre-registrado-con-archivo-en-disco.
+        const preRegistrados = hooksSWLRegistrados(settingsPath).filter(
+          nombre => cargarHooksConfig()[nombre] && fs.existsSync(path.join(rutas.hooks, nombre))
+        );
+        const hookFilesFinal = [...new Set([...hookFilesInstalados, ...preRegistrados])];
         try {
           const resultado = registrarHooks({
             settingsPath,
             hooksDir: rutas.hooks,
             esGlobal: false,
-            hookFiles: hookFilesInstalados,
+            hookFiles: hookFilesFinal,
           });
           hooksRegistrados = resultado.registrados;
           hooksPreservados = resultado.preservados;
@@ -1172,12 +1240,35 @@ function instalarArchivo(archivo, rutas, runtime, opciones = {}) {
     } else {
       destino = path.join(dirDestino, nombreArchivo);
     }
+  } else if (
+    archivo.tipo === 'hooks' &&
+    archivo.rutaRelativa &&
+    (archivo.rutaRelativa.startsWith('hooks/lib/') || archivo.rutaRelativa.startsWith('scripts/lib/'))
+  ) {
+    // Contrato de layout de hooks: los hooks requieren sus libs como
+    // './lib/X' (y check-update/session-briefing usan ese fallback
+    // explícito). El aplanado total dejaba TODOS esos require() muertos en
+    // instalaciones frescas — MODULE_NOT_FOUND tragado por el wrapper de
+    // settings; los installs de campo sobrevivían por el lib/ residual de
+    // versiones previas. Preservar el subárbol lib/ (incluye subdirs como
+    // lib/ciclo-autonomo/) restaura el contrato. scripts/ NO-lib sigue
+    // aplanado en la raíz de hooks (status quo: rotar-audit-logs, etc.).
+    const resto = archivo.rutaRelativa.replace(/^(?:hooks|scripts)\/lib\//, '');
+    const partes = resto.split('/');
+    const subdirLib = path.join(dirDestino, 'lib', ...partes.slice(0, -1));
+    if (!fs.existsSync(subdirLib)) {
+      fs.mkdirSync(subdirLib, { recursive: true });
+    }
+    destino = path.join(subdirLib, partes[partes.length - 1]);
   } else {
     destino = path.join(dirDestino, nombreArchivo);
   }
 
-  // Seguridad: validar ruta
-  validarRuta(dirDestino, nombreArchivo);
+  // Seguridad: validar el DESTINO calculado completo, no solo el basename —
+  // cubre también las ramas con subdirectorios (reglas/lenguajes, hooks/lib)
+  // contra un rutaRelativa con traversal (endurecimiento, revisor-seguridad
+  // 2026-07-10; el manifiesto es artefacto confiable, defensa en profundidad).
+  validarRuta(dirDestino, path.relative(dirDestino, destino));
 
   // Verificar archivo sensible
   if (esArchivoSensible(nombreArchivo)) {

package/scripts/lib/activar-hooks-proyecto.js

@@ -1,104 +1,116 @@
-'use strict';
-
-/**
- * activar-hooks-proyecto.js — Camino "solo hooks" (DT-HOOKS-SOLO-PROYECTO).
- *
- * Registra en el `.claude/settings.json` del PROYECTO los hooks del scope
- * GLOBAL ya instalado, sin copiar ningún componente. Cierra el dilema del
- * install local: los hooks solo funcionan registrados a nivel proyecto
- * (ADR-0009), pero el install local completo duplica agentes/comandos en la
- * UI de Claude Code (lee ambos scopes). Con este camino:
- *
- *   - Los comandos del settings apuntan con ruta ABSOLUTA al hooks/ global
- *     (esGlobal: true en registrarHooks) → cero archivos copiados.
- *   - `swl-ses update` del global refresca los hooks de TODOS los proyectos
- *     activados así, gratis (apuntan a los mismos archivos).
- *   - Hooks externos (no-SWL) del settings del proyecto se preservan
- *     (garantía de registrarHooks).
- *
- * Uso: `swl-ses install --target claude --solo-hooks` (en la raíz del
- * proyecto). Requiere instalación global previa del runtime.
- */
-
-const fs = require('fs');
-const path = require('path');
-
-const RUNTIMES_SOPORTADOS = new Set(['claude', 'openclaude']);
-
-/**
- * @param {object} opciones
- * @param {string} [opciones.target='claude']     Runtime (claude|openclaude — formato de settings de Claude Code)
- * @param {string} [opciones.dirProyecto=cwd]     Raíz del proyecto destino
- * @param {string} [opciones.hooksDirGlobal]      Override del hooks/ global (tests)
- * @param {object} [opciones.deps]                Inyección para tests: { registrarHooks, registrarOptimizaciones, cargarHooksConfig, scopesReales, obtenerRuntime }
- * @returns {{ok: boolean, error?: string, settingsPath?: string, hooksDirGlobal?: string, registrados?: number, preservados?: number}}
- */
-function activarHooksProyecto(opciones = {}) {
-  const target = opciones.target || 'claude';
-  if (!RUNTIMES_SOPORTADOS.has(target)) {
-    return { ok: false, error: `--solo-hooks soporta por ahora targets con settings formato Claude Code (claude, openclaude); recibido: "${target}".` };
-  }
-
-  const deps = opciones.deps || {};
-  const hs = require('./hooks-settings');
-  const registrarHooks = deps.registrarHooks || hs.registrarHooks;
-  const registrarOptimizaciones = deps.registrarOptimizaciones || hs.registrarOptimizaciones;
-  const cargarHooksConfig = deps.cargarHooksConfig || hs.cargarHooksConfig;
-
-  // 1. Localizar el hooks/ del scope GLOBAL del runtime.
-  let hooksDirGlobal = opciones.hooksDirGlobal;
-  if (!hooksDirGlobal) {
-    try {
-      const dr = require('./detectar-runtime');
-      const obtenerRuntime = deps.obtenerRuntime || dr.obtenerRuntime;
-      const scopesReales = deps.scopesReales || dr.scopesReales;
-      const runtime = obtenerRuntime(target);
-      const global = scopesReales(runtime).find(s => s.esGlobal);
-      if (!global) return { ok: false, error: `No se pudo resolver el scope global del runtime "${target}".` };
-      hooksDirGlobal = path.join(global.dir, 'hooks');
-    } catch (err) {
-      return { ok: false, error: `No se pudo detectar el runtime "${target}": ${err.message}` };
-    }
-  }
-  if (!fs.existsSync(hooksDirGlobal)) {
-    return { ok: false, error: `No hay instalación global con hooks en ${hooksDirGlobal}. Instala primero el global: npx -y @saulwade/swl-ses@latest install --target ${target} --global --perfil completo` };
-  }
-
-  // 2. Hooks disponibles = archivos del global ∩ hooks-config del paquete.
-  const hooksConfig = cargarHooksConfig();
-  const hookFiles = fs.readdirSync(hooksDirGlobal)
-    .filter(f => f.endsWith('.js') && hooksConfig[f]);
-  if (hookFiles.length === 0) {
-    return { ok: false, error: `El hooks/ global (${hooksDirGlobal}) no contiene hooks reconocidos por hooks-config.json — instalación global corrupta o muy antigua; corre update primero.` };
-  }
-
-  // 3. Registrar en el settings.json del PROYECTO, apuntando al global.
-  const dirProyecto = opciones.dirProyecto || process.cwd();
-  const dirClaude = path.join(dirProyecto, '.claude');
-  fs.mkdirSync(dirClaude, { recursive: true });
-  const settingsPath = path.join(dirClaude, 'settings.json');
-
-  const r = registrarHooks({
-    settingsPath,
-    hooksDir: hooksDirGlobal,
-    esGlobal: true, // semántica: comandos con ruta ABSOLUTA al hooksDir (que es el global)
-    hookFiles,
-  });
-
-  let optimizaciones = 0;
-  try {
-    const opt = registrarOptimizaciones(settingsPath);
-    optimizaciones = (opt && opt.registradas) || 0;
-  } catch { /* opcional — no bloquea la activación */ }
-
-  return {
-    ok: true,
-    settingsPath,
-    hooksDirGlobal,
-    registrados: r.registrados,
-    preservados: r.preservados,
-    optimizaciones,
-  };
-}
-
-module.exports = { activarHooksProyecto, RUNTIMES_SOPORTADOS };
+'use strict';
+
+/**
+ * activar-hooks-proyecto.js — Camino "solo hooks" (DT-HOOKS-SOLO-PROYECTO).
+ *
+ * Registra en el `.claude/settings.json` del PROYECTO los hooks del scope
+ * GLOBAL ya instalado, sin copiar ningún componente. Cierra el dilema del
+ * install local: los hooks solo funcionan registrados a nivel proyecto
+ * (ADR-0009), pero el install local completo duplica agentes/comandos en la
+ * UI de Claude Code (lee ambos scopes). Con este camino:
+ *
+ *   - Los comandos del settings apuntan con ruta ABSOLUTA al hooks/ global
+ *     (esGlobal: true en registrarHooks) → cero archivos copiados.
+ *   - `swl-ses update` del global refresca los hooks de TODOS los proyectos
+ *     activados así, gratis (apuntan a los mismos archivos).
+ *   - Hooks externos (no-SWL) del settings del proyecto se preservan
+ *     (garantía de registrarHooks).
+ *
+ * Uso: `swl-ses install --target claude --solo-hooks` (en la raíz del
+ * proyecto). Requiere instalación global previa del runtime.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const RUNTIMES_SOPORTADOS = new Set(['claude', 'openclaude']);
+
+/**
+ * @param {object} opciones
+ * @param {string} [opciones.target='claude']     Runtime (claude|openclaude — formato de settings de Claude Code)
+ * @param {string} [opciones.dirProyecto=cwd]     Raíz del proyecto destino
+ * @param {string} [opciones.hooksDirGlobal]      Override del hooks/ global (tests)
+ * @param {object} [opciones.deps]                Inyección para tests: { registrarHooks, registrarOptimizaciones, cargarHooksConfig, scopesReales, obtenerRuntime }
+ * @returns {{ok: boolean, error?: string, settingsPath?: string, hooksDirGlobal?: string, registrados?: number, preservados?: number}}
+ */
+function activarHooksProyecto(opciones = {}) {
+  const target = opciones.target || 'claude';
+  if (!RUNTIMES_SOPORTADOS.has(target)) {
+    return { ok: false, error: `--solo-hooks soporta por ahora targets con settings formato Claude Code (claude, openclaude); recibido: "${target}".` };
+  }
+
+  const deps = opciones.deps || {};
+  const hs = require('./hooks-settings');
+  const registrarHooks = deps.registrarHooks || hs.registrarHooks;
+  const registrarOptimizaciones = deps.registrarOptimizaciones || hs.registrarOptimizaciones;
+  const cargarHooksConfig = deps.cargarHooksConfig || hs.cargarHooksConfig;
+
+  // 1. Localizar el hooks/ del scope GLOBAL del runtime.
+  let hooksDirGlobal = opciones.hooksDirGlobal;
+  if (!hooksDirGlobal) {
+    try {
+      const dr = require('./detectar-runtime');
+      const obtenerRuntime = deps.obtenerRuntime || dr.obtenerRuntime;
+      const scopesReales = deps.scopesReales || dr.scopesReales;
+      const runtime = obtenerRuntime(target);
+      const global = scopesReales(runtime).find(s => s.esGlobal);
+      if (!global) return { ok: false, error: `No se pudo resolver el scope global del runtime "${target}".` };
+      hooksDirGlobal = path.join(global.dir, 'hooks');
+    } catch (err) {
+      return { ok: false, error: `No se pudo detectar el runtime "${target}": ${err.message}` };
+    }
+  }
+  if (!fs.existsSync(hooksDirGlobal)) {
+    return { ok: false, error: `No hay instalación global con hooks en ${hooksDirGlobal}. Instala primero el global: npx -y @saulwade/swl-ses@latest install --target ${target} --global --perfil completo` };
+  }
+
+  // 2. Hooks disponibles = archivos del global ∩ hooks-config del paquete.
+  const hooksConfig = cargarHooksConfig();
+  const hookFiles = fs.readdirSync(hooksDirGlobal)
+    .filter(f => f.endsWith('.js') && hooksConfig[f]);
+  if (hookFiles.length === 0) {
+    return { ok: false, error: `El hooks/ global (${hooksDirGlobal}) no contiene hooks reconocidos por hooks-config.json — instalación global corrupta o muy antigua; corre update primero.` };
+  }
+
+  // 3. Registrar en el settings.json del PROYECTO, apuntando al global.
+  const dirProyecto = opciones.dirProyecto || process.cwd();
+  const dirClaude = path.join(dirProyecto, '.claude');
+  fs.mkdirSync(dirClaude, { recursive: true });
+  const settingsPath = path.join(dirClaude, 'settings.json');
+
+  const r = registrarHooks({
+    settingsPath,
+    hooksDir: hooksDirGlobal,
+    esGlobal: true, // semántica: comandos con ruta ABSOLUTA al hooksDir (que es el global)
+    hookFiles,
+  });
+
+  let optimizaciones = 0;
+  try {
+    const opt = registrarOptimizaciones(settingsPath);
+    optimizaciones = (opt && opt.registradas) || 0;
+  } catch { /* opcional — no bloquea la activación */ }
+
+  // 4. Sembrar el .gitignore del proyecto: encender la telemetría hace que
+  // los hooks ESCRIBAN (.planning/METRICAS.md, audit*.jsonl, evolution/...)
+  // — sin la sección swl-ses esos archivos runtime aparecen como cambios
+  // pendientes en el editor del usuario (caso real sistema-verificacion-oic,
+  // 2026-07-10: 19 archivos sin trackear tras activar hooks).
+  let gitignorePath = null;
+  try {
+    const { actualizarGitignore } = deps.gitignoreManifest || require('./gitignore-manifest');
+    gitignorePath = actualizarGitignore(dirProyecto);
+  } catch { /* no bloquea la activación — se reporta null */ }
+
+  return {
+    ok: true,
+    settingsPath,
+    hooksDirGlobal,
+    registrados: r.registrados,
+    preservados: r.preservados,
+    optimizaciones,
+    gitignorePath,
+  };
+}
+
+module.exports = { activarHooksProyecto, RUNTIMES_SOPORTADOS };

package/scripts/lib/auditar-invocaciones-comandos.js

@@ -87,17 +87,107 @@ function auditarInvocacionesComandos(comandosDir) {
   return { ok: violaciones.length === 0, violaciones, escaneados };
 }
 
-module.exports = { auditarInvocacionesComandos, SELF_DEV };
+// Skills que corren SOLO en el repo madre (host-only declarado en su propio
+// frontmatter/cuerpo): sus `node scripts/...` son legítimos porque el CWD ES
+// el repo (DT-PATHS-DESTINO, cierre 2026-07-10).
+const SKILLS_SOLO_MADRE = new Set([
+  'doc-sync',
+  'release-semver',
+  'validacion-ci-sistema',
+]);
+
+// Lenguajes de fence que se auditan en skills: solo instrucciones ejecutables
+// de shell. Los bloques js/javascript documentan APIs de módulos (referencia,
+// no comandos a ejecutar downstream) y llevan su clarificador de layout.
+const LENGUAJES_EJECUTABLES = new Set(['', 'bash', 'sh', 'shell']);
+
+/**
+ * Igual que auditarInvocacionesComandos pero sobre habilidades/<skill>/SKILL.md.
+ * Solo audita fences ejecutables (bash/sh/shell/sin lenguaje).
+ * @param {string} [habilidadesDir]
+ * @returns {{ok:boolean, violaciones:Array<{comando:string,linea:number,texto:string,patron:string}>, escaneados:number}}
+ */
+function auditarInvocacionesSkills(habilidadesDir) {
+  const dir = habilidadesDir || path.join(__dirname, '..', '..', 'habilidades');
+  const violaciones = [];
+  let escaneados = 0;
+
+  let skills;
+  try {
+    skills = fs.readdirSync(dir, { withFileTypes: true })
+      .filter((d) => d.isDirectory())
+      .map((d) => d.name);
+  } catch {
+    return { ok: true, violaciones, escaneados: 0 };
+  }
+
+  for (const skill of skills) {
+    if (SKILLS_SOLO_MADRE.has(skill)) continue;
+    const ruta = path.join(dir, skill, 'SKILL.md');
+    let contenido;
+    try {
+      contenido = fs.readFileSync(ruta, 'utf8');
+    } catch {
+      continue;
+    }
+    escaneados++;
+
+    const lineas = contenido.split('\n');
+    let dentroCodigo = false;
+    let lenguaje = '';
+    let marcadores = 0;
+
+    for (let i = 0; i < lineas.length; i++) {
+      const linea = lineas[i];
+      const fence = linea.match(/^\s*```\s*(\S*)/);
+      if (fence) {
+        marcadores++;
+        dentroCodigo = !dentroCodigo;
+        lenguaje = dentroCodigo ? fence[1].toLowerCase() : '';
+        continue;
+      }
+      if (!dentroCodigo || !LENGUAJES_EJECUTABLES.has(lenguaje)) continue;
+      for (const { re, desc } of PATRONES) {
+        if (re.test(linea)) {
+          violaciones.push({
+            comando: `habilidades/${skill}/SKILL.md`,
+            linea: i + 1,
+            texto: linea.trim(),
+            patron: desc,
+          });
+          break;
+        }
+      }
+    }
+    // Fences desbalanceados (conteo impar de ```): el toggle booleano quedó
+    // invertido para el resto del archivo y pudo silenciar violaciones reales.
+    // Se reporta como violación para que el scan NO termine en verde falso.
+    if (marcadores % 2 !== 0) {
+      violaciones.push({
+        comando: `habilidades/${skill}/SKILL.md`,
+        linea: 0,
+        texto: `${marcadores} marcadores \`\`\` (impar) — fence sin cerrar o anidado`,
+        patron: 'fences desbalanceados (el scan de invocaciones pudo quedar ciego)',
+      });
+    }
+  }
+
+  return { ok: violaciones.length === 0, violaciones, escaneados };
+}
+
+module.exports = { auditarInvocacionesComandos, auditarInvocacionesSkills, SELF_DEV, SKILLS_SOLO_MADRE };
 
 if (require.main === module) {
   const r = auditarInvocacionesComandos();
-  if (r.ok) {
-    console.log(`[OK] invocaciones-comandos — ${r.escaneados} comandos user-facing sin rutas relativas al proyecto`);
+  const rs = auditarInvocacionesSkills();
+  if (r.ok && rs.ok) {
+    console.log(`[OK] invocaciones-comandos — ${r.escaneados} comandos + ${rs.escaneados} skills user-facing sin rutas relativas al proyecto`);
     process.exit(0);
   }
-  console.error(`[FALLA] invocaciones-comandos — ${r.violaciones.length} invocación(es) relativa(s) al proyecto en comandos user-facing:`);
-  for (const v of r.violaciones) {
-    console.error(`  ${v.comando}.md:${v.linea} [${v.patron}] ${v.texto}`);
+  const todas = [...r.violaciones, ...rs.violaciones];
+  console.error(`[FALLA] invocaciones-comandos — ${todas.length} invocación(es) relativa(s) al proyecto en componentes user-facing:`);
+  for (const v of todas) {
+    console.error(`  ${v.comando}:${v.linea} [${v.patron}] ${v.texto}`);
   }
   console.error('\nUsa el patrón cross-scope (docs/invocacion-cli-cross-scope.md): swl-ses <sub> / npx ... <sub> / node scripts/cli/<sub>.js');
   process.exit(1);