@saulwade/swl-ses 1.0.0

package/hooks/lib/context-compressor.js

@@ -0,0 +1,657 @@
+'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,
+};