claude-multiacc 2.0.37 → 2.0.39

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/lib/common.sh

@@ -685,6 +685,23 @@ codex_share_state_index() { # $1 acct dir — seed time: whatever index names ex
 #           shared sessions/ symlink (=> `codex resume` finds every session) with the
 #           shared rollout index that tree needs, and a shared AGENTS.md symlink so
 #           global instructions apply under any account.
+# MCP servers for EVERY account (lib/mcp_registry.py). Both clients keep MCP servers in
+# the CONFIG DIR (`<dir>/.claude.json`, `<CODEX_HOME>/config.toml`), so under the pool
+# there is one MCP configuration per account and a stock `claude mcp add` lands in ONE
+# random one. The pool's registry (mcp-servers.json, synced) plus the machine-local
+# overlay (mcp-servers.local.json, never synced) are reconciled into every account here,
+# at seed time, and by the shims right before exec. Fail-open: a seed never dies on it.
+seed_mcp_registry() { # $1 = acct dir
+  local d="$1" off
+  if [ "$MULTIACC_PROVIDER" = "codex" ]; then off="${CODEX_MULTIACC_MCP:-1}"; else off="${CLAUDE_MULTIACC_MCP:-1}"; fi
+  [ "$off" = "0" ] && return 0
+  [ -f "$ACC_ROOT/mcp-servers.json" ] || [ -f "$ACC_ROOT/mcp-servers.local.json" ] || return 0
+  [ -f "$LIB_DIR/mcp_registry.py" ] || return 0
+  "$PYBIN" "$LIB_DIR/mcp_registry.py" --root "$ACC_ROOT" --provider "$MULTIACC_PROVIDER" apply \
+    --account-dir "$d" --fail-open --quiet >/dev/null || true
+  return 0
+}
+
 seed_account_dir() { # $1 = acct dir
   local d="$1"
   mkdir -p "$d"
@@ -704,6 +721,7 @@ seed_account_dir() { # $1 = acct dir
       ln -s "$HOME/.codex/AGENTS.md" "$d/AGENTS.md" 2>/dev/null || true
     fi
     codex_share_state_index "$d"
+    seed_mcp_registry "$d"
     return 0
   fi
   if [ ! -f "$d/.claude.json" ] && [ -f "$HOME/.claude.json" ]; then
@@ -730,6 +748,7 @@ PYEOF
   if [ ! -e "$d/projects" ] && [ -d "$HOME/.claude/projects" ]; then
     ln -s "$HOME/.claude/projects" "$d/projects" 2>/dev/null || true
   fi
+  seed_mcp_registry "$d"
 }
 
 # Short-lived mutation lock: serialize only the brief critical sections (id reservation,