@saulwade/swl-ses 1.9.0 → 2.1.0

package/scripts/lib/plan-lock.js

@@ -0,0 +1,275 @@
+'use strict';
+
+/**
+ * plan-lock.js — Firma y verificación de integridad de PLAN.md (Gate G1).
+ *
+ * Materializa el gate G1 del enforcement SDD (Fase 09, ADR de la Revisión
+ * Evolutiva 03): un PLAN aprobado vía `/swl:aprobar-plan` queda firmado con
+ * un SHA256 escrito en `.planning/locks/<basename>.lock`. `ejecutar-fase`
+ * recomputa ese hash al arrancar; un plan mutado tras la aprobación detiene
+ * la ejecución. Cierra el hueco "el plan puede mutar tras aprobación" que
+ * dejaba SDD en ~60%.
+ *
+ * Cláusula de gracia D-05 (compatibilidad legacy): un PLAN con
+ * `estado: aprobado` en su frontmatter pero SIN `.lock` correspondiente
+ * (los planes creados antes de la Fase 09) se considera `modo: "legacy"` y
+ * se ejecuta con advertencia, sin bloqueo. Solo los planes firmados vía
+ * `/swl:aprobar-plan` (post-Fase 09) exigen coincidencia de hash.
+ *
+ * MODELO DE AMENAZA (gate G1): el lock detecta MUTACIÓN ACCIDENTAL o no
+ * aprobada del PLAN tras su firma, y planes alterados por un agente que
+ * confabula. NO es un control criptográfico contra un adversario con acceso
+ * de escritura al repo — quien pueda commitear puede recalcular el SHA256 y
+ * re-firmar. La evidencia real de aprobación es `aprobadoPor:` + el commit del
+ * lock por `/swl:aprobar-plan` en el audit trail de git. El SHA256 solo detecta
+ * drift entre firma y verificación. (Verificación Fase 09, hallazgo S-6.)
+ *
+ * API:
+ *   firmarPlan(planPath, opciones?)  -> { ok, sha256, lockPath, archivo }
+ *   verificarPlan(planPath)          -> { ok, modo, motivo, ... }
+ *   resolverLockPath(planPath)       -> string (ruta del .lock esperado)
+ *
+ * Zero-dependencies. Compatible Windows (hash sobre buffer crudo). Node 18+.
+ *
+ * Origen: Fase 09 — enforcement SDD/TDD vNext H1, Slice 1.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+// Escritura atómica obligatoria (regla CLAUDE.md). Fallback defensivo idéntico
+// al de scripts/generar-skills-lock.js para no acoplar a un layout fijo.
+let atomicWriteSync;
+try {
+  ({ atomicWriteSync } = require(path.join(__dirname, '..', '..', 'hooks', 'lib', 'atomic-write.js')));
+} catch {
+  atomicWriteSync = (p, c, e) => {
+    const dir = path.dirname(p);
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(p, c, e);
+  };
+}
+
+const LOCK_VERSION = 1;
+
+// Basename válido de un PLAN de fase: `PLAN.md` o `0N-PLAN.md`. Evita que
+// `firmarPlan` produzca locks de archivos arbitrarios (falsearía el audit
+// trail de aprobación). Verificación Fase 09, hallazgo S-2.
+const PLAN_BASENAME_RE = /^(\d{2}-)?PLAN\.md$/;
+
+/**
+ * SHA256 de un buffer. Idéntico a scripts/generar-skills-lock.js:42-44.
+ * Se hashea el buffer crudo (no string utf8) para que el hash sea byte-exacto
+ * y detecte incluso cambios de fin de línea introducidos por un editor.
+ *
+ * @param {Buffer|string} data
+ * @returns {string} hex digest
+ */
+function sha256(data) {
+  return crypto.createHash('sha256').update(data).digest('hex');
+}
+
+/**
+ * Extrae el campo `estado:` del frontmatter YAML del PLAN.
+ * Reutiliza el patrón CRLF-safe de scripts/generar-skills-lock.js:46-55.
+ *
+ * @param {string} contenido
+ * @returns {string|null} valor de `estado` o null si no hay frontmatter/campo
+ */
+function leerEstado(contenido) {
+  const m = contenido.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n/);
+  if (!m) return null;
+  for (const linea of m[1].split(/\r?\n/)) {
+    const kv = linea.match(/^estado:\s*(.*)$/);
+    if (kv) return kv[1].trim();
+  }
+  return null;
+}
+
+/**
+ * Resuelve el directorio `.planning/locks/` ascendiendo desde el PLAN hasta
+ * encontrar el directorio `.planning` ancestro. Robusto ante planes en
+ * `.planning/fases/0N-PLAN.md` o `.planning/PLAN.md`.
+ *
+ * Hardening S-1 (verificación Fase 09):
+ *   - Resuelve symlinks con `fs.realpathSync` antes de ascender, para que un
+ *     symlink plantado (`temp/.planning` → `/etc/.planning`) no permita escapar
+ *     del árbol real del proyecto.
+ *   - SIN fallback ciego: si no hay `.planning` ancestro, retorna `null` (antes
+ *     escribía `locks/` al lado del PLAN, en ubicación arbitraria). El caller
+ *     trata `null` como error explícito.
+ *
+ * @param {string} planPath
+ * @returns {string|null} ruta absoluta del directorio de locks, o null si no
+ *   hay `.planning` ancestro.
+ */
+function resolverLocksDir(planPath) {
+  let dir;
+  try {
+    dir = path.dirname(fs.realpathSync(path.resolve(planPath)));
+  } catch {
+    dir = path.dirname(path.resolve(planPath));
+  }
+  while (dir !== path.dirname(dir)) {
+    if (path.basename(dir) === '.planning') {
+      return path.join(dir, 'locks');
+    }
+    dir = path.dirname(dir);
+  }
+  return null;
+}
+
+/**
+ * Ruta del `.lock` esperado para un PLAN dado.
+ *
+ * @param {string} planPath
+ * @returns {string|null} ruta absoluta del archivo `.lock`, o null si el PLAN
+ *   no tiene un `.planning` ancestro.
+ */
+function resolverLockPath(planPath) {
+  const dir = resolverLocksDir(planPath);
+  return dir ? path.join(dir, `${path.basename(planPath)}.lock`) : null;
+}
+
+/**
+ * Firma un PLAN: computa su SHA256 y escribe el `.lock` correspondiente.
+ * Idempotente — re-firmar sobreescribe el lock (caso re-aprobación).
+ *
+ * @param {string} planPath
+ * @param {object} [opciones]
+ * @param {string} [opciones.firmadoPor='swl:aprobar-plan']
+ * @param {string} [opciones.firmadoEn] ISO timestamp; default new Date()
+ * @returns {{ok: boolean, sha256?: string, lockPath?: string, archivo?: string, motivo?: string}}
+ */
+function firmarPlan(planPath, opciones = {}) {
+  if (!fs.existsSync(planPath)) {
+    return { ok: false, motivo: `PLAN no existe: ${planPath}` };
+  }
+  const archivo = path.basename(planPath);
+  if (!PLAN_BASENAME_RE.test(archivo)) {
+    return {
+      ok: false,
+      motivo: `basename inválido para firma: "${archivo}". Solo se firman PLAN.md o 0N-PLAN.md de fases.`,
+    };
+  }
+  const lockPath = resolverLockPath(planPath);
+  if (!lockPath) {
+    return {
+      ok: false,
+      motivo: `el PLAN no tiene un directorio .planning ancestro: ${planPath}`,
+    };
+  }
+  const buffer = fs.readFileSync(planPath);
+  const hash = sha256(buffer);
+
+  const lock = {
+    version: LOCK_VERSION,
+    archivo,
+    sha256: hash,
+    firmadoEn: opciones.firmadoEn || new Date().toISOString(),
+    firmadoPor: opciones.firmadoPor || 'swl:aprobar-plan',
+  };
+
+  atomicWriteSync(lockPath, `${JSON.stringify(lock, null, 2)}\n`, 'utf8');
+  return { ok: true, sha256: hash, lockPath, archivo };
+}
+
+/**
+ * Verifica la integridad de un PLAN contra su `.lock`.
+ *
+ * Modos de retorno:
+ *   - `firmado`     : existe lock y el hash coincide  -> ok: true
+ *   - `legacy`      : NO existe lock pero estado:aprobado (gracia D-05) -> ok: true
+ *   - `mutado`      : existe lock y el hash NO coincide -> ok: false
+ *   - `lock-corrupto`: el lock existe pero no es JSON válido -> ok: false
+ *   - `sin-firmar`  : NO existe lock y estado != aprobado -> ok: false
+ *   - `sin-planning`: el PLAN no tiene `.planning` ancestro -> ok: false
+ *   - `no-existe`   : el PLAN no existe en disco -> ok: false
+ *
+ * @param {string} planPath
+ * @returns {{ok: boolean, modo: string, motivo?: string, hashEsperado?: string, hashActual?: string, lockPath?: string}}
+ */
+function verificarPlan(planPath) {
+  if (!fs.existsSync(planPath)) {
+    return { ok: false, modo: 'no-existe', motivo: `PLAN no existe: ${planPath}` };
+  }
+  const lockPath = resolverLockPath(planPath);
+  if (!lockPath) {
+    return {
+      ok: false,
+      modo: 'sin-planning',
+      motivo: `el PLAN no tiene un directorio .planning ancestro: ${planPath}`,
+    };
+  }
+  const buffer = fs.readFileSync(planPath);
+  const hashActual = sha256(buffer);
+
+  if (!fs.existsSync(lockPath)) {
+    // Cláusula de gracia D-05: plan aprobado antes de que existiera el lock.
+    const estado = leerEstado(buffer.toString('utf8'));
+    if (estado === 'aprobado') {
+      return {
+        ok: true,
+        modo: 'legacy',
+        motivo: 'plan aprobado pre-Fase09 (sin lock); ejecutar con advertencia',
+        hashActual,
+        lockPath,
+      };
+    }
+    return {
+      ok: false,
+      modo: 'sin-firmar',
+      motivo: `plan sin aprobar y sin lock (estado: ${estado || 'ausente'})`,
+      hashActual,
+      lockPath,
+    };
+  }
+
+  let lock;
+  try {
+    lock = JSON.parse(fs.readFileSync(lockPath, 'utf8'));
+  } catch (err) {
+    return {
+      ok: false,
+      modo: 'lock-corrupto',
+      motivo: `lock malformado en ${lockPath}: ${err.message}`,
+      hashActual,
+      lockPath,
+    };
+  }
+
+  const hashEsperado = lock && typeof lock.sha256 === 'string' ? lock.sha256 : null;
+  if (!hashEsperado) {
+    return {
+      ok: false,
+      modo: 'lock-corrupto',
+      motivo: `lock sin campo sha256 en ${lockPath}`,
+      hashActual,
+      lockPath,
+    };
+  }
+
+  if (hashEsperado === hashActual) {
+    return { ok: true, modo: 'firmado', hashEsperado, hashActual, lockPath };
+  }
+
+  return {
+    ok: false,
+    modo: 'mutado',
+    motivo: 'plan mutado tras aprobación (el hash no coincide con el lock)',
+    hashEsperado,
+    hashActual,
+    lockPath,
+  };
+}
+
+module.exports = {
+  firmarPlan,
+  verificarPlan,
+  resolverLockPath,
+  resolverLocksDir,
+  sha256,
+  leerEstado,
+  LOCK_VERSION,
+};

