claude-multiacc 2.0.36 → 2.0.38

package/README.md

@@ -177,17 +177,17 @@ buckets keep being tracked and the ≥90% rule keeps working. Unparseable entrie
 skipped, an all-legacy payload falls back to `five_hour`/`seven_day`, and a payload the
 code cannot read at all degrades that one account (fail open), never the run.
 
-**Limit resets are redeemed automatically, but only when one earns its keep.** Claude
+**A parked account gets its limit reset automatically.** Claude
 Code 2.1.280 added `/limit-reset`: an account can hold a *grant* (the Opus 5.5 launch gave
 every Pro/Max account one reset, usable until 2026-10-22) that refills its five-hour and
 weekly limits at once while the weekly reset day stays put. The same usage call carries the
 grant's status (`?cedar_ember=1&skip_spend=1`, Claude Code's own read, so it costs nothing
 against the endpoint's hourly budget), and the limits pass claims it with
-`POST /api/organizations/<org>/reset_rate_limits` when a **weekly** limit the grant refills
-is ≥ 95% used or reported exhausted — the codex rule, narrowed because a Claude reset is one
-irreversible shot. A full five-hour window alone never spends it (it refills in hours and the
-pool picks another account), and it is held while the account's own week refills in under
-24 h (`CLAUDE_MULTIACC_RESET_MIN_HORIZON`, seconds). The claim carries a request id derived
+`POST /api/organizations/<org>/reset_rate_limits` whenever the pool has **parked** the account on a
+window the grant refills — a bucket at/over the pool's own threshold (90%), a limit the server
+reports exhausted, or an active park (a client 429, or the app-robot panel's own park) — and holds
+it only when every such park lifts on its own within the hour (`CLAUDE_MULTIACC_RESET_MIN_HORIZON`,
+seconds). The claim carries a request id derived
 from the account, grant, remaining count and week, persisted before the POST, so a lost
 response is retried with the same id and fleet peers converge on one claim; a claim whose
 answer never came back is settled by the grant's own remaining count dropping, and a claim

package/bin/claude-accounts

@@ -81,10 +81,10 @@ USAGE
                                             or runner daemon distributes.
   claude-accounts verify [--quick]          auth matrix; full mode runs `-p "reply OK"` per account
   claude-accounts limits [--quiet] [--force] [--json]
-      refresh usage buckets, apply >=90% markers. When a WEEKLY limit is at least
-      95% used or exhausted, automatically redeems the account's Claude Code limit
-      reset (/limit-reset) with an idempotent request — never for a five-hour
-      window alone, and not while the week refills on its own within 24h.
+      refresh usage buckets, apply >=90% markers. When the pool has parked an
+      account on a window its Claude Code limit reset (/limit-reset) refills,
+      redeems it with an idempotent request — unless every park lifts on its own
+      within the hour.
       Auto-refreshes long-expired
       OAuth access tokens via the refresh-token grant (rotated credential is
       persisted), so idle accounts keep fresh telemetry and stay selectable.
@@ -105,8 +105,8 @@ ENV
   CLAUDE_SHIM_RETRY=0   disable -p auto-retry
   CLAUDE_MULTIACC_DISABLE=1  bypass the shim entirely
   CLAUDE_MULTIACC_AUTO_RESET=0  disable automatic limit-reset redemption
-  CLAUDE_MULTIACC_RESET_MIN_HORIZON  seconds before the natural weekly reset
-                        inside which a reset is held (default 86400)
+  CLAUDE_MULTIACC_RESET_MIN_HORIZON  a reset is held while every park lifts on
+                        its own within this many seconds (default 3600)
 EOF
 }
 
@@ -2408,7 +2408,7 @@ for acct in manifest.get('accounts', []):
     if source == 'oauth':
         try:
             reset_result, reset_view = claude_reset.refresh_reset_credits(
-                d, aid, data, url, headers, say, int(now))
+                d, aid, data, url, headers, say, int(now), threshold)
         except Exception as e:
             say(f'{aid}: limit reset automation failed unexpectedly ({type(e).__name__}); '
                 f'failing open')
