claude-multiacc 2.0.49 → 2.0.50

package/docs/UNIFIED_SELECTOR.md

@@ -57,9 +57,10 @@ weekly limits").
    is what makes a burst of parallel launches fan out instead of stacking on one
    account, and it is deterministic: the same request always yields the same winner.
 
-With no usable quota anywhere the band cannot apply (`band_floor` is `null`) and the
-plain ordering stands: known quota ahead of unknown, then highest effective headroom,
-then least-recently-selected.
+With no usable quota anywhere the band cannot apply (`band_floor` is `null`). Every
+eligible account is then a peer: least-recently-selected wins, followed by the same
+request-key spread. Equal histories must not concentrate launches on the first provider,
+account or runner identity merely because telemetry is unknown.
 
 Success returns the concrete engine/account/runner generation, normalized score basis
 (which still reports `effective_headroom` = min(weekly, session) for observability),

package/docs/VERIFICATION.md

@@ -4,7 +4,7 @@
 
 ```bash
 tests/run-tests.sh            # sandboxed compatibility tests, no quota
-python3 tests/test_selector.py # unified selector contract
+python3 -m unittest discover -s tests -p 'test_selector*.py' # unified selector contract and distribution
 python3 -m unittest discover -s tests -p 'test_autoresume*.py' # watchers and fallback probes (also in run-tests.sh)
 npm run test:commands         # packed npm commands; run npm install --ignore-scripts first
 claude-accounts verify        # real matrix: `claude -p "reply OK"` per authed account

package/lib/selector_policy.py

@@ -119,14 +119,6 @@ def _apply_policy(request: dict, rows: list[dict]) -> tuple[tuple, int]:
     return producer, alternatives
 
 
-def _winner_key(row: dict) -> tuple:
-    descending_headroom = Decimal(row["effective_headroom"] or "-1").copy_negate()
-    return (
-        not row["quota_known"], descending_headroom,
-        row["last_selected_at"] is not None, row["last_selected_at"] or "",
-        row["engine"], row["account_id"], row["runner_id"], row["runner_generation"])
-
-
 def _session_gate(rows: list[dict], gate: Decimal | None) -> list[dict]:
     """The FIRST cut: accounts whose 5h session bucket still has room.
 
@@ -229,13 +221,12 @@ def select(request: object) -> dict:
     ranked = healthy or known
     floor = _band_floor(ranked, band) if band is not None else None
     if floor is None:
-        # No usable quota anywhere: nothing to band, so keep the plain ordering
-        # (which already ranks unknown-quota rows last and rotates on ties).
+        # No usable quota anywhere: every eligible row is an unknown peer.
+        # Keep LRU and the request spread instead of preferring a fixed identity.
         banded = eligible
-        winner = min(banded, key=_winner_key)
     else:
         banded = [row for row in ranked if Decimal(row["weekly_remaining"]) >= floor]
-        winner = min(banded, key=_band_key(request["reservation_key"]))
+    winner = min(banded, key=_band_key(request["reservation_key"]))
     rows.sort(key=_snapshot_key)
     snapshot = canonical_sha256(rows)
     chosen = dict(zip(("runner_id", "runner_generation", "engine", "account_id"), _row_identity(winner)))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-multiacc",
-  "version": "2.0.49",
+  "version": "2.0.50",
   "description": "Unified Claude Code and OpenAI Codex subscription pooling with quota-aware selection.",
   "type": "module",
   "bin": {
@@ -56,7 +56,8 @@
   "scripts": {
     "postinstall": "node scripts/postinstall.mjs",
     "test": "npm run test:core && npm run test:seeding && npm run test:commands",
-    "test:core": "bash tests/run-tests.sh && python3 tests/test_selector.py && python3 tests/test_shim_path.py",
+    "test:core": "bash tests/run-tests.sh && npm run test:selector && python3 tests/test_shim_path.py",
+    "test:selector": "python3 -m unittest discover -s tests -p 'test_selector*.py'",
     "test:seeding": "python3 tests/test_account_seeding.py && python3 tests/test_mcp_registry.py && npm run test:codex-settings",
     "test:codex-settings": "python3 tests/test_codex_config_edit.py && python3 tests/test_codex_settings.py",
     "test:commands": "python3 tests/test_packaged_commands.py"

package/tests/test_selector_spread.py

@@ -0,0 +1,65 @@
+"""Unknown quota must not turn a launch burst into a fixed-identity preference."""
+
+from collections import Counter
+import unittest
+
+from test_selector import _candidate, _request
+from selector_policy import select
+
+
+class UnknownQuotaSpreadTests(unittest.TestCase):
+    def test_unknown_and_partial_quota_spread_across_accounts_and_providers(self):
+        for weekly, session in ((None, None), (0, None), (None, 0)):
+            with self.subTest(weekly=weekly, session=session):
+                pool = [_candidate(engine=engine, account_id=f"acct-{index:02d}",
+                                   weekly_pct=weekly, session_pct=session)
+                        for engine in ("claude", "codex") for index in range(4)]
+                counts = Counter()
+                for index in range(120):
+                    response = select(_request(pool, reservation_key=f"burst-{index}"))
+                    self.assertTrue(response["ok"])
+                    self.assertIsNone(response["band_floor"])
+                    self.assertEqual(response["session_ok_count"], 0)
+                    counts[(response["engine"], response["account_id"])] += 1
+                self.assertEqual(len(counts), len(pool), counts)
+                self.assertLess(max(counts.values()), 40, counts)
+
+    def test_equal_history_spreads_same_account_id_across_runner_identities(self):
+        pool = [_candidate(runner_id=index, engine="codex", account_id="acct-01",
+                           weekly_pct=None, session_pct=None,
+                           reservation_history={"active_expires_at": None,
+                                                "last_selected_at": "2026-08-25T08:00:00Z"})
+                for index in range(1, 9)]
+        counts = Counter(select(_request(pool, reservation_key=f"burst-{index}"))["runner_id"]
+                         for index in range(120))
+        self.assertEqual(len(counts), len(pool), counts)
+        self.assertLess(max(counts.values()), 40, counts)
+
+    def test_unknown_quota_preserves_lru_and_active_reservation_exclusion(self):
+        pool = [_candidate(account_id=name, weekly_pct=None, session_pct=None,
+                           reservation_history={"active_expires_at": expiry,
+                                                "last_selected_at": last})
+                for name, expiry, last in (
+                    ("reserved", "2026-08-25T09:10:00Z", None),
+                    ("unused", None, None),
+                    ("old", None, "2026-08-25T08:00:00Z"),
+                    ("recent", None, "2026-08-25T08:50:00Z"))]
+        for index in range(20):
+            response = select(_request(pool, reservation_key=f"burst-{index}"))
+            self.assertEqual(response["account_id"], "unused")
+            self.assertEqual(response["eligible_count"], 3)
+        for index in range(20):
+            response = select(_request(pool[2:], reservation_key=f"burst-{index}"))
+            self.assertEqual(response["account_id"], "old")
+
+    def test_unknown_quota_remains_deterministic_and_input_order_independent(self):
+        pool = [_candidate(account_id=f"acct-{index:02d}", weekly_pct=None, session_pct=None)
+                for index in range(8)]
+        response = select(_request(pool, reservation_key="stable"))
+        self.assertEqual(response, select(_request(pool, reservation_key="stable")))
+        reversed_response = select(_request(list(reversed(pool)), reservation_key="stable"))
+        self.assertEqual(response["account_id"], reversed_response["account_id"])
+
+
+if __name__ == "__main__":
+    unittest.main()