code-coordinator 0.5.50__tar.gz → 0.5.51__tar.gz

{code_coordinator-0.5.50/code_coordinator.egg-info → code_coordinator-0.5.51}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.50",
+  "tag": "0.5.51",
   "distance": 0,
-  "node": "gca3ee22c5e4aae8d967745ca59a33f20268bac29",
+  "node": "g8bdeec98b4c80e1f4bce8254cebe773e20b83813",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-13"

{code_coordinator-0.5.50 → code_coordinator-0.5.51}/coord/commands/drive_queue.py

@@ -510,6 +510,79 @@ def _clear_queue_alert() -> None:
         pass
 
 
+# ── board-read retry (#2159) ─────────────────────────────────────────────────
+#
+# A transient SQLite "database is locked" / SQLITE_BUSY on the board read is
+# not evidence the board is broken — it is evidence something else (the
+# daemon's own tick loop, `coord notify`, the web dashboard, another machine's
+# drive-queue tick) was mid-write on the same DB at the exact instant this
+# tick asked to read it. The read is idempotent — nothing has been decided
+# yet — so retrying it a few times over a couple of seconds is strictly safer
+# than the alternative: aborting the whole tick and leaving
+# `coord-drive-queue.service` sitting `failed` over a one-off, millisecond-
+# wide race (2026-08-12, dellserver, one tick in a 14-hour window).
+#
+# `coord.db._open` already sets `PRAGMA busy_timeout=5000` on the connection
+# the local (daemon-host) board read goes through, so SQLite itself already
+# retries internally for up to 5s before ever raising — this loop is the
+# belt-and-braces layer above that: it also covers a thin client's board read
+# (an HTTP round trip to the daemon, which cannot be taught a SQLite pragma)
+# and the case where 5s of internal retry still wasn't enough. Any OTHER read
+# failure — the daemon is genuinely unreachable, a malformed payload, a real
+# non-transient error — does not match `_is_db_locked_error` and is re-raised
+# on the FIRST attempt: retrying those would only delay the fail-closed abort
+# this module's docstring requires.
+_BOARD_READ_RETRY_ATTEMPTS = 3
+_BOARD_READ_RETRY_BACKOFF_SECONDS = (0.5, 1.0)  # 2 sleeps across 3 attempts, ~2s total
+
+
+def _is_db_locked_error(exc: BaseException) -> bool:
+    """``True`` for the transient "database is locked" / SQLITE_BUSY class.
+
+    Matched on the exception's message rather than restricted to
+    ``sqlite3.OperationalError``: a thin client's board read goes through
+    ``httpx`` against the daemon's ``GET /board``, so a locked DB on the
+    daemon's end can surface here wrapped in whatever exception carries the
+    daemon's error detail, not necessarily a local ``sqlite3`` exception.
+    Every other read failure lacks this text and is unaffected.
+    """
+    return "database is locked" in str(exc).lower() or "sqlite_busy" in str(exc).lower()
+
+
+def _fetch_board_view_with_retry() -> BoardView:
+    """:func:`_fetch_board_view`, with a bounded retry for lock contention.
+
+    Up to :data:`_BOARD_READ_RETRY_ATTEMPTS` reads, backing off
+    :data:`_BOARD_READ_RETRY_BACKOFF_SECONDS` between them — but ONLY while
+    the failure matches :func:`_is_db_locked_error`; anything else is
+    re-raised immediately so the caller's existing fail-closed abort is
+    unchanged. Logs once, at the tick level, when a retry actually recovered
+    the read, so the contention stays visible rather than silently smoothed
+    over — never once when the very first attempt already succeeded.
+    """
+    last_exc: Exception | None = None
+    for attempt in range(_BOARD_READ_RETRY_ATTEMPTS):
+        try:
+            board = _fetch_board_view()
+        except Exception as exc:  # noqa: BLE001 — re-raised below when not retryable
+            if not _is_db_locked_error(exc) or attempt == _BOARD_READ_RETRY_ATTEMPTS - 1:
+                raise
+            last_exc = exc
+            time.sleep(
+                _BOARD_READ_RETRY_BACKOFF_SECONDS[
+                    min(attempt, len(_BOARD_READ_RETRY_BACKOFF_SECONDS) - 1)
+                ]
+            )
+            continue
+        if last_exc is not None:
+            click.echo(
+                f"board read hit lock contention and recovered after {attempt} "
+                f"retry(ies) (last error: {last_exc})"
+            )
+        return board
+    raise AssertionError("unreachable — the loop above always returns or raises")
+
+
 # ── tick ─────────────────────────────────────────────────────────────────────
 
 
