aiuse 3.2.6__tar.gz → 3.2.7__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aiuse
-Version: 3.2.6
+Version: 3.2.7
 Summary: Aggregate AI subscription/API usage and flag use-it-or-lose-it allotments
 Author: djbclark
 License-Expression: MIT
@@ -510,7 +510,7 @@ Lapsed subscriptions: `analysis.lapsed_accounts` maps `"provider/account"` to a
 ## Notes / limitations
 
 - Live quota accuracy depends on each tool's auth (browser cookies, OAuth, keychain). Errors are reported per account rather than aborting the whole run.
-- All enabled collectors (cswap, CodexBar, caut, OpenUsage.ai, OpenUsage.sh, tokscale, qwencloud, bailian) run concurrently; each CodexBar provider is its own subprocess. Default tool timeout is **45s** (`-t` / `config.toml [timeouts]`).
+- All enabled collectors (cswap, CodexBar, caut, OpenUsage.ai, OpenUsage.sh, tokscale, qwencloud, bailian) run concurrently; each CodexBar provider is its own subprocess. Default tool timeout is **45s**; `cswap` and `openusage_sh` are **90s** (`-t` / `config.toml [timeouts]`).
 - Per-window detail still shows $ value, flexibility class, and a **pace** ratio when computable.
 - Duplicate live measurements are retained for cross-checking but only one copy drives recommendations.
 - Dollar values use plan `monthly_price` with waking-hours correction (default 16h/day).

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

@@ -469,7 +469,7 @@ Lapsed subscriptions: `analysis.lapsed_accounts` maps `"provider/account"` to a
 ## Notes / limitations
 
 - Live quota accuracy depends on each tool's auth (browser cookies, OAuth, keychain). Errors are reported per account rather than aborting the whole run.
-- All enabled collectors (cswap, CodexBar, caut, OpenUsage.ai, OpenUsage.sh, tokscale, qwencloud, bailian) run concurrently; each CodexBar provider is its own subprocess. Default tool timeout is **45s** (`-t` / `config.toml [timeouts]`).
+- All enabled collectors (cswap, CodexBar, caut, OpenUsage.ai, OpenUsage.sh, tokscale, qwencloud, bailian) run concurrently; each CodexBar provider is its own subprocess. Default tool timeout is **45s**; `cswap` and `openusage_sh` are **90s** (`-t` / `config.toml [timeouts]`).
 - Per-window detail still shows $ value, flexibility class, and a **pace** ratio when computable.
 - Duplicate live measurements are retained for cross-checking but only one copy drives recommendations.
 - Dollar values use plan `monthly_price` with waking-hours correction (default 16h/day).

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

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

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

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

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

@@ -37,7 +37,7 @@ from aiuse.models import coerce_int as _int_or_none
 from .base import CollectorError, run_json, which
 
 
-def collect_cswap(*, timeout: float = 45.0) -> list[AccountUsage]:
+def collect_cswap(*, timeout: float = 90.0) -> list[AccountUsage]:
     if not which("cswap"):
         raise CollectorError("cswap not found on PATH")
 

{aiuse-3.2.6 → aiuse-3.2.7}/src/aiuse/collectors/muse.py

@@ -14,9 +14,14 @@ If one transport is absent or fails, the other is tried. Absent both → [] . 40
 credential present surfaces as AccountUsage(error=…) only after both transports fail.
 
 As of 2026-08, api.meta.ai exposes /models and /status for the LLM| key but no billing
-path (all candidates 404). Cookie path uses LLMDCBillingBannerContainerQuery plus
-LLMDCHomeContentUsageSummaryQuery: Muse's UI "balance" is MTD PAYG spend (counts up),
+path (all candidates 404). Cookie path uses the portal billing banner plus
+month-to-date USAGE_BILLABLE_COST: Muse's UI "balance" is MTD PAYG spend (counts up),
 not prepaid remaining.
