playmaker-cli 0.6.0__tar.gz → 0.7.1__tar.gz

{playmaker_cli-0.6.0 → playmaker_cli-0.7.1}/CHANGELOG.md

@@ -5,6 +5,58 @@ 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.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
+
+- **A batch label is a name you reuse, so the summary now belongs to the
+  fan-out rather than the label.** `--batch dashboard` twice used to mean one
+  batch forever: the second fan-out never pinged at all, because exactly-once
+  was guarded by an `O_EXCL` sentinel in `logs/` that nothing ever removed —
+  and with the sentinel gone it would have counted yesterday's sessions too,
+  `4/4 done · codex ✓ · claude ✓ · codex ✓ · agy ✓` for a fan-out of two, with
+  the stale outputs pasted into the combined `/tmp` file. The claim now lives in
+  `state.db` as a `batch_notified` column: `list_batch` returns the sessions not
+  yet reported, and the finisher that wins the claim releases the label for the
+  next fan-out. Cross-process safety is unchanged — the loser's `UPDATE` finds
+  its set already claimed, rolls back and stays quiet.
+
+- **`playmaker kill` drains the batch it empties.** `killed` is terminal like
+  `done` and `failed`, but `kill` never finalised, so killing a fan-out's last
+  live session left nobody to notice the batch had drained: no summary, ever.
+
+### Changed
+
+- **The combined batch file moved out of `/tmp`.** It is what a batch
+  notification opens on click, so it now lands with the outputs it quotes —
+  `~/.playmaker/outputs/batch-<label>.md` rather than
+  `/tmp/playmaker-batch-<label>.md`, a predictable name in a world-writable
+  directory built from a label the user chose. It also meant the test suite
+  wrote outside `tmp_path`.
+
 ## [0.6.0] - 2026-07-27
 
 ### Added