@@ -1035,7 +1108,7 @@ def drive_queue_tick(
         # "we do not know what is running", and launching on that assumption is
         # how a sequential batch becomes concurrent on the fleet.
         try:
-            board = _fetch_board_view()
+            board = _fetch_board_view_with_retry()
         except Exception as exc:  # noqa: BLE001 — every fetch failure is fatal here
             raise click.ClickException(
                 f"could not read the board — aborting without launching anything: {exc}"

{code_coordinator-0.5.50 → code_coordinator-0.5.51}/coord/dao.py

@@ -260,6 +260,15 @@ class SqliteStore:
         conn = sqlite3.connect(uri, uri=True, check_same_thread=False)
         conn.row_factory = sqlite3.Row
         conn.execute("PRAGMA query_only=ON")
+        # #2159: without a busy_timeout SQLite fails a locked read INSTANTLY
+        # (the default is 0ms) instead of waiting out a writer's momentary
+        # hold — this is the daemon's `/board` read path, hit by every thin
+        # client's `coord drive-queue tick`, `coord notify`, and the web
+        # dashboard, so it is also the connection most exposed to lock
+        # contention scaling with the fleet. Same value as the writer
+        # connection's own `busy_timeout` (`coord.db._open`), so a read-only
+        # request waits out a writer exactly as long as another writer would.
+        conn.execute("PRAGMA busy_timeout=5000")
         return conn
 
     # ── internal builders (take an open connection) ────────────────────────────

{code_coordinator-0.5.50 → code_coordinator-0.5.51}/tests/test_cli_drive_queue.py

@@ -1378,6 +1378,79 @@ def test_an_unreadable_board_aborts_without_launching(
     assert state._list_drive_queue_local() == before
 
 
+# ── #2159: a transient board-read lock retries instead of failing the tick ──
+
+
+def test_a_transient_locked_board_read_retries_and_the_tick_still_launches(
+    cli, seed, launches, monkeypatch
+):
+    """Two `database is locked` reads followed by a real one must not abort
+    the tick — the read is idempotent, so the bounded retry recovers it and
+    the tick completes exactly as an unretried, first-try success would."""
+    import sqlite3
+
+    from coord.commands import drive_queue as drive_queue_cmd
+
+    seed(issues={1650: "open"})
+    cli("add", REPO, "1650", "--machine", "dellserver")
+
+    real_fetch = drive_queue_cmd._fetch_board_view
+    calls = {"n": 0}
+
+    def flaky() -> drive_queue_cmd.BoardView:
+        calls["n"] += 1
+        if calls["n"] <= 2:
+            raise sqlite3.OperationalError("database is locked")
+        return real_fetch()
+
+    monkeypatch.setattr(drive_queue_cmd, "_fetch_board_view", flaky)
+    slept: list[float] = []
+    monkeypatch.setattr(drive_queue_cmd.time, "sleep", slept.append)
+
+    result = cli("tick")
+    assert result.exit_code == 0, result.output
+    assert calls["n"] == 3
+    assert len(slept) == 2  # backed off between attempts 1→2 and 2→3
+    assert "recovered after 2 retry" in result.output
+
+    # The tick did real work — not a silent no-op — exactly like an unretried
+    # success would.
+    assert "launched" in result.output
+    assert launches and "1650" in " ".join(launches[0])
+    assert queued(1650)["state"] == "running"
+
+
+def test_a_board_read_still_locked_past_the_retry_budget_aborts_as_before(
+    cli, seed, launches, monkeypatch
+):
+    """The retry budget is bounded — a lock that never clears must still
+    abort the tick with the pre-#2159 message, not spin forever or no-op."""
+    import sqlite3
+
+    from coord.commands import drive_queue as drive_queue_cmd
+
+    seed(issues={1650: "open"})
+    cli("add", REPO, "1650")
+    before = state._list_drive_queue_local()
+
+    calls = {"n": 0}
+
+    def always_locked() -> drive_queue_cmd.BoardView:
+        calls["n"] += 1
+        raise sqlite3.OperationalError("database is locked")
+
+    monkeypatch.setattr(drive_queue_cmd, "_fetch_board_view", always_locked)
+    monkeypatch.setattr(drive_queue_cmd.time, "sleep", lambda _s: None)
+
+    result = cli("tick")
+    assert result.exit_code != 0
+    assert "aborting without launching" in result.output
+    assert "database is locked" in result.output
+    assert calls["n"] == drive_queue_cmd._BOARD_READ_RETRY_ATTEMPTS
+    assert launches == []
+    assert state._list_drive_queue_local() == before
+
+
 def test_a_failed_launch_is_a_consumed_attempt_not_a_running_entry(
     cli, seed, launches
 ):