claude-dev-env 8.75.2 → 8.75.3

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "claude-dev-env",
-    "version": "8.75.2",
+    "version": "8.75.3",
     "description": "Claude Code development standards — rules, hooks, agents, commands, and skills",
     "type": "module",
     "bin": {

package/scripts/account_broker_support.py

@@ -12,6 +12,7 @@ import subprocess
 import sys
 import tempfile
 import threading
+import time
 from contextlib import contextmanager
 from datetime import datetime, timezone
 from pathlib import Path, PureWindowsPath
@@ -37,6 +38,10 @@ from dev_env_scripts_constants.account_broker_constants import (
     CMD_SHELL_METACHARACTERS,
     Decision,
     JobOutcome,
+    METER_READ_ATTEMPTS,
+    METER_READ_DELAY_FACTOR,
+    METER_READ_FIRST_DELAY_SECONDS,
+    METER_READ_MAX_DELAY_SECONDS,
     Meters,
     Product,
     ProductAdapter,
@@ -210,12 +215,13 @@ def read_claude_meters(account: Account) -> Meters | None:
         account: Account whose meter is read.
 
     Returns:
-        Its meters, or None when the probe fails.
+        Its meters.
+
+    Raises:
+        WeeklyUtilizationProbeError: The usage meters could not be measured.
+        OSError: The credentials file could not be read.
     """
-    try:
-        usage = probe_account_meters(account.home / CREDENTIALS_FILE_NAME)
-    except (WeeklyUtilizationProbeError, OSError):
-        return None
+    usage = probe_account_meters(account.home / CREDENTIALS_FILE_NAME)
     return Meters(
         FULL_PERCENT - usage.session_utilization if usage.session_utilization is not None else None,
         usage.session_resets_at,
@@ -231,17 +237,14 @@ def read_codex_account_meters(account: Account) -> Meters:
         account: Account whose meter is read.
 
     Returns:
-        Its meters, read again once when the first read fails.
+        Its meters.
 
     Raises:
-        CodexMeterUnreadError: Both reads failed; the message is the second failure.
+        CodexMeterUnreadError: The meter read failed.
         OSError: No Codex executable was found.
     """
     codex_path = codex_account_meters.resolve_codex_path(None)
-    try:
-        usage = codex_account_meters.read_codex_meters(codex_path, account.home)
-    except codex_account_meters.CodexMeterUnreadError:
-        usage = codex_account_meters.read_codex_meters(codex_path, account.home)
+    usage = codex_account_meters.read_codex_meters(codex_path, account.home)
     weekly = [window for window in usage.all_windows if window.duration_minutes is None or window.duration_minutes >= WEEKLY_WINDOW_MINUTES]
     short = [window for window in usage.all_windows if window.duration_minutes is not None and window.duration_minutes < WEEKLY_WINDOW_MINUTES]
     weekly_window = max(weekly, key=lambda window: window.used_percent) if weekly else None
@@ -254,6 +257,35 @@ def read_codex_account_meters(account: Account) -> Meters:
     )
 
 
+def read_meters_with_backoff(read_meters: Callable[[Account], Meters | None], account: Account) -> tuple[Meters | None, str | None]:
+    """Read one account's meters, retrying a failed read with exponential backoff.
+
+    Args:
+        read_meters: The product's meter reader.
+        account: Account whose meter is read.
+
+    Returns:
+        The meters from the first read that succeeds, or None with the last
+        failure text once every attempt failed.
+    """
+    unread_reason = None
+    for each_attempt in range(METER_READ_ATTEMPTS):
+        if each_attempt:
+            time.sleep(min(METER_READ_FIRST_DELAY_SECONDS * METER_READ_DELAY_FACTOR ** (each_attempt - 1), METER_READ_MAX_DELAY_SECONDS))
+        try:
+            return read_meters(account), None
+        except (
+            codex_account_meters.CodexMeterUnreadError,
+            WeeklyUtilizationProbeError,
+            OSError,
+            ValueError,
+            RuntimeError,
+            subprocess.SubprocessError,
+        ) as error:
+            unread_reason = str(error) or type(error).__name__
+    return None, unread_reason
+
+
 all_product_adapters = {
     Product.CLAUDE: ProductAdapter(load_claude_accounts, read_claude_meters, CLAUDE_CONFIG_DIR_ENV_VAR, ALL_USAGE_LIMIT_SIGNATURES),
     Product.CODEX: ProductAdapter(load_codex_accounts, read_codex_account_meters, CODEX_HOME_ENVIRONMENT_VARIABLE, codex_usage_limit_signatures()),
@@ -409,12 +441,7 @@ def _read_one_account(account: Account, adapter: ProductAdapter, all_cache: dict
     if isinstance(cached, dict) and isinstance(cached.get("read_at"), (int, float)) and 0 <= now.timestamp() - cached["read_at"] < 60:
         cached_reason = cached.get("unread_reason")
         return Reading(account, _meters_from_payload(cached.get("meters")), cached_reason if isinstance(cached_reason, str) else None), False
-    unread_reason = None
-    try:
-        meters = adapter.read_meters(account)
-    except (codex_account_meters.CodexMeterUnreadError, OSError, ValueError, RuntimeError, subprocess.SubprocessError) as error:
-        meters = None
-        unread_reason = str(error) or type(error).__name__
+    meters, unread_reason = read_meters_with_backoff(adapter.read_meters, account)
     all_cache[key] = {"read_at": now.timestamp(), "meters": _meter_payload(meters), "unread_reason": unread_reason}
     return Reading(account, meters, unread_reason), True
 

package/scripts/dev_env_scripts_constants/account_broker_constants.py

@@ -48,6 +48,10 @@ ALL_CODEX_FLOORS = {
     "luna_short_minimum_left": LUNA_TIER_SHORT_WINDOW_MINIMUM_PERCENT_LEFT,
 }
 
+METER_READ_ATTEMPTS = 3
+METER_READ_FIRST_DELAY_SECONDS = 1.0
+METER_READ_DELAY_FACTOR = 2.0
+METER_READ_MAX_DELAY_SECONDS = 8.0
 WAIT_EXIT_CODE = 3
 COMMAND_MISSING_EXIT_CODE = 127
 TIMEOUT_EXIT_CODE = 124

package/scripts/test_account_broker.py

@@ -10,6 +10,7 @@ from pathlib import Path
 import pytest
 
 import account_broker
+import account_broker_support
 import claude_account_worker
 from account_broker import (
     Account,
@@ -75,7 +76,8 @@ def _adapter(accounts: tuple[Account, ...], meters: dict[str, Meters | None]) ->
     )
 
 
-def test_should_name_the_unread_account_and_its_reason_when_no_account_has_room() -> None:
+def test_should_name_the_unread_account_and_its_reason_when_no_account_has_room(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr(account_broker_support.time, "sleep", lambda _: None)
     codex_3 = _account("codex-3")
     codex_4 = _account("codex-4")
 

package/scripts/test_account_broker_support.py

@@ -154,40 +154,113 @@ def _codex_meter_reads(
     return all_homes_read
 
 
-def test_should_read_codex_meters_again_after_one_failed_read(
+def _claude_meter_reads(monkeypatch: pytest.MonkeyPatch, all_outcomes: list[object]) -> list[Path]:
+    all_paths_read: list[Path] = []
+
+    def probe_account_meters(credentials_path: Path) -> object:
+        all_paths_read.append(credentials_path)
+        outcome = all_outcomes.pop(0)
+        if isinstance(outcome, Exception):
+            raise outcome
+        return outcome
+
+    monkeypatch.setattr(support, "probe_account_meters", probe_account_meters)
+    return all_paths_read
+
+
+def _recorded_sleeps(monkeypatch: pytest.MonkeyPatch) -> list[float]:
+    all_delays: list[float] = []
+    monkeypatch.setattr(support.time, "sleep", all_delays.append)
+    return all_delays
+
+
+def _first_reading(monkeypatch: pytest.MonkeyPatch, tmp_path: Path, account: Account, read_meters: object) -> object:
+    monkeypatch.setattr(support, "broker_state_path", lambda: tmp_path / "broker" / "state.json")
+    adapter = ProductAdapter(lambda: (account,), read_meters, "HOME", ())
+    state = support._load_state(support.broker_state_path())
+    now = datetime(2026, 10, 3, tzinfo=timezone.utc)
+    return support.read_accounts(account.product, adapter, all_state=state, now=now)[0], adapter, state, now
+
+
+def test_should_read_claude_meters_after_transient_failures_with_growing_delays(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    usage = SimpleNamespace(session_utilization=20.0, session_resets_at=None, weekly_utilization=30.0, weekly_resets_at=None)
+    unread = support.WeeklyUtilizationProbeError("usage endpoint timed out")
+    all_paths_read = _claude_meter_reads(monkeypatch, [unread, unread, usage])
+    all_delays = _recorded_sleeps(monkeypatch)
+
+    reading = _first_reading(monkeypatch, tmp_path, Account(Product.CLAUDE, "org-jon", tmp_path), support.read_claude_meters)[0]
+
+    assert reading.meters is not None
+    assert reading.meters.weekly_percent_left == 70.0
+    assert reading.unread_reason is None
+    assert len(all_paths_read) == 3
+    assert all_delays == [1.0, 2.0]
+
+
+def test_should_read_codex_meters_after_transient_failures_with_growing_delays(
     monkeypatch: pytest.MonkeyPatch, tmp_path: Path
 ) -> None:
     weekly = SimpleNamespace(duration_minutes=10080, used_percent=30.0, resets_at=None)
     usage = SimpleNamespace(all_windows=(weekly,), short_window_percent_left=None)
     unread = support.codex_account_meters.CodexMeterUnreadError("codex app-server sent no rate-limit reply")
-    all_homes_read = _codex_meter_reads(monkeypatch, tmp_path, [unread, usage])
+    all_homes_read = _codex_meter_reads(monkeypatch, tmp_path, [unread, unread, usage])
+    all_delays = _recorded_sleeps(monkeypatch)
 
-    meters = support.read_codex_account_meters(Account(Product.CODEX, "one", tmp_path))
+    reading = _first_reading(monkeypatch, tmp_path, Account(Product.CODEX, "one", tmp_path), support.read_codex_account_meters)[0]
 
-    assert meters is not None
-    assert meters.weekly_percent_left == 70.0
-    assert all_homes_read == [tmp_path, tmp_path]
+    assert reading.meters is not None
+    assert reading.meters.weekly_percent_left == 70.0
+    assert all_homes_read == [tmp_path, tmp_path, tmp_path]
+    assert all_delays == [1.0, 2.0]
 
 
-def test_should_keep_the_unread_reason_after_two_failed_codex_reads(
+def test_should_keep_the_unread_reason_after_every_claude_read_fails(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    all_failures = [support.WeeklyUtilizationProbeError(f"usage endpoint failed {each_number}") for each_number in range(3)]
+    all_paths_read = _claude_meter_reads(monkeypatch, all_failures)
+    all_delays = _recorded_sleeps(monkeypatch)
+
+    reading, adapter, state, now = _first_reading(monkeypatch, tmp_path, Account(Product.CLAUDE, "org-jon", tmp_path), support.read_claude_meters)
+    cached_reading = support.read_accounts(Product.CLAUDE, adapter, all_state=state, now=now)[0]
+
+    assert reading.meters is None
+    assert reading.unread_reason == "usage endpoint failed 2"
+    assert cached_reading.unread_reason == "usage endpoint failed 2"
+    assert len(all_paths_read) == 3
+    assert all_delays == [1.0, 2.0]
+
+
+def test_should_keep_the_unread_reason_after_every_codex_read_fails(
     monkeypatch: pytest.MonkeyPatch, tmp_path: Path
 ) -> None:
-    monkeypatch.setattr(support, "broker_state_path", lambda: tmp_path / "broker" / "state.json")
     first_unread = support.codex_account_meters.CodexMeterUnreadError("codex app-server failed: timed out")
-    second_unread = support.codex_account_meters.CodexMeterUnreadError("codex app-server sent no rate-limit reply")
-    all_homes_read = _codex_meter_reads(monkeypatch, tmp_path, [first_unread, second_unread])
-    account = Account(Product.CODEX, "codex-3", tmp_path)
-    adapter = ProductAdapter(lambda: (account,), support.read_codex_account_meters, "CODEX_HOME", ())
-    state = support._load_state(support.broker_state_path())
-    now = datetime(2026, 10, 3, tzinfo=timezone.utc)
+    last_unread = support.codex_account_meters.CodexMeterUnreadError("codex app-server sent no rate-limit reply")
+    all_homes_read = _codex_meter_reads(monkeypatch, tmp_path, [first_unread, first_unread, last_unread])
+    _recorded_sleeps(monkeypatch)
 
-    first_reading = support.read_accounts(Product.CODEX, adapter, all_state=state, now=now)[0]
+    reading, adapter, state, now = _first_reading(monkeypatch, tmp_path, Account(Product.CODEX, "codex-3", tmp_path), support.read_codex_account_meters)
     cached_reading = support.read_accounts(Product.CODEX, adapter, all_state=state, now=now)[0]
 
-    assert first_reading.meters is None
-    assert first_reading.unread_reason == "codex app-server sent no rate-limit reply"
+    assert reading.meters is None
+    assert reading.unread_reason == "codex app-server sent no rate-limit reply"
     assert cached_reading.unread_reason == "codex app-server sent no rate-limit reply"
-    assert all_homes_read == [tmp_path, tmp_path]
+    assert all_homes_read == [tmp_path, tmp_path, tmp_path]
+
+
+def test_should_cap_the_meter_read_delay(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:
+    monkeypatch.setattr(support, "METER_READ_ATTEMPTS", 6)
+    all_delays = _recorded_sleeps(monkeypatch)
+    all_failures = [support.WeeklyUtilizationProbeError("down") for _ in range(6)]
+    _claude_meter_reads(monkeypatch, all_failures)
+
+    meters, unread_reason = support.read_meters_with_backoff(support.read_claude_meters, Account(Product.CLAUDE, "one", tmp_path))
+
+    assert meters is None
+    assert unread_reason == "down"
+    assert all_delays == [1.0, 2.0, 4.0, 8.0, 8.0]
 
 
 def test_should_cache_account_reading_under_injected_state_path(