playmaker-cli 0.7.0__tar.gz → 0.7.2__tar.gz

{playmaker_cli-0.7.0 → playmaker_cli-0.7.2}/CHANGELOG.md

@@ -5,6 +5,79 @@ 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.7.2] - 2026-08-18
+
+### Fixed
+
+- **`[agents.<name>] binary` was documented, written into every config `init`
+  produced, and read by nothing.** All five handlers hardcoded the executable —
+  `shutil.which("opencode")` for the availability check, `cmd = ["opencode", …]`
+  for the dispatch — so a config pointing at an absolute path or an alternate
+  build changed exactly nothing, and the agent still had to be on `PATH` under
+  its own name. That is the wrong assumption for how these CLIs install:
+  opencode lands in `~/.opencode/bin`, which reaches `PATH` only through a line
+  in an interactive `.zshrc`, so every non-interactive dispatch — cron, an
+  editor-spawned run, the coach itself — reported the agent unavailable unless
+  you'd worked around it with a symlink. The setting is now honoured everywhere
+  an executable is named: `is_available()`, both dispatch and resume, and the
+  roster probes (`agy models`, `opencode models`, `gemini --list-sessions`). A
+  bare name still resolves on `PATH`; an absolute path is used as-is and a
+  leading `~` is expanded, since subprocess does no shell expansion of its own.
+  When the lookup fails, the error now names the executable it actually tried
+  and where the setting came from, instead of insisting it is "not on PATH".
+
+- **The Z.ai windows lost their names when z.ai renamed them.** `playmaker
+  quotas` had started printing the GLM rows as `5 hours` and `1 week` instead
+  of `Session` and `Weekly`: the plans moved to weekly Credits and the API now
+  types the inference windows `CREDIT_LIMIT` where it sent `TOKENS_LIMIT` in
+  July, so the label lookup missed and fell back to rendering the bare span.
+  The labels are shared with the claude probe on purpose — the two providers
+  are meant to read like-for-like down the table — so the fallback quietly cost
+  the comparison. Both spellings are mapped now. The monthly `MCP tools` pool
+  is simply absent from the response on a current plan; nothing to do, it just
+  stops appearing.
+
+- **The coach skill named a stale GLM model and lied about where the opencode
+  default lives.** The skill ships in the wheel, so its facts are the coach's
+  facts. It routed bulk work to `zai-coding-plan/glm-5.2` when the plan's
+  current flagship is `glm-5.3`, described the Z.ai quota as token windows plus
+  a monthly `MCP tools` pool (the windows are credits now; the pool is gone),
+  and told the coach that omitting `--model` falls back to whatever
+  `~/.config/opencode/opencode.json` names. That last one sends you looking in
+  the wrong file: opencode keeps the interactively-picked default in its own
+  state, not in that config, so a machine with no `model` key there still
+  resolves to something — and the only way to see what an unqualified dispatch
+  will run is the `providerID`/`modelID` on a past session in `opencode.db`.
+
+- **`--model` for agy validated against the wrong column.** agy 1.1.14 prints
+  `agy models` as `<slug>\t<Display Name>` after a `Fetching available
+  models...` line; the roster was read as whole lines, so every real slug was
+  rejected as unknown. Only the first token counts now (older builds printed
+  the bare slug — same first token).
+
+## [0.7.1] - 2026-08-18
+
+### Fixed
+
+- **The Antigravity quota probe knocked on every port on the machine, and one
+  of them answered in TLS.** `playmaker quotas` had shown
+  `Antigravity (agy) error: BadStatusLine` for a week: the daemon lookup ran
+  `lsof -p <pid> -iTCP -sTCP:LISTEN` without `-a`, and lsof ORs its selectors
+  unless told otherwise — so "agy's listening sockets" was actually every
+  LISTEN socket on the box (hence the old `!= 5432` Postgres carve-out). The
+  probe then POSTed the quota RPC to Steam, chromedriver, a Logi plugin, …
+  until a TLS-only listener sorted below agy's ports answered a plaintext
+  request with a TLS alert record. urllib raises that as
+  `http.client.BadStatusLine`, which is not an `OSError`, so it escaped the
+  per-port `except`, escaped `antigravity_probe`, and the aggregator recorded
+  the whole provider as an error — with the working local daemon two ports
+  away. lsof now gets `-a` (one call, all pids), the `pgrep` for `agy` is
+  anchored so playmaker's own dispatches with `playmaker-agy-*.log` in their
+  arguments don't count as the daemon, anything a port says only disqualifies
+  that port, and any failure on the local path falls back to the remote
+  Gemini-only probe rather than to `error`. The refresh also stopped spending
+  ~30 s in timeouts on strangers' ports (1.3 s now).
+
 ## [0.7.0] - 2026-08-05
 
 ### Fixed

