@saulwade/swl-ses 1.9.0 → 2.1.0

package/habilidades/validacion-ci-sistema/SKILL.md

@@ -1,12 +1,12 @@
 ---
 name: validacion-ci-sistema
 description: Validación de integridad del sistema SWL inspirado en ECC CI stack. Cubre validación de frontmatter de agentes, validación de skills (SKILL.md presente y no vacío), validación de hooks (sintaxis Node.js, exit codes), validación de comandos, validación de reglas, catálogo automático con métricas y script ejecutable de validación.
-version: "1.0.0"
+version: "1.1.0"
 herramientasPermitidas: [Read, Bash]
 exclusiones:
   - "No cargar para validar el código de aplicación del usuario (tests, linting de Python/TS, cobertura) — este skill valida la integridad del sistema SWL (frontmatter de agentes, SKILL.md presentes, exit codes de hooks); para validación de código cargar `reglas/pruebas.md` o invocar `tdd-qa-swl`."
   - "No cargar para diagnosticar por qué un agente específico falló en una tarea — este skill detecta problemas estructurales del sistema SWL, no bugs en la lógica de un agente; para diagnóstico de agente usar `evaluacion-agentes`."
-  - "No cargar si `/swl:salud` acaba de ejecutarse sin errores — la validación CI es un subconjunto de lo que salud corre; no tiene sentido duplicarla en la misma sesión."
+  - "No cargar si `/swl:status salud` acaba de ejecutarse sin errores — la validación CI es un subconjunto de lo que salud corre; no tiene sentido duplicarla en la misma sesión."
   - "No cargar para agregar un componente nuevo al sistema — primero crear el componente (agente, skill, hook) y luego ejecutar validación CI para verificarlo; no como guía de creación."
 evolvable: true  # default para skill estandar
 ---
@@ -20,6 +20,22 @@ El sistema SWL crece con el tiempo. Sin validación, acumula:
 - Hooks que fallan con códigos de salida incorrectos
 - Comandos con formato inválido
 
+## Precondición — solo aplica al repo host de SWL
+
+Este skill valida los **componentes** del sistema SWL (`agentes/`, `habilidades/`,
+`comandos/swl/`, `reglas/`, `hooks/`). Solo tiene sentido en el repo que los
+**hospeda** (swl-ses o un fork). En un proyecto **consumidor** (usa las
+convenciones SWL vía `~/.claude/` pero no aloja los componentes), no hay nada que
+validar y un score de componentes sería engañoso. El gate determinista vive en
+`/swl:status salud` (Paso 0):
+
+```bash
+node scripts/lib/detectar-host-swl.js --json
+```
+
+Si `esHost: false`, NO ejecutar este skill: reportar que `salud` no aplica y
+redirigir a los subcomandos de `/swl:status` que sí aplican al proyecto consumidor.
+
 ---
 
 ## Reglas de Validación por Componente