package/scripts/migrar-fase-dominio.js

@@ -80,7 +80,6 @@ const MAPEO = {
   'revisor-typescript-swl': ['verify', 'quality'],
   'sre-swl': ['release', 'infra'],
   'tdd-qa-swl': ['verify', 'quality'],
-  'ux-disenador-swl': ['plan', 'ux'],
 };
 
 function migrarAgente(nombre) {

package/scripts/tui/ejecutores.js

@@ -47,7 +47,7 @@ function _calcularTotalesDelPlan(opciones) {
   // mediante resolverPerfil, que devuelve { perfil, modulos, archivos, warnings }.
   try {
     const { resolverPerfil } = require('../lib/manifiestos');
-    const resolucion = resolverPerfil(opciones.profile || 'core', {});
+    const resolucion = resolverPerfil(opciones.profile || 'completo', {});
     if (!resolucion || !Array.isArray(resolucion.archivos)) return {};
     const totales = {};
     for (const archivo of resolucion.archivos) {

package/scripts/validar-manifest.js

@@ -149,6 +149,88 @@ function verificarModulosReferenciadosPorPerfil(modulos, perfiles) {
   return false;
 }
 
+function fragmentosDeclaradosEnAgente(contenido) {
+  // Extrae los nombres de fragmento (_x) del frontmatter `fragmentos:` de un
+  // agente. Soporta lista multilínea (`fragmentos:\n  - _x`) e inline
+  // (`fragmentos: [_x, _y]`).
+  const fm = contenido.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!fm) return [];
+  const lineas = fm[1].split(/\r?\n/);
+  const out = [];
+  let dentro = false;
+  for (const l of lineas) {
+    const inline = l.match(/^fragmentos:\s*\[(.*)\]\s*$/);
+    if (inline) {
+      inline[1].split(',').forEach(s => { const t = s.trim(); if (t) out.push(t); });
+      dentro = false;
+      continue;
+    }
+    if (/^fragmentos:\s*$/.test(l)) { dentro = true; continue; }
+    if (dentro) {
+      const m = l.match(/^\s*-\s*(_[a-z][a-z0-9-]*)\s*$/);
+      if (m) { out.push(m[1]); continue; }
+      if (/^\S/.test(l)) dentro = false; // siguiente clave de primer nivel
+    }
+  }
+  return out;
+}
+
+function verificarFragmentos(declarados) {
+  // DT-FRAGMENTOS-VALIDACION (Fase 13): dos invariantes que la regla
+  // fragmentos-compartidos.md declara y que antes no se enforzaban:
+  //   1. Todo fragmento agentes/_*.md debe estar referenciado por ≥2 agentes.
+  //   2. Ningún fragmento agentes/_*.md debe aparecer en modulos.json (no es agente).
+  const base = path.join(RAIZ, 'agentes');
+  if (!fs.existsSync(base)) {
+    log('  [OK]    fragmentos: sin directorio agentes/ (nada que validar)');
+    return true;
+  }
+  const fragmentos = fs.readdirSync(base)
+    .filter(f => f.startsWith('_') && f.endsWith('.md'))
+    .map(f => f.replace(/\.md$/, '')); // '_propose-step'
+
+  // Contar referencias por fragmento en los agentes reales (no fragmentos).
+  const referencias = new Map(fragmentos.map(f => [f, 0]));
+  const agentes = fs.readdirSync(base)
+    .filter(f => f.endsWith('.md') && !f.startsWith('_'));
+  for (const ag of agentes) {
+    const refs = fragmentosDeclaradosEnAgente(fs.readFileSync(path.join(base, ag), 'utf-8'));
+    for (const r of refs) {
+      if (referencias.has(r)) referencias.set(r, referencias.get(r) + 1);
+    }
+  }
+
+  let ok = true;
+
+  // Check 1: ≥2 referencias.
+  const subreferenciados = fragmentos.filter(f => referencias.get(f) < 2);
+  if (subreferenciados.length === 0) {
+    log(`  [OK]    fragmentos: ${fragmentos.length}/${fragmentos.length} referenciados por ≥2 agentes`);
+  } else {
+    ok = false;
+    log(`  [FALLA] fragmentos: ${subreferenciados.length} referenciado(s) por <2 agentes`);
+    for (const f of subreferenciados) {
+      log(`          → agentes/${f}.md (referencias: ${referencias.get(f)})`);
+      errores.push({ categoria: 'fragmentos', archivo: `agentes/${f}.md`, tipo: 'fragmento_subreferenciado' });
+    }
+  }
+
+  // Check 2: no en modulos.json.
+  const enModulos = fragmentos.filter(f => declarados.has(`agentes/${f}.md`));
+  if (enModulos.length === 0) {
+    log('  [OK]    fragmentos: ninguno declarado como agente en modulos.json');
+  } else {
+    ok = false;
+    log(`  [FALLA] fragmentos: ${enModulos.length} declarado(s) en modulos.json (no son agentes)`);
+    for (const f of enModulos) {
+      log(`          → agentes/${f}.md`);
+      errores.push({ categoria: 'fragmentos', archivo: `agentes/${f}.md`, tipo: 'fragmento_en_modulos' });
+    }
+  }
+
+  return ok;
+}
+
 function verificarDeclarados1a1ExistenEnDisco(declarados) {
   // Caso inverso: declarados en manifest pero no presentes en disco
   const rotos = [];
@@ -205,6 +287,9 @@ function main() {
   const perfilOk = verificarModulosReferenciadosPorPerfil(modulos, perfiles);
   if (!perfilOk) todoOk = false;
 
+  const fragmentosOk = verificarFragmentos(declarados);
+  if (!fragmentosOk) todoOk = false;
+
   const inversoOk = verificarDeclarados1a1ExistenEnDisco(declarados);
   if (!inversoOk) todoOk = false;
 
@@ -219,6 +304,8 @@ function main() {
     log('  - "no_declarado_hooks_config": registrar el hook en manifiestos/hooks-config.json');
     log('  - "modulo_huerfano_sin_perfil": agregar el módulo al array `modulos` de al menos un perfil en manifiestos/perfiles.json');
     log('  - "declarado_no_existe": eliminar la ruta de modulos.json (archivo borrado) o crear el archivo');
+    log('  - "fragmento_subreferenciado": el fragmento agentes/_*.md debe ser usado por ≥2 agentes (declararlo en su frontmatter `fragmentos:`) o re-incrustarlo en el único agente que lo usa');
+    log('  - "fragmento_en_modulos": quitar el fragmento agentes/_*.md de modulos.json (no es un agente routable)');
   }
 
   if (salidaJson) {
@@ -228,4 +315,8 @@ function main() {
   process.exit(todoOk ? 0 : 1);
 }
 
-main();
+if (require.main === module) {
+  main();
+}
+
+module.exports = { fragmentosDeclaradosEnAgente };

package/scripts/verificar-evolucion.js

@@ -33,6 +33,26 @@ const fs = require('fs');
 const path = require('path');
 const { execSync } = require('child_process');
 
+/**
+ * Detecta si `dir` es la raíz del paquete swl-ses (repo madre).
+ *
+ * Espeja la excepción de `markAsEvolved` (hooks/lib/evolution-tracker.js):
+ * en el repo madre los cambios del mantenedor se rastrean por git + bump de
+ * `version`, NO por metadatos `evolved-*` — el tracker se NIEGA a marcarlos.
+ * Antes de este fix, los CHECKs 2/3 exigían aquí lo que el tracker rechaza
+ * escribir → el gate del Paso 6 de /swl:aprender era insatisfacible en el
+ * repo madre (detectado 2026-06-12, aprendizaje M4). El set de nombres debe
+ * mantenerse alineado con `isPackageRoot` del tracker.
+ */
+function esRaizDelPaquete(dir) {
+  try {
+    const pkg = JSON.parse(fs.readFileSync(path.join(dir || process.cwd(), 'package.json'), 'utf8'));
+    return pkg.name === '@saulwade/swl-ses' || pkg.name === 'swl-ses';
+  } catch {
+    return false;
+  }
+}
+
 /** Extrae el bloque de frontmatter YAML del inicio del archivo. */
 function extraerFrontmatter(contenido) {
   const m = /^---\r?\n([\s\S]*?)\r?\n---/.exec(contenido);
@@ -132,8 +152,16 @@ function archivosModificados(since) {
   }
 }
 
-/** Verifica un archivo concreto. Devuelve `{ archivo, problemas[], info }`. */
-function verificarArchivo(filePath) {
+/**
+ * Verifica un archivo concreto. Devuelve `{ archivo, problemas[], info }`.
+ * @param {object} [opts] - `opts.raizPaquete` fuerza/inyecta la detección de
+ *   repo madre (default: `esRaizDelPaquete(process.cwd())`). En repo madre los
+ *   CHECKs 2/3 (evolved) se omiten — solo aplican version presente + bump.
+ */
+function verificarArchivo(filePath, opts = {}) {
+  const raizPaquete = opts.raizPaquete !== undefined
+    ? opts.raizPaquete
+    : esRaizDelPaquete(process.cwd());
   const resultado = { archivo: filePath, problemas: [], info: {} };
 
   if (!fs.existsSync(filePath)) {
@@ -186,7 +214,15 @@ function verificarArchivo(filePath) {
   // CHECK 2: evolved = true (en frontmatter o en .evolved.json)
   // v1.6.1 (Cabo A4): exento si deprecated:true — no tiene sentido exigir
   // metadatos de evolución para componentes que se van a eliminar.
-  if (ev.evolved !== 'true' && !esDeprecated) {
+  // Exento también en el repo madre: markAsEvolved se NIEGA a marcar ahí
+  // (los cambios del mantenedor se rastrean por git + bump de version), así
+  // que exigirlo haría el gate insatisfacible. Ver esRaizDelPaquete().
+  if (raizPaquete) {
+    resultado.info.notas = resultado.info.notas || [];
+    resultado.info.notas.push(
+      'raíz del paquete: checks evolved omitidos (cambios del mantenedor = git + bump)'
+    );
+  } else if (ev.evolved !== 'true' && !esDeprecated) {
     resultado.problemas.push(
       '`evolved` no encontrado (ni en frontmatter ni en .evolved.json del directorio)'
     );
@@ -284,6 +320,13 @@ function main() {
     archivos = args.filter(a => !a.startsWith('--'));
   }
 
+  if (esRaizDelPaquete(process.cwd())) {
+    process.stdout.write(
+      '[nota] Raíz del paquete swl-ses: los checks de `evolved` se omiten — ' +
+      'los cambios del mantenedor se rastrean por git + bump de `version`.\n'
+    );
+  }
+
   let fallos = 0;
   for (const archivo of archivos) {
     const r = verificarArchivo(archivo);
@@ -302,4 +345,11 @@ function main() {
 
 if (require.main === module) main();
 
-module.exports = { verificarArchivo, extraerFrontmatter, leerCampo, obtenerVersionEnHEAD, main };
+module.exports = {
+  verificarArchivo,
+  extraerFrontmatter,
+  leerCampo,
+  obtenerVersionEnHEAD,
+  esRaizDelPaquete,
+  main,
+};

package/scripts/verificar-release.js

@@ -32,6 +32,10 @@
 const fs = require('fs');
 const path = require('path');
 const contadoresLib = require('./lib/contadores-inventario');
+// Gate de licencias (Fase 14, ADR-0038) — WARN-ONLY: reporta copyleft pero
+// NUNCA bloquea el release en v1 (D-14-02). Cargado como módulo, no subproceso.
+const { evaluarLicencias } = require('./lib/gate-licencias');
+const { evaluarHooksRequires } = require('./lib/gate-hooks-requires');
 
 const CWD = process.cwd();
 
@@ -272,6 +276,18 @@ function main() {
     fallasObligatorias++;
   }
 
+  // Gate de requires hooks→scripts: valida que toda lib de scripts/ requerida
+  // por un hook DISTRIBUIDO (incluidas dependencias transitivas) esté registrada
+  // en modulos.json y cubierta en todos los perfiles que instalan el hook.
+  // Bloqueante: sin esto el hook muere con MODULE_NOT_FOUND en el destino y el
+  // wrapper de settings.json lo traga en silencio. Origen: bug check-update —
+  // el aviso de nuevas versiones nunca llegó a instalaciones destino (2026-06-12,
+  // commit 12b2a31). Misma familia que el gate de bin-imports, eje instalador→destino.
+  const gateHooksRequires = ejecutarGateHooksRequires();
+  if (gateHooksRequires.disponible && gateHooksRequires.hallazgos.length > 0) {
+    fallasObligatorias++;
+  }
+
   // Gate de consistencia cross-manifest del campo description:
   // valida que package.json#description y plugin.json#description tengan
   // las mismas cifras (60 agentes / N habilidades / M comandos / K reglas / L hooks)
@@ -295,6 +311,12 @@ function main() {
     }
   }
 
+  // Gate de licencias (Fase 14, ADR-0038) — WARN-ONLY por diseño (D-14-02):
+  // clasifica el árbol prod (copyleft fuerte/débil, desconocida) pero NUNCA
+  // suma a fallasObligatorias. Solo informa; la promoción a blocking exigiría
+  // calibración + ADR posterior (mismo patrón que G0/G2/G3).
+  const gateLicencias = ejecutarGateLicencias();
+
   if (jsonOut) {
     process.stdout.write(JSON.stringify({
       version,
@@ -304,8 +326,10 @@ function main() {
       warnings_opcionales: warningsOpcionales,
       contadores_gate: gateContadores,
       bin_imports_gate: gateBinImports,
+      hooks_requires_gate: gateHooksRequires,
       description_gate: gateDescription,
       aiisms_gate: aiismsGate,
+      gate_licencias: gateLicencias,
       resultados: resultados.map(({ entrada, resultado }) => ({
         archivo: entrada.archivo,
         obligatorio: entrada.obligatorio,
@@ -378,6 +402,28 @@ function main() {
       process.stdout.write('\n');
       process.stdout.write('Gate de bin-imports: no disponible — ' + gateBinImports.error + '\n');
     }
+    if (gateHooksRequires.disponible) {
+      process.stdout.write('\n');
+      process.stdout.write('Gate de requires hooks→scripts (vs modulos.json + perfiles.json):\n');
+      process.stdout.write(
+        '  Hooks distribuidos analizados: ' + gateHooksRequires.hooksDistribuidos +
+        ' | dependencias hooks→scripts: ' + gateHooksRequires.dependencias.length + '\n'
+      );
+      if (gateHooksRequires.hallazgos.length === 0) {
+        process.stdout.write('  [OK] Toda lib de scripts/ requerida por hooks distribuidos está registrada y cubierta\n');
+      } else {
+        for (const h of gateHooksRequires.hallazgos) {
+          process.stdout.write('  [FALLA] [' + h.tipo + '] ' + h.detalle + '\n');
+        }
+        process.stdout.write(
+          '  Bloqueo: registra la lib (y sus transitivas) en el módulo del hook en modulos.json. ' +
+          'Sin esto el hook muere en silencio en el destino (wrapper traga MODULE_NOT_FOUND).\n'
+        );
+      }
+    } else if (gateHooksRequires.error) {
+      process.stdout.write('\n');
+      process.stdout.write('Gate de hooks-requires: no disponible — ' + gateHooksRequires.error + '\n');
+    }
     if (gateDescription.disponible) {
       process.stdout.write('\n');
       process.stdout.write('Gate de description (package.json vs plugin.json vs INVENTARIO.md):\n');
@@ -420,6 +466,29 @@ function main() {
         );
       }
     }
+    if (gateLicencias.disponible) {
+      process.stdout.write('\n');
+      process.stdout.write('Gate de licencias (árbol prod — WARN-ONLY, no bloquea):\n');
+      const r = gateLicencias.resumen;
+      process.stdout.write(
+        '  permisiva: ' + r.permisiva + ' | débil: ' + r.debil +
+        ' | fuerte: ' + r.fuerte + ' | desconocida: ' + r.desconocida + '\n'
+      );
+      const alertas = gateLicencias.hallazgos.filter((h) => h.clasificacion !== 'permisiva');
+      if (alertas.length > 0) {
+        for (const h of alertas) {
+          process.stdout.write(
+            '  [WARN ' + h.clasificacion + '] ' + h.paquete + '@' + h.version + ' — ' + h.licencia + '\n'
+          );
+        }
+        process.stdout.write('  Aviso: licencias no permisivas detectadas (informativo, no bloquea el release).\n');
+      } else {
+        process.stdout.write('  [OK] Todas las dependencias de producción son permisivas.\n');
+      }
+    } else if (gateLicencias.error) {
+      process.stdout.write('\n');
+      process.stdout.write('Gate de licencias: no disponible — ' + gateLicencias.error + '\n');
+    }
     if (fallasObligatorias > 0) {
       process.stdout.write('\n');
       process.stdout.write('Corrige los archivos marcados como FALLA antes de hacer push o publicar.\n');
@@ -583,6 +652,18 @@ function ejecutarGateBinImports() {
   }
 }
 
+/**
+ * Gate de requires hooks→scripts (lib: scripts/lib/gate-hooks-requires.js).
+ * Bloqueante. Ver comentario en el flujo principal.
+ */
+function ejecutarGateHooksRequires() {
+  try {
+    return evaluarHooksRequires(CWD);
+  } catch (err) {
+    return { disponible: false, error: err.message };
+  }
+}
+
 function ejecutarGateAiisms() {
   const { spawnSync } = require('child_process');
   const detector = path.join(CWD, 'habilidades', 'estilo-sin-ai-isms', 'scripts', 'detectar_aiisms.py');
@@ -795,6 +876,26 @@ function ejecutarGateDescription(contadoresReales) {
   };
 }
 
+/**
+ * Gate de licencias (Fase 14, ADR-0038) — WARN-ONLY.
+ *
+ * Clasifica las licencias del árbol de producción (vía scripts/lib/gate-licencias)
+ * y devuelve el resumen para impresión. NO bloquea el release: el caller NUNCA
+ * suma este resultado a fallasObligatorias (D-14-02, calibración primero).
+ *
+ * @param {string} [baseDir=CWD] raíz del proyecto a evaluar (parametrizable
+ *   para tests; en producción usa el CWD del proceso).
+ * @returns {{disponible: boolean, hallazgos?: Array, resumen?: object, error?: string}}
+ */
+function ejecutarGateLicencias(baseDir = CWD) {
+  try {
+    const { hallazgos, resumen } = evaluarLicencias(baseDir);
+    return { disponible: true, hallazgos, resumen };
+  } catch (err) {
+    return { disponible: false, error: err.message };
+  }
+}
+
 if (require.main === module) main();
 
 module.exports = {
@@ -803,4 +904,5 @@ module.exports = {
   versionObjetivo,
   extraerCifrasDescription,
   ejecutarGateDescription,
+  ejecutarGateLicencias,
 };