VS Code on Linux: remote compaction fails when context window is full with GPT-6 Astra, leaving thread unrecoverable

What version of the IDE extension are you using?

newest

What subscription do you have?

Pro

Which IDE are you using?

VS Code

What platform is your computer?

Kubuntu 26.04.1 LTS (Resolute Raccoon) x86_64

What issue are you seeing?

What issue are you seeing?

When using Codex in the VS Code extension on Linux with GPT-6 Astra, long-running threads can reach a state where automatic context compaction fails because the context window is already full.

The UI first shows:

Context automatically compacted

followed by:

Reconnecting 2/2

and then fails with:

Error running remote compact task: Codex ran out of room in the model's context window. Start a new thread or clear earlier history before retrying.

At this point the thread is effectively unusable.

This seems like a catch-22 in the compaction logic:

1. The context window becomes full.
2. Codex attempts automatic compaction.
3. The remote compaction task itself requires context space.
4. Compaction fails because the context window is already full.
5. The existing thread can no longer recover.

This is particularly problematic for long-running coding sessions, where maintaining the accumulated context is important.

Environment

• OS: Linux
• Editor: VS Code
• Client: Codex VS Code extension
• Model: GPT-6 Astra
• Context management: automatic compaction
• Usage: long-running coding session / large project

Steps to reproduce

1. Open a project in VS Code on Linux.

2. Start a Codex session using GPT-6 Astra.

3. Continue using the same thread for a sufficiently long coding session.

4. Allow the context window to grow until automatic compaction is triggered.

5. Eventually Codex attempts to compact the conversation.

6. The remote compact task fails with:

   Codex ran out of room in the model's context window.

7. Retrying/reconnecting does not recover the thread.

Expected behavior

Codex should reserve enough context for compaction before the model reaches its hard context limit.

Ideally, automatic compaction should happen proactively before the remaining context becomes too small to perform the compaction itself.

If compaction nevertheless fails because of a context overflow, Codex should have a fallback mechanism that can recover the thread without requiring the user to start a completely new conversation.

For example:

• trigger compaction earlier;
• reserve a context budget specifically for compaction;
• truncate non-essential history before sending the compaction request;
• compact the history in chunks;
• or automatically create a recovery summary and continue the existing session.

A context-management feature should ideally prevent the thread from becoming unrecoverable because the context-management operation itself ran out of context.

Actual behavior

Automatic compaction is triggered, but the remote compact task runs out of context itself.

The session then enters an unrecoverable state and Codex tells the user to start a new thread or clear earlier history.

Additional information

The UI showed:

Context automatically compacted

Reconnecting 2/2

followed by:

Error running remote compact task: Codex ran out of room in the model's context window. Start a new thread or clear earlier history before retrying.

Screenshot attached.

The important part here is that this does not appear to simply be the model reaching its context limit. The recovery mechanism intended to handle that condition is itself failing because the context limit has already been reached.

What steps can reproduce the bug?

I am using the Codex VS Code extension on Linux with GPT-6 Astra.

The issue occurs in long-running Codex threads after the context has grown large enough for automatic compaction to trigger.

Steps:

1. Open a project in VS Code on Linux.
2. Start a Codex thread using GPT-6 Astra.
3. Continue working in the same thread for a long coding session.
4. Let the conversation/context grow until automatic context compaction is triggered.
5. Codex displays "Context automatically compacted".
6. The extension then shows "Reconnecting 2/2".
7. The remote compaction task fails with:

Error running remote compact task: Codex ran out of room in the model's context window. Start a new thread or clear earlier history before retrying.

After this happens, retrying does not recover the thread and I can no longer continue the existing session.

There is no small code snippet that reliably reproduces this because the problem appears to depend on accumulated conversation/context size rather than the code being processed.

What is the expected behavior?

Automatic context compaction should occur before the remaining context becomes too small for the compaction operation itself.

Reaching the context limit should not make an existing Codex thread unrecoverable.

If normal compaction cannot run because the context is already too large, Codex should fall back to another recovery method, for example by compacting older history in chunks, temporarily dropping non-essential context, or reserving enough context space for the compaction operation.

After compaction, the existing thread should remain usable and continue normally without requiring the user to start a new thread.

Additional information

Environment:

• OS: Linux
• Editor: VS Code
• Client: Codex VS Code extension
• Model: GPT-6 Astra
• Context management: Automatic compaction
• Workload: Long-running coding session in a large project

The exact error shown by the extension is:

Error running remote compact task: Codex ran out of room in the model's context window. Start a new thread or clear earlier history before retrying.

Immediately before the error, the UI shows:

Context automatically compacted

and:

Reconnecting 2/2

I have attached a screenshot showing the error.

The unusual part is that the mechanism intended to recover from a large/full context appears to run out of context itself.

This creates a catch-22:

Full context -> automatic compaction -> compaction runs out of context -> thread cannot recover.

Starting a new thread is possible, but that loses the accumulated conversational context from a long coding session, so it is not an ideal workaround.

No source file or test is named. Start by tracing the VS Code extension's automatic-compaction and reconnect flow, then reproduce a long-running GPT-6 Astra thread until the reported error appears. Done means a full-context thread can recover and continue without requiring a new conversation.