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

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

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

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

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

{code_coordinator-0.5.450 → code_coordinator-0.5.451}/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.451}/tests/test_board_read_path.py

@@ -186,6 +186,228 @@ def test_board_version_bumps_when_content_changes(
         assert r3.headers["etag"] != r1.headers["etag"]
 
 
+def test_board_digest_projection_masks_only_the_named_volatile_fields() -> None:
+    """#3293 unit-level check on ``_board_digest_projection`` itself: the
+    three named culprits (``audit_recent_count``, ``issues[*].synced_at``,
+    and ``fleet_health``'s clocks + self-referential ``fleet_board_latency``
+    check) are stripped from the digest input, while every other field —
+    including the REST of ``fleet_health`` (severities, results, other
+    checks) — passes through untouched, so a real state change still bumps
+    the ETag.
+    """
+    from coord.serve_app import _board_digest_projection
+
+    result = {
+        "round_number": 3,
+        "assignments": [{"assignment_id": "work1", "status": "done"}],
+        "audit_recent_count": 7,
+        "issues": [
+            {"repo_name": "api", "number": 42, "title": "A", "synced_at": 111.0},
+            {"repo_name": "api", "number": 43, "title": "B", "synced_at": 222.0},
+        ],
+        "fleet_health": {
+            "schema": 1,
+            "refreshed_at": 1000.0,
+            "truncated": False,
+            "machine_health": [
+                {
+                    "machine": "laptop",
+                    "severity": "warn",
+                    "received_at": 1000.0,
+                    "checked_at": 999.0,
+                    "results": [{"check_id": "disk", "severity": "warn", "headroom": "9% free"}],
+                }
+            ],
+            "fleet_checks": [
+                {
+                    "check_id": "fleet_board_latency",
+                    "severity": "ok",
+                    "headroom": "738ms / 3.4M",
+                    "values": {"latency_ms": 738.0, "payload_bytes": 3_400_000},
+                },
+                {
+                    "check_id": "fleet_deploy_lanes",
+                    "severity": "crit",
+                    "headroom": "2 machines behind",
+                    "values": {"behind": 2},
+                },
+            ],
+        },
+    }
+
+    projection = _board_digest_projection(result)
+
+    # The three named culprits are gone from the digest input...
+    assert "audit_recent_count" not in projection
+    assert all("synced_at" not in issue for issue in projection["issues"])
+    assert "refreshed_at" not in projection["fleet_health"]
+    masked_row = projection["fleet_health"]["machine_health"][0]
+    assert "received_at" not in masked_row and "checked_at" not in masked_row
+    masked_latency_check = projection["fleet_health"]["fleet_checks"][0]
+    assert masked_latency_check["check_id"] == "fleet_board_latency"
+    assert "headroom" not in masked_latency_check and "values" not in masked_latency_check
+
+    # ...but real state signal is untouched: severities, other fields on the
+    # issue rows, and a DIFFERENT fleet check's headroom/values all survive,
+    # so a genuine state change still moves the digest.
+    assert projection["assignments"] == result["assignments"]
+    assert projection["issues"][0]["title"] == "A"
+    assert masked_row["severity"] == "warn"
+    assert masked_row["results"] == [{"check_id": "disk", "severity": "warn", "headroom": "9% free"}]
+    other_check = projection["fleet_health"]["fleet_checks"][1]
+    assert other_check == result["fleet_health"]["fleet_checks"][1]
+
+    # And the original `result` passed in is never mutated — it's still the
+    # dict that gets serialized as the wire body, culprits and all.
+    assert result["audit_recent_count"] == 7
+    assert result["issues"][0]["synced_at"] == 111.0
+    assert result["fleet_health"]["refreshed_at"] == 1000.0
+
+
+def test_board_version_stable_across_audit_and_health_tick_noise(
+    detail_db: Path, valid_config_path: Path, monkeypatch
+) -> None:
+    """#3293 production-shaped regression test.
+
+    Before #3293 this failed: ``_stamp_board_version`` hashed the wire body
+    directly, which embeds ``audit_recent_count`` (a sliding 900s window
+    count) and ``fleet_health`` (moves on the 60s health tick, including a
+    self-referential ``fleet_board_latency`` check that measures the board
+    response's OWN previous fetch latency/size). An audit row landing inside
+    the window, combined with a fleet-health refresh, bumped the ETag on a
+    rebuild even though nothing a poller should care about — assignments,
+    issues, machine severities — actually changed. That meant a
+    just-issued ETag could never survive to the next poll (#3293's "7 of 7
+    consecutive attempts" live-daemon measurement).
+
+    Reproduces exactly that: seed an audit_log row inside the window and
+    swap in a second, clock-advanced ``fleet_health`` snapshot between two
+    builds, with everything else held identical, and assert the version/ETag
+    survive — a conditional GET after both must still 304.
+    """
+    import time as _time
+
+    from coord.health.fleet_snapshot import FleetHealthRefresher
+
+    monkeypatch.setenv("COORD_BOARD_CACHE_TTL", "0")  # rebuild every request
+
+    now = _time.time()
+
+    def _fleet_health(*, refreshed_at: float, latency_ms: float, payload_bytes: int) -> dict:
+        return {
+            "schema": 1,
+            "refreshed_at": refreshed_at,
+            "truncated": False,
+            "machine_health": [
+                {
+                    "machine": "laptop",
+                    "state": "online",
+                    "reason": "",
+                    "latency_ms": 12.3,
+                    "received_at": refreshed_at,
+                    "stale": False,
+                    "severity": "ok",
+                    "checked_at": refreshed_at - 1.0,
+                    "results": [
+                        {
+                            "key": "disk:/home", "check_id": "disk", "scope": "machine",
+                            "subject": "/home", "title": "disk", "label": "disk",
+                            "severity": "ok", "headroom": "40% free",
+                            "threshold": "warn at 10%", "detail": "", "trend": None,
+                            "values": {"free_pct": 40}, "error": None,
+                        },
+                    ],
+                    "worktree_bytes": 1_048_576,
+                    "agent_runtime_version": "1.2.3",
+                }
+            ],
+            "fleet_checks": [
+                {
+                    "key": "fleet_board_latency", "check_id": "fleet_board_latency",
+                    "scope": "fleet", "subject": None, "title": "board latency+size",
+                    "label": "board latency+size", "severity": "ok",
+                    "headroom": f"{latency_ms:.0f}ms / {payload_bytes}",
+                    "threshold": "warn at 2.0MiB/1500ms, crit at 5.0MiB/4000ms",
+                    "detail": "", "trend": None,
+                    "values": {"latency_ms": latency_ms, "payload_bytes": payload_bytes},
+                    "error": None,
+                },
+            ],
+        }
+
+    # Same real health state both times (machine "laptop", disk 40% free,
+    # severity "ok") — only the clocks and the self-measured board
+    # latency/size (which necessarily differs build-to-build) move.
+    fleet_health_by_build = [
+        _fleet_health(refreshed_at=now, latency_ms=738.0, payload_bytes=3_400_000),
+        _fleet_health(refreshed_at=now + 60.0, latency_ms=812.0, payload_bytes=3_512_000),
+    ]
+    calls = {"i": 0}
+
+    class _FakeSnapshot:
+        def __init__(self, d: dict) -> None:
+            self._d = d
+
+        def to_dict(self) -> dict:
+            return self._d
+
+    def fake_snapshot(self):  # noqa: ANN001
+        i = min(calls["i"], len(fleet_health_by_build) - 1)
+        calls["i"] += 1
+        return _FakeSnapshot(fleet_health_by_build[i])
+
+    monkeypatch.setattr(FleetHealthRefresher, "snapshot", fake_snapshot)
+
+    cfg = load_config(valid_config_path)
+    app = build_app(SqliteStore(detail_db), cfg)
+    with TestClient(app) as cli:
+        r1 = cli.get("/board")
+        assert r1.status_code == 200
+        body1 = r1.json()
+        v1 = body1["board_version"]
+        etag1 = r1.headers["etag"]
+        assert etag1
+
+        # Between builds: an audit_log row lands inside the 900s recency
+        # window (the per-build killer named in #3293) AND fleet-health
+        # ticks forward. Nothing else in the DB changes.
+        conn = sqlite3.connect(str(detail_db))
+        conn.execute(
+            "INSERT INTO audit_log (ts, tier, category, event_type, actor, summary) "
+            "VALUES (?,?,?,?,?,?)",
+            (now, "info", "board", "test.event", "tester", "inside the window"),
+        )
+        conn.commit()
+        conn.close()
+
+        # A conditional GET with the first ETag must still 304 — the whole
+        # point of #1336's cache-validated polling, which #3293 says can
+        # "never match" today.
+        r2 = cli.get("/board", headers={"If-None-Match": etag1})
+        assert r2.status_code == 304, (
+            "an audit row inside the window + a fleet-health tick must not "
+            "move the ETag — this is exactly #3293's failure mode"
+        )
+        assert r2.headers.get("etag") == etag1
+        assert not r2.content
+
+        # An unconditional rebuild confirms the underlying fields really DID
+        # move (this test isn't vacuous) while the version/ETag held.
+        r3 = cli.get("/board")
+        body3 = r3.json()
+        assert body3["audit_recent_count"] != body1["audit_recent_count"]
+        assert (
+            body3["fleet_health"]["refreshed_at"]
+            != body1["fleet_health"]["refreshed_at"]
+        )
+        assert (
+            body3["fleet_health"]["fleet_checks"][0]["values"]
+            != body1["fleet_health"]["fleet_checks"][0]["values"]
+        )
+        assert body3["board_version"] == v1
+        assert r3.headers["etag"] == etag1
+
+
 def test_stale_concurrent_rebuild_is_never_published(
     detail_db: Path, valid_config_path: Path, monkeypatch
 ) -> None:
@@ -575,13 +797,17 @@ def test_board_stamp_raises_on_nan_instead_of_silently_encoding_it(
     assert resp.status_code == 500
 
 
-def test_board_stamp_serializes_payload_once(
+def test_board_stamp_serializes_payload_twice(
     app_client: TestClient, monkeypatch
 ) -> None:
-    """#1597 Part 2: the ~5 MB board payload is JSON-encoded exactly ONCE per
-    build — the same bytes serve as both the ETag's content-hash input and
-    the wire body, instead of once for the hash and again for the response
-    (the "~10 MB of JSON work per rebuild" amplifier named in the issue).
+    """#1597 Part 2 established the wire body is encoded exactly once (no
+    separate render pass for the HTTP response). #3293 deliberately adds a
+    SECOND encode of a stable projection to compute the ETag digest from —
+    hashing the wire bytes directly meant the digest moved on every build
+    (see ``_stamp_board_version``'s docstring), so the two can no longer be
+    the same pass. This test pins the count at exactly 2 (not "however many
+    it happens to be") so a future change that reintroduces extra passes
+    (e.g. re-encoding per retry, or double-hashing) gets caught.
 
     Targets the full-payload dumps() call specifically (its distinctive
     ``separators=(",", ":")`` signature) so per-field encodes elsewhere in
@@ -602,9 +828,9 @@ def test_board_stamp_serializes_payload_once(
     resp = app_client.get("/board")
 
     assert resp.status_code == 200
-    assert len(calls) == 1, (
-        f"the full-board payload was JSON-encoded {len(calls)}x for one "
-        "build — expected exactly 1"
+    assert len(calls) == 2, (
+        f"the board payload was JSON-encoded {len(calls)}x for one build — "
+        "expected exactly 2 (wire body + #3293's digest projection)"
     )
 
 

{code_coordinator-0.5.450 → code_coordinator-0.5.451}/tests/test_sqlite_connect_ratchet.py

@@ -273,10 +273,18 @@ SQLITE_CONNECT_ALLOWLIST: dict[str, Classification] = {
         "checkpoint tick.",
     ),
     "test_board_read_path.py": Classification(
-        8, (BUCKET_C,),
-        "All file DBs for SqliteStore/TestClient; two are deliberate second "
+        9, (BUCKET_C,),
+        "All file DBs for SqliteStore/TestClient; three are deliberate second "
         "connections to an already-existing file DB, asserting "
-        "cross-connection visibility — the definition of bucket C.",
+        "cross-connection visibility — the definition of bucket C. The third "
+        "(#3293, test_board_version_stable_across_audit_and_health_tick_noise) "
+        "is the same shape as the #1336 one above it: it reopens the live "
+        "`detail_db` mid-test to land an audit_log row inside the 900s "
+        "recency window, then asserts the running daemon's next rebuild sees "
+        "it. Neither the autouse `coord_db` fixture nor "
+        "tests.backends.scratch_database() fits — both hand back a DIFFERENT "
+        "database than the one SqliteStore is already holding by path, so the "
+        "write would be invisible to the endpoint under test.",
     ),
     "test_needs_attention.py": Classification(
         4, (BUCKET_C,),