feat(pacing): shorten the tester run (end_affinity 35, recall_cooldown 1, bad_min_turn 3)

memory.py

@@ -3,8 +3,8 @@ import re
 from schemas import TurnUpdate
 
 PACING = {
-    "tester": {"recall_min_memories": 1, "recall_cooldown": 2,
-               "end_affinity": 50, "end_claimed": 2, "bad_min_turn": 4},
+    "tester": {"recall_min_memories": 1, "recall_cooldown": 1,
+               "end_affinity": 35, "end_claimed": 2, "bad_min_turn": 3},
     "full":   {"recall_min_memories": 2, "recall_cooldown": 3,
                "end_affinity": 68, "end_claimed": 3, "bad_min_turn": 6},
 }

tests/test_memory.py

@@ -197,15 +197,15 @@ class TestShouldRecall:
         assert fired is True
         assert mem == "memory B"
 
-    def test_no_recall_within_2_turns_of_last(self):
-        state = self._state(affinity=60, turn=6, last_recall_turn=5)
+    def test_no_recall_on_the_same_turn_as_last(self):
+        state = self._state(affinity=60, turn=5, last_recall_turn=5)
         fired, mem = should_recall(state)
-        assert fired is False  # 6 - 5 = 1 < 2
+        assert fired is False  # 5 - 5 = 0 < 1 (tester cooldown)
 
-    def test_recall_exactly_at_2_turns_after_last(self):
-        state = self._state(affinity=60, turn=7, last_recall_turn=5)
+    def test_recall_one_turn_after_last(self):
+        state = self._state(affinity=60, turn=6, last_recall_turn=5)
         fired, mem = should_recall(state)
-        assert fired is True  # 7 - 5 = 2 >= 2
+        assert fired is True  # 6 - 5 = 1 >= 1 (tester cooldown)
         assert mem == "has a dog named Nala"
 
     def test_no_recall_if_no_unclaimed_after_some_claimed(self):
@@ -250,6 +250,19 @@ class TestDecideEnding:
     def test_loop_when_tone_mildly_negative(self):
         assert decide_ending(_end_state(tone=-10)) == "loop"
 
+    # --- tester thresholds lowered for a short, judge-friendly run ---
+    def test_tester_good_fires_at_lowered_affinity_35(self):
+        assert decide_ending(_end_state(affinity=35, claimed_count=2,
+                                        tone=30, turn=5)) == "good"
+
+    def test_tester_good_just_below_35_does_not_fire(self):
+        assert decide_ending(_end_state(affinity=34, claimed_count=2,
+                                        tone=30, turn=5)) is None
+
+    def test_tester_bad_fires_at_turn_3(self):
+        assert decide_ending(_end_state(affinity=12, claimed_count=0, tone=-45,
+                                        turn=3, wounds=["w1", "w2"])) == "bad"
+
     # --- dev seed forces a deterministic ending (HOLLOW_FAST_FINALE) ---
     def test_force_ending_overrides_the_tone_branch(self):
         # a flat-tone state would normally be "loop"; the dev force wins
@@ -264,9 +277,9 @@ class TestDecideEnding:
         assert decide_ending(s) == "bad"
 
     def test_bad_needs_minimum_turns(self):
-        s = _end_state(affinity=12, claimed_count=0, tone=-60, turn=3,
+        s = _end_state(affinity=12, claimed_count=0, tone=-60, turn=2,
                        wounds=["w1", "w2"])
-        assert decide_ending(s) is None
+        assert decide_ending(s) is None  # 2 < bad_min_turn (3)
 
     def test_bad_needs_two_wounds(self):
         s = _end_state(affinity=12, claimed_count=0, tone=-60, turn=8,
@@ -280,8 +293,8 @@ class TestDecideEnding:
         assert decide_ending(s) == "bad"
 
     # --- none ---
-    def test_none_below_50(self):
-        assert decide_ending(_end_state(affinity=49, claimed_count=5)) is None
+    def test_none_below_35(self):
+        assert decide_ending(_end_state(affinity=34, claimed_count=5)) is None
 
     def test_none_with_fewer_than_2_claimed(self):
         assert decide_ending(_end_state(affinity=95, claimed_count=1)) is None
@@ -371,14 +384,14 @@ class TestApplyUpdatePlusSignTolerance:
 
 
 class TestSingleGateBranchesByTone:
-    def test_nothing_fires_below_50(self):
-        # one gate at 50; no lower threshold can race a warm run
-        assert decide_ending(_end_state(affinity=49, tone=5)) is None
-        assert decide_ending(_end_state(affinity=49, tone=30)) is None
+    def test_nothing_fires_below_35(self):
+        # one gate at 35; no lower threshold can race a warm run
+        assert decide_ending(_end_state(affinity=34, tone=5)) is None
+        assert decide_ending(_end_state(affinity=34, tone=30)) is None
 
-    def test_gate_at_50_branches_only_by_tone(self):
-        assert decide_ending(_end_state(affinity=50, tone=20)) == "good"
-        assert decide_ending(_end_state(affinity=50, tone=19)) == "loop"
+    def test_gate_at_35_branches_only_by_tone(self):
+        assert decide_ending(_end_state(affinity=35, tone=20)) == "good"
+        assert decide_ending(_end_state(affinity=35, tone=19)) == "loop"
 
 
 class TestHollowWordsFiltered:
@@ -441,13 +454,13 @@ def test_first_recall_fires_without_high_affinity():
     assert do is True and mem == "grew up near the sea"   # wow by turn ~2, low bond
 
 
-def test_recall_still_waits_two_turns_between():
+def test_recall_still_waits_one_turn_between():
     from memory import should_recall
     state = {"affinity": 60, "treasure": ["a", "bb", "ccc"], "claimed": ["a"],
-             "turn": 4, "last_recall_turn": 3}
-    assert should_recall(state)[0] is False               # only 1 turn since last
-    state["turn"] = 5
-    assert should_recall(state)[0] is True                # 2 turns since last
+             "turn": 3, "last_recall_turn": 3}
+    assert should_recall(state)[0] is False               # same turn as last recall
+    state["turn"] = 4
+    assert should_recall(state)[0] is True                # 1 turn gap >= tester cooldown
 
 
 def test_good_ending_reachable_at_lower_affinity():