@@ -2481,6 +2481,16 @@ for acct in manifest.get('accounts', []):
         # human's /limit-reset) enters it here, from the grant's own count dropping; this
         # GET already came after it, so its numbers stand.
         observed = claude_reset.observed_reset(prev, reset_status, now)
+        if observed:
+            # Stamped when SEEN, which is later than the reset itself: every park
+            # written in between counts as "before" it. A weekly window cannot
+            # re-exhaust in that gap, but a 5h one can — so the 5h refill only counts
+            # when this very (post-reset) reading MEASURED the session window; a silent
+            # one proves nothing (the acct-14 shape). One second back, so a park this
+            # pass writes can never tie with the stamp.
+            kept = [t for t in observed[1]
+                    if session_measured or t not in claude_reset.SESSION_LIMITS]
+            observed = (observed[0] - 1, kept) if kept else None
         reset_record = claude_reset.latest(claude_reset.record_from(prev, now), observed,
                                            claude_reset.local_record(d, now))
         if observed and reset_record is observed:

package/bin/codex-accounts

@@ -89,8 +89,10 @@ USAGE
                                             `codex exec` per account
   codex-accounts limits [--quiet] [--force] [--json]
       refresh usage windows from the ChatGPT usage endpoint, apply >=90% markers.
-      When a fresh bucket is at least 95% used, automatically redeems an earned
-      usage-limit reset if the account has one, using an idempotent request.
+      When the pool has parked the account (a window at/over the threshold, a
+      finished limit, or a client-reported limit that lifts more than an hour from
+      now), automatically redeems an earned usage-limit reset if the account has
+      one, using an idempotent request.
       Auto-refreshes long-expired access tokens via the OAuth refresh-token grant
       (rotated credential is persisted), so idle accounts keep fresh telemetry and
       stay selectable. Skips accounts fetched in the last 45s and honors
@@ -1620,7 +1622,8 @@ for acct in manifest.get('accounts', []):
     if sessionp is None and live:
         sessionp = 0
     try:
-        reset_result, reset_view = refresh_reset_credits(d, aid, maxp, data, url, headers, say, int(now))
+        reset_result, reset_view = refresh_reset_credits(d, aid, maxp, data, url, headers, say,
+                                                         int(now), threshold)
     except Exception as e:
         say(f'{aid}: usage reset automation failed unexpectedly ({type(e).__name__}); failing open')
         reset_result = {'status': 'error'}

package/docs/CODEX.md

@@ -44,8 +44,9 @@ Codex-specific notes:
   own public client id) and the rotated credential is persisted 0600. Overrides for
   tests: `CODEX_MULTIACC_TOKEN_URL`, `CODEX_MULTIACC_CLIENT_ID`,
   `CODEX_MULTIACC_USAGE_URL`.
-- **Earned usage resets are redeemed automatically at 95% used** (5% remaining) or
-  when the backend reports the limit finished. The limits refresher checks the reset
+- **Earned usage resets are redeemed automatically for a parked account:** a bucket
+  at/over the pool's exclusion threshold (90%), a limit the backend reports finished, or
+  an active usage park (a client-reported 429) that lifts more than an hour from now. The limits refresher checks the reset
   credits belonging to that same account, uses the soonest-expiring available credit,
   and writes a per-account/window idempotency key before redemption so a lost response
   or simultaneous fleet poll cannot spend a second reset. Set

package/lib/claude_reset.py

@@ -6,19 +6,15 @@ names (``clears``: five_hour, seven_day, seven_day_overage_included, ...) while
 weekly reset day stays where it was. The first grant arrived with the Opus 5.5
 launch on 2026-09-22 — one reset per Pro/Max account, usable until 2026-10-22.
 
