@saulwade/swl-ses 1.0.0

package/hooks/lib/resource-quota.js

@@ -0,0 +1,122 @@
+'use strict';
+
+/**
+ * Resource Quota — Control de consumo por ventana temporal.
+ *
+ * Adoptado de OpenFang (crates/openfang-kernel/src/metering.rs).
+ * Implementa quotas rolling por hora, dia y mes para tokens y costo USD.
+ *
+ * Zero dependencias externas.
+ *
+ * Uso:
+ *   const { quota } = require('./lib/resource-quota');
+ *   quota.registrar({ tokens: 1500, costoUsd: 0.005, agente: 'implementador-swl' });
+ *   const check = quota.verificar();
+ *   if (check.excedido) console.log(check.mensaje);
+ *
+ * @module hooks/lib/resource-quota
+ */
+
+const DEFAULTS = {
+  maxTokensPorHora:   200000,
+  maxCostoPorHoraUsd: 2.00,
+  maxCostoPorDiaUsd:  10.00,
+  maxCostoPorMesUsd:  100.00,
+  alertAt:            0.80,
+};
+
+const _registros = [];
+const MAX_REGISTROS = 10000;
+
+function _ahora() { return Date.now(); }
+function _haceUnaHora() { return _ahora() - 3600000; }
+function _haceUnDia() { return _ahora() - 86400000; }
+function _haceUnMes() { return _ahora() - 2592000000; }
+
+const quota = {
+  configurar(opciones) {
+    Object.assign(DEFAULTS, opciones);
+  },
+
+  registrar(datos) {
+    _registros.push({
+      tokens: datos.tokens || 0,
+      costoUsd: datos.costoUsd || 0,
+      agente: datos.agente || 'desconocido',
+      timestamp: _ahora(),
+    });
+    if (_registros.length > MAX_REGISTROS) {
+      _registros.splice(0, _registros.length - MAX_REGISTROS);
+    }
+  },
+
+  _sumarVentana(desdeMs) {
+    let tokens = 0, costo = 0;
+    for (let i = _registros.length - 1; i >= 0; i--) {
+      const r = _registros[i];
+      if (r.timestamp < desdeMs) break;
+      tokens += r.tokens;
+      costo += r.costoUsd;
+    }
+    return { tokens, costo };
+  },
+
+  verificar() {
+    const hora = this._sumarVentana(_haceUnaHora());
+    const dia  = this._sumarVentana(_haceUnDia());
+    const mes  = this._sumarVentana(_haceUnMes());
+
+    const violations = [];
+
+    if (hora.tokens >= DEFAULTS.maxTokensPorHora) {
+      violations.push({ tipo: 'tokens_hora', valor: hora.tokens, limite: DEFAULTS.maxTokensPorHora });
+    }
+    if (hora.costo >= DEFAULTS.maxCostoPorHoraUsd) {
+      violations.push({ tipo: 'costo_hora', valor: hora.costo, limite: DEFAULTS.maxCostoPorHoraUsd });
+    }
+    if (dia.costo >= DEFAULTS.maxCostoPorDiaUsd) {
+      violations.push({ tipo: 'costo_dia', valor: dia.costo, limite: DEFAULTS.maxCostoPorDiaUsd });
+    }
+    if (mes.costo >= DEFAULTS.maxCostoPorMesUsd) {
+      violations.push({ tipo: 'costo_mes', valor: mes.costo, limite: DEFAULTS.maxCostoPorMesUsd });
+    }
+
+    const warnings = [];
+    const alertThreshold = DEFAULTS.alertAt;
+
+    if (hora.costo >= DEFAULTS.maxCostoPorHoraUsd * alertThreshold && !violations.find(v => v.tipo === 'costo_hora')) {
+      warnings.push({ tipo: 'costo_hora', valor: hora.costo, limite: DEFAULTS.maxCostoPorHoraUsd, pct: Math.round(hora.costo / DEFAULTS.maxCostoPorHoraUsd * 100) });
+    }
+    if (dia.costo >= DEFAULTS.maxCostoPorDiaUsd * alertThreshold && !violations.find(v => v.tipo === 'costo_dia')) {
+      warnings.push({ tipo: 'costo_dia', valor: dia.costo, limite: DEFAULTS.maxCostoPorDiaUsd, pct: Math.round(dia.costo / DEFAULTS.maxCostoPorDiaUsd * 100) });
+    }
+
+    return {
+      excedido: violations.length > 0,
+      violations,
+      warnings,
+      consumo: { hora, dia, mes },
+      mensaje: violations.length > 0
+        ? 'Quota excedida: ' + violations.map(v => v.tipo + ' (' + v.valor.toFixed(2) + '/' + v.limite + ')').join(', ')
+        : warnings.length > 0
+          ? 'Alerta: ' + warnings.map(w => w.tipo + ' al ' + w.pct + '%').join(', ')
+          : 'Dentro de quota',
+    };
+  },
+
+  resumen() {
+    const hora = this._sumarVentana(_haceUnaHora());
+    const dia  = this._sumarVentana(_haceUnDia());
+    const mes  = this._sumarVentana(_haceUnMes());
+    return {
+      hora: { tokens: hora.tokens, costoUsd: Math.round(hora.costo * 10000) / 10000 },
+      dia:  { tokens: dia.tokens,  costoUsd: Math.round(dia.costo * 10000) / 10000 },
+      mes:  { tokens: mes.tokens,  costoUsd: Math.round(mes.costo * 10000) / 10000 },
+      registros: _registros.length,
+    };
+  },
+
+  reset() { _registros.length = 0; },
+};
+
+module.exports = { quota, DEFAULTS };

