@saulwade/swl-ses 2.5.3 → 2.6.0

package/scripts/cli/memoria-search.js

@@ -0,0 +1,69 @@
+'use strict';
+
+/**
+ * Wrapper CLI `swl-ses memoria-search <op>` — búsqueda en la memoria del
+ * proyecto (.planning/sessions/, APRENDIZAJES.md, diary). Reemplaza los
+ * `require('./hooks/lib/memory-search')` relativos al proyecto que
+ * memoria-busqueda y benchmark-memoria instruían — rotos downstream (ver
+ * docs/invocacion-cli-cross-scope.md).
+ *
+ * Ops:
+ *   search   --query="..." [--limit=N] [--tipo=aprendizaje|sesion|instinto]
+ *            [--desde=YYYY-MM-DD] [--hasta=YYYY-MM-DD]   (default)
+ *   timeline --ids=id1,id2,...
+ *   fetch    --id=<id>
+ *
+ * Salida: JSON a stdout. La base es la RAÍZ del proyecto (raizProyecto),
+ * no el cwd crudo — misma semántica que los hooks (DT-HOOKS-RAIZ-GIT).
+ */
+
+const ms = require('../../hooks/lib/memory-search');
+const { raizProyecto } = require('../../hooks/lib/raiz-proyecto');
+
+function memoriaSearch(opciones = {}) {
+  const op = (opciones._args && opciones._args[0]) || 'search';
+  const base = raizProyecto(process.cwd());
+
+  if (op === 'search') {
+    const query = opciones.query != null && opciones.query !== true ? String(opciones.query) : '';
+    if (!query) {
+      console.error('Error: falta --query="<términos>"');
+      process.exitCode = 1;
+      return;
+    }
+    const filtros = {};
+    const limit = parseInt(opciones.limit, 10);
+    if (!isNaN(limit) && limit > 0) filtros.limit = limit;
+    if (opciones.tipo != null && opciones.tipo !== true) filtros.tipo = String(opciones.tipo);
+    if (opciones.desde != null && opciones.desde !== true) filtros.fecha_desde = String(opciones.desde);
+    if (opciones.hasta != null && opciones.hasta !== true) filtros.fecha_hasta = String(opciones.hasta);
+    console.log(JSON.stringify(ms.search(base, query, filtros), null, 2));
+    return;
+  }
+
+  if (op === 'timeline') {
+    const ids = String(opciones.ids || '').split(',').map(s => s.trim()).filter(Boolean);
+    if (ids.length === 0) {
+      console.error('Error: falta --ids=id1,id2,...');
+      process.exitCode = 1;
+      return;
+    }
+    console.log(JSON.stringify(ms.timeline(base, ids), null, 2));
+    return;
+  }
+
+  if (op === 'fetch') {
+    if (opciones.id == null || opciones.id === true) {
+      console.error('Error: falta --id=<id>');
+      process.exitCode = 1;
+      return;
+    }
+    console.log(JSON.stringify(ms.fetch(base, String(opciones.id)), null, 2));
+    return;
+  }
+
+  console.error(`Error: op desconocida "${op}" (usa search|timeline|fetch)`);
+  process.exitCode = 1;
+}
+
+module.exports = memoriaSearch;

package/scripts/cli/nudge-accionar.js

@@ -0,0 +1,39 @@
+'use strict';
+
+/**
+ * Subcomando `swl-ses nudge-accionar <id> --por <consumidor>` — cierra el
+ * ciclo de un nudge (T-09, Fase 21 / ADR-0041).
+ *
+ * Lo invocan los comandos /swl:aprender y /swl:evolucionar (y el agente
+ * auto-evolucion-swl) tras atender la sugerencia de un nudge, para que
+ * `evolution/nudges.jsonl` registre quién lo accionó. Sin este cierre los
+ * nudges se acumulan sin consumidor (174 emitidos / 0 accionados al crear
+ * la Fase 21).
+ *
+ * Uso: swl-ses nudge-accionar <id> [--por <consumidor>]
+ */
+
+const { marcarAccionado } = require('../lib/ciclo-autonomo/higiene-nudges');
+
+function nudgeAccionar(opciones = {}) {
+  const id = (opciones._args || [])[0];
+  const baseDir = opciones.dir || process.cwd();
+
+  if (!id) {
+    console.error('[nudge-accionar] falta el id. Uso: swl-ses nudge-accionar <id> [--por <consumidor>]');
+    process.exitCode = 1;
+    return null;
+  }
+
+  const por = opciones.por || opciones.by || 'desconocido';
+  const resultado = marcarAccionado(baseDir, { id, por });
+
+  if (resultado.marcados === 0) {
+    console.error(`[nudge-accionar] nudge "${id}" no encontrado o ya accionado`);
+  } else {
+    console.log(`[nudge-accionar] nudge "${id}" marcado como accionado por "${por}"`);
+  }
+  return resultado;
+}
+
+module.exports = nudgeAccionar;

package/scripts/cli/run-eval.js

