code-coordinator 0.5.170__tar.gz → 0.5.171__tar.gz

{code_coordinator-0.5.170 → code_coordinator-0.5.171}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.170",
+  "tag": "0.5.171",
   "distance": 0,
-  "node": "g8abd90cf35709226356d93ec35209ccca9e9ee6c",
+  "node": "ga2bdfedae4a53fa1092820a1d38f8c7e925a87d7",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-19"

{code_coordinator-0.5.170 → code_coordinator-0.5.171}/coord/dashboard/fixture.py

@@ -35,6 +35,7 @@ Fixture schema (every key optional except ``board``)::
       "proposals":       [ {...coord.models.Proposal fields...} ],
       "machines":        [ {...GET /api/machines entry...} ],
       "sessions":        [ {...GET /api/sessions entry...} ],
+      "drive_queue":     [ {...coord.state._decode_drive_queue_row shape...} ],
       "review_findings": {"rev-1": {"verdict": "approve", "body": "..."}},
       "diffs":           {"work-1": "diff --git ..."},
       "chat_reply":      "canned /api/chat response text",
@@ -154,6 +155,7 @@ class FixtureServer:
     proposals_raw: list = field(default_factory=list)
     machines_raw: list = field(default_factory=list)
     sessions_raw: list = field(default_factory=list)
+    drive_queue_raw: list = field(default_factory=list)
     review_findings_raw: dict = field(default_factory=dict)
     diffs: dict = field(default_factory=dict)
     chat_reply: str = "fixture mode: the coordinator assistant is not wired up."
@@ -194,6 +196,20 @@ class FixtureServer:
     def sessions(self) -> list[dict]:
         return copy.deepcopy(self.sessions_raw)
 
