@saulwade/swl-ses 2.3.0 → 2.4.1

package/hooks/lib/context-compressor.js

@@ -1,657 +0,0 @@
-'use strict';
-
-/**
- * Context Compressor — Compresión de contexto multi-fase.
- *
- * Algoritmo de 5 fases inspirado en Hermes Agent (context_compressor.py):
- *
- *   Fase 1: Podar tool results antiguos (sin LLM, automática)
- *   Fase 2: Proteger head (system prompt) + tail (mensajes recientes)
- *   Fase 3: Serializar turnos intermedios para resumen
- *   Fase 4: Generar/actualizar resumen estructurado (requiere LLM)
- *   Fase 5: Sanitizar pares tool_call/tool_result huérfanos
- *
- * Integración:
- *   - monitor-contexto.js activa Fase 1 automáticamente en CRITICAL
- *   - Las Fases 2-4 se invocan vía /swl:compactar o instrucción al agente
- *   - El resumen se persiste en .planning/COMPACTACION.md para sesiones futuras
- *
- * @module hooks/lib/context-compressor
- */
-
-const fs   = require('fs');
-const path = require('path');
-
-const { atomicWriteSync } = require('./atomic-write');
-
-// ---------------------------------------------------------------------------
-// Constantes (adoptadas de Hermes Agent)
-// ---------------------------------------------------------------------------
-
-/** Porcentaje de contexto a partir del cual activar compresión. */
-const THRESHOLD_PERCENT = 0.50;
-
-/** Primeros N mensajes que nunca se comprimen (system prompt + contexto inicial). */
-const PROTECT_HEAD_N = 3;
-
-/** Budget de tokens para proteger los mensajes más recientes (tail). */
-const TAIL_TOKEN_BUDGET = 20000;
-
-/** Mínimo de tokens que el resumen debe tener. */
-const MIN_SUMMARY_TOKENS = 2000;
-
-/** Proporción del contenido comprimido que se asigna al resumen. */
-const SUMMARY_RATIO = 0.20;
-
-/** Techo máximo de tokens para el resumen (incluso en contextos enormes). */
-const SUMMARY_TOKENS_CEILING = 12000;
-
-/** Estimación de caracteres por token (español). */
-const CHARS_PER_TOKEN = 4;
-
-/** Placeholder para tool results podados. */
-const PRUNED_PLACEHOLDER = '[Resultado de herramienta anterior omitido por compresión]';
-
-/** Máximo de caracteres de tool output a preservar en serialización. */
-const MAX_TOOL_OUTPUT_CHARS = 3000;
-
-/** Máximo de caracteres de tool args a preservar en serialización. */
-const MAX_TOOL_ARGS_CHARS = 500;
-
-// ---------------------------------------------------------------------------
-// Micro-compactación por TTL (inspirado en Claude Code microCompact.ts)
-// ---------------------------------------------------------------------------
-
-/** Turnos después de los cuales un tool result se comprime a resumen. */
-const TOOL_RESULT_TTL_TURNS = 15;
-
-/** Herramientas cuyos resultados NUNCA se comprimen por TTL (escrituras). */
-const TTL_EXEMPT_TOOLS = new Set(['Write', 'Edit', 'NotebookEdit']);
-
-/** Herramientas de lectura cuyo resultado se puede comprimir agresivamente. */
-const TTL_COMPRESSIBLE_TOOLS = new Set(['Read', 'Bash', 'Grep', 'Glob', 'WebFetch', 'WebSearch']);
-
-/** Placeholder para resultados comprimidos por TTL. */
-const TTL_PLACEHOLDER_FN = (toolName, turnsAgo, originalChars) =>
-  `[Resultado de ${toolName} — ${Math.round(originalChars / CHARS_PER_TOKEN)} tokens, hace ${turnsAgo} turnos — comprimido por TTL]`;
-
-// ---------------------------------------------------------------------------
-// Utilidades
-// ---------------------------------------------------------------------------
-
-function estimarTokens(texto) {
-  return Math.ceil((texto || '').length / CHARS_PER_TOKEN);
-}
-
-function calcularSummaryBudget(middleTokens) {
-  const budget = Math.round(middleTokens * SUMMARY_RATIO);
-  return Math.max(MIN_SUMMARY_TOKENS, Math.min(budget, SUMMARY_TOKENS_CEILING));
-}
-
-// ---------------------------------------------------------------------------
-// Fase 1: Podar tool results antiguos (sin LLM)
-// ---------------------------------------------------------------------------
-
-// ---------------------------------------------------------------------------
-// Fase 0: Respaldo de transcripción pre-compactación
-// ---------------------------------------------------------------------------
-
-/**
- * Respalda la transcripción completa antes de compactar.
- * Guarda en .planning/sessions/transcripts/ con timestamp.
- * Inspirado en obsidian-mind PreCompact hook.
- *
- * @param {object[]} messages - Array de mensajes de la conversación.
- * @param {string} [cwd] - Directorio de trabajo.
- * @returns {{ backed: boolean, path: string|null, messageCount: number }}
- */
-function phase0_BackupTranscript(messages, cwd) {
-  if (!Array.isArray(messages) || messages.length < 5) {
-    return { backed: false, path: null, messageCount: 0 };
-  }
-
-  const dir = cwd || process.cwd();
-  const transcriptDir = path.join(dir, '.planning', 'sessions', 'transcripts');
-
-  try {
-    fs.mkdirSync(transcriptDir, { recursive: true });
-  } catch (_) {
-    return { backed: false, path: null, messageCount: messages.length };
-  }
-
-  const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
-  const filePath = path.join(transcriptDir, `transcript-${timestamp}.md`);
-
-  const lines = [
-    `# Transcripción pre-compactación`,
-    `**Fecha**: ${new Date().toISOString()}`,
-    `**Mensajes**: ${messages.length}`,
-    '',
-    '---',
-    '',
-  ];
-
-  for (let i = 0; i < messages.length; i++) {
-    const msg = messages[i];
-    const role = msg.role || 'unknown';
-    lines.push(`## [${i + 1}] ${role}`);
-
-    if (typeof msg.content === 'string') {
-      // Truncar contenido muy largo
-      const content = msg.content.length > 2000
-        ? msg.content.slice(0, 2000) + '\n...[truncado]'
-        : msg.content;
-      lines.push(content);
-    } else if (Array.isArray(msg.content)) {
-      for (const block of msg.content) {
-        if (block.type === 'text') {
-          const text = (block.text || '').length > 1000
-            ? block.text.slice(0, 1000) + '...[truncado]'
-            : block.text;
-          lines.push(text);
-        } else if (block.type === 'tool_use') {
-          lines.push(`**Tool**: ${block.name}(${JSON.stringify(block.input || {}).slice(0, 200)})`);
-        } else if (block.type === 'tool_result') {
-          const content = typeof block.content === 'string' ? block.content : JSON.stringify(block.content || '');
-          lines.push(`**Result**: ${content.slice(0, 500)}`);
-        }
-      }
-    }
-    lines.push('');
-  }
-
-  try {
-    atomicWriteSync(filePath, lines.join('\n'));
-    return { backed: true, path: filePath, messageCount: messages.length };
-  } catch (_) {
-    return { backed: false, path: null, messageCount: messages.length };
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Fase 1: Poda de tool results
-// ---------------------------------------------------------------------------
-
-/**
- * Reemplaza el contenido de tool results antiguos con un placeholder.
- * No requiere LLM. Segura para ejecución automática.
- *
- * @param {object[]} messages - Array de mensajes de la conversación.
- * @param {number} [protectLastN=15] - Últimos N mensajes a proteger.
- * @returns {{ messages: object[], tokensSaved: number, pruneCount: number }}
- */
-function phase1_PruneToolResults(messages, protectLastN = 15) {
-  if (!Array.isArray(messages) || messages.length === 0) {
-    return { messages: [], tokensSaved: 0, pruneCount: 0 };
-  }
-
-  const protectFrom = Math.max(0, messages.length - protectLastN);
-  let tokensSaved = 0;
-  let pruneCount = 0;
-  const result = [];
-
-  for (let i = 0; i < messages.length; i++) {
-    const msg = { ...messages[i] };
-
-    // Solo podar tool_result fuera de la zona protegida
-    if (i < protectFrom && msg.role === 'tool' && typeof msg.content === 'string') {
-      const contentTokens = estimarTokens(msg.content);
-      if (contentTokens > 50) { // Solo podar si vale la pena
-        tokensSaved += contentTokens - estimarTokens(PRUNED_PLACEHOLDER);
-        pruneCount++;
-        msg.content = PRUNED_PLACEHOLDER;
-      }
-    }
-
-    result.push(msg);
-  }
-
-  return { messages: result, tokensSaved, pruneCount };
-}
-
-// ---------------------------------------------------------------------------
-// Fase 1b: Micro-compactación por TTL (sin LLM)
-// ---------------------------------------------------------------------------
-
-/**
- * Comprime resultados de herramientas de lectura que tienen más de N turnos
- * de antigüedad. Solo afecta a herramientas en TTL_COMPRESSIBLE_TOOLS.
- *
- * Inspirado en microCompact.ts de Claude Code: los resultados de Read/Bash/Grep
- * pierden relevancia después de varios turnos. Comprimirlos libera contexto
- * sin perder la señal de que la operación ocurrió.
- *
- * @param {object[]} messages - Array de mensajes de la conversación.
- * @param {number} [ttlTurns=15] - Turnos de antigüedad para comprimir.
- * @returns {{ messages: object[], tokensSaved: number, compressedCount: number }}
- */
-function phase1b_MicroCompactByTTL(messages, ttlTurns = TOOL_RESULT_TTL_TURNS) {
-  if (!Array.isArray(messages) || messages.length === 0) {
-    return { messages: [], tokensSaved: 0, compressedCount: 0 };
-  }
-
-  // Contar turnos desde el final (turno = par assistant+tool o user message)
-  let currentTurn = 0;
-  const turnIndex = new Array(messages.length).fill(0);
-
-  for (let i = messages.length - 1; i >= 0; i--) {
-    if (messages[i].role === 'user' || messages[i].role === 'assistant') {
-      currentTurn++;
-    }
-    turnIndex[i] = currentTurn;
-  }
-
-  let tokensSaved = 0;
-  let compressedCount = 0;
-  const result = [];
-
-  for (let i = 0; i < messages.length; i++) {
-    const msg = { ...messages[i] };
-    const turnsAgo = turnIndex[i];
-
-    // Solo comprimir tool results con suficiente antigüedad
-    if (turnsAgo >= ttlTurns && msg.role === 'tool' && typeof msg.content === 'string') {
-      // Determinar el nombre de la herramienta del tool_use correspondiente
-      const toolName = _findToolNameForResult(messages, i);
-
-      // No comprimir herramientas exentas
-      if (toolName && !TTL_EXEMPT_TOOLS.has(toolName) && TTL_COMPRESSIBLE_TOOLS.has(toolName)) {
-        const originalTokens = estimarTokens(msg.content);
-        if (originalTokens > 30) { // Solo si vale la pena
-          const placeholder = TTL_PLACEHOLDER_FN(toolName, turnsAgo, msg.content.length);
-          tokensSaved += originalTokens - estimarTokens(placeholder);
-          compressedCount++;
-          msg.content = placeholder;
-        }
-      }
-    }
-
-    result.push(msg);
-  }
-
-  return { messages: result, tokensSaved, compressedCount };
-}
-
-/**
- * Busca el nombre de la herramienta que generó un tool_result.
- * Recorre hacia atrás buscando el tool_use con el mismo tool_use_id.
- */
-function _findToolNameForResult(messages, toolResultIdx) {
-  const toolUseId = messages[toolResultIdx]?.tool_use_id;
-  if (!toolUseId) return null;
-
-  for (let i = toolResultIdx - 1; i >= 0; i--) {
-    const msg = messages[i];
-    if (msg.role === 'assistant' && Array.isArray(msg.content)) {
-      for (const block of msg.content) {
-        if (block.type === 'tool_use' && block.id === toolUseId) {
-          return block.name;
-        }
-      }
-    }
-  }
-  return null;
-}
-
-// ---------------------------------------------------------------------------
-// Fase 2: Proteger head y tail, identificar middle
-// ---------------------------------------------------------------------------
-
-/**
- * Divide los mensajes en head (protegidos), middle (comprimibles) y tail (recientes).
- *
- * @param {object[]} messages - Mensajes post-Fase 1.
- * @returns {{ head: object[], middle: object[], tail: object[] }}
- */
-function phase2_ProtectBoundaries(messages) {
-  if (!Array.isArray(messages)) {
-    return { head: [], middle: [], tail: [] };
-  }
-
-  // Head: primeros PROTECT_HEAD_N mensajes
-  const head = messages.slice(0, PROTECT_HEAD_N);
-
-  // Tail: últimos mensajes hasta TAIL_TOKEN_BUDGET
-  let tailTokens = 0;
-  let tailStart = messages.length;
-  for (let i = messages.length - 1; i >= PROTECT_HEAD_N; i--) {
-    const msgTokens = estimarTokens(JSON.stringify(messages[i]));
-    if (tailTokens + msgTokens > TAIL_TOKEN_BUDGET) break;
-    tailTokens += msgTokens;
-    tailStart = i;
-  }
-
-  // Alinear boundaries para no cortar pares tool_call/tool_result
-  tailStart = _alignBoundaryForward(messages, tailStart);
-
-  const middle = messages.slice(PROTECT_HEAD_N, tailStart);
-  const tail   = messages.slice(tailStart);
-
-  return { head, middle, tail };
-}
-
-/**
- * Alinea el boundary hacia adelante para no separar un tool_result de su tool_call.
- */
-function _alignBoundaryForward(messages, idx) {
-  while (idx < messages.length && messages[idx].role === 'tool') {
-    idx++;
-  }
-  return idx;
-}
-
-// ---------------------------------------------------------------------------
-// Fase 3: Serializar middle para resumen
-// ---------------------------------------------------------------------------
-
-/**
- * Serializa los mensajes intermedios en texto plano para el LLM resumidor.
- *
- * @param {object[]} middleMessages
- * @returns {string} Texto serializado con contexto de cada turno.
- */
-function phase3_SerializeForSummary(middleMessages) {
-  if (!Array.isArray(middleMessages) || middleMessages.length === 0) {
-    return '';
-  }
-
-  const parts = [];
-
-  for (const msg of middleMessages) {
-    const role = msg.role || 'unknown';
-
-    if (role === 'assistant' && msg.tool_calls) {
-      // Tool calls del asistente
-      for (const tc of msg.tool_calls) {
-        const name = tc.function?.name || tc.name || 'unknown';
-        const args = JSON.stringify(tc.function?.arguments || tc.arguments || {});
-        parts.push(`[TOOL CALL] ${name}: ${args.substring(0, MAX_TOOL_ARGS_CHARS)}`);
-      }
-      if (msg.content) {
-        parts.push(`[ASSISTANT] ${String(msg.content).substring(0, 1000)}`);
-      }
-    } else if (role === 'tool') {
-      const content = String(msg.content || '');
-      parts.push(`[TOOL RESULT] ${content.substring(0, MAX_TOOL_OUTPUT_CHARS)}`);
-    } else if (role === 'user') {
-      parts.push(`[USER] ${String(msg.content || '').substring(0, 500)}`);
-    } else if (role === 'assistant') {
-      parts.push(`[ASSISTANT] ${String(msg.content || '').substring(0, 1000)}`);
-    }
-  }
-
-  return parts.join('\n');
-}
-
-// ---------------------------------------------------------------------------
-// Fase 4: Prompt de resumen estructurado (para el LLM)
-// ---------------------------------------------------------------------------
-
-/**
- * Genera el prompt para que el LLM produzca un resumen estructurado.
- * Este prompt se usa como instrucción al agente, no como API call directa.
- *
- * @param {string} serialized - Output de phase3.
- * @param {string|null} previousSummary - Resumen previo para actualización iterativa.
- * @param {number} budgetTokens - Tokens disponibles para el resumen.
- * @returns {string} Prompt completo para el LLM.
- */
-function phase4_BuildSummaryPrompt(serialized, previousSummary, budgetTokens) {
-  const budgetChars = budgetTokens * CHARS_PER_TOKEN;
-
-  if (previousSummary) {
-    return [
-      'Actualiza el siguiente resumen de sesión con la información nueva.',
-      'Preserva las decisiones y el contexto crítico del resumen anterior.',
-      'Mueve items de "Próximos pasos" a "Progreso" si fueron completados.',
-      `Mantén el resumen en máximo ${budgetChars} caracteres.`,
-      '',
-      '--- RESUMEN ANTERIOR ---',
-      previousSummary,
-      '--- FIN RESUMEN ANTERIOR ---',
-      '',
-      '--- INFORMACIÓN NUEVA ---',
-      serialized,
-      '--- FIN INFORMACIÓN NUEVA ---',
-      '',
-      'Usa esta estructura exacta:',
-      '',
-      '**Objetivo**: [qué se está haciendo en esta sesión]',
-      '**Progreso**: [qué se completó, con archivos específicos]',
-      '**Decisiones**: [qué se decidió y por qué — preservar de resumen anterior]',
-      '**Archivos clave**: [paths de archivos creados/modificados]',
-      '**Próximos pasos**: [qué falta por hacer]',
-      '**Contexto crítico**: [información que no puede perderse]',
-    ].join('\n');
-  }
-
-  return [
-    'Resume la siguiente actividad de sesión en un resumen estructurado.',
-    `Máximo ${budgetChars} caracteres. Sé conciso pero preserva decisiones.`,
-    '',
-    '--- ACTIVIDAD ---',
-    serialized,
-    '--- FIN ACTIVIDAD ---',
-    '',
-    'Usa esta estructura exacta:',
-    '',
-    '**Objetivo**: [qué se está haciendo en esta sesión]',
-    '**Progreso**: [qué se completó, con archivos específicos]',
-    '**Decisiones**: [qué se decidió y por qué]',
-    '**Archivos clave**: [paths de archivos creados/modificados]',
-    '**Próximos pasos**: [qué falta por hacer]',
-    '**Contexto crítico**: [información que no puede perderse]',
-  ].join('\n');
-}
-
-// ---------------------------------------------------------------------------
-// Fase 5: Sanitizar pares tool_call/tool_result
-// ---------------------------------------------------------------------------
-
-/**
- * Verifica y repara la consistencia de pares tool_call/tool_result.
- *
- * - Remueve tool_results cuyo tool_call_id no existe en los mensajes
- * - Inserta stub results para tool_calls sin resultado
- *
- * @param {object[]} messages
- * @returns {{ messages: object[], orphansRemoved: number, stubsInserted: number }}
- */
-function phase5_SanitizeToolPairs(messages) {
-  if (!Array.isArray(messages)) {
-    return { messages: [], orphansRemoved: 0, stubsInserted: 0 };
-  }
-
-  // Recolectar tool_call IDs presentes
-  const toolCallIds = new Set();
-  const toolResultIds = new Set();
-
-  for (const msg of messages) {
-    if (msg.role === 'assistant' && msg.tool_calls) {
-      for (const tc of msg.tool_calls) {
-        if (tc.id) toolCallIds.add(tc.id);
-      }
-    }
-    if (msg.role === 'tool' && msg.tool_call_id) {
-      toolResultIds.add(msg.tool_call_id);
-    }
-  }
-
-  let orphansRemoved = 0;
-  let stubsInserted = 0;
-  const result = [];
-
-  for (const msg of messages) {
-    // Remover tool_results huérfanos (sin tool_call correspondiente)
-    if (msg.role === 'tool' && msg.tool_call_id && !toolCallIds.has(msg.tool_call_id)) {
-      orphansRemoved++;
-      continue;
-    }
-    result.push(msg);
-  }
-
-  // Insertar stubs para tool_calls sin resultado
-  const missingResults = [...toolCallIds].filter(id => !toolResultIds.has(id));
-  for (const callId of missingResults) {
-    // Encontrar posición después del tool_call correspondiente
-    let insertIdx = result.length;
-    for (let i = 0; i < result.length; i++) {
-      if (result[i].role === 'assistant' && result[i].tool_calls) {
-        const hasCall = result[i].tool_calls.some(tc => tc.id === callId);
-        if (hasCall) {
-          insertIdx = i + 1;
-          break;
-        }
-      }
-    }
-
-    result.splice(insertIdx, 0, {
-      role: 'tool',
-      tool_call_id: callId,
-      content: '[Resultado no disponible — fue comprimido en resumen anterior]',
-    });
-    stubsInserted++;
-  }
-
-  return { messages: result, orphansRemoved, stubsInserted };
-}
-
-// ---------------------------------------------------------------------------
-// API pública: Orquestador
-// ---------------------------------------------------------------------------
-
-/**
- * Determina si el contexto necesita compresión.
- *
- * @param {number} usagePercent - Porcentaje de contexto usado (0-100).
- * @returns {boolean}
- */
-function shouldCompress(usagePercent) {
-  return usagePercent >= (THRESHOLD_PERCENT * 100);
-}
-
-/**
- * Ejecuta la compresión completa (Fases 1-3, 5).
- * La Fase 4 (resumen LLM) produce el prompt pero requiere invocación externa.
- *
- * @param {object[]} messages - Mensajes de la conversación.
- * @param {object} [opts={}]
- * @param {string} [opts.previousSummary] - Resumen previo para actualización iterativa.
- * @param {string} [opts.baseDir]         - Para persistir resumen en COMPACTACION.md.
- * @returns {{
- *   phase1: { messages, tokensSaved, pruneCount },
- *   phase2: { head, middle, tail },
- *   serialized: string,
- *   summaryPrompt: string,
- *   summaryBudget: number,
- *   phase5: { messages, orphansRemoved, stubsInserted }
- * }}
- */
-function compress(messages, opts = {}) {
-  // Fase 1: Podar tool results por posición
-  const p1 = phase1_PruneToolResults(messages);
-
-  // Fase 1b: Micro-compactación por TTL (resultados antiguos de Read/Bash/Grep)
-  const p1b = phase1b_MicroCompactByTTL(p1.messages, opts.ttlTurns);
-
-  // Fase 2: Proteger boundaries
-  const p2 = phase2_ProtectBoundaries(p1b.messages);
-
-  // Fase 3: Serializar middle
-  const serialized = phase3_SerializeForSummary(p2.middle);
-  const middleTokens = estimarTokens(serialized);
-  const summaryBudget = calcularSummaryBudget(middleTokens);
-
-  // Fase 4: Generar prompt de resumen (para invocación LLM externa)
-  const summaryPrompt = phase4_BuildSummaryPrompt(
-    serialized,
-    opts.previousSummary || null,
-    summaryBudget,
-  );
-
-  // Fase 5: Sanitizar los mensajes comprimidos (head + tail, sin middle)
-  const compressed = [...p2.head, ...p2.tail];
-  const p5 = phase5_SanitizeToolPairs(compressed);
-
-  return {
-    phase1: { tokensSaved: p1.tokensSaved, pruneCount: p1.pruneCount },
-    phase1b: { tokensSaved: p1b.tokensSaved, compressedCount: p1b.compressedCount },
-    phase2: { headCount: p2.head.length, middleCount: p2.middle.length, tailCount: p2.tail.length },
-    serialized,
-    summaryPrompt,
-    summaryBudget,
-    phase5: { orphansRemoved: p5.orphansRemoved, stubsInserted: p5.stubsInserted },
-    compressedMessages: p5.messages,
-  };
-}
-
-/**
- * Persiste un resumen de compresión para recuperación en sesiones futuras.
- *
- * @param {string} baseDir - Directorio raíz del proyecto.
- * @param {string} summary - Resumen generado por el LLM (Fase 4).
- */
-function persistSummary(baseDir, summary) {
-  const compactPath = path.join(baseDir, '.planning', 'COMPACTACION.md');
-  const timestamp = new Date().toISOString();
-
-  const content = [
-    `# Resumen de Compresión`,
-    ``,
-    `**Generado**: ${timestamp}`,
-    `**Tipo**: Resumen iterativo de sesión activa`,
-    ``,
-    summary,
-    ``,
-  ].join('\n');
-
-  atomicWriteSync(compactPath, content);
-}
-
-/**
- * Lee el resumen de compresión previo (si existe).
- *
- * @param {string} baseDir
- * @returns {string|null}
- */
-function loadPreviousSummary(baseDir) {
-  const compactPath = path.join(baseDir, '.planning', 'COMPACTACION.md');
-  try {
-    if (!fs.existsSync(compactPath)) return null;
-    const content = fs.readFileSync(compactPath, 'utf8');
-    // Extraer solo el resumen (después del header)
-    const parts = content.split('\n\n');
-    return parts.slice(2).join('\n\n').trim() || null;
-  } catch (_) {
-    return null;
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Exports
-// ---------------------------------------------------------------------------
-
-module.exports = {
-  // Fases individuales (para uso granular)
-  phase0_BackupTranscript,
-  phase1_PruneToolResults,
-  phase1b_MicroCompactByTTL,
-  phase2_ProtectBoundaries,
-  phase3_SerializeForSummary,
-  phase4_BuildSummaryPrompt,
-  phase5_SanitizeToolPairs,
-  // Orquestador
-  shouldCompress,
-  compress,
-  // Persistencia
-  persistSummary,
-  loadPreviousSummary,
-  // Constantes
-  THRESHOLD_PERCENT,
-  PROTECT_HEAD_N,
-  TAIL_TOKEN_BUDGET,
-  MIN_SUMMARY_TOKENS,
-  SUMMARY_RATIO,
-  SUMMARY_TOKENS_CEILING,
-  TOOL_RESULT_TTL_TURNS,
-};