code-coordinator 0.5.333__tar.gz → 0.5.334__tar.gz

{code_coordinator-0.5.333 → code_coordinator-0.5.334}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.333
+Version: 0.5.334
 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.333 → code_coordinator-0.5.334}/code_coordinator.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.333
+Version: 0.5.334
 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.333 → code_coordinator-0.5.334}/code_coordinator.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.333",
+  "tag": "0.5.334",
   "distance": 0,
-  "node": "g05e864bdfa3476802900ee1d85295822957907e0",
+  "node": "ga8ed02fdc4995b6f8f25c6915f46e94404a5ef85",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-09-01"

{code_coordinator-0.5.333 → code_coordinator-0.5.334}/coord/dashboard/index.html

@@ -521,12 +521,12 @@ async function loadMachines() {
       const a = m.assignments.active[0];
       const spec = a.spec || {};
       detail = `<div class="meta">${badge('busy', 'busy')} #${spec.issue_number}: ${E(spec.issue_title || '')}</div>`;
-      if (a.progress && a.progress.updates && a.progress.updates.length) {
-        detail += `<div class="meta">latest: ${E(a.progress.updates[a.progress.updates.length-1])}</div>`;
-      }
-      if (a.progress && a.progress.stuck) {
-        detail += `<div class="meta" style="color:#da3633">STUCK: ${E(a.progress.stuck)}</div>`;
-      }
+      // #3023: GET /api/machines no longer carries `a.progress` (live
+      // STATUS:/STUCK: tail of the owning machine's own log file) — that
+      // data only ever existed via a fresh per-agent probe, and serving it
+      // here would reintroduce the exact per-request fleet fan-out this
+      // endpoint was reworked to remove. Use `coord status` / `coord log
+      // <id> -f` for live per-worker progress instead.
     }
     return `
       <div class="card">

{code_coordinator-0.5.333 → code_coordinator-0.5.334}/coord/dashboard/server.py

@@ -51,7 +51,6 @@ from coord.drive_queue import (
     summarize_drive_queue,
 )
 from coord.models import Assignment
-from coord.network import check_all, fetch_status
 from coord.openapi import build_spec, dataclass_schema, openapi_and_docs_routes
 from coord.pipeline import PipelineView
 from coord.state import list_drive_queue, load_proposals
@@ -1142,6 +1141,94 @@ def build_app(
             return
         write_board(board)
 
+    def _read_board_and_machine_health() -> tuple:  # -> tuple[Board, dict[str, dict]]
+        """The board plus every configured machine's latest daemon-tick-
+        refreshed health row, keyed by machine name (#3023).
+
+        Backs ``GET /api/machines``. Fetches both in ONE daemon round trip
+        when this dashboard is a thin client (``board_service`` configured)
+        instead of two independent ``GET /board`` calls — the review found
+        that ``_read_machine_health()`` fetching its own payload and then
+        ``_active_assignments_by_machine(_read_board())`` fetching a SECOND
+        one doubled this endpoint's daemon I/O per client poll, which is
+        exactly the per-request amplification #3023 exists to eliminate
+        (just at a smaller scale than the fan-out it replaced). A thin
+        client reads the daemon-published payload's
+        ``fleet_health.machine_health`` sibling key — the tick-refreshed
+        output of ``coord.health.fleet_snapshot.FleetHealthRefresher``
+        (#1630) a board poll already carries — never a fresh per-request
+        probe of the fleet. A dashboard co-located with the daemon (no
+        ``board_service``) has no network cost to share in the first place:
+        it reads the board from the local DB and the health rows straight
+        out of the same local DB via ``coord.state.load_machine_health`` +
+        ``coord.health.fleet_snapshot.machine_health_rows`` (the public
+        wrapper ``FleetHealthRefresher.refresh()`` itself calls right after
+        persisting) — so the two modes can't drift.
+
+        A machine absent from the health dict was never polled (fresh
+        install, or nothing has ticked the health refresher yet) — callers
+        must treat that the same as an ``unknown`` state, never as healthy
+        (#1485's failure mode).
+        """
+        from coord import board_service  # noqa: PLC0415
+
+        svc = board_service.resolve()
+        if svc is not None:
+            from coord.client import board_from_payload, fetch_board_payload  # noqa: PLC0415
+
+            payload = fetch_board_payload(svc)
+            board = board_from_payload(payload)
+            rows = (payload.get("fleet_health") or {}).get("machine_health") or []
+            return board, {row["machine"]: row for row in rows}
+
+        from coord.health.fleet_snapshot import machine_health_rows  # noqa: PLC0415
+        from coord.state import load_machine_health  # noqa: PLC0415
+
+        board = _read_board()
+        raw = load_machine_health()
+        machine_names = [m.name for m in config.machines]
+        rows = machine_health_rows(machine_names, raw, now=time.time())
+        return board, {row["machine"]: row for row in rows}
+
+    def _active_assignments_by_machine(board) -> dict[str, list[dict]]:  # noqa: ANN001
+        """Group *board*'s RUNNING active assignments by machine (#3023).
+
+        Backs the legacy dashboard's per-machine "busy" card
+        (``coord/dashboard/index.html``'s ``loadMachines()``), which used
+        to come from a live per-agent ``GET /status`` probe. The board
+        already carries the same fact — which issue a machine is currently
+        running — from the normal board read path, so grouping it here
+        costs no extra daemon I/O beyond what ``_read_board_and_machine_health()``
+        already fetches.
+
+        Filters to ``status == "running"`` exactly like
+        ``Board.idle_machines()`` and ``Board.active_files_by_repo()`` in
+        ``coord/models.py`` do before treating an active-list entry as real,
+        in-progress work — an unfiltered read of ``board.active`` would be a
+        second, independent answer to "is this machine busy" that could
+        diverge from those two (epic #2096 "one question, one answer").
+        Every ``board.active.append()`` call site happens to set
+        ``status="running"`` at append time today, and reconcile removes
+        non-running entries the same tick it retags them, so this filter is
+        currently a no-op in practice — which is exactly why the existing
+        code defends against it twice already rather than trusting that
+        invariant to hold forever.
+        """
+        out: dict[str, list[dict]] = {}
+        for a in board.active:
+            if a.status != "running":
+                continue
+            out.setdefault(a.machine_name, []).append({
+                "assignment_id": a.assignment_id,
+                "status": a.status,
+                "spec": {
+                    "issue_number": a.issue_number,
+                    "issue_title": a.issue_title,
+                    "repo_name": a.repo_name,
+                },
+            })
+        return out
+
     def _read_drive_queue() -> list[dict]:
         """Every drive-queue row — seeded fixture or the daemon/local DB (#2428).
 
@@ -1350,27 +1437,61 @@ def build_app(
         })
 
     async def api_machines(request: Request) -> JSONResponse:
+        """GET /api/machines — the fleet panel, from daemon-refreshed state (#3023).
+
+        Used to do a synchronous fan-out probe on every request: ``GET
+        /health`` against every configured machine, then ``GET /status``
+        against every one that answered — seconds of worst-case latency,
+        multiplied by every connected client polling this panel live. Now
+        serves the SAME state the board daemon's tick loop already
+        refreshes on its own cadence, plus the board this dashboard reads
+        for every other panel anyway, both from ONE combined read
+        (``_read_board_and_machine_health()``) — zero per-request network
+        fan-out to the fleet, whether this dashboard is co-located with the
+        daemon or a thin client of it.
+
+        Design decision (#3023 review): each active assignment's ``spec``
+        (issue/repo) is included, but the live ``STATUS:``/``STUCK:``
+        per-worker progress tail (``a.progress.updates`` / ``a.progress.stuck``
+        in the pre-#3023 shape) is NOT. That data only ever existed as a
+        fresh tail-read of the OWNING machine's own log file — see
+        ``AgentServer.progress()``/``list_assignments()`` in ``coord/agent.py``
+        ("only this machine can see its own log file — the coordinator
+        cannot stat a remote path") — so serving it here would mean putting
+        the exact per-request fan-out probe this endpoint exists to remove
+        right back in, just hidden one level down. ``coord/dashboard/index.html``
+        no longer reads those two keys; live per-worker progress is still
+        available via ``coord status`` / ``coord log <id> -f``, which DO pay
+        for a targeted probe of the one machine in question rather than
+        every machine on every dashboard poll.
+        """
         if _fixture is not None:
             # Seeded reachability — never probe the fleet in fixture mode.
             return JSONResponse(_fixture.machines())
-        statuses = check_all(config.machines, timeout=3.0)
+        board, health_by_name = _read_board_and_machine_health()
+        assignments_by_machine = _active_assignments_by_machine(board)
         result = []
-        for s in statuses:
+        for m in config.machines:
+            row = health_by_name.get(m.name) or {}
             machine_data = {
-                "name": s.machine.name,
-                "host": s.machine.host,
-                "repos": s.machine.repos,
-                "state": s.state,
-                "reason": s.reason,
-                "latency_ms": s.latency_ms,
+                "name": m.name,
+                "host": m.host,
+                "repos": m.repos,
+                "state": row.get("state", "unknown"),
+                "reason": row.get("reason", ""),
+                "latency_ms": row.get("latency_ms"),
+                # #3023: agent's own running version — compared against
+                # this coordinator's local version by consumers (coord-tui's
+                # `machine_detail_list` shows it red on a mismatch) — and
+                # total on-disk size of this agent's git worktrees. Both
+                # ride the same tick-refreshed health blob as everything
+                # else here; see `coord.health.fleet_snapshot.refresh`.
+                "agent_version": row.get("agent_runtime_version"),
+                "worktree_bytes": row.get("worktree_bytes"),
             }
-            if s.is_online:
-                status_result = fetch_status(s.machine, timeout=3.0)
-                if status_result.ok:
-                    machine_data["assignments"] = status_result.data
-                else:
-                    machine_data["assignments"] = None
-                    machine_data["status_error"] = status_result.error
+            active = assignments_by_machine.get(m.name)
+            if active:
+                machine_data["assignments"] = {"active": active}
             result.append(machine_data)
         return JSONResponse(result)
 

{code_coordinator-0.5.333 → code_coordinator-0.5.334}/coord/health/fleet_snapshot.py

@@ -209,6 +209,19 @@ def _effective_severity(entry: dict, *, now: float) -> tuple[str, bool]:
     return (severity or "unknown"), stale
 
 
+def machine_health_rows(machine_names: list[str], raw: dict, *, now: float) -> list[dict]:
+    """Public wrapper around :func:`_machine_health_rows` (#3023).
+
+    ``coord.dashboard.server`` reads this from outside the module (the
+    local-mode half of ``GET /api/machines``, mirroring the thin-client half
+    that reads the daemon-published ``fleet_health.machine_health`` block
+    ``FleetHealthRefresher.refresh()`` builds from this same function) —
+    exposed as a real entry point instead of reaching across the module
+    boundary for the underscore-prefixed helper below.
+    """
+    return _machine_health_rows(machine_names, raw, now=now)
+
+
 def _machine_health_rows(machine_names: list[str], raw: dict, *, now: float) -> list[dict]:
     rows: list[dict] = []
     for name in machine_names:
@@ -234,6 +247,11 @@ def _machine_health_rows(machine_names: list[str], raw: dict, *, now: float) ->
                 "severity": severity,
                 "checked_at": checks.get("checked_at"),
                 "results": checks.get("results", []),
+                # #3023: sibling facts `refresh()` stashes on the same
+                # persisted `health` blob — see its docstring comment for
+                # why they live here instead of inside `results`.
+                "worktree_bytes": checks.get("worktree_bytes"),
+                "agent_runtime_version": checks.get("agent_runtime_version"),
             }
         )
     return rows
@@ -310,6 +328,36 @@ class FleetHealthRefresher:
             health_block = (
                 status.health.get("health") if status.health else None
             ) or last_known_health
+            # #3023: the coord-web Machines panel (GET /api/machines) needs
+            # two more whole-payload facts that live OUTSIDE the H-1
+            # check-registry block above — the agent's own running
+            # `version` (compared against the coordinator's local version to
+            # flag skew) and `worktree_bytes` (total on-disk size of this
+            # agent's git worktrees). Both are real facts about the agent
+            # PROCESS, not a health check result, so they ride as sibling
+            # keys on the same persisted `health` blob rather than a schema
+            # change — advisory only, same as everything else in this
+            # module (see the module docstring). Freshly measured whenever
+            # this poll actually reached the agent; carried forward from the
+            # last successful poll otherwise, same "last-known, not
+            # blanked" posture as the H-1 `results` above, so a machine
+            # that's merely offline for one tick doesn't flash to "no data"
+            # in the panel. Named `agent_runtime_version` (not
+            # `agent_version`) to avoid colliding with the unrelated
+            # `agent_version` H-1 *check* already inside `results`, which
+            # measures installed-vs-latest-on-PyPI skew, not this.
+            if status.health is not None:
+                worktree_bytes = status.health.get("worktree_bytes")
+                agent_runtime_version = status.health.get("version")
+            else:
+                worktree_bytes = (last_known_health or {}).get("worktree_bytes")
+                agent_runtime_version = (last_known_health or {}).get("agent_runtime_version")
+            if health_block is not None:
+                health_block = {
+                    **health_block,
+                    "worktree_bytes": worktree_bytes,
+                    "agent_runtime_version": agent_runtime_version,
+                }
             state.save_machine_health(
                 machine.name,
                 state=status.state,

{code_coordinator-0.5.333 → code_coordinator-0.5.334}/tests/test_dashboard.py

@@ -125,23 +125,30 @@ class TestBoardAPI:
 
 
 class TestMachinesAPI:
-    @patch("coord.dashboard.server.fetch_status")
-    @patch("coord.dashboard.server.check_all")
-    def test_returns_machine_list(
-        self, mock_check: MagicMock, mock_fetch: MagicMock,
-    ) -> None:
-        mock_status = MagicMock()
-        mock_status.machine = Machine(name="laptop", host="laptop.tailnet", repos=["api"])
-        mock_status.state = "online"
-        mock_status.reason = ""
-        mock_status.latency_ms = 5.0
-        mock_status.is_online = True
-        mock_check.return_value = [mock_status]
-        from coord.network import StatusResult
-        mock_fetch.return_value = StatusResult(data={"active": [], "completed": []})
-
-        client = _client()
-        r = client.get("/api/machines")
+    """#3023: served from the daemon's already-refreshed health snapshot,
+    never a per-request fan-out probe of the fleet — see
+    ``tests/test_dashboard_api.py::TestMachinesAPI`` for the fuller
+    shape/no-probe/legacy-consumer coverage this issue asks for. This class
+    keeps the smoke-level "does the route wire up" check colocated with the
+    rest of this file's board/sessions API tests.
+    """
+
+    def test_returns_machine_list(self) -> None:
+        health = {
+            "laptop": {
+                "state": "online",
+                "reason": "",
+                "latency_ms": 5.0,
+                "received_at": time.time(),
+                "health": {"schema": 1, "checked_at": time.time(), "results": []},
+            },
+        }
+        client = _client()
+        with (
+            patch("coord.state.load_machine_health", return_value=health),
+            patch("coord.dashboard.server.read_board", return_value=Board()),
+        ):
+            r = client.get("/api/machines")
         assert r.status_code == 200
         data = r.json()
         assert len(data) == 1

{code_coordinator-0.5.333 → code_coordinator-0.5.334}/tests/test_dashboard_api.py

@@ -10,14 +10,16 @@ worker thread, which the autouse ``coord_db`` in-memory connection
 from __future__ import annotations
 
 import sqlite3
+import time
 from pathlib import Path
+from unittest.mock import patch
 
 import pytest
 from starlette.testclient import TestClient
 
 from coord.config import Config
 from coord.dashboard.server import build_app
-from coord.models import Machine, Repo
+from coord.models import Assignment, Board, Machine, Repo
 
 
 @pytest.fixture(autouse=True)
@@ -499,3 +501,271 @@ class TestPortalThinClientRouting:
         )
 
         assert r.status_code == 404
+
+
+class TestMachinesAPI:
+    """#3023: GET /api/machines serves the daemon's already-refreshed
+    machine state — never a synchronous per-request fan-out probe of the
+    fleet (the old shape: ``check_all`` against every machine's
+    ``/health``, then ``fetch_status`` against every one that answered).
+    """
+
+    def _health_row(self, **overrides) -> dict:
+        now = time.time()
+        row = {
+            "state": "online",
+            "reason": "",
+            "latency_ms": 7.5,
+            "received_at": now,
+            "health": {
+                "schema": 1,
+                "checked_at": now,
+                "results": [],
+                "worktree_bytes": 4096,
+                "agent_runtime_version": "0.42.0",
+            },
+        }
+        row.update(overrides)
+        return row
+
+    def test_served_shape_carries_daemon_refreshed_fields(self) -> None:
+        """reachability, state/reason, latency, agent version, worktree
+        bytes — all sourced from the tick-refreshed health snapshot, not a
+        live probe of the agent."""
+        client = _client()
+        with (
+            patch(
+                "coord.state.load_machine_health",
+                return_value={"laptop": self._health_row()},
+            ),
+            patch("coord.dashboard.server.read_board", return_value=Board()),
+        ):
+            r = client.get("/api/machines")
+
+        assert r.status_code == 200
+        data = r.json()
+        assert len(data) == 1
+        m = data[0]
+        assert m["name"] == "laptop"
+        assert m["host"] == "laptop.tailnet"
+        assert m["repos"] == ["api"]
+        assert m["state"] == "online"
+        assert m["reason"] == ""
+        assert m["latency_ms"] == 7.5
+        assert m["agent_version"] == "0.42.0"
+        assert m["worktree_bytes"] == 4096
+
+    def test_never_polled_machine_reads_unknown_not_absent(self) -> None:
+        client = _client()
+        with (
+            patch("coord.state.load_machine_health", return_value={}),
+            patch("coord.dashboard.server.read_board", return_value=Board()),
+        ):
+            r = client.get("/api/machines")
+
+        assert r.status_code == 200
+        data = r.json()
+        assert data[0]["state"] == "unknown"
+
+    def test_performs_no_per_request_fleet_probe(self) -> None:
+        """The whole point of #3023: assert on the ABSENCE of the fan-out
+        probe call, not on wall-clock timing (a slow mock could satisfy a
+        timing assertion while still being the wrong architecture).
+        """
+        client = _client()
+        with (
+            patch("coord.network.check_all") as mock_check_all,
+            patch("coord.network.check_machine") as mock_check_machine,
+            patch("coord.network.fetch_status") as mock_fetch_status,
+            patch("coord.state.load_machine_health", return_value={}),
+            patch("coord.dashboard.server.read_board", return_value=Board()),
+        ):
+            r = client.get("/api/machines")
+
+        assert r.status_code == 200
+        mock_check_all.assert_not_called()
+        mock_check_machine.assert_not_called()
+        mock_fetch_status.assert_not_called()
+
+    def test_busy_machine_carries_its_active_assignment_from_the_board(self) -> None:
+        """The legacy dashboard's per-machine 'busy' card used to come from
+        a live per-agent GET /status probe; it now comes from the same
+        board this dashboard already reads for every other panel."""
+        board = Board(active=[
+            Assignment(
+                machine_name="laptop", repo_name="api",
+                issue_number=42, issue_title="Fix auth",
+                assignment_id="abc123", status="running",
+            ),
+        ])
+        client = _client()
+        with (
+            patch("coord.state.load_machine_health", return_value={}),
+            patch("coord.dashboard.server.read_board", return_value=board),
+        ):
+            r = client.get("/api/machines")
+
+        assert r.status_code == 200
+        active = r.json()[0]["assignments"]["active"]
+        assert len(active) == 1
+        assert active[0]["spec"]["issue_number"] == 42
+        assert active[0]["spec"]["issue_title"] == "Fix auth"
+
+    def test_idle_machine_carries_no_assignments_key(self) -> None:
+        client = _client()
+        with (
+            patch("coord.state.load_machine_health", return_value={}),
+            patch("coord.dashboard.server.read_board", return_value=Board()),
+        ):
+            r = client.get("/api/machines")
+
+        assert "assignments" not in r.json()[0]
+
+    def test_non_running_assignment_excluded_from_busy_card(self) -> None:
+        """``_active_assignments_by_machine`` must filter to ``status ==
+        "running"`` exactly like ``Board.idle_machines()`` and
+        ``Board.active_files_by_repo()`` do — an unfiltered read of
+        ``board.active`` would be a second, independent answer to "is this
+        machine busy" that could diverge from those two (#2096 "one
+        question, one answer")."""
+        board = Board(active=[
+            Assignment(
+                machine_name="laptop", repo_name="api",
+                issue_number=99, issue_title="Not actually running",
+                assignment_id="pending1", status="pending",
+            ),
+        ])
+        client = _client()
+        with (
+            patch("coord.state.load_machine_health", return_value={}),
+            patch("coord.dashboard.server.read_board", return_value=board),
+        ):
+            r = client.get("/api/machines")
+
+        assert "assignments" not in r.json()[0]
+
+    def test_thin_client_reads_the_daemons_published_fleet_health_block(
+        self, monkeypatch
+    ) -> None:
+        """``board_service`` configured -> the raw ``/board`` payload's
+        ``fleet_health.machine_health`` sibling key, not a local DB read and
+        not a fresh probe of the fleet.
+
+        Also asserts the payload is fetched exactly ONCE (#3023 review): the
+        health rows and the board's active assignments both come from the
+        same ``/board`` response, not two independent daemon round trips."""
+        import coord.client as cc
+
+        monkeypatch.setattr(
+            cc, "resolve_board_service",
+            lambda *a, **k: cc.ServiceConfig("http://daemon:7435"),
+        )
+
+        now = time.time()
+        payload = {
+            "assignments": [],
+            "plans": {},
+            "round_number": 0,
+            "fleet_health": {
+                "schema": 1,
+                "refreshed_at": now,
+                "truncated": False,
+                "machine_health": [
+                    {
+                        "machine": "laptop",
+                        "state": "online",
+                        "reason": "",
+                        "latency_ms": 3.2,
+                        "received_at": now,
+                        "stale": False,
+                        "severity": "ok",
+                        "checked_at": now,
+                        "results": [],
+                        "worktree_bytes": 999,
+                        "agent_runtime_version": "1.0.0",
+                    },
+                ],
+                "fleet_checks": [],
+            },
+        }
+
+        calls = []
+
+        def fake_get(url, **kw):
+            calls.append(url)
+
+            class _Resp:
+                status_code = 200
+
+                def raise_for_status(self):
+                    return None
+
+                def json(self):
+                    return payload
+
+            return _Resp()
+
+        monkeypatch.setattr(cc.httpx, "get", fake_get)
+
+        with patch("coord.network.check_all") as mock_check_all:
+            client = _client()
+            r = client.get("/api/machines")
+
+        assert len(calls) == 1, (
+            f"expected exactly one /board round trip, got {len(calls)}: {calls}"
+        )
+
+        assert r.status_code == 200
+        mock_check_all.assert_not_called()
+        data = r.json()
+        assert data[0]["worktree_bytes"] == 999
+        assert data[0]["agent_version"] == "1.0.0"
+
+    def test_legacy_dashboard_still_consumes_the_response(self) -> None:
+        """Compatibility check (this issue's explicit ask):
+        ``coord/dashboard/index.html``'s ``loadMachines()`` reads
+        ``m.state``, ``m.latency_ms``, ``m.name``, ``m.host``, ``m.repos``,
+        and ``m.assignments.active[0].spec.{issue_number,issue_title}`` —
+        every key it dereferences must still be present in the served
+        shape.
+
+        Also asserts the (documented, #3023 review) DROPPED half of the old
+        shape: ``a.progress`` (the live per-worker ``STATUS:``/``STUCK:``
+        log tail) is gone from BOTH sides — the server no longer serves it,
+        and ``index.html`` no longer dereferences it — so this isn't a
+        silent, undiscovered loss the way the reviewer flagged the first
+        version of this PR for.
+        """
+        board = Board(active=[
+            Assignment(
+                machine_name="laptop", repo_name="api",
+                issue_number=7, issue_title="Add logging",
+                assignment_id="def456", status="running",
+            ),
+        ])
+        client = _client()
+
+        index_html = client.get("/").text
+        assert "loadMachines" in index_html
+        assert "m.assignments.active" in index_html
+        assert "m.repos" in index_html
+        # Dead branches removed, not just left dangling — a comment
+        # referencing `a.progress` for context is fine, a live
+        # `a.progress.updates`/`a.progress.stuck` dereference is not.
+        assert "a.progress." not in index_html
+
+        with (
+            patch(
+                "coord.state.load_machine_health",
+                return_value={"laptop": self._health_row()},
+            ),
+            patch("coord.dashboard.server.read_board", return_value=board),
+        ):
+            r = client.get("/api/machines")
+
+        m = r.json()[0]
+        for key in ("name", "host", "repos", "state", "latency_ms"):
+            assert key in m
+        assert m["assignments"]["active"][0]["spec"]["issue_number"] == 7
+        assert m["assignments"]["active"][0]["spec"]["issue_title"] == "Add logging"
+        assert "progress" not in m["assignments"]["active"][0]

{code_coordinator-0.5.333 → code_coordinator-0.5.334}/tests/test_dashboard_fixture.py

@@ -68,8 +68,12 @@ def _no_io(monkeypatch: pytest.MonkeyPatch) -> None:
     monkeypatch.setattr("coord.dashboard.server.write_board", _boom)
     monkeypatch.setattr("coord.dashboard.server.load_proposals", _boom)
     monkeypatch.setattr("coord.dashboard.server.list_drive_queue", _boom)
-    monkeypatch.setattr("coord.dashboard.server.check_all", _boom)
-    monkeypatch.setattr("coord.dashboard.server.fetch_status", _boom)
+    # #3023: GET /api/machines no longer fans out to the fleet at all (live
+    # mode now reads the daemon's already-refreshed health snapshot instead
+    # of probing `check_all`/`fetch_status`) — these two boundaries assert
+    # fixture mode never falls through to THAT read path either.
+    monkeypatch.setattr("coord.state.load_machine_health", _boom)
+    monkeypatch.setattr("coord.client.fetch_board_payload", _boom)
     monkeypatch.setattr("coord.merge_queue.load_queue", _boom)
     monkeypatch.setattr("coord.state.load_assignment_review_findings", _boom)
     monkeypatch.setattr("coord.github_ops._gh", _boom)