+    def drive_queue(self, repo_name: str | None = None) -> list[dict]:
+        """The seeded `coord drive` queue rows (#2428 DQW-1).
+
+        Same raw-row shape ``GET /api/drive-queue`` serves off the real DB
+        (``coord.state._decode_drive_queue_row``) — no reshaping, so a
+        fixture captured from a live queue (or hand-written to that shape)
+        drops in unchanged. ``repo_name`` filters exactly like
+        ``coord.state._list_drive_queue_local``'s ``WHERE repo_name = ?``.
+        """
+        rows = copy.deepcopy(self.drive_queue_raw)
+        if repo_name:
+            rows = [r for r in rows if r.get("repo_name") == repo_name]
+        return rows
+
     def review_findings(self, assignment_id: str) -> tuple[str, str] | None:
         """Stand-in for ``coord.state.load_assignment_review_findings``.
 
@@ -343,6 +359,7 @@ def parse_fixture(raw: Any, *, path: Path | None = None) -> FixtureServer:
         proposals_raw=_as_list(raw.get("proposals"), "proposals"),
         machines_raw=_as_list(raw.get("machines"), "machines"),
         sessions_raw=_as_list(raw.get("sessions"), "sessions"),
+        drive_queue_raw=_as_list(raw.get("drive_queue"), "drive_queue"),
         review_findings_raw=_as_dict(raw.get("review_findings"), "review_findings"),
         diffs=diffs,
         events=_parse_events(raw.get("events")),

{code_coordinator-0.5.170 → code_coordinator-0.5.171}/coord/dashboard/server.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import asyncio
 import json
+import sqlite3
 import subprocess
 import time
 from concurrent.futures import ThreadPoolExecutor
@@ -34,11 +35,19 @@ from coord.events import (
     build_events_route,
 )
 from coord.board_service import read_board, write_board
+from coord.dao import _JSON_COLUMNS
+from coord.db import _ensure_schema
+from coord.drive_queue import DriveQueueSummary, entries_from_rows, summarize_drive_queue
 from coord.models import Assignment
 from coord.network import check_all, fetch_status
-from coord.openapi import build_spec, dataclass_schema, openapi_and_docs_routes
+from coord.openapi import (
+    build_spec,
+    dataclass_schema,
+    openapi_and_docs_routes,
+    sqlite_table_schema,
+)
 from coord.pipeline import PipelineView
-from coord.state import load_proposals
+from coord.state import list_drive_queue, load_proposals
 
 DASHBOARD_DIR = Path(__file__).parent
 # Built React webapp lives here after `npm run build` inside coord/dashboard/webapp/.
@@ -317,6 +326,35 @@ def openapi_spec() -> dict:
     components: dict = {}
     assignment_ref = dataclass_schema(Assignment, components)
     pipeline_view_ref = dataclass_schema(PipelineView, components)
+    # #2428 DQW-1: the drive-queue entry schema comes straight from the
+    # SQLite DDL, the same way coord/serve_app.py's `_board_response_schema`
+    # builds `BoardDriveQueueEntry` for `/board` — the wire schema *is* the
+    # DDL (coord/db.py), not a hand-maintained field list that can drift from
+    # it. `after_json` is JSON-encoded TEXT in SQLite, decoded to an array on
+    # the wire — the JSON columns come from `coord.dao._JSON_COLUMNS` itself
+    # (the same source `coord/serve_app.py`'s `_board_response_schema` derives
+    # its own `frozenset(_JSON_COLUMNS.get(table, ()))` from) rather than a
+    # second hand-maintained literal, so a future JSON column on `drive_queue`
+    # only needs updating in one place (#2096).
+    _schema_conn = sqlite3.connect(":memory:")
+    try:
+        _ensure_schema(_schema_conn)
+        components["BoardDriveQueueEntry"] = sqlite_table_schema(
+            _schema_conn,
+            "drive_queue",
+            json_columns=frozenset(_JSON_COLUMNS.get("drive_queue", ())),
+        )
+    finally:
+        _schema_conn.close()
+    drive_queue_entry_ref = {"$ref": "#/components/schemas/BoardDriveQueueEntry"}
+    drive_queue_summary_ref = dataclass_schema(DriveQueueSummary, components)
+    drive_queue_response = {
+        "type": "object",
+        "properties": {
+            "entries": {"type": "array", "items": drive_queue_entry_ref},
+            "summary": drive_queue_summary_ref,
+        },
+    }
     board_response = {
         "type": "object",
         "properties": {
@@ -372,6 +410,37 @@ def openapi_spec() -> dict:
                 "responses": {"200": {"description": "OK"}},
             }
         },
+        "/api/drive-queue": {
+            "get": {
+                "summary": (
+                    "The `coord drive` work queue in run order, plus a "
+                    "server-computed pending/running/waiting/eligible/"
+                    "blocked/held summary (#2428 DQW-1)"
+                ),
+                "parameters": [
+                    {
+                        "name": "repo",
+                        "in": "query",
+                        "required": False,
+                        "schema": {"type": "string"},
+                        "description": (
+                            "Restrict `entries` to one repo. `summary` is always "
+                            "computed over the FULL queue, whatever `repo` is set "
+                            "to — `fleet_held`/`level` are fleet-wide facts (a "
+                            "fleet-scoped fired deploy gate anywhere stops the "
+                            "whole tick), so narrowing the summary to one repo "
+                            "could misreport it as clear."
+                        ),
+                    }
+                ],
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "content": {"application/json": {"schema": drive_queue_response}},
+                    }
+                },
+            }
+        },
         "/api/approve": {
             "post": {
                 "summary": "Dispatch one or more proposals by id",
@@ -624,6 +693,19 @@ def build_app(
             return
         write_board(board)
 
+    def _read_drive_queue() -> list[dict]:
+        """Every drive-queue row — seeded fixture or the daemon/local DB (#2428).
+
+        ALWAYS the full, unfiltered queue, same as ``_read_board()`` for the
+        board: ``?repo=`` is applied by ``api_drive_queue`` itself, to the
+        response's ``entries`` list only, AFTER this. That is deliberate, not
+        an oversight — see ``api_drive_queue``'s docstring for why the
+        aggregate summary must never be computed over a repo-filtered subset.
+        """
+        if _fixture is not None:
+            return _fixture.drive_queue()
+        return list_drive_queue()
+
     # ── Real-time event bus ────────────────────────────────────────────────
     event_source = EventSource()
 
@@ -902,6 +984,46 @@ def build_app(
         from dataclasses import asdict
         return JSONResponse([asdict(p) for p in proposals])
 
+    async def api_drive_queue(request: Request) -> JSONResponse:
+        """GET /api/drive-queue?repo= — the operator-declared `coord drive`
+        work queue, plus a server-computed aggregate summary (#2428 DQW-1).
+
+        Mirrors ``api_board``'s shape via ``_read_drive_queue()`` (the fixture-
+        vs-live indirection every other handler in this file goes through —
+        see ``_read_board()``), which resolves daemon-vs-local exactly like
+        ``coord drive-queue list`` itself does. ``entries`` is the raw row
+        list — optionally narrowed to ``?repo=`` — verbatim: same shape as the
+        daemon's own ``GET /drive-queue`` and ``/board``'s ``drive_queue``
+        field, no reshaping, no new fields.
+
+        ``summary`` (:func:`coord.drive_queue.summarize_drive_queue`) is
+        DELIBERATELY computed over the FULL, unfiltered queue, never the
+        ``?repo=``-narrowed one — even though only ``entries`` respects the
+        filter. This mirrors the summary's one existing call site
+        (``tui/src/app/mod.rs``'s ``summarize_drive_queue(&self.data.drive_queue)``,
+        always the whole board queue) and is required for correctness, not
+        just consistency: ``fleet_held``/``level == "held"`` is documented as
+        "a non-zero fleet-scoped fired gate stops the tick from launching
+        ANYTHING, whatever repo it's in", and ``summarize_drive_queue``'s
+        ``after=`` satisfaction check (``_after_satisfied``) treats a pre-req
+        absent from the entries it's given as already satisfied ("it may have
+        landed long ago"). Summarizing only the filtered subset would let
+        ``GET /api/drive-queue?repo=web`` report ``level: "normal"`` while a
+        DIFFERENT repo's entry actually holds the whole fleet queue, and could
+        count a cross-repo ``after=`` dependency as eligible when the real
+        prerequisite is still pending, just filtered out of view. So the
+        Queue panel sidebar's pending/running/waiting/eligible/blocked/held
+        counts are always fleet-wide, exactly like the TUI's; only the visible
+        row list narrows with ``?repo=``.
+        """
+        from dataclasses import asdict
+
+        repo = request.query_params.get("repo") or None
+        rows = _read_drive_queue()
+        summary = summarize_drive_queue(entries_from_rows(rows))
+        entries = [r for r in rows if r.get("repo_name") == repo] if repo else rows
+        return JSONResponse({"entries": entries, "summary": asdict(summary)})
+
     async def api_approve(request: Request) -> JSONResponse:
         from coord.dispatch import dispatch, post_briefing, compute_do_not_touch
         from coord.state import (
@@ -1821,6 +1943,7 @@ def build_app(
         Route("/api/machines", api_machines, methods=["GET"]),
         Route("/api/sessions", api_sessions, methods=["GET"]),
         Route("/api/proposals", api_proposals, methods=["GET"]),
+        Route("/api/drive-queue", api_drive_queue, methods=["GET"]),
         Route("/api/approve", api_approve, methods=["POST"]),
         Route("/api/reject", api_reject, methods=["POST"]),
         Route("/api/diff/{id}", api_diff, methods=["GET"]),

{code_coordinator-0.5.170 → code_coordinator-0.5.171}/coord/dashboard/webapp/src/api/generated.ts

@@ -176,3 +176,40 @@ export interface Assignment {
   stop_reason: string | null
   dispatched_by_assignment_id: string | null
 }
+
+export interface BoardDriveQueueEntry {
+  id: number | null
+  repo_name: string
+  issue_number: number
+  position: number
+  machine: string | null
+  after_json: string[]
+  state: string
+  attempts: number
+  deferrals: number
+  last_reason: string
+  reason_at: number | null
+  session_name: string | null
+  launched_at: number | null
+  enqueued_at: number
+  hold_after: number
+  hold_reason: string
+  resume_when: string
+  hold_state: string
+  hold_probes: number
+  launch_host: string
+  hold_scope: string
+  resumes: number
+  retry_backoff_at: number | null
+}
+
+export interface DriveQueueSummary {
+  level: string
+  pending: number
+  running: number
+  waiting: number
+  blocked: number
+  eligible: number
+  held: number
+  fleet_held: number
+}

{code_coordinator-0.5.170 → code_coordinator-0.5.171}/coord/drive_queue.py

@@ -722,6 +722,130 @@ def entries_from_rows(rows: Iterable[Mapping[str, Any]]) -> list[QueueEntry]:
     )
 
 
+# ── aggregate summary (#2428 DQW-1) ───────────────────────────────────────────
+#
+# Ported field-for-field from `tui/src/app/drive_queue.rs`'s
+# `summarize_drive_queue`/`DriveQueueSummary` — see that module's own comments
+# for the #2186 incident behind "blocked outranks a fleet-held gate, which
+# outranks a stall" and for why `fleet_held` (not `held`) is what actually
+# stops the queue. Kept here, next to `entries_from_rows`, rather than in
+# `coord/dashboard/server.py`, so any future consumer (a CLI summary, another
+# server) gets the exact same counts without re-deriving them.
+
+
+def _entry_is_pending(entry: QueueEntry) -> bool:
+    """Rows that still have work ahead — `done` entries are history."""
+    return entry.state != STATE_DONE
+
+
+def _entry_is_holding(entry: QueueEntry) -> bool:
+    """Is this row's OWN deploy gate currently fired? Scope-agnostic."""
+    return entry.hold_state == HOLD_FIRED
+
+
+def _entry_stops_fleet(entry: QueueEntry) -> bool:
+    """Does this row's fired gate stop the WHOLE queue (#2186)?"""
+    return _entry_is_holding(entry) and entry.hold_scope == HOLD_SCOPE_FLEET
+
+
+def _after_satisfied(entry: QueueEntry, all_entries: Sequence[QueueEntry]) -> bool:
+    """Is *entry*'s `after=` list satisfied by the queue it sits in?
+
+    Same conservative, local read as the Rust original: a pre-req not
+    present in *all_entries* at all is treated as satisfied (it may have
+    landed long ago); a pre-req whose OWN gate has fired is unsatisfied even
+    though its row has by then reconciled to `done`.
+    """
+    for key in entry.after:
+        unsatisfied = any(
+            other.key == key
+            and (other.state != STATE_DONE or _entry_is_holding(other))
+            for other in all_entries
+        )
+        if unsatisfied:
+            return False
+    return True
+
+
+@dataclass(frozen=True)
+class DriveQueueSummary:
+    """Aggregate reading over a whole (or `?repo=`-filtered) queue read.
+
+    ``level`` is the same ascending-severity rank
+    `tui/src/app/drive_queue.rs::DriveQueueLevel` computes — `"empty"` <
+    `"normal"` < `"stalled"` < `"held"` < `"blocked"` — so a client can badge
+    the panel sidebar without re-deriving the ranking rule.
+    """
+
+    level: str = "empty"
+    # #2428: total non-`done` rows — the Rust original never materializes
+    # this as a struct field (it's implicit in the loop's filter), but a web
+    # sidebar wants a single "N pending" headline as much as it wants the
+    # breakdown, so it is added here rather than left for the client to sum.
+    pending: int = 0
+    running: int = 0
+    waiting: int = 0
+    blocked: int = 0
+    # Waiting rows whose in-queue pre-reqs are all satisfied — rows a tick
+    # could plausibly pick up next. Zero-with-waiting-rows is the stall.
+    eligible: int = 0
+    # Rows whose OWN deploy gate has fired, any scope — purely informational.
+    held: int = 0
+    # Rows whose FLEET-scoped deploy gate has fired — non-zero means the tick
+    # will launch nothing at all, whatever `eligible` says.
+    fleet_held: int = 0
+
+
+def summarize_drive_queue(entries: Sequence[QueueEntry]) -> DriveQueueSummary:
+    """Summarise *entries* — pure, no clock, no DB. See :class:`DriveQueueSummary`."""
+    pending = sum(1 for e in entries if _entry_is_pending(e))
+    held = sum(1 for e in entries if _entry_is_holding(e))
+    fleet_held = sum(1 for e in entries if _entry_stops_fleet(e))
+    running = waiting = blocked = eligible = 0
+    for e in entries:
+        if not _entry_is_pending(e):
+            continue
+        if e.state == STATE_RUNNING:
+            running += 1
+        elif e.state == STATE_BLOCKED:
+            blocked += 1
+        elif e.state == STATE_WAITING:
+            waiting += 1
+            if _after_satisfied(e, entries):
+                eligible += 1
+        # An unrecognised state from a newer daemon: counted in `pending`
+        # above (it is not `done`) but never as waiting/eligible/running/
+        # blocked, so it can neither trigger nor mask a stall.
+
+    if blocked > 0:
+        # Blocked outranks stalled — a hard stop is worse news than a queue
+        # that is merely waiting for capacity.
+        level = "blocked"
+    elif fleet_held > 0:
+        # #1757/#2186: a FLEET-scoped fired gate outranks a stall, even a
+        # real one — "3 waiting, none eligible" is a symptom here, and "you
+        # have a deploy to do" is the cause.
+        level = "held"
+    elif waiting > 0 and eligible == 0 and running == 0:
+        # Nothing running AND nothing that could start.
+        level = "stalled"
+    elif running > 0 or waiting > 0:
+        level = "normal"
+    else:
+        level = "empty"
+
+    return DriveQueueSummary(
+        level=level,
+        pending=pending,
+        running=running,
+        waiting=waiting,
+        blocked=blocked,
+        eligible=eligible,
+        held=held,
+        fleet_held=fleet_held,
+    )
+
+
 # ── the board projection ─────────────────────────────────────────────────────
 
 

{code_coordinator-0.5.170 → code_coordinator-0.5.171}/coord/openapi.py

@@ -165,6 +165,8 @@ _JSON_COLUMN_SHAPES: dict[tuple[str, str], dict[str, Any]] = {
     ("issues", "labels"): {"type": "array", "items": {"type": "string"}},
     ("machines", "capabilities"): {"type": "array", "items": {"type": "string"}},
     ("machines", "repos"): {"type": "array", "items": {"type": "string"}},
+    # #2428: the drive queue's pre-req list — ["repo#N", ...] on the wire.
+    ("drive_queue", "after_json"): {"type": "array", "items": {"type": "string"}},
 }
 
 _SQLITE_AFFINITY_TO_SCHEMA: dict[str, dict[str, Any]] = {

{code_coordinator-0.5.170 → code_coordinator-0.5.171}/tests/fixtures/board-pipeline-basic.json

@@ -218,6 +218,58 @@
     }
   ],
 
