usage-cli 0.34.9__tar.gz → 0.34.10__tar.gz

{usage_cli-0.34.9/usage_cli.egg-info → usage_cli-0.34.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: usage-cli
-Version: 0.34.9
+Version: 0.34.10
 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.9 → usage_cli-0.34.10}/adapters/rate_limits.py

@@ -44,7 +44,7 @@ def _read_status() -> dict[str, Any] | None:
 
 def load_rate_limits() -> RateLimits | None:
     data = _read_status()
-    if data is None or not usage_client._has_complete_rate_limits(data):
+    if data is None or not usage_client._has_rate_limits(data):
         snapshot = usage_client.read_quota_fallback()
         if snapshot is not None:
             return _snapshot_rate_limits(snapshot)

{usage_cli-0.34.9 → usage_cli-0.34.10}/installer/setup_hook.py

@@ -86,7 +86,7 @@ PREV_SL_KEY = "previousStatusLine"
 # Where the status-line switch parks the live statusLine while it is off, so it
 # never overwrites the pre-install backup under PREV_SL_KEY.
 DISABLED_SL_KEY = "disabledStatusLine"
-HOOK_VERSION = "1.14"
+HOOK_VERSION = "1.16"
 FORWARDER_VERSION = "1.1"
 # Antigravity's Go runner hands its status-line command to cmd.exe unquoted, so
 # every character cmd.exe treats specially has to be kept out of the path.

{usage_cli-0.34.9 → usage_cli-0.34.10}/loaders/claude_usage.py

@@ -293,17 +293,19 @@ def _hook_broken_message(now: float, polled_at: float) -> str | None:
     return HOOK_BROKEN_NOT_INSTALLED
 
 
-def _has_complete_rate_limits(data: dict[str, Any]) -> bool:
+def _has_rate_limits(data: dict[str, Any]) -> bool:
+    """True when every window the hook sent is valid and at least one was sent.
+
+    Plans without a 5-hour limit never send five_hour, so requiring both windows
+    would leave them on the cache or the loading state forever. A window that is
+    present but unreadable still falls back to the cache.
+    """
     rl = data.get("rate_limits")
     if not isinstance(rl, dict):
         return False
