Summary

• Problem: Codex app-server turns can emit a completed raw assistant rawResponseItem/completed with final text but never send turn/completed, leaving OpenClaw waiting for the terminal idle timeout.
• Why it matters: channel delivery stays blocked even though the model output is already available, matching the stalled Discord/Telegram delivery shape in Agent sessions using Codex app-server backend timeout - model completes but response never delivered to channels #82343.
• What changed: pre-tool raw assistant message completions now arm the existing completed-assistant idle release path, so OpenClaw best-effort interrupts the native Codex turn and releases the session lane with the captured assistant text.
• What did NOT change (scope boundary): raw tool-output watchdog behavior, active request/item guards, abort-marker handling, channel delivery, and SecretRef delivery resolution are unchanged.

Change Type

• Bug fix
• Docs

Scope

• Gateway / orchestration
• Integrations

Linked Issue/PR

• Fixes Agent sessions using Codex app-server backend timeout - model completes but response never delivered to channels #82343
• This PR fixes a bug or regression

Real behavior proof

• Behavior or issue addressed: a pre-tool completed raw assistant response item without turn/completed releases the Codex app-server run, while post-tool raw assistant progress does not release the turn early.
• Real environment tested: local Windows OpenClaw source checkout, local codex CLI logged in with ChatGPT, real Codex app-server using gpt-5.5, and the real runCodexAppServerAttempt path. Workspace and CODEX_HOME are redacted below.
• Exact steps or command run after this patch: node --import tsx C:\tmp\openclaw-real-run-attempt-proof.mjs
• Evidence after fix: the probe used a redacting local proxy around real app-server notifications. It dropped agentMessage notifications to isolate the raw fallback, dropped turn/completed only for the final-raw scenario, and delayed turn/completed by 1000ms after post-tool raw assistant progress.

{
  "ok": true,
  "model": "gpt-5.5",
  "workspace": "<redacted-temp-workspace>",
  "codexHome": "<redacted-codex-home>",
  "finalRawWithoutTurnCompleted": {
    "passed": true,
    "proof": {
      "sawRawAssistant": true,
      "droppedTurnCompleted": 1,
      "interruptRequests": 1
    },
    "result": {
      "aborted": false,
      "timedOut": false,
      "promptError": null,
      "assistantTexts": ["REAL_OPENCLAW_RAW_FINAL_PROOF"]
    }
  },
  "postToolRawAssistantProgress": {
    "passed": true,
    "proof": {
      "sawToolRequest": true,
      "sawPostToolRawAssistant": true,
      "delayedAfterPostToolRawAssistantMs": 1000,
      "interruptRequests": 0
    },
    "result": {
      "aborted": false,
      "timedOut": false,
      "promptError": null,
      "assistantTexts": ["REAL_OPENCLAW_TOOL_DONE_PROOF"]
    }
  }
}

• Observed result after fix: the final raw assistant path releases with captured assistant text after the terminal event is withheld, and the post-tool raw assistant path waits for turn/completed without issuing turn/interrupt.
• What was not tested: live Discord/Telegram credentials or real channel delivery; this proof exercises the local Codex app-server/OpenClaw run-attempt boundary only.

Root Cause

• Root cause: event-projector already captured assistant text from raw assistant rawResponseItem/completed notifications, but run-attempt only released completion on turn/completed, abort markers, or completed agentMessage items.
• Missing detection / guardrail: the completed-assistant idle release did not recognize pre-tool raw assistant message completions as equivalent final assistant output, while post-tool raw assistant progress still needed to stay behind the dynamic-tool handoff guard.
• Contributing context: adjacent watchdog fixes covered raw tool-output silence and completed agentMessage silence, but left the raw assistant final-output path waiting for the terminal watchdog.

Regression Test Plan

• Coverage level that should have caught this:
  • Seam / integration test
• Target test or file: extensions/codex/src/app-server/run-attempt.test.ts
• Scenario the test should lock in: a pre-tool raw assistant rawResponseItem/completed with final text and no turn/completed releases the run with the captured assistant text; post-tool raw assistant progress does not release before turn/completed.
• Why this is the smallest reliable guardrail: the bug is in the app-server attempt completion/watchdog boundary, not in channel delivery or the event projector.
• Existing test that already covers this: extensions/codex/src/app-server/event-projector.test.ts already proves raw assistant text extraction; this PR adds the missing run-attempt release coverage.

User-visible / Behavior Changes

Codex app-server turns that have already produced pre-tool final raw assistant text can deliver instead of waiting for the terminal idle timeout when turn/completed never arrives.

Diagram

Before:
raw assistant completed -> text captured -> wait for turn/completed -> terminal idle timeout

After:
pre-tool raw assistant completed -> text captured -> completed-assistant release -> channel delivery can proceed
post-tool raw assistant progress -> wait for turn/completed -> channel delivery can proceed

Security Impact

• New permissions/capabilities? No
• Secrets/tokens handling changed? No
• New/changed network calls? No
• Command/tool execution surface changed? No
• Data access scope changed? No

Repro + Verification

Environment

• OS: Windows local development checkout
• Runtime/container: local Node with tsx
• Model/provider: real local Codex app-server, gpt-5.5
• Integration/channel: real Codex app-server embedded-run path through runCodexAppServerAttempt
• Relevant config (redacted): workspace path and CODEX_HOME

Steps

1. Start a real local Codex app-server through the OpenClaw app-server attempt path.
2. In the final-raw scenario, observe current-turn rawResponseItem/completed for assistant output and drop turn/completed in the local redacting proxy.
3. In the post-tool scenario, force a real message tool call, observe post-tool raw assistant text, and delay turn/completed for 1000ms.

Expected

• OpenClaw releases the pre-tool final raw assistant attempt with captured assistant text and does not mark the turn timed out.
• OpenClaw does not release post-tool raw assistant progress through the raw assistant fallback; it waits for turn/completed.

Actual

• Before this patch, OpenClaw waited for turn/completed until the terminal idle timeout in the final-raw scenario.
• ClawSweeper also found that the first patch could let post-tool raw assistant progress trigger the completed-assistant release. This revision blocks that path while dynamic tool calls have occurred in the turn.

Evidence

• Failing test/log before + passing after
• Real local app-server behavior proof after the fix

Human Verification

• Verified scenarios:
  • pre-tool raw assistant completion without turn/completed releases with assistant text
  • raw assistant progress after a dynamic tool response still waits for turn/completed
  • real local Codex app-server path preserves both behaviors through runCodexAppServerAttempt
  • raw tool-output watchdog behavior remains covered
  • active current-turn item guard still blocks release
  • interrupted turn marker behavior remains covered
• Edge cases checked:
  • event projector still extracts raw assistant response items
  • formatting, lint, and whitespace checks pass
• What you did not verify:
  • live channel delivery with real Discord/Telegram credentials

Review Conversations

• ClawSweeper's P2 blocker is addressed in code, tests, and this PR body.
• I left the bot review unresolved pending ClawSweeper re-review.

Compatibility / Migration

• Backward compatible? Yes
• Config/env changes? No
• Migration needed? No

Risks and Mitigations

• Risk: treating an interim raw assistant status message as final too early.
  • Mitigation: only arm the raw assistant completion release before any OpenClaw dynamic-tool handoff in the turn, reuse the completed-assistant idle release instead of immediate completion, and keep active app-server request/current-turn item guards in place. New coverage confirms raw assistant progress after a dynamic tool response still waits for turn/completed.