@saulwade/swl-ses 1.0.0

package/hooks/resumen-sesion.js

@@ -0,0 +1,249 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Hook: resumen-sesion.js
+ * Tipo: Stop
+ *
+ * Se ejecuta cuando Claude Code termina una respuesta. Imprime un resumen
+ * compacto de la sesión: componentes SWL utilizados, tokens, costo y archivos.
+ *
+ * Solo imprime si la sesión tiene al menos 5 tool calls (evita ruido en
+ * interacciones triviales) y si hay componentes SWL registrados.
+ *
+ * Resultado:
+ *   - stdout: resumen formateado (visible para Claude como contexto)
+ *   - stderr: no escribe (nunca bloquea)
+ *   - exit 0: siempre
+ */
+
+const fs     = require('fs');
+const path   = require('path');
+const os     = require('os');
+const { execFile } = require('child_process');
+
+const bus           = require('./lib/event-bus');
+const runLog        = require('./lib/run-log');
+const abortRegistry = require('./lib/abort-registry');
+
+// Umbral mínimo de tool calls para mostrar resumen cuando NO hay componentes SWL
+// registrados. Si hay componentes, emitimos siempre (gap 3 resuelto en v5.8.1, mantenido en v5.10.0).
+const MIN_TOOL_CALLS_SIN_COMPONENTES = 5;
+const MIN_TOOL_CALLS_CON_COMPONENTES = 1;
+
+/**
+ * Sincroniza los JSONL de Claude Code → SQLite (claude-usage) en segundo plano.
+ * No bloquea ni falla si Python no está disponible.
+ */
+function sincronizarUsageDB() {
+  const cliPath = path.join(__dirname, '..', 'scripts', 'vendor', 'claude-usage', 'cli.py');
+  if (!fs.existsSync(cliPath)) return;
+
+  const python = process.platform === 'win32' ? 'python' : 'python3';
+  execFile(python, [cliPath, 'scan'], { timeout: 30_000 }, () => {
+    // Silencioso — nunca bloquea el hook
+  });
+}
+
+/**
+ * Lee el estado del bridge de tracking-costos para la sesión.
+ */
+function leerBridge(sessionId) {
+  const bridgePath = path.join(os.tmpdir(), `swl-costs-${sessionId}.json`);
+  try {
+    return JSON.parse(fs.readFileSync(bridgePath, 'utf8'));
+  } catch (_) {
+    return null;
+  }
+}
+
+/**
+ * Formatea número con separador de miles.
+ */
+function fmt(n) {
+  return n.toLocaleString('es-MX');
+}
+
+/**
+ * Genera el resumen de sesión.
+ */
+/**
+ * Lee los hooks SWL que se dispararon en la sesión actual.
+ * Fuente: eventos del event-bus (fallback: run-log).
+ * Esto complementa `componentesSWL.hooks` que solo captura registros manuales.
+ */
+function hooksDisparados(sessionId) {
+  const hooks = new Set();
+  try {
+    const eventos = (runLog.readEvents && runLog.readEvents(sessionId)) || [];
+    for (const e of eventos) {
+      if (e && typeof e.hook === 'string' && e.hook) hooks.add(e.hook);
+    }
+  } catch { /* ignore */ }
+
+  // Fallback: heurística por archivos JSONL de hooks conocidos en .planning/
+  try {
+    const planningDir = path.join(process.cwd(), '.planning');
+    const jsonlCandidatos = [
+      ['evolucion/nudges.jsonl', 'nudge-tracker'],
+      ['auto-evolucion/agentes.jsonl', 'auto-evolucion'],
+      ['perfil-usuario/dirty.json', 'actualizar-perfil-usuario'],
+      ['evolucion/metricas.json', 'metricas-evolucion'],
+    ];
+    for (const [rel, nombre] of jsonlCandidatos) {
+      const p = path.join(planningDir, rel);
+      if (fs.existsSync(p)) {
+        const stat = fs.statSync(p);
+        // Si se modificó en los últimos 10 minutos, probablemente fue de esta sesión
+        if (Date.now() - stat.mtimeMs < 10 * 60 * 1000) {
+          hooks.add(nombre);
+        }
+      }
+    }
+  } catch { /* ignore */ }
+
+  return Array.from(hooks);
+}
+
+function generarResumen(estado, sessionId) {
+  const c = estado.componentesSWL || {};
+
+  // Fusionar hooks registrados con los detectados por JSONL recientes
+  const hooksDet = hooksDisparados(sessionId);
+  const hooksSet = new Set([...(c.hooks || []), ...hooksDet]);
+  const hooks = Array.from(hooksSet);
+
+  const tieneComponentes =
+    (c.agentes || []).length > 0 ||
+    (c.skills || []).length > 0 ||
+    (c.comandos || []).length > 0 ||
+    (c.scripts || []).length > 0 ||
+    (c.reglas || []).length > 0 ||
+    hooks.length > 0;
+
+  // Solo suprimir el resumen si NO hay componentes Y la sesión fue trivial.
+  const umbral = tieneComponentes
+    ? MIN_TOOL_CALLS_CON_COMPONENTES
+    : MIN_TOOL_CALLS_SIN_COMPONENTES;
+  if (estado.toolCalls < umbral) return null;
+  if (!tieneComponentes && estado.toolCalls < MIN_TOOL_CALLS_SIN_COMPONENTES) return null;
+
+  // Si no hay ningún componente SWL registrado pero sí hubo muchas tool calls,
+  // emitir una nota mínima en lugar de nada (gap 3: "no se usó SWL visiblemente").
+  if (!tieneComponentes) {
+    return [
+      '',
+      '━━━ Resumen de sesión SWL ━━━',
+      `  Herramientas: ${fmt(estado.toolCalls)} llamadas | Tokens: ~${fmt(estado.tokensTotal)} | Costo: ~$${estado.costoTotal.toFixed(2)} USD`,
+      '  Componentes SWL usados: ninguno registrado (sesión sin delegación a agentes ni carga explícita de skills).',
+      '  Tip: invoca agentes con Agent(subagent_type="...-swl") o skills con Skill("...") para registrarlos.',
+      '━━━━━━━━━━━━━━━━━━━━━━━━━━━━━',
+      '',
+    ].join('\n');
+  }
+
+  const lineas = [];
+  lineas.push('');
+  lineas.push('━━━ Resumen de sesión SWL ━━━');
+  lineas.push(`  Herramientas: ${fmt(estado.toolCalls)} llamadas | Tokens: ~${fmt(estado.tokensTotal)} | Costo: ~$${estado.costoTotal.toFixed(2)} USD`);
+
+  if ((c.agentes || []).length > 0) {
+    lineas.push(`  Agentes (${c.agentes.length}): ${c.agentes.join(', ')}`);
+  }
+  if ((c.skills || []).length > 0) {
+    lineas.push(`  Skills (${c.skills.length}): ${c.skills.join(', ')}`);
+  }
+  if ((c.comandos || []).length > 0) {
+    lineas.push(`  Comandos: ${c.comandos.join(', ')}`);
+  }
+  if ((c.scripts || []).length > 0) {
+    lineas.push(`  Scripts: ${c.scripts.join(', ')}`);
+  }
+  if (hooks.length > 0) {
+    lineas.push(`  Hooks (${hooks.length}): ${hooks.join(', ')}`);
+  }
+  if ((c.reglas || []).length > 0) {
+    lineas.push(`  Reglas: ${c.reglas.join(', ')}`);
+  }
+
+  // Top 5 herramientas más usadas
+  const topTools = Object.entries(estado.desglosePorHerramienta || {})
+    .sort(([, a], [, b]) => b.llamadas - a.llamadas)
+    .slice(0, 5)
+    .map(([nombre, datos]) => `${nombre}(${datos.llamadas})`)
+    .join(', ');
+  if (topTools) {
+    lineas.push(`  Top herramientas: ${topTools}`);
+  }
+
+  lineas.push('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+  lineas.push('');
+
+  return lineas.join('\n');
+}
+
+// ---------------------------------------------------------------------------
+// Entrypoint
+// ---------------------------------------------------------------------------
+
+let inputRaw = '';
+
+process.stdin.on('data', chunk => {
+  inputRaw += chunk;
+});
+
+process.stdin.on('end', () => {
+  try {
+    const data = JSON.parse(inputRaw);
+    const sessionId = String(data.session_id || 'default');
+
+    // Registrar sesión activa en abort-registry para manejo de señales
+    abortRegistry.registrarSesionActiva(sessionId);
+
+    // Sincronizar JSONL → SQLite en background (claude-usage)
+    sincronizarUsageDB();
+
+    const estado = leerBridge(sessionId);
+
+    // Registrar evento session-stop en JSONL de run (trazabilidad)
+    if (estado) {
+      runLog.sessionStop(sessionId, {
+        toolCalls:          estado.toolCalls          || 0,
+        tokensTotal:        estado.tokensTotal        || 0,
+        costoTotal:         estado.costoTotal         || 0,
+        modeloPredominante: estado.modeloPredominante || 'unknown',
+      });
+      bus.publish({
+        type:               'session-stop',
+        runId:              sessionId,
+        toolCalls:          estado.toolCalls          || 0,
+        costoTotal:         estado.costoTotal         || 0,
+        modeloPredominante: estado.modeloPredominante || 'unknown',
+      });
+    }
+
+    // Limpiar abort-registry post-sesión
+    abortRegistry.cleanup(sessionId);
+
+    if (!estado) return;
+
+    const resumen = generarResumen(estado, sessionId);
+    if (resumen) {
+      // Agregar diagnóstico de guardrails al resumen de sesión si hay activaciones
+      let resumenCompleto = resumen;
+      try {
+        const { getMetrics, diagnosticar } = require('./lib/guardrail-metrics');
+        const metricas = getMetrics(sessionId);
+        const advertencias = diagnosticar(metricas);
+        if (advertencias.length > 0) {
+          resumenCompleto += '\n⚠ Diagnóstico de guardrails:\n' +
+            advertencias.map(a => '  - ' + a).join('\n') + '\n';
+        }
+      } catch (_) { /* métricas opcionales */ }
+
+      process.stdout.write(resumenCompleto);
+    }
+  } catch (_) {
+    // Nunca bloquear
+  }
+});

package/hooks/risk-scoring.js

@@ -0,0 +1,323 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Hook: risk-scoring.js
+ * Tipo: PreToolUse  (aplica a: todas las herramientas — matcher vacío)
+ *
+ * Evalúa el riesgo de cada operación de Claude Code usando el motor de scoring
+ * compuesto definido en lib/risk-engine.js. Toma decisiones en 4 niveles:
+ *
+ *   allow   (score < 0.35) — Continúa silenciosamente.
+ *   review  (score < 0.60) — Emite advertencia en stderr y continúa.
+ *   confirm (score < 0.85) — Bloquea con mensaje que solicita reformulación
+ *                            o aprobación explícita del usuario.
+ *   block   (score ≥ 0.85) — Bloquea con mensaje de operación peligrosa.
+ *
+ * La fórmula de scoring es:
+ *   score = min(1.0, baseRisk + fileSensitivity + blastRadius + irreversibility)
+ *
+ * Resultado:
+ *   - allow   → exit 0, sin output
+ *   - review  → exit 0, warning en stderr
+ *   - confirm → exit 2, JSON {result:"block", reason:"..."} en stdout
+ *   - block   → exit 2, JSON {result:"block", reason:"..."} en stdout
+ *   - Error   → exit 0 (nunca bloquear por fallo interno del hook)
+ */
+
+const fs   = require('fs');
+const path = require('path');
+const os   = require('os');
+
+// Cargar el motor de scoring desde lib/ relativo al directorio de este script
+const { calcularRiskScore, UMBRALES_DEFAULT } = require(
+  path.join(__dirname, 'lib', 'risk-engine.js')
+);
+const { getDelegationRiskFactor } = require(
+  path.join(__dirname, 'lib', 'delegation-tracker.js')
+);
+const { isTripped, recordFailure, recordSuccess } = require(
+  path.join(__dirname, 'lib', 'hook-circuit-breaker.js')
+);
+const { normalizar, formatear } = require(
+  path.join(__dirname, 'lib', 'normalize-error.js')
+);
+const { tracker: taintTracker } = require(
+  path.join(__dirname, 'lib', 'taint-tracker.js')
+);
+
+// ---------------------------------------------------------------------------
+// Override tracking — registra cuando el usuario ignora advertencias de riesgo
+// ---------------------------------------------------------------------------
+
+const HOOK_NAME = 'risk-scoring';
+const MAX_HIGH_OVERRIDES = 5;
+
+/**
+ * Ruta del archivo de tracking de overrides por sesión.
+ */
+function overrideTrackingPath() {
+  const sessionId = process.env.SWL_SESSION_ID || 'default';
+  return path.join(os.tmpdir(), `swl-risk-overrides-${sessionId}.json`);
+}
+
+/**
+ * Lee el estado de overrides.
+ */
+function readOverrides() {
+  try {
+    return JSON.parse(fs.readFileSync(overrideTrackingPath(), 'utf8'));
+  } catch {
+    return { highOverrides: 0, auditWritten: false, entries: [] };
+  }
+}
+
+/**
+ * Escribe el estado de overrides.
+ */
+function writeOverrides(state) {
+  try {
+    fs.writeFileSync(overrideTrackingPath(), JSON.stringify(state), 'utf8');
+  } catch { /* silencioso */ }
+}
+
+/**
+ * Registra un override de nivel alto y escribe audit si supera el umbral.
+ */
+function trackHighOverride(score, factors, toolName) {
+  const state = readOverrides();
+  state.highOverrides += 1;
+  state.entries.push({
+    timestamp: new Date().toISOString(),
+    score: score.toFixed(2),
+    tool: toolName,
+    factors: Array.isArray(factors) ? factors : Object.keys(factors),
+  });
+
+  if (state.highOverrides >= MAX_HIGH_OVERRIDES && !state.auditWritten) {
+    const auditPath = path.join(process.cwd(), '.planning', 'AUDITORIA.md');
+    try {
+      const auditEntry = [
+        '',
+        `## [${new Date().toISOString().slice(0, 16)}] risk-override-threshold`,
+        '',
+        `**Agente**: sesión activa`,
+        '',
+        `**Operación**: ${state.highOverrides} operaciones de riesgo alto aceptadas sin mitigación`,
+        '',
+        `**Justificación**: registro automático — umbral de ${MAX_HIGH_OVERRIDES} overrides superado`,
+        '',
+        `**Detalle de overrides**:`,
+        '',
+        ...state.entries.map(e => `- ${e.timestamp.slice(0, 16)} | ${e.tool} | score ${e.score}`),
+        '',
+        `**Estado**: registrado automáticamente por risk-scoring.js`,
+        '',
+        '---',
+        '',
+      ].join('\n');
+
+      if (fs.existsSync(auditPath)) {
+        fs.appendFileSync(auditPath, auditEntry);
+      } else {
+        const dir = path.dirname(auditPath);
+        if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+        fs.writeFileSync(auditPath, `# Registro de Auditoría\n\nRegistro automático de operaciones de alto riesgo generado por \`risk-scoring.js\`.\n${auditEntry}`);
+      }
+      state.auditWritten = true;
+    } catch { /* no bloquear por fallo de audit */ }
+  }
+
+  writeOverrides(state);
+}
+
+// ---------------------------------------------------------------------------
+// Construcción de mensajes
+// ---------------------------------------------------------------------------
+
+/**
+ * Construye el mensaje de bloqueo para niveles 'confirm' y 'block'.
+ *
+ * El mensaje para 'confirm' usa un tono más suave: solicita reformulación
+ * o aprobación explícita en lugar de declarar la operación directamente
+ * peligrosa. El mensaje para 'block' usa lenguaje más firme.
+ *
+ * @param {'confirm'|'block'} level    - Nivel de decisión.
+ * @param {number}            score    - Score calculado.
+ * @param {string[]}          factors  - Factores que contribuyeron al score.
+ * @param {object}            umbrales - Umbrales usados en la evaluación.
+ * @returns {string}
+ */
+function construirMensajeBloqueo(level, score, factors, umbrales) {
+  const factoresTexto = factors.length > 0
+    ? factors.map(f => `  - ${f}`).join('\n')
+    : '  - (sin factores específicos identificados)';
+
+  if (level === 'confirm') {
+    return [
+      `Operación pausada por Risk Scoring (score: ${score.toFixed(2)} / umbral de confirmación: ${umbrales.confirm}).`,
+      ``,
+      `Esta operación requiere confirmación explícita antes de continuar.`,
+      ``,
+      `Factores de riesgo detectados:`,
+      factoresTexto,
+      ``,
+      `Para proceder:`,
+      `  1. Solicita aprobación explícita al usuario antes de ejecutar esta operación.`,
+      `  2. O reformula la operación reduciendo su alcance o riesgo.`,
+      `  3. Si el usuario ya aprobó explícitamente, indica "aprobado por el usuario" en tu mensaje.`,
+    ].join('\n');
+  }
+
+  // level === 'block'
+  return [
+    `Operación bloqueada por Risk Scoring (score: ${score.toFixed(2)} / umbral: ${umbrales.confirm}).`,
+    ``,
+    `Factores de riesgo detectados:`,
+    factoresTexto,
+    ``,
+    `Para proceder, reformula la operación con menor riesgo o solicita aprobación explícita.`,
+  ].join('\n');
+}
+
+/**
+ * Construye el mensaje de advertencia para nivel 'review'.
+ *
+ * @param {number}   score   - Score calculado.
+ * @param {string[]} factors - Factores que contribuyeron al score.
+ * @param {object}   umbrales - Umbrales usados en la evaluación.
+ * @returns {string}
+ */
+function construirMensajeReview(score, factors, umbrales) {
+  const factoresTexto = factors.length > 0
+    ? factors.map(f => `    - ${f}`).join('\n')
+    : '    - (sin factores específicos identificados)';
+
+  return [
+    `[risk-scoring] ADVERTENCIA — score de riesgo: ${score.toFixed(2)} (umbral review: ${umbrales.allow}, confirm: ${umbrales.review})`,
+    `  Factores detectados:`,
+    factoresTexto,
+    `  La operación continúa — verificar que es intencional.`,
+  ].join('\n');
+}
+
+// ---------------------------------------------------------------------------
+// Entrypoint principal
+// ---------------------------------------------------------------------------
+
+let inputRaw = '';
+
+process.stdin.on('data', chunk => {
+  inputRaw += chunk;
+});
+
+process.stdin.on('end', () => {
+  try {
+    // Circuit breaker: si el hook ha fallado demasiadas veces, degradar
+    if (isTripped(HOOK_NAME, { maxConsecutive: 5 })) {
+      process.stderr.write('[risk-scoring] Circuit breaker activo — hook degradado a pass-through\n');
+      return;
+    }
+
+    const data = JSON.parse(inputRaw);
+
+    const toolName  = String(data.tool_name  || data.tool?.name || '');
+    const toolInput = data.tool_input || data.tool?.input || {};
+    const sessionId = String(data.session_id || 'default');
+
+    // Sin nombre de herramienta: nada que evaluar
+    if (!toolName) {
+      recordSuccess(HOOK_NAME);
+      return;
+    }
+
+    // Taint tracking: registrar sources y verificar sinks
+    const targetPath = toolInput.file_path || toolInput.command || toolInput.url || '';
+    if (/^Read$/i.test(toolName) || /^WebFetch$/i.test(toolName)) {
+      taintTracker.registrarSource(toolName, targetPath);
+    }
+    const taintViolation = taintTracker.verificarSink(toolName, targetPath);
+    if (taintViolation) {
+      const msg = [
+        `Operación bloqueada por Taint Tracking (${taintViolation.severity}).`,
+        ``,
+        `Flujo de información peligroso detectado:`,
+        `  ${taintViolation.flujo}`,
+        ``,
+        `${taintViolation.descripcion}.`,
+        `Reformula la operación sin propagar datos sensibles a este destino.`,
+      ].join('\n');
+      process.stderr.write(msg);
+      try { require('./lib/guardrail-metrics').recordActivation('risk-scoring.js', sessionId, true); } catch (_) {}
+      recordSuccess(HOOK_NAME);
+      process.exit(2);
+    }
+
+    // Calcular el score de riesgo compuesto
+    const result = calcularRiskScore(toolName, toolInput, UMBRALES_DEFAULT);
+
+    // Agregar factor de profundidad de delegación (0.15 por nivel)
+    const delegationFactor = getDelegationRiskFactor();
+    result.score = Math.min(1.0, result.score + delegationFactor);
+    if (delegationFactor > 0) {
+      result.factors.delegation = delegationFactor;
+    }
+
+    // Recalcular level después del ajuste por delegación
+    const { score, factors } = result;
+    const level = score >= UMBRALES_DEFAULT.confirm ? 'block'
+                : score >= UMBRALES_DEFAULT.review  ? 'confirm'
+                : score >= UMBRALES_DEFAULT.allow   ? 'review'
+                : 'allow';
+
+    switch (level) {
+      case 'allow':
+        // Operación segura — exit 0 (allow)
+        recordSuccess(HOOK_NAME);
+        return;
+
+      case 'review': {
+        // Advertencia visible pero no bloqueante — stdout con info, exit 0 (allow)
+        const mensajeReview = construirMensajeReview(score, factors, UMBRALES_DEFAULT);
+        process.stderr.write(mensajeReview);
+        // Registrar como override si el score era alto (>= confirm threshold)
+        if (score >= UMBRALES_DEFAULT.review) {
+          trackHighOverride(score, factors, toolName);
+        }
+        try { require('./lib/guardrail-metrics').recordActivation('risk-scoring.js', sessionId, false); } catch (_) {}
+        recordSuccess(HOOK_NAME);
+        break;
+      }
+
+      case 'confirm': {
+        // Bloqueo suave: solicita confirmación — exit 2 (block)
+        // stderr: Claude recibe el mensaje y puede razonar con él.
+        const mensajeConfirm = construirMensajeBloqueo('confirm', score, factors, UMBRALES_DEFAULT);
+        process.stderr.write(mensajeConfirm);
+        try { require('./lib/guardrail-metrics').recordActivation('risk-scoring.js', sessionId, true); } catch (_) {}
+        recordSuccess(HOOK_NAME);
+        process.exit(2);
+      }
+
+      case 'block': {
+        // Bloqueo firme: operación peligrosa — exit 2 (block)
+        // stderr: Claude recibe el mensaje y puede razonar con él.
+        const mensajeBlock = construirMensajeBloqueo('block', score, factors, UMBRALES_DEFAULT);
+        process.stderr.write(mensajeBlock);
+        try { require('./lib/guardrail-metrics').recordActivation('risk-scoring.js', sessionId, true); } catch (_) {}
+        recordSuccess(HOOK_NAME);
+        process.exit(2);
+      }
+
+      default:
+        recordSuccess(HOOK_NAME);
+        break;
+    }
+
+  } catch (err) {
+    // El hook nunca bloquea por errores internos propios
+    const errNorm = normalizar(err, { fuente: 'risk-scoring' });
+    process.stderr.write(`[risk-scoring] ${formatear(errNorm)}\n`);
+    recordFailure(HOOK_NAME);
+  }
+});

package/hooks/rotar-audit-auto.js

@@ -0,0 +1,122 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Hook: rotar-audit-auto.js
+ * Tipo: Stop
+ *
+ * Se ejecuta al terminar una respuesta. Verifica si los archivos de auditoría
+ * (.planning/audit.jsonl y audit-merkle.jsonl) superan el umbral configurable
+ * y, de ser así, invoca scripts/rotar-audit-logs.js para archivar entradas
+ * antiguas a .planning/archivo/audit/<nombre>-YYYY-MM.jsonl.gz.
+ *
+ * Política:
+ *   - Umbral default: 5 MB por archivo (UMBRAL_BYTES). Configurable vía env
+ *     SWL_AUDIT_ROTATE_UMBRAL_MB (valor en MB, default 5).
+ *   - Retención default: 30 días (coincide con el default del script).
+ *     Configurable vía env SWL_AUDIT_ROTATE_DIAS.
+ *   - Desactivable con SWL_AUDIT_ROTATE_OFF=1 (para CI o escenarios donde
+ *     la rotación debe ser manual).
+ *   - Cooldown: no se re-ejecuta si hubo una rotación exitosa en las últimas
+ *     6 horas (marca en .planning/archivo/audit/.ultima-rotacion).
+ *
+ * Resultado:
+ *   - stdout: 1-2 líneas si se rotó, silencioso si no
+ *   - stderr: nunca escribe
+ *   - exit 0: siempre (hook no-bloqueante)
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const RAIZ_PROYECTO = path.resolve(__dirname, '..');
+const DIR_PLANNING = path.join(RAIZ_PROYECTO, '.planning');
+const ARCHIVOS_AUDIT = [
+  path.join(DIR_PLANNING, 'audit.jsonl'),
+  path.join(DIR_PLANNING, 'audit-merkle.jsonl'),
+];
+const DIR_ARCHIVO = path.join(DIR_PLANNING, 'archivo', 'audit');
+const MARCA_ULTIMA_ROTACION = path.join(DIR_ARCHIVO, '.ultima-rotacion');
+const SCRIPT_ROTAR = path.join(RAIZ_PROYECTO, 'scripts', 'rotar-audit-logs.js');
+
+const COOLDOWN_MS = 6 * 60 * 60 * 1000; // 6 horas
+
+function umbralBytes() {
+  const mb = parseFloat(process.env.SWL_AUDIT_ROTATE_UMBRAL_MB || '5');
+  return isNaN(mb) || mb <= 0 ? 5 * 1024 * 1024 : mb * 1024 * 1024;
+}
+
+function diasRetencion() {
+  const d = parseInt(process.env.SWL_AUDIT_ROTATE_DIAS || '30', 10);
+  return isNaN(d) || d <= 0 ? 30 : d;
+}
+
+function algunArchivoSuperaUmbral() {
+  const limite = umbralBytes();
+  for (const ruta of ARCHIVOS_AUDIT) {
+    try {
+      const st = fs.statSync(ruta);
+      if (st.size > limite) return { excedido: true, ruta, size: st.size, limite };
+    } catch (_) {
+      // Archivo ausente — ignorar
+    }
+  }
+  return { excedido: false };
+}
+
+function enCooldown() {
+  try {
+    const raw = fs.readFileSync(MARCA_ULTIMA_ROTACION, 'utf8').trim();
+    const ultima = parseInt(raw, 10);
+    if (isNaN(ultima)) return false;
+    return Date.now() - ultima < COOLDOWN_MS;
+  } catch (_) {
+    return false;
+  }
+}
+
+function marcarRotacion() {
+  try {
+    fs.mkdirSync(DIR_ARCHIVO, { recursive: true });
+    fs.writeFileSync(MARCA_ULTIMA_ROTACION, String(Date.now()), 'utf8');
+  } catch (_) {
+    // Silencioso — no crítico
+  }
+}
+
+function main() {
+  if (process.env.SWL_AUDIT_ROTATE_OFF === '1') return;
+  if (!fs.existsSync(SCRIPT_ROTAR)) return;
+
+  const check = algunArchivoSuperaUmbral();
+  if (!check.excedido) return;
+  if (enCooldown()) return;
+
+  const dias = diasRetencion();
+  const nodeBin = process.execPath;
+  const result = spawnSync(
+    nodeBin,
+    [SCRIPT_ROTAR, `--dias=${dias}`, `--raiz=${DIR_PLANNING}`],
+    { encoding: 'utf8', timeout: 30_000, cwd: RAIZ_PROYECTO }
+  );
+
+  if (result.status === 0) {
+    marcarRotacion();
+    const sizeMb = (check.size / 1024 / 1024).toFixed(1);
+    const limiteMb = (check.limite / 1024 / 1024).toFixed(1);
+    const nombreArchivo = path.basename(check.ruta);
+    const match = (result.stdout || '').match(/(\d+) archivadas/g);
+    const archivadas = match ? match.map((m) => m.replace(' archivadas', '')).join('+') : '?';
+    process.stdout.write(
+      `[rotacion-audit] ${nombreArchivo}=${sizeMb}MB > ${limiteMb}MB → archivadas ${archivadas} entradas (>${dias}d)\n`
+    );
+  }
+}
+
+try {
+  main();
+} catch (_) {
+  // Nunca bloquear
+}
+process.exit(0);