claude-multiacc 2.0.20 → 2.0.21

package/tests/test_selector.py

@@ -52,9 +52,10 @@ class SelectorTests(unittest.TestCase):
         self.assertEqual(
             response["candidate_snapshot_digest"],
             "e8ef0b4bc7b95e76231ee6da79616d92bd9251c1c991845c8c0524fcbfb6593a")
+        # Recomputed 2026-09-03: the proof input grew by session_gate.
         self.assertEqual(
             response["selection_digest"],
-            "8b68d69b31b2d2252a16f7b83ac46860987647aa360402caa815b2a1bd468def")
+            "1239440c286d579f4326b4dd633072f51435709a0459cba4f9d671b8cefeb646")
 
     def test_unicode_and_active_reservation_proof(self):
         busy = {"active_expires_at": "2026-08-25T09:00:00.000001Z", "last_selected_at": None}
@@ -66,9 +67,10 @@ class SelectorTests(unittest.TestCase):
         self.assertEqual(
             response["candidate_snapshot_digest"],
             "29e8e7d1a611f38ee0be43622102b33875e7ff75ff9024aa43d16151575071d4")
+        # Recomputed 2026-09-03: the proof input grew by session_gate.
         self.assertEqual(
             response["selection_digest"],
-            "72e7b31a00496fff0f6281f4dacd656d3a2a1fc438038e2c20c49274e1f61068")
+            "646f38c209df65af94a4ee25e47579d4794902161f902e94030da23ca49d07ff")
 
     def test_both_chooses_each_provider_and_survives_provider_loss(self):
         codex = select(_request([
@@ -308,5 +310,105 @@ class HeadroomBandTests(unittest.TestCase):
         self.assertEqual(select(_request(pool))["headroom_band"], "30")
 
 
+class SessionGateTests(unittest.TestCase):
+    """The session (5h) bucket is the FIRST cut; the weekly band ranks the survivors.
+
+    Operator, 2026-09-03: "among accounts where high session limits it must choose
+    randomly from ones where highest weekly limits." A nearly-spent 5h bucket is
+    about to reject the launch whatever the weekly headroom says, so it disqualifies
+    the account outright — it is no longer a tie-break, and it no longer shrinks the
+    band through min(weekly, session).
+    """
+
+    def _pool(self, *specs) -> list[dict]:
+        # spec: (account_id, weekly_pct, session_pct) — distinct runner ids keep the
+        # identities unique without touching the account names the assertions read.
+        return [_candidate(runner_id=3 + index, account_id=name,
+                           weekly_pct=weekly, session_pct=session)
+                for index, (name, weekly, session) in enumerate(specs)]
+
+    def _winners(self, pool: list[dict], **patch) -> set[str]:
+        return {select(_request(pool, reservation_key=f"launch-{index}", **patch))["account_id"]
+                for index in range(40)}
+
+    def test_spent_session_loses_to_a_worse_weekly_account(self):
+        # 10w/85s vs 70w/20s -> ALWAYS the 70w account. This reverses the pre-gate
+        # behaviour, where the session-heavy account stayed in the band on its
+        # weekly headroom alone.
+        pool = self._pool(("session-spent", 10, 85), ("session-free", 70, 20))
+        response = select(_request(pool))
+        self.assertEqual(response["account_id"], "session-free")
+        self.assertEqual((response["session_ok_count"], response["band_count"]), (1, 1))
+        self.assertEqual(self._winners(pool), {"session-free"})
+
+    def test_weekly_decides_when_both_clear_the_gate(self):
+        # 10w/45s vs 70w/20s -> always the 10w account: session only acts through the
+        # gate, never as a tie-break inside the band.
+        pool = self._pool(("best-weekly", 10, 45), ("session-free", 70, 20))
+        response = select(_request(pool))
+        self.assertEqual(response["account_id"], "best-weekly")
+        self.assertEqual((response["session_ok_count"], response["band_count"]), (2, 1))
+        self.assertEqual(self._winners(pool), {"best-weekly"})
+
+    def test_gate_steps_aside_when_nobody_clears_it(self):
+        # 10w/85s vs 70w/60s -> the gate compares, it never empties the pool, so the
+        # weekly band ranks everyone exactly as it did before the gate existed.
+        pool = self._pool(("best-weekly", 10, 85), ("other", 70, 60))
+        response = select(_request(pool))
+        self.assertEqual(response["account_id"], "best-weekly")
+        self.assertEqual(response["session_ok_count"], 0)
+        self.assertEqual((response["band_floor"], response["band_count"]), ("60", 1))
+
+    def test_gate_of_one_hundred_disables_it(self):
+        pool = self._pool(("best-weekly", 10, 85), ("session-free", 70, 20))
+        response = select(_request(pool, session_gate=100))
+        self.assertEqual(response["account_id"], "best-weekly")
+        self.assertEqual((response["session_gate"], response["session_ok_count"]), ("100", 2))
+        self.assertEqual(self._winners(pool, session_gate=100), {"best-weekly"})
+
+    def test_unknown_quota_never_clears_the_gate(self):
+        # A row with no telemetry has no session reading, so it cannot be evidence of
+        # room: it stays out of the gated set and out of the weekly band, and the
+        # floor is computed from the known row alone.
+        pool = [_candidate(account_id="blind", weekly_pct=None, session_pct=None),
+                _candidate(runner_id=4, account_id="heavy", weekly_pct=0, session_pct=90)]
+        response = select(_request(pool))
+        self.assertEqual(response["account_id"], "heavy")
+        self.assertEqual(response["session_ok_count"], 0)
+        self.assertEqual((response["band_floor"], response["band_count"]), ("70", 1))
+
+    def test_gate_is_validated_exactly_like_the_band(self):
+        pool = self._pool(("a", 0, 0), ("b", 40, 0))
+        narrow = select(_request(pool, session_gate="0"))
+        self.assertTrue(narrow["ok"])
+        self.assertEqual(narrow["session_gate"], "0")
+        for bad in ("abc", True, [], "1e5", None):
+            refusal = select(_request(pool, session_gate=bad))
+            self.assertFalse(refusal["ok"], bad)
+            self.assertEqual(refusal["error_detail"], {"field": "session_gate"}, bad)
+
+    def test_gate_participates_in_the_selection_proof(self):
+        # Same pool, same winner, different gate -> a different proof: a policy input
+        # that can change the winner has to be inside the digest.
+        pool = self._pool(("a", 0, 40), ("b", 20, 40))
+        tight = select(_request(pool, session_gate="10"))
+        loose = select(_request(pool, session_gate="90"))
+        self.assertNotEqual(tight["selection_digest"], loose["selection_digest"])
+        # An omitted gate is the documented default, and says so in the response.
+        self.assertEqual(select(_request(pool))["session_gate"], "50")
+
+    def test_band_measures_weekly_not_the_minimum_of_weekly_and_session(self):
+        # 0w/45s vs 40w/0s with band 30: on min(weekly, session) the 0w account's
+        # effective headroom (55) is below the other's (60) and both used to band
+        # together. On weekly remaining the 0w account IS the leader and the 40w
+        # account (60) falls outside the 70-point floor.
+        pool = self._pool(("empty-weekly", 0, 45), ("empty-session", 40, 0))
+        response = select(_request(pool))
+        self.assertEqual(response["account_id"], "empty-weekly")
+        self.assertEqual((response["band_floor"], response["band_count"]), ("70", 1))
+        self.assertEqual(response["session_ok_count"], 2)
+        self.assertEqual(self._winners(pool), {"empty-weekly"})
+
+
 if __name__ == "__main__":
     unittest.main()