+
+A monthly Muse Code plan does not publish a monthly used-percent. The plan meter is
+``subs_usage`` on ``POST https://api.meta.ai/muse-code/key`` (Muse CLI keychain access
+token): a rolling window (``window_duration_mins``, 300 for the 5-hour clock) and a
+weekly window. No active subscription omits ``subs_usage``; the row stays spend-only.
 """
 
 from __future__ import annotations
@@ -26,8 +31,10 @@ import os
 import re
 import shutil
 import subprocess
+import threading
+import time
 from collections.abc import Mapping
-from datetime import date
+from datetime import date, datetime, timezone
 from pathlib import Path
 from typing import Any
 from urllib.parse import quote, urlencode
@@ -83,6 +90,15 @@ _BILLING_FRIENDLY = "LLMDCBillingBannerContainerQuery"
 _SPEND_DOC_ID = "28692949813640152"
 _SPEND_FRIENDLY = "LLMDCHomeContentUsageSummaryQuery"
 _PE_AMOUNT_OFFSET = 100.0
+# Muse Code plan meter. The API key cannot read it; the device-login access token can.
+_MUSE_CODE_KEY_URL = "https://api.meta.ai/muse-code/key"
+_KEYCHAIN_SERVICE = "ai.meta.dev.credentials"
+_KEYCHAIN_ACCOUNT = "meta"
+_SUBS_CACHE_TTL_S = 300.0
+_subs_cache_lock = threading.Lock()
+# ``payload`` None means "no cached read". A dict (possibly without subs_usage)
+# is a fresh key response and is reused for five minutes.
+_subs_cache: dict[str, Any] = {"at": 0.0, "payload": None}
 
 
 def collect_muse(
@@ -110,7 +126,7 @@ def collect_muse(
                 if cookie and _is_soft_inventory_row(accounts[0]):
                     soft_from_key = accounts
                 else:
-                    return accounts
+                    return _merge_subscription_windows(accounts, timeout, allow_local=allow_local)
         except CollectorError as exc:
             msg = str(exc)
             errors.append(msg)
@@ -132,7 +148,11 @@ def collect_muse(
 
     if cookie:
         try:
-            return _collect_via_cookie(cookie, env, timeout, account=account)
+            return _merge_subscription_windows(
+                _collect_via_cookie(cookie, env, timeout, account=account),
+                timeout,
+                allow_local=allow_local,
+            )
         except CollectorError as exc:
             msg = str(exc)
             errors.append(msg)
@@ -143,7 +163,7 @@ def collect_muse(
                     *row.notes,
                     f"Cookie balance unavailable: {msg}",
                 ]
-                return soft_from_key
+                return _merge_subscription_windows(soft_from_key, timeout, allow_local=allow_local)
             if key:
                 # Both failed
                 raise CollectorError("; ".join(errors)) from exc
@@ -162,7 +182,7 @@ def collect_muse(
             raise
 
     if soft_from_key is not None:
-        return soft_from_key
+        return _merge_subscription_windows(soft_from_key, timeout, allow_local=allow_local)
 
     # One transport was tried and failed with non-401 without fallback
     if errors:
@@ -1244,6 +1264,226 @@ def _windows_from_payload(data: dict) -> list[QuotaWindow]:
     return windows
 
 
+def _epoch_to_utc(value: Any) -> datetime | None:
+    """Muse sends ``resets_at`` as unix seconds (or an ISO string)."""
+    if isinstance(value, bool) or value is None:
+        return None
+    if isinstance(value, (int, float)):
+        seconds = float(value)
+        if seconds > 10_000_000_000:
+            seconds /= 1000.0
+        if seconds <= 0:
+            return None
+        return datetime.fromtimestamp(seconds, timezone.utc)
+    if isinstance(value, str):
+        return parse_dt(value)
+    return None
+
+
+def _windows_from_subs_usage(payload: Any) -> list[QuotaWindow]:
+    """Map ``subs_usage`` from ``POST /muse-code/key`` into clock windows.
+
+    ``used_percent`` is the share consumed. The rolling window's
+    ``window_duration_mins`` picks the clock (300 is the 5-hour plan window).
+    The weekly object has no duration of its own.
+    """
+    if not isinstance(payload, dict):
+        return []
+    usage = payload.get("subs_usage")
+    if not isinstance(usage, dict):
+        return []
+    windows: list[QuotaWindow] = []
+    rolling = usage.get("window")
+    if isinstance(rolling, dict):
+        window = _quota_window_from_subs_spec(
+            rolling,
+            label="Muse 5-hour",
+            minutes=300,
+        )
+        if window is not None:
+            windows.append(window)
+    weekly = usage.get("weekly")
+    if isinstance(weekly, dict):
+        window = _quota_window_from_subs_spec(
+            weekly,
+            label="Muse weekly",
+            minutes=10080,
+        )
+        if window is not None:
+            windows.append(window)
+    return windows
+
+
+def _quota_window_from_subs_spec(
+    spec: dict[str, Any],
+    *,
+    label: str,
+    minutes: int,
+) -> QuotaWindow | None:
+    percent = spec.get("used_percent")
+    if isinstance(percent, bool) or not isinstance(percent, (int, float)):
+        return None
+    used = float(percent)
+    duration = spec.get("window_duration_mins")
+    if isinstance(duration, (int, float)) and not isinstance(duration, bool) and duration > 0:
+        minutes = int(duration)
+        if minutes == 300:
+            label = "Muse 5-hour"
+        elif minutes == 10080:
+            label = "Muse weekly"
+        else:
+            label = f"Muse {minutes}m"
+    resets = _epoch_to_utc(spec.get("resets_at"))
+    raw = {
+        "used_percent": used,
+        "resets_at": spec.get("resets_at"),
+        "window_duration_mins": spec.get("window_duration_mins"),
+    }
+    return QuotaWindow(
+        label=label,
+        used_percent=used,
+        remaining_percent=max(0.0, 100.0 - used),
+        resets_at=resets,
+        window_minutes=minutes,
+        raw={key: value for key, value in raw.items() if value is not None},
+    )
+
+
+def _plan_note_from_key_payload(payload: Any, windows: list[QuotaWindow]) -> str | None:
+    if not isinstance(payload, dict):
+        return None
+    tier = payload.get("subs_tier_name")
+    if isinstance(tier, str) and tier.strip():
+        return f"Muse Code plan: {tier.strip()}."
+    if payload.get("is_subs_active") is False and not windows:
+        return (
+            "Muse Code subscription is inactive, so Meta reports no plan usage percent. "
+            "The row is pay-as-you-go spend only."
+        )
+    return None
+
+
+def _read_muse_keychain_access_token() -> str | None:
+    """OAuth access token from the Muse CLI login. Never the API key."""
+    try:
+        result = subprocess.run(
+            [
+                "security",
+                "find-generic-password",
+                "-s",
+                _KEYCHAIN_SERVICE,
+                "-a",
+                _KEYCHAIN_ACCOUNT,
+                "-w",
+            ],
+            capture_output=True,
+            text=True,
+            timeout=5,
+            check=False,
+        )
+    except (OSError, subprocess.TimeoutExpired):
+        return None
+    if result.returncode != 0:
+        return None
+    try:
+        payload = json.loads(result.stdout.strip())
+    except json.JSONDecodeError:
+        return None
+    if not isinstance(payload, dict):
+        return None
+    token = payload.get("access_token")
+    if not isinstance(token, str) or not token.strip():
+        return None
+    return token.strip()
+
+
+def _fetch_muse_code_key(token: str, timeout: float) -> dict[str, Any] | None:
+    try:
+        response = requests.post(
+            _MUSE_CODE_KEY_URL,
+            json={},
+            timeout=timeout,
+            headers={
+                "Authorization": f"Bearer {token}",
+                "Accept": "application/json",
+                "Content-Type": "application/json",
+                "x-api-version": "1.0.0",
+                "User-Agent": _USER_AGENT,
+            },
+        )
+    except requests.RequestException:
+        return None
+    if response.status_code != 200:
+        return None
+    try:
+        payload = response.json()
+    except ValueError:
+        return None
+    if not isinstance(payload, dict):
+        return None
+    # The response repeats the API key. Do not keep it on the account.
+    payload.pop("api_key", None)
+    payload.pop("user_email", None)
+    payload.pop("user_avatar_url", None)
+    return payload
+
+
+def _subscription_windows_for_local_login(timeout: float) -> tuple[list[QuotaWindow], str | None]:
+    """Plan windows from the local Muse CLI login.
+
+    The key endpoint is rate-limited, and ``aiuse watch`` collects on a short
+    interval, so a hit is reused for five minutes. Unit tests must not read
+    the operator keychain or call Meta.
+    """
+    if os.environ.get("PYTEST_CURRENT_TEST"):
+        return [], None
+    now = time.monotonic()
+    with _subs_cache_lock:
+        cached_at = float(_subs_cache.get("at") or 0.0)
+        cached = _subs_cache.get("payload")
+        if isinstance(cached, dict) and now - cached_at < _SUBS_CACHE_TTL_S:
+            payload = cached
+        else:
+            payload = None
+    if payload is None:
+        token = _read_muse_keychain_access_token()
+        payload = _fetch_muse_code_key(token, timeout) if token else None
+        # Cache a miss too, so a locked keychain or an inactive plan does not
+        # hit the rate-limited key endpoint on every watch tick.
+        stored = payload if isinstance(payload, dict) else {}
+        with _subs_cache_lock:
+            _subs_cache["at"] = time.monotonic()
+            _subs_cache["payload"] = stored
+        payload = stored
+    windows = _windows_from_subs_usage(payload)
+    return windows, _plan_note_from_key_payload(payload, windows)
+
+
+def _merge_subscription_windows(
+    accounts: list[AccountUsage],
+    timeout: float,
+    *,
+    allow_local: bool,
+) -> list[AccountUsage]:
+    """Attach Muse Code plan windows when the local login reports them."""
+    if not accounts or not allow_local:
+        return accounts
+    windows, note = _subscription_windows_for_local_login(timeout)
+    if not windows and not note:
+        return accounts
+    for row in accounts:
+        if row.error:
+            continue
+        if windows:
+            present = {window.label for window in row.windows}
+            row.windows.extend(window for window in windows if window.label not in present)
+            if row.billing_kind == BillingKind.PAYG_API:
+                row.billing_kind = BillingKind.SUBSCRIPTION_WINDOW
+        if note and note not in row.notes:
+            row.notes.append(note)
+    return accounts
+
+
 def _resolve_key_and_account(
     env: Mapping[str, str],
     timeout: float,

{aiuse-3.2.6 → aiuse-3.2.7}/src/aiuse/collectors/openusage_sh.py

@@ -29,7 +29,7 @@ def _window_label(provider_id: str, key: str, metric: dict[object, object]) -> s
     return "weekly" if label.casefold() == "7d" else label
 
 
-def collect_openusage_sh(*, timeout: float = 45.0) -> list[AccountUsage]:
+def collect_openusage_sh(*, timeout: float = 90.0) -> list[AccountUsage]:
     """Read OpenUsage.sh's documented versioned JSON export.
 
     Only explicit subscription/rate-limit percentage metrics become quota

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

