code-coordinator 0.5.331__tar.gz → 0.5.332__tar.gz

{code_coordinator-0.5.331 → code_coordinator-0.5.332}/PKG-INFO

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.331
+Version: 0.5.332
 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.331 → code_coordinator-0.5.332}/code_coordinator.egg-info/SOURCES.txt

@@ -91,6 +91,7 @@ coord/interactive.py
 coord/issue_store.py
 coord/issues_sync_status.py
 coord/liveness_auditor.py
+coord/machine_metrics.py
 coord/machine_onboard.py
 coord/machine_pause.py
 coord/merge_queue.py
@@ -625,6 +626,7 @@ tests/test_issues_sync_status.py
 tests/test_liveness_auditor.py
 tests/test_liveness_notify.py
 tests/test_lock_contention_ratchet.py
+tests/test_machine_metrics.py
 tests/test_machine_onboard.py
 tests/test_machine_pause.py
 tests/test_merge_queue.py

{code_coordinator-0.5.331 → code_coordinator-0.5.332}/code_coordinator.egg-info/scm_file_list.json

@@ -181,6 +181,7 @@
     "coord/issue_store.py",
     "coord/issues_sync_status.py",
     "coord/liveness_auditor.py",
+    "coord/machine_metrics.py",
     "coord/machine_onboard.py",
     "coord/machine_pause.py",
     "coord/merge_queue.py",
@@ -651,6 +652,7 @@
     "tests/test_liveness_auditor.py",
     "tests/test_liveness_notify.py",
     "tests/test_lock_contention_ratchet.py",
+    "tests/test_machine_metrics.py",
     "tests/test_machine_onboard.py",
     "tests/test_machine_pause.py",
     "tests/test_merge_queue.py",

code_coordinator-0.5.332/code_coordinator.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "0.5.332",
+  "distance": 0,
+  "node": "g9eb084d2d068fc5fdf96e3a5de7f75bb41902679",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-09-01"
+}

code_coordinator-0.5.332/coord/machine_metrics.py