@@ -0,0 +1,38 @@
+'use strict';
+
+/**
+ * Wrapper CLI `swl-ses run-eval` — ejecuta un eval del framework de validación
+ * de outputs estructurados (scripts/run-eval.js). Reemplaza el
+ * `node scripts/run-eval.js` relativo al proyecto que eval-framework
+ * instruía — roto downstream (ver docs/invocacion-cli-cross-scope.md).
+ *
+ * Uso:
+ *   swl-ses run-eval <ruta-eval.json>
+ *   swl-ses run-eval --rebuild-aggregate
+ *
+ * ADVERTENCIA (nemesis iter-1 S3-6): el main() envuelto llama process.exit()
+ * en todas sus ramas — este wrapper TERMINA el proceso host. Correcto vía
+ * `bin/swl-ses.js` (proceso fresco por invocación); NO invocar in-process
+ * (batch runners, tests que compongan varios wrappers) o matará el proceso.
+ */
+
+const { main } = require('../run-eval.js');
+
+function runEval(opciones = {}) {
+  const args = [];
+  if (opciones['rebuild-aggregate'] || opciones.rebuild_aggregate) {
+    args.push('--rebuild-aggregate');
+  } else if (opciones._args && opciones._args[0]) {
+    args.push(String(opciones._args[0]));
+  }
+
+  const argvOriginal = process.argv;
+  process.argv = ['node', 'run-eval.js', ...args];
+  try {
+    main();
+  } finally {
+    process.argv = argvOriginal;
+  }
+}
+
+module.exports = runEval;

package/scripts/cli/run-skill-evals.js

@@ -11,10 +11,17 @@
  *   --list                 → listar evals del skill
  *   --json                 → output JSON
  *   --record-baseline      → registrar score baseline
- *   --record-after         → registrar score post-cambio
- *   --score=<N>            → score numérico (acompaña --record-*)
+ *   --record-after         → registrar score post-cambio (el score se LEE del
+ *                            artefacto de evaluación con procedencia — ver abajo)
+ *   --score=<N>            → score numérico (baseline/revert; en record-after
+ *                            solo como verificación de coincidencia)
  *   --hypothesis=<texto>   → hipótesis de la mutación
  *   --invariantes-ok       → marcar invariantes como OK
+ *   --emitir-evaluacion    → escribir artefacto de procedencia (lo invoca
+ *                            /swl:evaluar-skill; exige --score y --producido-por)
+ *   --producido-por=<a>    → actor que corrió la evaluación (≠ target)
+ *   --badge=<b>            → badge asignado (opcional, acompaña emitir)
+ *   --evaluacion=<path>    → override del path del artefacto en record-after
  */
 
 const path = require('path');
