code-coordinator 0.5.336__tar.gz → 0.5.337__tar.gz

{code_coordinator-0.5.336 → code_coordinator-0.5.337}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.336
+Version: 0.5.337
 Summary: Coordinate Claude Code workers across multiple machines and repos.
 Author-email: John Donaghy <johnfdonaghy@gmail.com>
 License-Expression: LicenseRef-FSL-1.1-MIT

{code_coordinator-0.5.336 → code_coordinator-0.5.337}/code_coordinator.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.336
+Version: 0.5.337
 Summary: Coordinate Claude Code workers across multiple machines and repos.
 Author-email: John Donaghy <johnfdonaghy@gmail.com>
 License-Expression: LicenseRef-FSL-1.1-MIT

{code_coordinator-0.5.336 → code_coordinator-0.5.337}/code_coordinator.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.336",
+  "tag": "0.5.337",
   "distance": 0,
-  "node": "g40054efb9557131858aa5684627e8e9e93b9f6ff",
+  "node": "gd62241bfb0c96bba0b64ac55588d7a44b20a4ed6",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-09-01"

{code_coordinator-0.5.336 → code_coordinator-0.5.337}/coord/dashboard/server.py

@@ -703,6 +703,16 @@ def openapi_spec() -> dict:
                 },
             }
         },
