code-coordinator 0.5.214__tar.gz → 0.5.215__tar.gz

{code_coordinator-0.5.214 → code_coordinator-0.5.215}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.214",
+  "tag": "0.5.215",
   "distance": 0,
-  "node": "g2e87641a37faa3849364d808e9047a3c9632f0c2",
+  "node": "g43e59d754122e055c18ab64170d43a1f2d7a4afd",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-21"

{code_coordinator-0.5.214 → code_coordinator-0.5.215}/coord/auto_loop.py

@@ -34,6 +34,7 @@ Data model:
 from __future__ import annotations
 
 import logging
+import sqlite3
 import time
 import uuid
 from dataclasses import dataclass
@@ -1221,10 +1222,37 @@ def _dispatch_fix(
     )
     board.active.append(fix_assignment)
 
-    record_dispatched_assignment(
-        assignment=fix_assignment,
-        repo_github=repo.github,
-    )
+    try:
+        record_dispatched_assignment(
+            assignment=fix_assignment,
+            repo_github=repo.github,
+        )
+    except sqlite3.OperationalError as exc:
+        if "database is locked" not in str(exc).lower():
+            # Not the transient contention this guard exists for (#2538) —
+            # a schema mismatch or malformed statement is a real bug and
+            # must not be swallowed as an ordinary declined dispatch.
+            raise
+        # `record_dispatched_assignment` already retries transient
+        # "database is locked" contention itself (coord.db.retry_on_locked,
+        # via coord._record_dispatched_assignment_local) — this is only
+        # reached once that bounded retry budget is exhausted. The fix
+        # worker has already been POSTed to the agent above and is really
+        # running; only the durable board-DB row failed to write. Treat it
+        # the same as any other declined dispatch (no machine, agent
+        # unreachable, …) rather than letting a transient lock crash the
+        # whole caller (`coord merge`'s CI-fix queue, the review auto-loop,
+        # …) — undo the in-memory append so a saved board never carries a
+        # row this call never durably recorded, and let the caller's
+        # existing "dispatch declined" handling take it from here.
+        board.active.remove(fix_assignment)
+        log.warning(
+            "auto_loop: fix dispatch for %s hit persistent DB contention "
+            "recording assignment %s (%s) — treating as not dispatched; "
+            "will retry next run",
+            work.assignment_id, fix_assignment.assignment_id, exc,
+        )
+        return None
     return fix_assignment
 
 

{code_coordinator-0.5.214 → code_coordinator-0.5.215}/coord/commands/merge.py

@@ -610,10 +610,24 @@ def _dispatch_ci_fixes(events, config, *, dry_run: bool) -> None:
                 details={"reason": "ci_fix_retry_cap", "error": entry.error},
             )
             dispatched_any = True  # the HUMAN_REQUIRED mutation needs saving
-        # else: budget remains but dispatch declined for another reason (no
-        # machine, an unrelated fix already in flight, agent unreachable) —
-        # leave the entry PENDING for the next tick to retry, exactly like a
-        # declined conflict-fix dispatch does.
+        else:
+            # Budget remains but dispatch declined for another reason (no
+            # machine, an unrelated fix already in flight, agent
+            # unreachable, or — #2538 — `_dispatch_fix` hit persistent
+            # "database is locked" contention recording the assignment
+            # after its own bounded retry budget was exhausted) — leave the
+            # entry PENDING for the next tick to retry, exactly like a
+            # declined conflict-fix dispatch does. Echoed (matching
+            # `_dispatch_conflict_fixes`'s equivalent branch) so an
+            # operator watching `coord merge` isn't left wondering why
+            # nothing happened for this entry — and so a transient DB lock
+            # collision on ONE entry is visibly a retry, not a silent drop,
+            # while every other entry keeps processing normally.
+            click.echo(
+                f"  {entry.repo_name} #{entry.issue_number}: "
+                "ci-fix not dispatched (no machine / already in flight / "
+                "transient DB contention — will retry next run)"
+            )
     if dispatched_any:
         save_board(fix_board)
 

{code_coordinator-0.5.214 → code_coordinator-0.5.215}/coord/db.py

@@ -15,7 +15,9 @@ from __future__ import annotations
 import json
 import os
 import sqlite3
+import time
 from pathlib import Path
