playmaker-cli 0.9.0__tar.gz → 0.10.0__tar.gz

{playmaker_cli-0.9.0 → playmaker_cli-0.10.0}/CHANGELOG.md

@@ -5,6 +5,31 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.10.0] - 2026-09-04
+
+### Added
+
+- **`playmaker quotas` shows the two buckets that actually run out first.**
+  Codex's `additional_rate_limits[]` carries a separate GPT-5.3-Codex-Spark
+  pool with its own 5h and weekly windows, and Anthropic's `limits[]` carries
+  a model-scoped weekly next to the all-models one. Both were in the raw
+  responses and dropped by the probe, so a coach could route a junior WP to
+  Spark while its weekly sat at 4%, or budget a session on the all-models bar
+  while its own model-scoped bucket was the one about to end it. Codex now
+  renders a `Codex — Spark` sub-block and Claude a `Weekly · <model>` row;
+  probes return an additive `blocks` key that `_render_provider` draws for any
+  provider.
+
+### Changed
+
+- **The coach no longer tiers Antigravity's Claude models by name.**
+  `lanes.md` called `agy`'s Claude-Opus "top-tier Claude judgment on Google's
+  pool" and offered it as the reviewer to reach for when the Anthropic bucket
+  is precious. That roster trails Anthropic's releases by a generation, and
+  the name kept pulling real work onto it. The reference now says to tier by
+  the version `agy models` shows, and points the second-strong-reviewer row
+  at Gemini Pro.
+
 ## [0.9.0] - 2026-08-24
 
 ### Added

