@saulwade/swl-ses 1.0.0

package/hooks/tracking-costos.js

@@ -0,0 +1,688 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Hook: tracking-costos.js
+ * Tipo: PostToolUse
+ *
+ * Registra el consumo estimado de tokens y costo en USD por sesión.
+ * Cada invocación acumula los datos en un archivo bridge por sesión en /tmp/
+ * y actualiza .planning/METRICAS.md cada INTERVALO_ACTUALIZACION tool calls.
+ *
+ * Umbrales de presupuesto (configurables en hooks-config.json):
+ *   - alertAt (defecto 0.80): emite WARNING en stderr al superar el 80%
+ *   - 100%: emite ALERTA CRITICA en stderr
+ *
+ * El presupuesto base se lee de hooks-config.json (costBudget).
+ * Fallback si no existe: $10.00 USD / 500,000 tokens.
+ *
+ * El hook nunca bloquea (siempre exit 0). Es PostToolUse informativo.
+ * Los mensajes de alerta se emiten en stderr con prefijo [tracking-costos].
+ */
+
+const fs   = require('fs');
+const path = require('path');
+const os   = require('os');
+
+// ---------------------------------------------------------------------------
+// Dependencias internas
+// ---------------------------------------------------------------------------
+
+const {
+  estimarToolCall,
+  formatearCosto,
+  formatearNumero,
+  inferirFamiliaModelo,
+} = require('./lib/token-estimator');
+
+const bus    = require('./lib/event-bus');
+const runLog = require('./lib/run-log');
+const { quota } = require('./lib/resource-quota');
+
+// Importar modelo de uso con guard de robustez — el hook no debe fallar
+// si el módulo aún no existe en instalaciones anteriores del sistema.
+let usageModel = null;
+try {
+  usageModel = require('./lib/usage-model');
+} catch (_) {
+  // Módulo no disponible — usar estimación heurística como fallback
+}
+
+// ---------------------------------------------------------------------------
+// Constantes de configuración
+// ---------------------------------------------------------------------------
+
+/**
+ * Cada cuántas tool calls se actualiza METRICAS.md.
+ * Reducir este valor genera más I/O; aumentarlo hace el reporte menos frecuente.
+ */
+const INTERVALO_ACTUALIZACION = 20;
+
+/** Presupuesto por defecto si no hay hooks-config.json. */
+const PRESUPUESTO_DEFAULT = {
+  maxUsd:    10.0,
+  maxTokens: 500_000,
+  alertAt:   0.80,
+};
+
+/** Ruta del manifesto de configuración de hooks. */
+const RUTA_HOOKS_CONFIG = path.join(process.cwd(), 'manifiestos', 'hooks-config.json');
+
+/** Ruta del archivo de métricas de sesión. */
+const RUTA_METRICS = path.join(process.cwd(), '.planning', 'METRICAS.md');
+
+// ---------------------------------------------------------------------------
+// Utilidades de configuración
+// ---------------------------------------------------------------------------
+
+/**
+ * Lee el presupuesto configurado en hooks-config.json.
+ * Si el archivo no existe o está malformado, devuelve el presupuesto por defecto.
+ *
+ * @returns {{ maxUsd: number, maxTokens: number, alertAt: number }}
+ */
+function leerPresupuesto() {
+  try {
+    const raw = fs.readFileSync(RUTA_HOOKS_CONFIG, 'utf8');
+    const config = JSON.parse(raw);
+    const budget = config.costBudget || {};
+    return {
+      maxUsd:    typeof budget.maxUsd    === 'number' ? budget.maxUsd    : PRESUPUESTO_DEFAULT.maxUsd,
+      maxTokens: typeof budget.maxTokens === 'number' ? budget.maxTokens : PRESUPUESTO_DEFAULT.maxTokens,
+      alertAt:   typeof budget.alertAt   === 'number' ? budget.alertAt   : PRESUPUESTO_DEFAULT.alertAt,
+    };
+  } catch (_) {
+    return { ...PRESUPUESTO_DEFAULT };
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Bridge de estado de sesión (/tmp)
+// ---------------------------------------------------------------------------
+
+/**
+ * Devuelve la ruta del archivo bridge para la sesión dada.
+ *
+ * @param {string} sessionId
+ * @returns {string}
+ */
+function rutaBridge(sessionId) {
+  return path.join(os.tmpdir(), `swl-costs-${sessionId}.json`);
+}
+
+/**
+ * Estado inicial vacío para una nueva sesión.
+ *
+ * @returns {object}
+ */
+function estadoInicial() {
+  return {
+    sessionId:          '',
+    toolCalls:          0,
+    tokensTotal:        0,
+    costoTotal:         0,
+    modeloPredominante: 'sonnet',
+    inicio:             new Date().toISOString(),
+    ultimaActualizacion: new Date().toISOString(),
+    // Desglose por herramienta: { NombreTool: { llamadas, tokens } }
+    desglosePorHerramienta: {},
+    // Contador de usos por modelo para determinar el predominante
+    conteoPorModelo: {},
+    // Componentes SWL usados en la sesión
+    componentesSWL: {
+      agentes:      [],   // agentes invocados via Agent tool
+      skills:       [],   // skills cargados via Skill tool
+      scripts:      [],   // scripts/ modificados o ejecutados
+      hooks:        [],   // hooks que se ejecutaron (auto-registrado)
+      reglas:       [],   // reglas/ tocadas
+      comandos:     [],   // comandos /swl:* invocados
+    },
+    // Métricas por agente: { agentName: { llamadas, tokens, costo } }
+    // Permite calcular costo-por-resolución y detectar agentes costosos.
+    costePorAgente: {},
+  };
+}
+
+/**
+ * Lee el estado acumulado del bridge de la sesión.
+ * Si el archivo no existe, devuelve un estado inicial limpio.
+ *
+ * @param {string} bridgePath
+ * @returns {object}
+ */
+function leerEstado(bridgePath) {
+  try {
+    const raw = fs.readFileSync(bridgePath, 'utf8');
+    const datos = JSON.parse(raw);
+    // Asegurar que los campos opcionales existen (compatibilidad con versiones previas)
+    datos.desglosePorHerramienta = datos.desglosePorHerramienta || {};
+    datos.conteoPorModelo        = datos.conteoPorModelo        || {};
+    datos.costePorAgente         = datos.costePorAgente         || {};
+    return datos;
+  } catch (_) {
+    return estadoInicial();
+  }
+}
+
+/**
+ * Persiste el estado de la sesión en el archivo bridge.
+ *
+ * @param {string} bridgePath
+ * @param {object} estado
+ */
+function guardarEstado(bridgePath, estado) {
+  try {
+    fs.writeFileSync(bridgePath, JSON.stringify(estado, null, 2), 'utf8');
+  } catch (err) {
+    // Error al escribir bridge — ignorar silenciosamente
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Actualización de estado acumulado
+// ---------------------------------------------------------------------------
+
+/**
+ * Acumula los datos de la invocación actual en el estado de sesión.
+ *
+ * @param {object} estado     - Estado actual leído del bridge.
+ * @param {string} toolName   - Nombre de la herramienta invocada.
+ * @param {string} modelLabel - Etiqueta corta del modelo.
+ * @param {string} sessionId  - ID de sesión.
+ * @param {object} toolInput  - Parámetros de entrada de la herramienta.
+ * @returns {object} Estado actualizado (muta y devuelve la misma referencia).
+ */
+/**
+ * Extrae tokens reales del payload PostToolUse si están disponibles.
+ * Claude Code puede exponer campos de uso en tool_result para llamadas LLM.
+ *
+ * @param {object} data - Payload completo del evento PostToolUse.
+ * @returns {{ inputTokens: number, outputTokens: number, cachedTokens: number, reasoningTokens: number }|null}
+ *          Datos reales o null si no están disponibles en el payload.
+ */
+function extraerTokensReales(data) {
+  // Claude Code expone usage en varios lugares según la versión del evento
+  const uso = data.usage
+    || (data.tool_result && data.tool_result.usage)
+    || (data.result && data.result.usage)
+    || null;
+  if (!uso) return null;
+
+  const inputTokens     = Number(uso.input_tokens  || uso.inputTokens  || 0);
+  const outputTokens    = Number(uso.output_tokens || uso.outputTokens || 0);
+  const cachedTokens    = Number(uso.cache_read_input_tokens || uso.cached_tokens  || uso.cachedTokens  || 0);
+  const reasoningTokens = Number(uso.reasoning_tokens       || uso.reasoningTokens || 0);
+
+  if (inputTokens === 0 && outputTokens === 0) return null;
+  return { inputTokens, outputTokens, cachedTokens, reasoningTokens };
+}
+
+function acumularInvocacion(estado, toolName, modelLabel, sessionId, toolInput, dataCompleto) {
+  // Intentar usar tokens reales del payload antes de recurrir a estimación
+  let tokensEstimados;
+  let costoEstimado;
+  let tokensRealesUsados = false;
+
+  const tokensReales = dataCompleto ? extraerTokensReales(dataCompleto) : null;
+
+  if (tokensReales && usageModel) {
+    // Datos reales disponibles — usar Usage model para tracking preciso
+    if (!estado.usageModel) {
+      estado.usageModel = usageModel.crearUsage().serialize();
+    }
+    const usoActual = usageModel.fromJSON(estado.usageModel);
+    usoActual.addEntrada({
+      inputTokens:     tokensReales.inputTokens,
+      outputTokens:    tokensReales.outputTokens,
+      cachedTokens:    tokensReales.cachedTokens,
+      reasoningTokens: tokensReales.reasoningTokens,
+      modelo:          modelLabel,
+    });
+    estado.usageModel = usoActual.serialize();
+
+    tokensEstimados    = tokensReales.inputTokens + tokensReales.outputTokens;
+    tokensRealesUsados = true;
+    // Estimar costo desde tokens reales con la misma función de precios
+    const { costoEstimado: costoBase } = estimarToolCall(toolName, modelLabel);
+    // Escalar el costo estimado proporcionalmente a los tokens reales
+    const { tokensEstimados: tokensBase } = estimarToolCall(toolName, modelLabel);
+    costoEstimado = tokensBase > 0
+      ? (costoBase / tokensBase) * tokensEstimados
+      : costoBase;
+  } else {
+    // Fallback a estimación heurística (comportamiento original)
+    const estimacion = estimarToolCall(toolName, modelLabel);
+    tokensEstimados  = estimacion.tokensEstimados;
+    costoEstimado    = estimacion.costoEstimado;
+  }
+
+  estado.sessionId           = sessionId;
+  estado.toolCalls          += 1;
+  estado.tokensTotal        += tokensEstimados;
+  estado.costoTotal         += costoEstimado;
+  // Indicar si la entrada tiene tokens reales (para auditabilidad)
+  if (tokensRealesUsados) estado.ultimaEntradaConTokensReales = true;
+  estado.ultimaActualizacion = new Date().toISOString();
+
+  // Desglose por herramienta
+  if (!estado.desglosePorHerramienta[toolName]) {
+    estado.desglosePorHerramienta[toolName] = { llamadas: 0, tokens: 0 };
+  }
+  estado.desglosePorHerramienta[toolName].llamadas += 1;
+  estado.desglosePorHerramienta[toolName].tokens   += tokensEstimados;
+
+  // Conteo por modelo para determinar el predominante
+  if (!estado.conteoPorModelo[modelLabel]) {
+    estado.conteoPorModelo[modelLabel] = 0;
+  }
+  estado.conteoPorModelo[modelLabel] += 1;
+
+  // Actualizar modelo predominante (el que tiene más llamadas)
+  const modeloPred = Object.entries(estado.conteoPorModelo)
+    .sort(([, a], [, b]) => b - a)[0];
+  estado.modeloPredominante = modeloPred ? modeloPred[0] : modelLabel;
+
+  // Rastrear componentes SWL usados
+  rastrearComponentesSWL(estado, toolName, toolInput);
+
+  // Registrar en resource-quota para verificación de límites rolling
+  try {
+    quota.registrar({ tokens: tokensEstimados, costoUsd: costoEstimado, agente: toolName });
+    const check = quota.verificar();
+    if (check.excedido) {
+      process.stderr.write(`[tracking-costos] ALERTA QUOTA: ${check.mensaje}\n`);
+    } else if (check.warnings.length > 0) {
+      process.stderr.write(`[tracking-costos] ${check.mensaje}\n`);
+    }
+  } catch { /* no bloquear por fallo de quota */ }
+
+  return estado;
+}
+
+/**
+ * Detecta y registra componentes SWL usados a partir de la herramienta y sus parámetros.
+ * También acumula métricas de costo por agente para análisis de rendimiento.
+ */
+function rastrearComponentesSWL(estado, toolName, toolInput) {
+  if (!estado.componentesSWL) {
+    estado.componentesSWL = { agentes: [], skills: [], scripts: [], hooks: [], reglas: [], comandos: [] };
+  }
+  if (!estado.costePorAgente) {
+    estado.costePorAgente = {};
+  }
+  const c = estado.componentesSWL;
+  const input = toolInput || {};
+
+  // Agent tool → registrar agente invocado y acumular costo estimado
+  if (toolName === 'Agent') {
+    const tipo = String(input.subagent_type || input.description || '').slice(0, 60);
+    if (tipo) {
+      if (!c.agentes.includes(tipo)) c.agentes.push(tipo);
+      // Acumular costo/tokens para este agente
+      // Los subagentes son llamadas "Agent" cuyo costo es proporcional al de la herramienta.
+      const { tokensEstimados, costoEstimado } = estimarToolCall('Agent', estado.modeloPredominante || 'sonnet');
+      if (!estado.costePorAgente[tipo]) {
+        estado.costePorAgente[tipo] = { llamadas: 0, tokens: 0, costo: 0 };
+      }
+      estado.costePorAgente[tipo].llamadas += 1;
+      estado.costePorAgente[tipo].tokens   += tokensEstimados;
+      estado.costePorAgente[tipo].costo    += costoEstimado;
+    }
+  }
+
+  // Skill tool → registrar skill cargado
+  if (toolName === 'Skill') {
+    const nombre = String(input.skill || '').trim();
+    if (nombre && !c.skills.includes(nombre)) c.skills.push(nombre);
+  }
+
+  // Bash tool → detectar comandos /swl:* y ejecución de scripts
+  if (toolName === 'Bash') {
+    const cmd = String(input.command || '');
+    // Detectar /swl:* invocados via skill
+    const swlMatch = cmd.match(/swl:([a-z-]+)/);
+    if (swlMatch && !c.comandos.includes(`/swl:${swlMatch[1]}`)) {
+      c.comandos.push(`/swl:${swlMatch[1]}`);
+    }
+    // Detectar ejecución de scripts SWL
+    const scriptMatch = cmd.match(/node\s+(?:scripts|bin)\/([^\s]+)/);
+    if (scriptMatch && !c.scripts.includes(scriptMatch[1])) {
+      c.scripts.push(scriptMatch[1]);
+    }
+  }
+
+  // Write/Edit → detectar archivos SWL modificados
+  if (toolName === 'Write' || toolName === 'Edit') {
+    const filePath = String(input.file_path || '');
+    // Detectar scripts modificados
+    const scriptMatch = filePath.match(/scripts\/(?:lib\/)?([^/]+\.js)/);
+    if (scriptMatch && !c.scripts.includes(scriptMatch[1])) {
+      c.scripts.push(scriptMatch[1]);
+    }
+    // Detectar hooks modificados
+    const hookMatch = filePath.match(/hooks\/([^/]+\.js)/);
+    if (hookMatch && !c.hooks.includes(hookMatch[1])) {
+      c.hooks.push(hookMatch[1]);
+    }
+    // Detectar reglas modificadas
+    const reglaMatch = filePath.match(/reglas\/([^/]+\.md)/);
+    if (reglaMatch && !c.reglas.includes(reglaMatch[1])) {
+      c.reglas.push(reglaMatch[1]);
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Generación de METRICAS.md
+// ---------------------------------------------------------------------------
+
+/**
+ * Calcula la duración estimada de la sesión en minutos.
+ * Heurística: cada tool call toma ~30 segundos en promedio.
+ *
+ * @param {string} inicio - ISO timestamp de inicio de sesión.
+ * @param {number} toolCalls - Número total de tool calls.
+ * @returns {number} Minutos estimados.
+ */
+function estimarDuracionMinutos(inicio, toolCalls) {
+  try {
+    const ms = Date.now() - new Date(inicio).getTime();
+    const minutosPorTiempo = ms / 60_000;
+    const minutosPorCalls  = toolCalls * 0.5; // 30 seg por call
+    // Usar el mayor de los dos para ser conservadores
+    return Math.round(Math.max(minutosPorTiempo, minutosPorCalls));
+  } catch (_) {
+    return Math.round(toolCalls * 0.5);
+  }
+}
+
+/**
+ * Genera la sección de componentes SWL usados en la sesión.
+ * Solo incluye categorías con al menos un componente.
+ */
+function generarSeccionComponentesSWL(componentesSWL) {
+  if (!componentesSWL) return '';
+
+  const categorias = [
+    { clave: 'agentes',  titulo: 'Agentes' },
+    { clave: 'skills',   titulo: 'Skills' },
+    { clave: 'scripts',  titulo: 'Scripts' },
+    { clave: 'hooks',    titulo: 'Hooks' },
+    { clave: 'reglas',   titulo: 'Reglas' },
+    { clave: 'comandos', titulo: 'Comandos' },
+  ];
+
+  const filas = categorias
+    .filter(cat => (componentesSWL[cat.clave] || []).length > 0)
+    .map(cat => `| ${cat.titulo.padEnd(10)} | ${componentesSWL[cat.clave].join(', ')} |`);
+
+  if (filas.length === 0) return '';
+
+  return [
+    '## Componentes SWL Utilizados',
+    '| Tipo       | Componentes |',
+    '|------------|-------------|',
+    ...filas,
+    '',
+  ].join('\n');
+}
+
+/**
+ * Genera la sección de rendimiento por agente.
+ * Muestra llamadas, tokens, costo y costo promedio por invocación.
+ *
+ * @param {object} costePorAgente - Mapa { agentName: { llamadas, tokens, costo } }
+ * @param {number} costoTotal     - Costo total de la sesión (para calcular % por agente).
+ * @returns {string}
+ */
+function generarSeccionAgentes(costePorAgente, costoTotal) {
+  if (!costePorAgente || Object.keys(costePorAgente).length === 0) return '';
+
+  // Ordenar por costo descendente
+  const filas = Object.entries(costePorAgente)
+    .sort(([, a], [, b]) => b.costo - a.costo)
+    .map(([nombre, datos]) => {
+      const pctCosto    = costoTotal > 0 ? Math.round((datos.costo / costoTotal) * 100) : 0;
+      const costoPorInv = datos.llamadas > 0 ? (datos.costo / datos.llamadas) : 0;
+      const nombreCorto = nombre.length > 30 ? nombre.slice(0, 27) + '...' : nombre;
+      return `| ${nombreCorto.padEnd(32)} | ${String(datos.llamadas).padStart(8)} | ${formatearCosto(datos.costo).padStart(10)} | ${String(pctCosto + '%').padStart(8)} | ${formatearCosto(costoPorInv).padStart(12)} |`;
+    })
+    .join('\n');
+
+  return [
+    '## Rendimiento por Agente',
+    '| Agente                           | Llamadas | Costo est. | % total | Costo/llamada |',
+    '|----------------------------------|----------|------------|---------|---------------|',
+    filas,
+    '',
+  ].join('\n');
+}
+
+/**
+ * Genera el contenido completo de METRICAS.md a partir del estado actual.
+ *
+ * @param {object} estado      - Estado acumulado de la sesión.
+ * @param {object} presupuesto - Presupuesto configurado.
+ * @returns {string} Contenido markdown completo.
+ */
+function generarMetrics(estado, presupuesto) {
+  const {
+    toolCalls,
+    tokensTotal,
+    costoTotal,
+    modeloPredominante,
+    inicio,
+    ultimaActualizacion,
+    desglosePorHerramienta,
+    componentesSWL,
+    costePorAgente,
+  } = estado;
+
+  const duracion    = estimarDuracionMinutos(inicio, toolCalls);
+  const pctCosto    = presupuesto.maxUsd    > 0 ? (costoTotal / presupuesto.maxUsd)    * 100 : 0;
+  const pctTokens   = presupuesto.maxTokens > 0 ? (tokensTotal / presupuesto.maxTokens) * 100 : 0;
+
+  // Estado del presupuesto
+  let estadoPresupuesto;
+  if (pctCosto >= 100 || pctTokens >= 100) {
+    estadoPresupuesto = 'PRESUPUESTO SUPERADO';
+  } else if (pctCosto >= presupuesto.alertAt * 100 || pctTokens >= presupuesto.alertAt * 100) {
+    estadoPresupuesto = 'CERCA DEL LIMITE';
+  } else {
+    estadoPresupuesto = 'DENTRO DE PRESUPUESTO';
+  }
+
+  // Tabla de desglose por herramienta (ordenada por tokens desc)
+  const filasDesglose = Object.entries(desglosePorHerramienta)
+    .sort(([, a], [, b]) => b.tokens - a.tokens)
+    .map(([herramienta, datos]) => {
+      const pct = tokensTotal > 0
+        ? Math.round((datos.tokens / tokensTotal) * 100)
+        : 0;
+      return `| ${herramienta.padEnd(16)} | ${String(datos.llamadas).padStart(8)} | ${formatearNumero(datos.tokens).padStart(11)} | ${String(pct + '%').padStart(11)} |`;
+    })
+    .join('\n');
+
+  const tablaDesglose = filasDesglose.length > 0
+    ? filasDesglose
+    : '| (sin datos)      |        0 |           0 |          0% |';
+
+  return [
+    '# Metricas de Sesion',
+    '',
+    `**Ultima actualizacion**: ${ultimaActualizacion}`,
+    '',
+    '## Resumen',
+    '| Metrica | Valor |',
+    '|---------|-------|',
+    `| Tool calls totales | ${formatearNumero(toolCalls)} |`,
+    `| Tokens estimados | ~${formatearNumero(tokensTotal)} |`,
+    `| Costo estimado | ~${formatearCosto(costoTotal)} USD |`,
+    `| Modelo predominante | ${modeloPredominante} |`,
+    `| Duracion estimada | ~${duracion} min |`,
+    '',
+    '## Desglose por Herramienta',
+    '| Herramienta      | Llamadas | Tokens est. | % del total |',
+    '|------------------|----------|-------------|-------------|',
+    tablaDesglose,
+    '',
+    generarSeccionAgentes(costePorAgente, costoTotal),
+    generarSeccionComponentesSWL(componentesSWL),
+    '',
+    '## Presupuesto',
+    '',
+    `- Limite: ${formatearCosto(presupuesto.maxUsd)} USD / ${formatearNumero(presupuesto.maxTokens)} tokens`,
+    `- Consumido: ${formatearCosto(costoTotal)} USD (${pctCosto.toFixed(1)}%) / ${formatearNumero(tokensTotal)} tokens (${pctTokens.toFixed(1)}%)`,
+    `- Estado: ${estadoPresupuesto}`,
+    '',
+  ].join('\n');
+}
+
+/**
+ * Escribe el archivo METRICAS.md en .planning/.
+ * Crea el directorio si no existe.
+ *
+ * @param {object} estado      - Estado acumulado.
+ * @param {object} presupuesto - Presupuesto configurado.
+ */
+function escribirMetrics(estado, presupuesto) {
+  try {
+    const dir = path.dirname(RUTA_METRICS);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    const contenido = generarMetrics(estado, presupuesto);
+    fs.writeFileSync(RUTA_METRICS, contenido, 'utf8');
+  } catch (err) {
+    // Error al escribir METRICAS.md — ignorar silenciosamente
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Alertas de presupuesto
+// ---------------------------------------------------------------------------
+
+/**
+ * Emite advertencias de presupuesto en stderr si se superan los umbrales.
+ * WARNING al superar alertAt (defecto 80%). CRITICO al superar el 100%.
+ *
+ * @param {number} costoTotal      - Costo acumulado en USD.
+ * @param {number} tokensTotal     - Tokens acumulados.
+ * @param {object} presupuesto     - Presupuesto configurado.
+ */
+function verificarPresupuesto(costoTotal, tokensTotal, presupuesto) {
+  const pctCosto   = presupuesto.maxUsd    > 0 ? costoTotal  / presupuesto.maxUsd    : 0;
+  const pctTokens  = presupuesto.maxTokens > 0 ? tokensTotal / presupuesto.maxTokens : 0;
+  const pctMax     = Math.max(pctCosto, pctTokens);
+
+  // Las alertas de presupuesto se manejan silenciosamente en el bridge.
+  // Claude Code reporta stderr como hook error, así que no se emiten alertas aquí.
+  // El estado se refleja en METRICAS.md que se actualiza periódicamente.
+}
+
+// ---------------------------------------------------------------------------
+// Entrypoint principal
+// ---------------------------------------------------------------------------
+
+let inputRaw = '';
+
+process.stdin.on('data', chunk => {
+  inputRaw += chunk;
+});
+
+process.stdin.on('end', () => {
+  try {
+    const data = JSON.parse(inputRaw);
+
+    // Extraer campos del evento PostToolUse
+    const sessionId = String(data.session_id || 'default');
+    const modelId   = String(data.model       || '');
+    const toolName  = String(data.tool_name   || 'Unknown');
+    const toolInput = data.tool_input || {};
+
+    // Inferir etiqueta del modelo para el estimador
+    const modelLabel = inferirFamiliaModelo(modelId);
+
+    // Leer presupuesto configurado
+    const presupuesto = leerPresupuesto();
+
+    // Leer estado acumulado del bridge
+    const bridge = rutaBridge(sessionId);
+    const estado = leerEstado(bridge);
+
+    // Acumular invocación actual (incluye rastreo de componentes SWL)
+    // Se pasa `data` completo para extraer tokens reales si están disponibles.
+    acumularInvocacion(estado, toolName, modelLabel, sessionId, toolInput, data);
+
+    // Persistir estado actualizado
+    guardarEstado(bridge, estado);
+
+    // -----------------------------------------------------------------------
+    // Publicar evento al bus (observabilidad desacoplada)
+    // -----------------------------------------------------------------------
+    const esNuevaSession = estado.toolCalls === 1;
+    if (esNuevaSession) {
+      // Primera invocación: registrar inicio de sesión en JSONL
+      runLog.sessionStart(sessionId, { cwd: process.cwd(), model: modelLabel });
+      runLog.limpiarRunsAntiguos();
+      bus.publish({ type: 'session-start', runId: sessionId, cwd: process.cwd(), model: modelLabel });
+    }
+
+    // Publicar evento de tool-call al bus
+    bus.publish({
+      type:       'tool-call',
+      runId:      sessionId,
+      toolName:   toolName,
+      modelLabel: modelLabel,
+    });
+
+    // Registrar en JSONL de run cada 5 tool calls (balance entre trazabilidad e I/O)
+    if (estado.toolCalls % 5 === 0 || esNuevaSession) {
+      runLog.toolCall(sessionId, toolName, { callNumber: estado.toolCalls });
+    }
+
+    // Registrar agentes y skills detectados en JSONL
+    const c = estado.componentesSWL || {};
+    if (toolName === 'Agent') {
+      const agName = String((toolInput || {}).subagent_type || (toolInput || {}).description || '').slice(0, 60);
+      if (agName) runLog.agentInvoked(sessionId, agName);
+    }
+    if (toolName === 'Skill') {
+      const skName = String((toolInput || {}).skill || '').trim();
+      if (skName) runLog.skillLoaded(sessionId, skName);
+    }
+
+    // Verificar alertas de presupuesto en cada invocación
+    verificarPresupuesto(estado.costoTotal, estado.tokensTotal, presupuesto);
+
+    // Actualizar METRICAS.md cada INTERVALO_ACTUALIZACION tool calls
+    if (estado.toolCalls % INTERVALO_ACTUALIZACION === 0) {
+      escribirMetrics(estado, presupuesto);
+    }
+
+    // Sincronizar con session-store cada INTERVALO_ACTUALIZACION
+    if (estado.toolCalls % INTERVALO_ACTUALIZACION === 0) {
+      try {
+        const { actualizarSesion } = require('./lib/session-store');
+        const cwd = process.cwd();
+        actualizarSesion(cwd, {
+          toolCall: toolName,
+          tokensEstimated: estado.tokensTotal,
+          costEstimated: estado.costoTotal,
+        });
+        // Registrar agentes y skills detectados
+        const c = estado.componentesSWL || {};
+        for (const ag of (c.agentes || [])) {
+          actualizarSesion(cwd, { agentInvoked: ag });
+        }
+      } catch (_) {
+        // session-store no disponible — continuar sin sincronizar
+      }
+    }
+
+    // PostToolUse: no escribir a stdout — salida limpia.
+
+  } catch (err) {
+    // No escribir a stderr — Claude Code lo reporta como hook error
+  }
+});

package/instintos/global.yaml

@@ -0,0 +1,8 @@
+# Instintos Globales — SWL-SES
+# Aplican a todos los proyectos. Solo se promueven instintos con confidence > 0.8
+
+version: "1.0"
+generado: "2026-03-31"
+total_instintos: 0
+
+instintos: []