code-coordinator 0.5.290__tar.gz → 0.5.292__tar.gz

{code_coordinator-0.5.290 → code_coordinator-0.5.292}/.github/workflows/test.yml

@@ -31,6 +31,17 @@ jobs:
       # testpaths=["tests"]) was the one accidental gap. (ms-51 — Playwright,
       # never .py either — left this repo entirely with the webapp, #2009.)
       - run: pytest --ignore=tests/acceptance
+      # #2897: the Rust drift gate `tests/test_generated_rust_fixture.py`
+      # no longer byte-compares the committed `tui/src/app/types/generated.rs`
+      # (see docs/ADR_COORD_TUI_CI.md and the header comment further down
+      # this file) — this explicit step stands in for that comparison while
+      # `tui/` still lives here. `$COORD_TUI_SRC=.` names this checkout as
+      # the coord-tui root (`RUST_OUTPUT_RELPATH` keeps the `tui/` prefix for
+      # exactly this reason). One matrix leg only: the generator's output
+      # depends on `coord.serve_app.openapi_spec()`, not the Python version.
+      - name: python scripts/codegen.py --rust --check
+        if: matrix.python-version == '3.12'
+        run: COORD_TUI_SRC=. python scripts/codegen.py --rust --check
       # #2180: the cli-pytest sealed route (acceptance.drivers routes
       # "coord/**" -> cli-pytest -> tests/acceptance/ms-37) run through the
       # #2164 CI wrapper instead of a raw `pytest tests/acceptance` call, so
@@ -310,16 +321,31 @@ jobs:
   # for it to run against, and a job that installs Node to build nothing is
   # how the previous `acceptance`-on-every-push waste (#2389) started.
   #
-  # #1941: `scripts/codegen.py` also generates coord-tui's RUST wire types
-  # (`--rust`), and unlike the TS half above, `tui/` never left this repo —
-  # so that drift gate needs no separate job or `coord-web` checkout at all.
-  # It rides the ordinary `pytest --ignore=tests/acceptance` runs above, as
-  # `tests/test_generated_rust_fixture.py::
-  # test_committed_generated_rs_matches_generator_output`, the same way the
-  # TS-side `tests/test_generated_types_fixture.py` already rides them for
-  # the half of that check this repo can still make (the generator runs and
-  # covers every schema; the coord-web byte-comparison itself is that repo's
-  # own CI, per the paragraph above).
+  # #1941/#2897: `scripts/codegen.py` also generates coord-tui's RUST wire
+  # types (`--rust`). #2897 gave that half the SAME cross-repo shape as the
+  # TS half above (`--out PATH` / `$COORD_TUI_SRC`, no fallback default,
+  # docs/ADR_COORD_TUI_CI.md) — but `tui/` has not actually moved out of
+  # this repo yet, so unlike the TS byte-comparison (which is now
+  # exclusively `coord-web`'s CI job), the Rust byte-comparison has nowhere
+  # else to run yet and stays HERE, as an explicit step below rather than a
+  # pytest test:
+  #
+  #     COORD_TUI_SRC=. python scripts/codegen.py --rust --check
+  #
+  # `tests/test_generated_rust_fixture.py` itself is narrowed to what one
+  # checkout can prove — the generator runs and covers every schema — same
+  # as `tests/test_generated_types_fixture.py`; it no longer byte-compares
+  # the committed `tui/src/app/types/generated.rs`. The day coord-tui gets
+  # its own checkout + CI, delete the step below (its replacement lives in
+  # that CI, installing `code-coordinator[server]` from PyPI exactly as
+  # `coord-web`'s does) — no pytest file to un-narrow.
+  #
+  # The consumer-side INTEGER-backed-bool text-scraping guard
+  # (`coord/board_bool_guard.py`) that used to also read Rust source text
+  # here is RETIRED as of #2897, not moved — see docs/ADR_COORD_TUI_CI.md:
+  # #2895 (Phase 1 of #2894) deleted coord-tui's last direct SQL reader, so
+  # `tests/test_board_schema.py`'s DTO-level assertions are now the sole
+  # guard against that class.
 
   # #2886: a real Postgres 16 service, so `coord/sql.py`'s Postgres branches
   # (paramstyle translation, upsert idioms, `information_schema`