@@ -0,0 +1,217 @@
+"""Coordinator-side machine metrics sampler + bounded ring buffer (#3020).
+
+Part of milestone #71 (Fleet metrics + machines API) — the backend half of
+the coord-web Machines panel.
+
+``coord-tui`` renders CPU/mem sparklines by polling **each agent's own**
+``/metrics`` endpoint directly on port 7433 (``coord.agent_app.metrics``, a
+``psutil`` cpu/mem snapshot) and buffering samples in-process for as long as
+the panel stays open (see ``coord-tui/src/app/data.rs``
+``spawn_machine_metrics``). A browser can't do that — ``coord web`` is a
+single-origin HTTP client of the dashboard API, not something that can fan
+out to N agent hosts — and nothing anywhere persists a series; the TUI's
+``VecDeque`` dies with the panel.
+
+This module is the one missing thing: a coordinator-side sampler, owned by
+the board daemon (``coord serve``) and driven off its existing periodic-loop
+machinery (mirrors ``coord.health.fleet_snapshot.FleetHealthRefresher`` and
+``coord.gate_snapshot.GateSnapshotRefresher`` — see ``coord.serve_app``'s
+``_machine_metrics_loop``, isolated from ``_tick_loop`` for the identical
+reason those two are: a fan-out HTTP GET per agent must never block, or be
+blocked by, the reconcile/enqueue/drain steps).
+
+**Bounded, not incidental (#3020).** Each machine gets its own
+``collections.deque(maxlen=...)`` ring buffer sized for a ~6h window at the
+default ~15s cadence (:data:`DEFAULT_MAX_SAMPLES` = 1440) — old samples are
+evicted automatically as new ones arrive; the process can never accumulate
+unbounded history no matter how long the daemon stays up.
+
+**``unknown``, never a silent gap (#1485).** A failed, timed-out, or 503
+(psutil not installed) poll still appends a sample — with
+``status="unknown"`` — never nothing. A renderer building a sparkline from
+this series must be able to tell "no data point" (a gap it filled in itself)
+from "the daemon tried and the agent didn't answer" (an explicit unknown
+sample); silently skipping the append would collapse that distinction back
+into "looks the same as healthy", the exact failure mode
+``coord.health.fleet_snapshot`` already guards against for machine health.
+
+**No persistence.** This is purely in-memory; history is lost on daemon
+restart by design (a sqlite time-series was considered and deliberately
+rejected for this milestone — see the issue).
+
+**Out of scope here.** The read endpoint for this series (#A2) and putting
+it on ``/board`` (explicitly rejected — every TUI client polls ``/board`` on
+a short interval and ``FleetHealthSnapshot`` already carries a 256 KiB cap
+for exactly this reason) are not this module's job.
+"""
+
+from __future__ import annotations
+
+import logging
+import time
+from collections import deque
+from concurrent.futures import ThreadPoolExecutor
+from dataclasses import dataclass
+
+import httpx
+
+from coord.network import AGENT_PORT, DEFAULT_TIMEOUT, classify_error
+
+log = logging.getLogger("coord.serve")
+
+# ~6h of history at the default ~15s cadence. Explicit and enforced (each
+# per-machine buffer is a `deque(maxlen=...)`, not a list someone forgot to
+# trim) rather than incidental.
+DEFAULT_MAX_SAMPLES = 1440
+DEFAULT_CADENCE_SECONDS = 15.0
+
+STATUS_OK = "ok"
+STATUS_UNKNOWN = "unknown"
+
+
+@dataclass(frozen=True)
+class MetricsSample:
+    """One machine, one point in time. ``status="unknown"`` carries no
+    cpu/mem values — never fabricated zeros — only a human-readable
+    ``reason`` for why the poll didn't produce a real reading.
+    """
+
+    timestamp: float
+    status: str  # STATUS_OK | STATUS_UNKNOWN
+    cpu_percent: float | None = None
+    mem_percent: float | None = None
+    mem_used_mb: float | None = None
+    mem_total_mb: float | None = None
+    reason: str = ""
+
+    def to_dict(self) -> dict:
+        return {
+            "timestamp": self.timestamp,
+            "status": self.status,
+            "cpu_percent": self.cpu_percent,
+            "mem_percent": self.mem_percent,
+            "mem_used_mb": self.mem_used_mb,
+            "mem_total_mb": self.mem_total_mb,
+            "reason": self.reason,
+        }
+
+
+def _unknown(reason: str, *, now: float | None = None) -> MetricsSample:
+    return MetricsSample(
+        timestamp=now if now is not None else time.time(),
+        status=STATUS_UNKNOWN,
+        reason=reason,
+    )
+
+
+def fetch_metrics(machine, timeout: float = DEFAULT_TIMEOUT) -> MetricsSample:  # noqa: ANN001 — coord.models.Machine
+    """GET one machine's agent ``/metrics`` and classify the result.
+
+    Mirrors ``coord.network.check_machine``'s error classification but
+    targets ``/metrics`` instead of ``/health``. Never raises: every failure
+    mode — connect/read timeout, DNS failure, connection refused, a non-200
+    status (including the documented 503 an agent returns when ``psutil``
+    isn't installed), and malformed/missing-field JSON — becomes an explicit
+    :data:`STATUS_UNKNOWN` sample rather than an exception or a dropped
+    point. The bounded ``timeout`` (default :data:`coord.network.
+    DEFAULT_TIMEOUT`, 3s) is what keeps one hanging agent from stalling this
+    call past that ceiling; :class:`MachineMetricsSampler.refresh` is what
+    keeps that bounded stall from serializing behind every other machine.
+    """
+    url = f"http://{machine.host}:{AGENT_PORT}/metrics"
+    try:
+        resp = httpx.get(url, timeout=timeout)
+    except Exception as e:  # noqa: BLE001 — classify every network error, never raise
+        _, reason = classify_error(e)
+        return _unknown(reason)
+
+    if resp.status_code == 503:
+        # #207's documented shape: psutil not installed on that agent.
+        return _unknown("psutil not installed on agent")
+    if resp.status_code != 200:
+        return _unknown(f"HTTP {resp.status_code}")
+
+    try:
+        data = resp.json()
+    except ValueError:
+        return _unknown("invalid JSON from /metrics")
+
+    try:
+        return MetricsSample(
+            timestamp=time.time(),
+            status=STATUS_OK,
+            cpu_percent=float(data["cpu_percent"]),
+            mem_percent=float(data["mem_percent"]),
+            mem_used_mb=float(data["mem_used_mb"]),
+            mem_total_mb=float(data["mem_total_mb"]),
+        )
+    except (KeyError, TypeError, ValueError):
+        return _unknown("malformed /metrics payload")
+
+
+class MachineMetricsSampler:
+    """Owns the bounded per-machine ring buffers; refreshed by the daemon tick.
+
+    ``series()``/``all_series()`` are the read path — bare in-memory reads,
+    no I/O, safe to call from a request handler. ``refresh(config)`` is the
+    only method that talks to agents and must only ever run from the
+    daemon's tick machinery (or a test driving it explicitly), exactly the
+    same split as ``coord.health.fleet_snapshot.FleetHealthRefresher``.
+    """
+
+    def __init__(
+        self,
+        *,
+        max_samples: int = DEFAULT_MAX_SAMPLES,
+        timeout: float = DEFAULT_TIMEOUT,
+    ) -> None:
+        if max_samples <= 0:
+            raise ValueError("max_samples must be positive")
+        self._max_samples = max_samples
+        self._timeout = timeout
+        self._buffers: dict[str, deque] = {}
+
+    def series(self, machine_name: str) -> list[dict]:
+        """This machine's samples, oldest first. ``[]`` if never polled."""
+        buf = self._buffers.get(machine_name)
+        return [s.to_dict() for s in buf] if buf else []
+
+    def all_series(self) -> dict[str, list[dict]]:
+        """Every known machine's series, oldest-first, keyed by name."""
+        return {name: [s.to_dict() for s in buf] for name, buf in self._buffers.items()}
+
+    def refresh(self, config) -> None:  # noqa: ANN001 — coord.config.Config
+        """Poll every machine in ``config.machines`` once and append a sample
+        each — :data:`STATUS_OK` or :data:`STATUS_UNKNOWN`, never neither.
+
+        Polls concurrently (mirrors ``coord.network.check_all``): each call
+        is individually bounded by ``timeout``, and running them in a thread
+        pool rather than sequentially means one slow/hanging agent's bounded
+        stall does not serialize in front of the rest of the fleet's polls —
+        the whole ``refresh()`` call takes roughly one ``timeout``, not
+        ``len(machines) * timeout``, no matter which machine is the slow
+        one. Called off the event loop (``run_in_threadpool`` from
+        ``coord.serve_app``'s own loop, isolated from ``_tick_loop``) so
+        even that bound never touches board-read latency.
+        """
+        machines = list(getattr(config, "machines", ()) or ())
+        if not machines:
+            return
+
+        workers = min(8, len(machines))
+        with ThreadPoolExecutor(max_workers=workers) as pool:
+            samples = list(pool.map(self._poll_one, machines))
+
+        for machine, sample in zip(machines, samples):
+            buf = self._buffers.get(machine.name)
+            if buf is None:
+                buf = deque(maxlen=self._max_samples)
+                self._buffers[machine.name] = buf
+            buf.append(sample)
+
+    def _poll_one(self, machine) -> MetricsSample:  # noqa: ANN001
+        try:
+            return fetch_metrics(machine, timeout=self._timeout)
+        except Exception as exc:  # noqa: BLE001 — one bad machine must never abort the refresh
+            log.warning("machine-metrics poll: %s raised %s", machine.name, exc)
+            return _unknown(f"poll raised: {exc}")

