fix(tui_gateway): preserve websocket batch order

[helix4u]

What does this PR do?

Serializes WebSocket writes per WSTransport across whole coalesced batches so streamed Desktop/dashboard frames cannot arrive out of order when the event loop recovers from a long stall.

The token buffer's threading.Lock currently preserves buffer-drain and task-creation order, but it does not serialize the asynchronous socket writes. Multiple _safe_send_many() tasks can therefore be in flight together, and each task yields at await send_text(). A later batch can enter the socket between two frames from an earlier batch. A deterministic reproduction produced A1, B1, B2, A2 from logically ordered batches [A1, A2] and [B1, B2].

This PR carries forward the per-socket serialization work from #48446 with the original contributor's authorship preserved, then adapts it to the token-batching implementation that landed afterward. It does not reopen the WebSocket-disconnect diagnosis resolved by #55545; this fixes the separate frame-ordering invariant.

Related Issue

Related to #48446 and #55545.

Type of Change

• 🐛 Bug fix (non-breaking change that fixes an issue)
• ✨ New feature (non-breaking change that adds functionality)
• 🔒 Security fix
• 📝 Documentation update
• ✅ Tests (adding or improving test coverage)
• ♻️ Refactor (no behavior change)
• 🎯 New skill (bundled or hub)

Changes Made

• tui_gateway/ws.py: add a per-transport async writer lock and hold it for each complete _safe_send_many() batch.
• tui_gateway/ws.py: route single-frame sends through the same serialized writer path.
• tui_gateway/ws.py: send tokens drained by write_async() and its current control/RPC frame in one lock acquisition so another batch cannot overtake the current frame.
• tests/test_tui_gateway_ws.py: retain the original concurrent-send regression and add deterministic cross-batch and write_async() ordering coverage.

How to Test

1. Run tests/test_tui_gateway_ws.py through the project test runner.
2. Confirm test_ws_transport_preserves_cross_batch_order blocks batch B until every frame in batch A has been sent.
3. Confirm test_ws_write_async_keeps_drained_tokens_with_current_frame keeps the current frame immediately behind the pending tokens it drains.

Focused local validation on Windows 11:

• python -m py_compile tui_gateway/ws.py tests/test_tui_gateway_ws.py passed.
• Direct isolated execution of the three serialization regressions passed.
• git diff --check passed.
• Full pytest coverage is left to GitHub CI.

Checklist

Code

• I've read the Contributing Guide
• My commit messages follow Conventional Commits (fix(scope):, feat(scope):, etc.)
• I searched for existing PRs to make sure this isn't a duplicate
• My PR contains only changes related to this fix/feature (no unrelated commits)
• I've run pytest tests/ -q and all tests pass
• I've added tests for my changes (required for bug fixes, strongly encouraged for features)
• I've tested on my platform: Windows 11

Documentation & Housekeeping

• I've updated relevant documentation (README, docs/, docstrings) — N/A, no user-facing contract changed
• I've updated cli-config.yaml.example if I added/changed config keys — N/A, no config changed
• I've updated CONTRIBUTING.md or AGENTS.md if I changed architecture or workflows — N/A, no workflow changed
• I've considered cross-platform impact (Windows, macOS) per the compatibility guide — the fix uses platform-neutral asyncio.Lock
• I've updated tool descriptions/schemas if I changed tool behavior — N/A, no model tool changed

Screenshots / Logs

Before the fix, the deterministic batch reproduction entered the socket as A1, B1, B2, A2. With the serialized batch boundary, it enters as A1, A2, B1, B2.

[OutThisLife]

Approve. Confirmed the ordering bug on current main: multiple _safe_send_many batches are scheduled as independent tasks with nothing serializing them across the await send_text() yield, so a loop stall interleaves them (A1,B1,B2,A2). The per-transport asyncio.Lock held across the whole batch — plus folding pending tokens + the control frame into one locked batch in write_async — closes both slip-in paths, and the ordering-invariant tests cover them. supplefrog's original #48446 work is preserved. Pushed one tiny follow-up removing the now-dead _safe_send wrapper. Enabling auto-merge.