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

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

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

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

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

{code_coordinator-0.5.337 → code_coordinator-0.5.338}/coord/dashboard/fixture.py

@@ -29,11 +29,19 @@ Fixture schema (every key optional except ``board``)::
         "round_number": 7,
         "assignments": [ {...assignment row...} ],
         "plans": {},                # assignment_id -> plan object
-        "notifications": []         # [{"assignment_id": ...}]
+        "notifications": [],        # [{"assignment_id": ...}]
+        "fleet_health": {           # GET /api/machines/health's block, verbatim (#3026)
+          "schema": 1, "refreshed_at": 1750000000.0,
+          "machine_health": [ {...coord.health.fleet_snapshot row shape...} ],
+          "fleet_checks": [], "truncated": false
+        }
       },
       "merge_queue":     [ {...coord.merge_queue.QueuedMerge fields...} ],
       "proposals":       [ {...coord.models.Proposal fields...} ],
       "machines":        [ {...GET /api/machines entry...} ],
+      "machine_metrics": {         # GET /api/machines/metrics source series (#3026)
+        "precision": [ {...coord.machine_metrics.MetricsSample.to_dict()...} ]
+      },
       "sessions":        [ {...GET /api/sessions entry...} ],
       "drive_queue":     [ {...coord.state._decode_drive_queue_row shape...} ],
       "report_catalogue": {"reports": [ {...coord.reports.ReportDef.to_dict()...} ]},