{playmaker_cli-0.7.0 → playmaker_cli-0.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: playmaker-cli
-Version: 0.7.0
+Version: 0.7.2
 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
@@ -309,6 +309,18 @@ reads `process.env.PWD`, which a subprocess `cwd` does not update, so left
 alone it would ignore `--cwd` and write into the directory *you* were standing
 in. playmaker passes `--dir` and fixes up `PWD`, so `--cwd` means what it says.
 
+And it is the agent most likely to need `binary`, which every lane accepts:
+
+```toml
+[agents.opencode]
+binary = "~/.opencode/bin/opencode"
+```
+
+A bare name is resolved on `PATH`; a path is used as-is. opencode installs to
+`~/.opencode/bin`, which reaches `PATH` only via a line in an interactive
+`.zshrc` — so a dispatch from cron, an editor, or the coach can't find it
+otherwise, and playmaker would report the agent as unavailable.
+
 ## Notifications
 
 Every detached dispatch pings when it finishes. With

{playmaker_cli-0.7.0 → playmaker_cli-0.7.2}/README.md

@@ -282,6 +282,18 @@ reads `process.env.PWD`, which a subprocess `cwd` does not update, so left
 alone it would ignore `--cwd` and write into the directory *you* were standing
 in. playmaker passes `--dir` and fixes up `PWD`, so `--cwd` means what it says.
 
+And it is the agent most likely to need `binary`, which every lane accepts:
+
+```toml
+[agents.opencode]
+binary = "~/.opencode/bin/opencode"
+```
+
+A bare name is resolved on `PATH`; a path is used as-is. opencode installs to
+`~/.opencode/bin`, which reaches `PATH` only via a line in an interactive
+`.zshrc` — so a dispatch from cron, an editor, or the coach can't find it
+otherwise, and playmaker would report the agent as unavailable.
+
 ## Notifications
 
 Every detached dispatch pings when it finishes. With

{playmaker_cli-0.7.0 → playmaker_cli-0.7.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "playmaker-cli"
-version = "0.7.0"
+version = "0.7.2"
 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.7.0 → playmaker_cli-0.7.2}/skills/playmaker-coach/SKILL.md

@@ -23,7 +23,7 @@ All Claude work — coach, internal sub-agents, external `claude -p` — draws f
 
 3. **External dispatch — `playmaker dispatch <agent>`.** Separate OS processes, tracked in playmaker (`list`/`watch`/`thread`/`continue`):
    - **`claude -p` (sibling Claude):** same subscription. Its key lever is the model bucket — **Sonnet is a separate weekly bucket from Opus**, usually idle while Opus depletes, so default **`--model sonnet`** to spare the scarce Opus bucket (**`--model haiku`** for trivial mechanical work). It **can write files** — playmaker runs it in `acceptEdits`, so it edits and runs commands freely inside `--cwd` and is refused outside it (see §10). Use it over an internal sub-agent when you want a **tracked, detached work-stream** you can monitor/continue independently of the coach's turn.
-   - **`codex` / `agy` / `opencode`:** each on its own subscription/quota — the right home for **write-heavy** parallel implementation that can leave the Anthropic subscription. `agy` is special: besides Gemini tiers it carries **Claude Sonnet/Opus 4.6 (Thinking)** on Google's pool, so even "must be Claude-quality" work can leave the Anthropic quota. `opencode` is the widest lane: one CLI over ~75 providers, addressed as `provider/model` — a GLM coding plan (`zai-coding-plan/glm-5.2`), or a model running locally on this machine, which spends **no** subscription quota at all.
+   - **`codex` / `agy` / `opencode`:** each on its own subscription/quota — the right home for **write-heavy** parallel implementation that can leave the Anthropic subscription. `agy` is special: besides Gemini tiers it carries **Claude Sonnet/Opus 4.6 (Thinking)** on Google's pool, so even "must be Claude-quality" work can leave the Anthropic quota. `opencode` is the widest lane: one CLI over ~75 providers, addressed as `provider/model` — a GLM coding plan (`zai-coding-plan/glm-5.3`), or a model running locally on this machine, which spends **no** subscription quota at all.
 
 **Routing cheat-sheet for Claude-side work:**
 
@@ -34,7 +34,7 @@ All Claude work — coach, internal sub-agents, external `claude -p` — draws f
 | is heavy reasoning only the coach can do | **coach** | top-tier Opus, serial |
 | is write-heavy and can leave Claude | **codex / agy / opencode** | their own quotas |
 | needs top-tier Claude but the Anthropic Opus weekly is precious | **`dispatch agy --model claude-opus-4-6-thinking`** | Opus quality on Google's pool |
-| is bulk work and every subscription is running low | **`dispatch opencode --model zai-coding-plan/glm-5.2`** | a separate GLM plan, untouched by the others |
+| is bulk work and every subscription is running low | **`dispatch opencode --model zai-coding-plan/glm-5.3`** | a separate GLM plan, untouched by the others |
 | is mechanical and privacy-sensitive, or all quotas are spent | **`dispatch opencode --model <local provider>/<model>`** | runs on this machine; costs no quota, just wall-clock |
 
 **Sonnet is your cheap parallel Claude worker** — a separate weekly bucket that usually sits idle while Opus depletes. Reach for it (via `dispatch claude --model sonnet`, or by pointing an internal sub-agent at Sonnet) instead of burning Opus on mid-tier work.
@@ -63,7 +63,7 @@ playmaker quotas --refresh          # current capacity, broken out per model
 - Claude: two non-coach ways to run it — an **internal sub-agent** (Task tool; in-session, write-capable, result returns to the coach) and an **external `claude -p` dispatch** (tracked, detached stream). Both draw on the subscription; the difference is where results land, not cost. See "Execution lanes". Default external Claude to `--model sonnet` — its weekly bucket is separate from Opus and usually idle, so it spares the scarce coach (Opus) bucket.
 - Antigravity (`agy`): one Google pool split across model families — Gemini Flash tiers for cheap bulk work, Gemini 3.1 Pro for hard Gemini work, **Claude Sonnet/Opus 4.6 (Thinking)** as Anthropic-quality capacity that spends *Google's* quota, GPT-OSS 120B as a spare mid-tier. `playmaker quotas` shows the **full categorized breakdown** — `Gemini 5h` / `Gemini weekly` and `Claude/GPT 5h` / `Claude/GPT weekly`. Two things share a bucket: all Gemini models draw the Gemini bucket, and Claude *and* GPT-OSS share the Claude/GPT bucket. So dispatching Opus 4.6 via agy spends the same `Claude/GPT` bucket as Sonnet or GPT-OSS — watch the `Claude/GPT 5h` window when fanning out several agy-Claude jobs. (This needs agy's local daemon up — normally true when any agy process is running; if `playmaker quotas` tags agy "daemon offline" it fell back to a coarse Gemini-only view.)
 - Codex: top-tier vs lighter modes (where applicable).
-- Z.ai (GLM): shown as its own provider because the plan is what has the quota, not the CLI — `Session` (5h) and `Weekly` windows plus a monthly `MCP tools` pool that only web-search/reader calls touch. It appears whenever `opencode auth login` has a Z.AI credential, and reads *unsupported* when it doesn't. An `opencode` dispatch pointed at a **local** model spends none of it, so local lanes never show up in this table at all.
+- Z.ai (GLM): shown as its own provider because the plan is what has the quota, not the CLI — `Session` (5h) and `Weekly` windows, denominated in the plan's **credits** (Pro: 12k per session, 60k per week). It appears whenever `opencode auth login` has a Z.AI credential, and reads *unsupported* when it doesn't. An `opencode` dispatch pointed at a **local** model spends none of it, so local lanes never show up in this table at all.
 
 If `quotas.json` is more than 1h old (or shows errors), say so before relying on the numbers.
 
@@ -162,7 +162,7 @@ Two exceptions to "always pass `--model`":
 - **codex** — its model roster depends on the account plan, and an unavailable name fails the whole dispatch (`codex turn failed: … not supported when using Codex with a ChatGPT account`). Omitting `--model` uses whatever that account actually has, which is usually what you want.
 - **agy** — its own default is a top-tier model, so omitting `--model` on a dispatch meant to be cheap silently spends the expensive bucket. Always pass it here.
 
