claude-multiacc 2.0.37 → 2.0.39

package/tests/test_account_seeding.py

@@ -107,6 +107,46 @@ class AccountSeedingTests(unittest.TestCase):
                 self.assertTrue((root / "acct-01" / name).is_symlink())
                 self.assertFalse(os.path.lexists(root / "acct-99" / name))
 
+    def test_seeding_applies_the_pool_mcp_registry(self):
+        """The registry reaches a fresh account at seed time; an account's own servers survive."""
+        registry = {"version": 1, "retired": [], "projects": {}, "mcpServers": {
+            "seeded": {"type": "stdio", "command": "echo", "args": ["hi"], "env": {"K": "v"}}}}
+        for provider, name in (("claude", ".claude.json"), ("codex", "config.toml")):
+            with self.subTest(provider=provider):
+                root = self.home / f".{provider}-accounts"
+                root.mkdir(exist_ok=True)
+                (root / "accounts.json").write_text(json.dumps({
+                    "version": 1, "server": "none",
+                    "accounts": [{"id": "acct-01", "email": "fixture@example.test", "home": "mac"}]}))
+                (root / "mcp-servers.json").write_text(json.dumps(registry))
+                account = root / "acct-01"
+                account.mkdir()
+                if provider == "claude":
+                    (account / name).write_text(json.dumps(
+                        {"mcpServers": {"own": {"type": "stdio", "command": "true", "args": [], "env": {}}}}))
+                else:
+                    (account / name).write_text('model = "gpt-5"\n\n[mcp_servers.own]\ncommand = "true"\nargs = []\n')
+                for _ in range(2):
+                    self.seed(provider, account)
+                    text = (account / name).read_text()
+                    if provider == "claude":
+                        servers = json.loads(text)["mcpServers"]
+                        self.assertEqual(servers["seeded"]["command"], "echo")
+                        self.assertIn("own", servers)
+                    else:
+                        self.assertIn("[mcp_servers.seeded]", text)
+                        self.assertIn('command = "echo"', text)
+                        self.assertIn("[mcp_servers.own]", text)
+                        self.assertIn('model = "gpt-5"', text)
+                self.assertTrue((account / ".mcp-applied").exists())
+
+    def test_seeding_without_a_registry_touches_no_config(self):
+        for provider, _, name in PROVIDERS:
+            with self.subTest(provider=provider):
+                account = self.seed(provider)
+                self.assertFalse((account / ".mcp-applied").exists())
+                self.assertFalse((self.home / f".{provider}-accounts" / "mcp-servers.json").exists())
+
 
 if __name__ == "__main__":
     unittest.main()

package/tests/test_claude_reset.py

