code-coordinator 0.5.451__tar.gz → 0.5.453__tar.gz

{code_coordinator-0.5.451 → code_coordinator-0.5.453}/PKG-INFO

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

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

@@ -539,6 +539,7 @@ tests/test_cli_test_plan.py
 tests/test_cli_track.py
 tests/test_cli_tui_update.py
 tests/test_cli_wait.py
+tests/test_client.py
 tests/test_client_base_install.py
 tests/test_client_config_cache_atomic_3052.py
 tests/test_client_resource_migration_1946.py
@@ -570,6 +571,7 @@ tests/test_dao.py
 tests/test_dashboard.py
 tests/test_dashboard_api.py
 tests/test_dashboard_fixture.py
+tests/test_dashboard_server.py
 tests/test_dashboard_terminal.py
 tests/test_dashboard_terminal_live.py
 tests/test_db.py

{code_coordinator-0.5.451 → code_coordinator-0.5.453}/code_coordinator.egg-info/scm_file_list.json

@@ -565,6 +565,7 @@
     "tests/test_cli_track.py",
     "tests/test_cli_tui_update.py",
     "tests/test_cli_wait.py",
+    "tests/test_client.py",
     "tests/test_client_base_install.py",
     "tests/test_client_config_cache_atomic_3052.py",
     "tests/test_client_resource_migration_1946.py",
@@ -596,6 +597,7 @@
     "tests/test_dashboard.py",
     "tests/test_dashboard_api.py",
     "tests/test_dashboard_fixture.py",
+    "tests/test_dashboard_server.py",
     "tests/test_dashboard_terminal.py",
     "tests/test_dashboard_terminal_live.py",
     "tests/test_db.py",

{code_coordinator-0.5.451 → code_coordinator-0.5.453}/code_coordinator.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.451",
+  "tag": "0.5.453",
   "distance": 0,
-  "node": "g75985b1122962fa0ccd6b97ab453eabdc7a1b5e9",
+  "node": "gf9162e8b92018087ab923c640b8eb07b232cf9bd",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-09-11"

{code_coordinator-0.5.451 → code_coordinator-0.5.453}/coord/client.py

@@ -88,11 +88,62 @@ def _headers(svc: ServiceConfig) -> dict[str, str]:
     return headers
 
 
+# #3295: per-service-URL ETag cache for `GET /board`, so a thin client that
+# calls `fetch_board_payload()` repeatedly in a short window (dashboard
+# panels each doing their own read, drive-queue polling, ...) gets a
+# bodyless 304 back and reuses the last body instead of re-shipping and
+# re-parsing the full board (measured at 3.5MB) on every call. The daemon
+# has served `ETag` / honoured `If-None-Match` on `GET /board` since #1336;
+# nothing on the server changes here, only this client now uses it.
+# Process-local and never persisted — like `board_service._RESOURCE_ROUTE_SUPPORT`
+# — so a fresh process (or a test) starts with an empty cache and the very
+# next call is an unconditional GET.
+_board_payload_cache: dict[str, tuple[str, dict]] = {}
+
+
+def reset_board_payload_cache() -> None:
+    """Forget every cached ``(etag, body)`` pair (tests; #3295)."""
+    _board_payload_cache.clear()
+
+
 def fetch_board_payload(svc: ServiceConfig, *, timeout: float = _DEFAULT_TIMEOUT) -> dict:
-    """GET /board → the raw projection dict (also carries machines/merge_queue/…)."""
-    resp = httpx.get(f"{svc.url}/board", headers=_headers(svc), timeout=timeout)
+    """GET /board → the raw projection dict (also carries machines/merge_queue/…).
+
+    #3295: sends ``If-None-Match`` with the ETag from this *svc.url*'s last
+    successful fetch, if any. A ``304`` means the daemon is telling us the
+    board hasn't changed since that ETag was minted — the cached body from
+    that fetch is still exactly correct, so it's returned as-is with no
+    re-parse. A ``200`` (first call for this URL, or the board really did
+    change) refreshes the cache with the new ``ETag``/body pair; a response
+    carrying no ``ETag`` at all clears any stale entry rather than caching
+    something we can't validate next time.
+    """
+    headers = _headers(svc)
+    cached = _board_payload_cache.get(svc.url)
+    if cached is not None:
+        headers["If-None-Match"] = cached[0]
+    resp = httpx.get(f"{svc.url}/board", headers=headers, timeout=timeout)
+    if resp.status_code == 304:
+        if cached is not None:
+            return cached[1]
+        # Should never happen — we only ever send `If-None-Match` when
+        # *cached* is set, so a 304 here means the daemon answered a
+        # conditional response to an unconditional request. Surfacing this
+        # loudly beats silently returning `None`/an empty board that looks
+        # like a real (if suspiciously quiet) fleet.
+        raise RuntimeError(
+            f"GET {svc.url}/board answered 304 but this client sent no "
+            "If-None-Match (no cached ETag for this service) — refusing to "
+            "guess at a board"
+        )
     resp.raise_for_status()
-    return resp.json()
+    body = resp.json()
+    etag = resp.headers.get("ETag")
+    if etag:
+        _board_payload_cache[svc.url] = (etag, body)
+    else:
+        _board_payload_cache.pop(svc.url, None)
+    return body
 
 
 def fetch_healthz(svc: ServiceConfig, *, timeout: float = _DEFAULT_TIMEOUT) -> dict:

{code_coordinator-0.5.451 → code_coordinator-0.5.453}/coord/dao.py

@@ -78,6 +78,7 @@ from __future__ import annotations
 import json
 import os
 import sqlite3
+import threading
 import time
 from contextlib import closing
 from pathlib import Path
@@ -186,6 +187,9 @@ class CoordStore(Protocol):
     def get_assignment(self, assignment_id: str) -> dict | None: ...
     def get_issue(self, repo_name: str, number: int) -> dict | None: ...
 
+    # ── change detection (#3294) ────────────────────────────────────────────
+    def change_token(self) -> str: ...
+
 
 def compute_board_keep_ids(
     assignment_index: list[dict],
@@ -305,10 +309,28 @@ class SqliteStore:
     pooling under real load) and never migrates the DB. ``board_projection``
     opens a single connection so the whole payload is one consistent
     snapshot.