-**opencode is `provider/model`, and the default is a trap.** Names look like `zai-coding-plan/glm-5.2` or `lmstudio/qwen/qwen3-coder-30b` — **run `opencode models` and copy a line** rather than writing one from memory; playmaker validates against that roster and fails the dispatch on a name it doesn't contain. Omitting `--model` does *not* fall back to something sensible: it uses whatever is set in the user's own `~/.config/opencode/opencode.json`, which is typically the last model they picked interactively — often a small local one. So for opencode, always pass `--model` unless `[agents.opencode] model` is already set in `~/.playmaker/config.toml`.
+**opencode is `provider/model`, and the default is invisible.** Names look like `zai-coding-plan/glm-5.3` or `lmstudio/qwen/qwen3-coder-30b` — **run `opencode models` and copy a line** rather than writing one from memory; playmaker validates against that roster and fails the dispatch on a name it doesn't contain. Omitting `--model` falls through to opencode's own default, which is whatever the user last picked interactively — and it is *not* necessarily written to `~/.config/opencode/opencode.json`, so you cannot read it back from a config file. The only way to know what an unqualified dispatch will run is to look at the `providerID`/`modelID` on a past session in `opencode.db`. So for opencode, always pass `--model` unless `[agents.opencode] model` is set in `~/.playmaker/config.toml` — which is the cheap fix: pin it there once and the lane becomes deterministic.
 
 **agy prompt discipline:** the agy agent's shell lives in a private scratch directory, not the workspace. playmaker automatically prepends a workspace preamble to every agy dispatch, but reinforce it: word file instructions with paths relative to the workspace root or absolute paths, never "in the current directory".
 
@@ -274,7 +274,7 @@ playmaker watch                                 # Rich live TUI of sessions
 
 Every command takes `--json` for machine-readable output.
 
-`--model NAME` is forwarded to the agent's native CLI: `claude --model sonnet`, `agy --model claude-opus-4-6-thinking`, `codex -m <whatever that account has>`, `opencode -m zai-coding-plan/glm-5.2`. Without it the agent CLI uses its own default. Model is stored on the session row, so detached re-runs and `continue` inherit it; `continue --model X` overrides for that one turn.
+`--model NAME` is forwarded to the agent's native CLI: `claude --model sonnet`, `agy --model claude-opus-4-6-thinking`, `codex -m <whatever that account has>`, `opencode -m zai-coding-plan/glm-5.3`. Without it the agent CLI uses its own default. Model is stored on the session row, so detached re-runs and `continue` inherit it; `continue --model X` overrides for that one turn.
 
 **The agy roster is not documented here on purpose** — it changes with Antigravity releases, and so does the spelling convention. Run `agy models` and copy a line. At the time of writing it returns bare slugs in the shape `gemini-3.6-flash-{low,medium,high}`, `gemini-3.1-pro-{low,high}`, `claude-sonnet-4-6`, `claude-opus-4-6-thinking`, `gpt-oss-120b-medium` — but treat that as an example of the *shape*, not a list to copy from.
 

{playmaker_cli-0.7.0 → playmaker_cli-0.7.2}/src/playmaker/agents/agy.py

@@ -37,7 +37,7 @@ import time
 from pathlib import Path
 
 from playmaker.agents.base import DispatchResult, SessionStartedCallback, Turn
-from playmaker.config import agent_setting, yolo_enabled
+from playmaker.config import agent_binary, agent_setting, yolo_enabled
 
 AGY_BRAIN_ROOT = Path("~/.gemini/antigravity-cli/brain").expanduser()
 
@@ -51,7 +51,7 @@ class AgyHandler:
     name = "agy"
 
     def is_available(self) -> bool:
-        return shutil.which("agy") is not None
+        return shutil.which(agent_binary("agy")) is not None
 
     @staticmethod
     @functools.lru_cache(maxsize=1)
