Cómo Recuperar Conversaciones Anteriores en Codex CLI desde los Registros

Este artículo proporciona una solución integral para el problema donde los registros de conversaciones pasadas se vuelven imposibles de desplazar en la TUI (Terminal UI) de OpenAI Codex CLI. Como buscar “resume” en Google produce principalmente resultados relacionados con currículos en lugar de información sobre recuperación de sesiones, lo documento aquí.

Qué Resuelve Este Artículo

• Has estado trabajando en Codex CLI por un tiempo y las conversaciones pasadas han desaparecido de la pantalla
• Reanudaste una sesión con codex resume, pero quieres revisar intercambios anteriores
• Quieres buscar sesiones pasadas por palabra clave
• Quieres guardar o compartir el historial de conversaciones como archivo de texto

En Resumen: No Confíes en el Desplazamiento de la TUI

Aunque la TUI de Codex CLI parece una interfaz de chat, hay un límite de cuánto puedes desplazarte hacia atrás. Durante sesiones largas, los registros pasados se vuelven “físicamente inalcanzables”.

Hay dos soluciones:

1. Leer los archivos de registro guardados localmente
2. Aumentar el límite del búfer de desplazamiento en la configuración de tu terminal

Este artículo se enfoca principalmente en el primer enfoque.

¿Dónde se Guardan los Registros de Codex?

Codex CLI guarda automáticamente los registros de conversaciones localmente.

~/.codex/sessions/AAAA/MM/DD/rollout-XXXX.jsonl

Ejemplo:

~/.codex/sessions/2025/12/14/rollout-2025-12-14T11-00-35-019b1a96-986b-7e20-865e-db1aff031855.jsonl

Estos archivos son los mismos que se usan al seleccionar una sesión con codex resume.

Verificación de Archivos de Registro

ls ~/.codex/sessions/
# Estructura de directorios Año/Mes/Día

ls ~/.codex/sessions/2025/12/14/
# archivos rollout-*.jsonl

Entendiendo la Estructura de Archivos JSONL

.jsonl (JSON Lines) es un formato donde cada línea es un objeto JSON separado. Abrirlo en bruto es bastante difícil de leer.

Herramienta Requerida: jq

Una herramienta de línea de comandos para formatear y extraer datos JSON.

# Instalación (Ubuntu/Debian)
sudo apt update && sudo apt install -y jq

Verificando la Estructura del Registro

Primero, examina la estructura de claves del archivo de registro:

cd ~/.codex/sessions/2025/12/14

# Seleccionar un archivo
f=$(ls -1 rollout-*.jsonl | head -n 1)
echo "FILE=$f"

# Verificar las claves de nivel superior
head -n 1 "$f" | jq 'keys'

Ejemplo de salida:

[
  "payload",
  "timestamp",
  "type"
]

Verificando Valores de Tipo

Los registros contienen múltiples tipos de eventos:

jq -r '.type' "$f" | sort | uniq -c | sort -nr | head -n 30

Ejemplo de salida:

    142 response_item
     47 event_msg
     12 turn_context
      1 session_start

Tipos principales:

• event_msg: Entrada del usuario o eventos del sistema
• response_item: Respuestas de la IA
• turn_context: Información de contexto
• session_start: Metadatos de inicio de sesión

Extrayendo Conversaciones en Formato Legible

Extrayendo Solo la Entrada del Usuario

jq -r '
  select(.type=="event_msg" and .payload.type=="user_message")
  | "USER: " + .payload.message
' "$f" | less -R

Extrayendo Solo las Respuestas de la IA

