code-coordinator 0.5.270__tar.gz → 0.5.272__tar.gz

{code_coordinator-0.5.270 → code_coordinator-0.5.272}/PKG-INFO

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

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

@@ -358,6 +358,7 @@ scripts/azure-workers/tailnet-acl.hujson
 scripts/azure-workers/verify-github-token.sh
 tests/SMOKE_SET.md
 tests/__init__.py
+tests/backends.py
 tests/conftest.py
 tests/test_acceptance.py
 tests/test_acceptance_drivers.py
@@ -394,6 +395,7 @@ tests/test_audit_outcome.py
 tests/test_audit_query.py
 tests/test_auto_loop.py
 tests/test_auto_release_publish_2035.py
+tests/test_backend_selection.py
 tests/test_base_checkout_restore.py
 tests/test_block_log.py
 tests/test_board_cap_762.py
@@ -713,6 +715,7 @@ tests/test_spend_ceiling_coordinator.py
 tests/test_split.py
 tests/test_split_work.py
 tests/test_sql_dialect.py
+tests/test_sqlite_connect_ratchet.py
 tests/test_stage_projection.py
 tests/test_stale_busy_reviewer_697.py
 tests/test_stalled_pipeline.py

{code_coordinator-0.5.270 → code_coordinator-0.5.272}/code_coordinator.egg-info/scm_file_list.json

@@ -410,6 +410,7 @@
     "tests/acceptance/ms-67/mocks/approved-items-populated.screen",
     "tests/acceptance/ms-67/pull_decomposition_2533.rs",
     "tests/acceptance/ms-example/mocks/home-active.html",
+    "tests/backends.py",
     "tests/conftest.py",
     "tests/fixtures/board-pipeline-basic.json",
     "tests/fixtures/board-pipeline-terminal-gates.json",
@@ -466,6 +467,7 @@
     "tests/test_audit_query.py",
     "tests/test_auto_loop.py",
     "tests/test_auto_release_publish_2035.py",
+    "tests/test_backend_selection.py",
     "tests/test_base_checkout_restore.py",
     "tests/test_block_log.py",
     "tests/test_board_cap_762.py",
@@ -785,6 +787,7 @@
     "tests/test_split.py",
     "tests/test_split_work.py",
     "tests/test_sql_dialect.py",
+    "tests/test_sqlite_connect_ratchet.py",
     "tests/test_stage_projection.py",
     "tests/test_stale_busy_reviewer_697.py",
     "tests/test_stalled_pipeline.py",

{code_coordinator-0.5.270 → code_coordinator-0.5.272}/code_coordinator.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.270",
+  "tag": "0.5.272",
   "distance": 0,
-  "node": "g03d05893c4dd0a33802455a4bac412f730e4f018",
+  "node": "g86d2609016c406aeea4b99ed80b0eae4e2963c25",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-28"

{code_coordinator-0.5.270 → code_coordinator-0.5.272}/coord/config.py

@@ -22,6 +22,7 @@ from coord.liveness_auditor import (
 )
 from coord.models import Machine, QuietHours, Repo, WorkerPermissionsConfig
 from coord.platform_paths import default_coord_dir
+from coord.sql import DIALECT_POSTGRES, DIALECT_SQLITE
 
 
 DEFAULT_CONFIG_PATH = Path("coordinator.yml")
@@ -1462,6 +1463,48 @@ class CiStoreConfig:
     token_env: str = "GITLAB_TOKEN"
 
 
