claude-multiacc 2.0.18 → 2.0.19

package/bin/codex-accounts

@@ -1492,8 +1492,17 @@ for acct in manifest.get('accounts', []):
         b for b in buckets if b['percent'] >= threshold]
     mpath = os.path.join(d, '.limited')
     if offenders:
-        worst = max(offenders, key=lambda b: b['percent'])
-        reset_epoch = max(int(b['resets_epoch']) for b in offenders)
+        # ONE bucket, described consistently: the marker's epoch is the reset of
+        # the bucket its detail line names. It used to pair the highest PERCENT
+        # with the LATEST reset over every offender, and the two came from
+        # different buckets — a 100% five-hour window resetting tonight written
+        # with a seven-day epoch — so everything that trusts the marker parked
+        # the account for days over a window that refills in hours. #20 fixed
+        # this for the claude pool and left the codex writer behind; app-robot
+        # reads both with the same rule. Among offenders the longest-lived wins,
+        # since any bucket over the threshold stays there until its own reset.
+        worst = max(offenders, key=lambda b: (int(b['resets_epoch']), b['percent']))
+        reset_epoch = int(worst['resets_epoch'])
         # Atomic: a concurrent shim must never read a half-written marker.
         with open(mpath + '.tmp', 'w') as f:
             f.write(f'{reset_epoch}\n')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-multiacc",
-  "version": "2.0.18",
+  "version": "2.0.19",
   "description": "Unified Claude Code and OpenAI Codex subscription pooling with quota-aware selection.",
   "type": "module",
   "bin": {

package/tests/test_codex_reset.py

@@ -61,7 +61,9 @@ class ResetHandler(BaseHTTPRequestHandler):
         return
 
 
-class CodexResetIntegrationTest(unittest.TestCase):
+class CodexPoolSandbox:
+    """A one-account codex pool with a fake usage/credits endpoint."""
+
     def setUp(self) -> None:
         self.temp = tempfile.TemporaryDirectory(prefix="multiacc-reset-")
         self.pool = Path(self.temp.name) / "pool"
@@ -88,6 +90,8 @@ class CodexResetIntegrationTest(unittest.TestCase):
         self.thread.join(timeout=5)
         self.temp.cleanup()
 
+
+class CodexResetIntegrationTest(CodexPoolSandbox, unittest.TestCase):
     def run_limits(self) -> subprocess.CompletedProcess:
         base = f"http://127.0.0.1:{self.server.server_port}/wham"
         env = os.environ.copy()
@@ -166,5 +170,66 @@ class CodexResetIntegrationTest(unittest.TestCase):
         self.assertEqual(self.server.state["credit_gets"], 1)
 
 
+class CodexMarkerNamesOneBucketTest(CodexPoolSandbox, unittest.TestCase):
+    """The marker's epoch is the reset of the bucket its detail line NAMES.
+
+    The codex writer used to pair the highest-PERCENT bucket's name with the
+    LATEST reset over every offender, so a five-hour window at 100% resetting
+    tonight was written under a seven-day epoch — and everything that trusts the
+    marker parked the account for a week over a window that refills in hours.
+    #20 fixed this for the claude pool and left codex behind.
+    """
+
+    def run_limits(self) -> subprocess.CompletedProcess:  # no auto-reset: it clears markers
+        base = f"http://127.0.0.1:{self.server.server_port}/wham"
+        env = os.environ.copy()
+        env.update({"CODEX_ACCOUNTS_ROOT": str(self.pool),
+                    "CODEX_MULTIACC_NO_SYNC": "1", "CODEX_MULTIACC_MIN_FETCH": "0",
+                    "CODEX_MULTIACC_AUTO_RESET": "0", "PYTHONDONTWRITEBYTECODE": "1",
+                    "CODEX_MULTIACC_USAGE_URL": f"{base}/usage"})
+        return subprocess.run([REPO / "bin/codex-accounts", "limits", "--force"],
+                              capture_output=True, text=True, env=env, timeout=20, check=False)
+
+    def _marker(self):
+        text = (self.pool / "acct-01/.limited").read_text(encoding="utf-8").splitlines()
+        return int(text[0]), text[1]
+
+    def test_two_offenders_write_one_bucket_with_its_own_reset(self) -> None:
+        now = int(time.time())
+        session_reset, weekly_reset = now + 3600, now + 6 * 86400
+        self.server.state["usage"] = {"plan_type": "pro", "rate_limit": {
+            "allowed": True,
+            # 100% and back in an hour …
+            "primary_window": {"used_percent": 100, "limit_window_seconds": 18000,
+                               "reset_at": session_reset},
+            # … beside 95% that is six days out. Both are over the threshold.
+            "secondary_window": {"used_percent": 95, "limit_window_seconds": 604800,
+                                 "reset_at": weekly_reset}}}
+        self.assertEqual(self.run_limits().returncode, 0)
+        epoch, detail = self._marker()
+        # The longest-lived offender is named, and the epoch is ITS reset — the
+        # account really is excluded until then, and a reader that takes the
+        # detail's percent gets the percent of the very bucket the epoch belongs
+        # to rather than a different bucket's.
+        self.assertEqual(epoch, weekly_reset)
+        self.assertIn("percent=95", detail)
+        self.assertIn(time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime(weekly_reset)), detail)
+        self.assertNotIn("percent=100", detail)
+
+    def test_a_single_offender_still_names_itself(self) -> None:
+        now = int(time.time())
+        reset = now + 4 * 86400
+        self.server.state["usage"] = {"plan_type": "pro", "rate_limit": {
+            "allowed": True,
+            "primary_window": {"used_percent": 91, "limit_window_seconds": 604800,
+                               "reset_at": reset},
+            "secondary_window": {"used_percent": 12, "limit_window_seconds": 18000,
+                                 "reset_at": now + 900}}}
+        self.assertEqual(self.run_limits().returncode, 0)
+        epoch, detail = self._marker()
+        self.assertEqual(epoch, reset)
+        self.assertIn("percent=91", detail)
+
+
 if __name__ == "__main__":
     unittest.main()