{playmaker_cli-0.9.0 → playmaker_cli-0.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: playmaker-cli
-Version: 0.9.0
+Version: 0.10.0
 Summary: Playing-coach CLI for orchestrating Claude Code, Codex, Antigravity and opencode sub-agents in parallel.
 Project-URL: Homepage, https://github.com/vladsafedev/playmaker
 Project-URL: Repository, https://github.com/vladsafedev/playmaker
@@ -391,14 +391,19 @@ stores, no scraping and no browser.
 ```console
 $ playmaker quotas --refresh
 Claude  Max 20x
-  Session     ████████████████░░░░ 80% left   resets in 3h 12m
-  Weekly      ███████████░░░░░░░░░ 55% left   resets in 4d 6h
-  Sonnet      ███████████████████░ 95% left   resets in 4d 6h
+  Session        ████████████████░░░░ 80% left   resets in 3h 12m
+  Weekly         ███████████░░░░░░░░░ 55% left   resets in 4d 6h
+  Weekly · Fable ██████░░░░░░░░░░░░░░ 28% left   resets in 4d 6h
+  Sonnet         ███████████████████░ 95% left   resets in 4d 6h
 
 Codex  Plus
   Session     ██████████████████░░ 90% left   resets in 1h 40m
   Weekly      █████████████░░░░░░░ 65% left   resets in 2d 9h
 
+Codex — Spark
+  Session     ████████████████████ 100% left  resets in 4h 59m
+  Weekly      ██░░░░░░░░░░░░░░░░░░ 8% left    resets in 5d 22h
+
 Antigravity (agy)
   Gemini 5h         ████████████████████ 100% left
   Gemini weekly     ███████████████████░ 95% left
@@ -411,12 +416,16 @@ Z.ai (GLM, via opencode)  Max
   MCP tools   ███████████████████░ 99% left   resets in 25d 11h
 ```
 
-The `Weekly` and `Sonnet` rows above are the point: they are **separate
-buckets**. So is every agy row, and so is the whole Z.ai block. Routing a
-subtask is choosing which of them to spend.
+The `Weekly`, `Weekly · Fable` and `Sonnet` rows above are the point: they are
+**separate buckets**. So is the `Codex — Spark` block, every agy row, and the
+whole Z.ai block. Routing a subtask is choosing which of them to spend.
 
 - **Claude** — OAuth usage API; token from the Claude Code Keychain entry.
-- **Codex** — ChatGPT `wham/usage` API; token from `~/.codex/auth.json`.
+  Model-scoped weekly buckets come from the usage API's `limits[]` array and
+  print as `Weekly · <model>`.
+- **Codex** — ChatGPT `wham/usage` API; token from `~/.codex/auth.json`. The
+  Spark model's own 5-hour and weekly windows come from
+  `additional_rate_limits[]` and print as their own `Codex — Spark` block.
 - **Antigravity** — prefers agy's **local daemon**
   (`RetrieveUserQuotaSummary` over its embedded gRPC-web endpoint), which is
   the only source for the full categorized breakdown above. Works whenever any

{playmaker_cli-0.9.0 → playmaker_cli-0.10.0}/README.md

@@ -364,14 +364,19 @@ stores, no scraping and no browser.
 ```console
 $ playmaker quotas --refresh
 Claude  Max 20x
-  Session     ████████████████░░░░ 80% left   resets in 3h 12m
-  Weekly      ███████████░░░░░░░░░ 55% left   resets in 4d 6h
-  Sonnet      ███████████████████░ 95% left   resets in 4d 6h
+  Session        ████████████████░░░░ 80% left   resets in 3h 12m
+  Weekly         ███████████░░░░░░░░░ 55% left   resets in 4d 6h
+  Weekly · Fable ██████░░░░░░░░░░░░░░ 28% left   resets in 4d 6h
+  Sonnet         ███████████████████░ 95% left   resets in 4d 6h
 
 Codex  Plus
   Session     ██████████████████░░ 90% left   resets in 1h 40m
   Weekly      █████████████░░░░░░░ 65% left   resets in 2d 9h
 
+Codex — Spark
+  Session     ████████████████████ 100% left  resets in 4h 59m
+  Weekly      ██░░░░░░░░░░░░░░░░░░ 8% left    resets in 5d 22h
+
 Antigravity (agy)
   Gemini 5h         ████████████████████ 100% left
   Gemini weekly     ███████████████████░ 95% left
@@ -384,12 +389,16 @@ Z.ai (GLM, via opencode)  Max
   MCP tools   ███████████████████░ 99% left   resets in 25d 11h
 ```
 
-The `Weekly` and `Sonnet` rows above are the point: they are **separate
-buckets**. So is every agy row, and so is the whole Z.ai block. Routing a
-subtask is choosing which of them to spend.
+The `Weekly`, `Weekly · Fable` and `Sonnet` rows above are the point: they are
+**separate buckets**. So is the `Codex — Spark` block, every agy row, and the
+whole Z.ai block. Routing a subtask is choosing which of them to spend.
 
 - **Claude** — OAuth usage API; token from the Claude Code Keychain entry.
-- **Codex** — ChatGPT `wham/usage` API; token from `~/.codex/auth.json`.
+  Model-scoped weekly buckets come from the usage API's `limits[]` array and
+  print as `Weekly · <model>`.
+- **Codex** — ChatGPT `wham/usage` API; token from `~/.codex/auth.json`. The
+  Spark model's own 5-hour and weekly windows come from
+  `additional_rate_limits[]` and print as their own `Codex — Spark` block.
 - **Antigravity** — prefers agy's **local daemon**
   (`RetrieveUserQuotaSummary` over its embedded gRPC-web endpoint), which is
   the only source for the full categorized breakdown above. Works whenever any

{playmaker_cli-0.9.0 → playmaker_cli-0.10.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "playmaker-cli"
-version = "0.9.0"
+version = "0.10.0"
 description = "Playing-coach CLI for orchestrating Claude Code, Codex, Antigravity and opencode sub-agents in parallel."
 readme = "README.md"
 requires-python = ">=3.11"

{playmaker_cli-0.9.0 → playmaker_cli-0.10.0}/skills/playmaker-coach/references/lanes.md

@@ -21,9 +21,11 @@ pays. Four lanes:
 4. **External dispatch — `codex` / `agy` / `opencode`.** Each on its own subscription or plan — the
    home for write-heavy parallel implementation that can leave the Anthropic subscription.
    - **`agy` (Antigravity)** carries more than Google models: alongside Gemini Flash and Pro tiers it
-     serves **Claude Sonnet/Opus (Thinking)** and a GPT-OSS mid tier. Its Claude runs on *Google's*
-     pool — top-tier Claude judgment that spends none of the Anthropic bucket. Note the internal
-     split: all Gemini models share one bucket, Claude and GPT-OSS share another.
+     serves **Claude Sonnet/Opus (Thinking)** and a GPT-OSS tier. Its Claude runs on *Google's*
+     pool and spends none of the Anthropic bucket — but that roster has trailed Anthropic's own
+     releases by a generation (Claude 4.6 on agy while Claude 5 ships on Anthropic), so tier it by
+     the version `agy models` shows, never by the name. Note the internal split: all Gemini models
+     share one bucket, Claude and GPT-OSS share another.
    - **`opencode`** is the widest lane: one CLI over ~75 providers addressed as `provider/model` — a
      GLM coding plan, or a model running locally on this machine, which spends no subscription quota
      at all.
@@ -40,17 +42,17 @@ against the live roster, failing the dispatch on a stale name.
 | is an independent stream to monitor separately | `dispatch claude --model sonnet` | tracked, detached, spares the top bucket |
 | is heavy reasoning only the coach can do | coach | top tier, serial |
 | is write-heavy and can leave Claude | codex / agy / opencode | their own quotas |
-| needs top-tier Claude but the Anthropic bucket is precious | `dispatch agy --model <claude-opus-thinking>` | Claude quality on Google's pool |
+| needs a second strong reviewer without touching the Anthropic bucket | `dispatch agy --model <gemini-pro-high>` | near-senior judgment on an uncontended pool |
 | is bulk work with every subscription low | `dispatch opencode --model <plan>/<model>` | a separate plan, untouched by the others |
 | is mechanical and privacy-sensitive, or all quotas spent | `dispatch opencode --model <local>/<model>` | runs on this machine, costs wall-clock only |
 
 ## Tier-matching
 
-- **Architectural / spec judgment / cross-module integration** → top tier (coach, agy's Claude-Opus
-  or Gemini-Pro-high, top-tier Codex).
+- **Architectural / spec judgment / cross-module integration** → top tier (coach, top-tier Codex,
+  Gemini-Pro-high on agy for review and advice rather than implementation).
 - **Pattern-following implementation, scoped CRUD, mechanical refactor, test scaffolding, writing
-  inside an existing convention** → mid tier (Claude Sonnet, agy's Claude-Sonnet / Gemini-Pro-low,
-  mid-tier Codex). Most delegated implementation lives here.
+  inside an existing convention** → mid tier (Claude Sonnet, Gemini-Pro-low, mid-tier Codex;
+  agy's Claude models only when the roster shows a current version). Most delegated implementation lives here.
 - **Recon, summarization, mechanical loops over many files, normalization** → cheap tier (Flash
   tiers, Haiku, fast Codex modes).
 

{playmaker_cli-0.9.0 → playmaker_cli-0.10.0}/skills/playmaker-coach/references/quotas.md

@@ -13,15 +13,17 @@ the plan instead of quoting the numbers.
 several tiers with independent buckets, and the whole point of pulling quotas is to push work
 *away from* the depleted bucket and *toward* the fresh one.
 
-- **Claude:** the top-tier weekly and the mid-tier weekly are **independent**. The coach and
-  in-session sub-agents spend the top one; the mid tier usually sits idle. Push mid-tier work there
-  instead of burning the scarce bucket.
+- **Claude:** the block shows the account-wide `Weekly` plus one `Weekly · <model>` row per
+  model-scoped bucket (e.g. `Weekly · Fable`). The model-scoped row is the one that empties first
+  during a long coach session — read it, not just `Weekly`.
 - **Antigravity (`agy`):** one Google pool split by family — `Gemini 5h` / `Gemini weekly` and
   `Claude/GPT 5h` / `Claude/GPT weekly`. All Gemini models share the first; Claude *and* GPT-OSS
   share the second. So one Gemini reviewer plus one agy-Claude reviewer costs one hit in each of two
   separate buckets — the cheapest way to buy two independent opinions. Requires agy's local daemon;
   if the table says "daemon offline" it fell back to a coarse Gemini-only view.
-- **Codex:** top-tier versus lighter modes, where the account plan carries them.
+- **Codex:** the main block is the primary Codex window; `Codex — Spark` is a separate block with
+  its own `Session` / `Weekly` rows for the Spark model, the junior Codex lane — route Spark work
+  off that block, not off the main one.
 - **opencode:** the quota belongs to the *plan behind the provider*, not to the CLI — it appears
   under that provider (e.g. a GLM coding plan's session and weekly credit windows) and reads
   unsupported without a credential. A dispatch pointed at a **local** model spends nothing and never

{playmaker_cli-0.9.0 → playmaker_cli-0.10.0}/src/playmaker/cli.py

@@ -978,6 +978,25 @@ def quotas(
 
 
 def _render_provider(name: str, info: dict) -> None:
+    def render_windows(windows: list[dict]) -> None:
+        # Adaptive name column so longer categorized labels (e.g. "Claude/GPT
+        # weekly") keep the bars aligned instead of overflowing a fixed width.
+        name_width = max(11, *(len(w["name"]) for w in windows))
+        for window in windows:
+            pct = window.get("pct_left")
+            bar = _bar(pct) if isinstance(pct, int) else " " * 20
+            line = f"  [bold]{window['name']:<{name_width}}[/bold] {bar} {pct}% left"
+            right_parts = []
+            if window.get("reset_relative"):
+                right_parts.append(f"resets in {window['reset_relative']}")
+            if window.get("forecast"):
+                right_parts.append(window["forecast"])
+            if window.get("reserve_pct") is not None:
+                right_parts.append(f"{window['reserve_pct']}% in reserve")
+            if right_parts:
+                line += f"   [dim]{'  ·  '.join(right_parts)}[/dim]"
+            console.print(line)
+
     status = info.get("status")
     label_color = {
         "codex": "blue",
@@ -1017,27 +1036,13 @@ def _render_provider(name: str, info: dict) -> None:
         return
 
     windows = info.get("windows") or []
+    blocks = info.get("blocks") or []
     if not windows:
         console.print("  [dim]no quota windows reported[/dim]")
-        return
-
-    # Adaptive name column so longer categorized labels (e.g. "Claude/GPT
-    # weekly") keep the bars aligned instead of overflowing a fixed width.
-    name_width = max(11, *(len(w["name"]) for w in windows))
-    for w in windows:
-        pct = w.get("pct_left")
-        bar = _bar(pct) if isinstance(pct, int) else " " * 20
-        line = f"  [bold]{w['name']:<{name_width}}[/bold] {bar} {pct}% left"
-        right_parts = []
-        if w.get("reset_relative"):
-            right_parts.append(f"resets in {w['reset_relative']}")
-        if w.get("forecast"):
-            right_parts.append(w["forecast"])
-        if w.get("reserve_pct") is not None:
-            right_parts.append(f"{w['reserve_pct']}% in reserve")
-        if right_parts:
-            line += f"   [dim]{'  ·  '.join(right_parts)}[/dim]"
-        console.print(line)
+        if not blocks:
+            return
+    else:
+        render_windows(windows)
 
     # A local provider has models where the metered ones have tiers; naming them
     # saves the coach a round-trip to `ollama list` before it can route here.
@@ -1059,6 +1064,13 @@ def _render_provider(name: str, info: dict) -> None:
             f"  [bold]{'Extra usage':<11}[/bold] ${used:.2f} / ${limit:.2f}   [dim]{util_str}[/dim]"
         )
 
+    for block in blocks:
+        block_windows = block.get("windows") or []
+        console.print()
+        console.print(f"[bold {label_color}]{display} — {block['name']}[/bold {label_color}]")
+        if block_windows:
+            render_windows(block_windows)
+
 
 def _bar(pct: int, width: int = 20) -> str:
     pct = max(0, min(100, pct))

{playmaker_cli-0.9.0 → playmaker_cli-0.10.0}/src/playmaker/quotas.py

@@ -242,6 +242,23 @@ def codex_probe() -> dict:
             raise
 
     rate = usage.get("rate_limit") or {}
+    reserve = _codex_reserve_from_additional(usage) if rate.get("secondary_window") else None
+    windows = _codex_windows(
+        rate, reserve_pct=reserve
+    )
+    spark_windows = _codex_spark_windows(usage)
+
+    return {
+        "status": "ok",
+        "account_email": payload.get("email"),
+        "tier": _humanize_codex_tier(usage.get("plan_type")),
+        "windows": windows,
+        "blocks": [{"name": "Spark", "windows": spark_windows}] if spark_windows else [],
+    }
+
+
+def _codex_windows(rate: dict, *, reserve_pct: int | None = None) -> list[dict]:
+    """Build the standard Session and Weekly rows for a Codex rate-limit block."""
     primary = rate.get("primary_window") or {}
     secondary = rate.get("secondary_window") or {}
 
@@ -266,10 +283,6 @@ def codex_probe() -> dict:
             (win_secs - max(0, (reset_at or 0) - time.time())) if reset_at else 0
         )
         forecast = _forecast_label(used, win_secs, elapsed)
-        # "In reserve" — averaged unused weekly across the additional metered
-        # rate-limits (CodexBar surfaces this so users see they have headroom
-        # in alternative buckets like Codex-Spark).
-        reserve = _codex_reserve_from_additional(usage)
         windows.append(
             {
                 "name": "Weekly",
@@ -277,16 +290,28 @@ def codex_probe() -> dict:
                 "reset_at_iso": _epoch_to_iso(reset_at),
                 "reset_relative": _format_relative(reset_at),
                 "forecast": forecast,
-                "reserve_pct": reserve,
+                "reserve_pct": reserve_pct,
             }
         )
 
-    return {
-        "status": "ok",
-        "account_email": payload.get("email"),
-        "tier": _humanize_codex_tier(usage.get("plan_type")),
-        "windows": windows,
-    }
+    return windows
+
+
+def _codex_spark_windows(usage: dict) -> list[dict]:
+    """Return the Codex-Spark rate-limit rows, if the provider reports them."""
+    extras = usage.get("additional_rate_limits") or []
+    if not isinstance(extras, list):
+        return []
+    for extra in extras:
+        if not isinstance(extra, dict):
+            continue
+        feature = extra.get("metered_feature")
+        limit_name = extra.get("limit_name")
+        if feature == "codex_bengalfox" or (
+            isinstance(limit_name, str) and "spark" in limit_name.lower()
+        ):
+            return _codex_windows(extra.get("rate_limit") or {})
+    return []
 
 
 def _codex_reserve_from_additional(usage: dict) -> int | None:
@@ -473,6 +498,52 @@ def claude_probe() -> dict:
             }
         )
 
+    scoped_windows: list[dict] = []
+    limits = usage.get("limits")
+    if isinstance(limits, list):
+        for limit in limits:
+            if not isinstance(limit, dict) or limit.get("kind") != "weekly_scoped":
+                continue
+            percent = limit.get("percent")
+            scope = limit.get("scope")
+            model = scope.get("model") if isinstance(scope, dict) else None
+            display_name = model.get("display_name") if isinstance(model, dict) else None
+            if isinstance(percent, bool) or not isinstance(percent, (int, float)):
+                continue
+            if not isinstance(display_name, str):
+                continue
+
+            resets_at = limit.get("resets_at")
+            forecast: str | None = None
+            if isinstance(resets_at, str):
+                try:
+                    reset_dt = datetime.fromisoformat(resets_at.replace("Z", "+00:00"))
+                    remaining = reset_dt.timestamp() - now
+                    elapsed = max(0.0, 7 * 86400 - remaining)
+                    forecast = _forecast_label(float(percent), 7 * 86400, elapsed)
+                except ValueError:
+                    pass
+            scoped_windows.append(
+                {
+                    "name": f"Weekly · {display_name}",
+                    "pct_left": int(round(100 - float(percent))),
+                    "reset_at_iso": resets_at,
+                    "reset_relative": _format_relative(resets_at),
+                    "forecast": forecast,
+                    "reserve_pct": None,
+                }
+            )
+
+    if scoped_windows:
+        weekly_index = next(
+            (index for index, window in enumerate(windows) if window["name"] == "Weekly"),
+            None,
+        )
+        if weekly_index is None:
+            windows.extend(scoped_windows)
+        else:
+            windows[weekly_index + 1 : weekly_index + 1] = scoped_windows
+
     # `extra_usage` is the user's monthly overage allowance — surface only
     # as a top-level field, not as the weekly window's reserve %.
     extra = usage.get("extra_usage") or {}

playmaker_cli-0.10.0/tests/test_quotas_claude.py

@@ -0,0 +1,197 @@
+"""Claude quota probe coverage for model-scoped weekly limits."""
+
+from __future__ import annotations
+
+import sys
+from copy import deepcopy
+from pathlib import Path
+
+import pytest
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "src"))
+
+import playmaker.quotas as quotas
+
+# Captured verbatim from api.anthropic.com/api/oauth/usage on a live Max plan.
+_PAYLOAD = {
+    "five_hour": {
+        "utilization": 14.0,
+        "resets_at": "2026-09-04T19:00:00.208321+00:00",
+        "limit_dollars": None,
+        "used_dollars": None,
+        "remaining_dollars": None,
+        "locked_reason": None,
+    },
+    "seven_day": {
+        "utilization": 46.0,
+        "resets_at": "2026-09-05T03:00:00.208343+00:00",
+        "limit_dollars": None,
+        "used_dollars": None,
+        "remaining_dollars": None,
+        "locked_reason": None,
+    },
+    "seven_day_oauth_apps": None,
+    "seven_day_opus": None,
+    "seven_day_sonnet": None,
+    "seven_day_cowork": None,
+    "seven_day_omelette": None,
+    "tangelo": None,
+    "iguana_necktie": None,
+    "omelette_promotional": None,
+    "nimbus_quill": {
+        "utilization": 0.0,
+        "resets_at": None,
+        "limit_dollars": None,
+        "used_dollars": None,
+        "remaining_dollars": None,
+        "locked_reason": None,
+    },
+    "cinder_cove": None,
+    "amber_ladder": None,
+    "juniper_tide": None,
+    "extra_usage": {
+        "is_enabled": False,
+        "monthly_limit": 2000,
+        "used_credits": 0.0,
+        "utilization": 0.0,
+        "currency": "USD",
+        "decimal_places": 2,
+        "disabled_reason": "out_of_credits",
+        "user_disabled": False,
+        "spend_limit_reached": False,
+        "credits_ever_enabled": True,
+        "daily": None,
+        "weekly": None,
+    },
+    "limits": [
+        {
+            "kind": "session",
+            "group": "session",
+            "percent": 14,
+            "severity": "normal",
+            "resets_at": "2026-09-04T19:00:00.208321+00:00",
+            "scope": None,
+            "is_active": False,
+        },
+        {
+            "kind": "weekly_all",
+            "group": "weekly",
+            "percent": 46,
+            "severity": "normal",
+            "resets_at": "2026-09-05T03:00:00.208343+00:00",
+            "scope": None,
+            "is_active": False,
+        },
+        {
+            "kind": "weekly_scoped",
+            "group": "weekly",
+            "percent": 72,
+            "severity": "normal",
+            "resets_at": "2026-09-05T03:00:00.208558+00:00",
+            "scope": {
+                "model": {
+                    "id": None,
+                    "display_name": "Fable",
+                },
+                "surface": None,
+            },
+            "is_active": True,
+        },
+    ],
+    "spend": {
+        "used": {
+            "amount_minor": 0,
+            "currency": "USD",
+            "exponent": 2,
+        },
+        "limit": {
+            "amount_minor": 2000,
+            "currency": "USD",
+            "exponent": 2,
+        },
+        "percent": 0,
+        "severity": "normal",
+        "enabled": False,
+        "disabled_reason": "out_of_credits",
+        "cap": {
+            "money": None,
+            "credits": {
+                "amount_minor": 2000,
+                "exponent": 2,
+            },
+        },
+        "balance": None,
+        "auto_reload": None,
+        "disclaimer": "Usage credits cover you when you hit your plan limits. [Learn more](https://support.claude.com/articles/12429409)",
+        "can_purchase_credits": False,
+        "can_toggle": False,
+    },
+    "member_dashboard_available": False,
+}
+
+
+def _respond(monkeypatch, payload: dict) -> None:
+    monkeypatch.setattr(quotas, "_http_json", lambda *args, **kwargs: payload)
+    monkeypatch.setattr(
+        quotas,
+        "_claude_load_keychain",
+        lambda: {
+            "accessToken": "tok",
+            "expiresAt": 4_000_000_000_000,
+            "subscriptionType": "max",
+        },
+    )
+    monkeypatch.setattr(quotas, "_claude_email_from_token", lambda token: None)
+
+
+def test_model_scoped_weekly_row_is_placed_after_weekly(monkeypatch) -> None:
+    _respond(monkeypatch, _PAYLOAD)
+
+    result = quotas.claude_probe()
+
+    assert [(window["name"], window["pct_left"]) for window in result["windows"]] == [
+        ("Session", 86),
+        ("Weekly", 54),
+        ("Weekly · Fable", 28),
+    ]
+    weekly, scoped = result["windows"][1:]
+    assert scoped["reset_at_iso"] == _PAYLOAD["limits"][2]["resets_at"]
+    assert (scoped["forecast"] is None) == (weekly["forecast"] is None)
+
+
+def test_inactive_model_scoped_weekly_limit_is_still_rendered(monkeypatch) -> None:
+    payload = deepcopy(_PAYLOAD)
+    payload["limits"][2]["is_active"] = False
+    _respond(monkeypatch, payload)
+
+    assert "Weekly · Fable" in [window["name"] for window in quotas.claude_probe()["windows"]]
+
+
+@pytest.mark.parametrize("shape", ["missing_name", "null_limits", "absent_limits"])
+def test_malformed_or_missing_scoped_limits_are_ignored(monkeypatch, shape: str) -> None:
+    payload = deepcopy(_PAYLOAD)
+    if shape == "missing_name":
+        del payload["limits"][2]["scope"]["model"]["display_name"]
+    elif shape == "null_limits":
+        payload["limits"] = None
+    else:
+        del payload["limits"]
+    _respond(monkeypatch, payload)
+
+    assert "Weekly · Fable" not in [window["name"] for window in quotas.claude_probe()["windows"]]
+
+
+def test_scoped_rows_precede_existing_model_window(monkeypatch) -> None:
+    payload = deepcopy(_PAYLOAD)
+    payload["seven_day_sonnet"] = {
+        "utilization": 12.0,
+        "resets_at": "2026-09-05T03:00:00.208343+00:00",
+    }
+    _respond(monkeypatch, payload)
+
+    assert [window["name"] for window in quotas.claude_probe()["windows"]] == [
+        "Session",
+        "Weekly",
+        "Weekly · Fable",
+        "Sonnet",
+    ]