{code_coordinator-0.5.331 → code_coordinator-0.5.332}/coord/serve_app.py

@@ -5340,6 +5340,15 @@ def build_app(store: CoordStore, config: Config, *, token: str | None = None) ->
 
     _fleet_health_refresher = FleetHealthRefresher()
 
+    # #3020: same shape again — polling every agent's own /metrics is real
+    # per-machine I/O, so it runs on the tick loop's cadence
+    # (`_machine_metrics_loop` below), never inline off a request handler.
+    # Series live only in this sampler's bounded in-memory ring buffers; no
+    # read endpoint exists yet (that's #A2) and nothing here touches /board.
+    from coord.machine_metrics import MachineMetricsSampler  # noqa: PLC0415
+
+    _machine_metrics_sampler = MachineMetricsSampler()
+
     # Short-TTL cache for the computed /board projection so burst polls from the
     # TUI don't each pay the full board_projection + merge-plan + stage-projection
     # recomputation (~465-issue load measured in the issue). Keyed to nothing
@@ -9452,6 +9461,26 @@ def build_app(store: CoordStore, config: Config, *, token: str | None = None) ->
                 except Exception:  # noqa: BLE001 — keep serving the old snapshot
                     log.warning("fleet-health refresh failed", exc_info=True)
 
+        # #3020: CPU/mem sampler for the coord-web Machines panel — default
+        # 15s (env COORD_METRICS_POLL_INTERVAL; 0 disables). Own loop, not a
+        # `_tick_loop` step, for the identical reason as `_health_refresh_loop`
+        # just above: it fans out one HTTP GET per agent and must never be
+        # held up behind, or hold up, the reconcile/enqueue/drain steps.
+        try:
+            metrics_poll_interval = float(
+                os.environ.get("COORD_METRICS_POLL_INTERVAL", "15")
+            )
+        except ValueError:
+            metrics_poll_interval = 15.0
+
+        async def _machine_metrics_loop() -> None:
+            while True:
+                await asyncio.sleep(metrics_poll_interval)
+                try:
+                    await run_in_threadpool(_machine_metrics_sampler.refresh, config)
+                except Exception:  # noqa: BLE001 — a tick must never crash the daemon
+                    log.warning("machine-metrics refresh failed", exc_info=True)
+
         # #2570: the #2536 phantom-row auto-heal, run a SECOND time from
         # inside this long-lived process rather than relying solely on
         # `coord-notify.timer`'s oneshot `~/.coord-venv/bin/coord notify`
