aiuse 3.2.7__tar.gz → 3.2.9__tar.gz

{aiuse-3.2.7/src/aiuse.egg-info → aiuse-3.2.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aiuse
-Version: 3.2.7
+Version: 3.2.9
 Summary: Aggregate AI subscription/API usage and flag use-it-or-lose-it allotments
 Author: djbclark
 License-Expression: MIT
@@ -258,6 +258,17 @@ guess:
 `aiuse --full` prints this exact table when a multi-account source cannot be
 matched safely. Explicit mappings take precedence over automatic normalization.
 
+Some vendors rate-limit quota probes. aiuse reads agy's (Antigravity's) quota
+at most once every 15 minutes across every aiuse process (CLI, LaunchAgent,
+`watch`, `serve`), reusing the last reading in between. Tune or disable it per
+provider, in seconds. See
+[Antigravity pools: query rate limit](docs/antigravity-pools.md#query-rate-limit-2026-10-05):
+
+```toml
+[query_min_interval]
+antigravity = 900 # 0 disables
+```
+
 ## Daily workflow
 
 ```bash
@@ -423,7 +434,7 @@ This tool:
 1. Pulls **remaining %** and **reset times** from **cswap** (Claude multi-account), **CodexBar** (broad live quotas), **caut**, **OpenUsage.ai**, **OpenUsage.sh** (cross-check peers / fill-in), and **tokscale** (independent measurement; preferred for Copilot).
 2. Scores windows with **pace-based** logic (default): compare how far through the cycle you are vs how much you've used, then project waste or early lockout.
 3. Classifies each window as **Burn** (will leave capacity unused), **Conserve** (on track to exhaust before reset — slow down), or **On pace** (no alert).
-4. For **shared-allotment** providers (Claude, Gemini by default), scores the longest governing window only so a fresh 5-hour bar does not outrank the weekly budget it draws from — but genuinely **independent pools are never merged into that governing window**: Cursor's Included+Auto pool and its separate Other Models pool are scored on their own, so an exhausted Other Models pool raises its own alert instead of being masked by a healthy Included.
+4. For **shared-allotment** providers (Claude, Gemini by default), scores the longest governing window only so a fresh 5-hour bar does not outrank the weekly budget it draws from — but genuinely **independent pools are never merged into that governing window**: Cursor's Included+Auto pool and its separate Other Models pool are scored on their own, so an exhausted Other Models pool raises its own alert instead of being masked by a healthy Included. Claude's **Fable cap is within the shared weekly pool** (up to 50%, not additional quota): the main row shows overall usage, with an indented cap underneath. Fable at 100% does not exhaust other Claude models; shared exhaustion blocks Fable too.
 5. Qualifies **Conserve** alerts with **overage awareness**: if the account has a real or config-confirmed overage/extra-usage wallet (Claude's usage credits, Cursor's on-demand balance, or a manually confirmed OpenCode Go overage state), the message says so — the real risk there is unplanned $ spend, not lockout, which is a different situation from a genuinely hard ceiling.
 6. Default pretty output is a **clock matrix** on stdout — one row per account/pool, one column per reset clock (5H/WEEK/MONTH), percentages **used** with that clock's reset after a slash (`75%/4h`, `89%/2d14h`; depleted → prepaid n/a → conserve → mid → use-soon at bottom; read bottom→top). Meta goes to stderr. Use `aiuse --full` for per-provider detail.
 7. On `--full`, keeps the trailing plan within ~**23 lines × console width** when possible; if the detailed plan is taller, both detailed and **at a glance** are printed (glance last). Forecast fragments (`~lockout …`, projected waste %) appear on table/status lines when pace can project them.

{aiuse-3.2.7 → aiuse-3.2.9}/README.md

@@ -217,6 +217,17 @@ guess:
 `aiuse --full` prints this exact table when a multi-account source cannot be
 matched safely. Explicit mappings take precedence over automatic normalization.
 
+Some vendors rate-limit quota probes. aiuse reads agy's (Antigravity's) quota
+at most once every 15 minutes across every aiuse process (CLI, LaunchAgent,
+`watch`, `serve`), reusing the last reading in between. Tune or disable it per
+provider, in seconds. See
+[Antigravity pools: query rate limit](docs/antigravity-pools.md#query-rate-limit-2026-10-05):
+
+```toml
+[query_min_interval]
+antigravity = 900 # 0 disables
+```
+
 ## Daily workflow
 
 ```bash
@@ -382,7 +393,7 @@ This tool:
 1. Pulls **remaining %** and **reset times** from **cswap** (Claude multi-account), **CodexBar** (broad live quotas), **caut**, **OpenUsage.ai**, **OpenUsage.sh** (cross-check peers / fill-in), and **tokscale** (independent measurement; preferred for Copilot).
 2. Scores windows with **pace-based** logic (default): compare how far through the cycle you are vs how much you've used, then project waste or early lockout.
 3. Classifies each window as **Burn** (will leave capacity unused), **Conserve** (on track to exhaust before reset — slow down), or **On pace** (no alert).
-4. For **shared-allotment** providers (Claude, Gemini by default), scores the longest governing window only so a fresh 5-hour bar does not outrank the weekly budget it draws from — but genuinely **independent pools are never merged into that governing window**: Cursor's Included+Auto pool and its separate Other Models pool are scored on their own, so an exhausted Other Models pool raises its own alert instead of being masked by a healthy Included.
+4. For **shared-allotment** providers (Claude, Gemini by default), scores the longest governing window only so a fresh 5-hour bar does not outrank the weekly budget it draws from — but genuinely **independent pools are never merged into that governing window**: Cursor's Included+Auto pool and its separate Other Models pool are scored on their own, so an exhausted Other Models pool raises its own alert instead of being masked by a healthy Included. Claude's **Fable cap is within the shared weekly pool** (up to 50%, not additional quota): the main row shows overall usage, with an indented cap underneath. Fable at 100% does not exhaust other Claude models; shared exhaustion blocks Fable too.
 5. Qualifies **Conserve** alerts with **overage awareness**: if the account has a real or config-confirmed overage/extra-usage wallet (Claude's usage credits, Cursor's on-demand balance, or a manually confirmed OpenCode Go overage state), the message says so — the real risk there is unplanned $ spend, not lockout, which is a different situation from a genuinely hard ceiling.
 6. Default pretty output is a **clock matrix** on stdout — one row per account/pool, one column per reset clock (5H/WEEK/MONTH), percentages **used** with that clock's reset after a slash (`75%/4h`, `89%/2d14h`; depleted → prepaid n/a → conserve → mid → use-soon at bottom; read bottom→top). Meta goes to stderr. Use `aiuse --full` for per-provider detail.
 7. On `--full`, keeps the trailing plan within ~**23 lines × console width** when possible; if the detailed plan is taller, both detailed and **at a glance** are printed (glance last). Forecast fragments (`~lockout …`, projected waste %) appear on table/status lines when pace can project them.

{aiuse-3.2.7 → aiuse-3.2.9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "aiuse"
-version = "3.2.7"
+version = "3.2.9"
 description = "Aggregate AI subscription/API usage and flag use-it-or-lose-it allotments"
 readme = "README.md"
 requires-python = ">=3.11"

{aiuse-3.2.7 → aiuse-3.2.9}/src/aiuse/__init__.py

@@ -1,3 +1,3 @@
 """Aggregate provider quotas and flag use-it-or-lose-it allotments."""
 
-__version__ = "3.2.7"
+__version__ = "3.2.9"

{aiuse-3.2.7 → aiuse-3.2.9}/src/aiuse/analysis/history.py

@@ -9,7 +9,7 @@ from pathlib import Path
 from typing import Any
 
 from aiuse.analysis.pace import independent_pool_key
-from aiuse.models import Snapshot, canonical_provider, effective_window_minutes, utcnow
+from aiuse.models import Snapshot, canonical_provider, claude_model_scope, effective_window_minutes, utcnow
 
 _DEFAULT_SNAPSHOT_DIR = "~/.cache/aiuse/snapshots"
 _DEFAULT_RETENTION_DAYS = 90
@@ -238,6 +238,9 @@ def window_series_key(provider: str, label: str | None, window_minutes: Any) ->
     independent pool within it (Gemini vs Claude/GPT), and the window duration.
     """
     pool = independent_pool_key(label) or "-"
+    model = claude_model_scope(label) if canonical_provider(provider) == "claude" else None
+    if model is not None:
+        pool = f"model_{model.casefold().replace(' ', '_')}"
     duration = _duration_key(window_minutes) or "?"
     return f"{canonical_provider(provider)}:{pool}:{duration}"
 

{aiuse-3.2.7 → aiuse-3.2.9}/src/aiuse/analysis/pace.py

@@ -5,7 +5,13 @@ from __future__ import annotations
 
 from datetime import datetime, timedelta
 
-from aiuse.models import PaceProfile, QuotaWindow, classify_window_minutes, nominal_window_minutes
+from aiuse.models import (
+    PaceProfile,
+    QuotaWindow,
+    classify_window_minutes,
+    claude_model_scope,
+    nominal_window_minutes,
+)
 
 
 def compute_pace(
@@ -99,8 +105,9 @@ def governing_partition(windows: list[QuotaWindow]) -> tuple[QuotaWindow | None,
     window because it temporarily blocks the entire pool, overriding longer durations.
     When durations tie (e.g. Cursor Included/Auto/other-models all monthly), prefer a
     window whose label looks like the overall included bar, then list order.
+    Claude model caps are children, never whole-pool governing windows.
     """
-    usable = [w for w in windows if w.remaining() is not None]
+    usable = [w for w in windows if w.remaining() is not None and claude_model_scope(w.label) is None]
     if not usable:
         return None, list(windows)
 

{aiuse-3.2.7 → aiuse-3.2.9}/src/aiuse/analysis/selfdescribe.py

@@ -20,7 +20,7 @@ from __future__ import annotations
 from datetime import datetime, timedelta
 from typing import Any, Iterable, Mapping
 
-from aiuse.models import parse_dt, utcnow
+from aiuse.models import claude_model_scope, parse_dt, utcnow
 
 SCHEMA_VERSION = "1.1"
 
@@ -34,12 +34,16 @@ FRESH_THRESHOLD_SECONDS_DEFAULT = 1500.0  # 25 min
 SEMANTICS: dict[str, str] = {
     "used_percent": "share CONSUMED; 100 means exhausted, 0 means untouched",
     "remaining_percent": "share still available; decide from this",
-    "headroom_percent": "alias of remaining_percent, spelled for humans",
+    "headroom_percent": "window: alias of remaining_percent; routing entry: least applicable headroom, with Fable's cap scaled to shared-weekly units",
     "state": "exhausted (<=1% left) | tight (<15% left) | ok | unknown (no data); never compute it yourself",
-    "usable_now": "false if any window of the account/pool is exhausted, or no window has data; true only with evidence of headroom",
+    "usable_now": "false if any applicable window is exhausted or no shared quota has data; Claude model caps restrict that model only, but shared limits restrict every Claude model",
     "binding_window": "label of the window with the least remaining_percent — the one that stops you first",
     "available_at": "earliest resets_at among exhausted windows; null when nothing is exhausted or no reset time is known",
-    "pool_family": "vendors that split quota by model family (antigravity: gemini vs claude_gpt; claude: default vs fable; cursor: auto/included/other); one family can be exhausted while another is fine — retry on the other family before abandoning the vendor",
+    "pool_family": "routing family, not necessarily independent quota: antigravity gemini vs claude_gpt are independent; Claude default is shared quota and fable is a model sublimit within it",
+    "quota_scope": "shared or model_sublimit; a model_sublimit is not additional quota and cannot exhaust the whole account",
+    "shared_pool_family": "parent routing family whose windows also constrain this model sublimit",
+    "max_share_of_parent_percent": "model cap as a share of the shared weekly budget; Fable <=50%, not an extra 50%",
+    "headroom_basis": "shared_weekly for Fable routing entries: min(shared headroom, 0.5 * Fable cap headroom); window percentages remain relative to their own limits",
     "age_seconds": "seconds since collected_at, computed at read time; stale data can hide a fresh exhaustion",
     "fresh": "age_seconds <= fresh threshold (default 1500s); when false, re-collect before trusting ok states",
     "summary_lines": "one human line per pool; always shows used AND left, never a bare percentage",
@@ -47,16 +51,15 @@ SEMANTICS: dict[str, str] = {
 }
 
 # (substring, family, models_hint) matched against the lowercased window label,
-# first hit wins. Only vendors that genuinely split pools by model family.
+# first hit wins. Claude families are routing views of one shared pool.
 _FAMILY_RULES: dict[str, list[tuple[str, str, str]]] = {
     "antigravity": [
         ("claude/gpt", "claude_gpt", "agy models — claude-* / gpt-* models draw this pool"),
         ("gemini", "gemini", "agy models — gemini-* models draw this pool"),
     ],
     "claude": [
-        ("fable", "fable", "Claude Fable pool (reasoning-tier models)"),
-        ("5-hour", "default", "ordinary Claude models"),
-        ("weekly", "default", "ordinary Claude models"),
+        ("5-hour", "default", "Claude models without a reported model cap; quota is shared with capped models"),
+        ("weekly", "default", "Claude models without a reported model cap; quota is shared with capped models"),
     ],
     "cursor": [
         ("grok", "grok_bot", "Cursor Grok Bot slot"),
@@ -92,6 +95,9 @@ def window_state(window: Mapping[str, Any]) -> str:
 
 def window_family(provider: str, label: str) -> tuple[str | None, str | None]:
     """(pool_family, models_hint) for split vendors; (None, None) otherwise."""
+    model = claude_model_scope(label) if provider == "claude" else None
+    if model is not None:
+        return model.casefold().replace(" ", "_"), f"Claude {model}; also draws shared Claude quota"
     rules = _FAMILY_RULES.get(provider)
     if not rules:
         return None, None
@@ -112,6 +118,15 @@ def enrich_window(window: dict[str, Any], *, provider: str) -> dict[str, Any]:
     window.pop("agent_reported", None)
     window["state"] = window_state(window)
     window["headroom_percent"] = window_remaining(window)
+    for key in ("quota_scope", "shared_pool_family", "max_share_of_parent_percent"):
+        window.pop(key, None)
+    if provider == "claude":
+        model = claude_model_scope(str(window.get("label") or ""))
+        window["quota_scope"] = "model_sublimit" if model else "shared"
+        if model:
+            window["shared_pool_family"] = "default"
+            if model.casefold() == "fable":
+                window["max_share_of_parent_percent"] = 50.0
     family, hint = window_family(provider, str(window.get("label") or ""))
     if family is not None:
         window["pool_family"] = family
@@ -160,17 +175,18 @@ def enrich_account(
             if _note_matches(note, provider, window):
                 _apply_note_to_window(window, note)
 
-    states = [str(w.get("state")) for w in windows]
+    applicable = [w for w in windows if w.get("quota_scope") != "model_sublimit"]
+    states = [str(w.get("state")) for w in applicable]
     if any(s == "exhausted" for s in states):
         usable_now: bool | None = False
-    elif windows and any(s != "unknown" for s in states):
+    elif applicable and any(s != "unknown" for s in states):
         usable_now = True
     else:
         # no windows at all, or every window unknown: no evidence of headroom
         usable_now = False
     account["usable_now"] = usable_now
 
-    numbered = [w for w in windows if w.get("headroom_percent") is not None]
+    numbered = [w for w in applicable if w.get("headroom_percent") is not None]
     if numbered:
         binding = min(numbered, key=lambda w: float(w["headroom_percent"]))
         account["binding_window"] = str(binding.get("label") or "")
@@ -180,7 +196,7 @@ def enrich_account(
         account["binding_headroom_percent"] = None
 
     reset_times = [
-        parse_dt(w.get("resets_at")) for w in windows if w.get("state") == "exhausted" and w.get("resets_at")
+        parse_dt(w.get("resets_at")) for w in applicable if w.get("state") == "exhausted" and w.get("resets_at")
     ]
     reset_times = [t for t in reset_times if t is not None]
     if reset_times:
@@ -259,11 +275,16 @@ def pool_entries(snap: Mapping[str, Any]) -> list[dict[str, Any]]:
             if window.get("models_hint"):
                 hints[family] = str(window["models_hint"])
         for family, windows in by_family.items():
+            model_sublimit = provider == "claude" and family != "default"
+            family_has_data = any(str(w.get("state") or "unknown") != "unknown" for w in windows)
+            shared = by_family.get("default", []) if model_sublimit else windows
+            if model_sublimit:
+                windows = shared + windows
             states = [str(w.get("state") or "unknown") for w in windows]
             numbered = [w for w in windows if w.get("headroom_percent") is not None]
             if any(s == "exhausted" for s in states):
                 usable: bool | None = False
-            elif any(s != "unknown" for s in states):
+            elif family_has_data and any(str(w.get("state") or "unknown") != "unknown" for w in shared):
                 usable = True
             else:
                 usable = False
@@ -271,7 +292,12 @@ def pool_entries(snap: Mapping[str, Any]) -> list[dict[str, Any]]:
                 parse_dt(w.get("resets_at")) for w in windows if w.get("state") == "exhausted" and w.get("resets_at")
             ]
             resets = [t for t in resets if t is not None]
-            binding = min(numbered, key=lambda w: float(w["headroom_percent"])) if numbered else None
+
+            def effective_headroom(window: Mapping[str, Any]) -> float:
+                share = float(window.get("max_share_of_parent_percent", 100.0)) / 100.0
+                return float(window["headroom_percent"]) * share
+
+            binding = min(numbered, key=effective_headroom) if numbered else None
             pools.append(
                 {
                     "provider": provider,
@@ -280,7 +306,14 @@ def pool_entries(snap: Mapping[str, Any]) -> list[dict[str, Any]]:
                     "cli_binary": account.get("cli_binary"),
                     "usable_now": usable,
                     "binding_window": str(binding.get("label") or "") if binding else None,
-                    "headroom_percent": float(binding["headroom_percent"]) if binding else None,
+                    "headroom_percent": effective_headroom(binding) if binding else None,
+                    **(
+                        {"shared_pool_family": "default", "headroom_basis": "shared_weekly"}
+                        if model_sublimit and family == "fable"
+                        else {"shared_pool_family": "default"}
+                        if model_sublimit
+                        else {}
+                    ),
                     "available_at": min(resets).isoformat() if resets else None,
                     "models_hint": hints.get(family),
                     "age_seconds": account.get("age_seconds"),
@@ -337,6 +370,9 @@ def summary_line(pool: Mapping[str, Any]) -> str:
             left = max(0.0, 100.0 - float(used))
         word = {"exhausted": "EXHAUSTED", "tight": "TIGHT", "ok": "ok", "unknown": "UNKNOWN"}.get(state, state)
         seg = f"{label}: {word} ({_fmt_pct(used)}% used / {_fmt_pct(left)}% left{_reset_fragment(window.get('resets_at'))})"
+        if window.get("quota_scope") == "model_sublimit":
+            cap = window.get("max_share_of_parent_percent")
+            seg += f" [cap <={cap:g}% of shared weekly]" if cap is not None else " [cap within shared weekly]"
         if window.get("state_source") == "agent-reported":
             seg += " [agent-reported]"
         segments.append(seg)

{aiuse-3.2.7 → aiuse-3.2.9}/src/aiuse/analysis/use_or_lose.py

@@ -38,6 +38,7 @@ from aiuse.models import (
     UseOrLoseAlert,
     canonical_provider,
     classify_window_minutes,
+    claude_model_scope,
     provider_config_key,
     provider_display_name,
     utcnow,
@@ -329,6 +330,8 @@ def analyze_use_or_lose(
                 shared_allotment = False
 
         for window in account.windows:
+            if claude_model_scope(window.label) is not None:
+                continue  # model caps cannot be burned as additional account quota
             if mode == "legacy" and _is_short_window(window):
                 continue
 
@@ -948,6 +951,8 @@ def _pace_message(
     # suppress shorter siblings that may show 100% open — say so clearly.
     depleted = remaining is not None and remaining <= 1.0
     child_note = ""
+    model_children = [c for c in suppressed_children or [] if claude_model_scope(c.label) is not None]
+    suppressed_children = [c for c in suppressed_children or [] if claude_model_scope(c.label) is None]
     if suppressed_children:
         labels = ", ".join(c.label for c in suppressed_children)
         if verdict == "conserve" and depleted:
@@ -960,6 +965,10 @@ def _pace_message(
             )
         else:
             child_note = f" (this also covers your {labels} — no need to burn it separately)"
+    for child in model_children:
+        model = claude_model_scope(child.label)
+        if child.remaining() == 0:
+            child_note += f" {model} cap exhausted; remaining shared quota is for other models."
     overage_note = (
         " Overage/extra-usage is available on this account — real risk is unplanned $ spend, not lockout."
         if pace.has_overage

{aiuse-3.2.7 → aiuse-3.2.9}/src/aiuse/chat_format.py

@@ -23,6 +23,7 @@ from aiuse.models import (
     Snapshot,
     UseOrLoseAlert,
     classify_window_minutes,
+    claude_model_scope,
     provider_display_name,
 )
 
@@ -420,8 +421,11 @@ class _PoolEntry:
         its 5-hour window shows headroom — the shorter window is carved out of
         the longer one, so the bad news governs.
         """
-        worst = self.rows[0].emoji
-        for row in self.rows[1:]:
+        shared = [r for r in self.rows if claude_model_scope(r.window.label) is None]
+        if not shared:
+            return EMOJI_INFO
+        worst = shared[0].emoji
+        for row in shared[1:]:
             worst = _worst_emoji(worst, row.emoji)
         return worst
 
@@ -438,7 +442,8 @@ class _PoolEntry:
 
     def sort_key(self) -> tuple[Any, ...]:
         """Order by the entry's most severe window, so the worst float up."""
-        return min(row.sort_key() for row in self.rows)
+        shared = [r for r in self.rows if claude_model_scope(r.window.label) is None]
+        return min(row.sort_key() for row in shared or self.rows)
 
 
 def _group_rows_into_pools(rows: list[_WindowRow]) -> list[_PoolEntry]:
@@ -474,7 +479,7 @@ def _apply_governing_warnings(rows: list[_WindowRow]) -> None:
     report capacity.
     """
     for entry in _group_rows_into_pools(rows):
-        pool_rows = entry.rows
+        pool_rows = [r for r in entry.rows if claude_model_scope(r.window.label) is None]
         if len(pool_rows) < 2:
             continue
         # Find the longest-duration window (governing candidate).
@@ -611,7 +616,15 @@ def _build_action_items(
 
     if routing_context is not None and sub_rows is not None:
         primary_prov = routing_context.primary_provider
-        primary_rows = [r for r in sub_rows if r.provider == primary_prov]
+        primary_rows = [
+            r
+            for r in sub_rows
+            if r.provider == primary_prov
+            and (
+                (scope := claude_model_scope(r.window.label)) is None
+                or scope.casefold() in routing_context.primary_model.casefold()
+            )
+        ]
         if primary_rows:
             min_remaining = min(r.remaining for r in primary_rows)
             name = provider_display_name(primary_prov)
@@ -750,6 +763,10 @@ def _render_prepaid_row(account: AccountUsage) -> list[str]:
 def _row_notes(row: _WindowRow) -> list[str]:
     """Continuation lines attached to a single window."""
     notes: list[str] = []
+    model = claude_model_scope(row.window.label)
+    if model is not None:
+        cap = "<=50% of shared weekly" if model.casefold() == "fable" else "within shared weekly"
+        notes.append(f"{model} cap ({cap}); not additional quota")
     if row.pace_line:
         notes.append(row.pace_line)
     if row.remaining <= 0 and not row.pace_line and not row.governing_warning:

{aiuse-3.2.7 → aiuse-3.2.9}/src/aiuse/collectors/codexbar.py

@@ -21,6 +21,7 @@ from aiuse.models import coerce_float as _f
 from aiuse.models import coerce_int as _int_or_none
 
 from .base import CollectorError, run_json, which
+from .throttle import QueryGate
 
 # Providers that are typically pure prepaid / API balance (not use-or-lose monthly)
 PREPAID_HINTS = {
@@ -107,6 +108,7 @@ def collect_codexbar(
     providers: str | list[str] | None = "enabled",
     timeout: float = 45.0,
     discovery_timeout: float | None = None,
+    min_intervals: dict[str, float] | None = None,
 ) -> list[AccountUsage]:
     if not which("codexbar"):
         raise CollectorError("codexbar not found on PATH")
@@ -124,8 +126,11 @@ def collect_codexbar(
 
     accounts: list[AccountUsage] = []
     errors: list[str] = []
+    reuse_notes: dict[str, str] = {}
 
-    for provider_arg, outcome in _query_providers(provider_list, timeout=timeout):
+    for provider_arg, outcome in _query_providers(
+        provider_list, timeout=timeout, min_intervals=min_intervals, reuse_notes=reuse_notes
+    ):
         if isinstance(outcome, CollectorError):
             name = provider_arg or "enabled providers"
             errors.append(f"{name}: {outcome}")
@@ -137,7 +142,10 @@ def collect_codexbar(
                     row_provider = str(row.get("provider", "")).strip().lower()
                     if row_provider and row_provider != provider_arg.lower():
                         continue
-                accounts.append(_from_row(row))
+                account = _from_row(row)
+                if provider_arg is not None and provider_arg in reuse_notes:
+                    account.notes = list(account.notes) + [reuse_notes[provider_arg]]
+                accounts.append(account)
                 zen = _opencode_zen_from_row(row)
                 if zen is not None:
                     accounts.append(zen)
@@ -202,6 +210,8 @@ def _query_providers(
     provider_list: list[str | None],
     *,
     timeout: float = 45.0,
+    min_intervals: dict[str, float] | None = None,
+    reuse_notes: dict[str, str] | None = None,
 ) -> list[tuple[str | None, Any]]:
     """Run one `codexbar usage` call per entry in provider_list, concurrently.
 
@@ -210,22 +220,51 @@ def _query_providers(
     error ordering stays deterministic. Duplicate entries are queried once —
     querying the same provider twice concurrently is never useful and would
     otherwise race on which duplicate's outcome survives.
+
+    Providers listed in ``min_intervals`` go through a cross-process
+    :class:`QueryGate`; when one is throttled its last stored payload is
+    returned instead and ``reuse_notes[provider]`` explains why.
     """
     deduped: list[str | None] = list(dict.fromkeys(provider_list))
+    intervals = min_intervals or {}
+    notes = reuse_notes if reuse_notes is not None else {}
+
+    def run(provider_arg: str | None) -> Any:
+        if provider_arg is not None and intervals.get(provider_arg.lower(), 0) > 0:
+            return _query_provider_gated(provider_arg, intervals[provider_arg.lower()], timeout=timeout, notes=notes)
+        return _query_provider(provider_arg, timeout=timeout)
+
     if len(deduped) <= 1:
-        return [(provider_arg, _query_provider(provider_arg, timeout=timeout)) for provider_arg in deduped]
+        return [(provider_arg, run(provider_arg)) for provider_arg in deduped]
 
     workers = min(len(deduped), _MAX_CONCURRENT_PROVIDER_QUERIES)
     with ThreadPoolExecutor(max_workers=workers) as pool:
-        futures = {
-            pool.submit(_query_provider, provider_arg, timeout=timeout): provider_arg for provider_arg in deduped
-        }
+        futures = {pool.submit(run, provider_arg): provider_arg for provider_arg in deduped}
         outcomes: dict[str | None, Any] = {}
         for future in as_completed(futures):
             outcomes[futures[future]] = future.result()
     return [(provider_arg, outcomes[provider_arg]) for provider_arg in deduped]
 
 
+def _query_provider_gated(
+    provider_arg: str,
+    min_interval: float,
+    *,
+    timeout: float,
+    notes: dict[str, str],
+) -> Any:
+    provider = provider_arg.lower()
+    with QueryGate(provider, min_interval=min_interval, wait=timeout + 15.0) as gate:
+        if gate.allowed:
+            outcome = _query_provider(provider_arg, timeout=timeout)
+            gate.record("codexbar", outcome)
+            return outcome
+        reused_at = gate.reused_from("codexbar")
+        if reused_at is not None:
+            notes[provider_arg] = f"{gate.describe()}; reused CodexBar's result from {reused_at.isoformat()}."
+        return gate.reuse("codexbar")
+
+
 def _query_provider(provider_arg: str | None, *, timeout: float = 45.0) -> Any:
     # Omitting --provider asks CodexBar for its enabled-provider list and data
     # (only reached as a fallback if _discover_enabled_providers() fails).

{aiuse-3.2.7 → aiuse-3.2.9}/src/aiuse/collectors/cswap.py

@@ -182,7 +182,7 @@ def _windows_from_usage(usage: dict[str, Any]) -> list[QuotaWindow]:
                 continue
             model_name = str(block.get("name") or "unnamed model")
             window = _window_from_block(f"Claude Code weekly — {model_name}", block)
-            if window and not _same_window_present(windows, window):
+            if window and not any(w.label == window.label and w.same_measurement(window) for w in windows):
                 windows.append(window)
 
     return windows

{aiuse-3.2.7 → aiuse-3.2.9}/src/aiuse/collectors/openusage.py

@@ -15,6 +15,7 @@ import subprocess
 import urllib.error
 import urllib.parse
 import urllib.request
+from contextlib import ExitStack
 from typing import Any
 
 from aiuse.models import (
@@ -30,6 +31,7 @@ from aiuse.models import (
 )
 
 from .base import CollectorError, run_json, which
+from .throttle import QueryGate
 
 DEFAULT_OPENUSAGE_BASE = "http://127.0.0.1:6736"
 DEFAULT_HTTP_TIMEOUT = 30.0
@@ -96,13 +98,15 @@ def collect_openusage_ai(
     base_url: str = DEFAULT_OPENUSAGE_BASE,
     force_refresh: bool = True,
     try_launch_app: bool = True,
+    min_intervals: dict[str, float] | None = None,
 ) -> list[AccountUsage]:
     """Fetch OpenUsage limits via CLI first, then loopback HTTP."""
-    payload, via = _fetch_limits(
+    payload, via, throttle_note = _fetch_limits_gated(
         timeout=timeout,
         base_url=base_url,
         force_refresh=force_refresh,
         try_launch_app=try_launch_app,
+        min_intervals=min_intervals or {},
     )
     if not isinstance(payload, dict):
         raise CollectorError("OpenUsage returned non-object JSON")
@@ -120,7 +124,10 @@ def collect_openusage_ai(
     for provider_id, body in providers.items():
         if not isinstance(body, dict):
             continue
-        accounts.append(_from_provider(str(provider_id), body, via=via))
+        account = _from_provider(str(provider_id), body, via=via)
+        if throttle_note and account.provider in _gated_providers(min_intervals):
+            account.notes = list(account.notes) + [throttle_note]
+        accounts.append(account)
 
     errors = payload.get("errors") or []
     if errors and accounts:
@@ -142,6 +149,51 @@ def collect_openusage_ai(
     return accounts
 
 
+def _gated_providers(min_intervals: dict[str, float] | None) -> set[str]:
+    return {provider for provider, seconds in (min_intervals or {}).items() if seconds > 0}
+
+
+def _fetch_limits_gated(
+    *,
+    timeout: float,
+    base_url: str,
+    force_refresh: bool,
+    try_launch_app: bool,
+    min_intervals: dict[str, float],
+) -> tuple[dict[str, Any], str, str | None]:
+    """``_fetch_limits`` with ``--force`` withheld while any gated provider is throttled.
+
+    A forced CLI refresh makes OpenUsage re-query every provider it has enabled,
+    so it counts as a query of each gated provider that comes back in the
+    payload. Without ``--force`` OpenUsage serves its own cached reading.
+    """
+    gated = sorted(_gated_providers(min_intervals))
+    if not force_refresh or not gated or not which("openusage"):
+        payload, via = _fetch_limits(
+            timeout=timeout, base_url=base_url, force_refresh=force_refresh, try_launch_app=try_launch_app
+        )
+        return payload, via, None
+
+    with ExitStack() as stack:
+        gates = [
+            stack.enter_context(QueryGate(provider, min_interval=min_intervals[provider], wait=timeout + 15.0))
+            for provider in gated
+        ]
+        blocked = [gate for gate in gates if not gate.allowed]
+        payload, via = _fetch_limits(
+            timeout=timeout, base_url=base_url, force_refresh=not blocked, try_launch_app=try_launch_app
+        )
+        if blocked:
+            reasons = "; ".join(gate.describe() for gate in blocked)
+            return payload, via, f"OpenUsage refresh not forced: {reasons}."
+        if via == "cli":
+            returned = payload.get("providers") if isinstance(payload, dict) else None
+            for gate in gates:
+                if isinstance(returned, dict) and gate.provider in {str(k).lower() for k in returned}:
+                    gate.record("openusage_ai", store=False)
+        return payload, via, None
+
+
 def _fetch_limits(
     *,
     timeout: float,

{aiuse-3.2.7 → aiuse-3.2.9}/src/aiuse/collectors/runner.py

@@ -35,6 +35,7 @@ from .openrouter import collect_openrouter
 from .openusage import collect_openusage_ai
 from .openusage_sh import collect_openusage_sh
 from .qwencloud import collect_qwencloud
+from .throttle import min_intervals
 from .tokscale import collect_tokscale
 
 # Prefer earlier sources for *selection* (what drives the ladder). All live
@@ -95,6 +96,7 @@ def run_collectors(config: dict[str, Any] | None = None) -> Snapshot:
     config = config or {}
     collectors_cfg = config.get("collectors") or {}
     snapshot = Snapshot(collected_at=utcnow())
+    intervals = min_intervals(config)
 
     # Each collector shells out (or hits loopback) independently — run concurrently.
     # Correctness: long default timeouts; all enabled sources always queried.
@@ -114,6 +116,7 @@ def run_collectors(config: dict[str, Any] | None = None) -> Snapshot:
                     providers=providers,
                     timeout=codexbar_timeout,
                     discovery_timeout=discovery_timeout,
+                    min_intervals=intervals,
                 ),
             )
         )
@@ -144,6 +147,7 @@ def run_collectors(config: dict[str, Any] | None = None) -> Snapshot:
                     force_refresh=force,
                     try_launch_app=launch,
                     base_url=base,
+                    min_intervals=intervals,
                 ),
             )
         )