# Error al compactar en Claude Code: causa y solución por mensaje > «Error compacting conversation» en Claude Code solo avisa de que la compactación falló; la causa está en la línea de al lado, y de ella depende la salida. - URL: https://blog.laozhang.ai/es/posts/claude-code-error-compacting-conversation - Published: 2026-10-16 - Updated: 2026-10-16 - Author: LaoZhang AI Team (https://blog.laozhang.ai/es/about) - Topic: Claude Code - Tags: Claude Code, Compactación, Contexto, Errores, Solución de problemas --- El aviso rojo `Error compacting conversation` de Claude Code no es un diagnóstico: solo indica que la compactación (el resumen que libera la ventana de contexto) lanzó un error. **La causa real está en la línea que aparece junto a él**, por ejemplo `Error during compaction:` seguido del motivo, `Conversation too long…` o `Prompt is too long · automatic compaction failed:` seguido del error de fondo. Cada texto tiene una salida distinta. El orden que menos trabajo te hace perder es este: 1. Ejecuta `claude update`. Muchos fallos de compactación se corrigieron en versiones concretas; a 16 de octubre de 2026 la última es la 2.1.301. 2. Busca tu mensaje exacto en la tabla de abajo. 3. Recupera la sesión empezando por lo menos drástico: rebobinar con Esc dos veces, `/compact` con instrucciones de enfoque, quitar el adjunto pesado o, como último paso, guardar el estado en un archivo y hacer `/clear`. Todo lo que sigue vale para Claude Code en la terminal y también en el IDE y la app de escritorio, donde funcionan los mismos comandos. La compactación del chat de claude.ai («Compacting our conversation so we can keep chatting») y la Compaction de la API son otros productos y no se tratan aquí. ## Error compacting conversation: el aviso rojo solo envuelve el fallo En la versión 2.1.301, Claude Code muestra esa notificación cada vez que una compactación termina en error, tanto si la lanzaste tú con `/compact` como si fue la compactación automática (auto-compact) o la parcial del menú de rebobinado (**Summarize from here** y **Summarize up to here**). La notificación no lleva el motivo; el motivo es el texto que sale en la conversación o en la línea de estado. Hay tres casos en los que la compactación se detiene **sin** ese aviso rojo, porque no son fallos: - Pulsaste Esc mientras compactaba. Desde la 2.1.133 verás `Compaction canceled.`; antes salía por error la notificación roja. - No hay nada anterior que resumir: `Not enough messages to compact.` - Un hook `PreCompact` bloqueó la compactación. Si sigues viendo el aviso al pulsar Esc, estás en una versión anterior a la 2.1.133, otro motivo para actualizar antes de investigar nada más. ![Seis mensajes que acompañan al aviso Error compacting conversation en Claude Code y la primera salida de cada uno](https://blog.laozhang.ai/posts/es/claude-code-error-compacting-conversation/img/mensajes-y-salidas.webp) ## Tabla de mensajes de compactación en Claude Code 2.1.301 Los textos de esta tabla corresponden a los incluidos en el ejecutable de Claude Code 2.1.301. La columna «Comprobado» separa lo que apareció en una prueba local de lo que procede de la documentación oficial, del registro de cambios o solo del texto del programa. | Mensaje que ves | Qué significa | Primera salida | Comprobado | | --- | --- | --- | --- | | `Error during compaction:` seguido de un motivo | `/compact` falló; el prefijo es fijo y el motivo real viene después | Busca ese motivo en esta misma tabla | Texto del programa | | `Conversation too long. Press esc twice to go up a few messages and try again.` | La conversación es tan grande que ni la petición de resumen cabe en la ventana de contexto | Actualiza; después Esc dos veces y vuelve unos mensajes atrás antes de reintentar | Registro de cambios (2.1.85 y 2.1.284) | | `Compaction failed · conversation could not be reduced below the context limit` | Ni resumiendo se consiguió bajar del límite de contexto | Rebobina hasta antes del turno más pesado o guarda el estado y haz `/clear` (inferencia) | Texto del programa | | `Compaction failed · attached media exceeds size limits` | Las imágenes o documentos adjuntos superan el tamaño admitido | Vuelve atrás hasta antes del turno que añadió el adjunto, o `/clear` (inferencia) | Texto del programa | | `Compaction interrupted · This may be due to network issues — please try again.` | Se cortó la conexión o la respuesta durante el resumen | Comprueba la red y repite `/compact` | Texto del programa | | `Prompt is too long · automatic compaction failed:` seguido del error de fondo | La compactación automática falló por otro error, como un modelo no disponible o un fallo de autenticación | Resuelve primero ese error; `/compact` fallará igual hasta entonces | Documentación oficial | | `Autocompact is thrashing: the context refilled to the limit within 3 turns…` | La compactación funcionó, pero un archivo o una salida de herramienta volvió a llenar el contexto tres veces seguidas | Lee el archivo por partes, `/compact` con foco o pasa el trabajo a un subagente | Documentación oficial | | `Compaction blocked by PreCompact hook:` seguido del comando y el motivo | Un hook tuyo o del proyecto impide compactar | Revisa o desactiva ese hook en tu configuración | Prueba local | | `Not enough messages to compact.` | No hay mensajes anteriores que resumir | Si el contexto está lleno, `/clear` y reenvía con menos texto pegado | Prueba local | | `/compact isn't available in this environment.` | La variable `DISABLE_COMPACT=1` está activa | Quita la variable si quieres compactar | Prueba local | | `Compaction canceled.` | Cancelaste con Esc | Nada; vuelve a lanzar `/compact` cuando quieras | Registro de cambios (2.1.133) | La prueba local se hizo el 16 de octubre de 2026 con Claude Code 2.1.301 en macOS, en modo no interactivo (`claude -p`) y con Haiku 5.5. En ella aparecieron tal cual el bloqueo por hook, `Not enough messages to compact.` y `/compact isn't available in this environment.`. No se reprodujeron `Conversation too long`, las dos variantes de `Compaction failed`, `Compaction interrupted`, el thrashing ni la propia notificación roja: hacen falta sesiones de cientos de miles de tokens o un corte de red. Para esas filas, el significado sale de la [referencia de errores de Claude Code](https://code.claude.com/docs/es/errors), de la [guía de solución de problemas de Claude Code](https://code.claude.com/docs/es/troubleshooting) y del [registro de cambios de Claude Code en GitHub](https://github.com/anthropics/claude-code/blob/main/CHANGELOG.md). Las salidas marcadas como «inferencia» no aparecen así en la documentación: se apoyan en lo que esta indica para el error `Request too large`, que pide volver atrás con Esc dos veces hasta antes del turno que añadió el contenido grande o empezar de cero con `/clear`. ### Conversation too long y Prompt is too long al compactar Son los dos textos que más se buscan y no significan lo mismo. `Conversation too long` es un fallo del propio `/compact`: el historial ya no cabía en la petición de resumen. Era habitual en 2025; la 2.1.85 corrigió que `/compact` fallara cuando la conversación había crecido demasiado para que cupiera la petición de compactación, y la 2.1.284 hace que, si el resultado sigue siendo demasiado largo, Claude Code compacte otra vez conservando menos conversación reciente. Si te sale en una versión actual, el mensaje mismo te da la salida: Esc dos veces, vuelve unos mensajes atrás y reintenta. `Prompt is too long` es el error de la petición normal cuando la conversación y los adjuntos superan la ventana del modelo. En una sesión interactiva se muestra como `Context limit reached · /compact or /clear to continue`. Desde la 2.1.229, si la compactación automática falla en ese momento, el mensaje añade la causa tras `automatic compaction failed:`; antes salía solo `Prompt is too long`, sin pista. En Amazon Bedrock la misma condición llega como `Input is too long for requested model.`, que Claude Code no reconocía antes de la 2.1.217; los demás mensajes de Bedrock están en [Error 400 de Claude en AWS Bedrock: qué significa cada mensaje](https://blog.laozhang.ai/es/posts/aws-claude-400-error). ## Recuperar la sesión tras el error al compactar, de menos a más drástico Ve en este orden y para en cuanto la sesión vuelva a responder. ![Seis pasos para recuperar la sesión de Claude Code tras un error al compactar, junto a lo que hace cada opción del menú de rebobinado](https://blog.laozhang.ai/posts/es/claude-code-error-compacting-conversation/img/escalera-recuperacion.webp) **1. Guarda una copia de la conversación.** `/export sesion.txt` escribe la conversación en texto plano; sin nombre de archivo abre un diálogo para copiarla o guardarla. Así tienes el historial aunque los pasos siguientes salgan mal. **2. Rebobina con Esc dos veces.** Con el campo de entrada vacío, pulsa Esc dos veces (o escribe `/rewind`) para abrir el menú de rebobinado. Si hay texto en el campo, el primer doble Esc solo lo borra. Elige un mensaje y una acción: - **Restore conversation** devuelve la conversación a ese punto y mantiene el código tal como está. Es lo que pide `Conversation too long`: subir unos mensajes y volver a intentarlo. - **Summarize up to here** resume todo lo anterior a ese mensaje y deja intacto lo posterior. Sirve cuando el peso está en el historial antiguo. - **Summarize from here** resume desde ese mensaje hasta el final. Sirve cuando lo que llenó el contexto fue un tramo reciente, como una depuración larga. Antes de confirmar un resumen puedes escribir qué debe conservar en la fila **add context (optional)**. Ten en cuenta que estos resúmenes parciales también son compactaciones: si fallan, verás el mismo aviso rojo y conviene pasar al siguiente paso. **3. Lanza `/compact` con instrucciones de enfoque.** Por ejemplo, `/compact conserva solo el plan y el diff`. Un resumen que descarta la salida grande tiene más margen para caber que uno que intenta guardarlo todo. **4. Quita el adjunto pesado.** Si el problema son imágenes, PDF o un pegado enorme, usa **Restore conversation** en el mensaje anterior al que los añadió. La próxima vez, pasa la ruta del archivo en lugar de pegar su contenido, para que Claude lo lea por partes. **5. Arregla el error de fondo.** Con `Prompt is too long · automatic compaction failed:`, lo que va detrás de los dos puntos manda: si es un modelo no disponible, cambia de modelo con `/model`; si es autenticación, vuelve a iniciar sesión. Hasta que no se resuelva, `/compact` falla con el mismo error. **6. Guarda el estado en archivos y haz `/clear`.** Pide a Claude que escriba en un archivo de plan (o en el `CLAUDE.md` del proyecto, si son reglas duraderas) qué estaba haciendo, qué falta y qué decisiones se tomaron. Después ejecuta `/clear` y, en la sesión nueva, pídele que lea ese archivo. La conversación anterior no se borra: puedes volver a ella con `/resume`, y mientras no cierres Claude Code el menú de rebobinado muestra arriba una entrada `(previous session)` para recuperarla. Algunos usuarios informan en Reddit y en GitHub de otros trucos que les funcionaron en versiones antiguas: salir de Claude Code, abrir la sesión con `claude --resume` y lanzar `/compact`, o encadenar `/clear`, `/resume` y `/compact`. No están documentados como solución oficial, pero no cuesta probarlos antes del paso 6. ## Si la compactación se queda colgada: Esc, Ctrl+C y claude --resume Si el resumen tarda demasiado, pulsa Esc: desde la 2.1.133 se cancela limpiamente con `Compaction canceled.` y la sesión sigue como estaba. Si la terminal no responde, la guía oficial de solución de problemas recomienda Ctrl+C y, si hace falta, cerrar la terminal. Reiniciar no borra la conversación: ejecuta `claude --resume` en el mismo directorio para retomarla. En Mac hay un caso concreto: hasta la 2.1.290, si el equipo entraba en reposo durante la compactación automática, esta se rendía con `Prompt is too long`. Con la versión actual no deberías verlo. ## Qué conserva Claude Code después de compactar Saber qué sobrevive al resumen explica por qué conviene guardar el estado en archivos antes de un `/clear`. Según la documentación de la ventana de contexto, tras compactar: - El prompt de sistema y el estilo de salida siguen aplicándose. - El `CLAUDE.md` de la raíz del proyecto, las reglas sin `paths:`, la memoria automática (auto memory) y el plan escrito en modo plan se vuelven a cargar desde el disco. - Claude Code vuelve a leer hasta cinco de los archivos que Claude leyó o editó, los modificados más recientemente; uno de más de 5.000 tokens vuelve solo como referencia a su ruta. - Las skills invocadas se reinyectan con un límite de 5.000 tokens por skill y 25.000 en total. - Las reglas con `paths:` y los `CLAUDE.md` de subcarpetas quedan resumidos y no vuelven hasta que se toque de nuevo un archivo que los active. Es decir: lo que esté en el `CLAUDE.md` raíz o en el plan sobrevive a cualquier compactación y a un `/clear`; lo que solo exista en la conversación depende de que el resumen lo recoja. Si quieres ordenar qué va en cada capa, tienes la [Guía de memoria de Claude Code (2026): CLAUDE.md, auto memory y cuándo necesitas un plugin](https://blog.laozhang.ai/es/posts/claude-code-memory). ## Auto-compact en Claude Code: cuándo salta y qué ajustes lo cambian La compactación automática se activa cerca del límite de contexto del modelo. En los modelos con ventana nativa de 1 millón de tokens (Fable, Sonnet 5 y posteriores, Haiku 5.5, Opus 4.7 y posteriores) salta hacia los 967.000 tokens; en Sonnet y Opus 4.6 sin contexto ampliado, en 200.000. Si usas un alias de modelo de una pasarela que Claude Code no reconoce, asume 200.000, y por eso el error puede aparecer mucho antes de lo esperado; la 2.1.299 corrigió uno de esos casos. Los ajustes que más se confunden: | Ajuste | Auto-compact | `/compact` manual | | --- | --- | --- | | `DISABLE_COMPACT=1` | Desactivado | Desactivado (`/compact isn't available in this environment.`) | | `DISABLE_AUTO_COMPACT=1` | Desactivado, también la compactación por inactividad | Disponible | | `autoCompactEnabled: false` o el interruptor **Auto-compact** de `/config` | Desactivado | Disponible | | `/autocompact` con un tamaño, por ejemplo `500k` | Activado, salta al llegar a ese tamaño | Disponible | `/autocompact` acepta valores entre 100K y 1M y, desde la 2.1.288, se guarda por modelo. La variable `CLAUDE_CODE_AUTO_COMPACT_WINDOW` (solo un número entero) tiene prioridad sobre el resto, y `CLAUDE_AUTOCOMPACT_PCT_OVERRIDE` solo puede bajar el porcentaje en que salta, no subirlo. Desactivar auto-compact no evita el error: lo cambia por `Context limit reached`, y la documentación recomienda volver a activarlo o, si lo dejas apagado, ejecutar `/compact` tú antes de que se llene la ventana. Desde la 2.1.235 el aviso de límite añade `auto-compact is off · /config to turn it on` cuando el ajuste de `/config` es lo que lo tiene apagado. Si lo que te molesta es que salte demasiado a menudo, mira qué ocupa el contexto con `/context`: suelen ser herramientas MCP o salidas enormes, y en [Claude Code con MCP: cómo liberar contexto sin perder la tarea](https://blog.laozhang.ai/es/posts/claude-code-mcp-context-overload) está cómo reducirlas. Desde la 2.1.299 también existe la compactación por inactividad: una conversación de más de 200.000 tokens que lleva unos 54 minutos parada se compacta antes de que caduque la caché de una hora; se desactiva con `"idleCompaction": false`. Cómo afecta eso a la factura lo tienes en [Claude Code cache miss y coste de tokens: por que un turn sale caro](https://blog.laozhang.ai/es/posts/claude-code-cache-miss-token-costs). Si el bloqueo viene de un hook `PreCompact` (puede impedir la compactación saliendo con código 2 o devolviendo `{"decision":"block"}`, desde la 2.1.105), revisa la sección `hooks` de tus archivos de configuración; cómo se definen está en [Claude Code: hooks, comandos de barra y skills, ¿cuál usar?](https://blog.laozhang.ai/es/posts/claude-code-hooks-slash-commands-skills). ## Versiones de Claude Code que corrigieron fallos de compactación Este es el motivo de que `claude update` vaya primero. Correcciones del registro de cambios relacionadas con la compactación: | Versión | Qué se corrigió | | --- | --- | | 2.1.76 | Auto-compact dejaba de reintentar sin fin: ahora para tras 3 fallos seguidos | | 2.1.85 | `/compact` fallaba cuando la conversación ya no cabía en la propia petición de compactación | | 2.1.89 | Bucle de thrashing: ahora se detiene con un mensaje que dice qué hacer | | 2.1.113 | Compactar una sesión reanudada de contexto largo fallaba con `Extra usage is required for long context requests` | | 2.1.133 | Esc durante la compactación mostraba un falso `Error compacting conversation` | | 2.1.217 | `/compact` fallaba en Bedrock con `Input is too long for requested model.` | | 2.1.280 | Una sesión fallaba en cada turno y en `/compact` por un aviso MCP mal formado | | 2.1.282 | Si el modelo rechaza hacer el resumen, se reintenta con un modelo alternativo | | 2.1.284 | `Prompt is too long` persistía tras compactar; ahora compacta otra vez con menos contexto reciente | | 2.1.285 | Compactar o reanudar fallaba por marcadores de compactación mal formados | | 2.1.290 | Error `null is not an object` al compactar, y el reposo del Mac durante la compactación | | 2.1.299 | Nombres de modelo de pasarela que acababan en `Prompt is too long · automatic compaction failed` cerca de 200.000 tokens | Si el fallo se repite con la versión actual, repórtalo. `/feedback` abre un diálogo en el que eliges cuánto historial de la sesión incluir y confirmas antes de enviar nada. También puedes abrir un issue en el [repositorio anthropics/claude-code de GitHub](https://github.com/anthropics/claude-code/issues) con la versión (`claude --version`), el mensaje exacto y qué estabas haciendo. ## Preguntas frecuentes sobre el error al compactar en Claude Code ### ¿Rebobinar con Esc dos veces deshace mis cambios en el código? Solo si eliges una opción que restaure código. **Restore conversation** y las dos opciones de **Summarize** no tocan los archivos; **Restore code** y **Restore code and conversation** sí los devuelven al estado de ese punto. Los comandos que Claude ejecutó por Bash no se registran en los puntos de control, así que no se deshacen. ### ¿Desactivar auto-compact evita el error al compactar? No. Sin compactación automática, la conversación acaba chocando con el límite y ves `Context limit reached · /compact or /clear to continue`. Lo útil es dejarlo activado y reducir lo que llena el contexto, o ajustar con `/autocompact` cuándo salta. ### ¿Sirve esto para el chat de claude.ai? No. El aviso de compactación del chat de claude.ai y la Compaction de la API de Claude son productos distintos de Claude Code; los comandos de esta página (`/compact`, `/rewind`, `/clear`) solo existen en Claude Code. ## Fuentes Páginas externas que cita esta guía, en el orden en que aparecen. Última actualización: 2026-10-16. - [referencia de errores de Claude Code](https://code.claude.com/docs/es/errors) (code.claude.com) - [guía de solución de problemas de Claude Code](https://code.claude.com/docs/es/troubleshooting) (code.claude.com) - [registro de cambios de Claude Code en GitHub](https://github.com/anthropics/claude-code/blob/main/CHANGELOG.md) (github.com) - [repositorio anthropics/claude-code de GitHub](https://github.com/anthropics/claude-code/issues) (github.com)