@saulwade/swl-ses 1.9.0 → 2.1.0

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/telemetria-skill-routing.js

@@ -0,0 +1,100 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Hook: telemetria-skill-routing.js
+ * Tipo: PostToolUse (matcher: "Skill")
+ *
+ * Cablea la lib huérfana `scripts/lib/skill-metrics.js`: por cada invocación
+ * del tool Skill registra la frecuencia/estado en `.planning/skill-metrics.json`
+ * vía `registrarUso(cwd, skillName, estado, duracionMs)`.
+ *
+ * Propósito (Revisión Evolutiva 04, P-2 "bloat y precisión de routing"):
+ * acumular telemetría de qué skills se invocan para alimentar la futura
+ * auditoría de bloat (skills muertos / solapados). Es la instrumentación que
+ * el roadmap permite adelantar como "tarea suelta" antes de la fase de auditoría.
+ *
+ * Distinto de telemetria-agentes.js (spans OTLP a traces/) y de audit-trail.js
+ * (todos los tool calls a audit.jsonl): este hook produce el agregado por-skill
+ * que la auditoría de bloat necesita y que ningún otro hook genera.
+ *
+ * NUNCA bloquea (siempre exit 0). Async: corre en background.
+ * Opt-out: SWL_SKILL_TELEMETRIA=0.
+ *
+ * Origen: punto P-2 de la Revisión Evolutiva 04 (instrumentación adelantada).
+ */
+
+/**
+ * Extrae el evento de skill de un payload PostToolUse.
+ * Pura y testeable — no toca el filesystem.
+ *
+ * @param {object} data  payload PostToolUse
+ * @returns {{skillName: string, estado: 'ok'|'error'}|null} null si no aplica
+ */
+function extraerEvento(data) {
+  if (!data || typeof data !== 'object') return null;
+  const toolName = String(data.tool_name || (data.tool && data.tool.name) || '');
+  if (toolName !== 'Skill') return null;
+
+  const input = data.tool_input || {};
+  const skillName = String(input.skill || input.name || '').trim();
+  if (!skillName) return null;
+
+  const esError = Boolean(data.error_message || data.error);
+  return { skillName, estado: esError ? 'error' : 'ok' };
+}
+
+/**
+ * Carga defensiva de la lib de métricas. Si no está disponible (destino
+ * aplanado, instalación parcial), retorna null y el hook degrada en silencio.
+ * @returns {Function|null} registrarUso o null
+ */
+function cargarRegistrar() {
+  try {
+    return require('../scripts/lib/skill-metrics').registrarUso;
+  } catch (_) {
+    try {
+      return require('./lib/skill-metrics').registrarUso;
+    } catch (_2) {
+      return null;
+    }
+  }
+}
+
+/**
+ * Procesa un payload y registra el uso del skill si aplica.
+ * @param {object} data  payload PostToolUse
+ * @param {string} cwd   directorio del proyecto
+ * @param {Function} [registrar]  inyectable para tests; default carga skill-metrics
+ * @returns {boolean} true si registró
+ */
+function procesar(data, cwd, registrar) {
+  const evento = extraerEvento(data);
+  if (!evento) return false;
+  const fn = registrar || cargarRegistrar();
+  if (!fn) return false;
+  fn(cwd, evento.skillName, evento.estado, 0);
+  return true;
+}
+
+module.exports = { extraerEvento, procesar };
+
+// --- Entrypoint -------------------------------------------------------------
+// Claude Code invoca el hook vía `node -e "require('./hooks/...')"`, donde
+// `require.main` es undefined. Adjuntar stdin SOLO en ese caso (o invocación
+// directa), nunca cuando un test requiere el módulo (ahí require.main es el
+// runner, definido y ≠ este módulo) — así los tests no cuelgan en stdin.
+if (!require.main || require.main === module) {
+  // Opt-out: no adjuntar el listener (sin process.exit, seguro de requerir).
+  if (process.env.SWL_SKILL_TELEMETRIA !== '0') {
+    let inputRaw = '';
+    process.stdin.on('data', (chunk) => { inputRaw += chunk; });
+    process.stdin.on('end', () => {
+      try {
+        procesar(JSON.parse(inputRaw), process.cwd());
+      } catch (_) {
+        // Silencioso — nunca interrumpir la sesión por un fallo de telemetría.
+      }
+    });
+  }
+}

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/instintos/autonomia.yaml

@@ -0,0 +1,27 @@
+# Dial de autonomía — SWL-SES (Fase 13, ADR-0037)
+#
+# Presupuesto de autonomía por clase de riesgo. Consumido por hooks/lib/autonomia.js
+# (orquestador y agentes ALTO leen el dial como GUÍA; no es un gate bloqueante en v1).
+#
+# Defaults = los controles vigentes de reglas/seguridad-agentes.md. Este archivo
+# NO relaja ningún control: lo hace visible y ajustable. El dial sube SOLO por
+# decisión explícita del usuario, nunca por conveniencia del agente.
+#
+# Niveles válidos por clase:
+#   total                -> acción autónoma sin checkpoint (lectura/análisis).
+#   con_auto_checkpoint  -> autónoma, pero registra un auto-checkpoint antes de actuar.
+#   hitl                 -> requiere confirmación humana siempre.
+# Cualquier valor desconocido se degrada a 'hitl' (nunca relaja).
+#
+# Estructura PLANA obligatoria (1 nivel bajo `clases:`) — ver 13-PLAN.md.
+
+version: "1.0"
+generado: "2026-06-11"
+defaults: seguridad-agentes.md
+clases:
+  lectura_analisis: total
+  # Subido a `total` por decisión explícita del usuario (2026-06-11, cierre Fase 13):
+  # cambios reversibles autónomos sin auto-checkpoint. Los commits atómicos siguen
+  # siendo el mecanismo de rollback. Default de seguridad-agentes.md era con_auto_checkpoint.
+  cambio_reversible: total
+  migracion_auth_push_publish: hitl

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, 44 comandos, 37 reglas base y 48 hooks. Soporta 11 lenguajes y 7 runtimes (Claude Code, OpenClaude, OpenCode, Gemini, Cursor, Codex, Copilot). Versión 2.1.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)
+- 44 comandos `/swl:*` en `comandos/swl/` (ciclo GSD, calidad, release, diagnóstico)
+- 37 reglas base + 40 reglas por lenguaje en `reglas/` (políticas obligatorias por matcher)
+- 48 hooks en `hooks/` (telemetría, validación, seguridad; zero-deps, escrituras atómicas)
 
 ## Opcional