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

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

@@ -5,6 +5,35 @@ 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.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.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: playmaker-cli
-Version: 0.6.0
+Version: 0.7.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
@@ -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.0}/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.0}/pyproject.toml

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