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

tests/unit/test_scheduler.py

@@ -46,7 +46,8 @@ async def test_tick_closes_round_with_no_participants_once_due(session_factory,
     past = datetime.now(timezone.utc) - timedelta(seconds=10)
     async with session_factory() as session:
         session.add(RoundConfig(fee_address="", round_duration_seconds=1))
-        session.add(Round(status="open", opened_at=past))
+        # B-61: the deadline comes from the round's own snapshot, not from the config.
+        session.add(Round(status="open", opened_at=past, duration_seconds=1))
         await session.commit()
 
     scheduler = RoundScheduler(session_factory, FakeListener())
@@ -528,3 +529,26 @@ async def test_close_and_draw_waits_when_a_bet_appears_after_the_tick_check(sess
         events = [e.event_type for e in (await session.scalars(select(AuditLog))).all()]
         assert "round_closed" not in events
         assert "winner_drawn" not in events
+
+
+async def test_tick_ignores_a_config_duration_edited_mid_round(session_factory):  # B-61
+    """Lowering round_duration_seconds from 600 to 30 while a round is 300s in used
+    to close that round on the spot, because the deadline was recomputed live from
+    the config on every tick. The edit applies to the *next* round."""
+    async with session_factory() as session:
+        session.add(RoundConfig(fee_address="", round_duration_seconds=30))  # just lowered
+        session.add(
+            Round(
+                status="open",
+                opened_at=datetime.now(timezone.utc) - timedelta(seconds=300),
+                duration_seconds=600,  # what this round opened with
+            )
+        )
+        await session.commit()
+
+    scheduler = RoundScheduler(session_factory, FakeListener())
+    await scheduler._tick()
+
+    async with session_factory() as session:
+        round_ = (await session.scalars(select(Round))).one()
+        assert round_.status == "open"  # still 300s to go, by its own clock