[Desktop Windows 26.825] Cross-thread delegation card fails to inject prompt body into destination LLM context

Summary

In Codex Desktop for Windows 26.825.6671.0, cross-thread task delegation (send_message_to_thread / codex_delegation) renders a task card in the UI ("Sent by ChatGPT from another task" / "由 ChatGPT 从另一项任务发送" with a collapsible "Show more ∨" / "显示更多 ∨"), but fails to inject the actual prompt text into the destination model's input context window (UserMessage).

As a result:

1. The target thread's LLM never receives the new task prompt in its actual model context.
2. The destination agent either blindly repeats its previous turn's output/completion text (with 0 new reasoning tokens), or idles.
3. When the user manually inquires in the thread what task it received, the agent explicitly confesses that its conversation context contains none of the delegated task text.

Reproduction Steps

1. In Thread A (Coordinator), invoke tools.mcp__codex_app__send_message_to_thread targeting an existing Thread B with a multi-line task description.
2. Thread B's window in Codex Desktop renders the delegation header card: "Sent by ChatGPT from another task" with a collapsed task snippet and "Show more ∨".
3. Thread B immediately responds without executing the new task, regurgitating its previous turn completion (e.g. COMPLETED_FOR_ACCEPTANCE or repeating previously completed commit info).
4. In Thread B's chat input, manually type and send: "Can you recite the full task you received from the other thread?"
5. Thread B responds that its textual conversation context does not contain the delegated task prompt at all, and that it can only guess from the truncated snippet visible if provided a screenshot.

Observed Behavior

• The UI renders the delegation card correctly.
• In the session JSONL (rollout-*.jsonl), the cross-thread dispatch is delivered as a custom event or tool output, but is never translated into a valid UserMessage turn containing the prompt text in the destination LLM context.
• The model in Thread B has essentially 0 reasoning tokens for the turn, hallucinates or recycles its previous state, and halts.
• Only when the user manually enters text into Thread B's input field is a proper role: user message dispatched, waking up the model properly.

Expected Behavior

When send_message_to_thread delivers a message to a destination thread:

• The entire prompt body must be injected into the destination turn's context as a first-class user instruction (UserMessage).
• The model must receive the full text (not truncated by UI folds) and initiate a new reasoning/planning turn to execute the requested instructions.

Environment

• Client: Codex Desktop App for Windows (Microsoft Store package OpenAI.Codex_26.825.6671.0_x64__2p2nqsd0c76g0)
• App Version: 26.825.6671.0
• OS: Windows 11 Pro 64-bit
• Tool involved: tools.mcp__codex_app__send_message_to_thread / codex_delegation

Impact

This breaks autonomous coordinator-worker / multi-agent orchestration. A controller thread believes the task was successfully handed off, while the worker thread never received the instructions and falsely reports completion based on stale context.

Start by tracing tools.mcp__codex_app__send_message_to_thread and codex_delegation through the destination thread's session JSONL handling, especially where custom events or tool output become model context. Reproduce the delegation and verify that the complete prompt appears as a role: user UserMessage and triggers a new reasoning turn rather than reusing prior output.