+from typing import Callable, TypeVar
 
 from coord.platform_paths import default_coord_dir
 
@@ -88,6 +90,57 @@ def close() -> None:
         _conn = None
 
 
+_T = TypeVar("_T")
+
+# #2538: a handful of consecutive short retries — long enough to ride out a
+# concurrent writer (the daemon's own passive tick, another `coord merge`/
+# `coord notify` invocation) that only holds the DB for a moment, short
+# enough that a genuinely stuck lock still fails fast rather than hanging
+# `coord merge` for a long time.
+_LOCK_RETRY_ATTEMPTS = 5
+_LOCK_RETRY_BASE_DELAY_S = 0.1
+
+
+def retry_on_locked(
+    write: Callable[[], _T],
+    *,
+    attempts: int = _LOCK_RETRY_ATTEMPTS,
+    base_delay: float = _LOCK_RETRY_BASE_DELAY_S,
+) -> _T:
+    """Run *write* (a zero-arg callable performing one or more SQLite writes),
+    retrying with exponential backoff when SQLite raises ``database is
+    locked`` (#2538).
+
+    That error is transient contention — a concurrent writer holding the DB
+    at the exact moment this call tries to write, not a real failure — and a
+    short wait is very likely to let it clear.  ``PRAGMA busy_timeout``
+    (set on every connection in :func:`_open`) already makes SQLite itself
+    wait before raising, but under sustained contention (several writers in
+    a tight loop) that single wait can still be exhausted; this adds a few
+    more short, backed-off attempts on top rather than failing on the first
+    collision.
+
+    Any other ``OperationalError`` (schema drift, a malformed statement, …)
+    is re-raised immediately without retrying — those are not transient, and
+    retrying would only delay surfacing a real bug.  After *attempts*
+    consecutive ``database is locked`` collisions, re-raises the last
+    ``sqlite3.OperationalError`` so the caller can decide how to degrade
+    (see ``coord.state._record_dispatched_assignment_local``, whose caller —
+    ``coord.auto_loop._dispatch_fix`` — treats it as a declined dispatch
+    rather than letting it crash the whole run).
+    """
+    delay = base_delay
+    for attempt in range(1, attempts + 1):
+        try:
+            return write()
+        except sqlite3.OperationalError as exc:
+            if "database is locked" not in str(exc).lower() or attempt >= attempts:
+                raise
+            time.sleep(delay)
+            delay *= 2
+    raise AssertionError("unreachable")  # loop above always returns or raises
+
+
 # ── Schema ────────────────────────────────────────────────────────────────────
 
 def _ensure_schema(conn: sqlite3.Connection) -> None:

{code_coordinator-0.5.214 → code_coordinator-0.5.215}/coord/state.py