+        "/api/machines/stats": {
+            "get": {
+                "summary": (
+                    "Per-machine work stats derived from the board (#3025): "
+                    "active vs configured concurrency, completed/failed counts "
+                    "over the retention window, and recent (last 20) job history"
+                ),
+                "responses": {"200": {"description": "OK"}},
+            }
+        },
         "/api/proposals": {
             "get": {
                 "summary": "Pending brain proposals awaiting approve/reject",
@@ -1790,6 +1800,104 @@ def build_app(
             )
         return JSONResponse(result)
 
+    async def api_machines_stats(request: Request) -> JSONResponse:
+        """GET /api/machines/stats — per-machine work stats derived purely
+        from the board (#3025): active workers vs configured concurrency,
+        completed/failed counts over the retention window, and recent job
+        history. No new probe, no agent contact — every number here is
+        already sitting in the board this dashboard reads for every other
+        panel; this endpoint just aggregates it per machine.
+
+        Kept as its own endpoint rather than folded into ``GET /api/machines``
+        for the same reason ``/api/machines/health`` and ``/api/machines/metrics``
+        were split out (#3021/#3022/#3024): ``GET /api/machines`` is the
+        small, steady-state shape the fleet panel polls constantly, and a
+        per-machine job-history list (up to 20 rows each) is exactly the
+        heavier, lower-poll-frequency payload that precedent argues for
+        keeping out of it.
+
+        Capacity: ``active`` counts ``board.active`` entries with
+        ``status == "running"`` for the machine — sourced from
+        ``coord.reconcile._running_by_machine``, the same helper
+        ``_reassign``/``describe_no_candidate_machines`` use, so this can't
+        produce a second, diverging answer to "is this machine busy" (#2096
+        / #1417). ``max`` is the effective concurrency ceiling
+        (``coord.reconcile._machine_capacity``: the machine's own
+        ``max_workers`` override, falling back to the fleet-wide
+        ``concurrency.max_workers``) — the exact same helper the dispatcher
+        itself uses to decide whether a machine has headroom, so this can't
+        drift from what actually gates dispatch either.
+
+        Counts + job history are both sourced from ``board.completed`` —
+        every non-active (``done``/``merged``/``failed``/``cancelled``/
+        ``advisory``/``refused_policy``) assignment currently on the board.
+        That list is already retention-windowed upstream
+        (``coord.dao._board_retention_cutoff`` / ``compute_board_keep_ids``,
+        identical in thin-client and co-located mode), so this handler
+        applies no additional cutoff of its own — a machine with nothing in
+        the window (fresh install, or everything aged out) reads zero counts
+        and an empty history, never an error. ``completed`` counts
+        ``status == "done"`` **and** ``status == "merged"`` together —
+        ``coord.state.mark_assignment_merged`` flips a done work assignment
+        to ``status="merged"`` once GitHub confirms the merge, so ``merged``
+        is the normal steady state for a successfully completed assignment,
+        not a distinct outcome (mirrors ``coord.scorecard``'s
+        ``status == "merged"`` success check). ``failed`` counts
+        ``status == "failed"``; ``cancelled``/``advisory``/``refused_policy``
+        rows still appear in ``job_history`` but are not bucketed into
+        either count — they are neither a clean success nor a failure
+        (#448/#2234's "advisory is a third state" distinction).
+
+        ``job_history`` is capped at the most recent 20 per machine (mirrors
+        coord-tui's ``machine_detail_list``), newest first by ``finished_at``
+        (falling back to ``dispatched_at`` for a row that somehow has no
+        ``finished_at``).
+        """
+        from coord.reconcile import _machine_capacity, _running_by_machine  # noqa: PLC0415
+
+        board = _read_board()
+        active_by_machine: dict[str, int] = {
+            name: len(rows) for name, rows in _running_by_machine(board).items()
+        }
+
+        completed_by_machine: dict[str, list] = {}
+        for a in board.completed:
+            completed_by_machine.setdefault(a.machine_name, []).append(a)
+
+        def _sort_key(a):  # noqa: ANN001, ANN202
+            return a.finished_at if a.finished_at is not None else (a.dispatched_at or 0.0)
+
+        result = []
+        for m in config.machines:
+            rows = sorted(
+                completed_by_machine.get(m.name, []), key=_sort_key, reverse=True
+            )
+            result.append({
+                "name": m.name,
+                "capacity": {
+                    "active": active_by_machine.get(m.name, 0),
+                    "max": _machine_capacity(m, config),
+                },
+                "counts": {
+                    "completed": sum(1 for a in rows if a.status in ("done", "merged")),
+                    "failed": sum(1 for a in rows if a.status == "failed"),
+                },
+                "job_history": [
+                    {
+                        "assignment_id": a.assignment_id,
+                        "repo_name": a.repo_name,
+                        "issue_number": a.issue_number,
+                        "issue_title": a.issue_title,
+                        "type": a.type,
+                        "status": a.status,
+                        "dispatched_at": a.dispatched_at,
+                        "finished_at": a.finished_at,
+                    }
+                    for a in rows[:20]
+                ],
+            })
+        return JSONResponse(result)
+
     async def api_sessions(request: Request) -> JSONResponse:
         """GET /api/sessions — live coord-* interactive sessions the phone can
         attach to via GET /ws/terminal/{session_id} (#1066).
@@ -3258,6 +3366,7 @@ def build_app(
         Route("/api/machines", api_machines, methods=["GET"]),
         Route("/api/machines/health", api_machines_health, methods=["GET"]),
         Route("/api/machines/metrics", api_machine_metrics, methods=["GET"]),
+        Route("/api/machines/stats", api_machines_stats, methods=["GET"]),
         Route("/api/sessions", api_sessions, methods=["GET"]),
         Route("/api/proposals", api_proposals, methods=["GET"]),
         Route("/api/drive-queue", api_drive_queue, methods=["GET"]),

{code_coordinator-0.5.336 → code_coordinator-0.5.337}/tests/test_dashboard_api.py

@@ -771,6 +771,203 @@ class TestMachinesAPI:
         assert "progress" not in m["assignments"]["active"][0]
 
 
+class TestMachinesStatsAPI:
+    """#3025: GET /api/machines/stats -- per-machine work stats derived
+    purely from the board (no new probe, no agent contact): active workers
+    vs configured concurrency, completed/failed counts, and recent job
+    history.
+    """
+
+    def _config(self, machines: list[Machine]) -> Config:
+        return Config(
+            repos=[Repo(name="api", github="acme/api")],
+            machines=machines,
+        )
+
+    def _client(self, machines: list[Machine]) -> TestClient:
+        return TestClient(build_app(self._config(machines)))
+
+    def test_machine_with_zero_jobs_reads_empty_stats(self) -> None:
+        """A machine with nothing on the board at all -- fresh install, or
+        everything aged out of the retention window -- reads zero counts
+        and an empty history, never an error."""
+        machines = [Machine(name="idle", host="idle.tailnet", repos=["api"])]
+        client = self._client(machines)
+        with patch("coord.dashboard.server.read_board", return_value=Board()):
+            r = client.get("/api/machines/stats")
+
+        assert r.status_code == 200
+        data = r.json()
+        assert len(data) == 1
+        m = data[0]
+        assert m["name"] == "idle"
+        assert m["capacity"] == {"active": 0, "max": 2}  # default concurrency.max_workers
+        assert m["counts"] == {"completed": 0, "failed": 0}
+        assert m["job_history"] == []
+
+    def test_machine_at_its_concurrency_ceiling(self) -> None:
+        """capacity.active reflects only RUNNING assignments (mirrors
+        `coord.reconcile._running_by_machine`/`Board.idle_machines`), and
+        capacity.max honours a per-machine `max_workers` override over the
+        fleet-wide default (`coord.reconcile._machine_capacity`)."""
+        machines = [
+            Machine(name="laptop", host="laptop.tailnet", repos=["api"], max_workers=1),
+        ]
+        board = Board(active=[
+            Assignment(
+                machine_name="laptop", repo_name="api",
+                issue_number=1, issue_title="At capacity",
+                assignment_id="running1", status="running",
+            ),
+            Assignment(
+                machine_name="laptop", repo_name="api",
+                issue_number=2, issue_title="Not yet dispatched",
+                assignment_id="pending1", status="pending",
+            ),
+        ])
+        client = self._client(machines)
+        with patch("coord.dashboard.server.read_board", return_value=board):
+            r = client.get("/api/machines/stats")
+
+        m = r.json()[0]
+        assert m["capacity"] == {"active": 1, "max": 1}
+
+    def test_completed_and_failed_counts_and_job_history_shape(self) -> None:
+        now = time.time()
+        board = Board(completed=[
+            Assignment(
+                machine_name="laptop", repo_name="api",
+                issue_number=10, issue_title="Older done",
+                assignment_id="done_old", status="done",
+                dispatched_at=now - 200, finished_at=now - 100,
+            ),
+            Assignment(
+                machine_name="laptop", repo_name="api",
+                issue_number=11, issue_title="Newer failure",
+                assignment_id="fail_new", status="failed",
+                dispatched_at=now - 50, finished_at=now - 10,
+            ),
+            Assignment(
+                machine_name="other", repo_name="api",
+                issue_number=12, issue_title="Different machine",
+                assignment_id="other_done", status="done",
+                dispatched_at=now - 30, finished_at=now - 20,
+            ),
+        ])
+        machines = [
+            Machine(name="laptop", host="laptop.tailnet", repos=["api"]),
+            Machine(name="other", host="other.tailnet", repos=["api"]),
+        ]
+        client = self._client(machines)
+        with patch("coord.dashboard.server.read_board", return_value=board):
+            r = client.get("/api/machines/stats")
+
+        by_name = {m["name"]: m for m in r.json()}
+        laptop = by_name["laptop"]
+        assert laptop["counts"] == {"completed": 1, "failed": 1}
+        # Newest (by finished_at) first.
+        assert [j["assignment_id"] for j in laptop["job_history"]] == [
+            "fail_new", "done_old",
+        ]
+        entry = laptop["job_history"][0]
+        assert entry["issue_number"] == 11
+        assert entry["issue_title"] == "Newer failure"
+        assert entry["status"] == "failed"
+        assert entry["repo_name"] == "api"
+        assert entry["dispatched_at"] == now - 50
+        assert entry["finished_at"] == now - 10
+
+        other = by_name["other"]
+        assert other["counts"] == {"completed": 1, "failed": 0}
+        assert [j["assignment_id"] for j in other["job_history"]] == ["other_done"]
+
+    def test_merged_status_counts_as_completed(self) -> None:
+        """`coord.state.mark_assignment_merged` flips a done work assignment
+        to `status="merged"` once GitHub confirms the merge -- that is the
+        normal steady state for a successfully completed assignment, not a
+        distinct outcome, so it must bucket into `counts.completed` the same
+        way `coord.scorecard` treats it as the success signal (not silently
+        fall into neither bucket like advisory/cancelled/refused_policy)."""
+        now = time.time()
+        board = Board(completed=[
+            Assignment(
+                machine_name="laptop", repo_name="api",
+                issue_number=30, issue_title="Merge-confirmed",
+                assignment_id="merged1", status="merged",
+                dispatched_at=now - 100, finished_at=now - 90,
+            ),
+            Assignment(
+                machine_name="laptop", repo_name="api",
+                issue_number=31, issue_title="Still just done",
+                assignment_id="done1", status="done",
+                dispatched_at=now - 50, finished_at=now - 40,
+            ),
+        ])
+        machines = [Machine(name="laptop", host="laptop.tailnet", repos=["api"])]
+        client = self._client(machines)
+        with patch("coord.dashboard.server.read_board", return_value=board):
+            r = client.get("/api/machines/stats")
+
+        m = r.json()[0]
+        assert m["counts"] == {"completed": 2, "failed": 0}
+        assert {j["assignment_id"] for j in m["job_history"]} == {"merged1", "done1"}
+        # job_history preserves the raw status, unlike the collapsed count.
+        history_by_id = {j["assignment_id"]: j for j in m["job_history"]}
+        assert history_by_id["merged1"]["status"] == "merged"
+
+    def test_advisory_and_cancelled_appear_in_history_but_not_in_counts(self) -> None:
+        """#448/#2234: advisory/cancelled/refused_policy are neither a clean
+        success nor a failure -- they still show up in job_history (it is a
+        raw recent-activity feed) but must not inflate either count."""
+        now = time.time()
+        board = Board(completed=[
+            Assignment(
+                machine_name="laptop", repo_name="api",
+                issue_number=20, issue_title="Zero-commit clean exit",
+                assignment_id="adv1", status="advisory",
+                dispatched_at=now - 10, finished_at=now - 5,
+            ),
+            Assignment(
+                machine_name="laptop", repo_name="api",
+                issue_number=21, issue_title="Cancelled mid-run",
+                assignment_id="cancel1", status="cancelled",
+                dispatched_at=now - 20, finished_at=now - 15,
+            ),
+        ])
+        machines = [Machine(name="laptop", host="laptop.tailnet", repos=["api"])]
+        client = self._client(machines)
+        with patch("coord.dashboard.server.read_board", return_value=board):
+            r = client.get("/api/machines/stats")
+
+        m = r.json()[0]
+        assert m["counts"] == {"completed": 0, "failed": 0}
+        assert {j["assignment_id"] for j in m["job_history"]} == {"adv1", "cancel1"}
+
+    def test_job_history_capped_at_most_recent_20(self) -> None:
+        now = time.time()
+        completed = [
+            Assignment(
+                machine_name="laptop", repo_name="api",
+                issue_number=i, issue_title=f"Job {i}",
+                assignment_id=f"job{i}", status="done",
+                dispatched_at=now - (100 - i), finished_at=now - (100 - i),
+            )
+            for i in range(25)
+        ]
+        board = Board(completed=completed)
+        machines = [Machine(name="laptop", host="laptop.tailnet", repos=["api"])]
+        client = self._client(machines)
+        with patch("coord.dashboard.server.read_board", return_value=board):
+            r = client.get("/api/machines/stats")
+
+        m = r.json()[0]
+        assert len(m["job_history"]) == 20
+        # Newest finished_at first: job24 finished most recently.
+        assert m["job_history"][0]["assignment_id"] == "job24"
+        assert m["job_history"][-1]["assignment_id"] == "job5"
+        assert m["counts"]["completed"] == 25  # counts are NOT capped like history
+
+
 class TestMachinesHealthAPI:
     """#3024: GET /api/machines/health -- the fleet-wide `FleetHealthSnapshot`
     (severity/stale/headroom detail per machine, plus fleet-scope checks)