Windows desktop: long-running task disappeared after usage exhaustion, leaving no recoverable checkpoint

What version of the Codex App are you using?

The new combined ChatGPT/Codex Windows desktop application. I do not have the exact package version available in the disappeared task history. I can provide it through a privacy-safe support channel if needed.

What subscription do you have?

ChatGPT Plus.

What platform is your computer?

Windows 11 x64.

What issue are you seeing?

A long-running local coding task disappeared completely from the desktop application's task/history UI immediately around weekly usage exhaustion.

This was not a normal completed, archived, or manually deleted task:

• I was signed into the same account and workspace.
• Other earlier coding tasks remained visible.
• Only this specific active task disappeared.
• It was not present in Recents.
• It was not present in Archived chats/tasks.
• Refreshing and signing out/in did not restore it.
• Support troubleshooting did not recover the task or its execution context.

The local private repository still contained a large amount of uncommitted work from the interrupted run. I had to preserve that state manually as a temporary WIP commit before resetting the workspace.

I then restarted the same implementation from the same clean baseline. The replacement run began with roughly 80% of the weekly allowance available, exhausted the remaining allowance, and stopped much earlier with a substantially smaller partial implementation. Because the original task history and execution context were gone, there was no reliable way to resume deterministically or prove that the restarted implementation would retain every safety property of the original run.

This creates a serious integrity problem for professional coding work: account usage can be consumed, the task can disappear, and the user is left with partial source changes but no durable task record, no checkpoint, no resumable plan, and no trustworthy continuation path.

Approximate impact observed

I am intentionally providing only sanitized aggregate information because the repository is private.

• Original interrupted run: partial changes spread across several dozen files, including implementation and regression tests.
• Restarted run before the next usage exhaustion: only a few logical files had been modified.
• The second run consumed most of the available weekly allowance despite reaching a much earlier visible implementation stage.
• Recovering safely required manual Git preservation and a semantic comparison between two incomplete implementations.

This is not primarily a complaint about a task being expensive. The critical bug is that an interrupted paid task became undiscoverable and non-resumable while private workspace changes remained on disk.

Steps that led to the problem

1. Open a private local Git repository in the Windows desktop app.
2. Start a large multi-stage coding task with a high-reasoning model.
3. Allow the task to run until the account's weekly Codex usage is exhausted.
4. Return to the task/history UI.
5. Observe that the active task is missing from Recents and Archived, although its uncommitted workspace changes still exist locally.
6. Attempt refresh and account sign-out/sign-in.
7. Observe that there is no durable task record or supported resume path.

I understand that exact reproduction may depend on the merged ChatGPT/Codex task-list synchronization and account-limit transition.

What is the expected behavior?

Usage exhaustion must pause a task safely, not make it disappear.

At minimum, the desktop app should provide all of the following:

1. Durable task persistence

The task, prompt, progress, plan, tool history, and interruption reason must remain visible after usage exhaustion, app restart, sign-out/in, or temporary task-list synchronization failures.

1. Deterministic resume

After the usage window resets or credits become available, the same task should resume from its last confirmed checkpoint rather than requiring a new run from scratch.

1. Automatic source checkpoint before interruption

Before a task is stopped by an account limit, Codex should create a clearly identified local patch, stash, temporary branch, or user-approved WIP commit. It must never silently leave the only copy of a large implementation as unidentified working-tree changes.

1. Visible interruption state

The UI should show something such as Paused — usage limit reached, together with the task ID, workspace, last successful step, last checkpoint, and resume eligibility.

1. Recovery independent of the sidebar

A local task should remain recoverable by durable task ID even if the merged remote task/history endpoint is unavailable or the sidebar state becomes inconsistent.

1. Clear separation of local and remote state

A remote account/task-list failure must not hide a healthy local task or make it appear deleted.

Data protection / privacy concerns

Recovery and bug reporting currently create pressure to expose far more private information than should be necessary. Raw diagnostics, rollout files, screenshots, and repository diffs may contain:

• proprietary source code;
• private prompts and tool outputs;
• local filesystem paths and Windows account names;
• repository names and remote URLs;
• email/account identifiers;
• branch names, commit metadata, and other correlatable identifiers.

A user should not have to publish or email raw private-repository data merely to prove that a paid task disappeared.

Please provide a privacy-preserving recovery and reporting flow with:

• a one-click sanitized diagnostic export;
• explicit preview of every field before submission;
• source code, prompts, local paths, repository URLs, email addresses, and account identifiers excluded by default;
• selective opt-in for each sensitive category;
• a documented retention period and deletion path;
• an official private channel for task IDs or account correlation data;
• a clear explanation of which task/session data is local, synchronized, retained, or deleted.

I am not attaching raw logs, source code, repository identifiers, screenshots, task IDs, commit hashes, or account information to this public issue. I can provide narrowly scoped sanitized metadata through an official private support route.

Additional information

The requested guarantee is straightforward: a paid coding task may be paused by a limit, but it must never become silently undiscoverable, uncheckpointed, and non-resumable while leaving an ambiguous partial implementation in a private workspace.