@saulwade/swl-ses 1.8.0 → 2.0.0

package/habilidades/tdd-workflow/SKILL.md

@@ -1,12 +1,12 @@
 ---
 name: tdd-workflow
 description: Flujo completo de Test-Driven Development. Ciclo RED (el test falla) → GREEN (implementación mínima) → REFACTOR (limpieza). Incluye cobertura mínima obligatoria, tests de frontera, factories, fixtures y estrategias para diferentes tipos de código (APIs, services, componentes Angular).
-version: "1.0.6"
+version: "1.2.0"
 evolved: true
-evolved-from: "1.0.4"
-evolved-at: "2026-05-16"
-evolved-by: "aprender"
-evolved-note: "v1.0.5: gotcha 'Tests E2E de CLIs interactivos sin PTY real'. Origen M2 sesión 2026-05-16 — harness TTY mockeado en swl-ses v1.6.0 que evita instalar node-pty. v1.0.4: silenced tests por race en path único compartido + anti-patrón `if (X) assert(Y)` sin else. v1.0.3: gotcha cwd cacheado al require()."
+evolved-from: "1.1.0"
+evolved-at: "2026-06-11"
+evolved-by: "fase-10-slice-2"
+evolved-note: "v1.2.0: sección 'Evidencia RED en telemetría' (gate G2, ADR-0035, cierra F-TDD-6) — registro de corridas tdd-* en loop-telemetry. v1.0.5: gotcha 'Tests E2E de CLIs interactivos sin PTY real'. Origen M2 sesión 2026-05-16. v1.0.4: silenced tests por race en path único compartido. v1.0.3: gotcha cwd cacheado al require()."
 herramientasPermitidas: [Read, Bash]
 evolvable: true  # default para skill estandar
 exclusiones:
@@ -40,6 +40,19 @@ que los tests exigen — ni más, ni menos.
 
 ---
 
+## Etapa opcional previa: Gherkin (BDD) y gate de mutación
+
+Dos extensiones opt-in del ciclo, ambas con guía completa en recursos:
+
+- **Antes del ciclo** — si la fase tiene criterios de aceptación de negocio,
+  convertirlos en escenarios Given–When–Then validados por el usuario ANTES de
+  implementar; cada escenario es el test RED de su criterio. Guía, runners por
+  stack y anti-patrones en [recursos/gherkin-bdd.md](recursos/gherkin-bdd.md).
+- **Después del ciclo** — en módulos críticos, verificar la calidad de los
+  asserts con mutation testing incremental sobre el diff:
+  `Skill("calidad-mutation-testing")`. La cobertura mide ejecución; los
+  mutantes sobrevivientes miden si los tests detectarían un bug.
+
 ## El ciclo fundamental RED → GREEN → REFACTOR
 
 ### Fase RED — El test debe fallar por la razón correcta
@@ -62,6 +75,46 @@ def test_descuento_cliente_premium_es_15_porciento():
 
 **NUNCA avanzar a GREEN si el test pasa en RED.**
 