playmaker_cli-0.10.0/tests/test_quotas_codex.py

@@ -0,0 +1,175 @@
+"""Codex quota probe coverage for model-scoped Spark limits."""
+
+from __future__ import annotations
+
+import sys
+from copy import deepcopy
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "src"))
+
+import playmaker.quotas as quotas
+from playmaker import cli
+
+# Captured verbatim from chatgpt.com/backend-api/wham/usage on a live Pro Lite
+# plan. The account identifiers are intentionally redacted.
+_PAYLOAD = {
+    "user_id": "<redacted>",
+    "account_id": "<redacted>",
+    "email": "<redacted>",
+    "plan_type": "prolite",
+    "rate_limit": {
+        "allowed": True,
+        "limit_reached": False,
+        "primary_window": {
+            "used_percent": 34,
+            "limit_window_seconds": 604800,
+            "reset_after_seconds": 218486,
+            "reset_at": 1788751180,
+        },
+        "secondary_window": None,
+    },
+    "code_review_rate_limit": None,
+    "additional_rate_limits": [
+        {
+            "limit_name": "GPT-5.3-Codex-Spark",
+            "metered_feature": "codex_bengalfox",
+            "rate_limit": {
+                "allowed": True,
+                "limit_reached": False,
+                "primary_window": {
+                    "used_percent": 0,
+                    "limit_window_seconds": 18000,
+                    "reset_after_seconds": 18000,
+                    "reset_at": 1788550695,
+                },
+                "secondary_window": {
+                    "used_percent": 92,
+                    "limit_window_seconds": 604800,
+                    "reset_after_seconds": 511704,
+                    "reset_at": 1789044398,
+                },
+            },
+            "normal_model_slug": None,
+        }
+    ],
+    "model_usage": {},
+    "credits": {
+        "has_credits": False,
+        "unlimited": False,
+        "overage_limit_reached": False,
+        "balance": "0",
+        "approx_local_messages": [0, 0],
+        "approx_cloud_messages": [0, 0],
+    },
+    "spend_control": {
+        "reached": False,
+        "individual_limit": None,
+    },
+    "rate_limit_reached_type": None,
+    "promo": None,
+    "rate_limit_reset_credits": {
+        "available_count": 2,
+        "applicable_available_count": 0,
+    },
+}
+
+
+def _respond(monkeypatch, payload: dict) -> None:
+    monkeypatch.setattr(quotas, "_http_json", lambda *args, **kwargs: payload)
+    monkeypatch.setattr(
+        quotas,
+        "_codex_load_auth",
+        lambda: {"tokens": {"access_token": "tok"}, "account_id": "acct"},
+    )
+
+
+def test_main_and_spark_windows_are_kept_separate(monkeypatch) -> None:
+    _respond(monkeypatch, _PAYLOAD)
+
+    result = quotas.codex_probe()
+
+    assert [(window["name"], window["pct_left"]) for window in result["windows"]] == [
+        ("Session", 66)
+    ]
+    assert result["windows"][0]["reserve_pct"] is None
+    assert [(window["name"], window["pct_left"]) for window in result["blocks"][0]["windows"]] == [
+        ("Session", 100),
+        ("Weekly", 8),
+    ]
+    spark_session, spark_weekly = result["blocks"][0]["windows"]
+    assert spark_session["forecast"] is None
+    assert spark_weekly["reset_at_iso"].startswith("2026-09-")
+    assert spark_weekly["reset_relative"]
+
+
+def test_missing_or_empty_additional_limits_have_no_spark_block(monkeypatch) -> None:
+    for additional_limits in ([], None):
+        payload = deepcopy(_PAYLOAD)
+        if additional_limits is None:
+            del payload["additional_rate_limits"]
+        else:
+            payload["additional_rate_limits"] = additional_limits
+        _respond(monkeypatch, payload)
+
+        assert quotas.codex_probe()["blocks"] == []
+
+
+def test_non_spark_additional_limit_remains_weekly_reserve(monkeypatch) -> None:
+    payload = deepcopy(_PAYLOAD)
+    payload["rate_limit"]["secondary_window"] = {
+        "used_percent": 25,
+        "limit_window_seconds": 604800,
+        "reset_after_seconds": 511704,
+        "reset_at": 1789044398,
+    }
+    payload["additional_rate_limits"] = [
+        {
+            "limit_name": "GPT-5 reserve",
+            "metered_feature": "codex_reserve",
+            "rate_limit": {
+                "secondary_window": {
+                    "used_percent": 40,
+                    "limit_window_seconds": 604800,
+                    "reset_at": 1789044398,
+                }
+            },
+        }
+    ]
+    _respond(monkeypatch, payload)
+
+    result = quotas.codex_probe()
+
+    assert result["blocks"] == []
+    assert result["windows"][1]["name"] == "Weekly"
+    assert result["windows"][1]["reserve_pct"] == 60
+
+
+def test_rendering_draws_spark_as_a_separate_block(monkeypatch) -> None:
+    _respond(monkeypatch, _PAYLOAD)
+    result = quotas.codex_probe()
+
+    with cli.console.capture() as capture:
+        cli._render_provider("codex", result)
+    text = capture.get()
+
+    assert text.count("Codex — Spark") == 1
+    assert text.index("Codex — Spark") > text.index("Session")
+
+    with cli.console.capture() as capture:
+        cli._render_provider(
+            "codex",
+            {
+                "status": "ok",
+                "windows": [
+                    {
+                        "name": "Session",
+                        "pct_left": 66,
+                        "reset_relative": None,
+                        "forecast": None,
+                        "reserve_pct": None,
+                    }
+                ],
+            },
+        )
+    assert "Codex — Spark" not in capture.get()