package/hooks/lib/retry-jitter.js

@@ -0,0 +1,165 @@
+'use strict';
+
+/**
+ * Retry con Jitter Decorrelado — Backoff exponencial con decorrelación.
+ *
+ * Patrón adoptado de Hermes Agent (agent/retry_utils.py).
+ * Usa seed basado en time + counter con golden ratio para decorrelación
+ * entre sesiones concurrentes — evita thundering herd.
+ *
+ * Zero dependencias externas — usa crypto nativo de Node.js.
+ *
+ * Uso:
+ *   const { jitteredBackoff, crearRetrier } = require('./lib/retry-jitter');
+ *
+ *   // Calcular delay para un intento específico
+ *   const delay = jitteredBackoff(2, { baseDelay: 5, maxDelay: 120 });
+ *
+ *   // Usar retrier completo
+ *   const retrier = crearRetrier({ maxIntentos: 3, baseDelay: 5 });
+ *   const resultado = await retrier.ejecutar(async () => {
+ *     return await llamadaAPI();
+ *   });
+ *
+ * @module hooks/lib/retry-jitter
+ */
+
+const crypto = require('crypto');
+
+// ---------------------------------------------------------------------------
+// Constantes
+// ---------------------------------------------------------------------------
+
+/** Golden ratio × 2^32 — constante de dispersión de Fibonacci hashing. */
+const GOLDEN_RATIO_32 = 0x9E3779B9;
+
+/** Contador global para decorrelación entre llamadas concurrentes. */
+let _jitterCounter = 0;
+
+// ---------------------------------------------------------------------------
+// Funciones core
+// ---------------------------------------------------------------------------
+
+/**
+ * Calcula delay con backoff exponencial + jitter decorrelado.
+ *
+ * Delay = min(base × 2^(intento-1), maxDelay) + jitter
+ * Jitter = random(0, jitterRatio × delay)
+ *
+ * El seed para el random combina timestamp con un contador global
+ * multiplicado por la constante golden ratio, lo que garantiza
+ * que llamadas concurrentes desde diferentes hilos/procesos
+ * NO coincidan en el mismo delay.
+ *
+ * @param {number} intento      - Número de intento (1-indexed)
+ * @param {object} [opciones]
+ * @param {number} [opciones.baseDelay=5]     - Delay base en segundos
+ * @param {number} [opciones.maxDelay=120]    - Delay máximo en segundos
+ * @param {number} [opciones.jitterRatio=0.5] - Proporción de jitter (0-1)
+ * @returns {number} Delay en segundos (con decimales)
+ */
+function jitteredBackoff(intento, opciones = {}) {
+  const {
+    baseDelay = 5,
+    maxDelay = 120,
+    jitterRatio = 0.5,
+  } = opciones;
+
+  _jitterCounter += 1;
+  const tick = _jitterCounter;
+
+  // Backoff exponencial acotado
+  const exponente = Math.max(0, intento - 1);
+  const delay = Math.min(baseDelay * Math.pow(2, exponente), maxDelay);
+
+  // Seed decorrelado: timestamp XOR (counter × golden_ratio)
+  const nowNs = BigInt(Date.now()) * 1_000_000n; // ms → pseudo-ns
+  const seed = Number((nowNs ^ BigInt(tick * GOLDEN_RATIO_32)) & 0xFFFFFFFFn);
+
+  // PRNG determinista basado en seed (sin crypto para velocidad)
+  const hash = crypto.createHash('md5').update(String(seed)).digest();
+  const pseudoRandom = hash.readUInt32LE(0) / 0xFFFFFFFF;
+
+  const jitter = pseudoRandom * jitterRatio * delay;
+
+  return delay + jitter;
+}
+
+/**
+ * Espera un número de segundos (para uso con async/await).
+ *
+ * @param {number} segundos
+ * @returns {Promise<void>}
+ */
+function esperar(segundos) {
+  return new Promise(resolve => setTimeout(resolve, Math.round(segundos * 1000)));
+}
+
+/**
+ * Crea un retrier configurable con jitter decorrelado.
+ *
+ * @param {object} [opciones]
+ * @param {number} [opciones.maxIntentos=3]    - Máximo de intentos
+ * @param {number} [opciones.baseDelay=5]      - Delay base en segundos
+ * @param {number} [opciones.maxDelay=120]     - Delay máximo en segundos
+ * @param {number} [opciones.jitterRatio=0.5]  - Proporción de jitter
+ * @param {Function} [opciones.esRetryable]    - Función que determina si un error es retryable
+ * @param {Function} [opciones.onReintento]    - Callback antes de cada reintento
+ * @returns {object} Retrier con método ejecutar()
+ */
+function crearRetrier(opciones = {}) {
+  const {
+    maxIntentos = 3,
+    baseDelay = 5,
+    maxDelay = 120,
+    jitterRatio = 0.5,
+    esRetryable = () => true,
+    onReintento = null,
+  } = opciones;
+
+  return {
+    /**
+     * Ejecuta una función con reintentos automáticos.
+     *
+     * @template T
+     * @param {() => Promise<T>} fn - Función async a ejecutar
+     * @returns {Promise<T>} Resultado de la función
+     * @throws {Error} Error del último intento si todos fallan
+     */
+    async ejecutar(fn) {
+      let ultimoError;
+
+      for (let intento = 1; intento <= maxIntentos; intento++) {
+        try {
+          return await fn();
+        } catch (error) {
+          ultimoError = error;
+
+          if (intento >= maxIntentos || !esRetryable(error)) {
+            throw error;
+          }
+
+          const delay = jitteredBackoff(intento, { baseDelay, maxDelay, jitterRatio });
+
+          if (onReintento) {
+            onReintento({ intento, maxIntentos, delay, error });
+          }
+
+          await esperar(delay);
+        }
+      }
+
+      throw ultimoError;
+    },
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Exports
+// ---------------------------------------------------------------------------
+
+module.exports = {
+  jitteredBackoff,
+  esperar,
+  crearRetrier,
+};

package/hooks/lib/risk-engine.js

@@ -0,0 +1,368 @@
+'use strict';
+
+/**
+ * lib/risk-engine.js
+ * Motor de scoring de riesgo compuesto para operaciones de Claude Code.
+ *
+ * Calcula un score normalizado [0.0 - 1.0] evaluando cada tool call en 4 ejes:
+ *
+ *   Score = min(1.0, baseRisk + fileSensitivity + blastRadius + irreversibility)
+ *
+ * Ejes de evaluación:
+ *
+ *   1. Base Tool Risk     — riesgo intrínseco por tipo de herramienta
+ *   2. File Sensitivity   — sensibilidad del archivo objetivo (Write/Edit/Read)
+ *   3. Blast Radius       — alcance del impacto del comando (Bash)
+ *   4. Irreversibility    — dificultad de deshacer la operación (Bash)
+ *
+ * API pública:
+ *   calcularRiskScore(toolName, toolInput) → { score, level, factors }
+ *   UMBRALES_DEFAULT                       → { allow, review, confirm }
+ *
+ * Niveles de decisión:
+ *   'allow'   — score < umbral allow   → operación segura, no intervenir
+ *   'review'  — score < umbral review  → advertencia en stderr, continuar
+ *   'confirm' — score < umbral confirm → solicitar confirmación explícita
+ *   'block'   — score >= umbral confirm → bloquear operación
+ */
+
+// ---------------------------------------------------------------------------
+// Umbrales de decisión
+// ---------------------------------------------------------------------------
+
+/**
+ * Umbrales por defecto para clasificar el nivel de riesgo.
+ * Un score igual o superior al umbral activa ese nivel.
+ *
+ *   allow   [0.00 – 0.35) → operación normal
+ *   review  [0.35 – 0.60) → advertencia
+ *   confirm [0.60 – 0.85) → requiere confirmación
+ *   block   [0.85 – 1.00] → bloqueo automático
+ */
+const UMBRALES_DEFAULT = {
+  allow:   0.35,
+  review:  0.60,
+  confirm: 0.85,
+};
+
+// ---------------------------------------------------------------------------
+// Eje 1 — Base Tool Risk
+// ---------------------------------------------------------------------------
+
+/**
+ * Riesgo base asignado a cada herramienta por su naturaleza.
+ * El mapa cubre las herramientas conocidas de Claude Code; las no listadas
+ * reciben el valor 'otros'.
+ */
+const BASE_TOOL_RISK = {
+  Bash:         0.20,
+  Write:        0.15,
+  Edit:         0.10,
+  NotebookEdit: 0.10,
+  Read:         0.02,
+  Grep:         0.02,
+  Glob:         0.02,
+  Agent:        0.05,
+  // valor para herramientas no reconocidas
+  _otros:       0.03,
+};
+
+/**
+ * Retorna el riesgo base para un nombre de herramienta dado.
+ *
+ * @param {string} toolName
+ * @returns {number}
+ */
+function obtenerRiesgoBase(toolName) {
+  return BASE_TOOL_RISK[toolName] ?? BASE_TOOL_RISK._otros;
+}
+
+// ---------------------------------------------------------------------------
+// Eje 2 — File Sensitivity
+// ---------------------------------------------------------------------------
+
+/**
+ * Patrones de alta sensibilidad: contienen secretos, claves o configuración
+ * crítica de seguridad. Contribución: +0.25
+ */
+const PATRONES_ALTA_SENSIBILIDAD = [
+  /\.env\b/i,
+  /secret/i,
+  /credential/i,
+  /\btoken\b/i,
+  /\.pem$/i,
+  /id_rsa/i,
+  /\.key$/i,
+  /password/i,
+  /\.pfx$/i,
+  /\.p12$/i,
+];
+
+/**
+ * Patrones de sensibilidad media: manifiestos de dependencias, configuración
+ * de infraestructura, esquemas de BD o pipelines de CI/CD. Contribución: +0.15
+ */
+const PATRONES_MEDIA_SENSIBILIDAD = [
+  /package\.json$/i,
+  /Cargo\.toml$/i,
+  /go\.mod$/i,
+  /pom\.xml$/i,
+  /\.csproj$/i,
+  /Dockerfile/i,
+  /docker-compose/i,
+  /\.github[/\\]workflows/i,
+  /schema/i,
+  /migration/i,
+  /production/i,
+  /Makefile$/i,
+  /\.tf$/i,
+  /\.tfvars$/i,
+];
+
+/**
+ * Calcula el delta de sensibilidad del archivo para operaciones que reciben
+ * un file_path en su toolInput (Write, Edit, Read).
+ *
+ * @param {string} toolName
+ * @param {object} toolInput
+ * @returns {{ delta: number, factor: string|null }}
+ */
+function calcularFileSensitivity(toolName, toolInput) {
+  // Solo aplica a herramientas que operan sobre archivos
+  if (!['Write', 'Edit', 'Read'].includes(toolName)) {
+    return { delta: 0, factor: null };
+  }
+
+  const filePath = String(toolInput.file_path || toolInput.path || '');
+  if (!filePath) return { delta: 0, factor: null };
+
+  // Prioridad alta sobre media: verificar en orden descendente de severidad
+  for (const patron of PATRONES_ALTA_SENSIBILIDAD) {
+    if (patron.test(filePath)) {
+      return {
+        delta: 0.25,
+        factor: `Archivo de alta sensibilidad (${patron.toString()}) — ruta: ${filePath}`,
+      };
+    }
+  }
+
+  for (const patron of PATRONES_MEDIA_SENSIBILIDAD) {
+    if (patron.test(filePath)) {
+      return {
+        delta: 0.15,
+        factor: `Archivo de sensibilidad media (${patron.toString()}) — ruta: ${filePath}`,
+      };
+    }
+  }
+
+  return { delta: 0, factor: null };
+}
+
+// ---------------------------------------------------------------------------
+// Eje 3 — Blast Radius
+// ---------------------------------------------------------------------------
+
+/**
+ * Patrones de alcance amplio: operaciones que afectan múltiples archivos o
+ * recursos de forma masiva / recursiva. Contribución: +0.35
+ */
+const PATRONES_BLAST_ALTO = [
+  /\brm\s+.*\*\*/,      // rm con glob recursivo (no globs en grep/ls/echo)
+  /\brm\s+.*\/\*/,      // rm con wildcard de directorio
+  /--all\b/,
+  /--recursive\b/,
+  /\bfind\s+\.\s+-.*\bdelete\b/,  // find con -delete (destructivo)
+  /\bxargs\s+rm\b/,     // xargs rm (destructivo)
+  /chmod\s+-R\b/,
+  /chown\s+-R\b/,
+];
+
+/**
+ * Patrones de alcance de publicación/despliegue: operaciones que propagan
+ * cambios a sistemas externos. Contribución: +0.25
+ */
+const PATRONES_BLAST_MEDIO = [
+  /\bgit\s+push\b/,
+  /\bnpm\s+publish\b/,
+  /\bdocker\s+push\b/,
+  /\bkubectl\s+apply\b/,
+  /\bterraform\s+apply\b/,
+];
+
+/**
+ * Calcula el delta de blast radius para comandos Bash.
+ *
+ * @param {string} toolName
+ * @param {object} toolInput
+ * @returns {{ delta: number, factor: string|null }}
+ */
+function calcularBlastRadius(toolName, toolInput) {
+  if (toolName !== 'Bash') return { delta: 0, factor: null };
+
+  const comando = String(toolInput.command || '');
+  if (!comando) return { delta: 0, factor: null };
+
+  // Prioridad alto sobre medio
+  for (const patron of PATRONES_BLAST_ALTO) {
+    if (patron.test(comando)) {
+      return {
+        delta: 0.35,
+        factor: `Blast radius alto — patrón de alcance masivo detectado: ${patron.toString()}`,
+      };
+    }
+  }
+
+  for (const patron of PATRONES_BLAST_MEDIO) {
+    if (patron.test(comando)) {
+      return {
+        delta: 0.25,
+        factor: `Blast radius medio — operación de publicación/despliegue: ${patron.toString()}`,
+      };
+    }
+  }
+
+  return { delta: 0, factor: null };
+}
+
+// ---------------------------------------------------------------------------
+// Eje 4 — Irreversibility
+// ---------------------------------------------------------------------------
+
+/**
+ * Patrones de alta irreversibilidad: operaciones que destruyen datos de forma
+ * permanente o difícilmente recuperable. Contribución: +0.45
+ */
+const PATRONES_IRREVERSIBLE_ALTO = [
+  /\brm\s+-rf\b/,
+  /\bgit\s+reset\s+--hard\b/,
+  /\bdrop\s+database\b/i,
+  /\btruncate\s+table\b/i,
+  /\bDROP\s+TABLE\b/i,
+  /\bformat\s+[A-Z]:/i,  // format C: / format D: (disk formatting, not dotnet format)
+  /\bfdisk\b/,
+  /\bmkfs\b/,
+];
+
+/**
+ * Patrones de irreversibilidad media: operaciones que sobrescriben o eliminan
+ * con cierta dificultad de recuperación. Contribución: +0.35
+ */
+const PATRONES_IRREVERSIBLE_MEDIO = [
+  /\brm\s+-f\b/,
+  /\bgit\s+push\s+--force\b/,
+  /\bgit\s+push\s+-f\b/,
+  /\bDELETE\s+FROM\b/i,
+  /\bgit\s+clean\s+-fd\b/,
+  /\bdocker\s+system\s+prune\b/,
+];
+
+/**
+ * Calcula el delta de irreversibilidad para comandos Bash.
+ *
+ * @param {string} toolName
+ * @param {object} toolInput
+ * @returns {{ delta: number, factor: string|null }}
+ */
+function calcularIrreversibilidad(toolName, toolInput) {
+  if (toolName !== 'Bash') return { delta: 0, factor: null };
+
+  const comando = String(toolInput.command || '');
+  if (!comando) return { delta: 0, factor: null };
+
+  // Prioridad alto sobre medio
+  for (const patron of PATRONES_IRREVERSIBLE_ALTO) {
+    if (patron.test(comando)) {
+      return {
+        delta: 0.45,
+        factor: `Irreversibilidad alta — operación destructiva permanente: ${patron.toString()}`,
+      };
+    }
+  }
+
+  for (const patron of PATRONES_IRREVERSIBLE_MEDIO) {
+    if (patron.test(comando)) {
+      return {
+        delta: 0.35,
+        factor: `Irreversibilidad media — operación difícilmente reversible: ${patron.toString()}`,
+      };
+    }
+  }
+
+  return { delta: 0, factor: null };
+}
+
+// ---------------------------------------------------------------------------
+// Clasificación de nivel
+// ---------------------------------------------------------------------------
+
+/**
+ * Clasifica un score numérico en un nivel de decisión usando los umbrales dados.
+ *
+ * @param {number} score          - Score en [0.0, 1.0].
+ * @param {object} umbrales       - Objeto { allow, review, confirm }.
+ * @returns {'allow'|'review'|'confirm'|'block'}
+ */
+function clasificarNivel(score, umbrales) {
+  if (score >= umbrales.confirm) return 'block';
+  if (score >= umbrales.review)  return 'confirm';
+  if (score >= umbrales.allow)   return 'review';
+  return 'allow';
+}
+
+// ---------------------------------------------------------------------------
+// API pública
+// ---------------------------------------------------------------------------
+
+/**
+ * Calcula el score de riesgo compuesto para una operación de Claude Code.
+ *
+ * La fórmula aplicada es:
+ *   score = min(1.0, baseRisk + fileSensitivity + blastRadius + irreversibility)
+ *
+ * @param {string} toolName  - Nombre de la herramienta (Bash, Write, Edit, etc.).
+ * @param {object} toolInput - Parámetros de la herramienta tal como los recibe el hook.
+ * @param {object} [umbrales=UMBRALES_DEFAULT] - Umbrales de clasificación a usar.
+ * @returns {{ score: number, level: string, factors: string[] }}
+ *   - score:   Valor entre 0.0 y 1.0 (2 decimales).
+ *   - level:   'allow' | 'review' | 'confirm' | 'block'.
+ *   - factors: Descripciones de los factores que contribuyeron al score.
+ */
+function calcularRiskScore(toolName, toolInput, umbrales = UMBRALES_DEFAULT) {
+  const factors = [];
+
+  // Eje 1 — Base risk
+  const baseRisk = obtenerRiesgoBase(toolName);
+  // Solo registrar el factor base si hay contribución no trivial (> 0)
+  if (baseRisk > 0) {
+    factors.push(`Riesgo base de herramienta "${toolName}": +${baseRisk.toFixed(2)}`);
+  }
+
+  // Eje 2 — File sensitivity
+  const { delta: deltaFile, factor: factorFile } = calcularFileSensitivity(toolName, toolInput);
+  if (deltaFile > 0 && factorFile) factors.push(factorFile);
+
+  // Eje 3 — Blast radius
+  const { delta: deltaBlast, factor: factorBlast } = calcularBlastRadius(toolName, toolInput);
+  if (deltaBlast > 0 && factorBlast) factors.push(factorBlast);
+
+  // Eje 4 — Irreversibility
+  const { delta: deltaIrrev, factor: factorIrrev } = calcularIrreversibilidad(toolName, toolInput);
+  if (deltaIrrev > 0 && factorIrrev) factors.push(factorIrrev);
+
+  // Score compuesto, acotado a [0.0, 1.0]
+  const scoreRaw = baseRisk + deltaFile + deltaBlast + deltaIrrev;
+  const score    = Math.min(1.0, parseFloat(scoreRaw.toFixed(2)));
+
+  const level = clasificarNivel(score, umbrales);
+
+  return { score, level, factors };
+}
+
+// ---------------------------------------------------------------------------
+// Exportaciones
+// ---------------------------------------------------------------------------
+
+module.exports = {
+  calcularRiskScore,
+  UMBRALES_DEFAULT,
+};