@@ -335,7 +335,16 @@ def _select_and_cross_check(
                 selected.extend(primary_rows)
             else:
                 live = [a for a in primary_rows if _has_live_data(a)]
-                selected.extend(live if live else primary_rows)
+                # A Max-plan OpenUsage.ai row with zero windows is an identity
+                # label, not a Claude reading. Keeping it is what showed Claude
+                # with no usage when CodexBar and cswap returned nothing.
+                blank_openusage_claude = (
+                    provider == "claude" and primary == "openusage_ai" and not any(row.error for row in primary_rows)
+                )
+                if live:
+                    selected.extend(live)
+                elif not blank_openusage_claude:
+                    selected.extend(primary_rows)
         else:
             # No priority source present — keep whatever we have.
             selected.extend(rows)

{aiuse-3.2.6 → aiuse-3.2.7}/src/aiuse/config.py

@@ -17,6 +17,13 @@ from typing import Any
 # Default wall-clock budget for every external CLI subprocess. Tools either
 # return within tens of seconds or hang; long budgets only delay failure.
 DEFAULT_SUBPROCESS_TIMEOUT = 45.0
+# `cswap list --json` is one subprocess. Beside the other collectors it crossed
+# 45s (snapshot 2026-10-04T12:55:23Z), and Claude then had no canonical row.
+# Same 90s budget as OpenUsage.sh: long enough for that slow success.
+CSWAP_TIMEOUT = 90.0
+# `openusage-sh export` polls every configured provider. A quiet run is about
+# 30s, and the same export often crosses 45s while the other collectors run.
+OPENUSAGE_SH_TIMEOUT = 90.0
 
 DEFAULT_CONFIG: dict[str, Any] = {
     # Subprocess timeouts (seconds). ``default`` applies to any tool that does
@@ -24,6 +31,8 @@ DEFAULT_CONFIG: dict[str, Any] = {
     # tokscale. Override via config.toml or CLI ``--timeout`` / ``-t``.
     "timeouts": {
         "default": DEFAULT_SUBPROCESS_TIMEOUT,
+        "cswap": CSWAP_TIMEOUT,
+        "openusage_sh": OPENUSAGE_SH_TIMEOUT,
     },
     "analysis": {
         "min_remaining_percent": 40,
@@ -684,13 +693,13 @@ def _default_toml_text() -> str:
         "# Tools either return quickly or hang — long budgets only delay failure.\n"
         f"default = {DEFAULT_SUBPROCESS_TIMEOUT:g}\n"
         "\n"
-        "# Optional per-tool overrides (omit to use default):\n"
-        "# cswap = 45\n"
+        "# Optional per-tool overrides (omit to use the built-in for that tool):\n"
+        "# cswap = 90\n"
         "# codexbar = 45\n"
         "# codexbar_discovery = 45   # `codexbar config providers` (local, usually ms)\n"
         "# caut = 45\n"
         "# openusage_ai = 45\n"
-        "# openusage_sh = 45\n"
+        "# openusage_sh = 90\n"
         "# tokscale = 45\n"
         "# hermes = 45\n"
         "\n"

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aiuse
-Version: 3.2.6
+Version: 3.2.7
 Summary: Aggregate AI subscription/API usage and flag use-it-or-lose-it allotments
 Author: djbclark
 License-Expression: MIT
@@ -510,7 +510,7 @@ Lapsed subscriptions: `analysis.lapsed_accounts` maps `"provider/account"` to a
 ## Notes / limitations
 
 - Live quota accuracy depends on each tool's auth (browser cookies, OAuth, keychain). Errors are reported per account rather than aborting the whole run.
-- All enabled collectors (cswap, CodexBar, caut, OpenUsage.ai, OpenUsage.sh, tokscale, qwencloud, bailian) run concurrently; each CodexBar provider is its own subprocess. Default tool timeout is **45s** (`-t` / `config.toml [timeouts]`).
+- All enabled collectors (cswap, CodexBar, caut, OpenUsage.ai, OpenUsage.sh, tokscale, qwencloud, bailian) run concurrently; each CodexBar provider is its own subprocess. Default tool timeout is **45s**; `cswap` and `openusage_sh` are **90s** (`-t` / `config.toml [timeouts]`).
 - Per-window detail still shows $ value, flexibility class, and a **pace** ratio when computable.
 - Duplicate live measurements are retained for cross-checking but only one copy drives recommendations.
 - Dollar values use plan `monthly_price` with waking-hours correction (default 16h/day).

{aiuse-3.2.6 → aiuse-3.2.7}/tests/test_config.py

@@ -3,8 +3,10 @@ from pathlib import Path
 import pytest
 
 from aiuse.config import (
+    CSWAP_TIMEOUT,
     DEFAULT_CONFIG,
     DEFAULT_SUBPROCESS_TIMEOUT,
+    OPENUSAGE_SH_TIMEOUT,
     collector_health_url,
     default_config_dir,
     default_config_path,
@@ -112,7 +114,9 @@ def test_explicit_config_remains_usable_when_both_default_files_exist(monkeypatc
     (config_dir / "services.yaml").write_text("analysis:\n  min_remaining_percent: 55\n", encoding="utf-8")
     monkeypatch.setenv("XDG_CONFIG_HOME", str(tmp_path))
 
-    assert timeout_for(load_config(canonical), "cswap") == 30
+    loaded = load_config(canonical)
+    assert timeout_for(loaded, "tokscale") == 30
+    assert timeout_for(loaded, "cswap") == 90
 
 
 def test_load_config_explicit_missing_path_exits():
@@ -132,6 +136,10 @@ def test_default_timeouts_are_45s():
     assert DEFAULT_SUBPROCESS_TIMEOUT == 45.0
     assert timeout_for({}, "tokscale") == 45.0
     assert timeout_for({"timeouts": {"default": 45}}, "cswap") == 45.0
+    assert OPENUSAGE_SH_TIMEOUT == 90.0
+    assert CSWAP_TIMEOUT == 90.0
+    assert timeout_for(DEFAULT_CONFIG, "openusage_sh") == 90.0
+    assert timeout_for(DEFAULT_CONFIG, "cswap") == 90.0
 
 
 def test_timeout_for_per_tool_and_force_precedence():
@@ -140,6 +148,8 @@ def test_timeout_for_per_tool_and_force_precedence():
     cfg_no_force = {"timeouts": {"default": 45, "tokscale": 20}}
     assert timeout_for(cfg_no_force, "tokscale") == 20.0
     assert timeout_for(cfg_no_force, "cswap") == 45.0
+    assert timeout_for({"timeouts": {"openusage_sh": 20}}, "openusage_sh") == 20.0
+    assert timeout_for({"timeouts": {"cswap": 30}}, "cswap") == 30.0
 
 
 def test_load_config_merges_toml_timeouts(monkeypatch, tmp_path):
@@ -153,8 +163,10 @@ def test_load_config_merges_toml_timeouts(monkeypatch, tmp_path):
 
     config = load_config()
 
-    assert timeout_for(config, "cswap") == 30.0
     assert timeout_for(config, "tokscale") == 12.0
+    # A generic default does not erase the built-in cswap or OpenUsage.sh budget.
+    assert timeout_for(config, "cswap") == 90.0
+    assert timeout_for(config, "openusage_sh") == 90.0
 
 
 def test_ensure_config_dir_creates_nested_levels(monkeypatch, tmp_path):

{aiuse-3.2.6 → aiuse-3.2.7}/tests/test_muse.py

@@ -6,7 +6,7 @@ import requests
 
 from aiuse.collectors.base import CollectorError
 from aiuse.collectors.muse import collect_muse
-from aiuse.models import BillingKind
+from aiuse.models import AccountUsage, BillingKind, UsageCredits
 
 
 def test_collect_muse_is_quiet_until_key_is_explicitly_supplied():
@@ -605,3 +605,85 @@ def test_collect_via_cookie_rejected_session_does_not_scrape_html(monkeypatch):
     with pytest.raises(CollectorError, match="api/auth/login"):
         muse_mod._collect_via_cookie("llm_sess=stale", {}, 5.0)
     assert seen == ["https://dev.meta.ai/api/auth/me"]
+
+
+def test_windows_from_subs_usage_maps_five_hour_and_weekly():
+    from aiuse.collectors import muse as muse_mod
+
+    windows = muse_mod._windows_from_subs_usage(
+        {
+            "is_subs_active": True,
+            "subs_tier_name": "Everyday Usage",
+            "subs_usage": {
+                "window": {
+                    "used_percent": 12,
+                    "resets_at": 1788431188,
+                    "window_duration_mins": 300,
+                },
+                "weekly": {"used_percent": 4, "resets_at": 1788739200},
+            },
+        }
+    )
+    by_label = {window.label: window for window in windows}
+    assert set(by_label) == {"Muse 5-hour", "Muse weekly"}
+    assert by_label["Muse 5-hour"].used_percent == 12
+    assert by_label["Muse 5-hour"].remaining_percent == 88
+    assert by_label["Muse 5-hour"].window_minutes == 300
+    assert by_label["Muse 5-hour"].resets_at is not None
+    assert by_label["Muse weekly"].used_percent == 4
+    assert by_label["Muse weekly"].window_minutes == 10080
+
+
+def test_windows_from_subs_usage_keeps_zero_and_drops_inactive_payload():
+    from aiuse.collectors import muse as muse_mod
+
+    untouched = muse_mod._windows_from_subs_usage(
+        {"subs_usage": {"window": {"used_percent": 0, "window_duration_mins": 300}}}
+    )
+    assert untouched[0].used_percent == 0
+    assert untouched[0].remaining_percent == 100
+    assert muse_mod._windows_from_subs_usage({"is_subs_active": False, "subs_usage": None}) == []
+    note = muse_mod._plan_note_from_key_payload({"is_subs_active": False}, [])
+    assert note is not None
+    assert "no plan usage percent" in note
+
+
+def test_merge_subscription_windows_promotes_spend_row(monkeypatch):
+    from aiuse.collectors import muse as muse_mod
+
+    windows = muse_mod._windows_from_subs_usage(
+        {
+            "subs_usage": {
+                "window": {"used_percent": 20, "window_duration_mins": 300},
+                "weekly": {"used_percent": 7},
+            }
+        }
+    )
+    monkeypatch.setattr(
+        muse_mod,
+        "_subscription_windows_for_local_login",
+        lambda _timeout: (windows, "Muse Code plan: Everyday Usage."),
+    )
+    row = AccountUsage(
+        source="muse",
+        provider="muse",
+        billing_kind=BillingKind.PAYG_API,
+        usage_credits=UsageCredits(used=0.30, currency="USD"),
+        notes=["spent already"],
+    )
+    merged = muse_mod._merge_subscription_windows([row], 5.0, allow_local=True)
+    assert merged[0].billing_kind == BillingKind.SUBSCRIPTION_WINDOW
+    assert merged[0].usage_credits is not None
+    assert merged[0].usage_credits.used == 0.30
+    assert [window.label for window in merged[0].windows] == ["Muse 5-hour", "Muse weekly"]
+    assert "Muse Code plan: Everyday Usage." in merged[0].notes
+
+    untouched = AccountUsage(
+        source="muse",
+        provider="muse",
+        billing_kind=BillingKind.PAYG_API,
+        usage_credits=UsageCredits(used=1.0, currency="USD"),
+    )
+    skipped = muse_mod._merge_subscription_windows([untouched], 5.0, allow_local=False)
+    assert skipped[0].billing_kind == BillingKind.PAYG_API
+    assert skipped[0].windows == []

{aiuse-3.2.6 → aiuse-3.2.7}/tests/test_runner_consolidation.py

@@ -379,6 +379,28 @@ def test_claude_falls_back_to_tokscale_when_cswap_and_codexbar_empty():
     assert any("falling back" in check.message for check in checks)
 
 
+def test_openusage_ai_claude_without_windows_is_not_a_reading():
+    row = _account("openusage_ai", "claude")
+    row.windows = []
+    row.plan = "Max 5x"
+
+    selected, checks = _select_and_cross_check([row], cswap_authoritative=True)
+
+    assert selected == []
+    assert any("cswap returned no" in check.message for check in checks)
+
+
+def test_openusage_ai_claude_without_windows_does_not_hide_a_live_peer():
+    empty = _account("openusage_ai", "claude")
+    empty.windows = []
+    empty.plan = "Max 5x"
+    tokscale = _account("tokscale", "claude")
+
+    selected, _checks = _select_and_cross_check([empty, tokscale], cswap_authoritative=True)
+
+    assert [account.source for account in selected] == ["tokscale"]
+
+
 def test_claude_keeps_cswap_error_when_no_alternate_live_source():
     cswap_err = _account("cswap", "claude", error="no data")
     selected, checks = _select_and_cross_check([cswap_err], cswap_authoritative=True)