Astra tasks fail to converge: premature stops, repeated compaction and code rework during persistent execution

What version of the Codex App are you using?

Windows desktop package: 26.901.5280.0.
The installed CLI and desktop core both report codex-cli 0.153.4.
These versions were checked on September 6, 2026; the exact build at every earlier occurrence was not recorded.

What subscription do you have?

ChatGPT Pro, using GPT-6 Astra. Current configured reasoning effort is medium; the effort for each affected run has not been independently established.

What platform is your computer?

Microsoft Windows NT 10.0.26200.0, 64-bit. This report concerns Codex Desktop.

What issue are you seeing?

I cannot reliably get a substantial coding task to converge to a completed deliverable:

• During ordinary execution, Astra sometimes stops responding/working while the requested task is still unfinished, requiring another instruction to continue.
• With persistent goal-style execution, it continues running but may consume the available usage allowance without completing the task.
• During these long tasks, context is repeatedly compacted. The agent repeatedly rewrites code and reruns validation while the overall project makes little observable progress.
• More elapsed time, tool activity, code changes, and verification do not reliably translate into completion of the original objective.
• Compared with my experience using Sol, Astra less consistently presents an explicit numbered execution plan (1, 2, 3, etc.) before proceeding. This makes it harder to see what has been completed and whether repeated work is advancing the original plan. This is a user-experience comparison, not a controlled model evaluation.

The persistent-execution command was described as /goat in my original report. This may refer to /goal, but the exact command invocation has not been verified from the affected transcript. The important distinction is ordinary execution versus a mode that keeps automatically continuing.

I generally authorize the requested implementation and validation and expect the agent to carry them through. I am not asking for safeguards to be bypassed; I need reliable continuation, preservation of completed work, and an actionable explanation when progress is blocked.

What steps can reproduce the bug?

Observed workflow, not yet a deterministic minimal reproduction:

1. Start a multi-step coding task in Codex Desktop with GPT-6 Astra and a concrete intended deliverable.
2. In ordinary execution, observe the task ending before the requested outcome is delivered.
3. Use persistent goal-style execution to try to avoid premature stopping.
4. During a long run, observe repeated context compaction, repeated code rewriting, and repeated validation.
5. The original objective remains unfinished despite sustained execution and significant usage consumption; the allowance may be exhausted first.

An exact affected task ID, compaction count, per-run token accounting, before/after code diff, and minimal repository reproduction are not included yet. Exhaustion and repeated work above are user-observed symptoms, not conclusions from a controlled benchmark. No exact frequency or cost multiplier is claimed.

What is the expected behavior?

• Maintain a visible, concise execution plan tied to acceptance criteria and preserve its state across compaction.
• Preserve completed work, prior decisions, and successful verification so they are not repeatedly rediscovered or redone without a concrete reason.
• Continue authorized work until the objective is met or a specific blocker is reached; do not silently treat a partial result as completion.
• Detect repeated cycles with no net progress. Explain what is stuck, retain the latest useful checkpoint, and change approach or present a bounded blocker instead of continuing the same work until the allowance is exhausted.
• Repeat validation when code changes or new evidence justify it, rather than treating repeated checks as progress by themselves.
• Distinguish normal completion, missing user input, safety review, transport failure, compaction failure, and usage exhaustion in the UI.

Additional information

Visible planning and safety interruptions: observations versus possible explanations

My proposed explanation is that Astra's more autonomous workflow may make it less likely to show an explicit numbered plan than Sol. Please clarify whether this is intended model behavior, missing plan-tool/UI integration, or a regression. I have not found an official statement establishing that numbered plans were intentionally removed. I would like a supported way to retain a visible execution checklist while allowing authorized work to continue, without forcing a separate plan-approval step.

OpenAI's September 1, 2026 announcement, Path to Astra: critical capabilities and frontier safeguards, states that Astra meets the Critical cybersecurity capability threshold and describes strengthened protections. It explicitly acknowledges that legitimate work, including long-running tasks and work not obviously related to cybersecurity, can be inadvertently slowed, paused, or stopped. It says ChatGPT/Codex users may be asked to review an action before continuing.

The misalignment monitoring documentation describes asynchronous review of reasoning and actions. A flag is a reason for review, not proof of user misconduct or an unauthorized action. It documents misalignment_policy_violation for blocked API requests and says there is no general API mechanism to resume a stopped conversation. API stopping behavior depends on the request's conversation-context mechanisms; it should not be generalized to every API call.

This makes safety-monitor false positives a plausible explanation for some interruptions, but not an established cause for my premature stops or compaction loops. I perceive interruptions as frequent; I do not have measurements establishing that they are the most common Astra complaint or quantifying launch-period frequency. Related user report #43041 describes a suspected false pause after later implementation authorization, and #42523 describes a Windows task that could not resume after a safety block.

Please make the cause of each pause distinguishable and provide a supported review/recovery path. More explicit progress reporting would also help users tell a deliberate safety pause from transport failure, compaction, or ordinary early termination.

Current configuration and diagnostic boundaries

The current installation has experimental context management configured as:

[features.context_management]
experimental_mode = true

This was enabled recently. A separate short smoke task confirmed that the setting was recognized and the runtime included ContextManagement, but did not test cross-window retention. The setting's state during every affected long run is unknown; this report does not establish that the experiment caused or fixed the symptoms.

A separate, bounded local log inspection found transport errors including stream disconnected before completion, tls handshake eof, and retries reaching 5/5. Those records have not been correlated with the specific long runs described here. They are a possible confounder, not proof of the cause. No evidence has established that all these interruptions are caused by misalignment monitoring.

Related reports, with overlap but not an established shared cause:

• #42937: premature stopping and unreliable autonomous completion.
• #43062: automatic compaction stalls and restarts on the same Windows desktop build.
• #43045: Astra WebSocket reconnect loops on core version 0.153.4.

This report focuses on the combined user-visible failure to converge: premature stopping without persistent continuation, versus ongoing compaction/rewrite/verification cycles with persistent continuation. It may help triage whether these symptoms share a task-state or progress-preservation problem, or should be tracked separately. Private source code, credentials, and full conversation logs are intentionally omitted.

The report names no source file, test, deterministic reproduction, or task ID. Start by collecting affected transcripts and the local transport logs, then compare behavior with related issues #42937, #43062, and #43045. Done means separating premature stops, compaction/rewrite loops, and transport or safety pauses with a reproducible case and a clear expected recovery path.