Desktop task follow-ups can interrupt active work without clear queue/interrupt semantics
Summary
When a follow-up is sent to an already-running Codex desktop task from another Codex task, the target task can pivot to the new instruction before it has completed or reported the current unit of work. The conversation history is retained, but the active execution is effectively interrupted or reprioritized without a clear user-facing warning.
This makes long, sequential implementation work unreliable: an operator may think they are adding a note for the next step, while the agent abandons an in-progress verification or partial implementation.
Reproduction
- In the Codex desktop app, create a project task and ask it to perform a multi-step implementation that includes edits and verification.
- Wait until the task is actively running commands or making edits.
- From another Codex task, send a follow-up to the active task using thread/task coordination.
- Observe that the target task receives a new injected user message (shown as coming from another Codex task) and begins responding to or implementing the new request before the current work has reached a clear checkpoint.
Actual behavior
- The follow-up appears in the target conversation immediately.
- The active task's priority changes mid-flight.
- There is no clear indication that the message will interrupt rather than queue behind the active unit of work.
- This can leave a task partially verified, with the operator needing to reconstruct what was completed.
Expected behavior
One of these should be explicit and controllable:
- Queue cross-task follow-ups until the active task reaches a tool/action checkpoint or completes its current turn.
- Require an explicit "interrupt current work" choice before injecting the follow-up.
- Clearly show in both source and target that the new message will interrupt/reprioritize the active task.
Why this matters
Codex desktop encourages multi-task project workflows. Without deterministic queue/interrupt behavior, coordinating related tasks can accidentally fragment implementation and verification work.
Environment
- Codex desktop app on Windows
- Local project task, with another Codex task forwarding follow-up instructions
2 Comments
Potential duplicates detected. Please review them and close your issue if it is a duplicate.
Powered by Codex Action
Additional confirmed incident: https://github.com/openai/codex/issues/38687#issuecomment-5395336523
In this case the cross-task follow-ups were not intentionally sent by the user or a root task. A non-root
luna_workerusedsend_message_to_threadfive times after its parent-target attempt failed. The old target woke automatically; latercodex_delegationmessages arrived while its turn was still running and interleaved with unfinished work.This raises the severity of queue/interrupt semantics: an unauthorized child can trigger the interrupt path. Cross-task input should queue by default, and active-turn steering should require explicit root/user authorization.