-    five = rl.get("five_hour")
-    seven = rl.get("seven_day")
-    if not isinstance(five, dict) or not isinstance(seven, dict):
-        return False
-    return (
-        _as_finite_float(five.get("used_percentage")) is not None
-        and _as_finite_float(seven.get("used_percentage")) is not None
+    windows = [w for w in (rl.get("five_hour"), rl.get("seven_day")) if isinstance(w, dict)]
+    return bool(windows) and all(
+        _as_finite_float(w.get("used_percentage")) is not None for w in windows
     )
 
 
@@ -440,11 +442,11 @@ class ClaudeUsageClient:
 
         # ``.claude.json`` is Claude Code's cache, not a competing live source.
         # In particular its fetchedAtMs can be newer than the hook timestamp while
-        # still describing a different/expired session.  A complete statusLine
-        # payload must therefore always win; use the cache only when the hook has
-        # not provided both quota windows yet. Desktop history is also a fallback;
-        # it never replaces a complete hook payload or supplies invented resets.
-        if not _has_complete_rate_limits(data):
+        # still describing a different/expired session.  A statusLine payload
+        # with quota must therefore always win; use the cache only when the hook
+        # has not provided any quota window yet. Desktop history is also a fallback;
+        # it never replaces a hook payload or supplies invented resets.
+        if not _has_rate_limits(data):
             fallback_snapshot = read_quota_fallback(self._read_claude_json_snapshot_cached)
             if fallback_snapshot is not None:
                 return self._success_outcome(fallback_snapshot)

{usage_cli-0.34.9 → usage_cli-0.34.10}/menubar/app.py

@@ -189,7 +189,6 @@ __all__ = [
 ]
 
 UPDATE_ALERT_BODY_LIMIT = 2000
-SLOW_POLL_INTERVAL_S = 300.0
 
 logger = logging.getLogger(__name__)
 
@@ -317,7 +316,7 @@ class AppDelegate(NSObject):
 
         self._request_notification_authorization()
         self._refresh()
-        self._reschedule_poll_timer(max(self.interval, SLOW_POLL_INTERVAL_S))
+        self._reschedule_poll_timer(menubar_title.menubar_poll_interval(self, self.latest_state))
         self._fs_stream = setup_fsevents(self)
         self._history_source_tracker.set_incremental_enabled(self._fs_stream is not None)
         warm_up_pricing(self._refresh_after_pricing_warm_up)
@@ -378,7 +377,7 @@ class AppDelegate(NSObject):
 
     def _panel_window_did_hide(self) -> None:
         self.popover_controller.evictInactivePanelViews()
-        self._reschedule_poll_timer(max(self.interval, SLOW_POLL_INTERVAL_S))
+        self._reschedule_poll_timer(menubar_title.menubar_poll_interval(self, self.latest_state))
 
     def windowDidMove_(self, notification: Any) -> None:
         if notification.object() is self.popover and self._panel_window_is_visible():

{usage_cli-0.34.9 → usage_cli-0.34.10}/menubar/state.py

@@ -106,6 +106,7 @@ class QuotaRowState:
     available: bool = True
     reset_text_compact: str = ""
     reset_done: bool = False
+    resets_at: float | None = None
 
     # Keep percent unchanged for quota notifications; renderers use display_percent.
 
@@ -1083,6 +1084,7 @@ def _quota_row(
         warning=warning,
         available=True,
         reset_done=time_to_reset <= 0,
+        resets_at=resets_at,
     )
     if warning_seconds is not None:
         row.reset_text_compact = _t(

{usage_cli-0.34.9 → usage_cli-0.34.10}/menubar/title.py

@@ -8,6 +8,8 @@
 
 from __future__ import annotations
 
+import math
+import time
 from collections.abc import Callable
 from typing import Any, Protocol
 
@@ -27,7 +29,7 @@ from menubar.chrome import (
     _menubar_icon_attachment_string,
     _muse_menubar_icon,
 )
-from menubar.state import PopoverState, _format_percent
+from menubar.state import PopoverState, QuotaRowState, _format_percent
 
 
 class _TitleApp(Protocol):
@@ -36,6 +38,11 @@ class _TitleApp(Protocol):
     _last_button_title_key: tuple[str] | None
     _last_plain_title_key: tuple[str] | None
     status_item: Any
+    interval: float
+
+    def _reschedule_poll_timer(self, interval: float) -> None: ...
+
+    def _panel_window_is_visible(self) -> bool: ...
 
 
 _MENUBAR_FONT: Any = None
@@ -65,10 +72,43 @@ def _menubar_text_string(app: _TitleApp, text: str) -> Any:
 
 # A wider strip slides behind the notch; the panel still lists every source.
 _MENUBAR_MAX_ITEMS = 3
+SLOW_POLL_INTERVAL_S = 300.0
+
+
+def _format_countdown(seconds: float) -> str:
+    minutes = math.ceil(seconds / 60)
+    if minutes >= 1440:
+        return f"{minutes // 1440}d{minutes % 1440 // 60}h"
+    if minutes >= 60:
+        return f"{minutes // 60}h{minutes % 60}m"
+    return f"{minutes}m"
+
+
+def _quota_countdown(rows: tuple[QuotaRowState, ...], now: float) -> str | None:
+    full = [row for row in rows if row.display_percent is not None and row.display_percent >= 100]
+    if not full:
+        return None
+    resets = []
+    for row in full:
+        if row.resets_at is None or row.resets_at <= now:
+            return None
+        resets.append(row.resets_at)
+    return _format_countdown(max(resets) - now)
+
+
+def menubar_poll_interval(app: _TitleApp, state: PopoverState) -> float:
+    if app._panel_window_is_visible() or any(
+        text != "--" and not text.endswith("%") for _icon, text in _menubar_items(app, state)
+    ):
+        return app.interval
+    return max(app.interval, SLOW_POLL_INTERVAL_S)
 
 
-def _menubar_items(app: _TitleApp, state: PopoverState) -> list[tuple[Callable[[], Any], str]]:
-    """Visible (icon loader, percent text) pairs, keeping the highest-usage sources in order."""
+def _menubar_items(
+    app: _TitleApp, state: PopoverState, now: float | None = None
+) -> list[tuple[Callable[[], Any], str]]:
+    """Visible icon/text pairs, keeping the highest-usage sources in order."""
+    now = time.time() if now is None else now
     items: list[tuple[Callable[[], Any], float | None]] = []
     if not state.hide_claude:
         items.append((_claude_menubar_icon, state.claude_session.display_percent))
@@ -85,15 +125,29 @@ def _menubar_items(app: _TitleApp, state: PopoverState) -> list[tuple[Callable[[
     ):
         if not hidden and percent is not None:
             items.append((icon, percent))
+    rows_by_icon = {
+        _claude_menubar_icon: (state.claude_session, state.claude_weekly),
+        _codex_menubar_icon: (state.codex_session, state.codex_weekly),
+        _agy_menubar_icon: (state.agy_session, state.agy_weekly),
+        _grok_menubar_icon: (state.grok_weekly,),
+        _muse_menubar_icon: (state.muse_session, state.muse_weekly),
+    }
+    countdowns = [_quota_countdown(rows_by_icon[icon], now) for icon, _percent in items]
     if len(items) > _MENUBAR_MAX_ITEMS:
         # Stable sort, so ties keep the fixed order; an unknown "--" ranks last.
-        ranks = [-1.0 if percent is None else percent for _icon, percent in items]
+        ranks = [
+            100.0 if countdowns[i] is not None else -1.0 if percent is None else percent
+            for i, (_icon, percent) in enumerate(items)
+        ]
         ranked = sorted(range(len(items)), key=ranks.__getitem__, reverse=True)
-        items = [items[i] for i in sorted(ranked[:_MENUBAR_MAX_ITEMS])]
-    return [
-        (icon, "--" if percent is None else f"{_format_percent(percent)}%")
-        for icon, percent in items
+        selected = sorted(ranked[:_MENUBAR_MAX_ITEMS])
+    else:
+        selected = list(range(len(items)))
+    rendered = [
+        (icon, countdown or ("--" if percent is None else f"{_format_percent(percent)}%"))
+        for (icon, percent), countdown in zip(items, countdowns, strict=True)
     ]
+    return [rendered[i] for i in selected]
 
 
 def _menubar_attributed_title(app: _TitleApp, state: PopoverState) -> Any:
@@ -110,6 +164,7 @@ def _menubar_attributed_title(app: _TitleApp, state: PopoverState) -> Any:
 
 
 def _set_button_title(app: _TitleApp, state: PopoverState) -> None:
+    app._reschedule_poll_timer(menubar_poll_interval(app, state))
     title = _compose_title(app, state)
     title_key = (title,)
     if app._last_button_title_key == title_key:

{usage_cli-0.34.9 → usage_cli-0.34.10}/pyproject.toml

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

{usage_cli-0.34.9 → usage_cli-0.34.10}/tests/test_desktop_quota_review.py

@@ -145,7 +145,7 @@ def test_complete_hook_never_reads_desktop_even_on_repeated_polls(
         assert cli is not None and (cli.five_hour_pct, cli.seven_day_pct) == (12, 13)
 
 
-@pytest.mark.parametrize("hook", [None, {}, {"five_hour": {"used_percentage": 99}}])
+@pytest.mark.parametrize("hook", [None, {}, {"five_hour": {"used_percentage": None}}])
 def test_gui_and_cli_use_code_cache_before_desktop(
     sources: Path, monkeypatch: pytest.MonkeyPatch, hook: dict[str, Any] | None
 ) -> None:

{usage_cli-0.34.9 → usage_cli-0.34.10}/tests/test_menubar.py

@@ -2363,9 +2363,13 @@ def test_set_button_title_skips_unchanged_visible_state(
     delegate.codex_5h_pct = 12
     monkeypatch.setattr(menubar_title, "_menubar_attributed_title", lambda app, current: object())
 
+    intervals: list[float] = []
+    monkeypatch.setattr(delegate, "_panel_window_is_visible", lambda: False)
+    monkeypatch.setattr(delegate, "_reschedule_poll_timer", intervals.append)
     menubar_title._set_button_title(delegate, state)
     menubar_title._set_button_title(delegate, state)
 
+    assert intervals == [300.0, 300.0]
     assert len(button.titles) == 1
     assert len(button.attributed_titles) == 1
 
@@ -3312,7 +3316,12 @@ def test_panel_window_hide_prunes_cache_and_keeps_slow_poll() -> None:
     controller = SimpleNamespace(evictInactivePanelViews=Mock())
     reschedule = Mock()
     delegate = SimpleNamespace(
-        popover_controller=controller, interval=60, _reschedule_poll_timer=reschedule
+        popover_controller=controller,
+        interval=60,
+        _reschedule_poll_timer=reschedule,
+        _panel_window_is_visible=lambda: False,
+        latest_state=menubar._empty_state(),
+        codex_5h_pct=None,
     )
     menubar.AppDelegate._panel_window_did_hide(cast(Any, delegate))
     controller.evictInactivePanelViews.assert_called_once_with()
@@ -3419,3 +3428,128 @@ def test_refresh_preserves_muse_on_success_and_fetch_error(
         assert "OSError" in result.status_text
     else:
         assert result.status_text == _t("en", "status_text", value=_t("en", "status_no_data"))
+
+
+@pytest.mark.parametrize(
+    ("seconds", "expected"),
+    [
+        (0, "0m"),
+        (59, "1m"),
+        (60, "1m"),
+        (3599, "1h0m"),
+        (3600, "1h0m"),
+        (10500, "2h55m"),
+        (86400, "1d0h"),
+        (273000, "3d3h"),
+        (274200, "3d4h"),
+    ],
+)
+def test_menubar_countdown_format(seconds: float, expected: str) -> None:
+    assert menubar_title._format_countdown(seconds) == expected
+
+
+@pytest.mark.parametrize("tool", ["claude", "codex", "agy", "grok", "muse"])
+@pytest.mark.parametrize(
+    ("session_pct", "session_reset", "weekly_pct", "weekly_reset", "expected"),
+    [
+        (100, 10500, 30, None, "2h55m"),
+        (30, None, 100, 274200, "3d4h"),
+        (100, 10500, 100, 274200, "3d4h"),
+        (100, None, 30, None, "100%"),
+        (100, 0, 30, None, "100%"),
+        (100, -60, 30, None, "100%"),
+        (100, 10500, 100, None, "100%"),
+        (100, 10500, 100, 0, "100%"),
+        (30, None, 99, 10500, "30%"),
+    ],
+)
+def test_menubar_tool_countdown(
+    monkeypatch: pytest.MonkeyPatch,
+    tool: str,
+    session_pct: float,
+    session_reset: float | None,
+    weekly_pct: float,
+    weekly_reset: float | None,
+    expected: str,
+) -> None:
+    monkeypatch.setattr(menubar, "_load_preferences", lambda: {})
+    state = menubar._empty_state()
+    for name in ("claude", "codex", "agy", "grok", "muse"):
+        setattr(state, f"hide_{name}", name != tool)
+    now = 1000000.0
+    if tool == "grok":
+        # Grok has only a weekly row; exercise the session cases on that row.
+        rows = [(state.grok_weekly, session_pct, session_reset)]
+        expected = "2h55m" if session_pct >= 100 and session_reset == 10500 else f"{session_pct}%"
+    else:
+        rows = [
+            (getattr(state, f"{tool}_session"), session_pct, session_reset),
+            (getattr(state, f"{tool}_weekly"), weekly_pct, weekly_reset),
+        ]
+    for row, percent, reset in rows:
+        row.percent = percent
+        row.reset_done = False
+        row.resets_at = None if reset is None else now + reset
+    app = cast(Any, SimpleNamespace(codex_5h_pct=session_pct))
+    assert [text for _icon, text in menubar_title._menubar_items(app, state, now)] == [expected]
+
+
+@pytest.mark.parametrize(
+    ("visible", "reset", "interval", "expected"),
+    [
+        (False, 10500, 60, 60),
+        (False, None, 60, 300),
+        (False, 0, 60, 300),
+        (True, None, 60, 60),
+        (False, None, 600, 600),
+    ],
+)
+def test_menubar_poll_interval(
+    monkeypatch: pytest.MonkeyPatch,
+    visible: bool,
+    reset: float | None,
+    interval: float,
+    expected: float,
+) -> None:
+    monkeypatch.setattr(menubar, "_load_preferences", lambda: {})
+    monkeypatch.setattr(time, "time", lambda: 1000000.0)
+    state = menubar._empty_state()
+    state.claude_session.percent = 100
+    state.claude_session.resets_at = None if reset is None else 1000000.0 + reset
+    app = cast(
+        Any,
+        SimpleNamespace(
+            codex_5h_pct=None,
+            interval=interval,
+            _panel_window_is_visible=lambda: visible,
+        ),
+    )
+    assert menubar_title.menubar_poll_interval(app, state) == expected
+    state.hide_claude = True
+    if not visible:
+        assert menubar_title.menubar_poll_interval(app, state) == max(interval, 300)
+
+
+def test_menubar_countdown_ranks_as_full_and_preserves_codex_path(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(menubar, "_load_preferences", lambda: {})
+    state = menubar._empty_state()
+    state.claude_session.percent = 30
+    state.claude_weekly.percent = 100
+    state.claude_weekly.resets_at = 1010500.0
+    state.codex_session.percent = 80
+    state.agy_session.percent = 60
+    state.muse_session.percent = 50
+    state.hide_agy = state.hide_muse = False
+    app = cast(Any, SimpleNamespace(codex_5h_pct=40))
+    assert [text for _icon, text in menubar_title._menubar_items(app, state, 1000000)] == [
+        "2h55m",
+        "60%",
+        "50%",
+    ]
+    state.hide_agy = state.hide_muse = True
+    assert [text for _icon, text in menubar_title._menubar_items(app, state, 1000000)] == [
+        "2h55m",
+        "40%",
+    ]

{usage_cli-0.34.9 → usage_cli-0.34.10}/tests/test_usage_client.py

@@ -457,6 +457,31 @@ def test_fetch_once_returns_awaiting_rate_limits_when_status_has_no_limits(
     assert outcome.message == "awaiting_rate_limits"
 
 
+def test_fetch_once_uses_status_with_only_weekly_window(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    # Issue #273: plans without a 5-hour limit only send seven_day.
+    status_path = tmp_path / "usage-status.json"
+    monkeypatch.setattr(usage_client, "STATUS_FILE", str(status_path))
+    monkeypatch.setattr(usage_client, "LEGACY_STATUS_FILE", str(tmp_path / f"{LEGACY_NAME}.json"))
+    monkeypatch.setattr(usage_client, "TT_STATUS_FILE", str(tmp_path / "tt-status.json"))
+    monkeypatch.setattr(
+        usage_client, "read_quota_fallback", lambda *_: pytest.fail("fallback must not run")
+    )
+    status_path.write_text(
+        json.dumps(
+            {"rate_limits": {"seven_day": {"used_percentage": 46, "resets_at": 9_999_999_999}}}
+        ),
+        encoding="utf-8",
+    )
+
+    outcome = asyncio.run(usage_client.ClaudeUsageClient(mock=False).fetch_once())
+
+    assert outcome.snapshot is not None
+    assert outcome.snapshot.current_percent is None
+    assert outcome.snapshot.weekly_percent == 46
+
+
 def test_fetch_once_reuses_parsed_data_and_rebuilds_when_status_mtime_is_unchanged(
     monkeypatch: pytest.MonkeyPatch, tmp_path: Path
 ) -> None:

{usage_cli-0.34.9 → usage_cli-0.34.10}/tests/test_usage_statusline.py

@@ -408,6 +408,64 @@ def test_save_overwrites_existing_rate_limits_when_new_data_is_complete(
     assert data["_received_at_ts"] == now.timestamp()
 
 
+@pytest.mark.parametrize(
+    ("cached_five_reset", "expected_five"),
+    [
+        # Issue #273: a plan without a 5-hour limit stops sending five_hour.
+        # The expired cached window is dropped and seven_day is not frozen.
+        (1_000, None),
+        # A cached window whose reset is still ahead fills the gap.
+        (9_999_999_999, {"used_percentage": 11, "resets_at": 9_999_999_999}),
+    ],
+)
+def test_save_merges_rate_limit_windows_one_by_one(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+    cached_five_reset: int,
+    expected_five: dict[str, Any] | None,
+) -> None:
+    status_file = tmp_path / "usage-status.json"
+    status_file.write_text(
+        json.dumps(
+            {
+                "rate_limits": {
+                    "five_hour": {"used_percentage": 11, "resets_at": cached_five_reset},
+                    "seven_day": {"used_percentage": 34, "resets_at": 9_999_999_999},
+                }
+            }
+        ),
+        encoding="utf-8",
+    )
+    monkeypatch.setattr(usage_statusline, "STATUS_FILE", str(status_file))
+    fresh_seven = {"used_percentage": 46, "resets_at": 1_793_660_400}
+
+    usage_statusline.save(
+        {"rate_limits": {"seven_day": fresh_seven}},
+        datetime(2026, 11, 1, 12, 0, tzinfo=UTC),
+    )
+
+    rate_limits = json.loads(status_file.read_text(encoding="utf-8"))["rate_limits"]
+    assert rate_limits["seven_day"] == fresh_seven
+    assert rate_limits.get("five_hour") == expected_five
+
+
+def test_save_keeps_expired_cached_windows_when_payload_has_no_quota(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    cached = {
+        "five_hour": {"used_percentage": 11, "resets_at": 1_000},
+        "seven_day": {"used_percentage": 34, "resets_at": 1_000},
+    }
+    status_file = tmp_path / "usage-status.json"
+    status_file.write_text(json.dumps({"rate_limits": cached}), encoding="utf-8")
+    monkeypatch.setattr(usage_statusline, "STATUS_FILE", str(status_file))
+
+    usage_statusline.save({"model": {"display_name": "new"}}, datetime(2026, 11, 1, tzinfo=UTC))
+
+    assert json.loads(status_file.read_text(encoding="utf-8"))["rate_limits"] == cached
+
+
 def _write_prefs(path: Path, prefs: dict[str, Any]) -> None:
     path.write_text(json.dumps(prefs), encoding="utf-8")
 
@@ -1512,3 +1570,52 @@ def test_mix_sweeps_stale_files_when_a_new_session_starts(tmp_path: Path) -> Non
     transcript.write_bytes(_mix_record({"type": "image"}))
     assert usage_statusline.read_mix({"session_id": "one", "transcript_path": str(transcript)})
     assert sorted(p.name for p in mix_dir.iterdir()) == ["fresh.json", "one.json"]
+
+
+@pytest.mark.parametrize("lang", ["zh-TW", "zh-CN", "en"])
+@pytest.mark.parametrize("width", [200, 16, 1])
+@pytest.mark.parametrize("percent", [99, 100, 101])
+@pytest.mark.parametrize("reset", [None, -60, 0, 10500, 274200])
+def test_render_quota_countdown_variants(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+    lang: str,
+    width: int,
+    percent: int,
+    reset: int | None,
+) -> None:
+    monkeypatch.setenv("TT_LANG", lang)
+    monkeypatch.setattr(usage_statusline, "get_width", lambda: width)
+    monkeypatch.setattr(usage_statusline, "read_mix", lambda _data: None)
+    monkeypatch.setattr(usage_statusline, "PREFERENCES_FILE", str(tmp_path / "update.json"))
+    monkeypatch.setattr(usage_statusline, "CONTEXT_BURN_FILE", str(tmp_path / "burn.json"))
+    now = datetime(2026, 1, 1, 23, tzinfo=UTC)
+    resets_at = None if reset is None else now.timestamp() + reset
+    payload = {"rate_limits": {"five_hour": {"used_percentage": percent, "resets_at": resets_at}}}
+    colors = usage_statusline.C
+    prefix = f"{colors['blue']}{usage_statusline._t('five_hour')}:{colors['reset']}"
+    suffix = ""
+    remaining = ""
+    clock = ""
+    if reset is not None and reset > 0:
+        remaining = usage_statusline.fmt_duration(reset)
+        remaining = (
+            usage_statusline._t("remaining_prefix") + remaining
+            if lang in ("zh-TW", "zh-CN")
+            else remaining + " " + usage_statusline._t("remaining_prefix")
+        )
+        assert resets_at is not None
+        reset_dt = datetime.fromtimestamp(resets_at)
+        clock = f"{reset_dt:%H:%M}"
+        if reset_dt.date() != datetime.fromtimestamp(now.timestamp()).date():
+            clock = f"{reset_dt.month}/{reset_dt.day} {clock}"
+        suffix = f" {colors['dim']}{clock}({remaining}){colors['reset']}"
+    if percent >= 100 and remaining:
+        content = f"{clock}({remaining})" if width == 200 else remaining
+        expected = f"{prefix}{colors['red']}{content}{colors['reset']}"
+    else:
+        bar = usage_statusline.progress_bar(percent, 8 if width >= 100 else 4)
+        expected = prefix + (f"{percent}%" if width == 1 else bar)
+        if width == 200:
+            expected += suffix
+    assert usage_statusline._render_core(payload, now) == expected

{usage_cli-0.34.9 → usage_cli-0.34.10/usage_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: usage-cli
-Version: 0.34.9
+Version: 0.34.10
 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.9 → usage_cli-0.34.10}/usage_hooks/usage_statusline.py

@@ -69,7 +69,7 @@ else:
 fcntl = _fcntl
 msvcrt = _msvcrt
 
-__version__ = "1.14"
+__version__ = "1.16"
 
 STATUS_FILE = os.path.expanduser("~/.claude/usage-status.json")
 LOCK_FILE = os.path.expanduser("~/.claude/usage-status.lock")
@@ -421,6 +421,46 @@ def _rate_limits_complete(rate_limits: Any) -> bool:
     return five.get("used_percentage") is not None and seven.get("used_percentage") is not None
 
 
+_RATE_WINDOWS = ("five_hour", "seven_day")
+
+
+def _window_used(window: Any) -> bool:
+    return isinstance(window, dict) and window.get("used_percentage") is not None
+
+
+def _window_unexpired(window: Any, now_ts: float) -> bool:
+    try:
+        return float(window.get("resets_at")) > now_ts
+    except (TypeError, ValueError):
+        return False
+
+
+def _merge_rate_limits(incoming: Any, cached: Any, now_ts: float) -> Any:
+    """Merge quota windows one by one; plans without a 5-hour limit omit five_hour.
+
+    A payload with no window at all (a new session before its first reply) keeps
+    the cached block; the reader zeroes expired windows. Otherwise a fresh window
+    wins, and a missing one is taken from the cache only while its reset is still
+    ahead, so a window Claude Code stopped sending disappears instead of freezing.
+    """
+    if not isinstance(cached, dict) or not any(_window_used(cached.get(k)) for k in _RATE_WINDOWS):
+        return incoming
+    if not isinstance(incoming, dict) or not any(
+        _window_used(incoming.get(k)) for k in _RATE_WINDOWS
+    ):
+        return cached
+    merged = dict(incoming)
+    for key in _RATE_WINDOWS:
+        if _window_used(merged.get(key)):
+            continue
+        old = cached.get(key)
+        if _window_used(old) and _window_unexpired(old, now_ts):
+            merged[key] = old
+        else:
+            merged.pop(key, None)
+    return merged
+
+
 def _acquire_msvcrt_lock(lock_fd: int) -> bool:
     """Block (bounded) until the byte is locked; False if locking is unavailable.
 
@@ -499,9 +539,11 @@ def save(data: Dict[str, Any], now: datetime) -> None:
                 except (OSError, UnicodeDecodeError, json.JSONDecodeError):
                     existing = None
                 if isinstance(existing, dict):
-                    existing_rate_limits = existing.get("rate_limits")
-                    if _rate_limits_complete(existing_rate_limits):
-                        data["rate_limits"] = existing_rate_limits
+                    merged = _merge_rate_limits(
+                        data.get("rate_limits"), existing.get("rate_limits"), now.timestamp()
+                    )
+                    if merged is not None:
+                        data["rate_limits"] = merged
             fd, tmp_path = tempfile.mkstemp(dir=target_dir, suffix=".tmp")
             with os.fdopen(fd, "w", encoding="utf-8") as f:
                 json.dump(data, f, ensure_ascii=False)
@@ -996,9 +1038,15 @@ def _render_core(data: Dict[str, Any], now: datetime) -> str:
                 if reset_dt.date() != datetime.fromtimestamp(now.timestamp()).date():
                     clock = f"{reset_dt.month}/{reset_dt.day} {clock}"
                 if lang in ("zh-TW", "zh-CN"):
-                    reset_str = f" {clock}({_t('remaining_prefix')}{fmt_duration(remain)})"
+                    remaining = f"{_t('remaining_prefix')}{fmt_duration(remain)}"
                 else:
-                    reset_str = f" {clock}({fmt_duration(remain)} {_t('remaining_prefix')})"
+                    remaining = f"{fmt_duration(remain)} {_t('remaining_prefix')}"
+                if pct_float >= 100:
+                    prefix = f"{C['blue']}{label}:{C['reset']}{C['red']}"
+                    compact = f"{prefix}{remaining}{C['reset']}"
+                    rl_parts.append((f"{prefix}{clock}({remaining}){C['reset']}", compact, compact))
+                    continue
+                reset_str = f" {clock}({remaining})"
                 reset_str = f" {C['dim']}{reset_str[1:]}{C['reset']}"
         rl_parts.append(
             (