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

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

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

@@ -125,6 +125,7 @@ coord/reports.py
 coord/revalidate.py
 coord/review.py
 coord/scorecard.py
+coord/self_health.py
 coord/serve_app.py
 coord/smoke.py
 coord/spend_ceiling.py
@@ -492,6 +493,7 @@ tests/test_cli_chat_continue.py
 tests/test_cli_decide.py
 tests/test_cli_diagnose_config_provenance.py
 tests/test_cli_diagnose_graph.py
+tests/test_cli_diagnose_self.py
 tests/test_cli_doctor.py
 tests/test_cli_doctor_config_free_1801.py
 tests/test_cli_doctor_config_mismatch_1712.py
@@ -726,6 +728,7 @@ tests/test_review_verdict_relay.py
 tests/test_review_zero_commits.py
 tests/test_scoped_review_wiring.py
 tests/test_scorecard.py
+tests/test_self_health.py
 tests/test_serve.py
 tests/test_serve_app_board_trim.py
 tests/test_session.py

{code_coordinator-0.5.169 → code_coordinator-0.5.171}/code_coordinator.egg-info/scm_file_list.json

@@ -306,6 +306,7 @@
     "coord/revalidate.py",
     "coord/review.py",
     "coord/scorecard.py",
+    "coord/self_health.py",
     "coord/serve_app.py",
     "coord/skills/coord-dispatch-verbs/SKILL.md",
     "coord/skills/drive-queue-preflight/SKILL.md",
@@ -538,6 +539,7 @@
     "tests/test_cli_decide.py",
     "tests/test_cli_diagnose_config_provenance.py",
     "tests/test_cli_diagnose_graph.py",
+    "tests/test_cli_diagnose_self.py",
     "tests/test_cli_doctor.py",
     "tests/test_cli_doctor_config_free_1801.py",
     "tests/test_cli_doctor_config_mismatch_1712.py",
@@ -772,6 +774,7 @@
     "tests/test_review_zero_commits.py",
     "tests/test_scoped_review_wiring.py",
     "tests/test_scorecard.py",
+    "tests/test_self_health.py",
     "tests/test_serve.py",
     "tests/test_serve_app_board_trim.py",
     "tests/test_session.py",

{code_coordinator-0.5.169 → code_coordinator-0.5.171}/code_coordinator.egg-info/scm_version.json

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

{code_coordinator-0.5.169 → code_coordinator-0.5.171}/coord/commands/status.py

@@ -1561,6 +1561,30 @@ def _diagnose_via_daemon(svc, params: dict) -> None:
         "daemon host / operator box.  Read-only, no network required."
     ),
 )
+@click.option(
+    "--self",
+    "self_check",
+    is_flag=True,
+    help=(
+        "#2436: report whether THIS coordinator process's own editable "
+        "`coord` install — wherever `coord.__file__` actually resolves, "
+        "never an assumed ~/src/<name> path — is behind "
+        "origin/<default_branch>.  A merged coord/** fix (other than "
+        "agent.py/serve_app.py) is silently inert here until this checkout "
+        "is pulled (docs/OPERATING_GOTCHAS.md #1).  Fetches from origin "
+        "unless --no-fetch is passed."
+    ),
+)
+@click.option(
+    "--no-fetch",
+    "self_no_fetch",
+    is_flag=True,
+    help=(
+        "With --self, skip the `git fetch` and compare HEAD against "
+        "whatever origin/<default_branch> the last fetch already left "
+        "behind."
+    ),
+)
 
 
 @_CONFIG_OPTION
@@ -1575,6 +1599,8 @@ def diagnose(
     orphan_worktrees: bool = False,
     graph_health: bool = False,
     config_provenance_check: bool = False,
+    self_check: bool = False,
+    self_no_fetch: bool = False,
 ) -> None:
     """Per-stage doctor — diagnose, best-effort recover, optional reset."""
     # ── graphify graph freshness sweep (read-only) ───────────────────────────
@@ -1587,6 +1613,11 @@ def diagnose(
         _diagnose_config_provenance()
         return
 
+    # ── #2436: THIS process's own editable coord install freshness ──────────
+    if self_check:
+        _diagnose_self(fetch=not self_no_fetch)
+        return
+
     # ── #618: --orphan-worktrees fleet sweep ─────────────────────────────────
     if orphan_worktrees:
         _diagnose_orphan_worktrees(config_path, dry_run=dry_run)
@@ -1762,6 +1793,40 @@ def _diagnose_config_provenance() -> None:
     click.echo(summary_line(prov))
 
 
+def _diagnose_self(*, fetch: bool) -> None:
+    """Report whether THIS process's own editable ``coord`` install is
+    behind origin (#2436).
+
+    Read-only, local-machine only — same family as ``--graph``/
+    ``--config-provenance``/``--orphan-worktrees``. Answers the question
+    ``docs/OPERATING_GOTCHAS.md`` #1 names but nothing previously checked:
+    "did the `git pull` this editable install depends on for `coord/**`
+    fixes to go live actually happen?" A coordinator host running last
+    week's code gives zero signal of it otherwise — every board row and
+    escalation reads exactly as if a merged fix were still unfixed (the
+    #2286/#2426 incident this closes).
+
+    Locates the install via ``coord.self_health.default_install_path()`` —
+    ``Path(coord.__file__).resolve().parents[1]``, never an assumed
+    ``~/src/<name>`` path (the doc's own assumption had drifted from reality
+    on the host that hit this).  Each coordinator/drive-queue host has its
+    own independent editable checkout that can drift independently, so this
+    is deliberately per-machine, run where it's invoked, exactly like
+    ``--graph``.
+    """
+    from coord.self_health import (  # noqa: PLC0415
+        default_install_path,
+        format_status_lines,
+        self_freshness,
+        summary_line as self_summary_line,
+    )
+
+    st = self_freshness(install_path=default_install_path(), fetch=fetch)
+    for line in format_status_lines(st):
+        click.echo(f"  {line}")
+    click.echo(self_summary_line(st))
+
+
 def _diagnose_orphan_worktrees(config_path: Path, *, dry_run: bool) -> None:
     """#618: local fleet sweep — find and prune orphaned coordinator worktrees.
 

{code_coordinator-0.5.169 → 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.169 → 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.169 → 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.169 → 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.169 → 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]] = {