+@dataclass
+class StoreConfig:
+    """``store:`` block (#827) — which database backend ``coord.db``/
+    ``coord.dao`` open their connections against, via ``coord.sql``'s
+    dialect-aware connection factory (``coord.sql.connect``).
+
+    Absent block == ``backend: sqlite`` == today's behaviour, byte-for-byte:
+    ``coord.db`` resolves its own on-disk path (``DB_PATH`` —
+    ``~/.coord/coord.db`` by default, see ``coord/platform_paths.py``)
+    completely independently of this config, so leaving this block out (or
+    writing it with ``backend: sqlite`` explicitly) changes nothing about
+    where an existing deployment's data lives or how it's opened.
+
+    ``dsn`` is required, and only consulted, when ``backend: postgres`` — a
+    libpq-style connection string (e.g.
+    ``"postgresql://user:pass@host:5432/dbname"``) passed straight to
+    ``psycopg`` (an optional dependency not declared anywhere in
+    ``pyproject.toml`` — see ``coord/sql.py``'s ``row_factory_for`` — so a
+    deployment that never sets ``backend: postgres`` never needs it
+    installed).
+
+    This is deliberately a **server-side-only** choice
+    (``docs/STORE_SERVICE.md`` §4 — "Why a server-side feature flag is the
+    wrong mechanism" carves out exactly this one exception): which storage
+    engine is live is a deployment property, not something an individual
+    client negotiates per request, so every machine pointed at the same
+    ``coord serve`` daemon's database must set the same ``store:`` block (or
+    none). Nothing in this repo currently cross-checks that across machines
+    (#829 territory).
+
+    Setting this block chooses the connection target only — it says nothing
+    about whether the schema has actually been migrated to Postgres (#828)
+    or whether any machine in the fleet is pointed at one yet (#829).
+    ``backend: postgres`` with no real server behind ``dsn`` just makes every
+    DB open fail loudly at connect time, the same as a bad DSN always would;
+    this block does not make Postgres "live" by itself.
+    """
+
+    backend: str = DIALECT_SQLITE
+    dsn: str | None = None
+
+
 @dataclass
 class AuditConfig:
     """``audit:`` block (#1036/#1038) — the append-only ``audit_log``
@@ -2123,6 +2166,8 @@ class Config:
     # #2131 — absent block == no ceiling == today's behaviour.
     budget: BudgetConfig = field(default_factory=BudgetConfig)
     ci_store: CiStoreConfig = field(default_factory=CiStoreConfig)
+    # #827 — absent block == backend="sqlite" == today's behaviour untouched.
+    store: StoreConfig = field(default_factory=StoreConfig)
     merge: MergeConfig = field(default_factory=MergeConfig)
     # #2583 — absent block == min_releases_behind=1 == today's behaviour
     # (any delta at all rolls, subject to quiescence/cordon as before).
@@ -2206,6 +2251,7 @@ def parse_mapping(raw: Any, *, path: Path | None = None) -> Config:
     usage_gate = _parse_usage_gate(raw.get("usage_gate"))
     budget = _parse_budget(raw.get("budget"))
     ci_store = _parse_ci_store(raw.get("ci_store"))
+    store = _parse_store(raw.get("store"))
     merge = _parse_merge(raw.get("merge"))
     propagation = _parse_propagation(raw.get("propagation"))
     milestone = _parse_milestone(raw.get("milestone"))
@@ -2229,6 +2275,7 @@ def parse_mapping(raw: Any, *, path: Path | None = None) -> Config:
         usage_gate=usage_gate,
         budget=budget,
         ci_store=ci_store,
+        store=store,
         merge=merge,
         propagation=propagation,
         milestone=milestone,
@@ -3667,6 +3714,30 @@ def _parse_ci_store(raw: Any) -> CiStoreConfig:
     return cfg
 
 
+def _parse_store(raw: Any) -> StoreConfig:
+    if raw is None:
+        return StoreConfig()
+    if not isinstance(raw, dict):
+        raise ConfigError("'store' must be a mapping")
+
+    cfg = StoreConfig()
+    if "backend" in raw:
+        value = raw["backend"]
+        if not isinstance(value, str) or value not in (DIALECT_SQLITE, DIALECT_POSTGRES):
+            raise ConfigError(
+                f"store.backend must be one of: {DIALECT_SQLITE}, {DIALECT_POSTGRES}"
+            )
+        cfg.backend = value
+    if "dsn" in raw:
+        value = raw["dsn"]
+        if value is not None and (not isinstance(value, str) or not value):
+            raise ConfigError("store.dsn must be a non-empty string (or omitted)")
+        cfg.dsn = value
+    if cfg.backend == DIALECT_POSTGRES and not cfg.dsn:
+        raise ConfigError("store.dsn is required when store.backend is 'postgres'")
+    return cfg
+
+
 def _parse_merge(raw: Any) -> MergeConfig:
     """Parse the optional ``merge:`` block from coordinator.yml.
 

