@saulwade/swl-ses 1.9.0 → 2.0.0

package/hooks/lib/evolution-tracker.js

@@ -64,6 +64,7 @@ const EXCLUDED_FILENAME_PATTERNS = [
   /\.rej$/,             // patch reject
   /\.merge_file_/,      // merge tools (kdiff3, etc.)
   /~$/,                 // editores tipo Emacs/Vim
+  /\.evolved-diff\.(md|txt)$/, // diffs de merge (no son componentes; .md legacy)
 ];
 
 /**
@@ -407,7 +408,13 @@ const DIFF_NOISY_THRESHOLD = 50;
  *
  * Estrategia: toma el archivo nuevo como base y re-aplica los campos de
  * evolución (frontmatter evolved-*). Las mutaciones de contenido se preservan
- * generando un archivo .evolved-diff.md que Claude puede re-aplicar.
+ * generando un archivo `.evolved-diff.txt` que Claude puede re-aplicar.
+ *
+ * Extensión `.txt` (no `.md`) deliberada: el diff vive junto al componente
+ * evolucionado (incluyendo `commands/`), pero el harness de Claude Code indexa
+ * todo `.md` dentro de `commands/` como slash-command — un `aprender.evolved-diff.md`
+ * aparecería como `/swl:aprender.evolved-diff`. Con `.txt` el harness no lo indexa
+ * y `scanEvolved` (que solo recorre `.md`) tampoco lo confunde con un componente.
  *
  * Comparación: solo el body (post-frontmatter) se compara línea-a-línea.
  * El frontmatter SIEMPRE diverge (el destino tiene campos `evolved-*` que el
@@ -415,7 +422,8 @@ const DIFF_NOISY_THRESHOLD = 50;
  * contarlo como mutación genera ruido por desplazamiento.
  *
  * Limpieza: cuando un merge posterior elimina la divergencia (diffs vacíos),
- * borra el `.evolved-diff.md` huérfano de sesiones previas si existe.
+ * borra el `.evolved-diff.txt` huérfano de sesiones previas si existe (y el
+ * `.evolved-diff.md` legacy de versiones anteriores a esta corrección).
  *
  * Cap defensivo: si tras alinear correctamente el body aún hay más de
  * `DIFF_NOISY_THRESHOLD` líneas distintas, genera un resumen estadístico
@@ -470,7 +478,17 @@ function mergeEvolved(destino, origen, versionNueva) {
       }
     }
 
-    const diffPath = destino.replace(/\.md$/, '.evolved-diff.md');
+    const diffPath = destino.replace(/\.md$/, '.evolved-diff.txt');
+    // Legacy: versiones previas escribían el diff como `.evolved-diff.md`, que
+    // el harness indexaba como slash-command. Se limpia siempre que se toca el
+    // componente, exista o no divergencia nueva.
+    const diffPathLegacy = destino.replace(/\.md$/, '.evolved-diff.md');
+    const limpiarLegacy = () => {
+      if (fs.existsSync(diffPathLegacy)) {
+        try { fs.unlinkSync(diffPathLegacy); return true; } catch { /* best-effort */ }
+      }
+      return false;
+    };
 
     if (diffs.length === 0) {
       // Sin diferencias reales — limpiar diff huérfano si existe (de sesión
@@ -486,6 +504,7 @@ function mergeEvolved(destino, origen, versionNueva) {
           // el merge sigue siendo válido.
         }
       }
+      if (limpiarLegacy()) cleanedDiff = true;
 
       // force: true — `mergeEvolved` solo se invoca en contexto de update
       // intencional. El skip de isPackageRoot() aplica a la primera marca
@@ -557,6 +576,8 @@ function mergeEvolved(destino, origen, versionNueva) {
     ].join('\n');
 
     atomicWriteSync(diffPath, diffContent, 'utf8');
