Snapshot a round's timing when it opens (B-61)

round_duration_seconds was read live on every scheduler tick and every bet
check, with the deadline computed as opened_at + duration. Lowering it from 600
to 60 while a round was 300s in closed that round instantly; raising it moved
the closes_at clients were already counting down to. round_cooldown_seconds had
the same property for the gap after a close. B-11 fixed this class of problem
for the advertised jackpot; the timing fields were left live.

Round now carries duration_seconds and cooldown_seconds, set from the config
when it opens. round_deadline() is the single place the deadline is computed —
the scheduler, place_bet's two checks and /rounds/current's closes_at all go
through it — and the cooldown is read off the round that just closed, so the gap
a round announced is the gap that's honoured. The config row becomes what the
*next* round opens with.

The migration backfills from the live config rather than leaving the column
defaults: an instance running 300s rounds would otherwise see the round
currently in progress jump to 600s the moment this lands, which is precisely the
retroactive change being fixed. Verified against a scratch DB with a non-default
config.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

tests/unit/test_rounds_service.py

@@ -171,3 +171,50 @@ async def test_closed_rounds_can_coexist_with_an_active_one(session_factory):
 
     async with session_factory() as session:
         assert len((await session.scalars(select(Round))).all()) == 3
+
+
+# --- B-61: a round runs by the timing it opened with, not by the live config ------
+
+
+async def test_a_new_round_snapshots_the_current_config_timing(session_factory):
+    async with session_factory() as session:
+        session.add(RoundConfig(fee_address="", round_duration_seconds=120, round_cooldown_seconds=45))
+        await session.commit()
+
+    async with session_factory() as session:
+        round_ = await open_new_round_if_needed(session)
+        await session.commit()
+
+    assert round_.duration_seconds == 120
+    assert round_.cooldown_seconds == 45
+
+
+async def test_round_accepts_bets_uses_the_rounds_own_duration(session_factory):
+    from app.rounds.service import round_accepts_bets
+
+    opened_at = datetime.now(timezone.utc) - timedelta(seconds=100)
+    still_open = Round(status="open", opened_at=opened_at, duration_seconds=600)
+    expired = Round(status="open", opened_at=opened_at, duration_seconds=60)
+
+    assert round_accepts_bets(still_open) is True
+    assert round_accepts_bets(expired) is False
+
+
+async def test_cooldown_comes_from_the_round_that_closed(session_factory):
+    """The gap a closing round announced is the gap that's honoured: shortening
+    round_cooldown_seconds afterwards must not open the next round early, nor
+    lengthening it hold the lottery shut."""
+    async with session_factory() as session:
+        session.add(RoundConfig(fee_address="", round_cooldown_seconds=0))  # just lowered to 0
+        session.add(
+            Round(
+                status="closed",
+                opened_at=datetime.now(timezone.utc) - timedelta(seconds=200),
+                closed_at=datetime.now(timezone.utc) - timedelta(seconds=10),
+                cooldown_seconds=300,  # what that round ran with
+            )
+        )
+        await session.commit()
+
+    async with session_factory() as session:
+        assert await open_new_round_if_needed(session) is None  # still cooling down