fix(gateway): give each queue-mode text follow-up its own turn

[EauDoon]

What does this PR do?

With display.busy_input_mode: queue, every TEXT message sent while the agent is busy is newline-joined into a single pending event and answered as one turn. Message boundaries are destroyed, so the model receives an unlabelled blob and pairs answers to the wrong questions.

The path:

1. run.py::_handle_active_session_busy_message declines plain TEXT in queue mode and returns False:

if (
    event.message_type == MessageType.TEXT
    and busy_text_mode == "queue"
    and effective_mode != "steer"
):
    return False

2. Control falls through to the adapter's debounce, and _flush_text_debounce_now pushes the burst into the single pending slot via merge_pending_message_event(..., merge_text=True), which does:

existing.text = f"{existing.text}\n{event.text}"

That merge has no time bound. It applies to a message arriving 30 seconds later exactly as to one arriving 0.3 seconds later, so an entire conversation's worth of follow-ups collapses into one turn. The drain then pops one event and runs it as a single turn.

This is already recognised in-tree. The comment at the FIFO site in run.py describes the raw merge as destroying message boundaries "so two separate user messages sent while the agent was busy... arrived as one mashed-together turn", and routes through _enqueue_fifo to fix it. That fix reached interrupt mode, steer-fallback and /queue. The queue-mode text path returns False before ever getting there.

The fix: hand the flushed burst to the runner's _queue_or_replace_pending_event — the same FIFO entry point those other paths use — so each follow-up gets its own turn in arrival order.

Merging inside the debounce window (0.35s rolling / 1.0s hard cap) is deliberately preserved. A single thought split across two quick taps should stay one turn; that is what the debounce is for.

The runner is reached through the bound _busy_session_handler it already installs on the adapter, so this needs no wiring changes in run.py and stays a single-file change. Adapters with no runner attached (TUI, standalone, tests) fall back to the previous merge, keeping #28503's no-message-loss guarantee intact.

Related Issue

No exact issue exists, so I did not use Fixes #.

• Bug: busy_input_mode: queue silently drops messages — single-slot overwrite instead of FIFO #28503 (closed) — "busy_input_mode: queue silently drops messages". Its fix introduced the FIFO and enabled merge_text=True on the debounce path to stop the data loss. This PR completes that work for the one path it did not reach: no messages were being lost after Bug: busy_input_mode: queue silently drops messages — single-slot overwrite instead of FIFO #28503, but their boundaries were.
• Rapid identical re-sends are stacked into the pending turn (queued-message merge) #52991 (open) — "Rapid identical re-sends are stacked into the pending turn". Same code path, different symptom. This PR does not fix it, and I want to be explicit about that: identical re-sends inside the debounce window still merge. The two are compatible — a dedup for Rapid identical re-sends are stacked into the pending turn (queued-message merge) #52991 belongs in the debounce buffer merge, which this PR leaves in place.

Type of Change

• 🐛 Bug fix (non-breaking change that fixes an issue)

Changes Made

• gateway/platforms/base.py — _flush_text_debounce_now now routes the flushed burst to the runner's FIFO, falling back to the existing merge when no runner is attached or the enqueue raises.
• tests/gateway/test_debounce_flush_fifo.py — new, 6 tests.

How to Test

Reproduction:

1. Set display.busy_input_mode: queue in config.yaml.
2. Send a message that starts a long turn.
3. While it runs, send three more distinct questions, spaced a couple of seconds apart.
4. Before: one reply that mixes all three, often pairing answers to the wrong questions. After: three turns, each answering its own question in arrival order.

Automated:

pytest tests/gateway/test_debounce_flush_fifo.py -q          # 6 passed
pytest tests/gateway/test_active_session_text_merge.py -q    # 7 passed, unchanged

The two behavioural tests fail on main and pass with the fix:

# with gateway/platforms/base.py reverted
FAILED test_successive_bursts_each_get_their_own_turn
FAILED test_third_burst_appends_in_arrival_order
2 failed, 4 passed

# with the fix
6 passed

The other two tests pin the fallback (no runner attached, and a raising FIFO) and pass either way by design.

Wider regression check across the related gateway suites — test_active_session_text_merge, test_queue_command, test_queue_consumption, test_pending_drain_no_recursion, test_pending_drain_race, test_pending_event_none, test_busy_session_ack, test_discord_pending_text_batch_shutdown, test_internal_event_never_interrupts_busy_session — 39 passed.

Checklist

Code

• I've read the Contributing Guide
• My commit messages follow Conventional Commits
• I searched for existing PRs to make sure this isn't a duplicate
• My PR contains only changes related to this fix
• I've run the relevant suites and all tests pass
• I've added tests for my changes
• I've tested on my platform: Ubuntu 24.04 (Docker, live gateway, Telegram) and Windows 11 (unit tests)

Documentation & Housekeeping

• I've updated relevant documentation — N/A, no user-facing config or API change
• I've updated cli-config.yaml.example if I added/changed config keys — N/A, no new keys
• I've updated CONTRIBUTING.md or AGENTS.md — N/A
• I've considered cross-platform impact — N/A, no file I/O, process or terminal handling; pure in-memory dispatch
• I've updated tool descriptions/schemas — N/A

Notes for the reviewer

Two things worth a look:

The 32-message cap now applies here. Text follow-ups that previously merged now occupy FIFO slots, so _BUSY_QUEUE_MAX_PENDING (32) can be reached where it could not before. Far beyond any realistic conversation, but it drops with a logger.warning and nothing user-visible. Happy to add a user-facing notice if you'd like it in scope.

The fallback is deliberate but worth confirming. The FIFO lives on the runner, so an adapter with no runner has nothing to enqueue into. Falling back to the merge is the only option there that preserves #28503's guarantee. It does mean the existing tests in test_active_session_text_merge.py pass unchanged — they use _make_adapter(), which sets _busy_session_handler = None. That is why the new test file attaches a runner explicitly.

This was found and validated on a live deployment running v0.19.0 (2026.7.20) before being reproduced against main.

Relation to other open PRs

• fix(gateway): FIFO-queue mid-run photo follow-ups in queue mode #59562 fixes the photo follow-up path in the runner fast path. This fixes the text path at the adapter debounce. Different branches, no overlap in the diff.
• fix(gateway): queue Telegram busy follow-ups #60488 centralizes the interrupt-vs-queue decision. Complementary: this changes what happens once a burst is already destined for the queue.

Happy to rebase or fold this in if maintainers would rather land it alongside either.

Fallback hardening

_queue_or_replace_pending_event can decline silently — it returns without queueing and without raising when the source resolves to no adapter, or when _BUSY_QUEUE_MAX_PENDING (32) is reached. Treating the call as success would drop the burst, and the cap was effectively unreachable before this change since the old merge collapsed every follow-up into one slot rather than one entry each.

The flush therefore confirms the queue actually grew, and falls back to the historical merge when it did not. Two cases take the historical path directly:

• A media occupant in the pending slot. _queue_or_replace_pending_event caption-merges into it and does not grow the queue, which the depth check would misread as a decline and merge a second time.
• A source that resolves to a different adapter. That adapter owns a different pending slot, and the drain that delivers this burst runs on ours.

Merging is lossy; dropping is worse. Covered by test_merge_preserved_when_fifo_declines_silently, test_merge_preserved_when_adapter_unresolvable, test_enqueue_failure_falls_back_to_merge and test_merge_preserved_when_no_runner_attached.