Codex 0.154.0 / Plus / GPT-5.6 Sol High exhausted two consecutive 5-hour windows on the same implementation task

What version of Codex CLI is running?

Codex CLI 0.154.0.

What subscription do you have?

ChatGPT Plus.

Which model were you using?

GPT-5.6 Sol, reasoning high, summaries auto.

Platform / environment

GitHub Codespaces / Linux workspace using Codex CLI in a private repository.

The task was a bounded repository implementation and provider-free local validation task. It involved a PostgreSQL migration, Python executor/tests, a source guard, and two controlled evidence records. No production/provider deployment was authorized or performed.

What issue are you seeing?

Codex exhausted the entire 5-hour usage allowance twice while attempting to execute the same bounded implementation task, and the task is still incomplete.

This is not a complaint that a single difficult prompt used a noticeable amount of quota. The practical problem is that the same implementation prompt has now consumed two complete 5-hour windows, interrupting the task twice before completion.

The task is security-sensitive and deliberately uses GPT-5.6 Sol High, but the observed quota consumption appears disproportionate to the useful repository work completed.

First 5-hour exhaustion

Codex status immediately after the first interruption:

Codex v0.154.0
Model: gpt-5.6-sol (reasoning high, summaries auto)
Plan: ChatGPT Plus
5h limit: 0% left (reset 10:34)
Weekly limit: 53% left
Context window: 73% left (77.6K used / 258K)

Session ID:

01a09e69-0183-7ec2-9f1c-37e4efe8757d

The task was resumed rather than restarted conceptually.

Second 5-hour exhaustion on the same implementation task

Codex later exhausted the 5-hour limit again:

Codex v0.154.0
Model: gpt-5.6-sol (reasoning high, summaries auto)
Plan: ChatGPT Plus
5h limit: 0% left (reset 16:01)
Weekly limit: 37% left
Context window: 24% left (200K used / 258K)

Session ID:

01a09f94-574a-77e2-bfe2-6b8ab6989a30

Token telemetry displayed by Codex for this second session:

Token usage:
  total=240,196
  input=197,230
  cached input=10,705,408
  output=42,966
  reasoning=16,923

The extremely large 10.7M cached-input figure is particularly notable relative to the visible uncached/output token counts and the amount of useful work completed.

Across the two attempts, the displayed weekly allowance moved from 53% remaining to 37% remaining while the same implementation remained incomplete. I am not claiming that every percentage point can be attributed perfectly from client-side telemetry; OpenAI needs to reconcile this against the authoritative server-side ledger.

Useful work actually completed

After two exhausted 5-hour windows, the repository is still in an uncommitted implementation state.

The final git status at the second interruption showed only:

modified:
  apps/web/prisma/migrations/0023_risk_issue_lifecycle_authority/migration.sql
  scripts/database/test_tq_0023_source_guard.py

untracked:
  docs/11-database-migrations/0212-risk-issue-lifecycle-authority-deterministic-executable-resolution-source-review.md
  scripts/database/test_tq_current_dev_0023_provider_apply.py
  scripts/database/tq_current_dev_0023_provider_apply.py
  scripts/database/__pycache__/

no changes added to commit

The task had not reached its required final integration/assurance completion. No commit, push, PR, deployment, provider SQL, or production operation was performed.

This makes the user-visible productivity impact concrete: two complete 5-hour windows were consumed without completing one bounded implementation/validation cycle.

Why this looks like more than ordinary high-reasoning cost

The workload is complex, but several details suggest the consumption rate deserves investigation:

1. The same bounded task consumed two complete 5-hour windows before completion.
2. The second session reports only ~197K ordinary input tokens and ~43K output tokens, but 10.7M cached input tokens.
3. The context window had reached ~200K/258K in the second session, so repeated large-context processing/tool loops may be materially affecting quota depletion.
4. The weekly allowance also fell materially during these attempts.
5. This is occurring on Codex CLI 0.154.0, where other recent users have reported severe 5-hour/quota depletion.

Related recent reports include:

• #45073 — Severe 5-hour usage drain in Codex: ~86% consumed in ~26 minutes with only 2 prompts
• #44455 — Excessive usage consumption, poor task efficiency, and ineffective previous feedback
• #42357 — Usage limits deplete unusually fast with mostly cached input

This report adds a case where a single governed implementation task exhausted two successive 5-hour windows, with explicit session IDs and local token/cached-context telemetry.

Steps to reproduce / observed sequence

This is an observed production workflow rather than a deterministic minimal reproducer:

1. Use ChatGPT Plus with Codex CLI 0.154.0.
2. Select GPT-5.6 Sol with reasoning effort High.
3. Run a substantial but bounded repository implementation task with repeated local inspection, edits, tests, and validation.
4. Maintain the same task context rather than discarding prior work.
5. Observe the 5-hour allowance reaching 0% before the task completes.
6. Resume the same implementation after the usage reset.
7. Observe the second 5-hour allowance also reaching 0% before the same task completes.
8. Inspect /status and token telemetry; in this case the second session reported ~10.7M cached input tokens.

Expected behavior

A difficult security-sensitive task on Sol High can reasonably consume more quota than a simple edit, but one bounded implementation cycle should not require repeated complete 5-hour resets without transparent accounting of why.

At minimum I expect:

• usage consumption to be reasonably proportional to useful requested work;
• cached-context reprocessing to be clearly reflected in an auditable quota breakdown;
• the client to show how much of the 5-hour/weekly allowance is attributable to cached input, uncached input, output, reasoning, retries, automatic review, compaction, tool-loop continuation, or hidden orchestration;
• long-running tasks not to become practically impossible to finish on Plus solely because the agent repeatedly reprocesses large cached context;
• if the current accounting is intentional, documentation explaining how cached input and long-context agent loops map to the 5-hour limit.

Requested investigation

Please correlate the two session IDs above with the authoritative server-side usage ledger and determine:

1. How much 5-hour and weekly quota each session consumed.
2. How the 10,705,408 cached input tokens in the second session were weighted toward the usage limits.
3. Whether repeated tool/model continuation caused the large context to be reprocessed many times.
4. Whether compaction, retries, automatic review, or other server-side work contributed materially.
5. Whether any quota was double-counted or incorrectly attributed.
6. Whether Codex 0.154.0 changed step frequency/context handling in a way that makes long repository tasks disproportionately expensive.
7. Whether the affected allowance can be restored if backend reconciliation shows abnormal or erroneous consumption.

Additional information

No secrets, source code, credentials, private repository contents, or provider data are included in this public report.

I can provide sanitized logs and additional telemetry privately if OpenAI Engineering needs them.

The issue appears closely related to the recently reported #45073 and other rate-limit/cached-context reports, but this case specifically documents two consecutive complete 5-hour windows consumed by the same unfinished task.

Start by correlating session IDs 01a09e69-0183-7ec2-9f1c-37e4efe8757d and 01a09f94-574a-77e2-bfe2-6b8ab6989a30 with the authoritative usage ledger. Compare the /status telemetry and cached-input figures with related reports #45073, #44455, and #42357. Done means explaining the quota accounting, identifying any abnormal attribution, and determining whether restoration is warranted.