claude-multiacc 2.0.17 → 2.0.19

package/bin/claude-accounts

@@ -2114,6 +2114,10 @@ for acct in manifest.get('accounts', []):
                 'percent': pct,
                 'resets_at': resets,
                 'resets_epoch': int(parse_iso(resets) or now + 3600),
+                # Present only for a bucket that belongs to ONE model: such a
+                # bucket parks that model, never the account (see the marker
+                # choice below and the shim's scoped_blocks_run).
+                'model': model,
             })
         if not buckets:
             # Fallback for a payload with no limits[] array: scan EVERY top-level object
@@ -2175,8 +2179,21 @@ for acct in manifest.get('accounts', []):
     offenders = [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% session bucket resetting in a minute was
+        # written with a Fable weekly bucket's epoch six days out, and everything
+        # that trusts the marker (this shim, app-robot's fleet verdict on every
+        # Mac) parked the whole account for six days over a five-hour window
+        # (2026-08-29, acct-05). An account-level bucket wins over a model-scoped
+        # one — the latter parks a model, not the account (scoped_blocks_run) —
+        # and among those, the longest-lived exclusion, since any bucket over the
+        # threshold stays there until its own reset.
+        account_level = [b for b in offenders if not b.get('model')]
+        worst = max(account_level or 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/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.17",
+  "version": "2.0.19",
   "description": "Unified Claude Code and OpenAI Codex subscription pooling with quota-aware selection.",
   "type": "module",
   "bin": {

package/tests/run-tests.sh

@@ -1883,6 +1883,70 @@ sc="$(python3 -c "import json;d=json.load(open('$ACC/acct-01/limits.json'));prin
   || t_fail "ranking score" "got $sc"
 rm -f "$ACC/acct-01/limits.json" "$ACC/acct-01/.limited"
 
+# ---- 16-marker. the marker names ONE bucket and carries THAT bucket's reset ----------
+# A 100% session bucket (resets in an hour) beside a 100% Fable-only weekly bucket
+# (resets in five days) used to produce "bucket=session … resets_at=<+1h>" on line 2
+# under a line-1 epoch five days out — the highest percent paired with the latest
+# reset of a DIFFERENT bucket. Every reader of the marker (this shim, app-robot's
+# fleet-wide verdict) then parked the whole account for five days over a five-hour
+# window (2026-08-29, acct-05). The account-level bucket is named with its own reset.
+cat > "$WORK/usage-session-vs-fable.json" <<'EOF2'
+{"limits":[
+  {"kind":"session","percent":100,"resets_at":"2099-01-01T01:00:00+00:00","scope":null},
+  {"kind":"weekly_all","percent":40,"resets_at":"2099-01-05T00:00:00+00:00","scope":null},
+  {"kind":"weekly_scoped","percent":100,"resets_at":"2099-01-06T00:00:00+00:00","scope":{"model":{"display_name":"Fable"}}}
+]}
+EOF2
+out="$(CLAUDE_MULTIACC_USAGE_URL="file://$WORK/usage-session-vs-fable.json" claude-accounts limits --force 2>&1)"
+check "session over threshold names the session bucket, not the Fable one" "LIMITED session at 100%" "$out"
+python3 - "$ACC/acct-01/.limited" <<'EOF2'
+import sys, time, calendar
+lines = open(sys.argv[1]).read().splitlines()
+epoch, detail = int(lines[0]), lines[1]
+want = calendar.timegm(time.strptime("2099-01-01T01:00:00", "%Y-%m-%dT%H:%M:%S"))
+assert epoch == want, (epoch, want, detail)                       # the SESSION reset
+assert "bucket=session percent=100" in detail, detail
+assert "resets_at=2099-01-01T01:00:00+00:00" in detail, detail
+EOF2
+[ $? -eq 0 ] && t_ok "marker epoch is the named bucket's own reset (session +1h, not Fable +5d)" \
+  || t_fail "marker epoch/bucket consistency" "$(cat "$ACC/acct-01/.limited" 2>&1 | tr '\n' ' ')"
+# Two ACCOUNT-level offenders: the longest-lived exclusion is the one named, with its
+# own reset — a session bucket that resets in an hour must not shorten a weekly park.
+cat > "$WORK/usage-session-vs-weekly.json" <<'EOF2'
+{"limits":[
+  {"kind":"session","percent":100,"resets_at":"2099-01-01T01:00:00+00:00","scope":null},
+  {"kind":"weekly_all","percent":95,"resets_at":"2099-01-05T00:00:00+00:00","scope":null}
+]}
+EOF2
+out="$(CLAUDE_MULTIACC_USAGE_URL="file://$WORK/usage-session-vs-weekly.json" claude-accounts limits --force 2>&1)"
+check "two account-level offenders: the longest-lived one is named" "LIMITED weekly_all at 95%" "$out"
+python3 - "$ACC/acct-01/.limited" <<'EOF2'
+import sys, time, calendar
+lines = open(sys.argv[1]).read().splitlines()
+want = calendar.timegm(time.strptime("2099-01-05T00:00:00", "%Y-%m-%dT%H:%M:%S"))
+assert int(lines[0]) == want, lines
+assert "bucket=weekly_all percent=95" in lines[1] and "resets_at=2099-01-05T00:00:00+00:00" in lines[1], lines
+EOF2
+[ $? -eq 0 ] && t_ok "weekly_all marker carries the weekly reset" \
+  || t_fail "weekly_all marker" "$(cat "$ACC/acct-01/.limited" 2>&1 | tr '\n' ' ')"
+# Only a model-scoped offender left: the scoped bucket is named (the shim treats it
+# as "switch model", never as an account park) with ITS reset.
+cat > "$WORK/usage-fable-only.json" <<'EOF2'
+{"limits":[
+  {"kind":"session","percent":10,"resets_at":"2099-01-01T01:00:00+00:00","scope":null},
+  {"kind":"weekly_scoped","percent":100,"resets_at":"2099-01-06T00:00:00+00:00","scope":{"model":{"display_name":"Fable"}}}
+]}
+EOF2
+out="$(CLAUDE_MULTIACC_USAGE_URL="file://$WORK/usage-fable-only.json" claude-accounts limits --force 2>&1)"
+check "a scoped-only offender still marks, scoped" "LIMITED weekly_scoped:Fable at 100%" "$out"
+grep -q "^bucket=weekly_scoped:Fable percent=100 " "$ACC/acct-01/.limited" 2>/dev/null \
+  && [ "$(head -1 "$ACC/acct-01/.limited")" = "$(python3 -c 'import time,calendar;print(calendar.timegm(time.strptime("2099-01-06T00:00:00","%Y-%m-%dT%H:%M:%S")))')" ] \
+  && t_ok "scoped marker carries the scoped bucket's reset" \
+  || t_fail "scoped marker" "$(cat "$ACC/acct-01/.limited" 2>&1 | tr '\n' ' ')"
+grep -q '"model": "Fable"' "$ACC/acct-01/limits.json" && t_ok "limits.json buckets record the model scope" \
+  || t_fail "bucket model field" "missing from limits.json"
+rm -f "$ACC/acct-01/limits.json" "$ACC/acct-01/.limited"
+
 # ---- 16a. future-proofing: works if the Fable bucket separation disappears ---------
 cat > "$WORK/usage-no-fable.json" <<'EOF'
 {"limits":[

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()