-This is the Claude half of lib/codex_reset.py: the scheduled limits pass redeems a
-reset when a limit the grant refills is at least 95% used, or when the server reports
-that limit exhausted. Two rules narrow that for Claude, because a Claude reset is ONE
-irreversible shot that refills the WEEK (support.claude.com "What is a limit reset?",
-2026-09-22: "Once you use it, you can't undo it"; "Your weekly limits still reset on
-their usual day and time"):
-
-* Only a WEEKLY limit (anything but ``five_hour``) triggers it. A full five-hour window
-  refills on its own within hours and the pool simply picks another account; spending
-  the week's refill on it throws nearly all of the reset away.
-* It is held while the account's own weekly reset is less than
-  ``CLAUDE_MULTIACC_RESET_MIN_HORIZON`` seconds away (default 24h): the week is about
-  to refill for free, and the grant is worth days of work later in its validity.
+This is the Claude half of lib/codex_reset.py, and it follows the operator's rule:
+an account the pool has PARKED on a window the grant refills gets its reset, so it goes
+back to work instead of sitting out the wall. Parked means exactly what the shim means
+by it — a bucket the grant clears at or above the pool's own exclusion threshold (90%
+by default, the manifest's `threshold`), a limit the server reports exhausted, or an
+active `.limited` park (a 429 the client received, or the app-robot panel's park) on
+such a window. The one hold: when every such park lifts on its own within
+``CLAUDE_MULTIACC_RESET_MIN_HORIZON`` seconds (default 1h), the reset is kept — a
+reset is one irreversible shot (support.claude.com "What is a limit reset?").
 
 What differs from codex beyond that is only the transport:
 
@@ -61,7 +57,7 @@ RESET_AT_USED_PERCENT = 95
 REDEEM_COOLDOWN_SECONDS = 900
 # Limit types that refill on their own within hours; never a reason to spend a reset.
 SESSION_LIMITS = frozenset({"five_hour"})
-DEFAULT_MIN_HORIZON_SECONDS = 86400
+DEFAULT_MIN_HORIZON_SECONDS = 3600
 # A claim whose response was lost is retried with the same request id while it is
 # younger than this, and dropped afterwards unless the status block proved it landed.
 PENDING_TTL_SECONDS = 3600
@@ -296,13 +292,51 @@ def _percent(grant: dict, usage: dict, limit_type: str) -> int | None:
     return None
 
 
-def reset_trigger(status: dict, grant: dict, usage: dict) -> tuple[list[str], list[str]]:
-    """(exhausted WEEKLY limits the grant refills, weekly limits it refills at >=95%)."""
-    clears = set(grant["clears"]) - SESSION_LIMITS
-    finished = sorted(clears & set(status["exhausted"]))
-    near = sorted(limit for limit in clears
-                  if (_percent(grant, usage, limit) or 0) >= RESET_AT_USED_PERCENT)
-    return finished, near
+def _lift_epoch(limit_type: str, status: dict, usage: dict) -> float | None:
+    """When a parked window refills on its own: the session window's reset, or the week's."""
+    if limit_type in SESSION_LIMITS:
+        for limit in (usage.get("limits") or []) if isinstance(usage, dict) else []:
+            if isinstance(limit, dict) and str(limit.get("kind") or "").startswith("session"):
+                found = _epoch(limit.get("resets_at"))
+                if found is not None:
+                    return found
+        bucket = usage.get("five_hour") if isinstance(usage, dict) else None
+        return _epoch(bucket.get("resets_at")) if isinstance(bucket, dict) else None
+    return _epoch(status.get("weekly_resets_at"))
+
+
+def _active_park(account_dir: str, now: float) -> tuple[str | None, float] | None:
+    """(limit type, lift epoch) of the account's `.limited` park, when it is a USAGE park
+    still in force and not already lifted by a reset on record; else None."""
+    try:
+        with open(os.path.join(account_dir, ".limited"), errors="replace") as handle:
+            text = handle.read(4096)
+        until = int(text.splitlines()[0])
+    except (OSError, ValueError, IndexError):
+        return None
+    if until <= now or not ("reason=limits" in text or "reason=client-rate-limit" in text):
+        return None
+    record = latest(record_from(_load(os.path.join(account_dir, "limits.json")), now),
+                    local_record(account_dir, now))
+    if marker_superseded(text, record):
+        return None
+    bucket = next((part[len("bucket="):] for part in text.split()
+                   if part.startswith("bucket=")), "")
+    return bucket_limit_type(bucket), float(until)
+
+
+def parked_on(status: dict, grant: dict, usage: dict, account_dir: str, threshold: int,
+              now: float) -> list[tuple[str, float | None]]:
+    """Every (limit type, when it lifts on its own) the pool parks this account on,
+    among the windows this grant refills."""
+    clears = set(grant["clears"])
+    parks = [(t, _lift_epoch(t, status, usage)) for t in sorted(clears & set(status["exhausted"]))]
+    parks += [(t, _lift_epoch(t, status, usage)) for t in sorted(clears)
+              if (_percent(grant, usage, t) or 0) >= threshold]
+    park = _active_park(account_dir, now)
+    if park and (park[0] == "*" or park[0] in clears):
+        parks.append(park)
+    return parks
 
 
 # ---- the reset record the whole fleet honours -------------------------------------
@@ -525,7 +559,8 @@ def _complete(state_path: str, pending: dict, outcome: str, now: int, cleared=No
 
 
 def try_auto_redeem(account_dir: str, account_id: str, usage: dict, status: dict | None,
-                    usage_url: str, headers: dict, say, now: int | None = None) -> dict:
+                    usage_url: str, headers: dict, say, now: int | None = None,
+                    threshold: int = RESET_AT_USED_PERCENT) -> dict:
     """Redeem one reset when policy says so and return a non-secret outcome document."""
     current = int(now if now is not None else time.time())
     if not auto_reset_enabled():
@@ -558,7 +593,7 @@ def try_auto_redeem(account_dir: str, account_id: str, usage: dict, status: dict
         return {"status": "cooldown", "outcome": state.get("outcome")}
     if not status["eligible"]:
         reason = status["ineligible_reason"] or "unknown"
-        if reason in _REQUEST_SIDE_REASONS and _usage_peak(usage) >= RESET_AT_USED_PERCENT:
+        if reason in _REQUEST_SIDE_REASONS and _usage_peak(usage) >= threshold:
             # Not a fact about the account: the server would not answer THIS client. On the
             # one machine that can redeem, that silently turns redemption off fleet-wide.
             say(f"{account_id}: limit-reset status refused for this client ({reason}; "
@@ -571,20 +606,20 @@ def try_auto_redeem(account_dir: str, account_id: str, usage: dict, status: dict
     grant = _usable_grant(status, current)
     if grant is None:
         return {"status": "no_credit"}
-    finished, near = reset_trigger(status, grant, usage)
-    if not finished and not near:
+    parks = parked_on(status, grant, usage, account_dir, threshold, current)
+    if not parks:
         return {"status": "not_eligible"}
+    parked = sorted({t for t, _ in parks})
     if grant["blocking"]:
         # The client's own rule: a limit this grant does not refill is exhausted too,
         # so refilling the others would not let the account work.
         return {"status": "not_eligible", "reason": "blocked",
                 "blocking": grant["blocking"]}
-    if grant["use_requires_limit"] and not finished:
+    if grant["use_requires_limit"] and not set(grant["clears"]) & set(status["exhausted"]):
         return {"status": "not_eligible", "reason": "waiting_for_limit"}
-    natural = _epoch(status["weekly_resets_at"])
-    if natural is not None and natural - current < min_horizon():
-        say(f"{account_id}: limit reset held — {', '.join(finished or near)} is at its "
-            f"limit but the week refills on its own at {status['weekly_resets_at']}")
+    if all(lift is not None and lift - current < min_horizon() for _, lift in parks):
+        say(f"{account_id}: limit reset held — parked on {', '.join(parked)}, which "
+            f"lifts on its own within {min_horizon() // 60} minutes")
         return {"status": "not_eligible", "reason": "natural_reset_soon"}
     org = organization_uuid(account_dir)
     url = claim_url(usage_url, org) if org else None
@@ -600,7 +635,7 @@ def try_auto_redeem(account_dir: str, account_id: str, usage: dict, status: dict
                  "request_id": request_id(org, account_uuid(account_dir) or account_id,
                                           grant, status),
                  "resets_left_before": grant["resets_left"], "started_at": current,
-                 "clears": grant["clears"], "trigger": finished or near}
+                 "clears": grant["clears"], "trigger": parked}
         _write(state_path, state)
     payload = {"program": PROGRAM, "grant_id": state["grant_id"],
                "request_id": state["request_id"]}
@@ -631,8 +666,7 @@ def try_auto_redeem(account_dir: str, account_id: str, usage: dict, status: dict
     left = _count(response.get("resets_left"))
     if outcome in {"reset", "already_used"}:
         said = "redeemed" if outcome == "reset" else "already redeemed"
-        say(f"{account_id}: limit reset {said} automatically "
-            f"({', '.join(finished or near)} at limit)")
+        say(f"{account_id}: limit reset {said} automatically (parked on {', '.join(parked)})")
         return _complete(state_path, state, outcome, current, cleared, left)
     if outcome == "unavailable":
         say(f"{account_id}: limit reset not confirmed (server unavailable); retry is idempotent")
@@ -648,7 +682,8 @@ def try_auto_redeem(account_dir: str, account_id: str, usage: dict, status: dict
     return {"status": outcome}
 
 
-def refresh_reset_credits(account_dir, account_id, usage, usage_url, headers, say, now):
+def refresh_reset_credits(account_dir, account_id, usage, usage_url, headers, say, now,
+                          threshold=RESET_AT_USED_PERCENT):
     """Read the allowance from this pass's usage response, redeem if due, report both.
 
     The view reported after a claim is the server's own post-claim count (the claim
@@ -658,7 +693,7 @@ def refresh_reset_credits(account_dir, account_id, usage, usage_url, headers, sa
     status = parse_status(usage)
     view = credits_view(status, now)
     result = try_auto_redeem(account_dir, account_id, usage, status, usage_url, headers,
-                             say, now)
+                             say, now, threshold)
     if result.get("status") == "redeemed":
         left = result.get("resets_left")
         if view and type(left) is int:

package/lib/codex_reset.py

@@ -22,6 +22,23 @@ from codex_reset_windows import reset_windows
 RESET_AT_USED_PERCENT = 95
 REDEEM_COOLDOWN_SECONDS = 900
 STATE_FILE = ".usage-reset.json"
+# A park that lifts on its own within this long keeps the credit (operator rule,
+# 2026-09-22: a PARKED account uses its reset; only a sub-hour wall is not worth one).
+PARK_HOLD_SECONDS = 3600
+
+
+def _active_park(account_dir: str, now: int) -> int | None:
+    """The epoch a USAGE park on this account lifts at (a >=threshold pass, or a 429 the
+    client received), or None. Error cool-downs and expired markers are not parks."""
+    try:
+        with open(os.path.join(account_dir, ".limited"), errors="replace") as handle:
+            text = handle.read(4096)
+        until = int(text.splitlines()[0])
+    except (OSError, ValueError, IndexError):
+        return None
+    if until <= now or not ("reason=limits" in text or "reason=client-rate-limit" in text):
+        return None
+    return until
 
 
 def auto_reset_enabled() -> bool:
@@ -111,11 +128,20 @@ def _redeem_request_id(account_id: str, usage: dict, headers: dict, now: int) ->
 
 def try_auto_redeem(account_dir: str, account_id: str, used_percent: int,
                     usage: dict, usage_url: str, headers: dict, say,
-                    now: int | None = None, credit_details: dict | None = None) -> dict:
-    """Redeem one available reset and return a non-secret outcome document."""
+                    now: int | None = None, credit_details: dict | None = None,
+                    threshold: int = RESET_AT_USED_PERCENT) -> dict:
+    """Redeem one available reset and return a non-secret outcome document.
+
+    Eligible whenever the pool has PARKED the account: a window at/over the pool's own
+    exclusion threshold (90 by default — the 95% line left accounts at 90-94% parked for
+    days with credits unused), a finished limit, or an active usage park that lifts more
+    than PARK_HOLD_SECONDS from now (a 429 the telemetry may not show)."""
     current = int(now if now is not None else time.time())
     finished, _ = reset_windows(usage, RESET_AT_USED_PERCENT)
-    if not auto_reset_enabled() or (used_percent < RESET_AT_USED_PERCENT and not finished):
+    park = _active_park(account_dir, current)
+    parked = park is not None and park - current >= PARK_HOLD_SECONDS
+    if not auto_reset_enabled() or (used_percent < min(threshold, RESET_AT_USED_PERCENT)
+                                     and not finished and not parked):
         return {"status": "not_eligible"}
     state, disposition = _pending_request(account_dir, current)
     if disposition == "cooldown":
@@ -151,7 +177,8 @@ def try_auto_redeem(account_dir: str, account_id: str, used_percent: int,
                     "redeemed_at": current, "suppress_until": current + REDEEM_COOLDOWN_SECONDS,
                     "windows_reset": int(response.get("windows_reset") or 0)}
         _write(os.path.join(account_dir, STATE_FILE), complete)
-        say(f"{account_id}: usage reset redeemed automatically at {used_percent}% used")
+        say(f"{account_id}: usage reset redeemed automatically at {used_percent}% used"
+            + ("" if used_percent >= threshold or finished else " (parked by a client-reported limit)"))
         return {"status": "redeemed", "outcome": outcome,
                 "windows_reset": complete["windows_reset"], "redeemed_at": current}
     try:

package/lib/codex_reset_telemetry.py

@@ -18,7 +18,8 @@ def _read_credits(url, headers, account_id, say):
         return {}, {}
 
 
-def refresh_reset_credits(account_dir, account_id, used_percent, usage, usage_url, headers, say, now):
+def refresh_reset_credits(account_dir, account_id, used_percent, usage, usage_url, headers, say, now,
+                          threshold=None):
     """Read all accounts, share the GET with redemption, then read back after a mutation.
 
     Failed reads omit the count; neither an embedded summary nor subtraction proves
@@ -27,8 +28,9 @@ def refresh_reset_credits(account_dir, account_id, used_percent, usage, usage_ur
     """
     list_url, _ = _reset_urls(usage_url)
     details, view = _read_credits(list_url, headers, account_id, say)
+    extra = {} if threshold is None else {"threshold": threshold}
     result = try_auto_redeem(account_dir, account_id, used_percent, usage, usage_url,
-                             headers, say, now, credit_details=details)
+                             headers, say, now, credit_details=details, **extra)
     if result.get("status") not in {"not_eligible", "cooldown", "no_credit", "error"}:
         _, view = _read_credits(list_url, headers, account_id, say)
     return result, view

package/package.json

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

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()
@@ -463,6 +513,27 @@ class ClaudeResetReviewRegressionTest(ClaudePoolSandbox, unittest.TestCase):
         self.assertFalse(marker.exists())
         self.assertIn("limit reset observed", self.log())
 
+    def test_an_observed_reset_lifts_a_5h_park_only_on_a_measured_session(self) -> None:
+        # The reset is only SEEN at this pass, later than it happened: a five-hour park
+        # taken in between may be real post-reset exhaustion, and a silent session bucket
+        # cannot disprove it. A weekly park in the same gap cannot be (review, 2026-09-22).
+        self.server.state["usage"] = usage_doc(fable=96)
+        self.run_limits(CLAUDE_MULTIACC_AUTO_RESET="0")
+        marked = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime(time.time() - 30))
+        park = self.account / ".limited"
+        park.write_text(f"{int(time.time()) + 3600}\nbucket=client:five_hour percent=100 "
+                        f"marked_at={marked} reason=client-rate-limit\n", encoding="utf-8")
+        self.server.state["usage"] = usage_doc(fable=2, resets_left=0)   # session silent
+        self.run_limits()
+        doc = self.limits_doc()
+        self.assertEqual(doc["reset_cleared"], "seven_day,seven_day_overage_included")
+        self.assertTrue(park.exists())
+        # ...while a weekly park from the same gap is lifted by the same record.
+        park.write_text(f"{int(time.time()) + 3 * 86400}\nbucket=client:seven_day percent=100 "
+                        f"marked_at={marked} reason=client-rate-limit\n", encoding="utf-8")
+        self.run_limits()
+        self.assertFalse(park.exists())
+
     def test_an_expired_grant_is_never_read_as_a_reset(self) -> None:
         self.server.state["usage"] = usage_doc(fable=96)
         self.run_limits(CLAUDE_MULTIACC_AUTO_RESET="0")

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,