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

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

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

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

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

{code_coordinator-0.5.170 → code_coordinator-0.5.172}/coord/client.py

@@ -510,6 +510,36 @@ def fetch_drive_queue_entry(
     return None
 
 
+def post_drive_queue(
+    svc: ServiceConfig,
+    action: str,
+    *,
+    timeout: float = _WRITE_TIMEOUT,
+    **fields,
+) -> dict:
+    """POST /drive-queue {action, ...fields} — the write side of
+    :func:`fetch_drive_queue` (#2429 DQW-2).
+
+    *fields* are forwarded verbatim as sibling keys next to ``action``,
+    e.g. ``post_drive_queue(svc, "move", repo_name="api", issue_number=1,
+    to_position=0)`` or ``post_drive_queue(svc, "update", repo_name="api",
+    issue_number=1, fields={"hold_state": "released"})`` — same body shape
+    ``coord/serve_app.py``'s ``post_drive_queue`` route (``action`` in
+    ``{enqueue, dequeue, update, move}``) already accepts, so a caller just
+    passes through whatever ``coord/dashboard/server.py``'s
+    ``/api/drive-queue/action`` handler decided to send. Returns the
+    decoded per-action response (``{"moved": bool}`` / ``{"deleted": bool}``
+    / ``{"updated": bool}`` / ``{"entry_id": int}``).
+
+    Unlike :func:`fetch_drive_queue` this is NOT fail-soft: it raises
+    ``httpx.HTTPError`` on transport/HTTP failure, the same posture as
+    :func:`post_cordon`/:func:`post_pause`/:func:`post_quiet_hours` — a
+    move/remove/unblock/resume that silently failed to reach the daemon
+    would leave the operator believing the queue changed when it didn't.
+    """
+    return post_record(svc, "/drive-queue", {"action": action, **fields}, timeout=timeout)
+
+
 def fetch_gate_a_approval(
     svc: ServiceConfig,
     repo_name: str,

{code_coordinator-0.5.170 → code_coordinator-0.5.172}/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.172}/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,25 @@ 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 (
+    HOLD_FIRED,
+    STATE_BLOCKED,
+    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 +332,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 +416,82 @@ 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/drive-queue/action": {
+            "post": {
+                "summary": (
+                    "move/remove/unblock/resume a `coord drive` queue row "
+                    "(#2429 DQW-2)"
+                ),
+                "requestBody": {
+                    "required": True,
+                    "content": {
+                        "application/json": {
+                            "schema": {
+                                "type": "object",
+                                "properties": {
+                                    "repo_name": {"type": "string"},
+                                    "issue_number": {"type": "integer"},
+                                    "action": {
+                                        "type": "string",
+                                        "enum": ["move", "remove", "unblock", "resume"],
+                                    },
+                                    "to_position": {
+                                        "type": "integer",
+                                        "description": "Required when action == 'move'.",
+                                    },
+                                },
+                                "required": ["repo_name", "issue_number", "action"],
+                            }
+                        }
+                    },
+                },
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "content": {"application/json": {"schema": ok_response}},
+                    },
+                    "400": {
+                        "description": (
+                            "Missing/unknown field, missing to_position for "
+                            "'move', 'unblock' on a non-blocked row, or "
+                            "'resume' on a row whose gate hasn't fired"
+                        )
+                    },
+                    "404": {"description": "drive-queue entry not found"},
+                },
+            }
+        },
         "/api/approve": {
             "post": {
                 "summary": "Dispatch one or more proposals by id",
@@ -624,6 +744,85 @@ 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()
+
+    def _drive_queue_write(action: str, **fields) -> dict:
+        """POST /drive-queue's ``{action, ...fields}`` shape (#2429 DQW-2).
+
+        Live mode only — callers check ``_fixture is not None`` themselves
+        (mirrors ``_write_board``, whose fixture no-op lives at the call
+        site in ``api_pipeline_action``, not inside ``_write_board`` itself).
+
+        Resolves daemon-vs-local by hand, the same decision
+        ``_read_board()``/``_write_board()`` make for the board, rather than
+        going through ``coord.state``'s own routed ``enqueue_drive_queue``/
+        ``dequeue_drive_queue``/``update_drive_queue_entry``/
+        ``move_drive_queue_entry`` wrappers — those already do this exact
+        dance internally, but routing here keeps the dashboard's thin-client
+        posture visible in this file instead of buried behind a
+        `coord.state` implementation detail.
+
+        Returns the daemon's per-action response dict verbatim
+        (``{"moved": bool}`` / ``{"deleted": bool}`` / ``{"updated": bool}``
+        / ``{"entry_id": int}``), whether it came from the wire or from the
+        matching local ``_*_local`` function directly — the same functions
+        ``coord/serve_app.py``'s own ``post_drive_queue`` route calls.
+        """
+        from coord import board_service
+
+        svc = board_service.resolve()
+        if svc is not None:
+            from coord.client import post_drive_queue
+
+            return post_drive_queue(svc, action, **fields)
+
+        from coord.state import (
+            _dequeue_drive_queue_local,
+            _enqueue_drive_queue_local,
+            _move_drive_queue_entry_local,
+            _update_drive_queue_entry_local,
+        )
+
+        if action == "dequeue":
+            return {
+                "deleted": _dequeue_drive_queue_local(
+                    fields["repo_name"], fields["issue_number"]
+                )
+            }
+        if action == "enqueue":
+            entry_id = _enqueue_drive_queue_local(
+                fields["repo_name"],
+                fields["issue_number"],
+                machine=fields.get("machine"),
+                after=fields.get("after") or [],
+                position=fields.get("position"),
+            )
+            return {"entry_id": entry_id}
+        if action == "update":
+            return {
+                "updated": _update_drive_queue_entry_local(
+                    fields["repo_name"], fields["issue_number"], **fields["fields"]
+                )
+            }
+        if action == "move":
+            return {
+                "moved": _move_drive_queue_entry_local(
+                    fields["repo_name"], fields["issue_number"], fields["to_position"]
+                )
+            }
+        raise ValueError(f"unknown drive-queue action: {action!r}")
+
     # ── Real-time event bus ────────────────────────────────────────────────
     event_source = EventSource()
 
@@ -902,6 +1101,190 @@ 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_drive_queue_action(request: Request) -> JSONResponse:
+        """POST /api/drive-queue/action — move/remove/unblock/resume a
+        `coord drive` queue row (#2429 DQW-2).
+
+        Body: ``{"repo_name": "...", "issue_number": N, "action": "move" |
+        "remove" | "unblock" | "resume", ...}``. Response:
+        ``{"ok": bool, "error"?: str}`` — the same envelope
+        ``api_pipeline_action`` uses, not a new one.
+
+        All four actions ride the daemon's already-implemented
+        ``POST /drive-queue`` ops (``coord/serve_app.py``'s
+        ``post_drive_queue``) via ``_drive_queue_write`` — no new
+        queue-mutation logic here, just routing plus the two client-side
+        guards the TUI already enforces (``tui/src/app/drive_queue.rs``'s
+        ``queue_unblock_selected``/``queue_resume_selected``):
+
+        * ``move`` -> ``{action: "move", to_position}`` -> daemon op ``move``.
+        * ``remove`` -> daemon op ``dequeue``.
+        * ``unblock`` -> dequeue then re-enqueue with the row's ``machine``
+          preserved and ``after`` DROPPED — the exact recipe
+          ``dispatch_drive_queue_unblock`` (and its Python precedent,
+          ``coord/commands/drive_queue.py``'s ``_requeue_command``) uses: an
+          unsatisfiable pre-req is one of the two things that blocks a row,
+          so re-adding with the same ``after`` would just re-block it.
+          Refused with 400 on anything but a ``state == "blocked"`` row.
+        * ``resume`` -> daemon op ``update`` with
+          ``fields={hold_state: "released", hold_probes: 0}``. Refused with
+          400 on a row whose gate hasn't fired (``hold_state != "fired"``).
+
+        In fixture mode (#1538) every one of these is **recorded, not
+        executed** — mirrors ``api_pipeline_action``'s ``_fixture_action``.
+        """
+        try:
+            body = await request.json()
+        except ValueError:
+            return JSONResponse({"error": "invalid JSON"}, status_code=400)
+
+        repo_name = body.get("repo_name")
+        issue_number = body.get("issue_number")
+        action = body.get("action")
+        if not repo_name or issue_number is None or not action:
+            return JSONResponse(
+                {"error": "repo_name, issue_number and action are required"},
+                status_code=400,
+            )
+        try:
+            issue_number = int(issue_number)
+        except (TypeError, ValueError):
+            return JSONResponse({"error": "issue_number must be an int"}, status_code=400)
+
+        if action not in ("move", "remove", "unblock", "resume"):
+            return JSONResponse({"error": f"unknown action: {action!r}"}, status_code=400)
+
+        to_position = None
+        if action == "move":
+            try:
+                to_position = int(body.get("to_position"))
+            except (TypeError, ValueError):
+                return JSONResponse(
+                    {"error": "to_position must be an int"}, status_code=400
+                )
+
+        rows = _fixture.drive_queue() if _fixture is not None else _read_drive_queue()
+        entry = next(
+            (
+                r for r in rows
+                if r.get("repo_name") == repo_name
+                and int(r.get("issue_number", -1)) == issue_number
+            ),
+            None,
+        )
+        if entry is None:
+            return JSONResponse({"error": "drive-queue entry not found"}, status_code=404)
+
+        if action == "unblock" and entry.get("state") != STATE_BLOCKED:
+            return JSONResponse(
+                {"ok": False, "error": "only a blocked entry can be unblocked"},
+                status_code=400,
+            )
+        if action == "resume" and entry.get("hold_state") != HOLD_FIRED:
+            return JSONResponse(
+                {
+                    "ok": False,
+                    "error": "only an entry whose deploy gate has fired can be resumed",
+                },
+                status_code=400,
+            )
+
+        if _fixture is not None:
+            _fixture.record("/api/drive-queue/action", body, action=action)
+            return JSONResponse({"ok": True})
+
+        try:
+            if action == "move":
+                result = _drive_queue_write(
+                    "move",
+                    repo_name=repo_name,
+                    issue_number=issue_number,
+                    to_position=to_position,
+                )
+                ok = bool(result.get("moved"))
+            elif action == "remove":
+                result = _drive_queue_write(
+                    "dequeue", repo_name=repo_name, issue_number=issue_number
+                )
+                ok = bool(result.get("deleted"))
+            elif action == "unblock":
+                dequeue_result = _drive_queue_write(
+                    "dequeue", repo_name=repo_name, issue_number=issue_number
+                )
+                if bool(dequeue_result.get("deleted")):
+                    enqueue_result = _drive_queue_write(
+                        "enqueue",
+                        repo_name=repo_name,
+                        issue_number=issue_number,
+                        machine=entry.get("machine"),
+                        after=[],
+                    )
+                    ok = enqueue_result.get("entry_id") is not None
+                else:
+                    # The guard read above (``_read_drive_queue()``) is not
+                    # atomic with this write: the row can be removed/changed
+                    # by a concurrent dequeue/resume/daemon tick between the
+                    # two. If there was nothing to dequeue, there is nothing
+                    # to re-enqueue either — doing so anyway would silently
+                    # resurrect a row someone else legitimately removed.
+                    ok = False
+            else:  # resume
+                result = _drive_queue_write(
+                    "update",
+                    repo_name=repo_name,
+                    issue_number=issue_number,
+                    fields={"hold_state": "released", "hold_probes": 0},
+                )
+                ok = bool(result.get("updated"))
+        except Exception as exc:  # noqa: BLE001
+            return JSONResponse({"ok": False, "error": str(exc)}, status_code=500)
+
+        if not ok:
+            return JSONResponse(
+                {"ok": False, "error": "drive-queue entry not found"}, status_code=404
+            )
+        return JSONResponse({"ok": True})
+
     async def api_approve(request: Request) -> JSONResponse:
         from coord.dispatch import dispatch, post_briefing, compute_do_not_touch
         from coord.state import (
@@ -1821,6 +2204,8 @@ 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/drive-queue/action", api_drive_queue_action, methods=["POST"]),
         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.172}/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
+}