{code_coordinator-0.5.290 → code_coordinator-0.5.292}/PKG-INFO

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

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

@@ -39,7 +39,6 @@ coord/approved_work.py
 coord/audit.py
 coord/auto_loop.py
 coord/block_log.py
-coord/board_bool_guard.py
 coord/board_schema.py
 coord/board_service.py
 coord/board_wire.py
@@ -65,6 +64,7 @@ coord/dead_end.py
 coord/decomposition_chat.py
 coord/deploy_manifest.py
 coord/deploy_units.py
+coord/deprecation_telemetry.py
 coord/deps.py
 coord/diagnose.py
 coord/dispatch.py
@@ -296,6 +296,7 @@ deploy/coord-web-dist-build.timer
 deploy/coord-web-rollback.sh
 deploy/coord-web.service
 deploy/node-shim.sh
+docs/ADR_COORD_TUI_CI.md
 docs/ADR_COORD_WEB_ACCEPTANCE_SUITE.md
 docs/ADR_COORD_WEB_CI.md
 docs/ADR_COORD_WEB_DIST.md
@@ -527,6 +528,7 @@ tests/test_deploy_manifest.py
 tests/test_deploy_notify_unit.py
 tests/test_deploy_units_lane.py
 tests/test_deploy_web_unit.py
+tests/test_deprecation_telemetry.py
 tests/test_deps.py
 tests/test_diagnose.py
 tests/test_dispatch.py

{code_coordinator-0.5.290 → code_coordinator-0.5.292}/code_coordinator.egg-info/scm_file_list.json

@@ -33,7 +33,6 @@
     "coord/audit.py",
     "coord/auto_loop.py",
     "coord/block_log.py",
-    "coord/board_bool_guard.py",
     "coord/board_schema.py",
     "coord/board_service.py",
     "coord/board_wire.py",
@@ -117,6 +116,7 @@
     "coord/deploy/coord-web.service",
     "coord/deploy_manifest.py",
     "coord/deploy_units.py",
+    "coord/deprecation_telemetry.py",
     "coord/deps.py",
     "coord/diagnose.py",
     "coord/dispatch.py",
@@ -288,6 +288,7 @@
     "deploy/coord-web-rollback.sh",
     "deploy/coord-web.service",
     "deploy/node-shim.sh",
+    "docs/ADR_COORD_TUI_CI.md",
     "docs/ADR_COORD_WEB_ACCEPTANCE_SUITE.md",
     "docs/ADR_COORD_WEB_CI.md",
     "docs/ADR_COORD_WEB_DIST.md",
@@ -553,6 +554,7 @@
     "tests/test_deploy_notify_unit.py",
     "tests/test_deploy_units_lane.py",
     "tests/test_deploy_web_unit.py",
+    "tests/test_deprecation_telemetry.py",
     "tests/test_deps.py",
     "tests/test_diagnose.py",
     "tests/test_dispatch.py",

{code_coordinator-0.5.290 → code_coordinator-0.5.292}/code_coordinator.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.290",
+  "tag": "0.5.292",
   "distance": 0,
-  "node": "gd9ef2036c79e6b93ba2c92ee4c1a1756d509370f",
+  "node": "g9ed59fdae3fcb49322878ab98ddea03c35c9dcf7",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-29"

{code_coordinator-0.5.290 → code_coordinator-0.5.292}/coord/board_schema.py

