usage-cli 0.34.14__tar.gz → 0.34.15__tar.gz

{usage_cli-0.34.14/usage_cli.egg-info → usage_cli-0.34.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: usage-cli
-Version: 0.34.14
+Version: 0.34.15
 Summary: usage — 在 macOS menu bar 與 Windows 系統匣顯示 Claude Code、Codex、Antigravity 用量的小工具（也提供終端機 TUI）
 License-Expression: AGPL-3.0-only
 Requires-Python: >=3.13

{usage_cli-0.34.14 → usage_cli-0.34.15}/loaders/agy_quota_probe.py

@@ -34,6 +34,7 @@ from typing import Any
 from urllib.error import HTTPError, URLError
 from urllib.request import Request, urlopen
 
+from loaders.cache_quarantine import quarantine
 from usage_common.cli_lookup import cli_env, resolve_cli
 from usage_common.network import google_auth_reachable
 from usage_common.subprocess_utils import hidden_console_kwargs
@@ -86,6 +87,9 @@ _cli_retry_after_monotonic = 0.0
 # When each group last appeared in a real API response; in memory only, reset on restart.
 _group_seen_at: dict[str, datetime] = {}
 _MISSING_GROUP_GRACE_MINUTES = 30
+# Models omit the period; keep known weekly resets weekly near expiry.
+# In memory only: after restart, unseen resets use the time heuristic again.
+_weekly_reset_times: set[str] = set()
 
 
 def _user_agent() -> str:
@@ -527,6 +531,7 @@ def _post_json(url: str, access_token: str, body: dict[str, object], timeout: fl
     except HTTPError as exc:
         _handle_http_error(exc)
         if exc.code == 401:
+            _token_cache.clear()
             _mark_auth_expired()
         return None
     except (URLError, OSError, ValueError):
@@ -637,7 +642,13 @@ def _gemini_group_from_models(raw: object) -> AgyQuotaGroup | None:
     window = _bucket_to_window(bucket)
     reset = _bucket_reset_time(bucket)
     assert reset is not None
-    session = _seconds_until(reset) <= 5 * 3600 + 5 * 60
+    _weekly_reset_times.difference_update(
+        [seen for seen in _weekly_reset_times if _seconds_until(seen) <= 0]
+    )
+    session = reset not in _weekly_reset_times and _seconds_until(reset) <= 5 * 3600 + 5 * 60
+    # A full bucket's reset time slides with every response, so only a spent one is remembered.
+    if not session and window is not None and window.remaining_percent < 100.0:
+        _weekly_reset_times.add(reset)
     template = _assemble_groups({"gemini": {}})[0]
     return AgyQuotaGroup(
         name=template.name,
@@ -825,7 +836,14 @@ def _read_cache() -> AgyQuotaResult | None:
     try:
         with CACHE_PATH.open(encoding="utf-8") as cache_file:
             payload: object = json.load(cache_file)
-    except (OSError, json.JSONDecodeError):
+    except (UnicodeDecodeError, json.JSONDecodeError) as exc:
+        quarantine(
+            CACHE_PATH, "decode-error" if isinstance(exc, UnicodeDecodeError) else "json-error"
+        )
+        with suppress(OSError):
+            CACHE_PATH.unlink()
+        return None
+    except OSError:
         return None
     return _result_from_payload(payload)
 

{usage_cli-0.34.14 → usage_cli-0.34.15}/menubar/agy.py

@@ -59,6 +59,7 @@ class AgyQuotaProjection:
     five_hour: AgyQuotaWindow | None
     group_switchable: bool = False
     weekly_only: bool = False
+    gemini_five_hour: AgyQuotaWindow | None = None
 
 
 @dataclass(frozen=True, slots=True)
@@ -162,6 +163,10 @@ def project_quota(
         weekly=weekly,
         stale=stale,
         five_hour=selected.five_hour,
+        gemini_five_hour=next(
+            (group.five_hour for group in quota.groups if _matches_group(group.name, "gemini")),
+            None,
+        ),
     )
 
 

{usage_cli-0.34.14 → usage_cli-0.34.15}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "usage-cli"
-version = "0.34.14"
+version = "0.34.15"
 description = "usage — 在 macOS menu bar 與 Windows 系統匣顯示 Claude Code、Codex、Antigravity 用量的小工具（也提供終端機 TUI）"
 readme = "README.md"
 requires-python = ">=3.13"

{usage_cli-0.34.14 → usage_cli-0.34.15}/quota/agy_window_keeper.py

@@ -118,7 +118,7 @@ def maybe_ping(result: AgyRefreshResult, mock: bool) -> None:
     if not enabled:
         return
     projection = result.projection
-    five_hour = projection.five_hour if projection is not None else None
+    five_hour = projection.gemini_five_hour if projection is not None else None
     now = time.time()
     last_ping_at = _load_last_ping()
     state = keeper_outcome.read_state(AGY_WINDOW_KEEPER_STATE_PATH)

{usage_cli-0.34.14 → usage_cli-0.34.15}/tests/test_agy_quota_probe.py

@@ -21,7 +21,7 @@ from urllib.request import Request
 
 import pytest
 
-from loaders import agy_quota_probe
+from loaders import agy_quota_probe, cache_quarantine
 from loaders.agy_quota_probe import (
     AgyQuotaGroup,
     AgyQuotaResult,
@@ -111,12 +111,14 @@ def _reset_token_cache(monkeypatch: pytest.MonkeyPatch) -> Iterator[None]:
     agy_quota_probe._rate_limit_until_monotonic = 0.0
     agy_quota_probe._cli_retry_after_monotonic = 0.0
     agy_quota_probe._group_seen_at.clear()
+    agy_quota_probe._weekly_reset_times.clear()
     monkeypatch.setattr(agy_quota_probe, "_read_macos_credential", lambda: None)
     yield
     agy_quota_probe._token_cache.clear()
     agy_quota_probe._rate_limit_until_monotonic = 0.0
     agy_quota_probe._cli_retry_after_monotonic = 0.0
     agy_quota_probe._group_seen_at.clear()
+    agy_quota_probe._weekly_reset_times.clear()
 
 
 # --- find_agy (unchanged behavior) -----------------------------------------
@@ -683,6 +685,36 @@ def test_load_quota_returns_fresh_cache_without_probing(
     assert agy_quota_probe.load_quota() == cached
 
 
+@pytest.mark.parametrize(
+    "contents,reason", [(b"\xff", "decode-error"), (b"{", "json-error"), (None, None)]
+)
+def test_load_quota_probes_after_corrupt_or_missing_cache(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path, contents: bytes | None, reason: str | None
+) -> None:
+    cache_path = tmp_path / "agy_quota_cache.json"
+    quarantine_dir = tmp_path / "quarantine"
+    monkeypatch.setattr(agy_quota_probe, "CACHE_PATH", cache_path)
+    monkeypatch.setattr(cache_quarantine, "QUARANTINE_DIR", quarantine_dir)
+    if contents is not None:
+        cache_path.write_bytes(contents)
+    calls: list[tuple[Path, str]] = []
+    quarantine = cache_quarantine.quarantine
+
+    def record_quarantine(path: Path, why: str) -> None:
+        calls.append((path, why))
+        quarantine(path, why)
+
+    monkeypatch.setattr(agy_quota_probe, "quarantine", record_quarantine)
+    fresh = _result(datetime.now(UTC))
+    monkeypatch.setattr(agy_quota_probe, "probe_quota", lambda: fresh)
+
+    assert agy_quota_probe.load_quota() == fresh
+    assert calls == ([(cache_path, reason)] if reason is not None else [])
+    backups = list(quarantine_dir.glob("*.bak"))
+    assert [backup.read_bytes() for backup in backups] == ([contents] if contents else [])
+    assert agy_quota_probe._read_cache() == fresh
+
+
 def test_load_quota_probes_when_cache_is_stale(
     monkeypatch: pytest.MonkeyPatch,
     tmp_path: Path,
@@ -748,6 +780,24 @@ def test_auth_expiration_marker(
     assert agy_quota_probe.auth_expired() is expired
 
 
+def test_quota_401_clears_cached_token(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:
+    token_path = tmp_path / "antigravity-oauth-token"
+    _write_token(token_path, access_token="new-token")
+    monkeypatch.setattr(agy_quota_probe, "_TOKEN_PATH", token_path)
+    agy_quota_probe._token_cache.update(
+        access_token="rejected-token", expires_monotonic=time.monotonic() + 3600
+    )
+    urlopen, visited = _build_http_error_urlopen(401)
+    monkeypatch.setattr(agy_quota_probe, "urlopen", urlopen)
+
+    token = agy_quota_probe._resolve_access_token(1)
+    assert token == "rejected-token"
+    assert agy_quota_probe._post_json(_QUOTA_URL, token, {}, 1) is None
+    assert visited == [(_QUOTA_URL, "Bearer rejected-token")]
+    assert agy_quota_probe._token_cache == {}
+    assert agy_quota_probe._resolve_access_token(1) == "new-token"
+
+
 def test_successful_probe_clears_expiration_marker(monkeypatch: pytest.MonkeyPatch) -> None:
     result = AgyQuotaResult(groups=[], fetched_at=datetime.now(UTC).isoformat())
     agy_quota_probe.AUTH_EXPIRED_PATH.touch()
@@ -916,6 +966,23 @@ def test_probe_models_fallback_selects_lowest_gemini(
     ]
 
 
+def test_models_fallback_keeps_weekly_reset_near_expiry(monkeypatch: pytest.MonkeyPatch) -> None:
+    reset = (datetime.now(UTC) + timedelta(hours=6)).isoformat()
+    raw = {
+        "models": {"gemini-flash": {"quotaInfo": {"remainingFraction": 0.5, "resetTime": reset}}}
+    }
+    seconds_left = 6 * 3600
+    monkeypatch.setattr(agy_quota_probe, "_seconds_until", lambda _: seconds_left)
+
+    first = agy_quota_probe._gemini_group_from_models(raw)
+    assert first is not None and first.weekly is not None and first.five_hour is None
+
+    seconds_left = 5 * 3600 + 5 * 60
+    refreshed = agy_quota_probe._gemini_group_from_models(raw)
+    assert refreshed is not None and refreshed.weekly is not None
+    assert refreshed.five_hour is None
+
+
 @pytest.mark.parametrize(
     "models",
     [None, {"models": {}}, {"models": {"claude": {"quotaInfo": {"resetTime": _FUTURE_RESET}}}}],

{usage_cli-0.34.14 → usage_cli-0.34.15}/tests/test_agy_window_keeper.py

@@ -8,13 +8,14 @@ import shutil
 import subprocess
 import sys
 import threading
+from datetime import UTC, datetime
 from pathlib import Path
 from typing import Any, cast
 
 import pytest
 
 import quota.agy_window_keeper as agy_window_keeper
-from loaders.agy_quota_probe import AgyQuotaWindow
+from loaders.agy_quota_probe import AgyQuotaGroup, AgyQuotaResult, AgyQuotaWindow
 from menubar import agy as menubar_agy
 from menubar.state import AgyStaleState, QuotaRowState
 from quota import keeper_outcome
@@ -158,6 +159,7 @@ def _refresh_result(
         weekly=row,
         stale=stale,
         five_hour=AgyQuotaWindow(remaining, None, resets_in_minutes),
+        gemini_five_hour=AgyQuotaWindow(remaining, None, resets_in_minutes),
     )
     return menubar_agy.AgyRefreshResult(projection=projection, hide_agy=False)
 
@@ -197,6 +199,38 @@ def test_maybe_ping_fires_and_stamps_dispatch(
     assert _SyncThread.instances[0].daemon is True
 
 
+@pytest.mark.parametrize("preference", ["claude_gpt", "argon"])
+@pytest.mark.parametrize("gemini_remaining", [None, 45.0, 100.0])
+def test_maybe_ping_uses_gemini_window_regardless_of_display(
+    monkeypatch: pytest.MonkeyPatch,
+    isolated_state: Path,
+    preference: str,
+    gemini_remaining: float | None,
+) -> None:
+    calls = _arm_ping(monkeypatch)
+    displayed = AgyQuotaWindow(100.0 if gemini_remaining != 100.0 else 45.0, None, 120)
+    groups = [
+        AgyQuotaGroup("CLAUDE AND GPT MODELS", [], None, displayed),
+        AgyQuotaGroup("GEMINI 4 ARGON", [], displayed, None),
+    ]
+    if gemini_remaining is not None:
+        groups.insert(
+            0,
+            AgyQuotaGroup("GEMINI MODELS", [], None, AgyQuotaWindow(gemini_remaining, None, 120)),
+        )
+    quota = AgyQuotaResult(groups, datetime.now(UTC).isoformat())
+    projection = menubar_agy.project_quota(quota, "en", group_preference=preference)
+    assert projection is not None
+    assert projection.group_name == groups[-1 if preference == "argon" else -2].name
+    assert projection.five_hour == (None if preference == "argon" else displayed)
+
+    agy_window_keeper.maybe_ping(
+        menubar_agy.AgyRefreshResult(projection=projection, hide_agy=False), mock=False
+    )
+
+    assert calls == (["/fake/agy"] if gemini_remaining == 100.0 else [])
+
+
 def test_maybe_ping_disabled_has_no_side_effects(
     monkeypatch: pytest.MonkeyPatch, isolated_state: Path
 ) -> None:

{usage_cli-0.34.14 → usage_cli-0.34.15}/tests/test_keeper_outcome.py

@@ -252,7 +252,7 @@ def test_other_keepers_retry_once_without_active_window(
     else:
         monkeypatch.setattr(module, "_agy_window_keeper_enabled", lambda: True)
         window = SimpleNamespace(remaining_percent=100)
-        result = SimpleNamespace(projection=SimpleNamespace(five_hour=window, stale=None))
+        result = SimpleNamespace(projection=SimpleNamespace(gemini_five_hour=window, stale=None))
 
         def dispatch() -> None:
             module.maybe_ping(result, False)
@@ -387,7 +387,9 @@ def test_warning_across_windows(
     )
     if tool == "codex":
         monkeypatch.setattr(module, "load_rate_limits", lambda: limits)
-    projection = SimpleNamespace(five_hour=SimpleNamespace(remaining_percent=100), stale=None)
+    projection = SimpleNamespace(
+        gemini_five_hour=SimpleNamespace(remaining_percent=100), stale=None
+    )
     clock = [1000.0]
     monkeypatch.setattr(time, "time", lambda: clock[0])
     result = [subprocess.CompletedProcess([], 2, "", "login")]

usage_cli-0.34.15/tests/test_network.py

@@ -0,0 +1,97 @@
+# SPDX-License-Identifier: AGPL-3.0-only
+# Copyright (C) 2026 lollapalooza <https://github.com/aqua5230>
+
+from __future__ import annotations
+
+import socket
+import threading
+import time
+import urllib.request
+
+import pytest
+
+from usage_common import network
+
+
+@pytest.fixture(autouse=True)
+def _no_proxy(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr(urllib.request, "getproxies", dict)
+
+
+class _Connection:
+    def __enter__(self) -> _Connection:
+        return self
+
+    def __exit__(self, *exc: object) -> None:
+        return None
+
+
+def test_reachable_when_connection_opens(monkeypatch: pytest.MonkeyPatch) -> None:
+    seen: list[tuple[tuple[str, int], float]] = []
+
+    def connect(address: tuple[str, int], timeout: float) -> _Connection:
+        seen.append((address, timeout))
+        return _Connection()
+
+    monkeypatch.setattr(socket, "create_connection", connect)
+
+    assert network.google_auth_reachable(timeout=1.5) is True
+    assert seen == [(("oauth2.googleapis.com", 443), 1.5)]
+
+
+@pytest.mark.parametrize("error", [socket.gaierror("no dns"), TimeoutError(), OSError("down")])
+def test_unreachable_when_connection_fails(monkeypatch: pytest.MonkeyPatch, error: OSError) -> None:
+    def connect(address: tuple[str, int], timeout: float) -> _Connection:
+        raise error
+
+    monkeypatch.setattr(socket, "create_connection", connect)
+
+    assert network.google_auth_reachable() is False
+
+
+def test_configured_proxy_counts_as_reachable(monkeypatch: pytest.MonkeyPatch) -> None:
+    def connect(address: tuple[str, int], timeout: float) -> _Connection:
+        raise AssertionError("a proxy-only network blocks the direct probe")
+
+    monkeypatch.setattr(urllib.request, "getproxies", lambda: {"https": "http://proxy:8080"})
+    monkeypatch.setattr(socket, "create_connection", connect)
+
+    assert network.google_auth_reachable() is True
+
+
+def test_hung_dns_returns_within_timeout(monkeypatch: pytest.MonkeyPatch) -> None:
+    entered = threading.Event()
+    release = threading.Event()
+    finished = threading.Event()
+
+    def resolve(*args: object, **kwargs: object) -> list[object]:
+        try:
+            entered.set()
+            release.wait()
+            raise socket.gaierror("no dns")
+        finally:
+            finished.set()
+
+    monkeypatch.setattr(socket, "getaddrinfo", resolve)
+    start = time.monotonic()
+    try:
+        assert network.google_auth_reachable(timeout=0.05) is False
+        assert entered.is_set()
+        assert time.monotonic() - start < 0.5
+    finally:
+        release.set()
+        assert finished.wait(0.5)
+
+
+def test_no_proxy_alone_keeps_the_probe(monkeypatch: pytest.MonkeyPatch) -> None:
+    seen: list[tuple[str, int]] = []
+
+    def connect(address: tuple[str, int], timeout: float) -> _Connection:
+        seen.append(address)
+        raise OSError("down")
+
+    monkeypatch.setattr(urllib.request, "getproxies", lambda: {"no": "localhost"})
+    monkeypatch.setattr(socket, "create_connection", connect)
+
+    assert network.google_auth_reachable() is False
+    assert seen == [("oauth2.googleapis.com", 443)]

{usage_cli-0.34.14 → usage_cli-0.34.15}/tests/test_usage_cli.py

@@ -1095,8 +1095,9 @@ def test_status_payload_antigravity_cache(monkeypatch: pytest.MonkeyPatch, age:
 def test_status_antigravity_unreadable_cache(content: str | None) -> None:
     if content is not None:
         agy_quota_probe.CACHE_PATH.write_bytes(content.encode("latin-1"))
+    # A corrupt cache is quarantined and dropped, so every case reads as no data.
     assert status_payload._status_antigravity(1_000_000) == status_payload._status_agent(
-        None, 1_000_000, "error" if content == "\xff" else "no_data"
+        None, 1_000_000, "no_data"
     )
 
 

{usage_cli-0.34.14 → usage_cli-0.34.15}/tests/test_wintray.py

@@ -3573,6 +3573,7 @@ def test_windows_auto_check_schedule_finishes(
 
 def test_windows_poll_loop_rechecks_each_hour(monkeypatch: pytest.MonkeyPatch) -> None:
     controller = wintray._WindowsTrayController(mock=True, interval=60)
+    controller.visible = True
     now = [0.0]
     ticks = iter([100.0, 3699.0, 3700.0])
     refreshes: list[float] = []
@@ -4113,12 +4114,85 @@ def test_hidden_poll_interval_with_quota_countdown(
     waits: list[float] = []
 
     def wait(interval: float) -> bool:
+        if controller.stopping.is_set():
+            return True
         waits.append(interval)
-        return True
+        return False
+
+    def refresh() -> None:
+        controller.stopping.set()
 
     monkeypatch.setattr(controller.stopping, "wait", wait)
+    monkeypatch.setattr(controller, "refresh", refresh)
+    monkeypatch.setattr(controller, "_clear_stale_update_cache", lambda: None)
     monkeypatch.setattr("wintray.app.time.time", lambda: 1000.0)
     controller._poll_loop()
 
-    assert waits == [expected_wait]
+    assert sum(waits) == expected_wait
     assert controller._poll_thread is None
+
+
+def test_hidden_poll_refreshes_once_after_countdown_ends(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    controller = wintray._WindowsTrayController(mock=True, interval=60)
+    controller.visible = False
+    controller.tray_provider = "claude"
+    controller.quota_label_enabled = True
+    state = _state()
+    full = replace(state.claude_weekly, percent=100, resets_at=11500.0)
+    controller.latest_state = replace(state, claude_weekly=full)
+    waits: list[float] = []
+
+    def wait(interval: float) -> bool:
+        if controller.stopping.is_set():
+            return True
+        waits.append(interval)
+        if len(waits) == 1:
+            # The quota resets mid-wait, so the countdown is gone on the next wake.
+            controller.latest_state = state
+        return False
+
+    def refresh() -> None:
+        controller.stopping.set()
+
+    monkeypatch.setattr(controller.stopping, "wait", wait)
+    monkeypatch.setattr(controller, "refresh", refresh)
+    monkeypatch.setattr(controller, "_clear_stale_update_cache", lambda: None)
+    monkeypatch.setattr("wintray.app.time.time", lambda: 1000.0)
+    controller._poll_loop()
+
+    assert waits == [60]
+
+
+def test_hidden_poll_refreshes_soon_after_countdown_starts(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    controller = wintray._WindowsTrayController(mock=True, interval=60)
+    controller.visible = False
+    controller.tray_provider = "claude"
+    controller.quota_label_enabled = True
+    state = _state()
+    controller.latest_state = state
+    waits: list[float] = []
+
+    def wait(interval: float) -> bool:
+        if controller.stopping.is_set():
+            return True
+        waits.append(interval)
+        if len(waits) == 1:
+            # A file event fills the weekly quota while the hidden loop is waiting.
+            full = replace(state.claude_weekly, percent=100, resets_at=11500.0)
+            controller.latest_state = replace(state, claude_weekly=full)
+        return False
+
+    def refresh() -> None:
+        controller.stopping.set()
+
+    monkeypatch.setattr(controller.stopping, "wait", wait)
+    monkeypatch.setattr(controller, "refresh", refresh)
+    monkeypatch.setattr(controller, "_clear_stale_update_cache", lambda: None)
+    monkeypatch.setattr("wintray.app.time.time", lambda: 1000.0)
+    controller._poll_loop()
+
+    assert waits == [60]

{usage_cli-0.34.14 → usage_cli-0.34.15/usage_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: usage-cli
-Version: 0.34.14
+Version: 0.34.15
 Summary: usage — 在 macOS menu bar 與 Windows 系統匣顯示 Claude Code、Codex、Antigravity 用量的小工具（也提供終端機 TUI）
 License-Expression: AGPL-3.0-only
 Requires-Python: >=3.13

{usage_cli-0.34.14 → usage_cli-0.34.15}/usage_common/network.py

@@ -9,6 +9,10 @@
 from __future__ import annotations
 
 import socket
+import threading
+import urllib.request
+from concurrent.futures import Future
+from concurrent.futures import TimeoutError as FutureTimeoutError
 
 # The host the Antigravity CLI refreshes its OAuth token against.
 _GOOGLE_AUTH_HOST = "oauth2.googleapis.com"
@@ -21,9 +25,27 @@ def google_auth_reachable(timeout: float = _PROBE_TIMEOUT_SECONDS) -> bool:
     Right after a sleep wake the network is often still down. The Antigravity CLI
     treats a failed token refresh as "not logged in" and opens a browser sign-in
     page, so callers skip launching it while this returns False.
+
+    A proxy-only network blocks this direct probe even though the CLI can connect
+    through the proxy, so a configured HTTPS proxy counts as reachable. A bare
+    ``NO_PROXY`` does not route anything through a proxy and keeps the probe.
     """
+    proxies = urllib.request.getproxies()
+    if proxies.get("https") or proxies.get("all"):
+        return True
+    result: Future[bool] = Future()
+
+    def probe() -> None:
+        try:
+            with socket.create_connection((_GOOGLE_AUTH_HOST, 443), timeout=timeout):
+                result.set_result(True)
+        except OSError:
+            result.set_result(False)
+        except BaseException as exc:
+            result.set_exception(exc)
+
+    threading.Thread(target=probe, daemon=True).start()
     try:
-        with socket.create_connection((_GOOGLE_AUTH_HOST, 443), timeout=timeout):
-            return True
-    except OSError:
+        return result.result(timeout=timeout)
+    except FutureTimeoutError:
         return False

{usage_cli-0.34.14 → usage_cli-0.34.15}/wintray/app.py

@@ -1437,12 +1437,18 @@ class _WindowsTrayController:
     def _poll_loop(self) -> None:
         current_thread = threading.current_thread()
         self._poll_thread = current_thread
+        waited = 0.0
+        fast = self._poll_fast()
         try:
-            while not self.stopping.wait(
-                self.interval
-                if self.visible or (self.quota_label_enabled and self._tray_countdown() is not None)
-                else max(self.interval, SLOW_POLL_INTERVAL_S)
-            ):
+            # Wake every interval even while hidden, so a countdown or panel that
+            # appears mid-wait refreshes promptly instead of after the slow interval.
+            # A countdown that just ended still gets one refresh to clear its label.
+            while not self.stopping.wait(self.interval):
+                waited += self.interval
+                was_fast, fast = fast, self._poll_fast()
+                if not (fast or was_fast) and waited < SLOW_POLL_INTERVAL_S:
+                    continue
+                waited = 0.0
                 self.refresh()
                 self._clear_stale_update_cache()
                 if self._auto_check_schedule.try_begin(time.time()):
@@ -1451,6 +1457,9 @@ class _WindowsTrayController:
             if self._poll_thread is current_thread:
                 self._poll_thread = None
 
+    def _poll_fast(self) -> bool:
+        return self.visible or (self.quota_label_enabled and self._tray_countdown() is not None)
+
     def _ensure_windows_watcher(self) -> None:
         if self.mock or self.stopping.is_set():
             return

usage_cli-0.34.14/tests/test_network.py

@@ -1,41 +0,0 @@
-# SPDX-License-Identifier: AGPL-3.0-only
-# Copyright (C) 2026 lollapalooza <https://github.com/aqua5230>
-
-from __future__ import annotations
-
-import socket
-
-import pytest
-
-from usage_common import network
-
-
-class _Connection:
-    def __enter__(self) -> _Connection:
-        return self
-
-    def __exit__(self, *exc: object) -> None:
-        return None
-
-
-def test_reachable_when_connection_opens(monkeypatch: pytest.MonkeyPatch) -> None:
-    seen: list[tuple[tuple[str, int], float]] = []
-
-    def connect(address: tuple[str, int], timeout: float) -> _Connection:
-        seen.append((address, timeout))
-        return _Connection()
-
-    monkeypatch.setattr(socket, "create_connection", connect)
-
-    assert network.google_auth_reachable(timeout=1.5) is True
-    assert seen == [(("oauth2.googleapis.com", 443), 1.5)]
-
-
-@pytest.mark.parametrize("error", [socket.gaierror("no dns"), TimeoutError(), OSError("down")])
-def test_unreachable_when_connection_fails(monkeypatch: pytest.MonkeyPatch, error: OSError) -> None:
-    def connect(address: tuple[str, int], timeout: float) -> _Connection:
-        raise error
-
-    monkeypatch.setattr(socket, "create_connection", connect)
-
-    assert network.google_auth_reachable() is False