+
+    ``change_token()`` (#3294) is the one exception to "fresh connection per
+    call": ``PRAGMA data_version`` is relative to the connection that reads
+    it — a brand-new SQLite connection always reports the same baseline
+    value no matter how many *other* connections have committed writes
+    before it opened, and only starts advancing once IT has observed a
+    change. So the cheap "did anything write?" signal only works against a
+    connection this store keeps open across calls; see ``_change_conn``
+    below and ``change_token``'s docstring.
     """
 
     def __init__(self, db_path: Path | str | None = None) -> None:
         self._path = Path(db_path) if db_path is not None else DB_PATH
+        # #3294: lazily-opened, kept-open connection dedicated to
+        # `change_token()` — see the class docstring for why this one
+        # connection is the exception to "fresh connection per call".
+        # Guarded by `_change_lock` because it is shared between the event
+        # loop thread (the /board handler's initial freshness check) and a
+        # threadpool worker (the same handler's rebuild leader) — see
+        # coord.serve_app's board().
+        self._change_conn: Any = None
+        self._change_lock = threading.Lock()
 
     # ── connection ────────────────────────────────────────────────────────────
     def _connect(self) -> Any:
@@ -576,3 +598,77 @@ class SqliteStore:
                 # retention cap; `after_json` arrives decoded as a real list.
                 "drive_queue": self._table(conn, "drive_queue", order="position"),
             }
+
+    # ── change detection (#3294) ────────────────────────────────────────────
+    def _open_change_conn(self) -> Any:
+        conn = sql.connect(
+            backend=sql.DIALECT_SQLITE,
+            sqlite_path=self._path,
+            read_only=True,
+            check_same_thread=False,
+        )
+        sql.apply_row_factory(conn)
+        sql.apply_connection_setup(conn, read_only=True)
+        return conn
+
+    def change_token(self) -> str:
+        """A cheap, opaque "has anything been written since I last asked?" token.
+
+        Backs the ``/board`` read path's cache invalidation in
+        ``coord.serve_app`` (the board() handler's cache block): a 1.5 s TTL
+        forced a full board rebuild on essentially every poll even when
+        nothing had changed, because pollers run at 5 s and always missed the
+        window. This token replaces "younger than N seconds" with "no write
+        since this build" as the PRIMARY trigger -- the TTL survives only as
+        a safety upper bound (see serve_app.py) in case this token's source
+        ever misses a write path.
+
+        SQLite: :func:`coord.sql.sqlite_data_version` (``PRAGMA
+        data_version``, spelled in the dialect seam rather than here --
+        ``PRAGMA`` is SQLite-only statement text and ``coord/sql.py`` is the
+        one module allowed to name one, #2782/#1948), which changes whenever
+        ANY connection -- not just this process's own POSTs, but the
+        drive-queue timer and a concurrent ``coord notify`` writing locally
+        too -- commits to the database file. **Unlike every other read in
+        this class, this is NOT a fresh connection per call**: ``data_version``
+        is relative to the connection that reads it, and a brand-new
+        connection always reports the same baseline value regardless of how
+        many other connections committed before it opened -- it only starts
+        advancing once it has personally observed a change. So this method
+        reuses one connection (``_change_conn``, opened lazily, guarded by
+        ``_change_lock`` since it's shared between the event loop thread and
+        a threadpool worker -- see ``coord.serve_app.board()``) across every
+        call for the life of this ``SqliteStore``. See
+        https://sqlite.org/pragma.html#pragma_data_version. A failure (e.g.
+        the connection went stale) reopens once and, failing that, propagates
+        -- callers must treat any exception here as "assume changed, rebuild"
+        rather than crash the read path over a cache optimization.
+
+        Postgres (#827's in-flight lane): TODO(#3294-pg) -- ``data_version``
+        has no Postgres equivalent. A ``board_revision`` sequence bumped at
+        each write choke point (the ``_*_local()`` family in
+        ``coord/state.py``) or a ``LISTEN``/``NOTIFY`` channel are the two
+        candidates the issue names; until one lands, this returns a constant
+        so two calls always compare equal and the cache degrades to
+        "TTL-only" -- exactly today's (pre-#3294) behaviour -- rather than
+        silently caching forever or rebuilding on every request.
+        """
+        target = db_mod._resolve_store_target()
+        if target.backend == sql.DIALECT_POSTGRES:
+            return "pg-change-token-unimplemented"  # TODO(#3294-pg)
+        with self._change_lock:
+            if self._change_conn is None:
+                self._change_conn = self._open_change_conn()
+            try:
+                return sql.sqlite_data_version(self._change_conn)
+            except Exception:  # noqa: BLE001 — reopen-once fallback, see below
+                # Stale/broken connection (e.g. the underlying file was
+                # replaced out from under us) — reopen once. A repeat
+                # failure propagates to the caller, which treats it as
+                # "assume changed" rather than serving a false cache hit.
+                try:
+                    self._change_conn.close()
+                except Exception:  # noqa: BLE001 — already broken, best effort
+                    pass
+                self._change_conn = self._open_change_conn()
+                return sql.sqlite_data_version(self._change_conn)

{code_coordinator-0.5.451 → code_coordinator-0.5.453}/coord/dashboard/server.py

@@ -2378,22 +2378,90 @@ def build_app(
         # would take those down to protest a missing frontend.
         logger.warning("coord web: %s", webapp_bundle_missing_message(webapp_dist))
 
+    # #3295: per-process board memo. Before this, EVERY `/api/*` request on
+    # the daemon host (no `board_service` configured — the deployment
+    # actually in use) fell through to `read_board()`: open sqlite, run the
+    # query, walk every row through `assemble_board()`. A single screen load
+    # (a few panels each polling their own endpoint) or one background
+    # `_background_poller()` tick fanned that out into 2-5 independent
+    # builds of the SAME board. In thin-client mode (`board_service`
+    # configured) the equivalent waste was `_read_board_and_machine_health()`
+    # and `_read_fleet_health()` each firing their OWN `fetch_board_payload()`
+    # round trip for the same daemon snapshot.
+    #
+    # `_board_memo` is local to this `build_app()` closure — like
+    # `_seen_terminal`/`_orphaned_since` below — never a module global, so
+    # each dashboard process (and each test's own `build_app()`) gets an
+    # independent memo that can never bleed into another's.
+    _BOARD_MEMO_TTL_S = 2.0
+    _board_memo: dict[str, Any] = {"at": 0.0, "board": None, "payload": None}
+
+    def _fetch_board_and_payload():  # -> tuple[Board, dict | None]
+        """Uncached ``(board, payload)`` build — what the memo below wraps.
+
+        ``payload`` is the raw ``/board`` projection dict when this process
+        is a thin client (``board_service`` configured) — it carries sibling
+        keys (``fleet_health``, ...) a bare :class:`Board` does not — and
+        ``None`` when reading the local DB/daemon-host path directly, since
+        there is no daemon payload to share in that 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)
+            return board_from_payload(payload), payload
+        return read_board(), None
+
+    def _memoized_board_and_payload():  # -> tuple[Board, dict | None]
+        """``(board, payload)``, rebuilt at most once per ``_BOARD_MEMO_TTL_S``.
+
+        The ONE read every board-shaped handler below goes through —
+        ``_read_board()``, ``_read_board_and_machine_health()`` and
+        ``_read_fleet_health()`` all call this rather than each doing their
+        own ``read_board()``/``fetch_board_payload()`` (#3295: "one question,
+        one answer" applies to *how the data is obtained*, not just what it
+        says). A short TTL rather than invalidate-on-write: long enough to
+        collapse a burst of requests (one screen load, one SSE tick) into a
+        single build, short enough that no panel is ever more than ~2s
+        behind the DB/daemon.
+        """
+        now = time.monotonic()
+        if _board_memo["board"] is not None and (now - _board_memo["at"]) < _BOARD_MEMO_TTL_S:
+            return _board_memo["board"], _board_memo["payload"]
+        board, payload = _fetch_board_and_payload()
+        _board_memo.update(at=now, board=board, payload=payload)
+        return board, payload
+
     def _read_board():
-        """The board for this request — seeded fixture or the live DB/daemon.
+        """The board for this request — seeded fixture or the memoized live DB/daemon.
 
         Fixture mode rebuilds the Board from the raw payload on every call, so
         a handler that mutates what it is handed (``unstick`` →
-        ``mark_failed_by_id``) can't leak that into the next request.
+        ``mark_failed_by_id``) can't leak that into the next request. Live
+        mode goes through :func:`_memoized_board_and_payload` (#3295).
         """
         if _fixture is not None:
             return _fixture.board()
-        return read_board()
+        board, _payload = _memoized_board_and_payload()
+        return board
 
     def _write_board(board) -> None:  # noqa: ANN001
-        """Persist *board* — a no-op in fixture mode (writes never execute)."""
+        """Persist *board* — a no-op in fixture mode (writes never execute).
+
+        Invalidates the #3295 board memo rather than repopulating it with
+        *board*: in thin-client mode the write only carries the mutated
+        `Board`, not a fresh daemon payload (`fleet_health` et al.), so
+        keeping a stale/partial cache entry around risks a subsequent
+        `_read_fleet_health()`/`_read_board_and_machine_health()` call
+        serving an empty block instead of paying for one more real read.
+        """
         if _fixture is not None:
             return
         write_board(board)
+        _board_memo.update(at=0.0, board=None, payload=None)
 
     def _read_board_and_machine_health() -> tuple:  # -> tuple[Board, dict[str, dict]]
         """The board plus every configured machine's latest daemon-tick-
@@ -2423,16 +2491,19 @@ def build_app(
         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).
+
+        #3295: the thin-client branch now reads through
+        :func:`_memoized_board_and_payload` instead of calling
+        ``fetch_board_payload`` itself — sharing the SAME daemon round trip
+        ``_read_fleet_health()`` (and ``_read_board()``) make within the
+        memo window, rather than each paying for its own.
         """
         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 []
+            board, payload = _memoized_board_and_payload()
+            rows = ((payload or {}).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
@@ -2494,15 +2565,19 @@ def build_app(
         ``coord status``. Per-machine severities still come from the same
         row-assembly the thin-client path rides (``machine_health_rows``), so
         the two modes can't drift on that half.
+
+        #3295: the thin-client branch reads through
+        :func:`_memoized_board_and_payload` — the same memo
+        ``_read_board_and_machine_health()`` reads through — instead of
+        issuing its own ``fetch_board_payload`` call, so the two no longer
+        double the daemon I/O a single request burst costs.
         """
         from coord import board_service  # noqa: PLC0415
 
         svc = board_service.resolve()
         if svc is not None:
-            from coord.client import fetch_board_payload  # noqa: PLC0415
-
-            payload = fetch_board_payload(svc)
-            return payload.get("fleet_health") or dict(_EMPTY_FLEET_HEALTH_BLOCK)
+            _board, payload = _memoized_board_and_payload()
+            return (payload or {}).get("fleet_health") or dict(_EMPTY_FLEET_HEALTH_BLOCK)
 
         from coord.health.aggregate import local_fleet_health_block  # noqa: PLC0415
 
@@ -2746,12 +2821,21 @@ def build_app(
     _sessions_offline_since: dict[str, float] = {}
 
     async def _background_poller() -> None:
-        """Runs forever; polls agents every _POLL_INTERVAL seconds."""
+        """Runs forever; polls agents every _POLL_INTERVAL seconds.
+
+        #3295: passes its own board read through the shared
+        ``_read_board()``/memo rather than letting ``_poll_once`` fall back
+        to its own bare ``read_board()`` — a tick landing inside a client's
+        own ``/api/board`` poll window reuses that build instead of paying
+        for a second one, and the tick's own build is then what the very
+        next client poll reuses.
+        """
         await asyncio.sleep(10)  # Short initial delay so the server is ready
         while True:
             try:
                 possibly_stuck = await _poll_once(
                     config, event_source, _seen_terminal, _orphaned_since,
+                    board=_read_board(),
                     needs_attention_seen=_needs_attention_seen,
                 )
                 event_source.publish(BOARD_UPDATED, {

{code_coordinator-0.5.451 → code_coordinator-0.5.453}/coord/health/checks/fleet_board.py

@@ -7,6 +7,16 @@ Like the other fleet checks in this package, the daemon's ``/board`` handler
 (``coord.serve_app``) is the thing that actually measures its own latency and
 serialized body size on each rebuild; this probe only judges the numbers it's
 handed.
+
+#3294 added a third, advisory-only number: how many rebuilds actually
+*published* in the last 60s (``board_builds_per_minute`` on ``daemon_host``,
+tracked by ``FleetHealthRefresher.record_board_stats``). The ``/board`` cache
+used to rebuild on a fixed 1.5s TTL regardless of whether anything had
+written — pollers run at 5s, so that meant a rebuild on nearly every poll.
+The cache's primary trigger is now "a write happened" (``dao.CoordStore.
+change_token``); this field is what makes that claim measurable rather than
+assumed. Never affects severity — a burst of real writes legitimately drives
+it up.
 """
 
 from __future__ import annotations
@@ -41,6 +51,13 @@ def probe_board_latency(ctx: HealthContext) -> CheckResult:
     dh = ctx.fleet.daemon_host or {}
     latency_ms = dh.get("board_latency_ms")
     payload_bytes = dh.get("board_payload_bytes")
+    # #3294: how many /board REBUILDS (not requests) published in the last
+    # 60s — the direct measurement of whether the write-triggered cache
+    # (dao.CoordStore.change_token, replacing the old 1.5s TTL) is actually
+    # cutting rebuilds, rather than an assumption. Advisory only: absent on
+    # an older daemon that hasn't published a build yet, and never affects
+    # severity below — a burst of real writes legitimately drives this up.
+    builds_per_minute = dh.get("board_builds_per_minute")
 
     if latency_ms is None and payload_bytes is None:
         return CheckResult(
@@ -72,6 +89,8 @@ def probe_board_latency(ctx: HealthContext) -> CheckResult:
         parts.append(f"{latency_ms:.0f}ms")
     if payload_bytes is not None:
         parts.append(human_bytes(payload_bytes))
+    if builds_per_minute is not None:
+        parts.append(f"{builds_per_minute} build/min")
     headroom = " / ".join(parts) if parts else "no data"
     if severity is not Severity.OK:
         headroom += f" ({', '.join(reasons)})"
@@ -85,5 +104,9 @@ def probe_board_latency(ctx: HealthContext) -> CheckResult:
             f"warn at {human_bytes(_PAYLOAD_WARN_BYTES)}/{_LATENCY_WARN_MS:.0f}ms, "
             f"crit at {human_bytes(_PAYLOAD_CRIT_BYTES)}/{_LATENCY_CRIT_MS:.0f}ms"
         ),
-        values={"latency_ms": latency_ms, "payload_bytes": payload_bytes},
+        values={
+            "latency_ms": latency_ms,
+            "payload_bytes": payload_bytes,
+            "builds_per_minute": builds_per_minute,
+        },
     )

{code_coordinator-0.5.451 → code_coordinator-0.5.453}/coord/health/fleet_snapshot.py

@@ -39,6 +39,7 @@ import json
 import logging
 import os
 import time
+from collections import deque
 from dataclasses import dataclass, field
 from pathlib import Path
 
@@ -276,6 +277,13 @@ class FleetHealthRefresher:
         # than fabricating a 0.
         self._board_latency_ms: float | None = None
         self._board_payload_bytes: int | None = None
+        # #3294: one timestamp per PUBLISHED /board build (never per request
+        # — a cache hit or a 304 doesn't rebuild, so it doesn't append here).
+        # This is the daemon-side, directly-measured answer to "did #3294's
+        # write-triggered cache actually cut rebuilds?", rather than an
+        # assumption — see `_builds_per_minute` and `probe_board_latency`
+        # (coord/health/checks/fleet_board.py).
+        self._board_build_timestamps: deque[float] = deque()
 
     def snapshot(self) -> FleetHealthSnapshot:
         return self._snapshot
@@ -284,12 +292,31 @@ class FleetHealthRefresher:
         """Called by the /board handler after each publish (#1630/#1597).
 
         Deliberately NOT I/O and NOT gated on the tick cadence — recording a
-        float+int is free, and the alternative (recomputing board latency
-        independently from this refresher) would mean building a whole
-        second board just to measure it, defeating the point of the check.
+        float+int (+ one timestamp, #3294) is free, and the alternative
+        (recomputing board latency independently from this refresher) would
+        mean building a whole second board just to measure it, defeating the
+        point of the check.
         """
         self._board_latency_ms = latency_ms
         self._board_payload_bytes = payload_bytes
+        self._board_build_timestamps.append(time.time())
+        self._prune_build_timestamps()
+
+    def _prune_build_timestamps(self, now: float | None = None) -> None:
+        """Drop build timestamps older than 60s — #3294's rolling window."""
+        cutoff = (now if now is not None else time.time()) - 60.0
+        timestamps = self._board_build_timestamps
+        while timestamps and timestamps[0] < cutoff:
+            timestamps.popleft()
+
+    def _builds_per_minute(self, now: float) -> int:
+        """#3294: how many /board REBUILDS (not requests) published in the
+        last 60s — the direct measurement backing the write-triggered
+        cache's whole premise ("rebuilds should track writes, not a 5s poll
+        clock"). Read by `refresh()` below into ``daemon_host`` for
+        ``fleet_board_latency`` (coord/health/checks/fleet_board.py)."""
+        self._prune_build_timestamps(now)
+        return len(self._board_build_timestamps)
 
     def refresh(self, config) -> FleetHealthSnapshot:  # noqa: ANN001 — coord.config.Config
         from coord import network, state  # noqa: PLC0415
@@ -376,6 +403,7 @@ class FleetHealthRefresher:
         daemon_host["phantom_running"] = self._phantom_running_rows(machines)
         daemon_host["board_latency_ms"] = self._board_latency_ms
         daemon_host["board_payload_bytes"] = self._board_payload_bytes
+        daemon_host["board_builds_per_minute"] = self._builds_per_minute(now)
         # #2858: per-repo issues-sync staleness — a small local JSON read
         # (coord.issues_sync_status), same "daemon-host-local fact" shape as
         # the two lines above. `coord.health.checks.issues_sync_staleness`