@saulwade/swl-ses 2.3.0 → 2.4.1

package/hooks/linea-estado.js

@@ -1,326 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-/**
- * Hook: linea-estado.js
- * Tipo: PostToolUse
- *
- * Muestra una línea de estado compacta con:
- *   - Modelo activo
- *   - Tarea actual (derivada del tool_name y parámetros)
- *   - Directorio de trabajo abreviado
- *   - Barra de progreso de contexto estimado
- *
- * Además escribe un archivo bridge en /tmp/swl-ctx-{session}.json
- * para que otros hooks (monitor-contexto, etc.) lean el estado.
- *
- * Integración con Claude Code hooks:
- *   El hook no bloquea (exit 0 siempre).
- *   Los mensajes informativos se escriben en stderr para que
- *   Claude Code los muestre en la barra de estado o los ignore;
- *   sin interferir con el flujo JSON en stdout.
- */
-
-const fs   = require('fs');
-const path = require('path');
-const os   = require('os');
-
-// ---------------------------------------------------------------------------
-// Constantes de configuración
-// ---------------------------------------------------------------------------
-
-/** Ancho de la barra de progreso del contexto (en caracteres de bloque). */
-const BARRA_ANCHO = 10;
-
-/**
- * Techo por defecto cuando no se detecta el modelo.
- * Mantiene la heurística histórica para compatibilidad.
- */
-const TOKENS_MAXIMOS_DEFAULT = 200_000;
-
-/**
- * Techos de contexto por modelo (en tokens).
- *
- * IMPORTANTE: las claves son prefijos del `model_id` reportado por Claude Code
- * en el evento del hook. La detección hace `modelId.includes(prefijo)` en orden;
- * los prefijos más específicos van primero para que `claude-opus-4-8` no
- * matchee accidentalmente con la entrada genérica `claude-opus`.
- *
- * Si el `model_id` contiene el sufijo `[1m]` (ej: `claude-opus-4-8[1m]`), el
- * techo se fuerza a 1M independientemente del modelo base — Anthropic usa
- * ese sufijo para indicar la variante de 1M context.
- */
-const TECHOS_POR_MODELO = {
-  // Opus 4.8 — variante de 1M context (la actual por defecto)
-  'claude-opus-4-8':  1_000_000,
-  // Opus 4.7 — variante de 1M context (histórica)
-  'claude-opus-4-7':  1_000_000,
-  // Resto de modelos modernos: 200k context
-  'claude-opus-4-6':    200_000,
-  'claude-opus-4-5':    200_000,
-  'claude-sonnet-4-6':  200_000,
-  'claude-sonnet-4-5':  200_000,
-  'claude-haiku-4-5':   200_000,
-  // Catch-all genéricos (orden: deben ir DESPUÉS de los específicos)
-  'claude-opus':        200_000,
-  'claude-sonnet':      200_000,
-  'claude-haiku':       200_000,
-};
-
-/**
- * Modelos conocidos y su etiqueta corta para la barra.
- * Clave: prefijo del model_id. Valor: etiqueta legible.
- */
-const ETIQUETAS_MODELO = {
-  'claude-opus':   'opus',
-  'claude-sonnet': 'sonnet',
-  'claude-haiku':  'haiku',
-};
-
-/**
- * Determina el techo de tokens del contexto según el modelo activo.
- *
- * Reglas (en orden):
- *   1. Si el `modelId` contiene `[1m]` → 1_000_000 (variante explícita 1M).
- *   2. Si el `modelId` matchea un prefijo de TECHOS_POR_MODELO → ese techo.
- *   3. Default → TOKENS_MAXIMOS_DEFAULT (200k).
- *
- * @param {string} modelId - Identificador completo del modelo, posiblemente
- *                           con sufijo de variante (ej: `claude-opus-4-8[1m]`).
- * @returns {number} Techo de tokens del contexto.
- */
-function techoTokens(modelId) {
-  if (!modelId) return TOKENS_MAXIMOS_DEFAULT;
-  const id = String(modelId);
-  if (id.includes('[1m]') || id.includes('-1m')) return 1_000_000;
-  for (const [prefijo, techo] of Object.entries(TECHOS_POR_MODELO)) {
-    if (id.includes(prefijo)) return techo;
-  }
-  return TOKENS_MAXIMOS_DEFAULT;
-}
-
-// ---------------------------------------------------------------------------
-// Utilidades
-// ---------------------------------------------------------------------------
-
-/**
- * Construye la etiqueta corta del modelo activo.
- * @param {string} modelId - Identificador completo del modelo.
- * @returns {string}
- */
-function etiquetaModelo(modelId) {
-  if (!modelId) return 'modelo?';
-  for (const [prefijo, etiqueta] of Object.entries(ETIQUETAS_MODELO)) {
-    if (modelId.includes(prefijo)) return etiqueta;
-  }
-  // Fallback: primeros 12 caracteres del modelo
-  return String(modelId).slice(0, 12);
-}
-
-/**
- * Determina la tarea actual a partir del nombre de la herramienta
- * y sus parámetros de entrada.
- * @param {string} toolName - Nombre de la tool que acaba de ejecutarse.
- * @param {object} toolInput - Parámetros de entrada de la tool.
- * @returns {string}
- */
-function tareaActual(toolName, toolInput) {
-  if (!toolName) return 'idle';
-
-  const nombre = String(toolName).toLowerCase();
-
-  switch (nombre) {
-    case 'write':
-    case 'edit': {
-      const filePath = toolInput?.file_path || toolInput?.path || '';
-      const base = path.basename(String(filePath));
-      return `editando ${base || 'archivo'}`;
-    }
-    case 'read': {
-      const filePath = toolInput?.file_path || toolInput?.path || '';
-      const base = path.basename(String(filePath));
-      return `leyendo ${base || 'archivo'}`;
-    }
-    case 'bash': {
-      // Mostrar primeros 28 chars del comando, sin saltos de línea
-      const cmd = String(toolInput?.command || '').replace(/\s+/g, ' ').slice(0, 28);
-      return `bash: ${cmd || '...'}`;
-    }
-    case 'grep': {
-      const patron = String(toolInput?.pattern || '').slice(0, 20);
-      return `grep: ${patron || '...'}`;
-    }
-    case 'glob': {
-      const patron = String(toolInput?.pattern || '').slice(0, 20);
-      return `glob: ${patron || '...'}`;
-    }
-    case 'task':
-    case 'agent':
-      return `agente: ${String(toolInput?.description || '').slice(0, 25) || '...'}`;
-    default:
-      return nombre.slice(0, 30);
-  }
-}
-
-/**
- * Abrevia una ruta de directorio para mostrar en la barra de estado.
- * Muestra sólo los últimos N segmentos.
- * @param {string} dirPath - Ruta completa.
- * @param {number} maxSegmentos - Número máximo de segmentos a mostrar.
- * @returns {string}
- */
-function abreviarDirectorio(dirPath, maxSegmentos = 2) {
-  if (!dirPath) return '.';
-  // Normalizar separadores en Windows
-  const normalizado = String(dirPath).replace(/\\/g, '/');
-  const partes = normalizado.split('/').filter(Boolean);
-  if (partes.length <= maxSegmentos) return normalizado;
-  return '…/' + partes.slice(-maxSegmentos).join('/');
-}
-
-/**
- * Construye la barra de progreso visual.
- * @param {number} porcentaje - Valor entre 0 y 100.
- * @returns {string} Ej: "████████░░ 80%"
- */
-function barraProgreso(porcentaje) {
-  const pct = Math.max(0, Math.min(100, porcentaje));
-  const llenos = Math.round((pct / 100) * BARRA_ANCHO);
-  const vacios = BARRA_ANCHO - llenos;
-  const barra = '█'.repeat(llenos) + '░'.repeat(vacios);
-  return `${barra} ${pct}%`;
-}
-
-/**
- * Estima el porcentaje de contexto utilizado.
- * Claude Code no expone directamente los tokens consumidos en el hook,
- * por lo que usamos una heurística basada en el número de invocaciones
- * de herramientas acumuladas en la sesión cuando el campo `usage` no está.
- *
- * La función lee el archivo bridge previo para mantener el contador,
- * y lo incrementa en cada invocación.
- *
- * @param {string} bridgePath - Ruta del archivo bridge.
- * @param {number} tokensReportados - Tokens reportados por Claude (si existen).
- * @param {number} techo - Techo de tokens del modelo activo.
- * @returns {{ porcentaje: number, invocaciones: number, techo: number }}
- */
-function estimarContexto(bridgePath, tokensReportados, techo) {
-  const techoEfectivo = (typeof techo === 'number' && techo > 0)
-    ? techo
-    : TOKENS_MAXIMOS_DEFAULT;
-  let invocaciones = 1;
-
-  // Leer estado previo del bridge
-  try {
-    const previo = JSON.parse(fs.readFileSync(bridgePath, 'utf8'));
-    invocaciones = (previo.invocaciones || 0) + 1;
-  } catch (_) {
-    // Archivo no existe aún — primera invocación
-  }
-
-  // Si Claude reporta tokens usados (campo no-estándar, puede no existir)
-  if (typeof tokensReportados === 'number' && tokensReportados > 0) {
-    const pct = Math.min(100, Math.round((tokensReportados / techoEfectivo) * 100));
-    return { porcentaje: pct, invocaciones, techo: techoEfectivo };
-  }
-
-  // Heurística: cada invocación consume ~500 tokens promedio (conversación + tool)
-  const tokenesEstimados = invocaciones * 500;
-  const pct = Math.min(99, Math.round((tokenesEstimados / techoEfectivo) * 100));
-  return { porcentaje: pct, invocaciones, techo: techoEfectivo };
-}
-
-// ---------------------------------------------------------------------------
-// Entrypoint principal
-// ---------------------------------------------------------------------------
-
-// Solo conectar stdin cuando se ejecuta como script (hook),
-// no cuando se carga vía require() desde tests u otros módulos.
-if (require.main === module) iniciarHook();
-
-function iniciarHook() {
-let inputRaw = '';
-
-process.stdin.on('data', chunk => {
-  inputRaw += chunk;
-});
-
-process.stdin.on('end', () => {
-  try {
-    const data = JSON.parse(inputRaw);
-
-    // Extraer campos del evento de hook de Claude Code
-    // Estructura documentada de PostToolUse:
-    //   data.session_id, data.model, data.tool_name, data.tool_input,
-    //   data.tool_result, data.usage (si existe)
-    const sessionId    = String(data.session_id || 'default');
-    const modelId      = String(data.model || '');
-    const toolName     = String(data.tool_name || '');
-    const toolInput    = data.tool_input || {};
-    const tokensUsados = data.usage?.input_tokens ?? data.usage?.total_tokens ?? 0;
-
-    // Ruta del archivo bridge compartido entre hooks
-    const bridgePath = path.join(os.tmpdir(), `swl-ctx-${sessionId}.json`);
-
-    // Resolver techo según modelo (Opus 4.8 con sufijo [1m] = 1M; resto 200k)
-    const techo = techoTokens(modelId);
-
-    // Calcular métricas
-    const { porcentaje, invocaciones } = estimarContexto(bridgePath, tokensUsados, techo);
-    const modeloLabel  = etiquetaModelo(modelId);
-    const tarea        = tareaActual(toolName, toolInput);
-    const directorio   = abreviarDirectorio(process.cwd());
-    const barra        = barraProgreso(porcentaje);
-
-    // Construir payload del bridge para otros hooks
-    const bridgePayload = {
-      sessionId,
-      modelId,
-      modeloLabel,
-      tarea,
-      directorio,
-      porcentaje,
-      invocaciones,
-      tokensUsados,
-      techoTokens: techo,
-      timestamp: new Date().toISOString(),
-    };
-
-    // Escribir bridge (ignorar error si /tmp no existe en este entorno)
-    try {
-      fs.writeFileSync(bridgePath, JSON.stringify(bridgePayload, null, 2), 'utf8');
-    } catch (errBridge) {
-      // No bloquear el flujo si no se puede escribir el bridge
-      // No se pudo escribir bridge — ignorar
-    }
-
-    // Construir la línea de estado como JSON válido para Claude Code
-    const lineaEstado = `${modeloLabel} | ${tarea} | ${directorio} | ctx: ${barra}`;
-
-    // PostToolUse hooks: no escribir nada a stdout para permitir
-    // que Claude Code procese la respuesta sin interferencia.
-
-  } catch (err) {
-    // Si el hook falla por cualquier razón, nunca bloquear a Claude
-    // No escribir a stderr — Claude Code lo reporta como hook error
-  }
-});
-}
-
-if (require.main !== module) {
-  module.exports = {
-    techoTokens,
-    estimarContexto,
-    etiquetaModelo,
-    tareaActual,
-    abreviarDirectorio,
-    barraProgreso,
-    _internals: {
-      TECHOS_POR_MODELO,
-      TOKENS_MAXIMOS_DEFAULT,
-      ETIQUETAS_MODELO,
-      BARRA_ANCHO,
-    },
-  };
-}