@@ -55,7 +63,17 @@ client is subscribed (a late subscriber can still catch up via
 ``board`` may also be spelled at the top level (``assignments`` /
 ``round_number`` as siblings of ``merge_queue``), which is exactly what
 ``scripts/gen_board_fixture.py`` emits — so a golden ``/board`` capture drops
-in unchanged.
+in unchanged. ``fleet_health`` rides along as a sibling of ``assignments`` in
+either spelling, for the identical reason: it is already a sibling key on the
+real daemon's ``/board`` payload (``FleetHealthSnapshot.to_dict()``), so a
+golden capture carries it for free.
+
+``GET /api/machines/stats`` (#3026) needs no dedicated fixture key at all —
+it is derived purely from ``board`` (completed/active assignments) and
+``config.machines`` (for the concurrency ceiling), exactly like the live
+handler, so seeding a realistic spread of completed/failed/running
+assignments per machine in ``board.assignments`` is all a fixture needs to
+exercise it.
 """
 
 from __future__ import annotations
@@ -157,6 +175,9 @@ class FixtureServer:
     merge_queue_raw: list = field(default_factory=list)
     proposals_raw: list = field(default_factory=list)
     machines_raw: list = field(default_factory=list)
+    #: #3026: seeded `GET /api/machines/metrics` source series, keyed by
+    #: machine name — see `machine_metrics_series()`.
+    machine_metrics_raw: dict = field(default_factory=dict)
     sessions_raw: list = field(default_factory=list)
     drive_queue_raw: list = field(default_factory=list)
     #: #2492 RPT-1: `GET /api/report`'s catalogue. `None` (the default) falls
@@ -202,6 +223,20 @@ class FixtureServer:
     def machines(self) -> list[dict]:
         return copy.deepcopy(self.machines_raw)
 
+    def machine_metrics_series(self) -> dict[str, list[dict]]:
+        """Seeded per-machine metrics ring-buffer contents (#3026).
+
+        Same shape ``coord.machine_metrics.MachineMetricsSampler.all_series()``
+        returns live — machine name to an oldest-first list of
+        ``MetricsSample``-shaped dicts — so ``api_machine_metrics`` can run
+        it through the real ``resolve_since``/``build_metrics_response``
+        pipeline unchanged (no parallel fake filtering/downsampling path);
+        only the series *source* differs from the live daemon-proxy path.
+        A machine absent here comes back ``[]``, same as the live sampler's
+        "never polled yet" case.
+        """
+        return copy.deepcopy(self.machine_metrics_raw)
+
     def sessions(self) -> list[dict]:
         return copy.deepcopy(self.sessions_raw)
 
@@ -387,6 +422,17 @@ def parse_fixture(raw: Any, *, path: Path | None = None) -> FixtureServer:
         "plans": _as_dict(board_raw.get("plans"), "board.plans"),
         "notifications": _as_list(board_raw.get("notifications"), "board.notifications"),
     }
+    # #3026: `fleet_health` rides along as a sibling of `assignments` on the
+    # real daemon's `/board` payload (`FleetHealthSnapshot.to_dict()`) — carry
+    # it through verbatim so `api_machines_health`'s fixture branch (which
+    # reads `board_payload.get("fleet_health")`) has something to serve.
+    # Absent entirely (the common case for a fixture that doesn't care about
+    # machine health) leaves the key out, matching `_EMPTY_FLEET_HEALTH_BLOCK`
+    # already being the handler's own fallback.
+    if board_raw.get("fleet_health") is not None:
+        board_payload["fleet_health"] = _as_dict(
+            board_raw.get("fleet_health"), "board.fleet_health"
+        )
 
     now = raw.get("now")
     if now is not None:
@@ -418,11 +464,20 @@ def parse_fixture(raw: Any, *, path: Path | None = None) -> FixtureServer:
             "fixture 'report_results' values must be mappings (ReportResult wire shape)"
         )
 
+    machine_metrics_raw = _as_dict(raw.get("machine_metrics"), "machine_metrics")
+    for name, series in machine_metrics_raw.items():
+        if not isinstance(series, list):
+            raise FixtureError(
+                f"fixture 'machine_metrics[{name!r}]' must be a list, "
+                f"got {type(series).__name__}"
+            )
+
     server = FixtureServer(
         board_payload=board_payload,
         merge_queue_raw=_as_list(raw.get("merge_queue"), "merge_queue"),
         proposals_raw=_as_list(raw.get("proposals"), "proposals"),
         machines_raw=_as_list(raw.get("machines"), "machines"),
+        machine_metrics_raw=machine_metrics_raw,
         sessions_raw=_as_list(raw.get("sessions"), "sessions"),
         drive_queue_raw=_as_list(raw.get("drive_queue"), "drive_queue"),
         report_catalogue_raw=report_catalogue_raw,

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

@@ -1749,11 +1749,14 @@ def build_app(
         duplicate or drift from it. See ``_machine_metrics_daemon_target()``
         for how daemon-vs-local is resolved.
 
-        Fixture mode has no live sampler to simulate at all, so it always
-        reports the same explicit-unreachable shape a real unreachable
-        daemon would (below) rather than pretending to have live data —
-        mirrors ``api_machines``' "never probe the fleet in fixture mode",
-        just with nothing to seed instead of a canned reachable answer.
+        Fixture mode (#3026) has no live sampler to simulate, so it runs the
+        seeded per-machine series (``FixtureServer.machine_metrics_series()``)
+        through the exact same ``resolve_since``/``build_metrics_response``
+        pipeline the daemon's own ``GET /machines/metrics`` handler
+        (``coord.serve_app.get_machine_metrics``) uses — only the series
+        *source* differs, so ``since``/``resolution``/``machine`` and a bad
+        value's 400 all behave identically to live mode. Never probes the
+        fleet, mirroring ``api_machines``' fixture branch.
 
         Degrades honestly (#3022): a daemon that is unreachable (down,
         network partition, wrong token) comes back as an explicit
@@ -1768,13 +1771,33 @@ def build_app(
         caller's bad input, not a daemon health problem.
         """
         if _fixture is not None:
-            return JSONResponse(
-                {
-                    "error": "machine metrics have no fixture source",
-                    "reachable": False,
-                },
-                status_code=503,
+            from coord.machine_metrics import (  # noqa: PLC0415
+                build_metrics_response,
+                resolve_since,
+            )
+
+            qp = request.query_params
+            resolution_raw = qp.get("resolution")
+            try:
+                resolution = int(resolution_raw) if resolution_raw else None
+                if resolution is not None and resolution <= 0:
+                    raise ValueError("resolution must be a positive integer")
+            except ValueError as e:
+                return JSONResponse(
+                    {"error": f"bad resolution={resolution_raw!r}: {e}"}, status_code=400
+                )
+            try:
+                since = resolve_since(qp.get("since"), now=_fixture.now)
+            except ValueError as e:
+                return JSONResponse({"error": str(e)}, status_code=400)
+            result = build_metrics_response(
+                _fixture.machine_metrics_series(),
+                machine=qp.get("machine") or None,
+                since=since,
+                resolution=resolution,
+                now=_fixture.now,
             )
+            return JSONResponse(result)
 
         from coord.client import fetch_machine_metrics  # noqa: PLC0415
 
@@ -1852,6 +1875,13 @@ def build_app(
         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``).
+
+        Fixture mode (#3026) needs no dedicated branch here at all: ``_read_board()``
+        already returns the seeded board and ``config`` is already the fixture's
+        own ``config`` block (or the caller-supplied fallback) — this handler
+        reads both exactly like live mode, so a fixture with a realistic spread
+        of completed/failed/running assignments per machine exercises it for
+        free.
         """
         from coord.reconcile import _machine_capacity, _running_by_machine  # noqa: PLC0415
 

{code_coordinator-0.5.337 → code_coordinator-0.5.338}/tests/fixtures/board-pipeline-basic.json

@@ -7,7 +7,19 @@
     "Every timestamp is a fixed epoch offset from `now` — nothing here reads",
     "the wall clock, so two runs produce byte-identical /api/pipeline output.",
     "The `events` script below does NOT auto-play: subscribe to /events first,",
-    "then POST /api/fixture/events/replay. Schema: coord/dashboard/fixture.py."
+    "then POST /api/fixture/events/replay. Schema: coord/dashboard/fixture.py.",
+    "",
+    "#3026 — board.fleet_health seeds GET /api/machines/health with five rows",
+    "spanning all four severities plus a stale row: precision=ok,",
+    "dellserver=unknown (offline, matches its `machines` reachability entry",
+    "below), gpu-box=warn, build-runner=crit, spare-mini=ok-but-stale (last",
+    "measured OK a long time ago — the 'OK' vs 'last measured OK, a while",
+    "ago' distinction #1630 exists for). Top-level `machine_metrics` seeds",
+    "GET /api/machines/metrics: precision's series has a gap (no sample",
+    "between now-90 and now-30 — e.g. a daemon restart, since the ring buffer",
+    "is memory-only) and one 'unknown' sample sandwiched between real",
+    "readings; dellserver's series is unknown end-to-end, matching its",
+    "offline reachability entry."
   ],
   "now": 1750000000.0,
 
@@ -181,7 +193,144 @@
       {"assignment_id": "rev-done"},
       {"assignment_id": "rev-merge-queued"},
       {"assignment_id": "rev-review-approved"}
-    ]
+    ],
+    "fleet_health": {
+      "schema": 1,
+      "refreshed_at": 1749999950.0,
+      "fleet_checks": [],
+      "truncated": false,
+      "machine_health": [
+        {
+          "machine": "precision",
+          "state": "online",
+          "reason": "",
+          "latency_ms": 12,
+          "received_at": 1749999950.0,
+          "stale": false,
+          "severity": "ok",
+          "checked_at": 1749999950.0,
+          "results": [
+            {
+              "key": "disk:/",
+              "check_id": "disk",
+              "scope": "machine",
+              "subject": "/",
+              "title": "disk",
+              "label": "disk /",
+              "severity": "ok",
+              "headroom": "42% used (120G free)",
+              "threshold": "warn at 80%, crit at 93%",
+              "detail": "",
+              "trend": null,
+              "values": {"used_pct": 42.0},
+              "error": null
+            }
+          ],
+          "worktree_bytes": 1048576,
+          "agent_runtime_version": "2026.9.1"
+        },
+        {
+          "machine": "dellserver",
+          "state": "offline",
+          "reason": "connection refused",
+          "latency_ms": null,
+          "received_at": null,
+          "stale": false,
+          "severity": "unknown",
+          "checked_at": null,
+          "results": [],
+          "worktree_bytes": null,
+          "agent_runtime_version": null
+        },
+        {
+          "machine": "gpu-box",
+          "state": "online",
+          "reason": "",
+          "latency_ms": 40,
+          "received_at": 1749999900.0,
+          "stale": false,
+          "severity": "warn",
+          "checked_at": 1749999900.0,
+          "results": [
+            {
+              "key": "disk:/",
+              "check_id": "disk",
+              "scope": "machine",
+              "subject": "/",
+              "title": "disk",
+              "label": "disk /",
+              "severity": "warn",
+              "headroom": "84% used (16G free)",
+              "threshold": "warn at 80%, crit at 93%",
+              "detail": "",
+              "trend": null,
+              "values": {"used_pct": 84.0},
+              "error": null
+            }
+          ],
+          "worktree_bytes": 2097152,
+          "agent_runtime_version": "2026.9.1"
+        },
+        {
+          "machine": "build-runner",
+          "state": "online",
+          "reason": "",
+          "latency_ms": 55,
+          "received_at": 1749999800.0,
+          "stale": false,
+          "severity": "crit",
+          "checked_at": 1749999800.0,
+          "results": [
+            {
+              "key": "disk:/",
+              "check_id": "disk",
+              "scope": "machine",
+              "subject": "/",
+              "title": "disk",
+              "label": "disk /",
+              "severity": "crit",
+              "headroom": "96% used (2G free)",
+              "threshold": "warn at 80%, crit at 93%",
+              "detail": "",
+              "trend": null,
+              "values": {"used_pct": 96.0},
+              "error": null
+            }
+          ],
+          "worktree_bytes": 3145728,
+          "agent_runtime_version": "2026.8.30"
+        },
+        {
+          "machine": "spare-mini",
+          "state": "online",
+          "reason": "",
+          "latency_ms": 20,
+          "received_at": 1749996400.0,
+          "stale": true,
+          "severity": "ok",
+          "checked_at": 1749996400.0,
+          "results": [
+            {
+              "key": "disk:/",
+              "check_id": "disk",
+              "scope": "machine",
+              "subject": "/",
+              "title": "disk",
+              "label": "disk /",
+              "severity": "ok",
+              "headroom": "30% used (200G free)",
+              "threshold": "warn at 80%, crit at 93%",
+              "detail": "",
+              "trend": null,
+              "values": {"used_pct": 30.0},
+              "error": null
+            }
+          ],
+          "worktree_bytes": 524288,
+          "agent_runtime_version": "2026.8.15"
+        }
+      ]
+    }
   },
 
   "merge_queue": [
@@ -306,6 +455,22 @@
     }
   ],
 
+  "machine_metrics": {
+    "precision": [
+      {"timestamp": 1749999880.0, "status": "ok", "cpu_percent": 12.5, "mem_percent": 40.0, "mem_used_mb": 6400.0, "mem_total_mb": 16000.0, "reason": ""},
+      {"timestamp": 1749999895.0, "status": "ok", "cpu_percent": 15.0, "mem_percent": 41.0, "mem_used_mb": 6560.0, "mem_total_mb": 16000.0, "reason": ""},
+      {"timestamp": 1749999910.0, "status": "unknown", "cpu_percent": null, "mem_percent": null, "mem_used_mb": null, "mem_total_mb": null, "reason": "agent unreachable (timeout)"},
+      {"timestamp": 1749999970.0, "status": "ok", "cpu_percent": 20.0, "mem_percent": 45.0, "mem_used_mb": 7200.0, "mem_total_mb": 16000.0, "reason": ""},
+      {"timestamp": 1749999985.0, "status": "ok", "cpu_percent": 18.0, "mem_percent": 44.0, "mem_used_mb": 7040.0, "mem_total_mb": 16000.0, "reason": ""},
+      {"timestamp": 1750000000.0, "status": "ok", "cpu_percent": 22.0, "mem_percent": 46.0, "mem_used_mb": 7360.0, "mem_total_mb": 16000.0, "reason": ""}
+    ],
+    "dellserver": [
+      {"timestamp": 1749999880.0, "status": "unknown", "cpu_percent": null, "mem_percent": null, "mem_used_mb": null, "mem_total_mb": null, "reason": "connection refused"},
+      {"timestamp": 1749999940.0, "status": "unknown", "cpu_percent": null, "mem_percent": null, "mem_used_mb": null, "mem_total_mb": null, "reason": "connection refused"},
+      {"timestamp": 1750000000.0, "status": "unknown", "cpu_percent": null, "mem_percent": null, "mem_used_mb": null, "mem_total_mb": null, "reason": "connection refused"}
+    ]
+  },
+
   "sessions": [
     {
       "session_id": "work-running",

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

@@ -1337,14 +1337,38 @@ class TestMachineMetricsAPI:
         assert r.status_code == 400
         assert "reachable" not in r.json()
 
-    def test_fixture_mode_reports_unreachable_rather_than_faking_a_series(self) -> None:
-        """``coord web --fixture`` has no live sampler to simulate -- it must
-        say so honestly rather than returning a canned "healthy" series."""
+    def test_fixture_mode_serves_the_seeded_series_never_the_live_daemon(
+        self, monkeypatch
+    ) -> None:
+        """``coord web --fixture`` (#3026) never proxies to a live daemon --
+        it runs the fixture's own seeded series through the same
+        ``resolve_since``/``build_metrics_response`` pipeline instead.
+        An unseeded fixture (no ``machine_metrics`` key) reads back as an
+        empty ``machines`` dict -- the same "nothing sampled yet" shape the
+        live sampler reports for a machine it has never polled -- rather
+        than a canned unreachable error (that was the pre-#3026 placeholder,
+        superseded now that the fixture has a real seeding path)."""
+        import coord.client as cc
         from coord.dashboard.fixture import FixtureServer
 
+        def _boom(*a, **k):
+            raise AssertionError("fixture mode reached a live daemon")
+
+        monkeypatch.setattr(cc, "fetch_machine_metrics", _boom)
+
         client = TestClient(build_app(_config(), fixture=FixtureServer()))
 
         r = client.get("/api/machines/metrics")
 
-        assert r.status_code == 503
-        assert r.json()["reachable"] is False
+        assert r.status_code == 200
+        assert r.json()["machines"] == {}
+
+        seeded = FixtureServer(machine_metrics_raw={"laptop": [
+            {"timestamp": 1234.5, "status": "ok", "cpu_percent": 12.0,
+             "mem_percent": 30.0, "mem_used_mb": 100.0, "mem_total_mb": 400.0,
+             "reason": ""},
+        ]})
+        client = TestClient(build_app(_config(), fixture=seeded))
+        r = client.get("/api/machines/metrics")
+        assert r.status_code == 200
+        assert r.json()["machines"] == {"laptop": seeded.machine_metrics_raw["laptop"]}

{code_coordinator-0.5.337 → code_coordinator-0.5.338}/tests/test_dashboard_fixture.py

@@ -77,6 +77,12 @@ def _no_io(monkeypatch: pytest.MonkeyPatch) -> None:
     monkeypatch.setattr("coord.merge_queue.load_queue", _boom)
     monkeypatch.setattr("coord.state.load_assignment_review_findings", _boom)
     monkeypatch.setattr("coord.github_ops._gh", _boom)
+    # #3026: GET /api/machines/health and GET /api/machines/metrics must serve
+    # the seeded fleet_health block / metrics series in fixture mode, never
+    # the live daemon-proxy (`fetch_machine_metrics`) or co-located
+    # (`local_fleet_health_block`) read paths those endpoints use live.
+    monkeypatch.setattr("coord.client.fetch_machine_metrics", _boom)
+    monkeypatch.setattr("coord.health.aggregate.local_fleet_health_block", _boom)
 
 
 def _config() -> Config:
@@ -310,6 +316,121 @@ class TestSeededReads:
         )
 
 
+class TestMachinesPanelFixtures:
+    """Machines-panel seeding for coord-web's Machines panel milestone (#3026).
+
+    ``GET /api/machines`` and ``GET /api/sessions`` were already covered by
+    ``TestSeededReads.test_machines_and_sessions_never_probe_the_fleet`` —
+    this class covers the three endpoints #3020-#3025 added on top: metrics,
+    health, and per-machine work stats. Every one of these must serve seeded
+    data and never reach the fleet, mirroring the rest of this module.
+    """
+
+    def test_machine_metrics_serves_the_seeded_series(self) -> None:
+        """#3021/#3022's response shape, sourced from the fixture (#3026)."""
+        r = _client().get("/api/machines/metrics")
+        assert r.status_code == 200
+        body = r.json()
+        assert body["schema"] == 1
+        assert body["generated_at"] == 1750000000.0
+        assert set(body["machines"]) == {"precision", "dellserver"}
+        precision = body["machines"]["precision"]
+        assert [s["status"] for s in precision] == [
+            "ok", "ok", "unknown", "ok", "ok", "ok",
+        ]
+        # The deliberate gap: no sample between the unknown one at -90s and
+        # the next real reading at -30s (a 60s hole a renderer must draw as
+        # a break, not interpolate across).
+        assert precision[2]["timestamp"] == 1749999910.0
+        assert precision[3]["timestamp"] == 1749999970.0
+        assert precision[3]["timestamp"] - precision[2]["timestamp"] == 60.0
+        # dellserver is unknown end-to-end, matching its offline `machines` row.
+        dellserver = body["machines"]["dellserver"]
+        assert dellserver and all(s["status"] == "unknown" for s in dellserver)
+
+    def test_machine_metrics_narrows_to_one_machine(self) -> None:
+        body = _client().get("/api/machines/metrics", params={"machine": "precision"}).json()
+        assert set(body["machines"]) == {"precision"}
+
+    def test_machine_metrics_since_and_resolution_use_the_real_pipeline(self) -> None:
+        """``since``/``resolution`` run through the real filter/downsample code
+        (``coord.machine_metrics``), not a fixture-only reimplementation."""
+        client = _client()
+        since_body = client.get(
+            "/api/machines/metrics", params={"since": "45s"}
+        ).json()
+        # now=1750000000.0, so since=now-45s=1749999955.0 keeps only the
+        # last two precision samples (-30s and -15s... actually 0s/-15s/-30s
+        # are >= 1749999955? recompute: samples at -30s/-15s/0s are all >=).
+        assert [s["timestamp"] for s in since_body["machines"]["precision"]] == [
+            1749999970.0, 1749999985.0, 1750000000.0,
+        ]
+        resolution_body = client.get(
+            "/api/machines/metrics", params={"resolution": 3}
+        ).json()
+        assert len(resolution_body["machines"]["precision"]) == 3
+        assert len(resolution_body["machines"]["dellserver"]) <= 3
+
+    def test_machine_metrics_bad_resolution_is_a_400(self) -> None:
+        r = _client().get("/api/machines/metrics", params={"resolution": "0"})
+        assert r.status_code == 400
+        assert "resolution" in r.json()["error"]
+
+    def test_machine_metrics_bad_since_is_a_400(self) -> None:
+        r = _client().get("/api/machines/metrics", params={"since": "not-a-time"})
+        assert r.status_code == 400
+
+    def test_machine_metrics_absent_from_fixture_is_an_empty_series(self) -> None:
+        """No ``machine_metrics`` key at all -- every machine reads ``[]``,
+        never an error (mirrors the live sampler's "never polled" case)."""
+        fx = parse_fixture({"board": {"assignments": []}})
+        body = _client(fx).get("/api/machines/metrics").json()
+        assert body["machines"] == {}
+
+    def test_machine_health_spans_all_four_severities_plus_a_stale_row(self) -> None:
+        r = _client().get("/api/machines/health")
+        assert r.status_code == 200
+        body = r.json()
+        assert body["schema"] == 1
+        by_machine = {row["machine"]: row for row in body["machine_health"]}
+        assert by_machine["precision"]["severity"] == "ok"
+        assert by_machine["dellserver"]["severity"] == "unknown"
+        assert by_machine["gpu-box"]["severity"] == "warn"
+        assert by_machine["build-runner"]["severity"] == "crit"
+        # #1630's honesty contract: `stale` and `severity` are independent —
+        # spare-mini's last-known reading was OK, but it is stale, so a
+        # renderer must be able to tell "OK" apart from "OK a while ago".
+        assert by_machine["spare-mini"]["severity"] == "ok"
+        assert by_machine["spare-mini"]["stale"] is True
+        assert all(
+            row["stale"] is False
+            for name, row in by_machine.items()
+            if name != "spare-mini"
+        )
+
+    def test_machine_health_absent_from_fixture_is_the_empty_block(self) -> None:
+        fx = parse_fixture({"board": {"assignments": []}})
+        body = _client(fx).get("/api/machines/health").json()
+        assert body["machine_health"] == []
+        assert body["schema"] == 1
+
+    def test_machine_stats_are_derived_from_the_seeded_board(self) -> None:
+        """#3025's endpoint needs no dedicated fixture key -- it reads the
+        seeded board + the ``Config`` the app was built with, same as live."""
+        r = _client().get("/api/machines/stats")
+        assert r.status_code == 200
+        by_name = {row["name"]: row for row in r.json()}
+        assert set(by_name) == {"precision", "dellserver"}
+        # precision has one running assignment (work-running) seeded above.
+        assert by_name["precision"]["capacity"]["active"] == 1
+        assert by_name["precision"]["counts"]["completed"] >= 1
+        assert by_name["dellserver"]["counts"]["failed"] == 1
+        assert any(
+            j["assignment_id"] == "work-failed"
+            for j in by_name["dellserver"]["job_history"]
+        )
+
+
 class TestReportEndpoints:
     """GET /api/report + GET /api/report/{report_id} in fixture mode (#2492 RPT-1).