code-coordinator 0.5.450__tar.gz → 0.5.452__tar.gz

{code_coordinator-0.5.450 → code_coordinator-0.5.452}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.450",
+  "tag": "0.5.452",
   "distance": 0,
-  "node": "g6d7a8b2b3bfaa147e2a191a6475f1bdbbf4cac6e",
+  "node": "g69efb323ff5ace2c8783a4e3eb8deb0b37b5aff0",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-09-11"

{code_coordinator-0.5.450 → code_coordinator-0.5.452}/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.450 → code_coordinator-0.5.452}/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.450 → code_coordinator-0.5.452}/coord/serve_app.py

@@ -5665,6 +5665,104 @@ def openapi_spec() -> dict:
     )
 
 
+# #3293: keys whose values are inherently volatile per-build (a sliding
+# window count) but carry no board-state signal of their own — excluded from
+# the ``/board`` ETag DIGEST INPUT only (see ``_board_digest_projection``
+# below and ``_stamp_board_version``'s docstring). Every one of these fields
+# still ships on the wire, unchanged; this only stops them from deciding
+# whether the version bumps.
+_BOARD_DIGEST_VOLATILE_TOP_KEYS = frozenset({"audit_recent_count"})
+
+
+def _board_digest_projection(result: dict) -> dict:
+    """A copy of *result* with digest-irrelevant volatile fields stripped.
+
+    Used ONLY to compute the ``/board`` ETag/version digest (#3293) — the
+    actual wire body is `result` itself, untouched. Three culprits, in order
+    of how often they move (see issue #3293's measurements):
+
+    - ``audit_recent_count``: a sliding 900s window count, changed on
+      essentially every build.
+    - ``issues[*].synced_at``: ~788 rows share one sync timestamp that moves
+      on the issues-sync tick, re-digesting the whole issues section at once.
+    - ``fleet_health``: moves on the 60s health tick. Its ``refreshed_at``
+      clock and its ``fleet_board_latency`` check are excluded — the latter
+      measures THIS /board response's own fetch latency and serialized size
+      and stores that measurement inside the response, which is structurally
+      self-invalidating for a content digest.
+
+    Deliberately narrow: per-machine health severities/results/headrooms are
+    left in the digest, because a real state change there (a machine going
+    offline, a disk filling up) SHOULD bump the ETag — only the fields that
+    move on their own, independent of any real state change, are excluded.
+    """
+    projection = {
+        k: v for k, v in result.items() if k not in _BOARD_DIGEST_VOLATILE_TOP_KEYS
+    }
+
+    issues = projection.get("issues")
+    if isinstance(issues, list):
+        projection["issues"] = [
+            {k: v for k, v in issue.items() if k != "synced_at"}
+            if isinstance(issue, dict) else issue
+            for issue in issues
+        ]
+
+    fleet_health = projection.get("fleet_health")
+    if isinstance(fleet_health, dict):
+        projection["fleet_health"] = _board_digest_fleet_health(fleet_health)
+
+    return projection
+
+
+def _board_digest_fleet_health(fleet_health: dict) -> dict:
+    """Strip ``fleet_health``'s clocks + self-referential latency check.
+
+    See ``_board_digest_projection`` — digest input only, never the wire body.
+    """
+    masked = {k: v for k, v in fleet_health.items() if k != "refreshed_at"}
+
+    machine_health = masked.get("machine_health")
+    if isinstance(machine_health, list):
+        masked["machine_health"] = [
+            _board_digest_health_row(row) if isinstance(row, dict) else row
+            for row in machine_health
+        ]
+
+    fleet_checks = masked.get("fleet_checks")
+    if isinstance(fleet_checks, list):
+        masked["fleet_checks"] = [
+            _board_digest_check_result(c) if isinstance(c, dict) else c
+            for c in fleet_checks
+        ]
+
+    return masked
+
+
+def _board_digest_health_row(row: dict) -> dict:
+    """Drop one machine's poll clocks (``received_at``/``checked_at``) from
+    the digest input — the results/severity/headroom that actually describe
+    the machine's state stay in, per ``_board_digest_projection``'s docstring.
+    """
+    return {k: v for k, v in row.items() if k not in ("received_at", "checked_at")}
+
+
+def _board_digest_check_result(check: dict) -> dict:
+    """Drop ``fleet_board_latency``'s self-measurement from the digest input.
+
+    This one check answers "how fast/big was the /board response that is
+    carrying this very check result?" — its ``headroom`` text and ``values``
+    (``latency_ms``/``payload_bytes``) are a measurement of the response
+    embedded in the response, so they change on every build regardless of
+    whether anything a human/client cares about actually changed. Every
+    other fleet check's headroom/values reflect real, digest-worthy state
+    and are left untouched.
+    """
+    if check.get("check_id") != "fleet_board_latency":
+        return check
+    return {k: v for k, v in check.items() if k not in ("headroom", "values")}
+
+
 def build_app(
     store: CoordStore,
     config: Config,
@@ -5768,13 +5866,31 @@ def build_app(
     _board_inflight: asyncio.Future[tuple] | None = None
 
     def _stamp_board_version(result: dict) -> tuple[str, bytes]:
-        """Serialize *result* to JSON exactly once, bump the version when the
-        content changed, stamp ``board_version`` into the payload, and
-        return ``(etag, body_bytes)`` — the SAME bytes serve as both the
-        content-hash input and the wire body (#1597 Part 2: previously this
-        hashed a separate ``sort_keys=True`` dump and the caller re-encoded
-        the dict a second time via ``JSONResponse`` — ~10 MB of JSON work per
-        build for a 5 MB board).
+        """Serialize *result* to JSON exactly once for the wire body, bump
+        the version when a STABLE PROJECTION of the content changed, stamp
+        ``board_version`` into the payload, and return ``(etag, body_bytes)``.
+
+        #1597 Part 2: the wire ``body`` bytes below are the same bytes
+        published to callers — no second encoder pass for the response
+        itself.
+
+        #3293: the content-hash input is deliberately NOT those same bytes
+        any more. The payload embeds fields that move on every build without
+        any board-state signal of their own — ``audit_recent_count`` (a
+        sliding 900s window count), ``issues[*].synced_at`` (~788 rows
+        re-stamped on one shared sync tick), and ``fleet_health``'s clocks
+        and its self-referential ``fleet_board_latency`` check (which
+        measures THIS response's own fetch latency/size and stores the
+        measurement inside the response being measured). Hashing those made
+        the ETag change on effectively every request, defeating #1336's
+        cache-validated polling entirely. ``_board_digest_projection`` builds
+        a masked copy for hashing only; the wire ``body`` — and every field
+        in it, unchanged — still carries the real values. This does cost a
+        second JSON encode of (most of) the payload on every cache-miss
+        rebuild, which is rare relative to requests (TTL-cached in between);
+        that's the trade #1597 avoided but #3293 requires; a truly stable
+        ETag that lets pollers 304 is worth far more than skipping it on the
+        rebuild path.
 
         ``board_version`` can't be known before the hash is computed (it
         depends on whether the hash changed), so it is deliberately excluded
@@ -5822,7 +5938,19 @@ def build_app(
                 indent=None, separators=(",", ":"), default=str,
             ).encode("utf-8")
         else:
-            digest = hashlib.sha256(body).hexdigest()[:16]
+            # #3293: hash a stable PROJECTION of the content, not the wire
+            # bytes themselves — see the docstring above. The wire `body`
+            # computed just above is untouched and still carries every
+            # field, including the ones excluded here.
+            # No `default=str` needed (unlike the fallback above): reaching
+            # this branch means the strict encode of `result` just SUCCEEDED,
+            # and the projection is a key-subset of those same values, so it
+            # cannot contain a type the strict encoder would reject.
+            digest_body = _json.dumps(
+                _board_digest_projection(result), ensure_ascii=False,
+                allow_nan=False, indent=None, separators=(",", ":"),
+            ).encode("utf-8")
+            digest = hashlib.sha256(digest_body).hexdigest()[:16]
         if digest != _board_hash:
             _board_hash = digest
             _board_version += 1

{code_coordinator-0.5.450 → code_coordinator-0.5.452}/tests/conftest.py

@@ -139,6 +139,26 @@ def _fresh_resource_route_support():
     board_service.reset_resource_route_support()
 
 
+@pytest.fixture(autouse=True)
+def _fresh_board_payload_cache():
+    """#3295: forget every cached ``GET /board`` ETag/body between tests.
+
+    ``coord.client.fetch_board_payload`` now memoizes ``(etag, body)`` per
+    service URL so a thin client sending a repeat ``If-None-Match`` can reuse
+    the daemon's 304. That memo is module-level — same shape as
+    ``_fresh_resource_route_support`` above — so without a reset a test that
+    populates it for a fake ``http://daemon:7435`` (a URL string reused
+    across dozens of unrelated tests) would leak a stale ``If-None-Match``
+    header, and a stale cached body, into the next test that happens to
+    reuse it.
+    """
+    from coord import client as _cc
+
+    _cc.reset_board_payload_cache()
+    yield
+    _cc.reset_board_payload_cache()
+
+
 @pytest.fixture(autouse=True)
 def _no_real_webapp_bundle(monkeypatch, tmp_path):
     """#2009: never let the HOST's live webapp bundle change a test's answer.