[BlueX888]

fix(voice): drop cleared end-of-turn decisions without breaking idle waits

What breaks

AgentSession.clear_user_turn() (push-to-talk cancel / application-driven discard) resets the live transcript and turn state but leaves a scheduled _end_of_turn_task running. When its endpointing delay elapses, _bounce_eou_task reads the now-empty self._audio_transcript at commit time and still calls on_end_of_turn. AgentActivity then runs on_user_turn_completed with an empty message, appends an empty user message to history, and generates an agent reply for the turn the application just discarded. Reproduced deterministically: chat history [None, None, '', 'reply after cancel'], LLM inputs ['hello world', ''], two speech handles.

Review then surfaced two idle-wait regressions in the first fix:

1. wait_for_idle() awaits the pending decision behind asyncio.shield; cancelling it forwarded CancelledError to the waiter, aborting the idle wait and losing deferred tool replies (_ToolExecutor._deliver_reply).
2. Treating every cancellation as idle was too broad: when _run_eou_detection supersedes decision A with B, an agent-only waiter (wait_for_idle(wait_for_user=False), used by the turn-limit path) returned while B was still pending, so the turn-limit callback could fire early.

Root cause

AudioRecognition._clear_user_turn() cancels the STT/commit path but not the already-scheduled end-of-turn decision, _bounce_eou_task trusts the transcript captured at scheduling time instead of the live transcript at commit time, and AgentActivity._wait_for_eou() cannot distinguish cancellation of the shielded decision from cancellation of the waiter, nor a dropped decision from one superseded by a replacement.

Fix

• Track the trigger (vad, stt, manual) of the pending decision in _end_of_turn_trigger when _run_eou_detection schedules _end_of_turn_task.
• In _clear_user_turn(), cancel and drop the pending task (and its trigger) unless it is a manual decision. Manual commit_user_turn() is an explicit application decision and keeps its current semantics, including cancellation by resumed speech.
• Belt-and-braces in _bounce_eou_task: for non-manual triggers with STT enabled, never commit when the transcript is empty at commit time, mirroring the existing _run_eou_detection entry guard.
• In AgentActivity._wait_for_eou(), swallow CancelledError only when the shielded decision itself was cancelled (waiter cancellation still propagates), then loop: if a replacement decision is pending, await it. A cleared turn drops the reference, so the loop exits and reads idle.

Tests

tests/test_agent_session.py:

• test_clear_user_turn_cancels_pending_end_of_turn — drives VAD start-of-speech, a final STT transcript, and VAD end-of-speech through a live session, then clears while the decision is pending; asserts no on_user_turn_completed input, no empty LLM input, no scheduled reply speech, no history messages, and the pending task cancelled.
• test_clear_user_turn_does_not_cancel_wait_for_idle — starts wait_for_idle() while the decision is pending, clears, and requires the waiter to complete normally while still producing no empty message/reply.

tests/test_wait_for_idle_cancellation.py:

• test_superseded_end_of_turn_task_waits_for_replacement — blocks an agent-only idle waiter on decision A, replaces A with B and cancels A, asserts the waiter is still pending, then completes B and releases it.

On base e57a07b7: all three fail (assert [''] == []; Failed: clear_user_turn surfaced CancelledError through wait_for_idle(); assert not idle_waiter.done()), 3 failed. With the fix: 3 passed; tests/test_agent_session.py 112 passed; tests/test_wait_for_idle_cancellation.py 4 passed; the broad relevant suite 415 passed; ruff clean.

Note: tests/test_eou_wait_span.py has pre-existing real-time flakiness in span-ordering assertions, reproduced with this change stashed; unrelated.

[devin-ai-integration]

Devin Review found 1 new potential issue.

[devin-ai-integration]

🟡 Agent-only idle wait skips replacement decision

When _run_eou_detection supersedes a pending decision, wait_for_idle(wait_for_user=False) can return while its replacement remains active. The agent-only loop exits after the cancelled task if no speech is queued, letting the turn-limit callback run early.

Learn more

An end-of-turn decision is an asynchronous task that can be replaced by a later transcript or VAD event. AudioRecognition._run_eou_detection cancels the old task and installs a new one. An agent-only idle wait awaits the old task, catches its cancellation, then checks only speech; with no queued speech, wait_for_idle exits even though the replacement decision can still produce a response. The turn-limit path uses exactly this agent-only wait in _user_turn_exceeded_task.

Example: A final transcript schedules decision A. A newer final transcript replaces it with decision B while the turn-limit callback waits on A. With no speech queued yet, the waiter returns before B's delay ends and fires the callback prematurely.

Recommended fix: After swallowing the cancellation, recheck the current recognition task and keep the agent-only wait active until any replacement decision completes. Preserve the distinction between cancellation of the decision and cancellation of the waiter.

---

Was this helpful? React with 👍 or 👎 to provide feedback.