@@ -63,18 +63,25 @@ class AgyHandler:
         Cached per-process; returns () if the roster can't be read (then we skip
         validation rather than block a dispatch on a probe failure).
         """
-        if shutil.which("agy") is None:
+        if shutil.which(agent_binary("agy")) is None:
             return ()
         try:
             proc = subprocess.run(
-                ["agy", "models"], capture_output=True, text=True, timeout=15
+                [agent_binary("agy"), "models"],
+                capture_output=True,
+                text=True,
+                timeout=15,
             )
         except (OSError, subprocess.SubprocessError):
             return ()
         if proc.returncode != 0:
             return ()
+        # `agy models` output is columnar: "<slug>\t<Display Name>" (older
+        # releases printed the bare slug only) — the slug is the first token.
         return tuple(
-            line.strip() for line in proc.stdout.splitlines() if line.strip()
+            line.split()[0]
+            for line in proc.stdout.splitlines()
+            if line.strip() and not line.startswith("Fetching")
         )
 
     def _validate_model(self, model: str | None) -> None:
@@ -146,7 +153,7 @@ class AgyHandler:
         os.close(fd_log)
         log_path = Path(log_name)
 
-        cmd = ["agy", "-p", full_prompt, "--log-file", str(log_path)]
+        cmd = [agent_binary("agy"), "-p", full_prompt, "--log-file", str(log_path)]
         if conversation_id:
             cmd += ["--conversation", conversation_id]
         # agy has no middle tier: unlike claude there is no per-mode permission

{playmaker_cli-0.7.0 → playmaker_cli-0.7.2}/src/playmaker/agents/claude.py

@@ -17,7 +17,12 @@ import subprocess
 from pathlib import Path
 
 from playmaker.agents.base import DispatchResult, SessionStartedCallback, Turn
-from playmaker.config import agent_list_setting, agent_setting, yolo_enabled
+from playmaker.config import (
+    agent_binary,
+    agent_list_setting,
+    agent_setting,
+    yolo_enabled,
+)
 
 # What a sub-agent is allowed to do without a human at the keyboard.
 # Verified against claude 2.x in `-p` mode:
@@ -53,7 +58,7 @@ class ClaudeHandler:
     name = "claude"
 
     def is_available(self) -> bool:
-        return shutil.which("claude") is not None
+        return shutil.which(agent_binary("claude")) is not None
 
     def dispatch(
         self,
@@ -76,7 +81,7 @@ class ClaudeHandler:
         # `--verbose` is required by claude-cli when stream-json is used
         # without partial-messages; without it we get a parse-time refusal.
         cmd = [
-            "claude",
+            agent_binary("claude"),
             "-p",
             "--output-format",
             "stream-json",
@@ -185,7 +190,7 @@ class ClaudeHandler:
     ) -> DispatchResult:
         full_prompt = self._build_prompt(prompt, files or [])
         cmd = [
-            "claude",
+            agent_binary("claude"),
             "-p",
             "--resume",
             agent_session_id,

{playmaker_cli-0.7.0 → playmaker_cli-0.7.2}/src/playmaker/agents/codex.py

@@ -23,7 +23,7 @@ import time
 from pathlib import Path
 
 from playmaker.agents.base import DispatchResult, SessionStartedCallback, Turn
-from playmaker.config import agent_setting
+from playmaker.config import agent_binary, agent_setting
 
 CODEX_SESSIONS_ROOT = Path("~/.codex/sessions").expanduser()
 
@@ -44,7 +44,7 @@ class CodexHandler:
     name = "codex"
 
     def is_available(self) -> bool:
-        return shutil.which("codex") is not None
+        return shutil.which(agent_binary("codex")) is not None
 
     def dispatch(
         self,
@@ -62,7 +62,7 @@ class CodexHandler:
             last_msg_path = Path(tmp.name)
 
         cmd = [
-            "codex",
+            agent_binary("codex"),
             "exec",
             "--json",
             "--skip-git-repo-check",
@@ -226,7 +226,7 @@ class CodexHandler:
 
         # `codex exec resume` has no --cd; cwd flows through subprocess.
         cmd = [
-            "codex",
+            agent_binary("codex"),
             "exec",
             "resume",
             "--json",

{playmaker_cli-0.7.0 → playmaker_cli-0.7.2}/src/playmaker/agents/gemini.py

@@ -21,6 +21,7 @@ import time
 from pathlib import Path
 
 from playmaker.agents.base import DispatchResult, SessionStartedCallback, Turn
+from playmaker.config import agent_binary
 
 GEMINI_CHATS_ROOT = Path("~/.gemini/tmp").expanduser()
 
@@ -29,7 +30,7 @@ class GeminiHandler:
     name = "gemini"
 
     def is_available(self) -> bool:
-        return shutil.which("gemini") is not None
+        return shutil.which(agent_binary("gemini")) is not None
 
     def dispatch(
         self,
@@ -48,7 +49,7 @@ class GeminiHandler:
         """
         full_prompt = self._build_prompt(prompt, files or [])
         cmd = [
-            "gemini",
+            agent_binary("gemini"),
             "-p",
             full_prompt,
             "-o",
@@ -150,7 +151,7 @@ class GeminiHandler:
 
         full_prompt = self._build_prompt(prompt, files or [])
         cmd = [
-            "gemini",
+            agent_binary("gemini"),
             "--resume",
             str(index),
             "-p",
@@ -220,7 +221,7 @@ class GeminiHandler:
             "  <N>. <title> (<age>) [<uuid>]"
         """
         proc = subprocess.run(
-            ["gemini", "--list-sessions"],
+            [agent_binary("gemini"), "--list-sessions"],
             cwd=str(cwd),
             capture_output=True,
             text=True,

{playmaker_cli-0.7.0 → playmaker_cli-0.7.2}/src/playmaker/agents/opencode.py

@@ -36,7 +36,7 @@ from datetime import UTC, datetime
 from pathlib import Path
 
 from playmaker.agents.base import DispatchResult, SessionStartedCallback, Turn
-from playmaker.config import agent_setting, yolo_enabled
+from playmaker.config import agent_binary, agent_setting, yolo_enabled
 from playmaker.state import PLAYMAKER_HOME
 
 
@@ -55,7 +55,7 @@ class OpencodeHandler:
     name = "opencode"
 
     def is_available(self) -> bool:
-        return shutil.which("opencode") is not None
+        return shutil.which(agent_binary("opencode")) is not None
 
     @staticmethod
     @functools.lru_cache(maxsize=1)
@@ -67,11 +67,14 @@ class OpencodeHandler:
         per-process; () if the roster can't be read (then validation is skipped
         rather than blocking a dispatch on a probe failure).
         """
-        if shutil.which("opencode") is None:
+        if shutil.which(agent_binary("opencode")) is None:
             return ()
         try:
             proc = subprocess.run(
-                ["opencode", "models"], capture_output=True, text=True, timeout=15
+                [agent_binary("opencode"), "models"],
+                capture_output=True,
+                text=True,
+                timeout=15,
             )
         except (OSError, subprocess.SubprocessError):
             return ()
@@ -157,7 +160,7 @@ class OpencodeHandler:
         # directory from process.env.PWD, which Popen(cwd=…) leaves pointing at
         # the parent. Without it a dispatch writes into whatever directory the
         # coach happened to be in. We set both and let them agree.
-        cmd = ["opencode", "run", "--format", "json", "--dir", str(cwd)]
+        cmd = [agent_binary("opencode"), "run", "--format", "json", "--dir", str(cwd)]
         if session_id:
             cmd += ["-s", session_id]
         if effective_model:

{playmaker_cli-0.7.0 → playmaker_cli-0.7.2}/src/playmaker/cli.py

@@ -158,7 +158,7 @@ def dispatch(
     state.init_db()
     handler = get_handler(agent)
     if not handler.is_available():
-        err_console.print(f"[red]agent {agent!r} binary not found on PATH[/red]")
+        err_console.print(_unavailable(agent))
         raise typer.Exit(1)
 
     cwd_resolved = cwd.expanduser().resolve()
@@ -414,7 +414,7 @@ def continue_(
 
     handler = get_handler(parent["agent"])
     if not handler.is_available():
-        err_console.print(f"[red]agent {parent['agent']!r} binary not found on PATH[/red]")
+        err_console.print(_unavailable(parent["agent"]))
         raise typer.Exit(1)
 
     cwd_resolved = (cwd or Path(parent["cwd"])).expanduser().resolve()
@@ -845,10 +845,13 @@ def _render_provider(name: str, info: dict) -> None:
         "agy": "green",
         "gemini": "cyan",
         "zai": "yellow",
+        "ollama": "bright_cyan",
     }.get(name, "white")
-    display = {"agy": "Antigravity (agy)", "zai": "Z.ai (GLM, via opencode)"}.get(
-        name, name.capitalize()
-    )
+    display = {
+        "agy": "Antigravity (agy)",
+        "zai": "Z.ai (GLM, via opencode)",
+        "ollama": "Ollama (local, via opencode)",
+    }.get(name, name.capitalize())
     title = f"[bold {label_color}]{display}[/bold {label_color}]"
     suffix_parts: list[str] = []
     if info.get("account_email"):
@@ -896,6 +899,12 @@ def _render_provider(name: str, info: dict) -> None:
             line += f"   [dim]{'  ·  '.join(right_parts)}[/dim]"
         console.print(line)
 
+    # 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.
+    models = info.get("models")
+    if models:
+        console.print(f"  [dim]models: {', '.join(models)}[/dim]")
+
     # Metered overage pool ("Extra usage" in Claude's UI) — the bucket that
     # holds usage-credit / Agent-SDK spend. monthly_limit/used arrive in cents.
     extra = info.get("extra_usage")
@@ -943,6 +952,19 @@ def agents() -> None:
     console.print(table)
 
 
+def _unavailable(agent: str) -> str:
+    """Why a dispatch is refused, naming the executable we actually looked for.
+
+    Without the name this reads as "not on PATH" even when the config points
+    `binary` at a path that simply does not exist.
+    """
+    from playmaker.config import agent_binary
+
+    executable = agent_binary(agent)
+    hint = "" if executable == agent else f" (agents.{agent}.binary in {state.CONFIG_PATH})"
+    return f"[red]agent {agent!r}: {executable!r} not found{hint}[/red]"
+
+
 def _status_icon(status: str) -> str:
     return {
         "pending": "[yellow]pending[/yellow]",
@@ -965,6 +987,12 @@ editor = "Zed"
 
 # How much each sub-agent may do while nobody is watching. A detached agent
 # cannot answer a permission prompt, so every agent needs *some* answer here.
+#
+# `binary` is the executable playmaker launches for that agent. A bare name is
+# resolved on PATH; an absolute path (~ allowed) is used as-is. Reach for the
+# path form when the CLI installs somewhere only an interactive shell knows
+# about — opencode's ~/.opencode/bin is added by a line in .zshrc, so a cron or
+# editor-spawned dispatch cannot find it otherwise.
 
 [agents.claude]
 binary = "claude"

{playmaker_cli-0.7.0 → playmaker_cli-0.7.2}/src/playmaker/config.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import os
 import tomllib
 from functools import lru_cache
 from typing import Any
@@ -24,6 +25,24 @@ def agent_setting(agent: str, key: str, default: Any = None) -> Any:
     return load_config().get("agents", {}).get(agent, {}).get(key, default)
 
 
+def agent_binary(agent: str) -> str:
+    """The executable to launch for this agent.
+
+    `[agents.<agent>] binary` when set, else the agent's own name. A bare name
+    and an absolute path both work: every call site feeds this to `shutil.which`
+    or straight to `subprocess`, and `which` returns a path containing a
+    separator as-is. `~` is expanded here because these CLIs install under the
+    home directory often enough — opencode lands in ~/.opencode/bin, which only
+    an interactive shell puts on PATH, so a non-interactive dispatch (cron, an
+    editor-spawned run, the coach) cannot find it without this setting.
+    """
+    value = agent_setting(agent, "binary")
+    if value is None:
+        return agent
+    text = os.path.expanduser(str(value).strip())
+    return text or agent
+
+
 def setting(section: str, key: str, default: Any = None) -> Any:
     """Look up [<section>] <key>, falling back to `default`."""
     value = load_config().get(section, {})

{playmaker_cli-0.7.0 → playmaker_cli-0.7.2}/src/playmaker/quotas.py

@@ -612,39 +612,48 @@ def gemini_probe() -> dict:
 _ANTIGRAVITY_QUOTA_SUMMARY_PATH = (
     "/exa.language_server_pb.LanguageServerService/RetrieveUserQuotaSummary"
 )
-_ANTIGRAVITY_PROC_NAMES = ("agy", "language_server")
+# `pgrep -f` regexes over the full command line. The agy one is anchored so a
+# process whose *arguments* merely mention agy — playmaker's own dispatch, with
+# its `--log-file .../playmaker-agy-*.log` — doesn't count as the daemon.
+_ANTIGRAVITY_PROC_PATTERNS = (r"(^|/)agy( |$)", r"language_server")
 
 
 def _antigravity_daemon_ports() -> list[int]:
     """Local TCP ports that a running agy/language_server daemon is listening on."""
     pids: set[int] = set()
-    for name in _ANTIGRAVITY_PROC_NAMES:
+    for pattern in _ANTIGRAVITY_PROC_PATTERNS:
         try:
             proc = subprocess.run(
-                ["pgrep", "-f", name], capture_output=True, text=True, timeout=5
+                ["pgrep", "-f", pattern], capture_output=True, text=True, timeout=5
             )
         except (OSError, subprocess.SubprocessError):
             continue
         for line in proc.stdout.split():
             if line.isdigit():
                 pids.add(int(line))
+    if not pids:
+        return []
+    # `-a` ANDs lsof's selectors. Without it they are ORed, and the listing is
+    # every LISTEN socket on the machine — Steam, chromedriver, whatever else
+    # sits on 127.0.0.1 — so the probe went knocking on strangers' ports.
+    try:
+        proc = subprocess.run(
+            [
+                "lsof", "-nP", "-a",
+                "-p", ",".join(str(pid) for pid in sorted(pids)),
+                "-iTCP", "-sTCP:LISTEN",
+            ],
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+    except (OSError, subprocess.SubprocessError):
+        return []
     ports: set[int] = set()
-    for pid in pids:
-        try:
-            proc = subprocess.run(
-                ["lsof", "-nP", "-p", str(pid), "-iTCP", "-sTCP:LISTEN"],
-                capture_output=True,
-                text=True,
-                timeout=5,
-            )
-        except (OSError, subprocess.SubprocessError):
-            continue
-        for line in proc.stdout.splitlines():
-            m = re.search(r"127\.0\.0\.1:(\d+)", line)
-            if m:
-                port = int(m.group(1))
-                if port != 5432:  # skip an unrelated Postgres LISTEN
-                    ports.add(port)
+    for line in proc.stdout.splitlines():
+        m = re.search(r"127\.0\.0\.1:(\d+)", line)
+        if m:
+            ports.add(int(m.group(1)))
     return sorted(ports)
 
 
@@ -664,12 +673,19 @@ def _antigravity_local_summary(ports: list[int], timeout: float = 5.0) -> dict |
                 method="POST",
                 headers={"Content-Type": "application/json", "Connect-Protocol-Version": "1"},
             )
+            # Whatever a port says, it only ever disqualifies that port. Not
+            # every refusal is an OSError: a TLS-only listener answers a
+            # plaintext POST with a TLS alert record, which urllib raises as
+            # http.client.BadStatusLine — an HTTPException that used to escape
+            # this loop and sink the whole probe.
             try:
                 with urllib.request.urlopen(req, timeout=timeout, context=ctx) as resp:
                     data = json.loads(resp.read().decode("utf-8"))
-            except (urllib.error.URLError, ssl.SSLError, OSError, json.JSONDecodeError):
+                if not isinstance(data, dict):
+                    continue
+                payload = data.get("response") or data.get("summary") or data
+            except Exception:
                 continue
-            payload = data.get("response") or data.get("summary") or data
             if isinstance(payload, dict) and payload.get("groups"):
                 return payload
     return None
@@ -756,29 +772,36 @@ def antigravity_probe() -> dict:
     back to the OAuth retrieveUserQuota, which only surfaces coarse Gemini daily
     buckets (source: "remote") — the Claude/GPT windows are simply not available
     to a plain OAuth token. The local path needs a running agy/CodexBar daemon.
+
+    The local path is a bonus, so it degrades to remote rather than to an
+    error: whatever goes wrong there — a stray listener, a daemon mid-start,
+    a payload we don't recognise — the user still gets a quota row.
     """
-    ports = _antigravity_daemon_ports()
-    if ports:
-        payload = _antigravity_local_summary(ports)
+    windows: list[dict] = []
+    try:
+        ports = _antigravity_daemon_ports()
+        payload = _antigravity_local_summary(ports) if ports else None
         if payload:
             windows = _antigravity_windows_from_summary(payload)
-            if windows:
-                out = {
-                    "status": "ok",
-                    "account_email": None,
-                    "tier": None,
-                    "windows": windows,
-                    "source": "local",
-                }
-                # Enrich email/tier from the cheap OAuth loadCodeAssist call;
-                # never let that failure sink the rich local windows.
-                try:
-                    meta = _antigravity_account_meta()
-                    out["account_email"] = meta.get("email")
-                    out["tier"] = meta.get("tier")
-                except Exception:
-                    pass
-                return out
+    except Exception:
+        windows = []
+    if windows:
+        out = {
+            "status": "ok",
+            "account_email": None,
+            "tier": None,
+            "windows": windows,
+            "source": "local",
+        }
+        # Enrich email/tier from the cheap OAuth loadCodeAssist call;
+        # never let that failure sink the rich local windows.
+        try:
+            meta = _antigravity_account_meta()
+            out["account_email"] = meta.get("email")
+            out["tier"] = meta.get("tier")
+        except Exception:
+            pass
+        return out
 
     result = _google_code_assist_probe(_ANTIGRAVITY_CLOUDCODE_BASE, "ANTIGRAVITY")
     result["source"] = "remote"
@@ -913,7 +936,15 @@ _ZAI_UNIT_NAMES = {3: "hour", 4: "day", 5: "month", 6: "week"}
 
 # (type, unit, number) -> label. "Session"/"Weekly" deliberately match the
 # claude probe's labels so the two providers read as like-for-like in the table.
+#
+# z.ai renamed the inference windows TOKENS_LIMIT -> CREDIT_LIMIT when the plans
+# moved to weekly Credits (observed 2026-08 on a Pro plan; the same account read
+# TOKENS_LIMIT in 2026-07). Both spellings stay mapped: an unrecognised type
+# still renders, but as the bare span ("5 hours"), which breaks the like-for-
+# like reading against the claude rows.
 _ZAI_WINDOW_LABELS = {
+    ("CREDIT_LIMIT", 3, 5): "Session",
+    ("CREDIT_LIMIT", 6, 1): "Weekly",
     ("TOKENS_LIMIT", 3, 5): "Session",
     ("TOKENS_LIMIT", 6, 1): "Weekly",
     ("TIME_LIMIT", 5, 1): "MCP tools",
@@ -956,16 +987,22 @@ def _zai_window_label(limit_type: object, unit: object, number: object) -> str:
 def zai_probe() -> dict:
     """GLM Coding Plan quota, for work dispatched through `opencode`.
 
-    Verified response on a live plan (2026-07):
+    Verified response on a live Pro plan (2026-08):
 
         {"code": 200, "success": true, "msg": "Operation successful",
-         "data": {"level": "max", "limits": [
-            {"type": "TOKENS_LIMIT", "unit": 3, "number": 5, "percentage": 0},
-            {"type": "TOKENS_LIMIT", "unit": 6, "number": 1, "percentage": 5,
-             "nextResetTime": 1785339213993},
-            {"type": "TIME_LIMIT", "unit": 5, "number": 1, "usage": 4000,
-             "currentValue": 10, "remaining": 3990, "percentage": 1,
-             "nextResetTime": 1787412813994, "usageDetails": [...]}]}}
+         "data": {"level": "pro", "limits": [
+            {"type": "CREDIT_LIMIT", "unit": 3, "number": 5, "usage": 12000,
+             "currentValue": 21, "remaining": 11978, "percentage": 1,
+             "nextResetTime": 1787084800394},
+            {"type": "CREDIT_LIMIT", "unit": 6, "number": 1, "usage": 60000,
+             "currentValue": 21, "remaining": 59978, "percentage": 1,
+             "nextResetTime": 1787671183998}]}}
+
+    Two things moved since 2026-07: the inference windows are typed
+    CREDIT_LIMIT rather than TOKENS_LIMIT (`usage` is the plan's credit
+    allowance — 12k per 5h / 60k per week on Pro), and the monthly TIME_LIMIT
+    pool for MCP tools no longer appears at all. Older accounts may still send
+    the previous shape, so both are mapped.
 
     `percentage` is percent *used*, `nextResetTime` is epoch ms and is absent
     until a window has been touched. TIME_LIMIT is the monthly MCP tool pool

{playmaker_cli-0.7.0 → playmaker_cli-0.7.2}/tests/test_agy.py

@@ -110,6 +110,34 @@ def test_validate_model_skips_when_roster_unavailable(monkeypatch) -> None:
     handler._validate_model("Anything At All")
 
 
+def test_available_models_takes_the_slug_column(monkeypatch) -> None:
+    # agy 1.1.14 prints a progress line and then `<slug>\t<Display Name>`;
+    # `--model` wants the slug. Older builds printed the bare slug — same
+    # first token, so both shapes parse.
+    import playmaker.agents.agy as agy_mod
+
+    class _Proc:
+        returncode = 0
+        stdout = (
+            "Fetching available models...\n"
+            "gemini-3.7-flash-high\tGemini 3.7 Flash (High)\n"
+            "claude-opus-4-6-thinking\tClaude Opus 4.6 (Thinking)\n"
+            "gpt-oss-120b-medium\n"
+        )
+
+    monkeypatch.setattr(agy_mod.shutil, "which", lambda name: "/usr/local/bin/agy")
+    monkeypatch.setattr(agy_mod.subprocess, "run", lambda *a, **kw: _Proc())
+    AgyHandler.available_models.cache_clear()
+    try:
+        assert AgyHandler.available_models() == (
+            "gemini-3.7-flash-high",
+            "claude-opus-4-6-thinking",
+            "gpt-oss-120b-medium",
+        )
+    finally:
+        AgyHandler.available_models.cache_clear()
+
+
 def test_find_session_file_prefers_full_transcript(tmp_path: Path, monkeypatch) -> None:
     import playmaker.agents.agy as agy_mod
 

playmaker_cli-0.7.2/tests/test_binary.py

@@ -0,0 +1,208 @@
+"""Which executable each handler actually launches: [agents.<name>] binary."""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+import pytest
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "src"))
+
+import playmaker.config as config
+from playmaker.config import agent_binary
+from playmaker.registry import all_handlers
+
+AGENTS = ("claude", "codex", "agy", "gemini", "opencode")
+
+
+@pytest.fixture
+def configured(monkeypatch):
+    """Install a fake config.toml body for the duration of a test."""
+
+    def _set(cfg: dict) -> None:
+        monkeypatch.setattr(config, "load_config", lambda: cfg)
+
+    return _set
+
+
+# ---- resolution -------------------------------------------------------------
+
+
+@pytest.mark.parametrize("agent", AGENTS)
+def test_an_unconfigured_agent_runs_its_own_name(configured, agent) -> None:
+    configured({})
+
+    assert agent_binary(agent) == agent
+
+
+@pytest.mark.parametrize("agent", AGENTS)
+def test_the_configured_binary_wins(configured, agent) -> None:
+    configured({"agents": {agent: {"binary": f"/opt/{agent}-nightly/bin/{agent}"}}})
+
+    assert agent_binary(agent) == f"/opt/{agent}-nightly/bin/{agent}"
+
+
+def test_a_leading_tilde_is_expanded(configured) -> None:
+    # The whole point of the setting is pointing at a CLI that installs under
+    # $HOME; subprocess does no shell expansion, so a literal "~" would ENOENT.
+    configured({"agents": {"opencode": {"binary": "~/.opencode/bin/opencode"}}})
+
+    resolved = agent_binary("opencode")
+
+    assert not resolved.startswith("~")
+    assert resolved == str(Path("~/.opencode/bin/opencode").expanduser())
+
+
+def test_an_empty_binary_falls_back_to_the_agent_name(configured) -> None:
+    # `binary = ""` is a config typo, not a request to exec the empty string.
+    configured({"agents": {"agy": {"binary": "   "}}})
+
+    assert agent_binary("agy") == "agy"
+
+
+def test_one_agents_binary_does_not_leak_into_another(configured) -> None:
+    configured({"agents": {"claude": {"binary": "/opt/claude-nightly"}}})
+
+    assert agent_binary("claude") == "/opt/claude-nightly"
+    assert agent_binary("codex") == "codex"
+
+
+# ---- availability -----------------------------------------------------------
+
+
+@pytest.mark.parametrize("agent", AGENTS)
+def test_availability_probes_the_configured_binary(monkeypatch, configured, agent) -> None:
+    # `playmaker dispatch` refuses to start when this says no, so a handler that
+    # ignored the setting would report "not installed" for a working CLI.
+    configured({"agents": {agent: {"binary": f"/opt/{agent}/bin/{agent}"}}})
+    probed: list[str] = []
+
+    def fake_which(cmd, *args, **kwargs):
+        probed.append(cmd)
+        return cmd
+
+    for module in ("claude", "codex", "agy", "gemini", "opencode"):
+        monkeypatch.setattr(f"playmaker.agents.{module}.shutil.which", fake_which)
+
+    assert all_handlers()[agent].is_available() is True
+    assert probed == [f"/opt/{agent}/bin/{agent}"]
+
+
+@pytest.mark.parametrize("agent", AGENTS)
+def test_availability_falls_back_to_the_bare_name(monkeypatch, configured, agent) -> None:
+    configured({})
+    probed: list[str] = []
+
+    def fake_which(cmd, *args, **kwargs):
+        probed.append(cmd)
+        return None
+
+    for module in ("claude", "codex", "agy", "gemini", "opencode"):
+        monkeypatch.setattr(f"playmaker.agents.{module}.shutil.which", fake_which)
+
+    assert all_handlers()[agent].is_available() is False
+    assert probed == [agent]
+
+
+# ---- the launched command ---------------------------------------------------
+
+
+def test_claude_dispatch_execs_the_configured_binary(monkeypatch, tmp_path, configured) -> None:
+    configured({"agents": {"claude": {"binary": "/opt/claude-nightly/bin/claude"}}})
+
+    assert _dispatch_argv0("claude", monkeypatch, tmp_path) == "/opt/claude-nightly/bin/claude"
+
+
+def test_codex_dispatch_execs_the_configured_binary(monkeypatch, tmp_path, configured) -> None:
+    configured({"agents": {"codex": {"binary": "/opt/codex/bin/codex"}}})
+
+    assert _dispatch_argv0("codex", monkeypatch, tmp_path) == "/opt/codex/bin/codex"
+
+
+def test_gemini_dispatch_execs_the_configured_binary(monkeypatch, tmp_path, configured) -> None:
+    configured({"agents": {"gemini": {"binary": "/opt/gemini/bin/gemini"}}})
+
+    assert _dispatch_argv0("gemini", monkeypatch, tmp_path) == "/opt/gemini/bin/gemini"
+
+
+def test_agy_dispatch_execs_the_configured_binary(monkeypatch, tmp_path, configured) -> None:
+    configured({"agents": {"agy": {"binary": "/opt/agy/bin/agy"}}})
+
+    assert _dispatch_argv0("agy", monkeypatch, tmp_path) == "/opt/agy/bin/agy"
+
+
+def test_opencode_dispatch_execs_the_configured_binary(monkeypatch, tmp_path, configured) -> None:
+    # The motivating case: opencode installs to ~/.opencode/bin, which only an
+    # interactive .zshrc puts on PATH — a detached dispatch needs this setting.
+    configured({"agents": {"opencode": {"binary": "~/.opencode/bin/opencode"}}})
+    expected = str(Path("~/.opencode/bin/opencode").expanduser())
+
+    assert _dispatch_argv0("opencode", monkeypatch, tmp_path) == expected
+
+
+def _dispatch_argv0(agent: str, monkeypatch, tmp_path: Path) -> str:
+    """argv[0] of the process a dispatch would have spawned.
+
+    Every handler streams its child's stdout, so the fake has to be a Popen
+    stand-in rather than a plain recorder; we let each dispatch fail after the
+    exec and read the recorded command out of the closure.
+    """
+    recorded: list[list[str]] = []
+
+    class _FakePopen:
+        """Enough of Popen for every handler's read loop: agy polls and writes
+        to file handles, the others iterate stdout and read stderr."""
+
+        returncode = 1
+
+        def __init__(self, cmd, **kwargs):
+            recorded.append(cmd)
+            self.stdout = iter(())
+            self.stderr = _Reader()
+
+        def wait(self) -> int:
+            return self.returncode
+
+        def poll(self) -> int:
+            return self.returncode
+
+        def kill(self) -> None:
+            pass
+
+    class _Reader:
+        @staticmethod
+        def read() -> str:
+            return "stubbed"
+
+    monkeypatch.setattr(f"playmaker.agents.{agent}.subprocess.Popen", _FakePopen)
+    if agent == "opencode":
+        # Model validation shells out to `opencode models`; keep it out of the way.
+        from playmaker.agents.opencode import OpencodeHandler
+
+        monkeypatch.setattr(OpencodeHandler, "available_models", staticmethod(tuple))
+    if agent == "agy":
+        from playmaker.agents.agy import AgyHandler
+
+        monkeypatch.setattr(AgyHandler, "available_models", staticmethod(tuple))
+
+    with pytest.raises(RuntimeError):
+        all_handlers()[agent].dispatch(prompt="p", cwd=tmp_path)
+
+    assert len(recorded) == 1
+    return recorded[0][0]
+
+
+# ---- the shipped template ---------------------------------------------------
+
+
+def test_every_agent_in_the_template_declares_the_binary_it_defaults_to() -> None:
+    # The template is a contract: a key it lists has to be one a handler reads.
+    import tomllib
+
+    from playmaker.cli import _DEFAULT_CONFIG
+
+    cfg = tomllib.loads(_DEFAULT_CONFIG)
+
+    for agent in AGENTS:
+        assert cfg["agents"][agent]["binary"] == agent

{playmaker_cli-0.7.0 → playmaker_cli-0.7.2}/tests/test_quotas_antigravity.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+import http.client
+import json
 import sys
 from pathlib import Path
 
@@ -98,3 +100,110 @@ def test_local_summary_returns_none_when_no_port_answers(monkeypatch) -> None:
     monkeypatch.setattr(quotas.urllib.request, "urlopen", boom)
 
     assert quotas._antigravity_local_summary([49999]) is None
+
+
+class _Response:
+    def __init__(self, body: bytes) -> None:
+        self._body = body
+
+    def read(self) -> bytes:
+        return self._body
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *exc) -> None:
+        return None
+
+
+def test_local_summary_skips_a_port_that_does_not_speak_http(monkeypatch) -> None:
+    # A TLS-only listener answers a plaintext POST with a TLS alert record;
+    # urllib surfaces that as http.client.BadStatusLine, which is not an
+    # OSError. It disqualifies that port — it must not sink the probe.
+    tls_alert = "\x15\x03\x03\x00\x02\x022"
+
+    def urlopen(req, timeout=None, context=None):
+        if ":50652/" in req.full_url:
+            if req.full_url.startswith("https"):
+                raise TimeoutError("The read operation timed out")
+            raise http.client.BadStatusLine(tls_alert)
+        return _Response(json.dumps({"response": _SUMMARY}).encode())
+
+    monkeypatch.setattr(quotas.urllib.request, "urlopen", urlopen)
+
+    assert quotas._antigravity_local_summary([50652, 51802]) == _SUMMARY
+
+
+def test_local_summary_ignores_a_port_that_answers_non_object_json(monkeypatch) -> None:
+    def urlopen(req, timeout=None, context=None):
+        return _Response(b"[]")
+
+    monkeypatch.setattr(quotas.urllib.request, "urlopen", urlopen)
+
+    assert quotas._antigravity_local_summary([49999]) is None
+
+
+def test_daemon_ports_lists_only_the_daemon_sockets(monkeypatch) -> None:
+    # lsof ORs its selectors unless told otherwise, so `-p PID -iTCP` without
+    # `-a` is every LISTEN socket on the machine — that is how the probe ended
+    # up POSTing to Steam and chromedriver. The lookup must AND them and ask
+    # for exactly the pids pgrep found.
+    calls: list[list[str]] = []
+
+    class _Proc:
+        def __init__(self, stdout: str) -> None:
+            self.stdout = stdout
+            self.returncode = 0
+
+    def run(cmd, **kwargs):
+        calls.append(cmd)
+        if cmd[0] == "pgrep":
+            return _Proc("8577\n" if "agy" in cmd[-1] else "")
+        assert cmd[0] == "lsof"
+        return _Proc(
+            "COMMAND PID USER FD TYPE DEVICE SIZE/OFF NODE NAME\n"
+            "agy 8577 me 10u IPv4 0x1 0t0 TCP 127.0.0.1:51802 (LISTEN)\n"
+            "agy 8577 me 11u IPv4 0x2 0t0 TCP 127.0.0.1:51803 (LISTEN)\n"
+        )
+
+    monkeypatch.setattr(quotas.subprocess, "run", run)
+
+    assert quotas._antigravity_daemon_ports() == [51802, 51803]
+    lsof = [c for c in calls if c[0] == "lsof"]
+    assert len(lsof) == 1
+    assert "-a" in lsof[0]
+    assert lsof[0][lsof[0].index("-p") + 1] == "8577"
+
+
+def test_daemon_ports_is_empty_without_a_daemon(monkeypatch) -> None:
+    calls: list[list[str]] = []
+
+    class _Proc:
+        stdout = ""
+        returncode = 1
+
+    def run(cmd, **kwargs):
+        calls.append(cmd)
+        return _Proc()
+
+    monkeypatch.setattr(quotas.subprocess, "run", run)
+
+    assert quotas._antigravity_daemon_ports() == []
+    # No pids → no lsof at all (an unfiltered lsof is the whole-machine listing).
+    assert all(c[0] == "pgrep" for c in calls)
+
+
+def test_antigravity_probe_falls_back_to_remote_when_the_local_path_blows_up(
+    monkeypatch,
+) -> None:
+    def boom():
+        raise http.client.BadStatusLine("\x15\x03\x03\x00\x02\x022")
+
+    monkeypatch.setattr(quotas, "_antigravity_daemon_ports", boom)
+    remote = {"status": "ok", "windows": [{"name": "Flash", "pct_left": 100}]}
+    monkeypatch.setattr(quotas, "_google_code_assist_probe", lambda base_url, ide_type: remote)
+
+    result = quotas.antigravity_probe()
+
+    assert result["status"] == "ok"
+    assert result["source"] == "remote"