@@ -124,7 +140,7 @@ Para código fuente completo de todos los validadores (agentes, skills, hooks, c
 ## Cuándo NO cargar
 
 - Se valida código de aplicación del usuario (tests Python/TS, cobertura, linting) — este skill valida la integridad del sistema SWL; para código de aplicación cargar `reglas/pruebas.md` o invocar `tdd-qa-swl`.
-- `/swl:salud` acaba de ejecutarse sin errores en esta sesión — la validación CI es un subconjunto de lo que salud ejecuta; duplicarla no aporta información nueva.
+- `/swl:status salud` acaba de ejecutarse sin errores en esta sesión — la validación CI es un subconjunto de lo que salud ejecuta; duplicarla no aporta información nueva.
 - El objetivo es diagnosticar por qué un agente específico falló en su tarea de dominio — este skill detecta problemas estructurales (frontmatter faltante, exit code incorrecto), no bugs en la lógica de un agente; para eso usar `evaluacion-agentes`.
 - Se está creando un componente nuevo y se necesita orientación sobre la estructura — este skill verifica componentes existentes, no guía la creación; usar `estructura-proyecto-claude` para crear con la estructura correcta desde el inicio.
 
@@ -132,5 +148,5 @@ Para código fuente completo de todos los validadores (agentes, skills, hooks, c
 
 - **Hook de observabilidad que usa `process.exit(1)` detectado como error crítico**: el validador marca el hook como inválido pero el hook fue escrito intencionalmente para bloquear en ciertos escenarios. Causa: el validador distingue entre hooks de observación (deben usar `exit(0)` siempre) y hooks de bloqueo (pueden usar `exit(1)` para rechazar acciones); si el hook no está categorizado correctamente, el validador aplica la regla incorrecta. Solución: verificar si el hook es bloqueante o de observación antes de corregir — un guardrail de seguridad que usa `exit(1)` es correcto; un hook de telemetría que usa `exit(1)` es un bug.
 - **Agente con `name` diferente al nombre de archivo pasa validación en local pero falla en CI**: el validador local compara el campo `name` del frontmatter con el nombre del directorio, pero CI usa la ruta del archivo. Causa: un agente renombrado actualiza el directorio pero no el campo `name` en el frontmatter. Solución: el checklist dice "name debe coincidir con nombre del archivo (kebab-case)" — al renombrar un agente o skill, actualizar el campo `name` del frontmatter en el mismo commit.
-- **`npm run validate` pasa sin advertencias pero `/swl:salud` reporta inconsistencias**: el script de validación CI cubre un subconjunto de las verificaciones de salud. Causa: las validaciones de grafo de dependencias, métricas de evolución y consistencia de versiones solo corren en `/swl:salud`, no en el validador CI básico. Solución: antes de un release o merge importante, ejecutar `/swl:salud` completo, no solo la validación CI — la validación CI es el mínimo para commits diarios.
+- **`npm run validate` pasa sin advertencias pero `/swl:status salud` reporta inconsistencias**: el script de validación CI cubre un subconjunto de las verificaciones de salud. Causa: las validaciones de grafo de dependencias, métricas de evolución y consistencia de versiones solo corren en `/swl:status salud`, no en el validador CI básico. Solución: antes de un release o merge importante, ejecutar `/swl:status salud` completo, no solo la validación CI — la validación CI es el mínimo para commits diarios.
 - **Skills con `description: >` YAML multiline registrados como sin frontmatter**: el validador usa una regex basada solo en LF (`/^---\n[\s\S]*?\n---/`) que no parsea correctamente archivos con terminaciones CRLF. Causa: archivos creados en Windows con CRLF en el frontmatter. Solución: si el validador reporta `sin-frontmatter` en un skill que claramente tiene frontmatter, verificar las terminaciones de línea con `file skill.md` — convertir CRLF→LF con `git config core.autocrlf input` o `sed -i 's/\r//'`.

package/hooks/calidad-pre-commit.js

@@ -44,7 +44,7 @@
 
 const fs          = require('fs');
 const path        = require('path');
-const { execSync } = require('child_process');
+const { execSync, execFileSync } = require('child_process');
 
 const { normalizeForDetection } = require('./lib/normalize-input');
 
@@ -151,7 +151,9 @@ function obtenerArchivosStagedGit() {
  */
 function obtenerContenidoStaged(rutaRelativa) {
   try {
-    const contenido = execSync(`git show :${rutaRelativa}`, {
+    // execFileSync (sin shell): el nombre de archivo se pasa como argumento
+    // directo, no se interpreta por el shell (defensa S-recom verificación F09).
+    const contenido = execFileSync('git', ['show', `:${rutaRelativa}`], {
       encoding: 'buffer',
       stdio: ['pipe', 'pipe', 'pipe'],
     });
@@ -172,7 +174,7 @@ function obtenerContenidoStaged(rutaRelativa) {
  */
 function obtenerTamanoStaged(rutaRelativa) {
   try {
-    const salida = execSync(`git cat-file -s :${rutaRelativa}`, {
+    const salida = execFileSync('git', ['cat-file', '-s', `:${rutaRelativa}`], {
       encoding: 'utf8',
       stdio: ['pipe', 'pipe', 'pipe'],
     });
@@ -824,12 +826,194 @@ function verificarRiskScore() {
   }
 }
 
+// ---------------------------------------------------------------------------
+// Gate G3 — tests-presence (warn-only). Fase 09, Slice 2.
+// ---------------------------------------------------------------------------
+
+/**
+ * ¿La ruta es un archivo de test? Consolida los patrones de test antes
+ * dispersos en este hook (verificarConsoleLog, verificarPrintPython) más
+ * convenciones multi-lenguaje. git entrega rutas relativas con separador `/`.
+ *
+ * @param {string} ruta - ruta relativa al repo
+ * @returns {boolean}
+ */
+function esArchivoTest(ruta) {
+  return (
+    /\.(test|spec)\.[jt]sx?$/.test(ruta) ||          // foo.test.ts, foo.spec.jsx
+    /(^|[/\\])__tests__[/\\]/.test(ruta) ||           // __tests__/
+    /(^|[/\\])tests?[/\\]/.test(ruta) ||              // test/ o tests/
+    /(^|[/\\])spec[/\\]/.test(ruta) ||                // spec/
+    /(^|[/\\])test_[^/\\]*\.py$/.test(ruta) ||        // test_foo.py
+    /test.*\.py$/.test(ruta) ||                       // pytest naming laxo
+    /_test\.(py|go)$/.test(ruta) ||                   // foo_test.go, foo_test.py
+    /Tests?\.(java|kt|cs)$/.test(ruta) ||             // FooTest.java, FooTests.cs
+    /_spec\.rb$/.test(ruta) ||                        // foo_spec.rb
+    /Test\.php$/.test(ruta)                            // FooTest.php
+  );
+}
+
+/**
+ * ¿La ruta es un archivo generado/derivado/lock que NO debe exigir tests?
+ *
+ * @param {string} ruta - ruta relativa al repo
+ * @returns {boolean}
+ */
+function esArchivoGenerado(ruta) {
+  return (
+    /(^|[/\\])(INVENTARIO|SALUD)\.md$/.test(ruta) ||
+    /(^|[/\\])llms\.txt$/.test(ruta) ||
+    /\.lock$/.test(ruta) ||
+    /(^|[/\\])(package-lock\.json|yarn\.lock|pnpm-lock\.yaml|poetry\.lock|Cargo\.lock|go\.sum)$/.test(ruta) ||
+    /(^|[/\\])(dist|build|coverage|node_modules|__pycache__|\.next|target)[/\\]/.test(ruta) ||
+    /\.min\.(js|css)$/.test(ruta) ||
+    /(^|[/\\])\.planning[/\\]/.test(ruta)
+  );
+}
+
+/**
+ * ¿La ruta es código fuente (lenguaje soportado), excluyendo test/generado/
+ * docs/config? Lo que dispara el gate cuando se toca sin tests.
+ *
+ * @param {string} ruta - ruta relativa al repo
+ * @returns {boolean}
+ */
+function esArchivoFuente(ruta) {
+  if (esArchivoTest(ruta) || esArchivoGenerado(ruta)) return false;
+  // Excluir docs/config/datos por extensión.
+  if (/\.(md|json|ya?ml|toml|ini|cfg|conf|txt|svg|png|jpe?g|gif|ico|csv|html?|xml|env)$/i.test(ruta)) {
+    return false;
+  }
+  return /\.(jsx?|tsx?|py|go|rs|java|kt|cs|rb|php|swift|c|cc|cpp|h|hpp|vue|svelte)$/i.test(ruta);
+}
+
+/**
+ * Extrae el mensaje del flag -m de un comando `git commit`. Soporta comillas
+ * dobles, simples o sin comillas (primera palabra). Devuelve '' si no hay -m.
+ *
+ * @param {string} comando
+ * @returns {string}
+ */
+function extraerMensajeCommit(comando) {
+  // Soporta: -m "x" | -m 'x' | -m x | -m"x" | -m=x | --message="x" | --message x.
+  // Multi -m: captura el primero (el subject, donde vive el prefijo Conventional).
+  // -F/--file: no hay mensaje en la línea → retorna '' → NO se exenta → advierte
+  // (conservador y correcto para un gate warn-only). Verificación Fase 09, S-3.
+  const m = comando.match(/(?:-m|--message)\s*=?\s*(?:"([^"]*)"|'([^']*)'|(\S+))/);
+  if (!m) return '';
+  return m[1] || m[2] || m[3] || '';
+}
+
+/**
+ * ¿El prefijo Conventional Commit exime del gate de tests? (docs/chore/style)
+ *
+ * @param {string} mensaje
+ * @returns {boolean}
+ */
+function esPrefijoExentoDeTests(mensaje) {
+  // Tolera prefijo(s) de trazabilidad de `ejecutar-fase` antes del tipo CC:
+  // `[T-NN]`, `[REQ-NN]`, `[F<fase>·T-NN]` (uno o más, consecutivos). Desde la
+  // Fase 12 los IDs se namespacean por fase (DT-IDS-NAMESPACE). El prefijo no
+  // cambia la semántica: un `[F12·T-03] docs(...)` sigue siendo exento de tests.
+  return /^\s*(?:\[(?:F\d+·)?(?:T|REQ)-\d+(?:-\d+)?\]\s*)*(docs|chore|style)(\([^)]*\))?!?:/i.test(mensaje);
+}
+
+/**
+ * Gate G3: detecta un diff staged que toca código fuente SIN tocar tests.
+ *
+ * @param {string[]} archivosStaged - rutas relativas staged
+ * @param {string} comandoCommit    - el comando bash `git commit ...`
+ * @returns {{ fuentes: string[] } | null} datos del warning, o null si no aplica
+ */
+function verificarTestPresence(archivosStaged, comandoCommit) {
+  const mensaje = extraerMensajeCommit(comandoCommit);
+  if (esPrefijoExentoDeTests(mensaje)) return null;   // docs:/chore:/style: exentos
+
+  const fuentes = archivosStaged.filter(esArchivoFuente);
+  if (fuentes.length === 0) return null;              // no toca código fuente
+
+  const tieneTests = archivosStaged.some(esArchivoTest);
+  if (tieneTests) return null;                        // hay al menos un test
+
+  return { fuentes };
+}
+
+/**
+ * Ejecutor real de cobertura (default de coverageDiferencial en el hook).
+ * Corre el runner detectado con timeout y parsea su reporte JSON al mapa
+ * { archivoRelativo: pct }. Best-effort: lanza si el runner falla o el reporte
+ * no es parseable, y coverageDiferencial captura el throw devolviendo null.
+ * @param {string[]} fuentes
+ * @param {{ runner: string, comando: string[], reporte: string }} runner
+ * @returns {Object<string, number>}
+ */
+function ejecutarCoverage(fuentes, runner) {
+  const { execFileSync } = require('child_process');
+  const path = require('path');
+  const cwd = process.cwd();
+  // Correr el runner con coverage (timeout duro — un commit no debe colgarse).
+  execFileSync(runner.comando[0], runner.comando.slice(1), {
+    cwd,
+    stdio: 'ignore',
+    timeout: Number(process.env.SWL_COVERAGE_DIFF_TIMEOUT_MS) || 120000,
+  });
+  const reporteAbs = path.join(cwd, runner.reporte);
+  const raw = fs.readFileSync(reporteAbs, 'utf8');
+
+  // pytest-cov coverage.json: { files: { "src/a.py": { summary: { percent_covered } } } }
+  if (runner.runner === 'pytest') {
+    const data = JSON.parse(raw);
+    const out = {};
+    for (const [f, info] of Object.entries(data.files || {})) {
+      const pct = info?.summary?.percent_covered;
+      if (typeof pct === 'number') out[f.replace(/\\/g, '/')] = pct;
+    }
+    return out;
+  }
+  // istanbul coverage-final.json (jest/vitest): { "/abs/path": { s: {...}, statementMap } }
+  if (runner.runner === 'vitest' || runner.runner === 'jest') {
+    const data = JSON.parse(raw);
+    const out = {};
+    for (const [abs, info] of Object.entries(data)) {
+      const stmts = info?.s ? Object.values(info.s) : [];
+      if (!stmts.length) continue;
+      const cubiertos = stmts.filter((n) => n > 0).length;
+      const rel = path.relative(cwd, abs).replace(/\\/g, '/');
+      out[rel] = (cubiertos / stmts.length) * 100;
+    }
+    return out;
+  }
+  // go coverprofile: líneas "file.go:from.col,to.col stmts count"
+  if (runner.runner === 'go') {
+    const porArchivo = {};
+    for (const linea of raw.split('\n')) {
+      const m = linea.match(/^(.+\.go):\d+\.\d+,\d+\.\d+\s+(\d+)\s+(\d+)$/);
+      if (!m) continue;
+      const [, f, stmts, count] = m;
+      porArchivo[f] = porArchivo[f] || { total: 0, cub: 0 };
+      porArchivo[f].total += Number(stmts);
+      if (Number(count) > 0) porArchivo[f].cub += Number(stmts);
+    }
+    const out = {};
+    for (const [f, v] of Object.entries(porArchivo)) {
+      out[f.replace(/\\/g, '/')] = v.total ? (v.cub / v.total) * 100 : 0;
+    }
+    return out;
+  }
+  return {};
+}
+
 // ---------------------------------------------------------------------------
 // Entrypoint principal
 // ---------------------------------------------------------------------------
 
 let inputRaw = '';
 
+// Solo enganchar stdin cuando el hook se ejecuta directamente (no al hacer
+// `require()` desde un test). Permite testear las funciones puras sin disparar
+// el flujo de stdin.
+if (require.main === module) {
+
 process.stdin.on('data', chunk => {
   inputRaw += chunk;
 });
@@ -861,6 +1045,76 @@ process.stdin.on('end', () => {
       return;
     }
 
+    // --- Gate G3: tests-presence (warn-only) ---
+    // Detecta diffs que tocan código fuente sin tocar tests y emite un nudge.
+    // NO bloquea (no exit 2): esta iteración es warn-only para calibrar falsos
+    // positivos (renames, refactors puros). Exenciones: docs:/chore:/style: y
+    // archivos generados/lock.
+    //
+    // PROMOCIÓN A BLOCKING: tras ~2 semanas de calibración sin falsos positivos
+    // recurrentes, documentar la promoción en un ADR (patrón ADR-0027) y
+    // convertir este bloque en `process.exit(2)` con la razón en stdout/stderr.
+    // Hasta entonces: solo nudge.
+    try {
+      const g3 = verificarTestPresence(archivos, comando);
+      if (g3) {
+        const tracker = require('./lib/nudge-tracker');
+        const muestra = g3.fuentes.slice(0, 3).join(', ');
+        const sufijo = g3.fuentes.length > 3 ? ` (+${g3.fuentes.length - 3} más)` : '';
+        tracker.emit({
+          kind: 'tests-presence',
+          target: g3.fuentes[0],
+          source: 'hooks/calidad-pre-commit.js',
+          message:
+            `Gate G3 (warn): el commit toca ${g3.fuentes.length} archivo(s) de ` +
+            `código fuente sin tocar ningún test: ${muestra}${sufijo}. ` +
+            `Considera agregar o actualizar tests. Exenta el commit con prefijo ` +
+            `docs:/chore:/style: si no aplica.`,
+          data: { fuentes: g3.fuentes, gate: 'G3' },
+          // 'optimize' = mejora de cobertura (no corrige un bug observado).
+          // El criterio del plan mencionaba "warn", pero el enum válido del
+          // tracker es repair|optimize|innovate; 'warn' se descartaría.
+          mutation_category: 'optimize',
+          risk_level: 'low',
+        });
+      }
+    } catch (_) {
+      // El gate G3 nunca rompe el commit (warn-only, best-effort).
+    }
+
+    // --- Gate G2-cov: coverage diferencial (opt-in SWL_COVERAGE_DIFF=1) ---
+    // Default OFF → cero latencia. Solo cuando el usuario lo activa: detecta el
+    // runner, mide cobertura de los módulos tocados y emite nudge warn-only si
+    // alguno cae bajo el umbral. Nunca bloquea (D-08).
+    if (process.env.SWL_COVERAGE_DIFF === '1') {
+      try {
+        const fuentes = archivos.filter(esArchivoFuente);
+        const runner = fuentes.length ? detectarRunnerCoverage(process.cwd()) : null;
+        if (runner) {
+          const umbral = Number(process.env.SWL_COVERAGE_DIFF_UMBRAL) || 80;
+          const res = coverageDiferencial(fuentes, runner, { ejecutor: ejecutarCoverage, umbral });
+          if (res && res.bajos.length) {
+            const tracker = require('./lib/nudge-tracker');
+            const muestra = res.bajos.slice(0, 3).join(', ');
+            tracker.emit({
+              kind: 'coverage-diff',
+              target: res.bajos[0],
+              source: 'hooks/calidad-pre-commit.js',
+              message:
+                `Coverage diferencial (warn): ${res.bajos.length} módulo(s) tocado(s) ` +
+                `bajo ${umbral}% de cobertura: ${muestra}. Runner: ${runner.runner}. ` +
+                `Agrega tests antes de mergear. Desactivar: SWL_COVERAGE_DIFF=0.`,
+              data: { bajos: res.bajos, runner: runner.runner, umbral, gate: 'G2-cov' },
+              mutation_category: 'optimize',
+              risk_level: 'low',
+            });
+          }
+        }
+      } catch (_) {
+        // Coverage diferencial es best-effort opt-in: nunca rompe el commit.
+      }
+    }
+
     // Verificar cada archivo
     const todasLasViolaciones = [];
 
@@ -927,3 +1181,90 @@ process.stdin.on('end', () => {
     // El hook nunca bloquea por errores internos propios
   }
 });
+
+} // fin if (require.main === module)
+
+// ─── Coverage diferencial opt-in (gate G2-cov, Fase 11) ──────────────────────
+//
+// Opt-in estricto: solo corre con SWL_COVERAGE_DIFF=1 (default off → cero
+// latencia). Mide la cobertura de los módulos tocados en el diff staged y emite
+// nudge warn-only `coverage-diff` si alguno cae bajo el umbral (default 80%).
+// Decisión D-08 del 11-CONTEXTO.md.
+
+/**
+ * Detecta el runner de cobertura del proyecto por marcadores de archivo.
+ * Detección barata (sin ejecutar nada) y segura ante ausencia.
+ * @param {string} cwd
+ * @returns {{ runner: string, comando: string[], reporte: string }|null}
+ */
+function detectarRunnerCoverage(cwd) {
+  const existe = (rel) => {
+    try { return fs.existsSync(require('path').join(cwd, rel)); } catch { return false; }
+  };
+  const path = require('path');
+
+  // Node: leer package.json para distinguir vitest/jest.
+  let pkg = null;
+  try {
+    pkg = JSON.parse(fs.readFileSync(path.join(cwd, 'package.json'), 'utf8'));
+  } catch { /* sin package.json */ }
+  const deps = pkg ? { ...(pkg.dependencies || {}), ...(pkg.devDependencies || {}) } : {};
+
+  if (deps.vitest || existe('vitest.config.ts') || existe('vitest.config.js')) {
+    return { runner: 'vitest', comando: ['npx', 'vitest', 'run', '--coverage'], reporte: 'coverage/coverage-final.json' };
+  }
+  if (deps.jest || existe('jest.config.js') || existe('jest.config.ts')) {
+    return { runner: 'jest', comando: ['npx', 'jest', '--coverage', '--coverageReporters=json'], reporte: 'coverage/coverage-final.json' };
+  }
+  // Python: pytest-cov.
+  if (existe('pyproject.toml') || existe('pytest.ini') || existe('setup.cfg') || existe('tox.ini')) {
+    return { runner: 'pytest', comando: ['pytest', '--cov', '--cov-report=json'], reporte: 'coverage.json' };
+  }
+  // Go: cobertura nativa.
+  if (existe('go.mod')) {
+    return { runner: 'go', comando: ['go', 'test', '-coverprofile=coverage.out', './...'], reporte: 'coverage.out' };
+  }
+  return null;
+}
+
+/**
+ * Mide la cobertura de los módulos tocados y devuelve los que están bajo umbral.
+ * El cómputo real de cobertura se delega a `opts.ejecutor` (inyectable para
+ * tests; por defecto no implementado para evitar correr runners pesados en el
+ * hook sin un parser robusto por formato). Best-effort: si el ejecutor falla,
+ * devuelve null y el hook no emite nada.
+ *
+ * @param {string[]} fuentes          Archivos de código fuente del diff staged.
+ * @param {object}   runner           Descriptor de detectarRunnerCoverage.
+ * @param {object}   [opts]
+ * @param {function} [opts.ejecutor]  (fuentes, runner) => { [archivo]: pct }.
+ * @param {number}   [opts.umbral=80]
+ * @returns {{ bajos: string[], cobertura: object }|null}
+ */
+function coverageDiferencial(fuentes, runner, opts = {}) {
+  const { ejecutor, umbral = 80 } = opts;
+  if (typeof ejecutor !== 'function') return null;
+  let cobertura;
+  try {
+    cobertura = ejecutor(fuentes, runner);
+  } catch (_) {
+    return null; // runner no instalado / reporte ilegible — best-effort.
+  }
+  if (!cobertura || typeof cobertura !== 'object') return null;
+  const bajos = fuentes.filter(
+    (f) => typeof cobertura[f] === 'number' && cobertura[f] < umbral,
+  );
+  return { bajos, cobertura };
+}
+
+// Exportar funciones puras del gate G3 + coverage diferencial para testing.
+module.exports = {
+  esArchivoTest,
+  esArchivoGenerado,
+  esArchivoFuente,
+  extraerMensajeCommit,
+  esPrefijoExentoDeTests,
+  verificarTestPresence,
+  detectarRunnerCoverage,
+  coverageDiferencial,
+};

package/hooks/check-update.js

@@ -22,7 +22,22 @@ const fs   = require('fs');
 const path = require('path');
 const os   = require('os');
 
-const { compararSemver, versionRemotaParalela } = require('../scripts/lib/npm-version');
+// La lib npm-version se distribuye junto con el hook (modulos.json hooks-core).
+// Require tolerante: repo madre / destino copy (../scripts/lib), destino
+// aplanado (./lib), o null. Antes de v2.2 este require era directo y la lib NO
+// se distribuía: en TODA instalación destino el hook moría con MODULE_NOT_FOUND
+// que el wrapper de settings.json traga en silencio — el aviso de nuevas
+// versiones nunca llegó a otros equipos (reportado 2026-06-12). Sin la lib, el
+// hook emite un diagnóstico throttled en vez de callar (anti-fallback-silencioso).
+let compararSemver = null;
+let versionRemotaParalela = null;
+try {
+  ({ compararSemver, versionRemotaParalela } = require('../scripts/lib/npm-version'));
+} catch (_) {
+  try {
+    ({ compararSemver, versionRemotaParalela } = require('./lib/npm-version'));
+  } catch (_2) { /* null — diagnosticado en el entrypoint */ }
+}
 
 // ---------------------------------------------------------------------------
 // Constantes
@@ -176,6 +191,29 @@ process.stdin.on('data', chunk => { inputRaw += chunk; });
 
 process.stdin.on('end', async () => {
   try {
+    // Lib no disponible (instalación incompleta o versión previa al fix de
+    // distribución): avisar una vez por ventana de throttle en vez de morir
+    // en silencio. `remota` con sentinel truthy → ventana de 24h, no de 1h.
+    if (!versionRemotaParalela || !compararSemver) {
+      if (debeVerificar()) {
+        try {
+          fs.writeFileSync(flagPath(), JSON.stringify({
+            timestamp: Date.now(),
+            local: null,
+            remota: 'lib-no-disponible',
+            hayNueva: false,
+            notificado: 2,
+          }), 'utf8');
+        } catch { /* silencioso */ }
+        process.stderr.write(
+          '[swl-ses/check-update] lib npm-version no disponible — el aviso de ' +
+          'nuevas versiones está inactivo. Reinstala con: ' +
+          'npx -y @saulwade/swl-ses@latest update\n'
+        );
+      }
+      return;
+    }
+
     // Throttle: solo verificar cada 24h
     if (!debeVerificar()) {
       // Si el último check detectó actualización, repetir notificación (1 vez)

package/hooks/ciclo-evolucion-subagente.js

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Hook: ciclo-evolucion-subagente.js
+ * Tipo: SubagentStop (async: true — fire-and-forget)
+ *
+ * Entry point del ciclo de evolución en el evento SubagentStop. Delega a la
+ * sub-etapa de auto-evolución (antes `auto-evolucion.js`), que analiza el
+ * payload del subagente, registra en el log y emite nudges de evolución
+ * (fallos/volumen/loop/drift). Fase 11, D-12.
+ *
+ * Nunca bloquea (siempre exit 0). Zero-deps fuera de hooks/lib/.
+ */
+
+const cicloEvolucion = require('./lib/ciclo-evolucion');
+
+let inputRaw = '';
+process.stdin.on('data', chunk => { inputRaw += chunk; });
+process.stdin.on('end', () => {
+  try {
+    cicloEvolucion.ejecutarSubagentStop(inputRaw);
+  } catch {
+    // El hook nunca bloquea por error interno.
+  }
+});

package/hooks/ciclo-evolucion.js

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Hook: ciclo-evolucion.js
+ * Tipo: Stop (async: true — fire-and-forget)
+ *
+ * Entry point del ciclo de evolución en el evento Stop. Ejecuta en UN solo
+ * proceso las sub-etapas que antes eran dos hooks separados
+ * (`metricas-evolucion.js` + `actualizar-perfil-usuario.js`), reduciendo de
+ * dos arranques de Node por sesión a uno (Fase 11, D-12).
+ *
+ * Nunca bloquea (siempre exit 0). Zero-deps fuera de hooks/lib/.
+ */
+
+const cicloEvolucion = require('./lib/ciclo-evolucion');
+
+let inputRaw = '';
+process.stdin.on('data', chunk => { inputRaw += chunk; });
+process.stdin.on('end', () => {
+  try {
+    cicloEvolucion.ejecutarStop(inputRaw);
+  } catch {
+    // El hook nunca bloquea por error interno.
+  }
+});

package/hooks/extraccion-aprendizajes.js

@@ -663,6 +663,19 @@ const PATRONES_ARCHIVO_SWL_EXCLUIDO = [
   /[\\/]package\.json$/,
   /[\\/]plugin\.json$/,
   /[\\/]package-lock\.json$/,
+  // Scripts temporales del agente (convención .tmp-*.js|.md en la raíz del
+  // repo, borrados en el mismo turno). Sus comentarios de cabecera describen
+  // la operación con keywords narrativas ("sustitución", "idempotente",
+  // "reescribe") que el hook confunde con descubrimientos. Detectado
+  // 2026-06-11: el comentario de .tmp-fusion-status.js se promovió como
+  // entrada "descubrimiento" a APRENDIZAJES.md.
+  /(?:^|[\\/])\.tmp-[^\\/]+$/,
+  // Reglas globales instaladas del usuario (~/.claude/rules/): editar esas
+  // copias es mantenimiento de configuración, no descubrimiento. El patrón
+  // /reglas[\\/]/ de arriba no las cubre porque el directorio se llama
+  // "rules" (inglés). Detectado 2026-06-11: fragmentos de una edición a
+  // verificar-citas-normativas.md (global) se promovieron como "patrón".
+  /(?:^|[\\/])\.claude[\\/]rules[\\/]/,
 ];
 
 /**