ctx: No Pierdas el Hilo Entre Compactaciones de Claude Code

Llevaba semanas trabajando en sesiones largas con Claude Code cuando empecé a notar un patrón que me sacaba de quicio.

A mitad de una tarea complicada — refactorizando un módulo, o construyendo una feature que involucraba varios archivos — Claude compactaba la conversación. Era necesario, el contexto se había llenado. Pero después de la compactación, algo cambiaba.

No de golpe. Gradualmente. Claude empezaba a hacer preguntas que ya habíamos respondido. Retomaba enfoques que habíamos descartado. Perdía el hilo de las decisiones técnicas que habíamos tomado juntos hace diez minutos.

El trabajo no se perdía — estaba en el código. Pero el momentum sí.

🤔 El problema real

Cuando Claude Code compacta, resume la conversación. Es un resumen inteligente, pero es un resumen al fin. Y los resúmenes priorizan por volumen, no por relevancia inmediata.

Lo que se diluye primero no son las explicaciones largas ni el código. Son las cosas pequeñas pero críticas:

• El objetivo específico de esta sesión.
• La decisión que tomamos hace veinte minutos de no usar esa abstracción.
• El archivo que estaba a medias.
• El siguiente paso concreto que quedaba pendiente.

Esas cosas no ocupan mucho espacio en la conversación, así que el resumen las aplana. Y después de dos o tres compactaciones, trabajar con Claude se sentía como volver a arrancar desde cero cada vez.

💡 La solución más obvia que no existía

Busqué herramientas. No encontré nada que atacara exactamente este problema.

Había muchas soluciones de memoria entre sesiones — guardar notas, persistir contexto entre días, construir bases de conocimiento. Útil para otra cosa, pero no para esto.

Lo que necesitaba era más simple: que Claude sepa dónde estábamos exactamente antes de la compactación, y lo sepa de vuelta justo después.

Un checkpoint. No un historial. No una memoria acumulativa. Solo el estado mínimo para retomar el trabajo sin perder el hilo.

🔧 Construyendo ctx

Así que lo construí. Se llama ctx — abreviatura de context.

La idea es directa: ctx se engancha a los eventos internos de Claude Code para capturar un snapshot estructurado del contexto justo antes de cada compactación, y restaurarlo automáticamente cuando el contexto se reinicia.

flowchart TD
    A([Sesión activa]) --> B([Claude compacta])
    B --> C["**PreCompact hook**
    lee transcripción + estado de git
    llama a claude -p
    escribe snapshot por rama"]
    C --> D["**PostCompact hook**
    lee el snapshot
    lo imprime a stdout → Claude"]
    D --> E([Sesión continúa con contexto])

    F([Nueva sesión — misma rama]) --> G["**SessionStart hook**
    encuentra snapshot del proyecto+rama
    lo inyecta como contexto"]
    G --> H([Claude retoma donde lo dejaste])

El snapshot es un documento markdown con cuatro campos:

# Session Context

_Captured: 2026-05-16T10:32Z_

## Goal
Migrar el sistema de autenticación a JWT con RS256

## Decisions
- Middleware aplicado a nivel de router, no por handler
- Usar refresh tokens de 7 días con rotación automática

## In Progress
 auth/middleware.go | 45 +++++++++
 auth/jwt.go        | 32 ++++++
 2 files changed, 77 insertions(+)

## Next
Agregar endpoint de refresh y escribir tests de integración

Eso es todo lo que necesita Claude para retomar exactamente donde estaba.

⚙️ Cómo funciona en la práctica

La instalación es una línea:

curl -fsSL https://raw.githubusercontent.com/AgusRdz/ctx/main/install.sh | sh
ctx init

Después de ctx init, los hooks quedan registrados en Claude Code. No hay nada más que configurar. La próxima vez que Claude compacte, ctx captura el contexto. La próxima vez que Claude arranque en ese proyecto y rama, lo restaura.

No tenés que acordarte de hacer nada.

🤖 Un detalle que me parece elegante

Para generar el snapshot, ctx no usa heurísticas simples. Llama a claude -p con la transcripción comprimida, el diff del git y el estado actual del proyecto, y le pide que extraiga los cuatro campos de manera semántica.

Esto significa que el snapshot no es un dump mecánico — es lo que realmente importa, filtrado por Claude mismo.

Si claude -p no está disponible por alguna razón, ctx tiene un fallback determinístico que construye el snapshot desde el estado del git. Nunca falla en silencio.

📋 Lo que cambió en mi flujo

Antes de ctx, después de una compactación yo dedicaba varios minutos a re-orientar a Claude: qué estábamos haciendo, qué habíamos decidido, qué faltaba. A veces pegaba texto manualmente de conversaciones anteriores.

Ahora no hago nada. La sesión continúa.

Lo que más me sorprendió no fue la conveniencia — fue darme cuenta de cuánto contexto estaba perdiendo sin notarlo. No lo ves mientras pasa. Solo ves que Claude empieza a hacer preguntas raras o sugiere cosas que ya descartaste.

🙃 Por qué lo hice público

Podría haber dejado ctx como un script en mi dotfiles. Pero el problema que resuelve es tan específico y tan común para cualquiera que trabaje con Claude Code regularmente, que me pareció que valía la pena pulirlo.

No es una herramienta para todos. Si usás Claude Code para sesiones cortas o tareas puntuales, probablemente no necesitás esto. Pero si trabajás en proyectos complejos, con sesiones que duran horas y varias compactaciones por día — ctx probablemente te ahorra entre 10 y 20 minutos de re-orientación por sesión.

✳️ Por dónde seguir

Es gratuito, de código abierto, con licencia MIT:

curl -fsSL https://raw.githubusercontent.com/AgusRdz/ctx/main/install.sh | sh
ctx init

👉 Página del proyecto ctx

La compactación no es un bug de Claude Code — es una necesidad arquitectónica. Pero la pérdida de contexto operativo que viene con ella sí es un problema que se puede resolver. ctx lo resuelve de la manera más pequeña posible.