@@ -32,6 +39,10 @@ function runSkillEvals(opciones) {
   if (opciones && opciones.score !== undefined) args.push(`--score=${opciones.score}`);
   if (opciones && opciones.hypothesis) args.push(`--hypothesis=${opciones.hypothesis}`);
   if (opciones && opciones['invariantes-ok']) args.push('--invariantes-ok');
+  if (opciones && opciones['emitir-evaluacion']) args.push('--emitir-evaluacion');
+  if (opciones && opciones['producido-por']) args.push(`--producido-por=${opciones['producido-por']}`);
+  if (opciones && opciones.badge) args.push(`--badge=${opciones.badge}`);
+  if (opciones && opciones.evaluacion) args.push(`--evaluacion=${opciones.evaluacion}`);
 
   const argvOriginal = process.argv;
   process.argv = ['node', 'run-skill-evals.js', ...args];

package/scripts/derivar-feature-list.js

@@ -102,22 +102,23 @@ function parsearTablaResumen(contenido, fases) {
 
     const celdas = trim.split('|').map(c => c.trim()).filter(c => c !== '');
 
-    // Detectar header
-    if (idxFase === -1) {
-      const lowered = celdas.map(c => c.toLowerCase());
-      const fa = lowered.findIndex(c => c === 'fase' || c === 'phase' || c === '#');
-      const no = lowered.findIndex(c => c === 'nombre' || c === 'name');
-      const ob = lowered.findIndex(c => c === 'objetivo' || c === 'objective');
-      const es = lowered.findIndex(c => c === 'estado' || c === 'status');
-      if (fa !== -1 && no !== -1 && es !== -1) {
-        idxFase = fa;
-        idxNombre = no;
-        idxObjetivo = ob;
-        idxEstado = es;
-        enTabla = true;
-      }
+    // Detectar header — en CADA línea de tabla, no solo en la primera del
+    // archivo: el HOJA-RUTA real acumula varias tablas de fase (una por
+    // iniciativa) y fijar los índices de la primera ignoraba las demás en
+    // silencio (--check daba verde con fases ausentes del JSON).
+    const lowered = celdas.map(c => c.toLowerCase());
+    const fa = lowered.findIndex(c => c === 'fase' || c === 'phase' || c === '#');
+    const no = lowered.findIndex(c => c === 'nombre' || c === 'name');
+    const es = lowered.findIndex(c => c === 'estado' || c === 'status');
+    if (fa !== -1 && no !== -1 && es !== -1) {
+      idxFase = fa;
+      idxNombre = no;
+      idxObjetivo = lowered.findIndex(c => c === 'objetivo' || c === 'objective');
+      idxEstado = es;
+      enTabla = true;
       continue;
     }
+    if (idxFase === -1) continue;
 
     // Línea separadora (|---|---|)
     if (celdas.every(c => /^-+$/.test(c.replace(/:/g, '')))) continue;

package/scripts/desinstalar.js

@@ -140,6 +140,17 @@ function uninstall(opciones) {
         `  - ${archivo.destino}`
       );
       eliminados++;
+      // Subdirectorios creados por el instalador (hooks/lib/, rules/<lang>/)
+      // quedan vacíos tras borrar sus archivos: rmdir no-recursivo — solo
+      // cae si el dir quedó realmente vacío; cualquier contenido del usuario
+      // lo preserva (ENOTEMPTY ignorado). Acotado a rutas.base: un
+      // install-state manipulado no puede dirigir el rmdir fuera del árbol
+      // gestionado (endurecimiento, revisor-seguridad 2026-07-10).
+      try {
+        const padre = path.resolve(path.dirname(archivo.destino));
+        const baseGestionada = path.resolve(rutas.base);
+        if (padre.startsWith(baseGestionada + path.sep)) fs.rmdirSync(padre);
+      } catch (_) { /* no vacío o raíz gestionada */ }
     } catch (err) {
       _emitir(
         { tipo: 'error', archivo: archivo.destino, mensaje: err.message },

package/scripts/doctor.js

@@ -31,7 +31,13 @@ async function obtenerVersionRemota() {
 }
 
 async function doctor(opciones = {}) {
-  const force = opciones.force || !ES_TTY;
+  // Reparar exige intención EXPLÍCITA (--force). El default previo
+  // (`|| !ES_TTY`) auto-reparaba en headless: los reparadores invocan al
+  // INSTALADOR contra el cwd — en un checkout del repo eso materializaba
+  // copias dentro del fuente, reescribía settings.json y disparaba
+  // `git rm --cached` masivo vía limpiarTracked (incidente 2026-07-10,
+  // tests/CI). Sin TTY y sin --force: doctor solo DIAGNOSTICA.
+  const force = !!opciones.force;
   const cwd = process.cwd();
 
   let errores = 0;
@@ -337,14 +343,18 @@ async function doctor(opciones = {}) {
                   });
                 }
                 if (resultado.incorrectos.length > 0) {
-                  const reparacion = repararHooks(settingsPath);
-                  if (reparacion.reparados > 0) {
-                    console.log(formatearPaso(`Hooks ${runtime.nombre}`, `${reparacion.reparados} hooks reparados automáticamente`));
-                    ok++;
-                  } else {
-                    console.log(formatearAdvertencia(`Hooks ${runtime.nombre}`, `${resultado.incorrectos.length} hooks con problemas`));
-                    advertencias++;
-                  }
+                  // NO reparar en la fase de diagnóstico: repararHooks muta
+                  // settings.json. Debe pasar por el gate --force como todo lo
+                  // demás (incidente 2026-07-10 — reparación no consentida).
+                  console.log(formatearAdvertencia(`Hooks ${runtime.nombre}`, `${resultado.incorrectos.length} hooks con problemas`));
+                  advertencias++;
+                  reparables.push({
+                    descripcion: `Reparar ${resultado.incorrectos.length} hooks con formato incorrecto en settings.json`,
+                    reparar: () => {
+                      const reparacion = repararHooks(settingsPath);
+                      return `${reparacion.reparados} hooks reparados en settings.json`;
+                    },
+                  });
                 }
               }
             }
@@ -683,10 +693,14 @@ async function doctor(opciones = {}) {
     console.log('');
 
     let proceder = force;
-    if (!proceder) {
+    if (!proceder && ES_TTY) {
       proceder = await preguntarSiNo('¿Reparar automáticamente?');
       console.log('');
     }
+    if (!proceder && !ES_TTY) {
+      console.log(`  ${color.dim('Modo no interactivo: reparación omitida. Ejecuta `swl-ses doctor --force` para reparar.')}`);
+      console.log('');
+    }
 
     if (proceder) {
       let reparados = 0;

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,
@@ -164,6 +164,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 +252,7 @@ async function install(opciones) {
   try {
     resolucion = resolverPerfil(perfil, {
       target,
-      with: opciones.with,
+      with: withCombinado.join(',') || undefined,
       without: opciones.without,
     });
   } catch (err) {
@@ -575,6 +597,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 +752,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 +776,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 +793,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 +1227,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

@@ -91,6 +91,17 @@ function activarHooksProyecto(opciones = {}) {
     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,
@@ -98,6 +109,7 @@ function activarHooksProyecto(opciones = {}) {
     registrados: r.registrados,
     preservados: r.preservados,
     optimizaciones,
+    gitignorePath,
   };
 }
 

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);