Auto-compaction never triggers

[brandomagnani]

What version of Codex CLI is running?

codex-cli 0.117.0

What subscription do you have?

Pro

Which model were you using?

gpt-5.3-codex

What platform is your computer?

macOS Darwin 25.3.0 (Apple Silicon)

What terminal emulator and version are you using (if applicable)?

Headless mode via codex exec (spawned programmatically)

What issue are you seeing?

Auto-compaction never fires when running Codex in headless exec mode. The session accumulates tool outputs until it hits the context window limit, then crashes with "Codex ran out of room in the model's context window." The watcher retries, each retry adds to the session, and it enters a permanent crash loop.

Config:

model_context_window = 400000
model_auto_compact_token_limit = 350000

Evidence from Codex session file:

• 86 shell commands executed, producing ~242K tokens of tool output
• token_count events in session file all show empty input_tokens_used — token tracking appears broken in exec mode
• Zero compact events in the session — compaction never triggered
• Session crashes at context limit without any compaction attempt

Evidence from traces:

• turn_context events appear (which I believe are compaction triggers) but they are followed immediately by task_complete with last_agent_message: null — suggesting compaction was attempted but failed silently
• After first crash, every retry fails within 4-5 seconds with the same context overflow error

Codex session ID: 019d30b8-c263-7190-9072-14650024a1ae

This is blocking automated workflows where agents need to read large codebases. The agent reads files incrementally (200-300 line chunks via sed), but after ~86 commands the accumulated context exceeds the window. In interactive mode, compaction would presumably trigger and summarize earlier context. In exec mode, it never fires.

What steps can reproduce the bug?

1. Set model_auto_compact_token_limit = 350000 and model_context_window = 400000 in config.toml
2. Run codex in headless exec mode: codex exec --resume <session-id> "Read a large codebase by running sed on many files"
3. The agent will read files until it accumulates ~350K+ tokens
4. Expected: auto-compact triggers at 350K, summarizes context, continues
5. Actual: no compaction, crashes at 400K, permanent crash loop on retry

What is the expected behavior?

model_auto_compact_token_limit should trigger auto-compaction in exec mode the same way it does in interactive mode. Token counting should work (currently reports empty values in exec mode).

Additional information

Related issues: #14860, #14913, #13279 (compaction death spiral)

This may be the same underlying issue as #14860 (TCP timeout on compaction endpoint), but the symptom is different — in our case compaction never even attempts to fire, rather than timing out mid-compact.

[github-actions]

Potential duplicates detected. Please review them and close your issue if it is a duplicate.

• Error running remote compact task #14860
• Compaction error #14913
• Error running remote compact task: stream disconnected before completion BUG #14559
• Codex ran out of room in the model's context window. Start a new thread or clear earlier history before retrying. #14310

Powered by Codex Action

[brandomagnani]

Update: confirmed this persists after completely nuking ~/.codex/, fresh installing 0.117.0, and re-authenticating (Pro subscription). No old threads or sessions carried over.

Error on every retry:

{"type":"error","message":"Codex ran out of room in the model's context window. Start a new thread or clear earlier history before retrying."}

Running via codex exec with --resume. Config: model_context_window = 400000, model_auto_compact_token_limit = 300000.

[brandomagnani]

Root cause found in source code (codex-rs/core/src/codex.rs):

Auto-compaction only checks token count between turns, not between tool calls within a turn.

Pre-sampling compact check (line 6080) runs once at turn start. But within a single turn, the agent can make 80+ tool calls that accumulate 240K+ tokens of output. No compaction check runs between tool calls — the token counter only updates from API response headers after the model responds.

So the sequence is:

1. Turn starts, pre-sampling check: get_total_token_usage() returns 0 (fresh session, no prior API response) → skip compact
2. Agent makes 83 shell commands reading files, each returning 2-20K tokens
3. Context fills from 0 → 400K within a single turn
4. Model finally tries to respond → API rejects: ContextWindowExceeded
5. Turn fails — compaction never had a chance

There is a TODO in the code acknowledging this (line 5584-5586):

// TODO(ccunningham): Pre-turn compaction runs before context updates and the
// new user message are recorded. Estimate pending incoming items (context
// diffs/full reinjection + user input) and trigger compaction preemptively
// when they would push the thread over the compaction threshold.

The fix would be checking accumulated token count after each tool output (or periodically mid-turn), not just between turns.

[brandomagnani]

Additional finding: compaction also fails to trigger in interactive mode (not just exec), suggesting this is not exec-specific.

Also noting that #16042 confirms a regression in >=0.115 where compaction fires but the model stops afterward with a "Handoff" summary instead of continuing. That reporter confirms 0.114.0 works correctly with no issues in multi-day runs. We will test downgrading to 0.114.0.

Our session traces show token_count events with real values climbing from 17K → 302K → 1.3M with model_context_window=380000 and auto_compact_token_limit derived as 342K (90% of 380K), yet zero compaction events fire. The compaction condition at codex.rs:5895 (token_limit_reached && needs_follow_up) is never satisfied despite both conditions appearing to be independently true at different points in the turn.

[brandomagnani]

Important update: the issue does not reproduce when model_context_window and model_auto_compact_token_limit are NOT set in config.toml. With defaults (256K context window), compaction works correctly and agents run for 10+ minutes with zero failures on the same workload.

The bug only triggers when these variables are explicitly set in config.toml (e.g. model_context_window = 400000, model_auto_compact_token_limit = 300000). Removing both lines and letting Codex use the default 256K window resolves the issue completely.