jq -r '
  select(.type=="response_item")
  | (.payload.role // "assistant") + ": " + ((.payload.content // []) | map(.text? // empty) | join(""))
' "$f" | less -R

Convirtiendo la Conversación Completa a Archivo de Texto

jq -r '
  if .type=="event_msg" and .payload.type=="user_message" then
    "USER: " + (.payload.message // "")
  elif .type=="response_item" then
    "ASSISTANT: " + ((.payload.content // []) | map(.text? // empty) | join(""))
  else empty end
' "$f" > convo.txt

less -R convo.txt

Salida con Marcas de Tiempo

jq -r '
  select(.type=="event_msg")
  | "[" + (.timestamp|tostring) + "] "
  + (.payload.type // "event") + ": "
  + (.payload.message // "")
' "$f" > convo_with_timestamp.txt

Buscando Conversaciones Pasadas por Palabra Clave

Para buscar palabras clave en múltiples archivos de registro, ripgrep (rg) es muy útil.

# Instalación
sudo apt install -y ripgrep

# Búsqueda
cd ~/.codex/sessions
rg -n "Next\.js|malware|vulnerability" --include "*.jsonl"

Buscando dentro de un directorio específico:

cd ~/.codex/sessions/2025/12/14
rg -n "palabra clave de búsqueda" rollout-*.jsonl

Creando Comandos de Conveniencia (Herramientas)

Escribir comandos jq cada vez es tedioso, así que crear un script es útil.

Creando el Comando codexlog

mkdir -p ~/bin

cat > ~/bin/codexlog <<'SH'
#!/usr/bin/env bash
set -euo pipefail

f="${1:-}"
if [[ -z "$f" ]]; then
  f="$(ls -1t rollout-*.jsonl 2>/dev/null | head -n 1)"
fi

if [[ ! -f "$f" ]]; then
  echo "Error: File not found: $f" >&2
  exit 1
fi

jq -r '
  if .type=="event_msg" and .payload.type=="user_message" then
    "USER: " + (.payload.message // "")
  elif .type=="event_msg" then
    ((.payload.type // "event") + ": " + (.payload.message // ""))
  elif .type=="response_item" then
    ((.payload.role // "unknown") + ": " + ((.payload.content // []) | map(.text? // empty) | join("")))
  else empty end
' "$f"
SH

chmod +x ~/bin/codexlog

Uso

# Agregar ~/bin a PATH (agregar a .bashrc)
export PATH="$HOME/bin:$PATH"

# Mostrar el registro más reciente
cd ~/.codex/sessions/2025/12/14
codexlog | less -R

# Especificar un archivo particular
codexlog rollout-2025-12-14T11-00-35-XXXXX.jsonl | less -R

Configuración del Terminal (Medidas Complementarias)

El límite de desplazamiento de la TUI depende de la configuración de tu terminal.

Para tmux

Agregar a ~/.tmux.conf:

set -g history-limit 100000

Para Windows Terminal

Configuración → Perfiles → Seleccionar perfil → Aumentar Líneas de desplazamiento (ej., 100000)

Grabando Todo con el Comando script

Un método para guardar toda la salida del terminal directamente en un archivo:

script -f codex.tui.log
codex
# Después del trabajo
exit

Esto graba toda la salida de la TUI en codex.tui.log.

Comandos Slash Útiles de Codex CLI

Comandos para usar cuando el contexto está a punto de desbordarse durante conversaciones largas:

Solución de Problemas

Errores de Análisis de jq

jq: parse error: Invalid numeric literal at line 1, column 4

Causa: Cuando head -n 1 rollout-*.jsonl coincide con múltiples archivos, head muestra líneas de encabezado (==> filename <==).

Solución: Especificar solo un archivo

f=$(ls -1 rollout-*.jsonl | head -n 1)
head -n 1 "$f" | jq 'keys'

La Variable $f Apunta a un Archivo Antiguo

Las variables de shell persisten incluso cuando cambias de directorio.

Solución: Restablecer la variable en tu directorio de trabajo

cd ~/.codex/sessions/2025/12/14
f=$(ls -1 rollout-*.jsonl | head -n 1)
echo "FILE=$f"

O especificar la ruta completa:

f="$HOME/.codex/sessions/2025/12/14/rollout-2025-12-14T11-00-35-XXXXX.jsonl"

No such file or directory

Cómo verificar:

pwd
echo "$f"
ls -l "$f"

Verifica que el directorio actual y el valor de $f coincidan.

Por Qué Funciona Este Método

El sistema de registro de Codex CLI está diseñado para permitir la recuperación incluso si la interfaz se rompe:

• Registra todas las conversaciones como un flujo de eventos (JSONL)
• Guarda por separado según el rol (user/assistant/system)
• Organiza archivos por fecha + UUID

Este diseño prioriza “registros inquebrantables” sobre “apariencia visual”.

Una vez que puedas analizar registros con jq:

• No estás limitado por los límites de visualización de la TUI
• Puedes buscar libremente en sesiones pasadas
• Puedes guardar y compartir conversaciones como texto
• Puedes recuperar manualmente incluso si la herramienta se rompe

Resumen

Esta información es difícil de encontrar en Google, pero conocerla definitivamente será útil.

Referencias

• Codex CLI Features – OpenAI Developers
• Codex Local Config – OpenAI Developers
• Codex Slash Commands – OpenAI Developers
• jq Manual

Espero que este artículo resuelva el problema de “¡no puedo verlo!” de alguien.

Cómo Recuperar Conversaciones Perdidas desde los Registros de Codex TUI

Cuando trabajas en la TUI (Terminal User Interface) de Codex durante períodos prolongados, las conversaciones pasadas pueden volverse invisibles. Esto no significa que hayan desaparecido—simplemente están más allá de los límites de visualización de la TUI.

Este artículo explica cómo recuperar y buscar conversaciones desde los registros guardados localmente (formato JSONL).

¿Qué es TUI?

TUI (Terminal User Interface) es una interfaz de usuario que se ejecuta en la terminal. A diferencia de las aplicaciones GUI que usan el mouse, las TUIs se manejan principalmente con el teclado. La interfaz de Codex es un ejemplo de TUI.

Ubicaciones de Archivos de Registro

Codex

~/.codex/sessions/AAAA/MM/DD/rollout-*.jsonl

Claude Code

~/.claude/projects/<project>/

Ambos siguen el mismo principio: puedes recuperar conversaciones “extrayendo solo las líneas relevantes de registros mezclados”.

Preparación para Verificar Registros

Abrir con VSCode (Recomendado)

Como los directorios de registros están profundamente anidados, abrir la carpeta .codex en VSCode para navegación visual es más eficiente que usar comandos.

cd ~
ls -la .codex

Los registros están organizados por fecha. Como puede haber múltiples archivos por día, primero necesitas determinar “cuál leer”. Generalmente, comienza con el archivo rollout-*.jsonl más reciente.

Entendiendo la Estructura del Registro

Hay dos tipos principales importantes en los registros.

event_msg

Registra la entrada del usuario.

jq -c 'select(.type=="event_msg") | .payload' "$f" | head -n 1 | jq .

Ejemplo de salida:

{
  "type": "user_message",
  "message": "Hola.\nRecientemente, mi aplicación Next.js fue explotada a través de una vulnerabilidad e infectada con malware.",
  "images": []
}

El campo message contiene el texto exacto que el usuario escribió.

response_item

Registra respuestas de la IA e información del sistema.

jq -c 'select(.type=="response_item") | .payload' "$f" | head -n 1 | jq .

Ejemplo de salida:

{
  "type": "message",
  "role": "user",
  "content": [
    {
      "type": "input_text",
      "text": "<environment_context>..."
    }
  ]
}

El role (user/assistant) y el contenido están dentro de content. Como la información del entorno también está mezclada, necesita manejarse por separado del texto de la conversación.

Verificando la Estructura

jq -c 'select(.type=="response_item") | .payload' "$f" | head -n 1 | jq 'keys'

Salida:

["content", "role", "type"]

Si tienes type / role / content, puedes recuperar la conversación separando usuario y asistente por rol y extrayendo solo el texto de content.

Comandos jq para Extraer Conversaciones

Puedes extraer solo la conversación de event_msg y response_item. Después de la extracción, puedes desplazarte usando la rueda del mouse, las teclas de flecha del teclado o PageUp/PageDown. Presiona “q” para salir.

Buscando Palabras Clave Específicas

Usando rg (ripgrep), puedes buscar rápidamente registros que contengan palabras clave específicas.

# Buscar registros relacionados con nginx
rg nginx "$f"

# Buscar registros relacionados con proxy
rg proxy "$f"

# Buscar patrones similares a nombres de archivos
rg -n "(/etc/nginx|nginx\.conf|sites-available|.conf|Dockerfile|next\.config|package\.json)" "$f"

# Buscar registros relacionados con edición/modificación
rg -n "edit|modify|change|update|patch|diff|file|fix|modification" "$f"

Qué Puedes y No Puedes Ver en los Registros

Probablemente Visible

• Texto explicativo como “editó el archivo XX” o “cambió la configuración”
• Comandos que fueron ejecutados
• Directorio de trabajo (cwd) e información del entorno

Difícil de Ver o No Garantizado

• Parches completos (diffs que muestran exactamente qué líneas cambiaron y cómo)
• El contenido real de los archivos modificados en sí mismos

Si bien los registros son útiles para “rastrear actividades”, Git es la mejor herramienta para conocer las verdaderas diferencias.

Resumen

• Puedes reanudar con codex resume, pero la TUI puede no mostrar todo el historial pasado
• Leer los registros directamente revela información e intercambios que ocurrieron durante el trabajo, los cuales puedes revisar más tarde
• Las conversaciones pueden recuperarse de los registros, pero para un seguimiento 100% confiable de cambios en archivos, git diff es el mejor enfoque