package/hooks/monitor-contexto.js

@@ -1,373 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-/**
- * Hook: monitor-contexto.js
- * Tipo: PostToolUse
- *
- * Lee el archivo bridge generado por linea-estado.js y emite advertencias
- * cuando el contexto estimado supera umbrales críticos.
- *
- * Umbrales por defecto (calibrados con evidencia empírica de
- * github.com/anthropics/claude-code issue #34685 — degradación detectable
- * ~20%, auto-compactación de Claude Code dispara ~40%, sweet spot 40-50%):
- *
- *   ≥ 40%: WARNING  — degradación detectable, evitar trabajo complejo
- *   ≥ 55%: CRITICAL — detenerse, guardar estado, compactar
- *   ≥ 35% en punto natural: sugerencia de compactación proactiva
- *
- * Override por env var (útil para experimentos o sesiones cortas):
- *   SWL_CTX_WARNING       (default 40)
- *   SWL_CTX_CRITICAL      (default 55)
- *   SWL_CTX_PROACTIVA     (default 35)
- *
- * Histórico: hasta v1.1.0 los umbrales eran 65/75/50. Se bajaron en v1.1.1
- * tras analizar el issue #34685 que documenta degradación al 20-40%.
- *
- * Debounce: solo emite aviso cada N_DEBOUNCE invocaciones de herramienta.
- * La escalación de severidad (pasar de WARNING a CRITICAL) bypasea el debounce.
- *
- * El hook nunca bloquea (siempre exit 0); sólo emite mensajes en stdout
- * como texto enriquecido que Claude Code puede mostrar al usuario.
- */
-
-const fs   = require('fs');
-const path = require('path');
-const os   = require('os');
-
-const { phase1_PruneToolResults, shouldCompress } = require('./lib/context-compressor');
-
-// ---------------------------------------------------------------------------
-// Constantes de configuración
-// ---------------------------------------------------------------------------
-
-/**
- * Lee un umbral numérico desde env var con default. Inválido o fuera de rango
- * (0-99) → usar default.
- */
-function umbralEnv(nombre, def) {
-  const valor = parseInt(process.env[nombre] || '', 10);
-  if (Number.isFinite(valor) && valor >= 0 && valor < 100) return valor;
-  return def;
-}
-
-/**
- * Resuelve los tres umbrales aplicando defaults y validando el invariante de
- * ordenamiento: PROACTIVA < WARNING < CRITICAL.
- *
- * Si los env vars violan el orden (p.ej. WARNING=80 y CRITICAL=50, que haría
- * CRITICAL inalcanzable lógicamente) o PROACTIVA >= WARNING (haciendo la
- * sugerencia proactiva inalcanzable), se descarta la configuración inválida
- * y se usan los defaults para los tres. La fallback es silenciosa porque el
- * hook nunca debe romper el flujo principal.
- */
-function resolverUmbrales() {
-  const defaults = { proactiva: 35, warning: 40, critical: 55 };
-
-  const proactiva = umbralEnv('SWL_CTX_PROACTIVA', defaults.proactiva);
-  const warning   = umbralEnv('SWL_CTX_WARNING',   defaults.warning);
-  const critical  = umbralEnv('SWL_CTX_CRITICAL',  defaults.critical);
-
-  if (proactiva < warning && warning < critical) {
-    return { proactiva, warning, critical };
-  }
-  return defaults;
-}
-
-const UMBRALES = resolverUmbrales();
-
-/** Porcentaje de USO a partir del cual se emite WARNING. */
-const UMBRAL_WARNING  = UMBRALES.warning;
-
-/** Porcentaje de USO a partir del cual se emite CRITICAL. */
-const UMBRAL_CRITICAL = UMBRALES.critical;
-
-/**
- * Número de invocaciones de herramienta entre avisos consecutivos del mismo nivel.
- * La escalación de severidad siempre bypasea este valor.
- */
-const N_DEBOUNCE = 5;
-
-/** Cada N invocaciones, sugerir compactacion si estamos en punto natural. */
-const N_COMPACTACION_PROACTIVA = 40;
-
-/** Umbral de uso para activar compactacion proactiva (antes del warning). */
-const UMBRAL_COMPACTACION_PROACTIVA = UMBRALES.proactiva;
-
-/**
- * Ruta del archivo de estado interno de este monitor.
- * Almacena cuándo se emitió el último aviso y con qué severidad.
- */
-function rutaEstadoMonitor(sessionId) {
-  return path.join(os.tmpdir(), `swl-monitor-${sessionId}.json`);
-}
-
-// ---------------------------------------------------------------------------
-// Tipos de severidad
-// ---------------------------------------------------------------------------
-const SEVERIDAD = {
-  NINGUNA:  0,
-  WARNING:  1,
-  CRITICAL: 2,
-};
-
-// ---------------------------------------------------------------------------
-// Utilidades
-// ---------------------------------------------------------------------------
-
-/**
- * Lee el archivo bridge de linea-estado.js.
- * @param {string} sessionId
- * @returns {object|null} Payload del bridge o null si no existe/falla.
- */
-function leerBridge(sessionId) {
-  const bridgePath = path.join(os.tmpdir(), `swl-ctx-${sessionId}.json`);
-  try {
-    return JSON.parse(fs.readFileSync(bridgePath, 'utf8'));
-  } catch (_) {
-    return null;
-  }
-}
-
-/**
- * Lee el estado interno previo del monitor.
- * @param {string} estadoPath
- * @returns {{ ultimaInvocacion: number, ultimaSeveridad: number }}
- */
-function leerEstadoMonitor(estadoPath) {
-  try {
-    const datos = JSON.parse(fs.readFileSync(estadoPath, 'utf8'));
-    return {
-      ultimaInvocacion:  datos.ultimaInvocacion  ?? 0,
-      ultimaSeveridad:   datos.ultimaSeveridad   ?? SEVERIDAD.NINGUNA,
-      compresionEmitida: datos.compresionEmitida ?? false,
-    };
-  } catch (_) {
-    return { ultimaInvocacion: 0, ultimaSeveridad: SEVERIDAD.NINGUNA, compresionEmitida: false };
-  }
-}
-
-/**
- * Persiste el estado del monitor.
- * @param {string} estadoPath
- * @param {object} estado
- */
-function guardarEstadoMonitor(estadoPath, estado) {
-  try {
-    fs.writeFileSync(estadoPath, JSON.stringify(estado, null, 2), 'utf8');
-  } catch (_) {
-    // Ignorar errores de escritura — no bloquear el flujo
-  }
-}
-
-/**
- * Determina la severidad actual en función del porcentaje de uso.
- * @param {number} porcentajeUso - Porcentaje de contexto consumido (0-100).
- * @returns {number} Valor de SEVERIDAD.*
- */
-function calcularSeveridad(porcentajeUso) {
-  if (porcentajeUso >= UMBRAL_CRITICAL) return SEVERIDAD.CRITICAL;
-  if (porcentajeUso >= UMBRAL_WARNING)  return SEVERIDAD.WARNING;
-  return SEVERIDAD.NINGUNA;
-}
-
-/**
- * Detecta si la ultima operacion es un punto natural para compactar.
- * Puntos naturales:
- *   - Despues de un git commit exitoso
- *   - Despues de correr tests exitosamente
- *   - Cuando tool_name es "Agent" (fin de subagente)
- * @param {object} data - Payload del hook
- * @returns {boolean}
- */
-function esPuntoNatural(data) {
-  const toolName = String(data.tool_name || '');
-  const toolInput = data.tool_input || {};
-  const comando = String(toolInput.command || '');
-
-  // Despues de un commit exitoso
-  if (toolName === 'Bash' && /\bgit\s+commit\b/.test(comando)) return true;
-
-  // Despues de correr tests
-  if (toolName === 'Bash' && /\b(pytest|jest|vitest|go test|cargo test|dotnet test|phpunit|npm test)\b/.test(comando)) return true;
-
-  // Fin de un subagente
-  if (toolName === 'Agent') return true;
-
-  return false;
-}
-
-/**
- * Genera el mensaje de sugerencia de compactacion proactiva.
- * @param {number} porcentajeUso
- * @param {number} invocaciones
- * @returns {string}
- */
-function generarMensajeCompactacion(porcentajeUso, invocaciones) {
-  return [
-    '',
-    '--- SUGERENCIA DE COMPACTACION ---',
-    `  Contexto: ${porcentajeUso}% usado | ${invocaciones} tool calls en sesion`,
-    '  Punto natural de pausa detectado.',
-    '  Considera ejecutar /compact o /swl:compactar para liberar contexto',
-    '  antes de continuar con tareas complejas.',
-    '',
-  ].join('\n');
-}
-
-/**
- * Genera el mensaje de advertencia según severidad.
- * El mensaje se emite en stdout para que Claude Code lo procese
- * como feedback informativo dentro de la conversación.
- *
- * @param {number} severidad
- * @param {number} porcentajeUso
- * @param {number} porcentajeRestante
- * @returns {string}
- */
-function generarMensaje(severidad, porcentajeUso, porcentajeRestante) {
-  const barra = '█'.repeat(Math.round(porcentajeUso / 10)) +
-                '░'.repeat(10 - Math.round(porcentajeUso / 10));
-
-  if (severidad === SEVERIDAD.CRITICAL) {
-    return [
-      '',
-      '╔══════════════════════════════════════════════════════╗',
-      '║  CONTEXTO CRÍTICO — ACCIÓN REQUERIDA                 ║',
-      '╚══════════════════════════════════════════════════════╝',
-      `  Contexto usado: ${barra} ${porcentajeUso}%  (${porcentajeRestante}% restante)`,
-      '',
-      '  Acciones recomendadas:',
-      '  1. Guarda el estado actual con un commit atómico.',
-      '  2. Ejecuta /compact o solicita compactación del contexto.',
-      '  3. Divide la tarea en partes más pequeñas.',
-      '  4. No inicies trabajo complejo hasta compactar.',
-      '',
-    ].join('\n');
-  }
-
-  if (severidad === SEVERIDAD.WARNING) {
-    return [
-      '',
-      '⚠  ADVERTENCIA DE CONTEXTO',
-      `   Contexto usado: ${barra} ${porcentajeUso}%  (${porcentajeRestante}% restante)`,
-      '   Evitar tareas complejas. Considera compactar pronto.',
-      '',
-    ].join('\n');
-  }
-
-  return '';
-}
-
-// ---------------------------------------------------------------------------
-// Entrypoint principal
-// ---------------------------------------------------------------------------
-
-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');
-    const estadoPath = rutaEstadoMonitor(sessionId);
-
-    // Leer el bridge de linea-estado
-    const bridge = leerBridge(sessionId);
-    if (!bridge) {
-      // Sin bridge no hay datos — salir silenciosamente
-      return;
-    }
-
-    const porcentajeUso       = bridge.porcentaje     ?? 0;
-    const invocacionesActual  = bridge.invocaciones   ?? 0;
-    const porcentajeRestante  = 100 - porcentajeUso;
-    const severidadActual     = calcularSeveridad(porcentajeUso);
-
-    // Leer estado previo del monitor (necesario tanto para WARNING/CRITICAL como para proactiva)
-    const estadoPrevio = leerEstadoMonitor(estadoPath);
-    const { ultimaInvocacion, ultimaSeveridad } = estadoPrevio;
-
-    // Resetear flag de compresión si el contexto bajó (post-compactación real)
-    if (severidadActual < SEVERIDAD.CRITICAL && estadoPrevio.compresionEmitida) {
-      guardarEstadoMonitor(estadoPath, {
-        ...estadoPrevio,
-        compresionEmitida: false,
-        timestamp: new Date().toISOString(),
-      });
-    }
-
-    if (severidadActual !== SEVERIDAD.NINGUNA) {
-      // Determinar si debemos emitir aviso:
-      //   a) Escalación de severidad → siempre emitir (bypasea debounce)
-      //   b) Mismo nivel → solo si han pasado N_DEBOUNCE invocaciones
-      const esEscalacion = severidadActual > ultimaSeveridad;
-      const invocacionesDesdeUltimoAviso = invocacionesActual - ultimaInvocacion;
-      const debounceExpirado = invocacionesDesdeUltimoAviso >= N_DEBOUNCE;
-
-      const debeEmitir = esEscalacion || debounceExpirado;
-
-      if (debeEmitir) {
-        const mensaje = generarMensaje(severidadActual, porcentajeUso, porcentajeRestante);
-        if (mensaje) {
-          // Emitir advertencia como systemMessage (stderr causa hook error)
-          process.stdout.write(JSON.stringify({ systemMessage: mensaje }));
-        }
-
-        // Actualizar estado del monitor
-        guardarEstadoMonitor(estadoPath, {
-          ultimaInvocacion: invocacionesActual,
-          ultimaSeveridad:  severidadActual,
-          compresionEmitida: estadoPrevio.compresionEmitida || false,
-          timestamp:        new Date().toISOString(),
-        });
-      }
-    }
-
-    // --- Compresión automática Fase 1 (sin LLM) al llegar a CRITICAL ---
-    // Solo emitir UNA VEZ por sesión para evitar spam de banners
-    if (severidadActual === SEVERIDAD.CRITICAL && shouldCompress(porcentajeUso)) {
-      const yaEmitioBanner = estadoPrevio.compresionEmitida === true;
-      if (!yaEmitioBanner) {
-        try {
-          const mensajeCompresion = [
-            '',
-            '--- COMPRESION AUTOMATICA (Fases 1+1b) ---',
-            `  Contexto: ${porcentajeUso}% usado`,
-            '  Fase 1: tool results antiguos podados por posición.',
-            '  Fase 1b: resultados de Read/Bash/Grep/Glob > 15 turnos comprimidos por TTL.',
-            '  Para compresión avanzada (Fases 2-4), ejecuta /swl:compactar',
-            '  o pide: "comprime el contexto preservando las decisiones clave".',
-            '',
-          ].join('\n');
-          process.stdout.write(JSON.stringify({ systemMessage: mensajeCompresion }));
-          // Marcar como emitido para no repetir
-          guardarEstadoMonitor(estadoPath, {
-            ...estadoPrevio,
-            ultimaInvocacion: invocacionesActual,
-            ultimaSeveridad: severidadActual,
-            compresionEmitida: true,
-            timestamp: new Date().toISOString(),
-          });
-        } catch (_) {}
-      }
-    }
-
-    // --- Compactacion proactiva: sugerir en punto natural antes de alcanzar WARNING ---
-    if (severidadActual === SEVERIDAD.NINGUNA &&
-        porcentajeUso >= UMBRAL_COMPACTACION_PROACTIVA &&
-        invocacionesActual % N_COMPACTACION_PROACTIVA === 0 &&
-        esPuntoNatural(data)) {
-      const mensajeCompactacion = generarMensajeCompactacion(porcentajeUso, invocacionesActual);
-      process.stdout.write(JSON.stringify({ systemMessage: mensajeCompactacion }));
-    }
-
-  } catch (err) {
-    // El hook nunca bloquea por errores internos
-    // No escribir a stderr — Claude Code lo reporta como hook error
-  }
-});