@saulwade/swl-ses 1.0.0

package/scripts/lib/span-schema.js

@@ -0,0 +1,134 @@
+'use strict';
+
+/**
+ * Esquema de tipos de span para telemetría de agentes.
+ *
+ * Portado desde openai-agents-python / src/agents/tracing/span_data.py
+ * Licencia origen: MIT. Traducción a JS: SWL (español es-MX).
+ *
+ * Proporciona la taxonomía de 13 tipos de span usados en el sistema de
+ * trazas OTLP-lite de swl-ses, garantizando consistencia entre el hook
+ * telemetria-agentes.js y los exportadores que consumen .planning/traces/.
+ *
+ * @module scripts/lib/span-schema
+ */
+
+// ---------------------------------------------------------------------------
+// Constantes
+// ---------------------------------------------------------------------------
+
+/**
+ * Tipos de span válidos en el sistema de trazas.
+ * Congelado para prevenir mutaciones accidentales en tiempo de ejecución.
+ *
+ * Correspondencia con openai-agents-python:
+ *   - agent        → AgentSpanData
+ *   - function     → FunctionSpanData
+ *   - generation   → GenerationSpanData
+ *   - handoff      → HandoffSpanData
+ *   - guardrail    → GuardrailSpanData
+ *   - turn         → TurnSpanData
+ *   - task         → TaskSpanData
+ *   - mcp_list_tools → MCPListToolsSpanData
+ *   - response     → ResponseSpanData
+ *   - speech       → SpeechSpanData
+ *   - transcription → TranscriptionSpanData
+ *   - speech_group → SpeechGroupSpanData
+ *   - custom       → CustomSpanData
+ *
+ * @type {Readonly<{[key: string]: string}>}
+ */
+const SPAN_TYPES = Object.freeze({
+  /** Invocación de un agente SWL (subagente orquestado). */
+  AGENT:           'agent',
+  /** Invocación de una herramienta/función por el agente. */
+  FUNCTION:        'function',
+  /** Llamada de generación al modelo LLM. */
+  GENERATION:      'generation',
+  /** Traspaso de control entre agentes (handoff). */
+  HANDOFF:         'handoff',
+  /** Activación de un guardrail de validación de input/output. */
+  GUARDRAIL:       'guardrail',
+  /** Un turno del loop del agente. */
+  TURN:            'turn',
+  /** Una ejecución completa de alto nivel (task runner run). */
+  TASK:            'task',
+  /** Listado de herramientas disponibles en un servidor MCP. */
+  MCP_LIST_TOOLS:  'mcp_list_tools',
+  /** Span de respuesta del modelo (responses API). */
+  RESPONSE:        'response',
+  /** Síntesis de voz (TTS). */
+  SPEECH:          'speech',
+  /** Transcripción de voz a texto (STT). */
+  TRANSCRIPTION:   'transcription',
+  /** Agrupación de spans de voz relacionados. */
+  SPEECH_GROUP:    'speech_group',
+  /** Span personalizado para eventos sin categoría definida. */
+  CUSTOM:          'custom',
+});
+
+/**
+ * Conjunto de valores válidos (para validación O(1)).
+ * @type {Set<string>}
+ */
+const _TIPOS_VALIDOS = new Set(Object.values(SPAN_TYPES));
+
+// ---------------------------------------------------------------------------
+// Funciones exportadas
+// ---------------------------------------------------------------------------
+
+/**
+ * Verifica si un string es un tipo de span válido en la taxonomía.
+ *
+ * @param {string} tipo - Valor a verificar.
+ * @returns {boolean} true si es un tipo de span reconocido.
+ *
+ * @example
+ * esTipoSpanValido('agent')    // → true
+ * esTipoSpanValido('unknown')  // → false
+ */
+function esTipoSpanValido(tipo) {
+  return _TIPOS_VALIDOS.has(tipo);
+}
+
+/**
+ * Construye un objeto de span estandarizado con los campos requeridos.
+ * Valida el tipo antes de construir — lanza TypeError si el tipo no es válido.
+ *
+ * @param {object} opciones - Parámetros del span.
+ * @param {string} opciones.tipo - Tipo de span (debe estar en SPAN_TYPES).
+ * @param {string} opciones.nombre - Nombre descriptivo del span (ej. "agent:revisor-swl").
+ * @param {object} [opciones.datos] - Payload específico del tipo de span.
+ * @param {string} [opciones.timestamp] - ISO timestamp de inicio (por defecto: ahora).
+ * @param {string} [opciones.traceId] - ID de traza padre (opcional).
+ * @param {string} [opciones.parentSpanId] - ID del span padre (opcional).
+ * @returns {{ tipo: string, nombre: string, datos: object, timestamp: string, traceId: string|null, parentSpanId: string|null }}
+ *
+ * @throws {TypeError} Si el tipo no es un valor válido de SPAN_TYPES.
+ *
+ * @example
+ * construirSpan({ tipo: 'agent', nombre: 'agent:planificador-swl' })
+ * // → { tipo: 'agent', nombre: 'agent:planificador-swl', datos: {}, timestamp: '...', traceId: null, parentSpanId: null }
+ */
+function construirSpan({ tipo, nombre, datos = {}, timestamp, traceId = null, parentSpanId = null }) {
+  if (!esTipoSpanValido(tipo)) {
+    throw new TypeError(
+      `Tipo de span inválido: "${tipo}". Tipos válidos: ${[..._TIPOS_VALIDOS].join(', ')}`
+    );
+  }
+
+  return {
+    tipo,
+    nombre:       String(nombre || ''),
+    datos:        datos && typeof datos === 'object' ? { ...datos } : {},
+    timestamp:    timestamp || new Date().toISOString(),
+    traceId:      traceId      || null,
+    parentSpanId: parentSpanId || null,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Exports
+// ---------------------------------------------------------------------------
+
+module.exports = { SPAN_TYPES, esTipoSpanValido, construirSpan };

package/scripts/lib/tool-cost-analyzer.js

@@ -0,0 +1,255 @@
+'use strict';
+
+/**
+ * tool-cost-analyzer.js
+ *
+ * Consulta ~/.claude/usage.db (SQLite generado por claude-usage) y devuelve
+ * métricas de costo por tool_name. Útil para identificar qué herramientas SWL
+ * consumen más tokens en sesiones reales.
+ *
+ * Uso programático:
+ *   const analyzer = require('./tool-cost-analyzer');
+ *   const metricas = await analyzer.obtenerMetricasPorHerramienta({ dias: 30 });
+ *
+ * Requiere: better-sqlite3 o sqlite3. Usa execFile('python') como fallback.
+ */
+
+const { execFile } = require('child_process');
+const path   = require('path');
+const os     = require('os');
+const fs     = require('fs');
+
+const DB_PATH = path.join(os.homedir(), '.claude', 'usage.db');
+
+// Precios estimados por 1M tokens (USD) — actualizados a 2026-04-17
+const PRECIOS = {
+  'claude-opus-4-7':    { input: 15.00, output: 75.00, cache_read: 1.50,  cache_creation: 18.75 },
+  'claude-opus-4-6':    { input: 15.00, output: 75.00, cache_read: 1.50,  cache_creation: 18.75 },
+  'claude-sonnet-4-6':  { input:  3.00, output: 15.00, cache_read: 0.30,  cache_creation:  3.75 },
+  'claude-haiku-4-5':   { input:  0.80, output:  4.00, cache_read: 0.08,  cache_creation:  1.00 },
+};
+const PRECIO_DEFAULT = { input: 3.00, output: 15.00, cache_read: 0.30, cache_creation: 3.75 };
+
+/**
+ * Calcula el costo estimado a partir de tokens y modelo.
+ */
+function calcularCosto(tokens, modelo) {
+  const precios = PRECIOS[modelo] || PRECIO_DEFAULT;
+  return (
+    ((tokens.input          || 0) * precios.input          / 1_000_000) +
+    ((tokens.output         || 0) * precios.output         / 1_000_000) +
+    ((tokens.cache_read     || 0) * precios.cache_read     / 1_000_000) +
+    ((tokens.cache_creation || 0) * precios.cache_creation / 1_000_000)
+  );
+}
+
+/**
+ * Ejecuta una consulta SQLite usando Python como fallback (zero npm deps).
+ * @param {string} sql
+ * @returns {Promise<Array>}
+ */
+function consultarSQLite(sql) {
+  return new Promise((resolve, reject) => {
+    if (!fs.existsSync(DB_PATH)) {
+      return resolve([]);
+    }
+
+    const pythonCmd = process.platform === 'win32' ? 'python' : 'python3';
+    const script = `
+import sqlite3, json, sys
+conn = sqlite3.connect(r'${DB_PATH.replace(/\\/g, '\\\\')}')
+conn.row_factory = sqlite3.Row
+rows = conn.execute(${JSON.stringify(sql)}).fetchall()
+print(json.dumps([dict(r) for r in rows]))
+`;
+    execFile(pythonCmd, ['-c', script], { timeout: 15_000 }, (err, stdout) => {
+      if (err) return reject(err);
+      try {
+        resolve(JSON.parse(stdout.trim() || '[]'));
+      } catch (e) {
+        reject(e);
+      }
+    });
+  });
+}
+
+/**
+ * Obtiene métricas agregadas por tool_name para los últimos N días.
+ *
+ * @param {object} opciones
+ * @param {number} [opciones.dias=30]       — Rango de días a consultar
+ * @param {number} [opciones.topN=20]       — Número de herramientas a retornar
+ * @returns {Promise<Array<{tool_name, llamadas, input_tokens, output_tokens, costo_usd}>>}
+ */
+async function obtenerMetricasPorHerramienta({ dias = 30, topN = 20 } = {}) {
+  const fechaDesde = new Date(Date.now() - dias * 86_400_000).toISOString();
+
+  const sql = `
+    SELECT
+      COALESCE(tool_name, '(sin herramienta)') AS tool_name,
+      COUNT(*)                                   AS llamadas,
+      SUM(input_tokens)                          AS input_tokens,
+      SUM(output_tokens)                         AS output_tokens,
+      SUM(cache_read_tokens)                     AS cache_read,
+      SUM(cache_creation_tokens)                 AS cache_creation,
+      MAX(model)                                 AS modelo
+    FROM turns
+    WHERE timestamp >= '${fechaDesde}'
+    GROUP BY tool_name
+    ORDER BY input_tokens + output_tokens DESC
+    LIMIT ${topN}
+  `;
+
+  const filas = await consultarSQLite(sql);
+
+  return filas.map(f => ({
+    tool_name:    f.tool_name,
+    llamadas:     f.llamadas,
+    input_tokens: f.input_tokens  || 0,
+    output_tokens: f.output_tokens || 0,
+    costo_usd:    calcularCosto({
+      input:          f.input_tokens,
+      output:         f.output_tokens,
+      cache_read:     f.cache_read,
+      cache_creation: f.cache_creation,
+    }, f.modelo),
+  }));
+}
+
+/**
+ * Obtiene resumen global de sesiones (total tokens, costo, sesiones) para N días.
+ *
+ * @param {object} opciones
+ * @param {number} [opciones.dias=30]
+ * @returns {Promise<{sesiones, turns, input_tokens, output_tokens, costo_usd}>}
+ */
+async function obtenerResumenGlobal({ dias = 30 } = {}) {
+  const fechaDesde = new Date(Date.now() - dias * 86_400_000).toISOString();
+
+  const sql = `
+    SELECT
+      COUNT(DISTINCT session_id) AS sesiones,
+      COUNT(*)                   AS turns,
+      SUM(input_tokens)          AS input_tokens,
+      SUM(output_tokens)         AS output_tokens,
+      SUM(cache_read_tokens)     AS cache_read,
+      SUM(cache_creation_tokens) AS cache_creation
+    FROM turns
+    WHERE timestamp >= '${fechaDesde}'
+  `;
+
+  const [f] = await consultarSQLite(sql);
+  if (!f) return { sesiones: 0, turns: 0, input_tokens: 0, output_tokens: 0, costo_usd: 0 };
+
+  return {
+    sesiones:      f.sesiones      || 0,
+    turns:         f.turns         || 0,
+    input_tokens:  f.input_tokens  || 0,
+    output_tokens: f.output_tokens || 0,
+    costo_usd:     calcularCosto({
+      input:          f.input_tokens,
+      output:         f.output_tokens,
+      cache_read:     f.cache_read,
+      cache_creation: f.cache_creation,
+    }, 'claude-sonnet-4-6'),
+  };
+}
+
+/**
+ * Obtiene métricas por nombre de agente SWL (columna agent_name).
+ * Solo disponible si la DB fue escaneada con scanner.py v5.3.3+.
+ *
+ * @param {object} opciones
+ * @param {number} [opciones.dias=30]
+ * @param {number} [opciones.topN=15]
+ * @returns {Promise<Array<{agent_name, llamadas, input_tokens, output_tokens, costo_usd}>>}
+ */
+async function obtenerMetricasPorAgente({ dias = 30, topN = 15 } = {}) {
+  const fechaDesde = new Date(Date.now() - dias * 86_400_000).toISOString();
+
+  const sql = `
+    SELECT
+      agent_name,
+      COUNT(*)          AS llamadas,
+      SUM(input_tokens) AS input_tokens,
+      SUM(output_tokens) AS output_tokens,
+      SUM(cache_read_tokens)    AS cache_read,
+      SUM(cache_creation_tokens) AS cache_creation,
+      MAX(model)        AS modelo
+    FROM turns
+    WHERE agent_name IS NOT NULL
+      AND timestamp >= '${fechaDesde}'
+    GROUP BY agent_name
+    ORDER BY input_tokens + output_tokens DESC
+    LIMIT ${topN}
+  `;
+
+  const filas = await consultarSQLite(sql);
+
+  return filas.map(f => ({
+    agent_name:   f.agent_name,
+    llamadas:     f.llamadas,
+    input_tokens: f.input_tokens  || 0,
+    output_tokens: f.output_tokens || 0,
+    costo_usd:    calcularCosto({
+      input:          f.input_tokens,
+      output:         f.output_tokens,
+      cache_read:     f.cache_read,
+      cache_creation: f.cache_creation,
+    }, f.modelo),
+  }));
+}
+
+/**
+ * Obtiene métricas por nombre de skill SWL (columna skill_name).
+ * Solo disponible si la DB fue escaneada con scanner.py v5.3.3+.
+ *
+ * @param {object} opciones
+ * @param {number} [opciones.dias=30]
+ * @param {number} [opciones.topN=15]
+ * @returns {Promise<Array<{skill_name, llamadas, input_tokens, output_tokens, costo_usd}>>}
+ */
+async function obtenerMetricasPorSkill({ dias = 30, topN = 15 } = {}) {
+  const fechaDesde = new Date(Date.now() - dias * 86_400_000).toISOString();
+
+  const sql = `
+    SELECT
+      skill_name,
+      COUNT(*)          AS llamadas,
+      SUM(input_tokens) AS input_tokens,
+      SUM(output_tokens) AS output_tokens,
+      SUM(cache_read_tokens)    AS cache_read,
+      SUM(cache_creation_tokens) AS cache_creation,
+      MAX(model)        AS modelo
+    FROM turns
+    WHERE skill_name IS NOT NULL
+      AND timestamp >= '${fechaDesde}'
+    GROUP BY skill_name
+    ORDER BY input_tokens + output_tokens DESC
+    LIMIT ${topN}
+  `;
+
+  const filas = await consultarSQLite(sql);
+
+  return filas.map(f => ({
+    skill_name:   f.skill_name,
+    llamadas:     f.llamadas,
+    input_tokens: f.input_tokens  || 0,
+    output_tokens: f.output_tokens || 0,
+    costo_usd:    calcularCosto({
+      input:          f.input_tokens,
+      output:         f.output_tokens,
+      cache_read:     f.cache_read,
+      cache_creation: f.cache_creation,
+    }, f.modelo),
+  }));
+}
+
+module.exports = {
+  obtenerMetricasPorHerramienta,
+  obtenerMetricasPorAgente,
+  obtenerMetricasPorSkill,
+  obtenerResumenGlobal,
+  calcularCosto,
+  DB_PATH,
+};

package/scripts/lib/tracing-processor-interface.js

@@ -0,0 +1,286 @@
+'use strict';
+
+/**
+ * Interfaz formal TracingProcessor para el sistema de trazabilidad SWL.
+ *
+ * Portado y adaptado desde:
+ *   openai-agents-python/src/agents/tracing/processor_interface.py
+ * Patrón: Open/Closed — múltiples exportadores sin modificar el núcleo.
+ * Zero-deps. Solo módulos nativos de Node.js.
+ *
+ * Clases exportadas:
+ *   - TracingProcessor  — interfaz abstracta para procesadores de trazas
+ *   - TracingExporter   — interfaz abstracta para exportadores de spans
+ *   - MultiProcessor    — implementación Composite que propaga a N procesadores
+ *
+ * @module scripts/lib/tracing-processor-interface
+ */
+
+// ---------------------------------------------------------------------------
+// TracingProcessor — interfaz base
+// ---------------------------------------------------------------------------
+
+/**
+ * Interfaz abstracta para procesadores de trazas y spans del sistema SWL.
+ *
+ * Todos los exportadores de trazas (OTLP local, Langfuse, Jaeger, consola)
+ * deben extender esta clase e implementar sus seis métodos.
+ *
+ * Contrato:
+ *   - Los métodos deben retornar rápido; no bloquear el flujo del agente.
+ *   - Los errores internos deben capturarse; nunca propagarse al caller.
+ *   - Todos los métodos son síncronos por defecto; las subclases pueden
+ *     usar callbacks o colas internas para operaciones asíncronas.
+ *
+ * @abstract
+ */
+class TracingProcessor {
+  /**
+   * Invocado cuando inicia una nueva traza (flujo de alto nivel).
+   *
+   * @param {object} traza - Objeto de traza con al menos { traceId, nombre, inicio }.
+   * @returns {void}
+   * @abstract
+   */
+  onTraceStart(traza) { // eslint-disable-line no-unused-vars
+    throw new Error(
+      `${this.constructor.name} debe implementar onTraceStart(traza).`
+    );
+  }
+
+  /**
+   * Invocado cuando finaliza una traza. Momento idóneo para exportar
+   * la traza completa con todos sus spans asociados.
+   *
+   * @param {object} traza - Objeto de traza completa con spans.
+   * @returns {void}
+   * @abstract
+   */
+  onTraceEnd(traza) { // eslint-disable-line no-unused-vars
+    throw new Error(
+      `${this.constructor.name} debe implementar onTraceEnd(traza).`
+    );
+  }
+
+  /**
+   * Invocado cuando inicia un span (operación individual dentro de una traza).
+   *
+   * @param {object} span - Objeto de span con al menos { spanId, traceId, nombre, inicio }.
+   * @returns {void}
+   * @abstract
+   */
+  onSpanStart(span) { // eslint-disable-line no-unused-vars
+    throw new Error(
+      `${this.constructor.name} debe implementar onSpanStart(span).`
+    );
+  }
+
+  /**
+   * Invocado cuando finaliza un span, con todos sus datos finales disponibles.
+   * Es el punto principal de exportación en la mayoría de procesadores.
+   *
+   * @param {object} span - Objeto de span completo con { spanId, traceId, nombre,
+   *   inicio, fin, duracionMs, estado, atributos }.
+   * @returns {void}
+   * @abstract
+   */
+  onSpanEnd(span) { // eslint-disable-line no-unused-vars
+    throw new Error(
+      `${this.constructor.name} debe implementar onSpanEnd(span).`
+    );
+  }
+
+  /**
+   * Cierra el procesador de forma limpia. Debe vaciar buffers pendientes,
+   * cerrar archivos abiertos y liberar recursos antes de retornar.
+   *
+   * @returns {void}
+   * @abstract
+   */
+  shutdown() {
+    throw new Error(
+      `${this.constructor.name} debe implementar shutdown().`
+    );
+  }
+
+  /**
+   * Fuerza el volcado inmediato de cualquier buffer o cola interna.
+   * Útil antes de un shutdown o cuando se necesita garantía de persistencia.
+   *
+   * @returns {void}
+   * @abstract
+   */
+  forceFlush() {
+    throw new Error(
+      `${this.constructor.name} debe implementar forceFlush().`
+    );
+  }
+
+  // ---------------------------------------------------------------------------
+  // Utilidades estáticas
+  // ---------------------------------------------------------------------------
+
+  /**
+   * Verifica que una instancia implementa todos los métodos requeridos
+   * de la interfaz TracingProcessor.
+   *
+   * @param {any} instancia - Objeto a verificar.
+   * @returns {boolean} true si todos los métodos están implementados.
+   *
+   * @example
+   * TracingProcessor.esProcesadorValido(new MiProcesador()) // → true
+   * TracingProcessor.esProcesadorValido({})                 // → false
+   */
+  static esProcesadorValido(instancia) {
+    if (!instancia || typeof instancia !== 'object') return false;
+    const metodosRequeridos = [
+      'onTraceStart', 'onTraceEnd',
+      'onSpanStart',  'onSpanEnd',
+      'shutdown',     'forceFlush',
+    ];
+    return metodosRequeridos.every(
+      metodo => typeof instancia[metodo] === 'function'
+    );
+  }
+}
+
+// ---------------------------------------------------------------------------
+// TracingExporter — interfaz para exportadores de ítems
+// ---------------------------------------------------------------------------
+
+/**
+ * Interfaz abstracta para exportadores de spans y trazas.
+ *
+ * Un exportador recibe un array de ítems (spans o trazas) ya finalizados
+ * y los envía a un destino: archivo, endpoint HTTP, consola, etc.
+ *
+ * A diferencia de TracingProcessor (que reacciona a eventos del ciclo de vida),
+ * TracingExporter opera en modo batch sobre ítems ya completos.
+ *
+ * @abstract
+ */
+class TracingExporter {
+  /**
+   * Exporta un array de spans o trazas a un destino externo.
+   *
+   * El método debe ser tolerante a fallos: si un ítem falla, el resto
+   * deben exportarse igualmente. Los errores no recuperables deben
+   * registrarse internamente, nunca propagarse al caller.
+   *
+   * @param {object[]} items - Array de spans o trazas a exportar.
+   * @returns {void}
+   * @abstract
+   */
+  export(items) { // eslint-disable-line no-unused-vars
+    throw new Error(
+      `${this.constructor.name} debe implementar export(items).`
+    );
+  }
+}
+
+// ---------------------------------------------------------------------------
+// MultiProcessor — patrón Composite
+// ---------------------------------------------------------------------------
+
+/**
+ * Procesador compuesto que propaga todos los eventos de ciclo de vida
+ * a una lista de procesadores hijos (patrón Composite).
+ *
+ * Características:
+ *   - Aislamiento de errores: si un hijo lanza, los demás reciben el evento.
+ *   - Composición dinámica: se pueden agregar/quitar procesadores en tiempo
+ *     de ejecución con addProcessor / removeProcessor.
+ *   - Compatible con TracingProcessor.esProcesadorValido().
+ *
+ * @extends TracingProcessor
+ *
+ * @example
+ * const multi = new MultiProcessor([
+ *   new OtlpLocalProcessor(cwd),
+ *   new ConsoleSpanExporter(),
+ * ]);
+ * multi.onSpanEnd(span); // propaga a ambos
+ */
+class MultiProcessor extends TracingProcessor {
+  /**
+   * @param {TracingProcessor[]} [procesadores] - Lista inicial de procesadores hijos.
+   */
+  constructor(procesadores = []) {
+    super();
+    /** @type {TracingProcessor[]} */
+    this._procesadores = [...procesadores];
+  }
+
+  /**
+   * Agrega un procesador hijo a la lista.
+   *
+   * @param {TracingProcessor} procesador - Instancia que implementa TracingProcessor.
+   * @throws {TypeError} Si el argumento no implementa la interfaz completa.
+   */
+  addProcessor(procesador) {
+    if (!TracingProcessor.esProcesadorValido(procesador)) {
+      throw new TypeError(
+        'addProcessor: el argumento debe implementar la interfaz TracingProcessor completa.'
+      );
+    }
+    this._procesadores.push(procesador);
+  }
+
+  /**
+   * Elimina un procesador hijo de la lista (por referencia de objeto).
+   *
+   * @param {TracingProcessor} procesador - Instancia a eliminar.
+   */
+  removeProcessor(procesador) {
+    this._procesadores = this._procesadores.filter(p => p !== procesador);
+  }
+
+  /**
+   * Propaga un evento a todos los hijos con aislamiento de errores.
+   *
+   * @private
+   * @param {string} metodo - Nombre del método a invocar.
+   * @param {any} arg - Argumento a pasar al método.
+   */
+  _propagar(metodo, arg) {
+    for (const p of this._procesadores) {
+      try {
+        p[metodo](arg);
+      } catch (_) {
+        // Aislamiento: si un hijo falla, los demás deben seguir recibiendo
+      }
+    }
+  }
+
+  /** @override */
+  onTraceStart(traza) { this._propagar('onTraceStart', traza); }
+
+  /** @override */
+  onTraceEnd(traza) { this._propagar('onTraceEnd', traza); }
+
+  /** @override */
+  onSpanStart(span) { this._propagar('onSpanStart', span); }
+
+  /** @override */
+  onSpanEnd(span) { this._propagar('onSpanEnd', span); }
+
+  /** @override */
+  shutdown() {
+    for (const p of this._procesadores) {
+      try { p.shutdown(); } catch (_) {}
+    }
+  }
+
+  /** @override */
+  forceFlush() {
+    for (const p of this._procesadores) {
+      try { p.forceFlush(); } catch (_) {}
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Exports
+// ---------------------------------------------------------------------------
+
+module.exports = { TracingProcessor, TracingExporter, MultiProcessor };