+#### Evidencia RED en telemetría (gate G2 — proyectos con SWL)
+
+El RED debe dejar rastro verificable (cierra F-TDD-6: "TDD declarativo sin
+evidencia"). En proyectos con `.planning/`, registrar la corrida en
+`hooks/lib/loop-telemetry.js` ANTES de pasar a GREEN:
+
+```bash
+# Una vez por fase/tarea — abre la corrida
+node -e "const lt=require('./hooks/lib/loop-telemetry');const r=lt.iniciarCorrida({tipo:'tdd',direccion:'lower_is_better',config:{fase:'0N',tarea:'T-NN'}});console.log(r.dir)"
+
+# Al confirmar el RED — métrica = número de tests fallando, descripción = fallo exacto
+node -e "const lt=require('./hooks/lib/loop-telemetry');lt.registrarIteracion('<dir>',{iteracion:0,metrica:N,delta:0,estado:'baseline',descripcion:'RED T-NN: <error textual del runner>'})"
+
+# Al llegar a GREEN
+node -e "const lt=require('./hooks/lib/loop-telemetry');lt.registrarIteracion('<dir>',{iteracion:1,metrica:0,delta:-N,estado:'keep',descripcion:'GREEN T-NN: suite verde'})"
+```
+
+`hooks/tdd-gate.js` (warn-only, ADR-0035) busca la fila RED en
+`.planning/loops/tdd-*/iteraciones.tsv` al commitear un feature con tests; sin
+evidencia emite nudge `tdd-red-evidence`. Sin `.planning/` no aplica.
+
+#### Marker de trazabilidad REQ en tests (proyectos con REQ-IDs)
+
+Cuando la fase tiene criterios `REQ-NN` en el CONTEXTO, cada test que verifica un
+criterio lleva el marker en comentario — `scripts/verificar-trazabilidad.js` lo usa
+para cerrar la cadena REQ→T→commit→test:
+
+```python
+def test_descuento_cliente_premium():
+    # verifica: REQ-03
+    ...
+```
+
+```javascript
+test('descuento cliente premium', () => {
+  // verifica: REQ-03
+  ...
+});
+```
+
 ### Fase GREEN — Implementación mínima
 
 **Regla de oro**: Implementar solo lo que hace pasar el test. Nada más.

package/habilidades/tdd-workflow/recursos/gherkin-bdd.md

@@ -0,0 +1,111 @@
+# Etapa Gherkin (BDD) — de criterios de aceptación a tests ejecutables
+
+Etapa opt-in previa al ciclo RED→GREEN→REFACTOR que convierte los criterios de
+aceptación del CONTEXTO.md/PRD en escenarios **Given–When–Then** ejecutables.
+Cierra el hueco entre "lo que el negocio pidió" y "lo que los tests verifican":
+cada escenario es a la vez especificación legible por el usuario y esqueleto
+del test.
+
+Inspirada en el flujo de Robert C. Martin (spec → hard spec → Gherkin → TDD →
+mutation testing): el Gherkin es la "hard spec" verificable; el ciclo TDD la
+implementa; el mutation testing (`Skill("calidad-mutation-testing")`) verifica
+la suite resultante.
+
+## Cuándo usar la etapa (y cuándo no)
+
+**Usar cuando**: la fase tiene criterios de aceptación de negocio (PRD o
+CONTEXTO.md con decisiones cerradas), el comportamiento tiene reglas con casos
+distinguibles (descuentos, permisos, estados), o el usuario validará la spec
+sin leer código.
+
+**NO usar cuando**: la fase es técnica pura (refactor, migración, infra), los
+criterios son triviales (CRUD sin reglas), o no hay quien lea los escenarios —
+Gherkin sin lector de negocio es ceremonia que duplica los tests.
+
+## Formato
+
+```gherkin
+# language: es
+Característica: Descuento por nivel de cliente
+  Como cliente premium quiero recibir mi descuento automático
+  para no capturar cupones manualmente.
+
+  Escenario: Cliente premium recibe 15% en compras normales
+    Dado un cliente con nivel "premium"
+    Cuando realiza una compra de $100.00 MXN
+    Entonces el descuento aplicado es de $15.00 MXN
+
+  Esquema del escenario: Descuento por nivel
+    Dado un cliente con nivel "<nivel>"
+    Cuando realiza una compra de $<monto> MXN
+    Entonces el descuento aplicado es de $<descuento> MXN
+
+    Ejemplos:
+      | nivel    | monto  | descuento |
+      | normal   | 100.00 | 0.00      |
+      | premium  | 100.00 | 15.00     |
+      | mayorista| 100.00 | 22.00     |
+```
+
+Reglas de redacción:
+
+- **Un comportamiento por escenario** — si necesitas "Y cuando..." encadenados,
+  son dos escenarios.
+- **Lenguaje del dominio, no de la implementación**: "Dado un cliente premium",
+  NUNCA "Dado un row en la tabla clientes con tipo=2".
+- **Valores concretos** en los ejemplos — los criterios vagos ("un monto
+  válido") no son verificables.
+- **Esquema del escenario** para reglas con tabla de casos — es la forma
+  natural de los tests de frontera de `pruebas.md`.
+- Español de México (`# language: es`) — los escenarios los lee el usuario.
+
+## Derivación desde CONTEXTO.md / PRD
+
+1. Tomar cada criterio de aceptación cerrado del CONTEXTO.md (o historia del PRD).
+2. Reescribirlo como 1-N escenarios: el caso feliz + las fronteras + el caso de error.
+3. Presentar los escenarios al usuario para validación ANTES de implementar —
+   este es el checkpoint humano del flujo: corregir una spec cuesta una
+   conversación; corregir la implementación cuesta un refactor.
+4. Los escenarios validados se guardan en `tests/features/<dominio>.feature`
+   y el PLAN.md referencia qué tarea implementa cada escenario.
+
+## Runners por stack
+
+| Stack | Runner | Binding típico |
+|-------|--------|----------------|
+| Python | `pytest-bdd` (o `behave`) | `@scenario("features/descuento.feature", "Cliente premium...")` + steps con `@given/@when/@then` |
+| JS/TS | `@cucumber/cucumber` | steps en `features/steps/*.ts` con `Given/When/Then` |
+| C#/.NET | Reqnroll (sucesor de SpecFlow) | bindings `[Given]/[When]/[Then]` |
+| Java | Cucumber-JVM | anotaciones `@Given/@When/@Then` |
+
+Verificar versión vigente con Context7 antes de instalar (regla `usar-context7.md`).
+
+Los steps son **pegamento delgado**: parsean el Gherkin y llaman al mismo
+código de test que usaría el ciclo TDD (factories incluidas). La lógica de
+verificación vive en los asserts, no en los steps.
+
+## Integración con el ciclo TDD
+
+```
+CONTEXTO.md/PRD → escenarios Gherkin → validación del usuario (checkpoint)
+      → por cada escenario: RED (step sin implementar falla)
+      → GREEN (implementación mínima) → REFACTOR
+      → al cierre de fase: mutation testing opcional sobre el diff
+```
+
+Cada escenario Gherkin ES un test RED al inicio: el runner reporta steps sin
+implementar como fallos — exactamente la fase RED del ciclo. No escribir tests
+unitarios duplicados del mismo criterio: el escenario cubre el comportamiento
+de negocio; los tests unitarios cubren los detalles internos que el Gherkin
+no expresa (errores de infraestructura, edge cases técnicos).
+
+## Anti-patrones
+
+- **Gherkin imperativo de UI**: "Cuando hago clic en el botón #submit" — eso
+  es un script de Selenium disfrazado. Los escenarios describen comportamiento
+  de dominio; la UI cambia sin que la regla de negocio cambie.
+- **Escenarios escritos DESPUÉS de implementar** para "documentar" — pierde el
+  checkpoint de validación, que es el valor de la etapa.
+- **Steps con lógica de negocio** — la duplican; los steps solo traducen.
+- **Un .feature gigante por módulo** — un archivo por característica, como el
+  código.

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

@@ -6,7 +6,7 @@ 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
 ---
@@ -124,7 +124,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 +132,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,190 @@ 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) {
+  return /^\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 +1041,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 +1177,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/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.
+  }
+});