{playmaker_cli-0.6.0 → playmaker_cli-0.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: playmaker-cli
-Version: 0.6.0
+Version: 0.7.1
 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
@@ -263,7 +263,8 @@ bookkeeping in between.
 ├── state.db          SQLite — sessions, status, pids, models, output paths
 ├── config.toml
 ├── agents/           optional agent profile markdown (claude.md, codex.md, agy.md…)
-├── outputs/          final output per session — .md, or .json if the agent returned JSON
+├── outputs/          final output per session — .md, or .json if the agent returned JSON,
+│                     plus batch-<label>.md, every output in one fan-out combined
 ├── logs/             subprocess stdout for detached runs
 ├── opencode/         pointer per opencode session (its transcript lives in SQLite)
 └── quotas.json       latest capacity snapshot

{playmaker_cli-0.6.0 → playmaker_cli-0.7.1}/README.md

@@ -236,7 +236,8 @@ bookkeeping in between.
 ├── state.db          SQLite — sessions, status, pids, models, output paths
 ├── config.toml
 ├── agents/           optional agent profile markdown (claude.md, codex.md, agy.md…)
-├── outputs/          final output per session — .md, or .json if the agent returned JSON
+├── outputs/          final output per session — .md, or .json if the agent returned JSON,
+│                     plus batch-<label>.md, every output in one fan-out combined
 ├── logs/             subprocess stdout for detached runs
 ├── opencode/         pointer per opencode session (its transcript lives in SQLite)
 └── quotas.json       latest capacity snapshot

{playmaker_cli-0.6.0 → playmaker_cli-0.7.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "playmaker-cli"
-version = "0.6.0"
+version = "0.7.1"
 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.6.0 → playmaker_cli-0.7.1}/src/playmaker/cli.py

@@ -311,7 +311,9 @@ def _maybe_finalize_batch(batch_id: str | None) -> None:
     """Fire one summary notification when every session in a batch is terminal.
 
     Cross-process safe: each detached dispatch calls this on completion; only
-    the finisher that wins the O_EXCL sentinel actually notifies.
+    the finisher that wins the claim in state.db actually notifies. The claim
+    also releases the label — dispatching `--batch dash` again tomorrow is a
+    new fan-out with its own summary, not a repeat of this one.
     """
     if not batch_id:
         return
@@ -322,11 +324,7 @@ def _maybe_finalize_batch(batch_id: str | None) -> None:
     if any(s["status"] not in terminal for s in siblings):
         return  # not the last to finish
 
-    sentinel = state.LOGS_DIR / f".batch-{_batch_slug(batch_id)}.done"
-    try:
-        fd = os.open(str(sentinel), os.O_CREAT | os.O_EXCL | os.O_WRONLY, 0o644)
-        os.close(fd)
-    except FileExistsError:
+    if not state.claim_batch([s["id"] for s in siblings]):
         return  # another finisher already fired the summary
 
     ok = [s for s in siblings if s["status"] == "done"]
@@ -342,7 +340,12 @@ def _maybe_finalize_batch(batch_id: str | None) -> None:
 
 
 def _render_batch_file(batch_id: str, siblings: list) -> Path | None:
-    """Write a combined markdown view of all batch outputs to /tmp for review."""
+    """Write a combined markdown view of all batch outputs, for review.
+
+    It lands in `outputs/` beside the per-session files it quotes: it is what
+    the batch notification opens on click, and its name is derived from a label
+    the user chose, which is not something to hand to a shared /tmp.
+    """
     lines = [f"# playmaker batch: {batch_id}", ""]
     for s in siblings:
         lines.append(f"## {s['agent']} — {s['status']}  ({s['id'][:8]})")
@@ -355,7 +358,7 @@ def _render_batch_file(batch_id: str, siblings: list) -> Path | None:
         except OSError:
             content = "_(no output captured — see `playmaker logs " + s["id"][:8] + "`)_"
         lines += ["", content or "_(empty)_", ""]
-    target = Path("/tmp") / f"playmaker-batch-{_batch_slug(batch_id)}.md"
+    target = state.OUTPUTS_DIR / f"batch-{_batch_slug(batch_id)}.md"
     try:
         target.write_text("\n".join(lines), encoding="utf-8")
         return target
@@ -791,6 +794,9 @@ def kill(
     state.update_session(
         row["id"], status="killed", finished_at=state.now_iso(), exit_code=143
     )
+    # killed is terminal too: if this was the batch's last live session, nobody
+    # else is left to notice the fan-out drained.
+    _maybe_finalize_batch(row.get("batch_id"))
     console.print(f"[magenta]killed[/magenta] {row['id']} (pid {pid})")
 
 

{playmaker_cli-0.6.0 → playmaker_cli-0.7.1}/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"

{playmaker_cli-0.6.0 → playmaker_cli-0.7.1}/src/playmaker/state.py

@@ -37,7 +37,8 @@ CREATE TABLE IF NOT EXISTS sessions (
     parent_id TEXT,
     pid INTEGER,
     model TEXT,
-    batch_id TEXT
+    batch_id TEXT,
+    batch_notified INTEGER
 );
 CREATE INDEX IF NOT EXISTS idx_status ON sessions(status);
 CREATE INDEX IF NOT EXISTS idx_agent ON sessions(agent);
@@ -78,6 +79,16 @@ def init_db() -> None:
             c.execute("ALTER TABLE sessions ADD COLUMN model TEXT")
         if "batch_id" not in existing_cols:
             c.execute("ALTER TABLE sessions ADD COLUMN batch_id TEXT")
+        if "batch_notified" not in existing_cols:
+            c.execute("ALTER TABLE sessions ADD COLUMN batch_notified INTEGER")
+            # Only on the upgrade run: sessions that finished before this column
+            # existed are history — their summary already fired, or never will.
+            # Left unclaimed they would land inside the next summary for the
+            # same label. Sessions still in flight keep theirs.
+            c.execute(
+                "UPDATE sessions SET batch_notified = 1 "
+                "WHERE status IN ('done', 'failed', 'killed')"
+            )
         # Created after migration so it works on pre-existing tables too.
         c.execute("CREATE INDEX IF NOT EXISTS idx_batch ON sessions(batch_id)")
         c.commit()
@@ -121,15 +132,48 @@ def insert_session(
 
 
 def list_batch(batch_id: str) -> list[dict[str, Any]]:
-    """All sessions in a dispatch batch, oldest first."""
+    """The not-yet-summarised sessions of a dispatch batch, oldest first.
+
+    A batch label is a name the user reuses, not a one-off id, so it is the
+    unreported sessions — not every session ever tagged — that make up "the
+    batch" a summary is about.
+    """
     with connect() as c:
         rows = c.execute(
-            "SELECT * FROM sessions WHERE batch_id = ? ORDER BY started_at ASC",
+            "SELECT * FROM sessions "
+            "WHERE batch_id = ? AND batch_notified IS NULL "
+            "ORDER BY started_at ASC",
             (batch_id,),
         ).fetchall()
     return [dict(r) for r in rows]
 
 
+def claim_batch(session_ids: list[str]) -> bool:
+    """Mark these sessions summarised; True if this caller is the one that did.
+
+    Every detached dispatch finalises its batch as it lands, so two of them can
+    see the same drained fan-out. SQLite serialises the write, so the loser
+    finds part of its set already claimed; it rolls back and stays quiet rather
+    than reporting sessions somebody else has already reported. Sessions
+    dispatched into the label after the read are left unclaimed, and become the
+    next fan-out.
+    """
+    if not session_ids:
+        return False
+    placeholders = ", ".join("?" for _ in session_ids)
+    with connect() as c:
+        cur = c.execute(
+            f"UPDATE sessions SET batch_notified = 1 "
+            f"WHERE id IN ({placeholders}) AND batch_notified IS NULL",
+            session_ids,
+        )
+        if cur.rowcount != len(session_ids):
+            c.rollback()
+            return False
+        c.commit()
+        return True
+
+
 def update_session(session_id: str, **fields: Any) -> None:
     if not fields:
         return

playmaker_cli-0.7.1/tests/test_batch.py

@@ -0,0 +1,129 @@
+"""One `--batch` label, many fan-outs: which sessions each summary covers."""
+
+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.state as state
+from playmaker import cli
+
+
+@pytest.fixture
+def db(monkeypatch, tmp_path: Path):
+    """Point the module-level paths at a throwaway home and initialise it."""
+    home = tmp_path / ".playmaker"
+    monkeypatch.setattr(state, "PLAYMAKER_HOME", home)
+    monkeypatch.setattr(state, "DB_PATH", home / "state.db")
+    monkeypatch.setattr(state, "LOGS_DIR", home / "logs")
+    monkeypatch.setattr(state, "OUTPUTS_DIR", home / "outputs")
+    monkeypatch.setattr(state, "AGENTS_DIR", home / "agents")
+    state.init_db()
+    return home
+
+
+@pytest.fixture
+def summaries(monkeypatch) -> list[str]:
+    """Capture the message of every notification the batch code fires."""
+    fired: list[str] = []
+    monkeypatch.setattr(
+        cli.notify, "notify", lambda title, message, **kwargs: fired.append(message)
+    )
+    return fired
+
+
+def _finish(session_id: str, status: str = "done") -> None:
+    state.update_session(session_id, status=status, finished_at=state.now_iso())
+
+
+def _fan_out(label: str, agents: list[str]) -> list[str]:
+    """Dispatch a batch, then let each member finish in order."""
+    ids = [state.insert_session(agent=a, prompt="p", cwd="/repo", batch_id=label) for a in agents]
+    for sid in ids:
+        _finish(sid)
+        cli._maybe_finalize_batch(label)
+    return ids
+
+
+def test_the_summary_waits_for_the_whole_fan_out(db: Path, summaries: list[str]) -> None:
+    first = state.insert_session(agent="codex", prompt="p", cwd="/repo", batch_id="dash")
+    state.insert_session(agent="claude", prompt="p", cwd="/repo", batch_id="dash")
+
+    _finish(first)
+    cli._maybe_finalize_batch("dash")
+
+    assert summaries == []
+
+
+def test_the_summary_fires_exactly_once_per_fan_out(db: Path, summaries: list[str]) -> None:
+    # Every detached dispatch calls the finaliser as it lands, so the last two
+    # to finish can both see an all-terminal batch.
+    _fan_out("dash", ["codex", "claude"])
+
+    cli._maybe_finalize_batch("dash")
+
+    assert summaries == ["2/2 done · codex ✓ · claude ✓"]
+
+
+def test_a_reused_batch_label_summarises_each_fan_out_separately(
+    db: Path, summaries: list[str]
+) -> None:
+    # The README teaches `B=dashboard` as a shell variable you keep around, so
+    # the same label comes back tomorrow with a different set of agents.
+    _fan_out("dash", ["codex", "claude"])
+
+    _fan_out("dash", ["agy", "opencode"])
+
+    assert summaries == [
+        "2/2 done · codex ✓ · claude ✓",
+        "2/2 done · agy ✓ · opencode ✓",
+    ]
+
+
+def test_killing_the_last_running_member_still_drains_the_batch(
+    db: Path, summaries: list[str], monkeypatch
+) -> None:
+    # `kill` is a terminal state like any other; if it does not finalise, the
+    # batch it emptied never reports at all.
+    done = state.insert_session(agent="codex", prompt="p", cwd="/repo", batch_id="dash")
+    doomed = state.insert_session(agent="claude", prompt="p", cwd="/repo", batch_id="dash")
+    _finish(done)
+    cli._maybe_finalize_batch("dash")
+    state.update_session(doomed, status="running", pid=4242)
+    monkeypatch.setattr(cli.os, "getpgid", lambda pid: pid)
+    monkeypatch.setattr(cli.os, "killpg", lambda pgid, sig: None)
+
+    cli.kill(doomed)
+
+    assert summaries == ["1/2 done · codex ✓ · claude ✗"]
+
+
+def test_the_combined_batch_file_lands_next_to_the_outputs_it_quotes(db: Path, monkeypatch) -> None:
+    # It is the file the notification click opens, so it belongs with the rest
+    # of a run's artefacts rather than in a world-writable /tmp under a name
+    # anyone can predict — and a hard-coded /tmp escapes tmp_path in tests.
+    opened: list[str | None] = []
+    monkeypatch.setattr(
+        cli.notify,
+        "notify",
+        lambda title, message, **kwargs: opened.append(kwargs.get("open_path")),
+    )
+
+    _fan_out("dash", ["codex", "claude"])
+
+    combined = db / "outputs" / "batch-dash.md"
+    assert opened == [str(combined)]
+    assert combined.read_text(encoding="utf-8").count("\n## ") == 2
+
+
+def test_a_batch_of_one_that_failed_reports_the_failure(db: Path, summaries: list[str]) -> None:
+    sid = state.insert_session(agent="agy", prompt="p", cwd="/repo", batch_id="solo")
+
+    _finish(sid, status="failed")
+    cli._maybe_finalize_batch("solo")
+
+    assert summaries == ["0/1 done · agy ✗"]

{playmaker_cli-0.6.0 → playmaker_cli-0.7.1}/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.6.0 → playmaker_cli-0.7.1}/tests/test_state.py

@@ -117,6 +117,44 @@ def test_list_batch_returns_only_that_batch_oldest_first(db: Path) -> None:
     assert state.list_batch("nothing") == []
 
 
+def test_list_batch_forgets_a_fan_out_that_was_already_summarised(db: Path) -> None:
+    # A batch label is reusable, so "the batch" means the fan-out that has not
+    # been reported yet — not every session ever tagged with that label.
+    first = state.insert_session(agent="codex", prompt="a", cwd="/r", batch_id="dash")
+    state.claim_batch([first])
+
+    second = state.insert_session(agent="agy", prompt="b", cwd="/r", batch_id="dash")
+
+    assert [r["id"] for r in state.list_batch("dash")] == [second]
+
+
+def test_claim_batch_lets_exactly_one_caller_win(db: Path) -> None:
+    # Each detached dispatch finalises its own batch as it lands, so two
+    # processes can race to report the same fan-out.
+    ids = [
+        state.insert_session(agent=a, prompt="p", cwd="/r", batch_id="dash")
+        for a in ("codex", "agy")
+    ]
+
+    assert state.claim_batch(ids) is True
+    assert state.claim_batch(ids) is False
+
+
+def test_claim_batch_refuses_a_set_that_is_already_partly_claimed(db: Path) -> None:
+    # A partial overlap means someone else's summary covered these sessions;
+    # reporting them again would double-count.
+    first = state.insert_session(agent="codex", prompt="a", cwd="/r", batch_id="dash")
+    second = state.insert_session(agent="agy", prompt="b", cwd="/r", batch_id="dash")
+    state.claim_batch([first])
+
+    assert state.claim_batch([first, second]) is False
+    assert [r["id"] for r in state.list_batch("dash")] == [second]
+
+
+def test_claim_batch_of_nothing_is_not_a_win(db: Path) -> None:
+    assert state.claim_batch([]) is False
+
+
 def test_init_db_migrates_a_database_without_model_and_batch_columns(
     monkeypatch, tmp_path: Path
 ) -> None:
@@ -155,3 +193,43 @@ def test_init_db_migrates_a_database_without_model_and_batch_columns(
     assert row["model"] is None
     assert row["batch_id"] is None
     assert state.insert_session(agent="agy", prompt="p", cwd="/r", batch_id="b")
+
+
+def test_init_db_treats_finished_sessions_as_already_summarised(
+    monkeypatch, tmp_path: Path
+) -> None:
+    # Reusing a batch label predates this column, so on the upgrade run every
+    # finished session is history: sweeping it into the next fan-out's summary
+    # would report last week's agents alongside today's.
+    home = tmp_path / ".playmaker"
+    home.mkdir()
+    monkeypatch.setattr(state, "PLAYMAKER_HOME", home)
+    monkeypatch.setattr(state, "DB_PATH", home / "state.db")
+    monkeypatch.setattr(state, "LOGS_DIR", home / "logs")
+    monkeypatch.setattr(state, "OUTPUTS_DIR", home / "outputs")
+    monkeypatch.setattr(state, "AGENTS_DIR", home / "agents")
+    legacy = sqlite3.connect(home / "state.db")
+    legacy.execute(
+        """
+        CREATE TABLE sessions (
+            id TEXT PRIMARY KEY, agent TEXT NOT NULL, agent_session_id TEXT,
+            prompt TEXT NOT NULL, cwd TEXT NOT NULL, files TEXT,
+            status TEXT NOT NULL, started_at TEXT NOT NULL, finished_at TEXT,
+            exit_code INTEGER, cost_usd REAL, duration_seconds REAL,
+            output_path TEXT, session_file_path TEXT, parent_id TEXT, pid INTEGER,
+            model TEXT, batch_id TEXT
+        )
+        """
+    )
+    legacy.executemany(
+        "INSERT INTO sessions (id, agent, prompt, cwd, status, started_at, batch_id) VALUES "
+        "(?, 'codex', 'p', '/repo', ?, '2020-01-01T00:00:00', 'dash')",
+        [("old-done", "done"), ("old-running", "running")],
+    )
+    legacy.commit()
+    legacy.close()
+
+    state.init_db()
+
+    # A batch still in flight when the upgrade lands keeps its summary.
+    assert [r["id"] for r in state.list_batch("dash")] == ["old-running"]