+  "drive_queue": [
+    {
+      "repo_name": "claude-coordinator",
+      "issue_number": 4201,
+      "position": 0,
+      "machine": "precision",
+      "after_json": [],
+      "state": "running",
+      "attempts": 1,
+      "deferrals": 0,
+      "last_reason": "",
+      "session_name": "drive-cc-4201",
+      "hold_after": false,
+      "hold_reason": "",
+      "hold_state": "",
+      "hold_scope": "entry",
+      "resumes": 0
+    },
+    {
+      "repo_name": "claude-coordinator",
+      "issue_number": 4202,
+      "position": 1,
+      "machine": "",
+      "after_json": ["claude-coordinator#4201"],
+      "state": "waiting",
+      "attempts": 0,
+      "deferrals": 1,
+      "last_reason": "waiting on claude-coordinator#4201",
+      "hold_after": false,
+      "hold_reason": "",
+      "hold_state": "",
+      "hold_scope": "entry",
+      "resumes": 0
+    },
+    {
+      "repo_name": "quadraui",
+      "issue_number": 88,
+      "position": 0,
+      "machine": "",
+      "after_json": [],
+      "state": "waiting",
+      "attempts": 0,
+      "deferrals": 0,
+      "last_reason": "",
+      "hold_after": true,
+      "hold_reason": "deploy gate: schema migration",
+      "hold_state": "fired",
+      "hold_scope": "fleet",
+      "resumes": 0
+    }
+  ],
+
   "proposals": [
     {
       "id": 1,

{code_coordinator-0.5.170 → code_coordinator-0.5.171}/tests/test_dashboard.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import asyncio
+import sqlite3
 import time
 from pathlib import Path
 from unittest.mock import patch, MagicMock
@@ -49,6 +50,28 @@ def _client(tmp_path: Path | None = None) -> TestClient:
     return TestClient(build_app(_config()))
 
 
+@pytest.fixture
+def rw_db(tmp_path: Path):
+    """A thread-safe (file-backed, ``check_same_thread=False``) coord.db override.
+
+    The autouse ``coord_db`` fixture (tests/conftest.py) installs a
+    thread-bound ``:memory:`` connection, which ``TestClient`` (it runs the
+    async handler on a worker thread) can't touch — mirrors
+    ``tests/test_serve.py``'s fixture of the same name, for the same reason:
+    production ``get_connection`` already uses ``check_same_thread=False``
+    (a file DB), so this just matches production for a route that actually
+    reads through it instead of a mocked seam.
+    """
+    from coord import db
+    from coord.db import _ensure_schema
+
+    conn = sqlite3.connect(str(tmp_path / "rw.db"), check_same_thread=False)
+    conn.row_factory = sqlite3.Row
+    _ensure_schema(conn)
+    db.override_connection(conn)
+    yield conn
+
+
 class TestIndexPage:
     def test_serves_html(self) -> None:
         client = _client()
@@ -405,6 +428,122 @@ class TestProposalsAPI:
         assert r.json() == []
 
 
+class TestDriveQueueAPI:
+    """GET /api/drive-queue (#2428 DQW-1).
+
+    Unlike `TestBoardAPI`/`TestProposalsAPI` above, this reads straight
+    through `coord.state.list_drive_queue` -> the local DB (the `coord_db`
+    autouse fixture in conftest.py gives every test a fresh in-memory
+    SQLite, and `_no_board_service` guarantees `resolve_board_service()` is
+    unset) rather than mocking the read seam — the same "seeded DB -> GET ->
+    assert shape" bar every other `/api/*` route in this file meets.
+    """
+
+    def test_empty_queue(self, rw_db) -> None:
+        client = _client()
+        r = client.get("/api/drive-queue")
+        assert r.status_code == 200
+        data = r.json()
+        assert data == {
+            "entries": [],
+            "summary": {
+                "level": "empty",
+                "pending": 0,
+                "running": 0,
+                "waiting": 0,
+                "blocked": 0,
+                "eligible": 0,
+                "held": 0,
+                "fleet_held": 0,
+            },
+        }
+
+    def test_seeded_db_returns_entries_and_summary(self, rw_db) -> None:
+        from coord.state import (
+            _enqueue_drive_queue_local,
+            _update_drive_queue_entry_local,
+        )
+
+        _enqueue_drive_queue_local("api", 1)
+        _enqueue_drive_queue_local("api", 2, after=["api#1"])
+        _update_drive_queue_entry_local("api", 1, state="running")
+        _enqueue_drive_queue_local("web", 9)
+        _update_drive_queue_entry_local(
+            "web", 9, state="blocked", last_reason="merge conflict"
+        )
+
+        client = _client()
+        r = client.get("/api/drive-queue")
+        assert r.status_code == 200
+        data = r.json()
+
+        entries = data["entries"]
+        assert len(entries) == 3
+        by_key = {(e["repo_name"], e["issue_number"]): e for e in entries}
+        assert by_key[("api", 1)]["state"] == "running"
+        assert by_key[("api", 2)]["state"] == "waiting"
+        assert by_key[("api", 2)]["after_json"] == ["api#1"]
+        assert by_key[("web", 9)]["state"] == "blocked"
+        assert by_key[("web", 9)]["last_reason"] == "merge conflict"
+        # #2428: raw entries carry the same columns the daemon's own
+        # GET /drive-queue and /board's drive_queue field already do — no
+        # reshaping, no invented fields.
+        assert {
+            "repo_name", "issue_number", "position", "state", "machine",
+            "attempts", "after_json", "hold_state", "hold_scope", "hold_after",
+            "last_reason", "resumes", "deferrals",
+        } <= set(by_key[("api", 1)])
+
+        summary = data["summary"]
+        assert summary["running"] == 1
+        assert summary["blocked"] == 1
+        # api#2's after=["api#1"] is unsatisfied — api#1 is `running`, not
+        # `done` — so it counts as waiting but NOT eligible.
+        assert summary["waiting"] == 1
+        assert summary["eligible"] == 0
+        assert summary["pending"] == 3
+        # blocked outranks everything else in the level ranking.
+        assert summary["level"] == "blocked"
+
+    def test_repo_filter_scopes_entries_but_not_the_summary(self, rw_db) -> None:
+        """``?repo=`` narrows ``entries``; ``summary`` stays fleet-wide.
+
+        Non-blocking review finding on #2428: `fleet_held`/`level` are
+        documented (both in `tui/src/app/drive_queue.rs` and the Python port)
+        as fleet-wide facts — "non-zero means the tick launches nothing at
+        all" — and the summary's `_after_satisfied` treats a pre-req absent
+        from the entries it's given as satisfied. Summarizing only the
+        `?repo=`-filtered subset would let `GET /api/drive-queue?repo=api`
+        report `level: "normal"` while a DIFFERENT repo's fired fleet gate is
+        actually holding the whole queue. So `summary` must always reflect
+        the full queue, exactly like `entries_from_rows`' one Rust call site
+        always passes the unfiltered board queue.
+        """
+        from coord.state import _enqueue_drive_queue_local, _update_drive_queue_entry_local
+
+        _enqueue_drive_queue_local("api", 1)
+        _enqueue_drive_queue_local(
+            "web", 2, hold_after=True, hold_reason="deploy gate", hold_scope="fleet",
+        )
+        _update_drive_queue_entry_local("web", 2, hold_state="fired")
+
+        client = _client()
+        r = client.get("/api/drive-queue", params={"repo": "api"})
+        assert r.status_code == 200
+        data = r.json()
+        # entries: narrowed to the requested repo.
+        assert [e["repo_name"] for e in data["entries"]] == ["api"]
+        # summary: unaffected by the filter — the "web" entry's fleet-scoped
+        # fired gate is still visible even though its row is filtered out of
+        # `entries`.
+        unfiltered = client.get("/api/drive-queue").json()
+        assert data["summary"] == unfiltered["summary"]
+        assert data["summary"]["pending"] == 2
+        assert data["summary"]["fleet_held"] == 1
+        assert data["summary"]["held"] == 1
+        assert data["summary"]["level"] == "held"
+
+
 class TestApproveAPI:
     # #749: board_service.read_board() tries load_board() before build_board()
     # — mock both so the real load_board() (which needs a live connection on