Collect model input after cadence pacing

[ZenAlexa]

Summary

• collect model-thread input after cadence pacing so events received during the wait reach the upcoming model step
• add one deterministic CPU regression for input freshness

This removes up to one configured model-step interval from the avoidable input-to-model-step latency tracked in #543. _pace() is driven by frames_per_second_for_step on each model-loop iteration. BackpressureMode.BLOCK adds a separate wait when the presentation queue is full.

Terminal message settlement remains unchanged from main; its lifecycle contract stays outside this ordering fix.

Validation

• PYTHONPATH=flashdreams uv run --no-project --with 'pytest>=8' --with 'pytest-manual-marker>=2' --with 'numpy>=1.24,<2.5' --with 'torch>=2.9' python -m pytest flashdreams/test_v2/test_event_buffer.py flashdreams/test_v2/test_session_runner.py -q — 56 passed
• uvx --from ruff==0.12.7 ruff format --check flashdreams/flashdreams/api_v2/loop.py flashdreams/test_v2/test_session_runner.py
• uvx --from ruff==0.12.7 ruff check flashdreams/flashdreams/api_v2/loop.py flashdreams/test_v2/test_session_runner.py
• focused ty check on both changed files

Addresses #543

[copy-pr-bot]

This pull request requires additional validation before any workflows can run on NVIDIA's runners.

Pull request vetters can view their responsibilities here.

Contributors can view more details about this message here.

[Copilot]

Copilot was unable to review this pull request because the user who requested the review has reached their quota limit.

[greptile-apps]

Greptile Summary

The PR refreshes model-loop input after cadence pacing so events received during the wait are available to the upcoming model step.

• Extracts event incorporation from _begin_run() for reuse after pacing.
• Adds a second event-buffer read immediately before model execution.
• Adds deterministic CPU coverage for input received during the cadence wait.

Confidence Score: 3/5

The PR does not appear safe to merge because finished model-loop paths can still discard asynchronously accepted state operations.

ZenAlexa reported both terminal-settlement races fixed, but current HEAD no longer contains the atomic finished-state settlement: it checks completion and exits before message acceptance is closed, allowing accepted operations to be drained without execution.

Files Needing Attention: flashdreams/flashdreams/api_v2/loop.py

Important Files Changed

Filename	Overview
flashdreams/flashdreams/api_v2/loop.py	Refreshes buffered input after pacing, while the previously reported terminal message-settlement races remain present at HEAD.
flashdreams/test_v2/test_session_runner.py	Adds deterministic coverage proving that input appended during cadence waiting reaches the next model step.

_{Reviews (5): Last reviewed commit: "Merge remote-tracking branch 'upstream/m..." | Re-trigger Greptile}

[gtong-nv]

The model loop snapshots EventBuffer before _pace(). Input arriving during that cadence wait reaches the following model step, adding up to one configured step interval.

Thanks @ZenAlexa , this is indeed an issue. With our current design, we need to do two paces for the model loop and UI loop.

[[collect events] -> [run] -> [model pace for BACKPRESSUE]  -> [present] -> [UI/present pace for PRESENTATION MODE]] -> [[collect events]

Your PR should address issue with the model pace order

read events A
    |
    +------ model rate-limit wait ------+
                                        |
                 event B arrives here --+--> not included
                                        |
                              model.step(N, A)

But model pace will only happen when BLOCK mode is used in BACKPRESSUE, and happens when model generation is faster than UI rate (which defaults to 60hz), which is rare.
I would suggest clear the PR to only address this issue.
The other changes listed below, don't seem to be relevant

make finished-loop settlement atomic with both reset generation and asynchronous message acceptance
execute every message accepted before the terminal cutoff as one finite batch, then resume generation when that batch reopens model state

[ZenAlexa]

Yep, I agree on keeping this PR tight 👍

One detail I found while tracing it: _pace() is currently driven by frames_per_second_for_step on every model-loop iteration. BackpressureMode.BLOCK adds a separate wait when the presentation queue fills. The ordering issue therefore exists across both modes, and its visible cost is largest when pacing actually sleeps.

I’ve trimmed #573 down to the ordering change and one focused regression. The terminal message settlement is a real lifecycle issue with its own boundary, so I’ve taken it out of this PR and will keep that work separate.

[ZenAlexa]

Caught up with #548's multi-session lifecycle in 8e174e70.

The model loop now reads once before cadence for lifecycle and finished-state decisions, then folds in one more event-buffer snapshot after cadence before the step. Queued state messages keep their once-per-model-step ordering. The focused CPU suite passes all 61 tests (•̀ᴗ•́)و

[ZenAlexa]

Yep, the race exists on current main. #573 intentionally removed that lifecycle change in f7913e96, and the current two-file diff leaves terminal settlement unchanged, matching the scope request above. invoke_async currently documents queued shutdown drops. This makes it a lifecycle-contract decision, and the cadence ordering diff remains isolated. I split that decision into #578.

[gtong-nv]

event_buffer.read(reader_id) is called twice in this loop.
here and in line 333.
This doesn't seem right.. I will look into this

[ZenAlexa]

The second event_buffer.read(reader_id) is intentional and defines the cadence boundary:

• The first read feeds _begin_run() before the cadence wait. It handles lifecycle events, reset generation, and the pre-wait snapshot.
• The second read runs after the wait and advances the same reader cursor. It collects events appended during the wait and folds them into the pending events through _incorporate_user_events() before step().

EventBuffer.read() advances each reader to the buffer end, so the first snapshot is not duplicated. The regression test_model_loop_collects_input_after_pacing appends a keyboard event from the patched cadence wait and verifies that it reaches the next model step. The focused test_session_runner.py suite passes 61 tests on this head.