+    // Si existía el `.evolved-diff.md` legacy, eliminarlo: el `.txt` lo reemplaza.
+    limpiarLegacy();
 
     return { merged: true, diffPath, diffsCount: diffs.length, truncated };
   } catch (err) {

package/hooks/spec-gate.js

@@ -0,0 +1,211 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Hook: spec-gate.js  (Gate G0 — SDD)
+ * Tipo: PreToolUse  (matcher: Write|Edit|MultiEdit)
+ *
+ * Detecta escrituras de CÓDIGO FUENTE sin fase activa con PLAN aprobado.
+ * Implementa el gate G0 del flujo SPEC→PLAN→TEST→CODE→VERIFY (Revisión
+ * Evolutiva 03 §5.2): "ningún Write/Edit a código fuente sin fase activa
+ * con PLAN aprobado".
+ *
+ * Modo actual: WARN-ONLY (ADR-0034, decisión D-07 de 10-CONTEXTO.md).
+ *   - Emite nudge `kind: spec-gate` a .planning/evolution/nudges.jsonl.
+ *   - NUNCA exit 2. La promoción a blocking se decide vía ADR tras ~2
+ *     semanas de calibración sin falsos positivos (patrón ADR-0027→0033).
+ *
+ * Concepto "fase activa": `.planning/locks/fase-activa.json`, escrito por
+ * /swl:aprobar-plan al firmar un plan y eliminado por /swl:ejecutar-fase al
+ * cerrar la fase. Formato:
+ *   { numero, planPath, sha256, aprobadoEn, aprobadoPor }
+ * El hook re-computa el SHA256 del plan referenciado y lo compara con el del
+ * archivo de fase activa — verificación autocontenida (sin dependencia de
+ * scripts/lib/, que puede no estar distribuido en proyectos destino).
+ *
+ * Zero-config: en proyectos sin `.planning/` el hook sale 0 sin ruido.
+ * Opt-out: SWL_SPEC_GATE=0 desactiva completamente el hook.
+ *
+ * Modelo de amenaza (heredado de plan-lock.js): detecta omisión accidental
+ * del ciclo GSD y mutación post-firma; NO resiste a un adversario con
+ * escritura al repo (puede regenerar fase-activa.json).
+ */
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+const RUTAS_EXCLUIDAS = [
+  '/temp/',
+  '/node_modules/',
+  '/respositorios-git/',
+  '/_userland/',
+  '/.planning/',
+  '/.claude/',
+];
+
+/**
+ * Clasificador de código fuente. Reutiliza esArchivoFuente() de
+ * calidad-pre-commit.js (misma definición que el gate G3) con fallback
+ * defensivo si el módulo no está disponible en el destino.
+ */
+function cargarClasificador() {
+  try {
+    const calidad = require(path.join(__dirname, 'calidad-pre-commit.js'));
+    if (typeof calidad.esArchivoFuente === 'function') return calidad.esArchivoFuente;
+  } catch (_) {
+    // Fallback mínimo: extensiones de código de los lenguajes soportados,
+    // excluyendo tests por sufijo/directorio.
+  }
+  return function esArchivoFuenteFallback(ruta) {
+    const normal = ruta.replace(/\\/g, '/');
+    if (/\.(test|spec)\.[jt]sx?$/.test(normal)) return false;
+    if (/(^|\/)(tests?|__tests__|spec)\//.test(normal)) return false;
+    if (/\.(md|json|ya?ml|toml|ini|cfg|conf|txt|svg|lock)$/i.test(normal)) return false;
+    return /\.(jsx?|tsx?|py|go|rs|java|kt|cs|rb|php|swift|c|cc|cpp|h|hpp)$/i.test(normal);
+  };
+}
+
+/**
+ * Evalúa el estado de la fase activa del proyecto en `cwd`.
+ * @returns {{ ok: boolean, motivo: string|null, numero?: number }}
+ *   ok=true  → hay fase activa con plan íntegro (no advertir)
+ *   ok=false → motivo describe por qué no hay cobertura de spec
+ */
+function evaluarFaseActiva(cwd) {
+  const rutaFaseActiva = path.join(cwd, '.planning', 'locks', 'fase-activa.json');
+  if (!fs.existsSync(rutaFaseActiva)) {
+    return { ok: false, motivo: 'sin fase activa (no existe .planning/locks/fase-activa.json)' };
+  }
+
+  let faseActiva;
+  try {
+    faseActiva = JSON.parse(fs.readFileSync(rutaFaseActiva, 'utf-8'));
+  } catch (_) {
+    return { ok: false, motivo: 'fase-activa.json corrupto (JSON inválido)' };
+  }
+
+  if (!faseActiva || typeof faseActiva.planPath !== 'string' || typeof faseActiva.sha256 !== 'string') {
+    return { ok: false, motivo: 'fase-activa.json sin planPath/sha256' };
+  }
+
+  const planAbs = path.isAbsolute(faseActiva.planPath)
+    ? faseActiva.planPath
+    : path.join(cwd, faseActiva.planPath);
+
+  if (!fs.existsSync(planAbs)) {
+    return { ok: false, motivo: `el plan de la fase activa no existe (${faseActiva.planPath})` };
+  }
+
+  let hashActual;
+  try {
+    hashActual = crypto.createHash('sha256').update(fs.readFileSync(planAbs)).digest('hex');
+  } catch (_) {
+    return { ok: false, motivo: 'no se pudo leer el plan de la fase activa' };
+  }
+
+  if (hashActual !== faseActiva.sha256) {
+    return {
+      ok: false,
+      motivo: `el plan de la fase activa fue mutado tras la firma (${faseActiva.planPath})`,
+      numero: faseActiva.numero,
+    };
+  }
+
+  return { ok: true, motivo: null, numero: faseActiva.numero };
+}
+
+/**
+ * Decide si la escritura amerita advertencia G0.
+ * @returns {null | { motivo: string }}  null = silencio
+ */
+function evaluarEscritura({ cwd, toolName, filePath, esArchivoFuente }) {
+  if (!toolName || !['Write', 'Edit', 'MultiEdit'].includes(toolName)) return null;
+  if (!filePath) return null;
+
+  // Zero-config: sin .planning/ no hay ciclo GSD que vigilar.
+  if (!fs.existsSync(path.join(cwd, '.planning'))) return null;
+
+  const normal = filePath.replace(/\\/g, '/');
+  if (RUTAS_EXCLUIDAS.some((ex) => normal.includes(ex))) return null;
+  if (!esArchivoFuente(normal)) return null;
+
+  const fase = evaluarFaseActiva(cwd);
+  if (fase.ok) return null;
+
+  return { motivo: fase.motivo };
+}
+
+function emitirNudge({ cwd, filePath, motivo }) {
+  const rutaRelativa = path.relative(cwd, filePath).replace(/\\/g, '/');
+  let emit;
+  try {
+    ({ emit } = require(path.join(__dirname, 'lib', 'nudge-tracker.js')));
+  } catch (_) {
+    return;
+  }
+  try {
+    emit({
+      kind: 'spec-gate',
+      target: rutaRelativa,
+      source: 'hooks/spec-gate.js',
+      message:
+        `Gate G0 (warn): escritura de código fuente ${rutaRelativa} ${motivo}. ` +
+        `El flujo SDD espera una fase activa con PLAN aprobado (/swl:aprobar-plan N) ` +
+        `antes de escribir código. Si es un fix trivial o exploración, ignora este aviso ` +
+        `— se usa para calibrar la promoción a blocking (ADR-0034). Opt-out: SWL_SPEC_GATE=0.`,
+      data: { archivo: rutaRelativa, motivo, gate: 'G0' },
+      mutation_category: 'optimize',
+      risk_level: 'low',
+    });
+  } catch (_) {
+    // La observabilidad nunca bloquea el trabajo productivo.
+  }
+}
+
+function main() {
+  if (process.env.SWL_SPEC_GATE === '0') process.exit(0);
+
+  let hookInput = '';
+  try {
+    hookInput = fs.readFileSync(0, 'utf-8');
+  } catch (_) {
+    process.exit(0);
+  }
+
+  let evento;
+  try {
+    evento = JSON.parse(hookInput);
+  } catch (_) {
+    process.exit(0);
+  }
+
+  const cwd = process.cwd();
+  const toolName = evento?.tool_name;
+  const filePath = evento?.tool_input?.file_path;
+
+  let resultado = null;
+  try {
+    resultado = evaluarEscritura({
+      cwd,
+      toolName,
+      filePath,
+      esArchivoFuente: cargarClasificador(),
+    });
+  } catch (_) {
+    process.exit(0);
+  }
+
+  if (resultado) {
+    emitirNudge({ cwd, filePath, motivo: resultado.motivo });
+  }
+
+  // WARN-ONLY (ADR-0034): jamás exit 2 en este modo.
+  process.exit(0);
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = { evaluarFaseActiva, evaluarEscritura, RUTAS_EXCLUIDAS };

package/hooks/tdd-gate.js

@@ -0,0 +1,241 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Hook: tdd-gate.js  (Gate G2 — TDD con evidencia RED)
+ * Tipo: PreToolUse  (matcher: Bash)
+ *
+ * Ante un `git commit` de feature (código fuente + tests en el diff staged),
+ * verifica que exista evidencia de ciclo RED en la telemetría de loops
+ * (`iteraciones.tsv` dentro de `.planning/loops/tdd-…`, escrita por
+ * ejecutar-fase / tdd-workflow). Cierra F-TDD-6 de la Revisión Evolutiva 03:
+ * "TDD declarativo sin evidencia — el RED no deja rastro".
+ *
+ * Modo actual: WARN-ONLY (ADR-0035, decisión D-07 de 10-CONTEXTO.md).
+ *   - Emite nudge `kind: tdd-red-evidence`; NUNCA exit 2 en este modo.
+ *
+ * Alcance deliberado (sin doble nudge ni falsos dominios):
+ *   - Solo aplica con FASE ACTIVA (`.planning/locks/fase-activa.json`) — el
+ *     enforcement TDD es parte del ciclo GSD, no de commits sueltos.
+ *   - Solo cuando el diff staged toca fuente Y tests: el caso "fuente sin
+ *     tests" es dominio del gate G3 (calidad-pre-commit) y ya tiene nudge.
+ *   - Respeta el opt-out declarado del CONTEXTO (`**TDD**: off — razón: ...`).
+ *   - Prefijos exentos: docs:/chore:/style: (mismos que G3).
+ *
+ * Evidencia RED válida: corrida `tdd-*` cuya `iteraciones.tsv` fue modificada
+ * dentro de la ventana (default 24h, `SWL_TDD_GATE_VENTANA_H`) con una fila
+ * de estado `baseline` con métrica > 0, o cuya descripción contenga "RED".
+ *
+ * Opt-out: SWL_TDD_GATE=0 desactiva completamente el hook.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execFileSync } = require('child_process');
+
+const VENTANA_HORAS_DEFAULT = 24;
+
+/** ¿El comando es un git commit? (ignora git status/log/diff y comandos no-git) */
+function esGitCommit(comando) {
+  if (typeof comando !== 'string') return false;
+  // Cinturón: un comando legítimo de commit no excede unos KB. Acotar evita
+  // costo lineal patológico del regex ante input gigante (hardening, no ReDoS).
+  if (comando.length > 10000) return false;
+  return /\bgit\b[^|&;]*\bcommit\b/.test(comando);
+}
+
+/** Lee el numero de fase activa y verifica el opt-out del CONTEXTO. */
+function estadoTddDeFaseActiva(cwd) {
+  const rutaFaseActiva = path.join(cwd, '.planning', 'locks', 'fase-activa.json');
+  if (!fs.existsSync(rutaFaseActiva)) return { aplica: false, motivo: 'sin-fase-activa' };
+
+  let faseActiva;
+  try {
+    faseActiva = JSON.parse(fs.readFileSync(rutaFaseActiva, 'utf-8'));
+  } catch (_) {
+    return { aplica: false, motivo: 'fase-activa-corrupta' };
+  }
+
+  const numero = Number(faseActiva?.numero);
+  if (!Number.isFinite(numero)) return { aplica: false, motivo: 'fase-activa-sin-numero' };
+
+  const nn = String(numero).padStart(2, '0');
+  const contextoPath = path.join(cwd, '.planning', 'fases', `${nn}-CONTEXTO.md`);
+  if (fs.existsSync(contextoPath)) {
+    try {
+      const contexto = fs.readFileSync(contextoPath, 'utf-8');
+      if (/\*\*TDD\*\*:\s*off/i.test(contexto)) {
+        return { aplica: false, motivo: 'tdd-off-declarado' };
+      }
+    } catch (_) {
+      // CONTEXTO ilegible: asumir TDD on (default)
+    }
+  }
+  return { aplica: true, numero: nn };
+}
+
+/** Archivos staged del repo en cwd (lista vacía si no es repo o falla git). */
+function archivosStaged(cwd) {
+  try {
+    const out = execFileSync('git', ['diff', '--cached', '--name-only'], {
+      cwd,
+      encoding: 'utf8',
+      timeout: 5000,
+    });
+    return out.split('\n').map((l) => l.trim()).filter(Boolean);
+  } catch (_) {
+    return [];
+  }
+}
+
+/**
+ * Busca evidencia RED en `.planning/loops/tdd-*` dentro de la ventana.
+ * @returns {boolean}
+ */
+function hayEvidenciaRed(cwd, ventanaHoras = VENTANA_HORAS_DEFAULT) {
+  const loopsDir = path.join(cwd, '.planning', 'loops');
+  if (!fs.existsSync(loopsDir)) return false;
+
+  let corridas;
+  try {
+    corridas = fs.readdirSync(loopsDir).filter((d) => d.startsWith('tdd-'));
+  } catch (_) {
+    return false;
+  }
+
+  const limite = Date.now() - ventanaHoras * 3600 * 1000;
+
+  for (const corrida of corridas) {
+    const tsvPath = path.join(loopsDir, corrida, 'iteraciones.tsv');
+    let stat;
+    try {
+      stat = fs.statSync(tsvPath);
+    } catch (_) {
+      continue;
+    }
+    if (stat.mtimeMs < limite) continue;
+
+    let contenido;
+    try {
+      contenido = fs.readFileSync(tsvPath, 'utf-8');
+    } catch (_) {
+      continue;
+    }
+
+    for (const linea of contenido.split('\n')) {
+      if (linea.startsWith('#') || linea.startsWith('iteracion')) continue;
+      const cols = linea.split('\t');
+      if (cols.length < 6) continue;
+      const metrica = Number(cols[2]);
+      const estado = (cols[4] || '').trim();
+      const descripcion = cols[5] || '';
+      if ((estado === 'baseline' && metrica > 0) || /\bRED\b/.test(descripcion)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+/**
+ * Decide si el commit amerita advertencia G2.
+ * @returns {null | { fuentes: string[], tests: string[] }}
+ */
+function evaluarCommit({ cwd, comando, helpers }) {
+  if (!esGitCommit(comando)) return null;
+
+  const mensaje = helpers.extraerMensajeCommit(comando);
+  if (helpers.esPrefijoExentoDeTests(mensaje)) return null;
+
+  const fase = estadoTddDeFaseActiva(cwd);
+  if (!fase.aplica) return null;
+
+  const staged = archivosStaged(cwd);
+  const fuentes = staged.filter(helpers.esArchivoFuente);
+  const tests = staged.filter(helpers.esArchivoTest);
+  // Solo el caso feature-con-tests: "fuente sin tests" es dominio de G3.
+  if (fuentes.length === 0 || tests.length === 0) return null;
+
+  const ventana = Number(process.env.SWL_TDD_GATE_VENTANA_H) || VENTANA_HORAS_DEFAULT;
+  if (hayEvidenciaRed(cwd, ventana)) return null;
+
+  return { fuentes, tests };
+}
+
+function emitirNudge({ cwd, hallazgo }) {
+  let emit;
+  try {
+    ({ emit } = require(path.join(__dirname, 'lib', 'nudge-tracker.js')));
+  } catch (_) {
+    return;
+  }
+  try {
+    const muestra = hallazgo.tests.slice(0, 2).join(', ');
+    emit({
+      kind: 'tdd-red-evidence',
+      target: hallazgo.tests[0],
+      source: 'hooks/tdd-gate.js',
+      message:
+        `Gate G2 (warn): commit de feature con tests (${muestra}) sin evidencia de ciclo ` +
+        `RED en .planning/loops/tdd-*/ — el TDD exige registrar el test fallando ANTES de ` +
+        `implementar (Skill("tdd-workflow") § Evidencia RED en telemetría). Este aviso ` +
+        `calibra la promoción a blocking (ADR-0035). Opt-out: SWL_TDD_GATE=0 o ` +
+        `'**TDD**: off — razón: ...' en el CONTEXTO de la fase.`,
+      data: { fuentes: hallazgo.fuentes, tests: hallazgo.tests, gate: 'G2' },
+      mutation_category: 'optimize',
+      risk_level: 'low',
+    });
+  } catch (_) {
+    // La observabilidad nunca bloquea el trabajo productivo.
+  }
+}
+
+function main() {
+  if (process.env.SWL_TDD_GATE === '0') process.exit(0);
+
+  let hookInput = '';
+  try {
+    hookInput = fs.readFileSync(0, 'utf-8');
+  } catch (_) {
+    process.exit(0);
+  }
+
+  let evento;
+  try {
+    evento = JSON.parse(hookInput);
+  } catch (_) {
+    process.exit(0);
+  }
+
+  if (evento?.tool_name !== 'Bash') process.exit(0);
+  const comando = evento?.tool_input?.command;
+  const cwd = process.cwd();
+
+  // Zero-config: sin .planning/ no hay ciclo GSD que vigilar.
+  if (!fs.existsSync(path.join(cwd, '.planning'))) process.exit(0);
+
+  let helpers;
+  try {
+    helpers = require(path.join(__dirname, 'calidad-pre-commit.js'));
+  } catch (_) {
+    process.exit(0);
+  }
+
+  let hallazgo = null;
+  try {
+    hallazgo = evaluarCommit({ cwd, comando, helpers });
+  } catch (_) {
+    process.exit(0);
+  }
+
+  if (hallazgo) emitirNudge({ cwd, hallazgo });
+
+  // WARN-ONLY (ADR-0035): jamás exit 2 en este modo.
+  process.exit(0);
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = { esGitCommit, estadoTddDeFaseActiva, hayEvidenciaRed, evaluarCommit };

package/hooks/validar-intent-spec.js

@@ -14,9 +14,12 @@
  *   - fragmentos: [_intent-spec]
  *   - maxTurnos (Parte 8 — Stop Rules)
  *
- * Comportamiento:
- *   - NUNCA bloquea (exit code 0 siempre — blocking:false en hooks-config)
- *   - Solo emite nudge cuando faltan campos en agente ALTO — ruido mínimo
+ * Comportamiento (modo blocking desde ADR-0033):
+ *   - BLOQUEA (exit 2) cuando un agente ALTO tiene frontmatter incompleto.
+ *     El Write/Edit ya ocurrió (PostToolUse); el exit 2 surface el error a
+ *     Claude para que complete el intent spec. Sigue emitiendo el nudge para
+ *     trazabilidad antes de bloquear.
+ *   - Sale 0 (sin ruido) cuando el agente ALTO está completo o no es ALTO.
  *   - Solo se dispara con archivos `agentes/*.md` (no fragmentos `_*.md`)
  *   - Respeta exclusiones: temp/, node_modules/, respositorios-git/, _userland/
  *
@@ -34,9 +37,10 @@
  *     accionado: false
  *   }
  *
- * Origen: ADR-0027 (F3 Opción B integración Lead Agents + DDIA).
- * Plan de promoción a `blocking:true`: tras 2 semanas sin falsos positivos
- * documentados, con nudges accionados, considerar bloqueo activo.
+ * Origen: ADR-0027 (warn-only) → ADR-0033 (promoción a blocking, 2026-06-11).
+ * Promoción justificada: 24 días estable en warn-only, 8/8 agentes ALTO con
+ * frontmatter completo al momento de la promoción (cero falsos positivos sobre
+ * el estado actual). Opt-out preservado: SWL_INTENT_SPEC=0.
  */
 
 const fs = require('fs');
@@ -216,7 +220,23 @@ try {
   }
   fs.appendFileSync(nudgesFile, JSON.stringify(nudge) + '\n');
 } catch (_) {
-  // Si falla persistir, no romper el flujo del usuario
-}
-
-process.exit(0);
+  // Si falla persistir, no romper el flujo del bloqueo
+}
+
+// ─── Modo blocking (ADR-0033) ─────────────────────────────────────────────
+// El agente ALTO tiene frontmatter incompleto: bloquear (exit 2) y surface el
+// detalle a Claude por stderr para que complete el intent spec. Opt-out global
+// SWL_INTENT_SPEC=0 ya cortó arriba; aquí el bloqueo es activo.
+const razon = [
+  `Intent spec incompleto en agente ALTO riesgo: ${nombreAgente}`,
+  `Faltan campos obligatorios: ${faltan.join(', ')}.`,
+  ``,
+  `Completa el frontmatter según reglas/intent-engineering.md:`,
+  `  strategy, healthMetrics, steering, hardGuardrails, maxTurnos,`,
+  `  y fragmentos: [_intent-spec].`,
+  `Carga Skill("proceso-intent-engineering") para la guía completa.`,
+  ``,
+  `Para omitir esta verificación: SWL_INTENT_SPEC=0 (registra la excepción).`,
+].join('\n');
+process.stderr.write(razon);
+process.exit(2);

package/llms.txt

@@ -1,6 +1,6 @@
 # swl-ses (@saulwade/swl-ses)
 
-> Sistema de ingeniería de software auto-evolutivo multi-runtime polyglot (SDLC completo), distribuido como paquete npm y plugin de Claude Code. 61 agentes, 181 habilidades, 45 comandos, 31 reglas base y 45 hooks. Soporta 11 lenguajes y 7 runtimes (Claude Code, OpenClaude, OpenCode, Gemini, Cursor, Codex, Copilot). Versión 1.9.0.
+> Sistema de ingeniería de software auto-evolutivo multi-runtime polyglot (SDLC completo), distribuido como paquete npm y plugin de Claude Code. 60 agentes, 182 habilidades, 43 comandos, 29 reglas base y 46 hooks. Soporta 11 lenguajes y 7 runtimes (Claude Code, OpenClaude, OpenCode, Gemini, Cursor, Codex, Copilot). Versión 2.0.0.
 
 Archivo generado por `node scripts/generar-inventario.js` — no editar a mano. Las cifras se sincronizan con INVENTARIO.md en cada regeneración.
 
@@ -16,11 +16,11 @@ Archivo generado por `node scripts/generar-inventario.js` — no editar a mano.
 
 ## Componentes
 
-- 61 agentes especializados en `agentes/` (orquestación, implementación por stack, revisión, calidad, diseño)
-- 181 habilidades cargables bajo demanda en `habilidades/` (conocimiento operacional con divulgación progresiva)
-- 45 comandos `/swl:*` en `comandos/swl/` (ciclo GSD, calidad, release, diagnóstico)
-- 31 reglas base + 40 reglas por lenguaje en `reglas/` (políticas obligatorias por matcher)
-- 45 hooks en `hooks/` (telemetría, validación, seguridad; zero-deps, escrituras atómicas)
+- 60 agentes especializados en `agentes/` (orquestación, implementación por stack, revisión, calidad, diseño)
+- 182 habilidades cargables bajo demanda en `habilidades/` (conocimiento operacional con divulgación progresiva)
+- 43 comandos `/swl:*` en `comandos/swl/` (ciclo GSD, calidad, release, diagnóstico)
+- 29 reglas base + 40 reglas por lenguaje en `reglas/` (políticas obligatorias por matcher)
+- 46 hooks en `hooks/` (telemetría, validación, seguridad; zero-deps, escrituras atómicas)
 
 ## Opcional
 

package/manifiestos/hooks-config.json

@@ -168,19 +168,10 @@
       "maxConsecutiveFailures": 5,
       "degradeOnFailure": "skip"
     },
-    "actualizar-perfil-usuario.js": {
+    "ciclo-evolucion.js": {
       "event": "Stop",
       "matcher": "",
-      "description": "Detecta señales de corrección/preferencia del usuario y acumula un dirty-bit en .planning/user-profile/. Emite nudge a perfilador-usuario-swl cuando cruza el umbral (default 3 señales).",
-      "blocking": false,
-      "async": true,
-      "maxConsecutiveFailures": 5,
-      "degradeOnFailure": "skip"
-    },
-    "metricas-evolucion.js": {
-      "event": "Stop",
-      "matcher": "",
-      "description": "Consolida métricas del ciclo de evolución (nudges accionados/pendientes, instintos, fallos de agentes, evoluciones aplicadas/revertidas) y actualiza .planning/evolution/metricas.json con health_score compuesto. Dispara escalamiento a alertas persistentes si >=5 nudges del mismo tipo ignorados en 14d.",
+      "description": "Ciclo de evolución (evento Stop): en un solo proceso ejecuta las sub-etapas de métricas (consolida .planning/evolution/metricas.json con health_score; escala alertas persistentes si >=5 nudges del mismo tipo ignorados en 14d) y perfil de usuario (acumula dirty-bit en .planning/user-profile/; nudge a perfilador-usuario-swl al cruzar umbral). Fusión de metricas-evolucion.js + actualizar-perfil-usuario.js (Fase 11, D-12). Lógica en hooks/lib/etapa-{metricas,perfil-usuario}.js.",
       "blocking": false,
       "async": true,
       "maxConsecutiveFailures": 5,
@@ -195,10 +186,10 @@
       "maxConsecutiveFailures": 5,
       "degradeOnFailure": "skip"
     },
-    "auto-evolucion.js": {
+    "ciclo-evolucion-subagente.js": {
       "event": "SubagentStop",
       "matcher": "",
-      "description": "Registra cada terminación de subagente SWL en .planning/auto-evolution/agentes.jsonl y emite nudge a /swl:evolucionar cuando un agente acumula fallos o volumen de runs (ventana 14 días, throttle 24h).",
+      "description": "Ciclo de evolución (evento SubagentStop): registra cada terminación de subagente SWL en .planning/auto-evolution/agentes.jsonl y emite nudge a /swl:evolucionar cuando un agente acumula fallos, volumen de runs, loop o drift (ventana 14 días, throttle 24h). Renombrado de auto-evolucion.js (Fase 11, D-12). Lógica en hooks/lib/etapa-auto-evolucion.js.",
       "blocking": false,
       "async": true,
       "maxConsecutiveFailures": 5,
@@ -374,14 +365,32 @@
       "maxConsecutiveFailures": 5,
       "degradeOnFailure": "skip"
     },
+    "tdd-gate.js": {
+      "event": "PreToolUse",
+      "matcher": "Bash",
+      "description": "Gate G2 (TDD): ante git commit de feature (fuente+tests staged) verifica evidencia de ciclo RED en .planning/loops/tdd-* (telemetria escrita por ejecutar-fase/tdd-workflow). Sin evidencia emite nudge kind:tdd-red-evidence (warn-only, NUNCA exit 2 en este modo). Solo aplica con fase activa (ciclo GSD); 'fuente sin tests' es dominio de G3 (sin doble nudge). Respeta opt-out declarado del CONTEXTO (**TDD**: off) y prefijos docs:/chore:/style:. Ventana de evidencia: 24h (SWL_TDD_GATE_VENTANA_H). Opt-out: SWL_TDD_GATE=0. Promocion a blocking via ADR-0035 (D-07).",
+      "blocking": false,
+      "async": false,
+      "maxConsecutiveFailures": 5,
+      "degradeOnFailure": "warn"
+    },
+    "spec-gate.js": {
+      "event": "PreToolUse",
+      "matcher": "Write|Edit|MultiEdit",
+      "description": "Gate G0 (SDD): detecta Write/Edit a codigo fuente sin fase activa con PLAN aprobado. Lee .planning/locks/fase-activa.json (escrito por /swl:aprobar-plan) y re-computa SHA256 del plan referenciado; sin fase activa o plan mutado emite nudge kind:spec-gate (warn-only, NUNCA exit 2 en este modo). Zero-config: sin .planning/ sale silencioso. Excluye tests/generados/docs (clasificador esArchivoFuente de calidad-pre-commit) y temp/, node_modules/, _userland/, respositorios-git/. Opt-out: SWL_SPEC_GATE=0. Promocion a blocking via ADR-0034 tras ~2 semanas de calibracion (D-07).",
+      "blocking": false,
+      "async": false,
+      "maxConsecutiveFailures": 5,
+      "degradeOnFailure": "warn"
+    },
     "validar-intent-spec.js": {
       "event": "PostToolUse",
       "matcher": "Write|Edit|MultiEdit",
-      "description": "Verifica que agentes nivelRiesgo:ALTO declaren las 6 partes del framework Intent Engineering (strategy, healthMetrics, steering, hardGuardrails, maxTurnos, fragmentos:[_intent-spec]) segun reglas/intent-engineering.md. Solo aplica a agentes/*.md no fragmentos. Emite nudge a .planning/evolution/nudges.jsonl si faltan campos. No bloquea (modo warn-only inicial; promocion a blocking:true tras 2 semanas estables). Excluye temp/, node_modules/, respositorios-git/, _userland/, .planning/. Opt-out: SWL_INTENT_SPEC=0. ADR-0027.",
-      "blocking": false,
-      "async": true,
+      "description": "Verifica que agentes nivelRiesgo:ALTO declaren las 6 partes del framework Intent Engineering (strategy, healthMetrics, steering, hardGuardrails, maxTurnos, fragmentos:[_intent-spec]) segun reglas/intent-engineering.md. Solo aplica a agentes/*.md no fragmentos. Emite nudge a .planning/evolution/nudges.jsonl y BLOQUEA (exit 2) si faltan campos. Excluye temp/, node_modules/, respositorios-git/, _userland/, .planning/. Opt-out: SWL_INTENT_SPEC=0. ADR-0027 (warn-only) -> ADR-0033 (blocking, 2026-06-11).",
+      "blocking": true,
+      "async": false,
       "maxConsecutiveFailures": 5,
-      "degradeOnFailure": "skip"
+      "degradeOnFailure": "warn"
     },
     "notificacion-telegram.js": {
       "event": "Stop",