@@ -36,7 +36,7 @@ def iso(offset: int) -> str:
 def usage_doc(*, session=0, weekly=50, fable=50, exhausted=(), resets_left=1,
               use_requires_limit=False, eligible=True, reason=None, blocking=(),
               clears=("five_hour", "seven_day", "seven_day_overage_included"),
-              usable=True, week_resets_in=3 * 86400) -> dict:
+              usable=True, week_resets_in=3 * 86400, session_resets_in=3600) -> dict:
     """A usage response in the live 2026-09-22 shape, cedar_ember block included."""
     grants = [{
         "id": GRANT, "label": "Claude Opus 5.5 launch: one usage-limit reset for Pro and Max",
@@ -50,7 +50,7 @@ def usage_doc(*, session=0, weekly=50, fable=50, exhausted=(), resets_left=1,
     return {
         "limits": [
             {"kind": "session", "group": "session", "percent": session,
-             "resets_at": iso(3600) if session else None, "scope": None},
+             "resets_at": iso(session_resets_in) if session else None, "scope": None},
             {"kind": "weekly_all", "group": "weekly", "percent": weekly,
              "resets_at": iso(week_resets_in), "scope": None},
             {"kind": "weekly_scoped", "group": "weekly", "percent": fable,
@@ -234,22 +234,65 @@ class ClaudeResetIntegrationTest(ClaudePoolSandbox, unittest.TestCase):
         self.run_limits()
         self.assertEqual(len(self.server.state["posts"]), 1)
 
-    def test_does_not_redeem_above_five_percent_remaining(self) -> None:
-        self.server.state["usage"] = usage_doc(session=94, weekly=80, fable=94)
+    def test_does_not_redeem_below_the_pools_own_threshold(self) -> None:
+        self.server.state["usage"] = usage_doc(session=89, weekly=80, fable=89)
         self.run_limits()
         self.assertEqual(self.server.state["posts"], [])
         self.assertFalse((self.account / ".usage-reset.json").exists())
         self.assertEqual(self.limits_doc()["reset_credits_available"], 1)
 
-    def test_a_full_five_hour_window_alone_never_spends_the_week(self) -> None:
-        # The grant refills the WEEK and exists once; a five-hour wall refills itself in
-        # hours while the pool picks another account.
+    def test_a_week_parked_at_the_pools_threshold_is_reset(self) -> None:
+        # The live acct-15 shape (2026-09-22): weekly_all 93% parks the account for six
+        # days at the pool's 90% line; waiting for 95% left its reset unused.
+        self.server.state["usage"] = usage_doc(session=100, weekly=93, fable=64,
+                                               session_resets_in=5400)
+        self.server.state["responses"] = [(200, {"result": "reset", "resets_left": 0}, True)]
+        self.run_limits()
+        self.assertEqual(len(self.server.state["posts"]), 1)
+        self.assertFalse((self.account / ".limited").exists())
+
+    def park(self, bucket: str, lifts_in: int, reason: str = "client-rate-limit") -> Path:
+        marker = self.account / ".limited"
+        marked = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime(time.time() - 600))
+        marker.write_text(f"{int(time.time()) + lifts_in}\nbucket={bucket} percent=100 "
+                          f"marked_at={marked} reason={reason}\n", encoding="utf-8")
+        return marker
+
+    def test_a_park_the_telemetry_cannot_see_is_reset(self) -> None:
+        # acct-13 (a client five-hour 429 while OAuth read 0% everywhere) and acct-19 (the
+        # panel's weekly park while OAuth read 24%): parked is parked.
+        for bucket, lifts_in in (("client:five_hour", 5400),
+                                 ("weekly_all", 3 * 86400), ("panel:observed", 86400)):
+            with self.subTest(bucket=bucket):
+                self.server.state["posts"] = []
+                self.server.state["usage"] = usage_doc(session=0, weekly=19, fable=24)
+                self.server.state["responses"] = [(200, {"result": "reset", "resets_left": 0}, True)]
+                (self.account / ".usage-reset.json").unlink(missing_ok=True)
+                (self.account / "limits.json").unlink(missing_ok=True)
+                marker = self.park(bucket, lifts_in)
+                self.run_limits()
+                self.assertEqual(len(self.server.state["posts"]), 1)
+                self.assertFalse(marker.exists())
+
+    def test_an_error_cooldown_is_not_a_usage_park(self) -> None:
+        self.park("session", 600, reason="error-cooldown")
+        self.server.state["usage"] = usage_doc(weekly=19, fable=24)
+        self.run_limits()
+        self.assertEqual(self.server.state["posts"], [])
+
+    def test_a_five_hour_wall_that_lifts_within_the_hour_keeps_its_reset(self) -> None:
         self.server.state["usage"] = usage_doc(session=100, weekly=40, fable=40,
-                                               exhausted=["five_hour"])
+                                               exhausted=["five_hour"], session_resets_in=1800)
         self.run_limits()
         self.assertEqual(self.server.state["posts"], [])
+        self.assertIn("limit reset held", self.log())
         self.assertTrue((self.account / ".limited").exists())   # still parked for the 5h
-        self.assertEqual(self.limits_doc()["reset_credits_available"], 1)
+        # ...but one that holds the account for longer is reset.
+        self.server.state["usage"] = usage_doc(session=100, weekly=40, fable=40,
+                                               exhausted=["five_hour"], session_resets_in=5400)
+        self.server.state["responses"] = [(200, {"result": "reset", "resets_left": 0}, True)]
+        self.run_limits()
+        self.assertEqual(len(self.server.state["posts"]), 1)
 
     def test_a_five_hour_wall_beside_a_spent_week_is_redeemed(self) -> None:
         # The live acct-17 shape of 2026-09-22: session 100% AND Fable weekly at 95%.
@@ -260,9 +303,9 @@ class ClaudeResetIntegrationTest(ClaudePoolSandbox, unittest.TestCase):
         self.assertEqual(len(self.server.state["posts"]), 1)
         self.assertFalse((self.account / ".limited").exists())
 
-    def test_a_week_that_refills_tomorrow_keeps_its_reset(self) -> None:
+    def test_a_week_that_refills_within_the_hour_keeps_its_reset(self) -> None:
         self.server.state["usage"] = usage_doc(fable=100, exhausted=["seven_day_overage_included"],
-                                               week_resets_in=13 * 3600)
+                                               week_resets_in=1800)
         self.run_limits()
         self.assertEqual(self.server.state["posts"], [])
         self.assertIn("limit reset held", self.log())
@@ -272,6 +315,13 @@ class ClaudeResetIntegrationTest(ClaudePoolSandbox, unittest.TestCase):
         self.run_limits(CLAUDE_MULTIACC_RESET_MIN_HORIZON="0")
         self.assertEqual(len(self.server.state["posts"]), 1)
 
+    def test_a_week_that_refills_in_eleven_hours_is_reset(self) -> None:
+        # acct-21 (2026-09-22): Fable at 95%, week back at 09:00 — out of service 11h.
+        self.server.state["usage"] = usage_doc(weekly=56, fable=95, week_resets_in=11 * 3600)
+        self.server.state["responses"] = [(200, {"result": "reset", "resets_left": 0}, True)]
+        self.run_limits()
+        self.assertEqual(len(self.server.state["posts"]), 1)
+
     def test_a_grant_that_needs_the_limit_waits_for_it(self) -> None:
         self.server.state["usage"] = usage_doc(fable=97, use_requires_limit=True)
         self.run_limits()

package/tests/test_codex_reset.py

@@ -140,18 +140,59 @@ class CodexResetIntegrationTest(CodexPoolSandbox, unittest.TestCase):
         self.run_limits()
         self.assertEqual(len(self.server.state["posts"]), 2)
 
-    def test_does_not_redeem_above_five_percent_remaining(self) -> None:
+    def test_does_not_redeem_below_the_pools_threshold(self) -> None:
         now = int(time.time())
         self.server.state["usage"] = {"rate_limit": {"allowed": True,
-            "primary_window": {"used_percent": 94, "limit_window_seconds": 18000,
+            "primary_window": {"used_percent": 89, "limit_window_seconds": 18000,
                                "reset_at": now + 3600}},
             "rate_limit_reset_credits": {"available_count": 1}}
+        self.server.state["credits"] = {"available_count": 1, "credits": []}
         result = self.run_limits()
         self.assertEqual(result.returncode, 0, result.stderr)
         self.assertEqual(self.server.state["credit_gets"], 1)
         self.assertEqual(self.server.state["posts"], [])
         self.assertFalse((self.pool / "acct-01/.usage-reset.json").exists())
 
+    def test_an_account_parked_at_the_pools_threshold_uses_its_reset(self) -> None:
+        # Operator rule (2026-09-22): a PARKED account uses its reset. The pool parks at
+        # 90%; waiting for 95% left accounts at 90-94% idle for days with credits unused.
+        now = int(time.time())
+        self.server.state["usage"] = {"rate_limit": {"allowed": True,
+            "primary_window": {"used_percent": 92, "limit_window_seconds": 604800,
+                               "reset_at": now + 4 * 86400}}}
+        self.server.state["credits"] = {"available_count": 1, "credits": []}
+        self.server.state["responses"] = [(200, {"code": "reset", "windows_reset": 1})]
+        self.assertEqual(self.run_limits().returncode, 0)
+        self.assertEqual(len(self.server.state["posts"]), 1)
+        self.assertFalse((self.pool / "acct-01/.limited").exists())
+
+    def test_a_client_reported_park_uses_its_reset(self) -> None:
+        # The rollout scan parked the account on a real 429 its telemetry does not show.
+        now = int(time.time())
+        marker = self.pool / "acct-01/.limited"
+        marker.write_text(f"{now + 3 * 86400}\nbucket=client:7d percent=100 "
+                          f"marked_at=2020-01-01T00:00:00Z reason=client-rate-limit\n")
+        self.server.state["usage"] = {"rate_limit": {"allowed": True,
+            "primary_window": {"used_percent": 40, "limit_window_seconds": 604800,
+                               "reset_at": now + 3 * 86400}}}
+        self.server.state["credits"] = {"available_count": 1, "credits": []}
+        self.server.state["responses"] = [(200, {"code": "reset", "windows_reset": 1})]
+        self.assertEqual(self.run_limits().returncode, 0)
+        self.assertEqual(len(self.server.state["posts"]), 1)
+        self.assertFalse(marker.exists())
+
+    def test_a_park_that_lifts_within_the_hour_keeps_its_reset(self) -> None:
+        now = int(time.time())
+        (self.pool / "acct-01/.limited").write_text(
+            f"{now + 1200}\nbucket=client:5h percent=100 marked_at=2020-01-01T00:00:00Z "
+            f"reason=client-rate-limit\n")
+        self.server.state["usage"] = {"rate_limit": {"allowed": True,
+            "primary_window": {"used_percent": 40, "limit_window_seconds": 604800,
+                               "reset_at": now + 3 * 86400}}}
+        self.server.state["credits"] = {"available_count": 1, "credits": []}
+        self.assertEqual(self.run_limits().returncode, 0)
+        self.assertEqual(self.server.state["posts"], [])
+
     def test_retries_a_lost_response_with_the_same_idempotency_key(self) -> None:
         now = int(time.time())
         self.server.state["usage"] = {"rate_limit": {"allowed": False,