Cap 5: Sesiones, Resumption y Forking

Sesiones, Resumption y Forking

Gestionar sesiones de forma inteligente permite continuar trabajo previo, explorar alternativas y dividir tareas grandes en passes manejables.

---

—resume para continuar sesiones nombradas

Cada sesión de Claude Code puede tener un nombre. Para retomarla:

# Iniciar una sesión con nombre
claude --session "auth-refactor"

# Retomarla después
claude --resume "auth-refactor"

Al resumir, Claude recupera el historial de la sesión y puede continuar donde se quedó. El contexto previo (mensajes, tool results, archivos leídos) está disponible.

Sesiones recientes sin nombre

# Listar sesiones recientes
claude --resume

# Retomar la más reciente
claude --continue

Cuándo resumir vs empezar fresco

Situación	Acción
El contexto previo sigue siendo mayormente válido	Resumir
Han cambiado muchos archivos desde la última sesión	Empezar fresco con summary
La tarea es continuación directa de la anterior	Resumir
El context window estaba casi lleno	Empezar fresco
Quieres un approach completamente diferente	Empezar fresco

Informar sobre cambios al resumir

Si entre sesiones cambiaron archivos relevantes, informa a Claude al inicio:

> Desde la última sesión:
> - Se actualizó src/auth/token.ts (nuevo campo refresh_token)
> - Se eliminó src/utils/deprecated.ts
> - Se agregaron tests en tests/auth/token.test.ts
> Continúa el refactoring del módulo de autenticación.

Sin esta información, Claude podría razonar sobre un estado de archivos que ya no existe.

fork_session para exploración divergente

fork_session crea una rama de exploración a partir del estado actual. El fork comparte el baseline (filesystem, historial hasta el punto de fork) pero opera de forma independiente.

Sesión principal ──────────────────────────►
    │
    ├── fork_session("approach-sql-raw")  ──►
    │
    └── fork_session("approach-orm")  ──────►

Casos de uso

Exploración de diseño: probar 2-3 approaches antes de comprometerse con uno.

# Desde la sesión principal
fork_session("caching-redis")
# → explora implementación con Redis

fork_session("caching-memcached")
# → explora implementación con Memcached

Cambios riesgosos: probar una refactorización sin afectar el trabajo estable.

Pruebas de concepto rápidas: validar una idea antes de invertir tiempo en la implementación completa.

Fork vs spawning paralelo

Aspecto	fork_session	Spawning paralelo (Task)
Estado	Hereda filesystem completo	Contexto aislado
Propósito	Explorar alternatives	Dividir trabajo
Resultado	Un approach ganador	Múltiples outputs combinados
Historial	Hereda hasta punto de fork	Limpio

Task decomposition: fijo vs dinámico

Prompt chaining fijo

Una secuencia predefinida de pasos donde cada paso alimenta al siguiente:

Paso 1: Extraer esquema →
Paso 2: Generar tipos TypeScript →
Paso 3: Crear validadores Zod →
Paso 4: Generar tests

Cada paso es un prompt diferente. La salida del paso N es la entrada del paso N+1. El flujo siempre es el mismo.

Ventajas: predecible, fácil de debuggear, cada paso es testeable.

Desventajas: no se adapta a casos inesperados, desperdicia pasos si la tarea es simple.

Descomposición dinámica adaptativa

El coordinator analiza la tarea y decide en runtime qué subtareas crear:

Coordinator analiza: "Migrar módulo de pagos a nuevo proveedor"
    │
    ├── Complejidad alta detectada
    │   ├── Subtarea: Mapear API del nuevo proveedor
    │   ├── Subtarea: Adaptar interfaces existentes
    │   ├── Subtarea: Migrar tests
    │   └── Subtarea: Actualizar documentación
    │
    vs.
    │
    └── Complejidad baja detectada
        └── Subtarea única: Actualizar endpoint y credenciales

Ventajas: se adapta a la complejidad real, no desperdicia recursos.

Desventajas: el coordinator debe tener buen juicio para descomponer correctamente.

Cuándo usar cada uno

Situación	Approach
Pipeline bien definido que no cambia	Prompt chaining fijo
Tareas con complejidad variable	Descomposición dinámica
Procesos regulatorios con pasos obligatorios	Prompt chaining fijo
Solicitudes de usuario abiertas	Descomposición dinámica

Splitting large code reviews

Las revisiones de código grandes se benefician de un approach en dos passes:

Pass 1: Per-file review

Cada archivo se revisa individualmente por un subagente:

Subagente A: Revisa src/auth/login.ts
  → Issues encontrados: 2 (input validation, error handling)

Subagente B: Revisa src/auth/token.ts
  → Issues encontrados: 1 (token expiration check)

Subagente C: Revisa src/auth/middleware.ts
  → Issues encontrados: 0

Cada subagente se enfoca en la calidad interna del archivo: estilo, bugs, seguridad, performance.

Pass 2: Integration review (cross-file)

Un subagente o el coordinator revisa las interacciones entre archivos:

Integration review:
  - ¿login.ts y token.ts usan el mismo formato de token? ✓
  - ¿middleware.ts maneja todos los errores que login.ts puede lanzar? ✗
  - ¿Las interfaces compartidas son consistentes? ✓
  - ¿Los imports están correctos y no hay dependencias circulares? ✓

Por qué dos passes

Un solo pass que revise todo simultáneamente puede:

• Agotar el context window con archivos grandes
• Perder detalles per-file por enfocarse en integración
• Perder problemas cross-file por enfocarse en detalles

Dos passes garantizan cobertura completa: profundidad per-file + amplitud cross-file.

Combinar resultados

El coordinator agrega los findings de ambos passes:

interface CodeReviewResult {
  per_file_issues: FileIssue[];      // Del pass 1
  integration_issues: IntegrationIssue[];  // Del pass 2
  summary: string;
  severity_breakdown: {
    critical: number;
    high: number;
    medium: number;
    low: number;
  };
}

Resumen

Concepto	Detalle
—resume	Retomar sesiones nombradas con contexto previo
fork_session	Exploración divergente desde baseline compartido
Cambios entre sesiones	Informar explícitamente a Claude
Prompt chaining	Pipeline fijo para procesos predefinidos
Decomposición dinámica	Adaptativa según complejidad
Code review	Pass per-file + pass integration cross-file

---

Anterior: Workflows, Hooks y Handoffs | Índice: Índice | Siguiente: Diseño de Tools