{code_coordinator-0.5.270 → code_coordinator-0.5.272}/coord/dao.py

@@ -32,16 +32,33 @@ the coordinator process is writing in WAL mode.
 #2766: every statement this module runs routes through ``coord.sql`` (the
 dialect seam, #2719/#1948) rather than calling ``conn.execute()`` directly —
 paramstyle translation, the row factory, and connection setup are the seam's
-job now, not hand-rolled here. Two decisions worth recording (see the PR):
-the ``mode=ro`` URI itself stays in this module's ``_connect()`` rather than
-moving into the seam, because ``SqliteStore`` is *already* the class that
-names its concrete backend — there is no live Postgres connection factory
-yet for the seam to branch on, so a second implementation (e.g.
-``PostgresStore``) would own its own connection factory rather than this one
-growing a dialect branch ahead of that backend existing. The read-only
-``PRAGMA query_only=ON`` (no Postgres connect-time equivalent — see
-``sql.apply_connection_setup``'s ``read_only`` flag) and ``busy_timeout``
-both now come from that one seam call instead of two bare PRAGMAs.
+job now, not hand-rolled here. The read-only ``PRAGMA query_only=ON`` (no
+Postgres connect-time equivalent — see ``sql.apply_connection_setup``'s
+``read_only`` flag) and ``busy_timeout`` both come from that one seam call
+instead of two bare PRAGMAs.
+
+#827 (superseding the #2766 decision note that used to live here): the
+``mode=ro`` URI itself has now moved into ``coord.sql.connect`` too. #2766
+kept it in this module's ``_connect()`` because "there is no live Postgres
+connection factory yet for the seam to branch on" — #827 is that factory, so
+the premise no longer holds, and ``SqliteStore._connect`` now calls
+``sql.connect(backend=..., ...)`` like every other connection opener in the
+tree rather than naming ``sqlite3.connect`` directly (enforced by
+``tests/test_sql_dialect.py``'s connect-call ratchet, the sibling of #2768's
+execute-call one).
+
+**Which backend** ``_connect()`` opens is resolved through
+``coord.db._resolve_store_target()`` — the identical decision
+``coord.db.get_connection()``'s write path makes — rather than this class
+hardcoding SQLite (#827 review fix: an earlier version of this PR left this
+class's name doing double duty as its behavior, so ``store.backend:
+postgres`` silently split-brained the daemon's read path from its write
+path — see the issue's blocking-finding history). ``SqliteStore`` still owns
+*which* backend it opens — nothing here forces a future ``PostgresStore`` to
+share this class, and this class is not renamed because nothing about its
+read contract or its "never migrates" invariant changes — it just no longer
+assumes the answer is always SQLite, matching ``coord.db``'s write path one
+config read away.
 
 All SQLite idioms (JSON-encoded TEXT columns, the ``mode=ro`` URI) that
 remain are encapsulated here: read methods return plain Python dicts with
@@ -67,6 +84,7 @@ from pathlib import Path
 from typing import Any, Protocol, runtime_checkable
 
 from coord import board_schema, sql
+from coord import db as db_mod
 from coord.db import DB_PATH
 
 # Bump when the /board payload shape changes incompatibly.  Clients may branch
@@ -272,26 +290,56 @@ def _decode_row(table: str, row: board_schema.RowLike, *, full: bool = False) ->
 
 
 class SqliteStore:
-    """Read-only SQLite-backed :class:`CoordStore`.
-
-    Opens a fresh ``mode=ro`` connection per call (cheap for SQLite, thread-safe
-    under the daemon's request handling, and never migrates the DB).
-    ``board_projection`` opens a single connection so the whole payload is one
-    consistent snapshot.
+    """Read-only :class:`CoordStore`, SQLite by default, Postgres when
+    ``coordinator.yml``'s ``store: backend: postgres`` opts in (#827 — see
+    :func:`_connect` and the module docstring's "Which backend" note; the
+    class keeps its pre-#827 name since its read contract and its "never
+    migrates the DB" invariant are unchanged either way).
+
+    Opens a fresh connection per call (cheap for SQLite, thread-safe under
+    the daemon's request handling; a Postgres deployment gets the same
+    "fresh connection per call" for now — #829 decides whether that needs
+    pooling under real load) and never migrates the DB. ``board_projection``
+    opens a single connection so the whole payload is one consistent
+    snapshot.
     """
 
     def __init__(self, db_path: Path | str | None = None) -> None:
         self._path = Path(db_path) if db_path is not None else DB_PATH
 
     # ── connection ────────────────────────────────────────────────────────────
-    def _connect(self) -> sqlite3.Connection:
-        # #2766: the `mode=ro` URI is a SQLite-only spelling of "open
-        # read-only" and stays here rather than in the seam — see the module
-        # docstring's decision note. Everything downstream of "how do I get
-        # a connection" (row factory, connection-setup pragmas) routes
-        # through `coord.sql`.
-        uri = f"file:{self._path}?mode=ro"
-        conn = sqlite3.connect(uri, uri=True, check_same_thread=False)
+    def _connect(self) -> Any:
+        # #827 (review fix): which backend to open is resolved through the
+        # SAME dialect decision `coord.db.get_connection()`'s write path
+        # uses -- `coord.db._resolve_store_target()` -- rather than this
+        # class hardcoding SQLite. `SqliteStore` still owns *which* backend
+        # it opens (there is no separate `PostgresStore`); it just no longer
+        # assumes the answer is always SQLite. `self._path` (an explicit or
+        # default on-disk path) is only meaningful for the SQLite branch --
+        # a Postgres deployment has no path, only `store.dsn`.
+        target = db_mod._resolve_store_target()
+        if target.backend == sql.DIALECT_POSTGRES:
+            # #1960's SQLite write-path guard has a Postgres analogue for
+            # exactly this read path -- see `coord.db.refuse_postgres_under_pytest`.
+            db_mod.refuse_postgres_under_pytest(
+                "the configured production Postgres store (dao read path)"
+            )
+            conn = sql.connect(backend=sql.DIALECT_POSTGRES, dsn=target.dsn)
+        else:
+            # #827: the `mode=ro` URI construction now lives in `sql.connect`
+            # — see the module docstring's updated decision note. This is a
+            # fresh connection per call (cheap for SQLite, thread-safe under
+            # the daemon's request handling), matching
+            # `check_same_thread=False`. #829 measures whether a Postgres
+            # deployment needs anything more than "fresh connection per
+            # call" too -- this issue only needs the read path to be
+            # *capable* of reaching Postgres, not tuned for it yet.
+            conn = sql.connect(
+                backend=sql.DIALECT_SQLITE,
+                sqlite_path=self._path,
+                read_only=True,
+                check_same_thread=False,
+            )
         sql.apply_row_factory(conn)
         # #2159: without a busy_timeout SQLite fails a locked read INSTANTLY
         # (the default is 0ms) instead of waiting out a writer's momentary
@@ -299,8 +347,9 @@ class SqliteStore:
         # 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. `read_only=True` also sets
-        # `PRAGMA query_only=ON` instead of the writer's WAL/foreign_keys
-        # pragmas (a `mode=ro` connection can't write the WAL toggle) — see
+        # `PRAGMA query_only=ON` (SQLite) / the read-only session/transaction
+        # flag (Postgres) instead of the writer's WAL/foreign_keys pragmas
+        # (a `mode=ro` SQLite connection can't write the WAL toggle) — see
         # `sql.apply_connection_setup`.
         sql.apply_connection_setup(conn, read_only=True)
         return conn