@@ -287,10 +287,12 @@ BOARD_PROJECTIONS: dict[str, type] = {
 #: therefore ship as ``0``/``1``.  Their DTO fields are annotated ``int`` on
 #: purpose; ``tests/test_board_schema.py`` asserts the generated JSON Schema
 #: types them ``integer`` and never ``boolean``, so the wire shape survives a
-#: storage-engine swap (Postgres would make these real ``BOOLEAN``s).  This is
-#: the DTO-level counterpart of ``coord/board_bool_guard.py``'s consumer-side
-#: check against the real Rust wire structs (``tui/src/app/types.rs`` and,
-#: since #1941, its generated ``types/generated.rs`` sibling).
+#: storage-engine swap (Postgres would make these real ``BOOLEAN``s).  This
+#: WAS the DTO-level counterpart of ``coord/board_bool_guard.py``'s consumer-
+#: side check against the real Rust wire structs (``tui/src/app/types.rs``
+#: and its generated ``types/generated.rs`` sibling, #1941); that
+#: text-scraping check is retired as of #2897 (docs/ADR_COORD_TUI_CI.md) —
+#: this assertion is now the sole remaining guard.
 INTEGER_BACKED_BOOLEANS: frozenset[str] = frozenset(
     {"is_interactive", "review_scoped", "hold_after", "no_acceptance"}
 )

{code_coordinator-0.5.290 → code_coordinator-0.5.292}/coord/board_wire.py

@@ -113,7 +113,8 @@ TRUNCATION_NOTICE = "\n… [truncated on the /board wire — full text: detail e
 # two: `coord/**` and `tui/**`). Lines carrying it survive the body cut; see
 # `_machine_readable_residue`. Kept in sync with the Rust side by
 # tests/test_board_wire.py::test_allowed_glob_marker_matches_the_rust_parser,
-# the same cross-language guard posture as coord/board_bool_guard.py.
+# the same cross-language-guard posture the now-retired coord/board_bool_
+# guard.py used (#2897, docs/ADR_COORD_TUI_CI.md).
 #
 # Measured cost of the retention: ZERO on today's live board — 0 of 781
 # issue bodies carry the marker (the house `## Files` convention is a bare

{code_coordinator-0.5.290 → code_coordinator-0.5.292}/coord/client.py

@@ -27,6 +27,7 @@ from typing import Any
 
 import httpx
 
+from coord import __version__
 from coord._board_mapping import assemble_board, infer_review_state
 from coord.models import Board
 
@@ -69,7 +70,20 @@ def resolve_board_service(
 
 
 def _headers(svc: ServiceConfig) -> dict[str, str]:
-    return {"Authorization": f"Bearer {svc.token}"} if svc.token else {}
+    # #1945: every request identifies itself as this package + its running
+    # version, whether it's the interactive `coord` CLI, an agent's own
+    # pinned `~/.coord-venv`, or the drive-queue runner -- all three are
+    # literally this same Python package, just invoked from a different
+    # entry point, so there is no finer-grained identity to report short of
+    # a caller passing one explicitly (none does today). This is what lets
+    # the daemon's deprecated-RPC-route telemetry (coord.deprecation_telemetry)
+    # name which client + version is still calling a route marked deprecated
+    # in the OpenAPI spec, instead of an unattributed hit that nobody can
+    # act on.
+    headers = {"X-Coord-Client": "coord-py", "X-Coord-Client-Version": __version__}
+    if svc.token:
+        headers["Authorization"] = f"Bearer {svc.token}"
+    return headers
 
 
 def fetch_board_payload(svc: ServiceConfig, *, timeout: float = _DEFAULT_TIMEOUT) -> dict:

code_coordinator-0.5.292/coord/deprecation_telemetry.py

@@ -0,0 +1,102 @@
+"""Deprecation-call telemetry for RPC routes (#1945, Phase B of milestone #60).
+
+#1944 stamped ``deprecated: true`` on every RPC route a resource-shaped
+route now supersedes (``coord.serve_app.RPC_SUPERSEDED_BY_RESOURCE``) — but
+that is a documentation signal only.  Nobody can safely retire one of those
+routes on "we think everyone upgraded": this repo has already found a
+`coord-serve` unit 591 hours stale and a pinned CLI three releases behind
+while driving.  Retirement needs a number, not a belief.
+
+This module is the write side of that number: :func:`record_deprecated_rpc_call`
+is the single choke point the daemon's ``_DeprecatedRouteTelemetryMiddleware``
+(``coord/serve_app.py``) calls on every request whose path is a deprecated
+RPC route, best-effort and after the fact — capture must never raise into,
+or delay, the request that triggered it.  The read side (per-route last
+call / calling clients / versions) is ``coord.reports``' ``deprecated-routes``
+report, folded over the audit rows this writes.
+
+Client identity travels over two request headers a calling client sets
+(:data:`CLIENT_HEADER` / :data:`CLIENT_VERSION_HEADER`); a client that
+predates this issue sends neither, and that is recorded as
+:data:`UNKNOWN_CLIENT` rather than dropped — an unattributed call must still
+count against retirement (#1945 acceptance), not vanish from the count.
+"""
+
+from __future__ import annotations
+
+import logging
+
+_log = logging.getLogger(__name__)
+
+__all__ = [
+    "CATEGORY",
+    "EVENT_TYPE",
+    "CLIENT_HEADER",
+    "CLIENT_VERSION_HEADER",
+    "UNKNOWN_CLIENT",
+    "record_deprecated_rpc_call",
+]
+
+# `coord.audit.query_audit_log(category=...)` filter value — also the value
+# `coord.reports.fold_deprecated_routes` filters on when reading these rows
+# back out.  One literal, shared by both ends via this module.
+CATEGORY = "deprecation"
+EVENT_TYPE = "deprecated_rpc_call"
+
+# Header names a calling client sets its identity/version on. Starlette's
+# `Request.headers` is case-insensitive, so the exact case here is cosmetic
+# (chosen to match the existing `X-Coord-Schema` convention, #1943).
+CLIENT_HEADER = "X-Coord-Client"
+CLIENT_VERSION_HEADER = "X-Coord-Client-Version"
+
+# What an absent/blank client identity or version is recorded as. Never
+# dropped — an unattributed caller is exactly the caller retirement needs to
+# know about most.
+UNKNOWN_CLIENT = "unknown"
+
+
+def _clean(value: str | None) -> str:
+    return (value or "").strip() or UNKNOWN_CLIENT
+
+
+def record_deprecated_rpc_call(
+    route: str,
+    *,
+    client: str | None,
+    client_version: str | None,
+    ts: float | None = None,
+) -> None:
+    """Best-effort record of one call to deprecated RPC *route*.
+
+    Wraps :func:`coord.audit.record_audit` — itself already best-effort and
+    non-raising — in its own ``try/except`` so a broken import, a bad
+    argument type from a caller, or a DB error can never turn this
+    observability hook into a failed or delayed request. This is the ONLY
+    posture that satisfies #1945's "must never raise or delay a request":
+    the caller (the daemon's request-handling middleware) gets control back
+    unconditionally, whether or not the write actually landed.
+
+    ``client``/``client_version`` missing or blank are recorded as the
+    literal string :data:`UNKNOWN_CLIENT` — never dropped, per #1945's
+    acceptance bar ("an unattributed call must still block retirement").
+    """
+    try:
+        from coord.audit import record_audit  # noqa: PLC0415
+
+        actor = _clean(client)
+        version = _clean(client_version)
+        record_audit(
+            tier="operational",
+            category=CATEGORY,
+            event_type=EVENT_TYPE,
+            actor=actor,
+            summary=f"deprecated RPC call: {route} (client={actor}@{version})",
+            ts=ts,
+            details={"route": route, "client": actor, "client_version": version},
+        )
+    except Exception:  # noqa: BLE001 — telemetry must never break the caller
+        _log.debug(
+            "record_deprecated_rpc_call: best-effort write failed for %s",
+            route,
+            exc_info=True,
+        )

{code_coordinator-0.5.290 → code_coordinator-0.5.292}/coord/reports.py

@@ -3366,6 +3366,183 @@ def run_trend(
     )
 
 
+# ── deprecated-routes: evidence for RPC retirement (#1945) ────────────────
+#
+# A live snapshot, same posture as `drive-queue-status`: no window, no
+# `repo` param — a deprecated *route* is not scoped to one repo the way an
+# issue is. Folds `coord.deprecation_telemetry`'s audit rows (category
+# "deprecation", written by the daemon's `_DeprecatedRouteTelemetryMiddleware`
+# on every call to a route in `coord.serve_app.RPC_SUPERSEDED_BY_RESOURCE`)
+# into one row per deprecated route: last call, distinct calling
+# client+version pairs, and a total count.
+#
+# The one thing this report exists to get right that a log grep would not:
+# telling "zero calls" (a real, actionable signal — safe to consider for
+# retirement) apart from "no data collected" (telemetry not running for
+# THIS route or ANY route — an old daemon build, `audit.level: business`
+# dropping the operational-tier rows, or the audit table's own retention
+# trim — which must never be read as "safe").  The distinction is made at
+# the corpus level: if literally zero deprecation-category rows exist
+# anywhere (any route), collection cannot be confirmed live, so EVERY route
+# reads `no_data` rather than the misleadingly reassuring `zero_calls`.
+
+DEPRECATED_ROUTES_COLUMNS = [
+    "route",
+    "replacement",
+    "status",
+    "last_call",
+    "call_count",
+    "clients",
+]
+
+# One entry per DEPRECATED_ROUTES_COLUMNS entry, same order (#1760).
+DEPRECATED_ROUTES_COLUMN_META = [
+    ColumnMeta(id="route", label="Route", kind="text", weight=1.5),
+    ColumnMeta(id="replacement", label="Replacement", kind="text", weight=2.5),
+    ColumnMeta(id="status", label="Status", kind="enum"),
+    ColumnMeta(id="last_call", label="Last Call", kind="timestamp"),
+    ColumnMeta(id="call_count", label="Calls", kind="int", align="right"),
+    ColumnMeta(id="clients", label="Clients", kind="list"),
+]
+
+# `status` values.  `no_data` and `zero_calls` are BOTH "nothing seen for
+# this route" — they differ only in whether that absence is trustworthy —
+# so a client rendering this column must not collapse them to one meaning.
+DEPRECATED_ROUTE_NO_DATA = "no_data"
+DEPRECATED_ROUTE_ZERO_CALLS = "zero_calls"
+DEPRECATED_ROUTE_IN_USE = "in_use"
+
+
+def fold_deprecated_routes(
+    entries: Iterable[Mapping[str, Any]],
+    generated_at: float,
+    *,
+    routes: Mapping[str, str] | None = None,
+) -> ReportResult:
+    """Fold already-fetched deprecation-telemetry audit rows into a
+    per-route snapshot.  **Pure** — no DB, no daemon, no clock.
+
+    ``entries`` is whatever ``coord.audit.query_audit_log(category=
+    "deprecation")`` (paginated by the caller — see :func:`run_deprecated_routes`)
+    returned, newest-first.  ``routes`` defaults to
+    ``coord.serve_app.RPC_SUPERSEDED_BY_RESOURCE`` so the set of routes this
+    report covers can never drift from the set the daemon actually stamps
+    ``deprecated: true`` on in the served OpenAPI spec (#1944) — there is
+    exactly one source of truth for "which routes are deprecated", and this
+    report reads it rather than redeclaring it (the ``routes=`` override
+    exists purely so this stays a pure function a test can call without
+    importing the daemon module).
+    """
+    if routes is None:
+        from coord.serve_app import RPC_SUPERSEDED_BY_RESOURCE  # noqa: PLC0415
+
+        routes = RPC_SUPERSEDED_BY_RESOURCE
+
+    entries = list(entries)
+    any_data = bool(entries)
+
+    by_route: dict[str, list[Mapping[str, Any]]] = {r: [] for r in routes}
+    for entry in entries:
+        details = entry.get("details") or {}
+        route = details.get("route")
+        if route in by_route:
+            by_route[route].append(entry)
+
+    rows: list[dict[str, Any]] = []
+    for route in sorted(routes):
+        calls = sorted(
+            by_route.get(route, []), key=lambda e: e.get("ts") or 0, reverse=True
+        )
+        last_call = calls[0].get("ts") if calls else None
+        clients: list[str] = []
+        seen: set[tuple[str, str]] = set()
+        for call in calls:
+            details = call.get("details") or {}
+            pair = (
+                details.get("client") or "unknown",
+                details.get("client_version") or "unknown",
+            )
+            if pair not in seen:
+                seen.add(pair)
+                clients.append(f"{pair[0]}@{pair[1]}")
+        if calls:
+            status = DEPRECATED_ROUTE_IN_USE
+        elif any_data:
+            status = DEPRECATED_ROUTE_ZERO_CALLS
+        else:
+            status = DEPRECATED_ROUTE_NO_DATA
+        rows.append(
+            {
+                "route": route,
+                "replacement": routes[route],
+                "status": status,
+                "last_call": last_call,
+                "call_count": len(calls),
+                "clients": clients,
+            }
+        )
+
+    notes: list[str] = []
+    if not any_data:
+        notes.append(
+            "No deprecation telemetry has been recorded at all, for any "
+            "route — this may mean genuinely zero calls, or that capture "
+            "is not running (an old daemon build predating #1945, "
+            "`audit.level: business` dropping operational-tier rows, or "
+            "the audit table's own retention trim). Every row above reads "
+            "`no_data`, not `zero_calls` — treat it as UNKNOWN, never as "
+            "evidence it is safe to retire."
+        )
+
+    return ReportResult(
+        report_id="deprecated-routes",
+        generated_at=generated_at,
+        window=(generated_at, generated_at),
+        columns=list(DEPRECATED_ROUTES_COLUMNS),
+        column_meta=list(DEPRECATED_ROUTES_COLUMN_META),
+        rows=rows,
+        notes=notes,
+    )
+
+
+def _default_fetch_deprecation_entries(
+    generated_at: float,
+) -> tuple[list[dict], bool]:
+    return fetch_audit_window(since=0.0, until=generated_at, category="deprecation")
+
+
+def run_deprecated_routes(
+    *,
+    now: float | None = None,
+    fetch: Callable[[float], tuple[Sequence[Mapping[str, Any]], bool]] | None = None,
+    routes: Mapping[str, str] | None = None,
+) -> ReportResult:
+    """Fetch every recorded deprecated-RPC-route call and fold it (#1945).
+
+    ``fetch``/``routes`` are test seams (mirrors every other ``run_*``'s
+    ``fetch=`` seam). Production always walks the FULL audit history
+    (``since=0``), never a recent window — "this route has not been called
+    in months" is exactly the number #1945 exists to produce, and a
+    windowed report would silently hide the very evidence retirement needs.
+    ``query_audit_log`` orders newest-first, so ``last_call`` is accurate
+    even if the walk is truncated by the page cap; only the full
+    client/version set and total ``call_count`` could then be incomplete,
+    which is called out in a note exactly like every other truncated fold
+    in this module.
+    """
+    generated_at = time.time() if now is None else float(now)
+    fetch_fn = _default_fetch_deprecation_entries if fetch is None else fetch
+    entries, truncated = fetch_fn(generated_at)
+    result = fold_deprecated_routes(entries, generated_at, routes=routes)
+    if truncated:
+        result.notes.append(
+            "Audit history walk hit its page cap before covering the full "
+            "history — `clients`/`call_count` may be missing older calls, "
+            "though `last_call` (newest-first order) is still accurate."
+        )
+    return result
+
+
 # ── the catalogue ──────────────────────────────────────────────────────────
 
 SINCE_PRESETS = ("1h", "6h", "24h", "3d", "7d")
@@ -3683,6 +3860,22 @@ TREND = ReportDef(
 )
 
 
+DEPRECATED_ROUTES = ReportDef(
+    id="deprecated-routes",
+    title="Deprecated RPC Routes",
+    description=(
+        "Per deprecated RPC route (the #1944 superseded-by-resource table): "
+        "last call, distinct calling client+version pairs, and a total "
+        "count — evidence for retirement instead of belief (#1945). "
+        "`status` distinguishes `in_use` from `zero_calls` (a real, "
+        "actionable signal) from `no_data` (telemetry not confirmed live — "
+        "never safe to read as `zero_calls`)."
+    ),
+    params=(),
+    run=run_deprecated_routes,
+)
+
+
 # ── CSV serialisation (#1765) ──────────────────────────────────────────────
 #
 # One serializer, server-side, for every surface: `coord report run --format
@@ -3863,6 +4056,7 @@ REPORTS: dict[str, ReportDef] = {
     USAGE.id: USAGE,
     QUEUE_OUTCOMES.id: QUEUE_OUTCOMES,
     TREND.id: TREND,
+    DEPRECATED_ROUTES.id: DEPRECATED_ROUTES,
 }
 
 

{code_coordinator-0.5.290 → code_coordinator-0.5.292}/coord/serve_app.py

@@ -453,6 +453,55 @@ class _SchemaNegotiationMiddleware(BaseHTTPMiddleware):
         )
 
 
+class _DeprecatedRouteTelemetryMiddleware(BaseHTTPMiddleware):
+    """Record client identity + version on every call to a deprecated RPC
+    route (#1945, Phase B of #60 -- retirement needs a number, not a belief).
+
+    ``RPC_SUPERSEDED_BY_RESOURCE`` (defined further down this module) is the
+    single source of truth for "which routes are deprecated" -- the same
+    dict :func:`_mark_superseded_rpc_routes` stamps ``deprecated: true``
+    with in the served OpenAPI spec (#1944). Matching against it here rather
+    than a second hardcoded list means every route the spec calls
+    deprecated is automatically covered by telemetry too; they cannot drift
+    apart.
+
+    Innermost middleware by construction (appended last in ``build_app``,
+    after gzip / schema negotiation / bearer auth) -- it only ever sees a
+    request that has already cleared every earlier gate, so it counts real
+    calls that reached a deprecated handler, not requests bounced upstream.
+
+    Capture happens by calling
+    :func:`coord.deprecation_telemetry.record_deprecated_rpc_call`, which is
+    itself best-effort and never raises -- but this dispatch method wraps it
+    in its own ``try/except`` besides, so even an import failure or a
+    surprising ``request.headers`` type can never turn telemetry into a
+    broken response. The write is a single local SQLite insert (the same
+    ``record_audit`` every board-mutation handler in this file already calls
+    synchronously on its own request path), so it adds no meaningfully
+    different latency than those existing writes -- there is no separate
+    async/background-thread mechanism elsewhere in this file to match, and
+    none is warranted here either.
+    """
+
+    async def dispatch(self, request: Request, call_next):  # noqa: ANN001, ANN201
+        if request.url.path in RPC_SUPERSEDED_BY_RESOURCE:
+            try:
+                from coord.deprecation_telemetry import (  # noqa: PLC0415
+                    CLIENT_HEADER,
+                    CLIENT_VERSION_HEADER,
+                    record_deprecated_rpc_call,
+                )
+
+                record_deprecated_rpc_call(
+                    request.url.path,
+                    client=request.headers.get(CLIENT_HEADER),
+                    client_version=request.headers.get(CLIENT_VERSION_HEADER),
+                )
+            except Exception:  # noqa: BLE001 — telemetry must never break a request
+                pass
+        return await call_next(request)
+
+
 def _reload_config_if_stale(
     current: Config, last_mtime: float | None
 ) -> tuple[Config, float | None]:
@@ -9649,4 +9698,9 @@ def build_app(store: CoordStore, config: Config, *, token: str | None = None) ->
     ]
     if token:
         middleware.append(Middleware(_BearerAuthMiddleware, token=token))