@@ -10218,12 +10247,18 @@ def build_app(store: CoordStore, config: Config, *, token: str | None = None) ->
                 else None,
                 "auto-revalidate",
             )
+            machine_metrics_task = _watch(
+                asyncio.create_task(_machine_metrics_loop())
+                if interval > 0 and metrics_poll_interval > 0
+                else None,
+                "machine-metrics",
+            )
             try:
                 yield
             finally:
                 for t in (
                     task, gate_task, health_task, phantom_heal_task,
-                    auto_revalidate_task,
+                    auto_revalidate_task, machine_metrics_task,
                 ):
                     if t is not None:
                         t.cancel()

{code_coordinator-0.5.331 → code_coordinator-0.5.332}/docs/ADR_PY_RUST_MIRRORS.md

@@ -97,6 +97,7 @@ they drift, the symbol names do not — grep the symbol if the line has moved.
 | `coord/commands/terminal.py:5` | `src/app/terminal.rs` | The embedded-terminal session contract. |
 | `coord/commands/_common.py:308` | `src/app/pipeline.rs` | Which acceptance subcommand the TUI's Pipeline dispatch fires. |
 | `coord/health/checks/deploy_lane_facts.py:115` | `src/app/data.rs` | Not a logic mirror: the *structural marker path* `resolve_coord_tui_checkout` uses to recognise a coord-tui checkout, and the pre-#2899 spelling it must NOT match. Listed because it is a hard-coded coord-tui path and would break on a layout change there. |
+| `coord/machine_metrics.py:9` | `src/app/data.rs::spawn_machine_metrics` | The per-agent `GET :7433/metrics` polling contract (`coord.agent_app.metrics`: a `psutil` cpu/mem snapshot, `503` when psutil is absent). Two *independent* samplers now read that one endpoint — coord-tui's in-process `VecDeque`, live only while its panel is open, and the daemon-side ring buffer added by #3020. Not a logic mirror and not a divergence risk in itself: both sides consume the same wire, which is the endpoint's own contract, not a re-derived rule. Listed because it is a hard-coded reference to a coord-tui source symbol, and because a future change to the `/metrics` payload has to be made aware of *both* readers. |
 
 ## Consequences
 

code_coordinator-0.5.332/tests/test_machine_metrics.py