@@ -37,7 +37,7 @@ from coord._board_mapping import (
 from coord.audit import record_audit as _record_audit
 from coord.board_service import resolve as _board_service_resolve
 from coord.board_service import route_write as _route_write
-from coord.db import get_connection
+from coord.db import get_connection, retry_on_locked
 from coord.models import (
     WORK_LIKE_TYPES,
     Assignment,
@@ -1018,8 +1018,17 @@ def _record_dispatched_assignment_local(
     )
 
     conn = get_connection()
-    conn.execute(
-        """INSERT INTO assignments (
+
+    # #2538: this INSERT/commit is the one write in this function that's
+    # actually load-bearing (unlike the best-effort `_record_audit` call
+    # below it) — a concurrent writer (the daemon's own passive tick,
+    # another `coord merge`/`coord notify` invocation) holding the DB for a
+    # moment must not crash the caller.  The statement is safe to retry
+    # as-is: `assignment_id` is the primary key and the `ON CONFLICT ...
+    # DO UPDATE` makes a re-attempted write idempotent.
+    def _write() -> None:
+        conn.execute(
+            """INSERT INTO assignments (
             assignment_id, machine_name, repo_name, repo_github,
             issue_number, issue_title, status, type, briefing,
             files_allowed, model, dispatched_at, review_of_assignment_id,
@@ -1101,8 +1110,10 @@ def _record_dispatched_assignment_local(
             assignment.driven_by,
             assignment.dispatched_by_assignment_id,
         ),
-    )
-    conn.commit()
+        )
+        conn.commit()
+
+    retry_on_locked(_write)
     _record_audit(
         tier="business",
         category="dispatch",

{code_coordinator-0.5.214 → code_coordinator-0.5.215}/tests/test_auto_loop.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import sqlite3
 import uuid
 from dataclasses import replace
 from typing import Any
@@ -2402,6 +2403,105 @@ class TestDispatchFixRemoteBranchGuard:
         assert result.machine_name == "server"
 
 
+# ── #2538: persistent "database is locked" must decline, not crash ─────────
+
+
+class TestDispatchFixDbContention:
+    """coord-portal#2538: a concurrent writer (the daemon's own passive
+    tick, another `coord merge`/`coord notify` invocation) can hold the DB
+    at the exact moment `record_dispatched_assignment` tries to record a
+    dispatched fix. `coord.state`'s own bounded retry
+    (`coord.db.retry_on_locked`) already rides out a short collision; this
+    covers what happens once that retry budget is well and truly exhausted
+    — `_dispatch_fix` must degrade to its documented "None on failure"
+    contract instead of letting the raw `sqlite3.OperationalError` crash
+    the caller (`coord merge`'s CI-fix queue, the review auto-loop, …)."""
+
+    def _work(self, machine: str = "laptop") -> Assignment:
+        return Assignment(
+            machine_name=machine,
+            repo_name="api",
+            issue_number=5,
+            issue_title="Fix thing",
+            briefing="Original briefing.",
+            assignment_id="work-2538",
+            status="done",
+            branch="issue-5-fix-thing",
+            dispatched_at=0.0,
+            finished_at=1.0,
+            type="work",
+        )
+
+    def test_persistent_lock_contention_returns_none_without_crashing(
+        self,
+    ) -> None:
+        cfg = _two_machine_config()
+        work = self._work()
+        board = Board(completed=[work])
+        mock_http = MagicMock()
+        mock_http.post.return_value.json.return_value = {"id": "fix-2538-a"}
+        mock_http.post.return_value.raise_for_status = MagicMock()
+
+        with patch(
+            "coord.auto_loop.record_dispatched_assignment",
+            side_effect=sqlite3.OperationalError("database is locked"),
+        ):
+            result = _dispatch_fix(
+                work, "Fix briefing.", board, cfg, iteration=1,
+                http_client=mock_http,
+            )
+
+        assert result is None
+
+    def test_persistent_lock_contention_rolls_back_the_board_append(
+        self,
+    ) -> None:
+        """The fix assignment is appended to `board.active` before the DB
+        write is attempted (so a fully successful dispatch needs no extra
+        round trip) — a failed write must undo that append, or a later
+        `save_board` call (triggered by some OTHER entry succeeding in the
+        same `coord merge` tick) would persist a phantom row that was never
+        actually recorded."""
+        cfg = _two_machine_config()
+        work = self._work()
+        board = Board(completed=[work])
+        mock_http = MagicMock()
+        mock_http.post.return_value.json.return_value = {"id": "fix-2538-b"}
+        mock_http.post.return_value.raise_for_status = MagicMock()
+
+        with patch(
+            "coord.auto_loop.record_dispatched_assignment",
+            side_effect=sqlite3.OperationalError("database is locked"),
+        ):
+            _dispatch_fix(
+                work, "Fix briefing.", board, cfg, iteration=1,
+                http_client=mock_http,
+            )
+
+        assert board.active == []
+
+    def test_unrelated_operational_error_still_propagates(self) -> None:
+        """A genuine bug (schema drift, a malformed statement) must not be
+        swallowed as if it were routine transient contention — only the
+        specific `database is locked` message is treated as declinable."""
+        cfg = _two_machine_config()
+        work = self._work()
+        board = Board(completed=[work])
+        mock_http = MagicMock()
+        mock_http.post.return_value.json.return_value = {"id": "fix-2538-c"}
+        mock_http.post.return_value.raise_for_status = MagicMock()
+
+        with patch(
+            "coord.auto_loop.record_dispatched_assignment",
+            side_effect=sqlite3.OperationalError("no such column: bogus"),
+        ):
+            with pytest.raises(sqlite3.OperationalError, match="no such column"):
+                _dispatch_fix(
+                    work, "Fix briefing.", board, cfg, iteration=1,
+                    http_client=mock_http,
+                )
+
+
 # ── #1176: test-author bounce gets a type="test-author" fix, not "work" ─────
 
 

{code_coordinator-0.5.214 → code_coordinator-0.5.215}/tests/test_ci_fix.py

@@ -333,3 +333,27 @@ class TestDispatchCiFixesWrapper:
             merge_cmd._dispatch_ci_fixes(events, two_machine_config, dry_run=False)
 
         assert entry.state == PENDING
+
+    def test_declined_dispatch_under_budget_is_echoed(
+        self, two_machine_config: Config, coord_db, capsys,
+    ) -> None:
+        """#2538: a declined dispatch (including `_dispatch_fix` hitting
+        persistent DB-lock contention, which surfaces exactly like any
+        other decline — see coord.auto_loop._dispatch_fix) must be visible
+        in `coord merge` output, not silently dropped — otherwise an
+        operator watching the run has no idea this entry didn't advance."""
+        from coord.commands import merge as merge_cmd
+        from coord.state import save_board
+
+        board = Board()
+        save_board(board)
+
+        entry = _entry()
+        events = [self._checks_failed_event(entry)]
+
+        with patch("coord.ci_fix.dispatch_ci_fix", return_value=None):
+            merge_cmd._dispatch_ci_fixes(events, two_machine_config, dry_run=False)
+
+        out = capsys.readouterr().out
+        assert "ci-fix not dispatched" in out
+        assert f"#{entry.issue_number}" in out

{code_coordinator-0.5.214 → code_coordinator-0.5.215}/tests/test_db.py

@@ -9,7 +9,13 @@ from pathlib import Path
 import pytest
 
 from coord import db as db_mod
-from coord.db import _ensure_schema, override_connection, close, _migrate_gate_order
+from coord.db import (
+    _ensure_schema,
+    override_connection,
+    close,
+    _migrate_gate_order,
+    retry_on_locked,
+)
 
 
 # ── Fixtures ──────────────────────────────────────────────────────────────────
@@ -724,6 +730,78 @@ class TestMergeQueueCiFixDispatchesColumn:
         conn.close()
 
 
+# ── retry_on_locked (#2538) ─────────────────────────────────────────────────
+
+
+class TestRetryOnLocked:
+    """#2538: `coord merge` crashed the whole run on a transient
+    `sqlite3.OperationalError: database is locked` raised while recording a
+    dispatched CI-fix assignment. `retry_on_locked` gives a momentary
+    collision (the daemon's own passive tick, another `coord merge`/`coord
+    notify` invocation holding the DB) a few short, backed-off attempts to
+    clear before it becomes the caller's problem.
+    """
+
+    def test_succeeds_immediately_when_no_contention(self) -> None:
+        calls = []
+
+        def _write() -> str:
+            calls.append(1)
+            return "ok"
+
+        assert retry_on_locked(_write) == "ok"
+        assert len(calls) == 1
+
+    def test_retries_through_transient_lock_then_succeeds(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        sleeps: list[float] = []
+        monkeypatch.setattr(db_mod.time, "sleep", lambda s: sleeps.append(s))
+
+        attempts = {"n": 0}
+
+        def _write() -> str:
+            attempts["n"] += 1
+            if attempts["n"] < 3:
+                raise sqlite3.OperationalError("database is locked")
+            return "ok"
+
+        result = retry_on_locked(_write)
+
+        assert result == "ok"
+        assert attempts["n"] == 3
+        # Two collisions before the third, successful attempt — backed off
+        # (each wait longer than the last), never a busy-loop.
+        assert len(sleeps) == 2
+        assert sleeps[1] > sleeps[0]
+
+    def test_raises_after_exhausting_the_retry_budget(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        monkeypatch.setattr(db_mod.time, "sleep", lambda s: None)
+
+        def _write() -> None:
+            raise sqlite3.OperationalError("database is locked")
+
+        with pytest.raises(sqlite3.OperationalError, match="database is locked"):
+            retry_on_locked(_write, attempts=3, base_delay=0.0)
+
+    def test_unrelated_operational_error_is_not_retried(self) -> None:
+        """A schema/statement bug is a real failure, not transient
+        contention — it must surface on the very first attempt rather than
+        being retried (and delayed) as if it were lock contention."""
+        calls = []
+
+        def _write() -> None:
+            calls.append(1)
+            raise sqlite3.OperationalError("no such table: bogus")
+
+        with pytest.raises(sqlite3.OperationalError, match="no such table"):
+            retry_on_locked(_write)
+
+        assert len(calls) == 1
+
+
 # ── override_connection ────────────────────────────────────────────────────────
 
 class TestOverrideConnection:

{code_coordinator-0.5.214 → code_coordinator-0.5.215}/tests/test_state.py

@@ -399,6 +399,92 @@ class TestDispatchedByAssignmentId:
         assert rows["sibling-load-001"]["dispatched_by_assignment_id"] == "origin-work-load"
 
 
+class TestRecordDispatchedAssignmentLockContention:
+    """#2538: `_record_dispatched_assignment_local`'s INSERT is the one
+    write in that function that's actually load-bearing (unlike the
+    best-effort `_record_audit` call alongside it) — a concurrent writer
+    (the daemon's own passive tick, another `coord merge`/`coord notify`
+    invocation) holding the DB for a moment must not be fatal. It now
+    retries transient `database is locked` collisions via
+    `coord.db.retry_on_locked` before giving up.
+    """
+
+    class _FlakyConn:
+        """Wraps a real (in-memory) connection, raising `database is
+        locked` on the first *fail_times* `execute()` calls before
+        delegating to the real one — simulates a concurrent writer holding
+        the DB for a few moments."""
+
+        def __init__(self, real_conn, fail_times: int) -> None:
+            self._real = real_conn
+            self._fail_times = fail_times
+            self.calls = 0
+
+        def execute(self, *args, **kwargs):
+            self.calls += 1
+            if self.calls <= self._fail_times:
+                import sqlite3
+
+                raise sqlite3.OperationalError("database is locked")
+            return self._real.execute(*args, **kwargs)
+
+        def commit(self):
+            return self._real.commit()
+
+    def test_retries_through_transient_lock_then_persists(
+        self, coord_db, monkeypatch
+    ) -> None:
+        from coord.models import Assignment
+        from coord.state import record_dispatched_assignment
+
+        monkeypatch.setattr("coord.db.time.sleep", lambda s: None)
+        flaky = self._FlakyConn(coord_db, fail_times=2)
+        monkeypatch.setattr("coord.state.get_connection", lambda: flaky)
+
+        record_dispatched_assignment(
+            assignment=Assignment(
+                assignment_id="ci-fix-2538", machine_name="laptop",
+                repo_name="api", issue_number=9, issue_title="[fix-1] thing",
+                type="work",
+            ),
+            repo_github="acme/api",
+        )
+
+        assert flaky.calls == 3  # two collisions, then the write that lands
+        row = coord_db.execute(
+            "SELECT status FROM assignments WHERE assignment_id=?",
+            ("ci-fix-2538",),
+        ).fetchone()
+        assert row is not None, "assignment must be durably recorded once the lock clears"
+        assert row["status"] == "running"
+
+    def test_raises_once_the_retry_budget_is_exhausted(
+        self, coord_db, monkeypatch
+    ) -> None:
+        """A lock that never clears within the bounded retry budget must
+        still surface to the caller — `coord.auto_loop._dispatch_fix` is
+        the layer responsible for turning that into a graceful "declined"
+        rather than a crash, not this one silently swallowing it."""
+        import sqlite3
+
+        from coord.models import Assignment
+        from coord.state import record_dispatched_assignment
+
+        monkeypatch.setattr("coord.db.time.sleep", lambda s: None)
+        flaky = self._FlakyConn(coord_db, fail_times=999)
+        monkeypatch.setattr("coord.state.get_connection", lambda: flaky)
+
+        with pytest.raises(sqlite3.OperationalError, match="database is locked"):
+            record_dispatched_assignment(
+                assignment=Assignment(
+                    assignment_id="ci-fix-2538-b", machine_name="laptop",
+                    repo_name="api", issue_number=9, issue_title="[fix-1] thing",
+                    type="work",
+                ),
+                repo_github="acme/api",
+            )
+
+
 class TestRecordDispatchedAssignmentBranch:
     """#557: record_dispatched_assignment must persist the branch column so
     coord reattach can find it for the remote push-back finalize."""