Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In `@src/util/order_utils/relay_order_db_reconcile.rs`:
- Around line 210-213: The test currently only ensures
reconcile_terminal_order_statuses_from_relay(&pool,
&relay_latest).await.unwrap() doesn't panic; add a postcondition that queries
the DB via the same test pool to assert no rows were inserted or updated (e.g.,
fetch count or fetch orders by relay id and assert it equals 0 or equals the
original pre-reconcile state). Use the existing pool handle and relay_latest
identifiers in your assertion (call the repository/select helper used elsewhere
in tests or run a SELECT COUNT(*) on the orders table for relay_latest entries)
immediately after the reconcile call to verify no changes occurred.
- Around line 51-53: The current use of Order::get_by_id(pool,
&order_id.to_string()).await silently ignores all errors; change it to match the
Result so you only treat RowNotFound as the benign case and surface or log any
other DB errors. Specifically, replace the let Ok(...) else { return } pattern
by matching the result of Order::get_by_id, keep the early return for
RowNotFound, but for other Err(e) either return an Err/propagate the error or
call the reconciler logger (include e) so non-RowNotFound failures are not
swallowed; refer to Order::get_by_id, pool, order_id and the RowNotFound variant
when implementing this handling.
- Around line 78-82: The in-memory SQLite tests use async fn test_pool() which
currently calls SqlitePool::connect("sqlite::memory:") causing multiple pooled
connections to see different databases; change test_pool to create the pool with
SqlitePoolOptions::new().max_connections(1).connect("sqlite::memory:").await
(preserving the expect message) so the pool is limited to a single connection
and the tests (which call test_pool) will see the same in-memory DB.

---

Outside diff comments:
In `@src/ui/key_handler/async_tasks.rs`:
- Around line 215-229: Ensure the relay→DB reconciliation completes before
rehydrating active-order DM state: call and await
run_relay_order_db_reconcile_once(...) and only after it finishes invoke
hydrate_startup_active_order_dm_state(pool).apply the same sequencing change to
apply_pending_fetch_scheduler_reload and reload_runtime_session_after_reconnect
so they await run_relay_order_db_reconcile_once(...) before calling any hydrate
or reload logic; reference spawn_fetch_scheduler_loops,
hydrate_startup_active_order_dm_state, run_relay_order_db_reconcile_once,
apply_pending_fetch_scheduler_reload, and reload_runtime_session_after_reconnect
to locate the spots to reorder.

In `@src/util/order_utils/helper.rs`:
- Around line 320-329: The current update in latest_by_id only replaces on
new_ts > old_ts, which leaves earlier-seen non-terminal events when two events
share created_at second; change the logic inside the and_modify closure for
latest_by_id (the order_id / existing / order handling) to also prefer terminal
events when timestamps are equal: replace the condition with one that updates
when new_ts > old_ts OR (new_ts == old_ts AND is_terminal(&order) &&
!is_terminal(existing)); add or reuse a small is_terminal(Order) helper if
needed to detect terminal states (expired/canceled) so terminal events win ties
even within the same second.

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Nitpick comments:
In `@src/util/order_utils/relay_order_db_reconcile.rs`:
- Around line 23-31: The function reconcile_terminal_order_statuses_from_relay
currently returns Result<()> but never fails because
reconcile_one_order_if_terminal returns () and logs errors internally; change
reconcile_terminal_order_statuses_from_relay to be infallible by updating its
signature to return () (remove Result), delete the final Ok(()) and keep the
for-loop calling reconcile_one_order_if_terminal, and then update any callers
that currently use ? to stop propagating a Result (or handle accordingly). If
you prefer surfacing failures instead, alternatively make
reconcile_one_order_if_terminal return Result<()> and have
reconcile_terminal_order_statuses_from_relay collect/propagate errors (e.g.,
aggregate failure count) so the Result return becomes meaningful.