@@ -0,0 +1,229 @@
+"""#3020: the coordinator-side machine-metrics sampler + bounded ring buffer.
+
+Covers the three acceptance bullets from the issue:
+1. bound enforcement — the per-machine ring buffer never grows unbounded;
+   oldest samples are evicted as new ones arrive.
+2. `unknown`, never a silent gap — a failed / timed-out / 503 poll still
+   appends an explicit unknown sample (#1485: absence must never render as
+   healthy).
+3. a hanging agent cannot stall the sampler for other machines — polls run
+   concurrently, each individually bounded by its own timeout.
+
+No live fleet contact: every test monkeypatches ``httpx.get`` (or the
+sampler's own per-machine poll) rather than reaching a real agent.
+"""
+
+from __future__ import annotations
+
+import time
+
+import httpx
+import pytest
+
+from coord import machine_metrics as mm
+from coord.config import Config
+from coord.machine_metrics import (
+    STATUS_OK,
+    STATUS_UNKNOWN,
+    MachineMetricsSampler,
+    MetricsSample,
+    fetch_metrics,
+)
+from coord.models import Machine
+
+
+def _machine(name: str, host: str = "x.tailnet") -> Machine:
+    return Machine(name=name, host=host, capabilities=["python"], repos=["api"],
+                    repo_paths={"api": f"/repos/{name}/api"})
+
+
+class _FakeResponse:
+    def __init__(self, status_code: int, payload: dict | None = None, *, bad_json: bool = False):
+        self.status_code = status_code
+        self._payload = payload
+        self._bad_json = bad_json
+
+    def json(self):
+        if self._bad_json:
+            raise ValueError("not json")
+        return self._payload
+
+
+# ── 1. bound enforcement ────────────────────────────────────────────────────
+
+
+def test_ring_buffer_evicts_oldest_and_never_grows_unbounded(monkeypatch) -> None:
+    cfg = Config(repos=[], machines=[_machine("laptop")])
+    sampler = MachineMetricsSampler(max_samples=3)
+
+    seen_cpu: list[float] = []
+
+    def fake_poll_one(self, machine):  # noqa: ANN001, ARG001
+        val = len(seen_cpu)
+        seen_cpu.append(val)
+        return MetricsSample(timestamp=time.time(), status=STATUS_OK, cpu_percent=float(val))
+
+    monkeypatch.setattr(MachineMetricsSampler, "_poll_one", fake_poll_one)
+
+    for _ in range(10):
+        sampler.refresh(cfg)
+
+    series = sampler.series("laptop")
+    # Bound is explicit and enforced — never more than max_samples, no matter
+    # how many refreshes ran.
+    assert len(series) == 3
+    # Oldest evicted: the buffer holds only the LAST 3 cpu values appended
+    # (7, 8, 9), not the first ones (0, 1, 2).
+    assert [s["cpu_percent"] for s in series] == [7.0, 8.0, 9.0]
+
+
+def test_unknown_machine_series_is_empty_not_an_error() -> None:
+    sampler = MachineMetricsSampler()
+    assert sampler.series("never-polled") == []
+    assert sampler.all_series() == {}
+
+
+# ── 2. `unknown`, never a silent gap (#1485) ────────────────────────────────
+
+
+def test_fetch_metrics_ok_populates_all_fields(monkeypatch) -> None:
+    payload = {
+        "cpu_percent": 12.5,
+        "mem_percent": 40.0,
+        "mem_used_mb": 1024.0,
+        "mem_total_mb": 2048.0,
+        "timestamp": time.time(),
+    }
+    monkeypatch.setattr(httpx, "get", lambda url, timeout=3.0: _FakeResponse(200, payload))
+
+    sample = fetch_metrics(_machine("laptop"))
+    assert sample.status == STATUS_OK
+    assert sample.cpu_percent == 12.5
+    assert sample.mem_percent == 40.0
+    assert sample.mem_used_mb == 1024.0
+    assert sample.mem_total_mb == 2048.0
+
+
+def test_fetch_metrics_503_psutil_missing_is_explicit_unknown(monkeypatch) -> None:
+    monkeypatch.setattr(httpx, "get", lambda url, timeout=3.0: _FakeResponse(503))
+
+    sample = fetch_metrics(_machine("laptop"))
+    assert sample.status == STATUS_UNKNOWN
+    assert "psutil" in sample.reason
+    assert sample.cpu_percent is None
+
+
+def test_fetch_metrics_timeout_is_explicit_unknown(monkeypatch) -> None:
+    def raise_timeout(url, timeout=3.0):
+        raise httpx.ReadTimeout("timed out", request=None)
+
+    monkeypatch.setattr(httpx, "get", raise_timeout)
+
+    sample = fetch_metrics(_machine("laptop"))
+    assert sample.status == STATUS_UNKNOWN
+    assert sample.cpu_percent is None
+
+
+def test_fetch_metrics_connection_error_is_explicit_unknown(monkeypatch) -> None:
+    def raise_connect_error(url, timeout=3.0):
+        raise httpx.ConnectError("connection refused")
+
+    monkeypatch.setattr(httpx, "get", raise_connect_error)
+
+    sample = fetch_metrics(_machine("laptop"))
+    assert sample.status == STATUS_UNKNOWN
+
+
+def test_fetch_metrics_malformed_payload_is_explicit_unknown(monkeypatch) -> None:
+    monkeypatch.setattr(
+        httpx, "get", lambda url, timeout=3.0: _FakeResponse(200, {"cpu_percent": "not-a-number"})
+    )
+
+    sample = fetch_metrics(_machine("laptop"))
+    assert sample.status == STATUS_UNKNOWN
+
+
+def test_fetch_metrics_bad_json_is_explicit_unknown(monkeypatch) -> None:
+    monkeypatch.setattr(httpx, "get", lambda url, timeout=3.0: _FakeResponse(200, bad_json=True))
+
+    sample = fetch_metrics(_machine("laptop"))
+    assert sample.status == STATUS_UNKNOWN
+
+
+def test_refresh_appends_unknown_sample_for_failed_machine_never_a_gap(monkeypatch) -> None:
+    cfg = Config(repos=[], machines=[_machine("dead")])
+    sampler = MachineMetricsSampler()
+
+    monkeypatch.setattr(httpx, "get", lambda url, timeout=3.0: (_ for _ in ()).throw(
+        httpx.ConnectError("refused")
+    ))
+
+    sampler.refresh(cfg)
+
+    series = sampler.series("dead")
+    assert len(series) == 1
+    assert series[0]["status"] == STATUS_UNKNOWN
+
+
+def test_poll_one_swallows_unexpected_exception_as_unknown(monkeypatch) -> None:
+    """Even a bug in fetch_metrics itself must not abort the whole refresh —
+    it degrades to an unknown sample for that one machine (mirrors
+    FleetHealthRefresher's "one bad machine must not abort the tick")."""
+    cfg = Config(repos=[], machines=[_machine("buggy"), _machine("fine")])
+    sampler = MachineMetricsSampler()
+
+    def fake_fetch(machine, timeout=3.0):
+        if machine.name == "buggy":
+            raise RuntimeError("boom")
+        return MetricsSample(timestamp=time.time(), status=STATUS_OK, cpu_percent=1.0)
+
+    monkeypatch.setattr(mm, "fetch_metrics", fake_fetch)
+
+    sampler.refresh(cfg)
+
+    assert sampler.series("buggy")[0]["status"] == STATUS_UNKNOWN
+    assert sampler.series("fine")[0]["status"] == STATUS_OK
+
+
+# ── 3. a hanging agent cannot stall the sampler for other machines ─────────
+
+
+def test_hanging_machine_does_not_serialize_behind_other_polls(monkeypatch) -> None:
+    cfg = Config(
+        repos=[],
+        machines=[_machine("slow-a"), _machine("slow-b"), _machine("fast")],
+    )
+    sampler = MachineMetricsSampler()
+    delay = 0.3
+
+    def fake_poll_one(self, machine):  # noqa: ANN001, ARG001
+        if machine.name.startswith("slow"):
+            time.sleep(delay)
+        return MetricsSample(timestamp=time.time(), status=STATUS_OK, cpu_percent=1.0)
+
+    monkeypatch.setattr(MachineMetricsSampler, "_poll_one", fake_poll_one)
+
+    start = time.monotonic()
+    sampler.refresh(cfg)
+    elapsed = time.monotonic() - start
+
+    # Two "slow" machines each sleep `delay`. If polls ran sequentially the
+    # refresh would take >= 2 * delay; concurrently it takes ~1 * delay.
+    assert elapsed < delay * 1.8, (
+        f"refresh() took {elapsed:.2f}s — polls appear to be serializing "
+        f"instead of running concurrently"
+    )
+    for name in ("slow-a", "slow-b", "fast"):
+        assert sampler.series(name)[0]["status"] == STATUS_OK
+
+
+def test_refresh_with_no_machines_is_a_noop() -> None:
+    cfg = Config(repos=[], machines=[])
+    sampler = MachineMetricsSampler()
+    sampler.refresh(cfg)  # must not raise
+    assert sampler.all_series() == {}
+
+
+def test_max_samples_must_be_positive() -> None:
+    with pytest.raises(ValueError):
+        MachineMetricsSampler(max_samples=0)

code_coordinator-0.5.331/code_coordinator.egg-info/scm_version.json

@@ -1,8 +0,0 @@
-{
-  "tag": "0.5.331",
-  "distance": 0,
-  "node": "g73f327b8112ca3cfc50ce512371659afb1a4c411",
-  "dirty": false,
-  "branch": "HEAD",
-  "node_date": "2026-08-31"
-}