{playmaker_cli-0.7.0 → playmaker_cli-0.7.2}/tests/test_quotas_zai.py

@@ -163,3 +163,56 @@ def test_the_environment_is_a_fallback_for_env_injected_configs(monkeypatch, tmp
 
     assert result["status"] == "ok"
     assert seen["headers"]["Authorization"] == "sk-from-env"
+
+
+# The same endpoint on a live Pro plan, 2026-08. z.ai renamed the inference
+# windows TOKENS_LIMIT -> CREDIT_LIMIT when plans moved to weekly Credits, and
+# stopped returning the monthly TIME_LIMIT pool altogether.
+_PAYLOAD_CREDITS = {
+    "code": 200,
+    "msg": "Operation successful",
+    "success": True,
+    "data": {
+        "level": "pro",
+        "limits": [
+            {
+                "type": "CREDIT_LIMIT",
+                "unit": 3,
+                "number": 5,
+                "usage": 12000,
+                "currentValue": 21,
+                "remaining": 11978,
+                "percentage": 1,
+                "nextResetTime": 1787084800394,
+            },
+            {
+                "type": "CREDIT_LIMIT",
+                "unit": 6,
+                "number": 1,
+                "usage": 60000,
+                "currentValue": 21,
+                "remaining": 59978,
+                "percentage": 1,
+                "nextResetTime": 1787671183998,
+            },
+        ],
+    },
+}
+
+
+def test_credit_limit_windows_read_like_the_token_ones(monkeypatch, keyed) -> None:
+    """The rename must not demote the rows to bare spans ("5 hours"/"1 week").
+
+    The labels are shared with the claude probe on purpose, so the two providers
+    line up in the table; an unmapped type still renders but loses that.
+    """
+    _respond(monkeypatch, _PAYLOAD_CREDITS)
+
+    result = quotas.zai_probe()
+
+    assert result["status"] == "ok"
+    assert result["tier"] == "Pro"
+    assert [(w["name"], w["pct_left"]) for w in result["windows"]] == [
+        ("Session", 99),
+        ("Weekly", 99),
+    ]