+    # #1945: innermost -- runs closest to the route handler, after schema
+    # negotiation and (if configured) bearer auth have already let the
+    # request through, so telemetry only counts calls that actually reached
+    # a deprecated route's handler.
+    middleware.append(Middleware(_DeprecatedRouteTelemetryMiddleware))
     return Starlette(routes=routes, middleware=middleware, lifespan=_lifespan)

{code_coordinator-0.5.290 → code_coordinator-0.5.292}/coord/usage.py

@@ -380,9 +380,9 @@ def fetch_usage_rows(
     :class:`~coord.models.Assignment` instances — the aggregator consumes the
     daemon ``/board`` ``assignments`` shape directly, including
     ``is_interactive``, which is a real DB/wire column but (deliberately,
-    #748/#632 — see :mod:`coord.board_bool_guard`) not an ``Assignment``
-    dataclass field, so converting through ``Assignment`` would silently
-    drop it.
+    #748/#632 — see ``coord.board_schema.INTEGER_BACKED_BOOLEANS`` and
+    ``tests/test_board_schema.py``) not an ``Assignment`` dataclass field, so
+    converting through ``Assignment`` would silently drop it.
 
     Remote reads the same ``/board`` endpoint ``coord status`` polls. Local
     reads the sqlite DB directly via ``SqliteStore.list_assignments()``