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

{code_coordinator-0.5.272 → code_coordinator-0.5.274}/.github/workflows/test.yml

@@ -320,3 +320,61 @@ jobs:
   # the half of that check this repo can still make (the generator runs and
   # covers every schema; the coord-web byte-comparison itself is that repo's
   # own CI, per the paragraph above).
+
+  # #2886: a real Postgres 16 service, so `coord/sql.py`'s Postgres branches
+  # (paramstyle translation, upsert idioms, `information_schema`
+  # introspection, `RETURNING`, `dict_row`) — spoken since #2719 but never
+  # once executed against a real server — actually run against one, and so
+  # `COORD_TEST_BACKEND=postgres` (#2884's test-suite backend switch) means
+  # something in CI for the first time.
+  #
+  # SEPARATE JOB, not a `services:` block bolted onto `test` above, for two
+  # reasons: (1) the SQLite lane must stay exactly as fast and exactly as
+  # reliable as it is today — a Postgres service, even an unused one, is
+  # more CI surface for that job to depend on for zero benefit to the
+  # SQLite path; (2) `continue-on-error: true` below softens THIS job's
+  # conclusion without touching `test`'s at all. Running the whole suite
+  # (`coord_db` is autouse — see tests/conftest.py — so every one of ~400
+  # test files follows `COORD_TEST_BACKEND` for free) against a backend
+  # nothing has ever run it against is expected to be red for real,
+  # unrelated-to-this-PR reasons at first (coord/db.py's `_ensure_schema`
+  # and friends were written and only ever exercised against SQLite) — the
+  # harness-portability issue's deliverable is exactly that failure list.
+  # `continue-on-error: true` keeps this job's signal visible (its own
+  # conclusion is still pass/fail on the Checks tab) without blocking merges
+  # on it. Flip it off once that failure list is closed out.
+  #
+  # `psycopg` is an optional extra (`postgres`, this issue) — never a base
+  # or `[dev]` dependency (see `pyproject.toml`) — so installing it is this
+  # job's own opt-in `pip install -e ".[dev,postgres]"`, not a change to
+  # what every other job's `pip install -e ".[dev]"` pulls in.
+  postgres:
+    runs-on: ubuntu-latest
+    continue-on-error: true
+    services:
+      postgres:
+        image: postgres:16
+        env:
+          POSTGRES_PASSWORD: postgres
+        options: >-
+          --health-cmd pg_isready --health-interval 10s
+          --health-timeout 5s --health-retries 5
+        ports:
+          - 5432:5432
+    env:
+      COORD_TEST_BACKEND: postgres
+      # The default image's bootstrap database is named after POSTGRES_USER
+      # (postgres) since no POSTGRES_DB was set above — matches
+      # tests/backends.py's schema-per-test isolation, which needs CREATE on
+      # an existing database, not a database of its own.
+      COORD_TEST_POSTGRES_DSN: postgresql://postgres:postgres@localhost:5432/postgres
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - run: pip install -e ".[dev,postgres]"
+      # #2180: same split as the `test` job above — the sealed acceptance
+      # suite is gated separately through the #2164 CI wrapper, not swept
+      # into this job's ordinary pytest run.
+      - run: pytest --ignore=tests/acceptance

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.272
+Version: 0.5.274
 Summary: Coordinate Claude Code workers across multiple machines and repos.
 Author-email: John Donaghy <johnfdonaghy@gmail.com>
 License-Expression: LicenseRef-FSL-1.1-MIT
@@ -26,6 +26,8 @@ Requires-Dist: starlette>=0.37; extra == "server"
 Requires-Dist: uvicorn>=0.30; extra == "server"
 Requires-Dist: websockets>=12.0; extra == "server"
 Requires-Dist: psutil>=5.9; extra == "server"
+Provides-Extra: postgres
+Requires-Dist: psycopg[binary]>=3.1; extra == "postgres"
 Provides-Extra: all
 Requires-Dist: code-coordinator[server]; extra == "all"
 Provides-Extra: dev

{code_coordinator-0.5.272 → code_coordinator-0.5.274}/code_coordinator.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.272
+Version: 0.5.274
 Summary: Coordinate Claude Code workers across multiple machines and repos.
 Author-email: John Donaghy <johnfdonaghy@gmail.com>
 License-Expression: LicenseRef-FSL-1.1-MIT
@@ -26,6 +26,8 @@ Requires-Dist: starlette>=0.37; extra == "server"
 Requires-Dist: uvicorn>=0.30; extra == "server"
 Requires-Dist: websockets>=12.0; extra == "server"
 Requires-Dist: psutil>=5.9; extra == "server"
+Provides-Extra: postgres
+Requires-Dist: psycopg[binary]>=3.1; extra == "postgres"
 Provides-Extra: all
 Requires-Dist: code-coordinator[server]; extra == "all"
 Provides-Extra: dev

{code_coordinator-0.5.272 → code_coordinator-0.5.274}/code_coordinator.egg-info/SOURCES.txt

@@ -141,6 +141,7 @@ coord/split_work.py
 coord/sql.py
 coord/stage_projection.py
 coord/state.py
+coord/store_migrate.py
 coord/test_author.py
 coord/test_chat.py
 coord/test_orchestrator.py
@@ -181,6 +182,7 @@ coord/commands/scorecard.py
 coord/commands/sessions.py
 coord/commands/setup.py
 coord/commands/status.py
+coord/commands/store_migrate.py
 coord/commands/terminal.py
 coord/commands/test_gate.py
 coord/commands/tui.py
@@ -724,6 +726,7 @@ tests/test_state_review_findings_daemon.py
 tests/test_status_fleet_footer.py
 tests/test_stop_1567.py
 tests/test_store_contract.py
+tests/test_store_migrate.py
 tests/test_stuck.py
 tests/test_stuck_test_state_watchdog_2803.py
 tests/test_terminal_command.py
@@ -754,6 +757,8 @@ tests/test_worker_safety.py
 tests/test_worker_test_scoping.py
 tests/test_worktree.py
 tests/test_worktree_rmtree_chokepoint.py
+tests/test_write_parity.py
+tests/write_parity.py
 tests/acceptance/ms-33/audit_1039.rs
 tests/acceptance/ms-33/contract.md
 tests/acceptance/ms-33/manifest.yml

{code_coordinator-0.5.272 → code_coordinator-0.5.274}/code_coordinator.egg-info/requires.txt

@@ -18,6 +18,9 @@ setuptools>=68
 setuptools-scm>=8
 wheel
 
+[postgres]
+psycopg[binary]>=3.1
+
 [server]
 starlette>=0.37
 uvicorn>=0.30

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

@@ -77,6 +77,7 @@
     "coord/commands/sessions.py",
     "coord/commands/setup.py",
     "coord/commands/status.py",
+    "coord/commands/store_migrate.py",
     "coord/commands/terminal.py",
     "coord/commands/test_gate.py",
     "coord/commands/tui.py",
@@ -251,6 +252,7 @@
     "coord/sql.py",
     "coord/stage_projection.py",
     "coord/state.py",
+    "coord/store_migrate.py",
     "coord/test_author.py",
     "coord/test_chat.py",
     "coord/test_orchestrator.py",
@@ -796,6 +798,7 @@
     "tests/test_status_fleet_footer.py",
     "tests/test_stop_1567.py",
     "tests/test_store_contract.py",
+    "tests/test_store_migrate.py",
     "tests/test_stuck.py",
     "tests/test_stuck_test_state_watchdog_2803.py",
     "tests/test_terminal_command.py",
@@ -826,6 +829,8 @@
     "tests/test_worker_test_scoping.py",
     "tests/test_worktree.py",
     "tests/test_worktree_rmtree_chokepoint.py",
+    "tests/test_write_parity.py",
+    "tests/write_parity.py",
     "tui/Cargo.lock",
     "tui/Cargo.toml",
     "tui/cargo-config-local-quadraui.toml.example",

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

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

{code_coordinator-0.5.272 → code_coordinator-0.5.274}/coord/cli.py

@@ -147,6 +147,7 @@ from coord.commands.release import release_group, release_preflight
 # #2220: `coord repo add` / `coord repo doctor` — onboarding a repo, and
 # verifying it actually happened across all five layers.
 from coord.commands.repo import repo_group
+from coord.commands.store_migrate import migrate_to_postgres
 from coord.commands.plan_followup import (
     _dispatch_followup,  # noqa: F401 — re-exported for tests
     approve_plan,
@@ -491,6 +492,7 @@ main.add_command(release_preflight)
 main.add_command(release_group)
 # #2220: repo onboarding + its verifier.
 main.add_command(repo_group)
+main.add_command(migrate_to_postgres)
 main.add_command(tui_group)
 
 

code_coordinator-0.5.274/coord/commands/store_migrate.py

@@ -0,0 +1,105 @@
+"""``coord migrate-to-postgres`` -- one-shot import of an existing SQLite
+``coord.db`` into the Postgres store #827's ``store:`` config seam names
+(#828 second half). See ``coord.store_migrate`` for the actual audit/copy
+logic this command is a thin CLI wrapper around.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import click
+
+from coord import db as coord_db
+from coord import sql
+from coord.store_migrate import ImportAborted, run_import
+
+
+@click.command(
+    "migrate-to-postgres",
+    help=(
+        "Import an existing SQLite coord.db into the Postgres store configured "
+        "by coordinator.yml's store: block (#828). Audits referential integrity "
+        "and type-affinity drift before writing anything."
+    ),
+)
+@click.option(
+    "--source",
+    "source_path",
+    type=click.Path(path_type=Path),
+    default=None,
+    help="Path to the source coord.db (default: this install's DB_PATH).",
+)
+@click.option(
+    "--dsn",
+    default=None,
+    help="Target Postgres DSN (default: coordinator.yml's store.dsn).",
+)
+@click.option(
+    "--force",
+    is_flag=True,
+    help="Wipe and re-import any target tables that already have rows (default: refuse).",
+)
+@click.option(
+    "--dry-run",
+    is_flag=True,
+    help="Audit the source and report row counts without opening or writing the target.",
+)
+def migrate_to_postgres(
+    source_path: Path | None, dsn: str | None, force: bool, dry_run: bool
+) -> None:
+    source_path = source_path or coord_db.DB_PATH
+    if dsn is None and not dry_run:
+        target = coord_db._resolve_store_target()
+        if not target.dsn:
+            raise click.ClickException(
+                "no --dsn given and coordinator.yml has no store.dsn configured -- "
+                "pass --dsn explicitly, or set store.backend: postgres / store.dsn "
+                "in coordinator.yml first (#827)."
+            )
+        dsn = target.dsn
+
+    click.echo(f"Source: {source_path}")
+    # Never echo the raw DSN -- it routinely embeds a password
+    # (`store.dsn`'s plain-string shape, coord/config.py), and this command's
+    # stdout is exactly the kind of text that can end up in a log or a
+    # GitHub comment (coord.db._migrate_if_needed's docstring states the
+    # policy this follows). sql.redact_dsn() prints host/dbname only.
+    target_line = sql.redact_dsn(dsn) if dsn else "(dry-run -- target is never opened)"
+    click.echo(f"Target: {target_line}")
+
+    try:
+        report = run_import(sqlite_path=source_path, dsn=dsn or "", force=force, dry_run=dry_run)
+    except ImportAborted as exc:
+        raise click.ClickException(str(exc)) from exc
+
+    click.echo()
+    if report.dry_run:
+        # The target is never opened for a dry run, so TableReport.target_rows
+        # is a placeholder 0 -- printing a source/target/status table here
+        # would read every table as a false "MISMATCH". Report source counts
+        # only; the audits (referential integrity, type affinity) already ran
+        # and would have raised ImportAborted above if either found anything.
+        click.echo(f"{'table':<30} {'source rows':>12}")
+        for t in report.tables:
+            click.echo(f"{t.table:<30} {t.source_rows:>12}")
+        click.echo(
+            "\nAudits passed (referential integrity, type affinity). "
+            "Dry run -- no target opened, no rows written."
+        )
+        return
+
+    click.echo(f"{'table':<30} {'source':>10} {'target':>10}  status")
+    all_ok = True
+    for t in report.tables:
+        status = "OK" if t.ok else "MISMATCH"
+        if not t.ok:
+            all_ok = False
+        click.echo(f"{t.table:<30} {t.source_rows:>10} {t.target_rows:>10}  {status}")
+
+    if not all_ok:
+        raise click.ClickException(
+            "row-count parity mismatch after import -- see table above; the target "
+            "was written but does not match the source row-for-row"
+        )
+    click.echo("\nImport complete: row-count parity confirmed for every table.")

{code_coordinator-0.5.272 → code_coordinator-0.5.274}/coord/db.py

@@ -361,6 +361,20 @@ def _open_postgres(dsn: str) -> Any:
     return conn
 
 
+def open_postgres_connection(dsn: str) -> Any:
+    """Public entry point onto :func:`_open_postgres` for tooling that needs
+    a fully-migrated Postgres connection outside the ``get_connection()``
+    singleton -- today, only ``coord.store_migrate``'s importer (#828), which
+    opens a target that may not (yet) be the DSN this process's own
+    ``coordinator.yml`` names, so it calls this directly with whatever DSN
+    the operator gave it rather than going through :func:`get_connection`'s
+    config-resolution path. Same guarantees as every other caller of
+    :func:`_open_postgres`: refuses under pytest, and runs the same schema
+    creation/migration path SQLite gets (#827 item 3).
+    """
+    return _open_postgres(dsn)
+
+
 # #2752: a clean, tagged release is always exactly "X.Y.Z" -- setuptools_scm
 # only emits anything else (a ".devN+g<sha>" local/dev suffix, a bare
 # "0+unknown" when no distribution resolves at all, or git-describe's

{code_coordinator-0.5.272 → code_coordinator-0.5.274}/coord/sql.py

@@ -46,8 +46,10 @@ text for the same intent.
 
 from __future__ import annotations
 
+import re
 from pathlib import Path
 from typing import Any, Iterable, Sequence
+from urllib.parse import urlsplit, urlunsplit
 
 # ── dialects ──────────────────────────────────────────────────────────────
 #
@@ -71,6 +73,92 @@ class UnsupportedDialectError(ValueError):
     """Raised when a connection's driver module maps to no known dialect."""
 
 
+#: What to tell a caller who hit a Postgres codepath without the extra
+#: installed -- mirrors ``coord.commands._common.SERVER_EXTRA_INSTALL_HINT``'s
+#: shape for the ``[server]`` extra.
+POSTGRES_EXTRA_INSTALL_HINT = "pip install 'code-coordinator[postgres]'"
+
+
+# Libpq keyword=value DSN tokens: ``key=value`` or ``key='quoted value'``
+# (single-quoted values may escape ``\'`` and ``\\`` per libpq's own
+# grammar). Used only by :func:`redact_dsn` below.
+_DSN_KV_RE = re.compile(r"(\w+)\s*=\s*('(?:\\.|[^'\\])*'|\S+)")
+
+
+def redact_dsn(dsn: str) -> str:
+    """*dsn* with every credential-bearing field removed -- safe to print,
+    log, or post as a GitHub comment.
+
+    A Postgres DSN routinely embeds ``user:password@host`` (URI form,
+    ``postgresql://user:pass@host:port/db``) or ``user=... password=...``
+    (libpq keyword=value form, ``host=... dbname=... user=... password=...``)
+    -- ``coord/db.py``'s ``_migrate_if_needed`` docstring already states the
+    policy this exists to satisfy: a DSN must "deliberately never" appear in
+    text that "can end up in a log or a GitHub comment", since agent failure
+    reports post their captured stdout/stderr verbatim. Every caller that
+    would otherwise echo a configured ``store.dsn`` (e.g. ``coord
+    migrate-to-postgres``'s ``--dsn`` echo) must route through this first.
+
+    Returns host/dbname only (port too, when the DSN specifies one) -- not a
+    masked-but-recognizable form, so nothing of the credential survives even
+    truncated. Handles both DSN shapes; an unparseable field is rendered as
+    ``?`` rather than raising, since this exists for a diagnostic message,
+    not validation -- a malformed DSN should fail *later*, at
+    :func:`connect`, with a real error naming what's wrong.
+    """
+    stripped = dsn.strip()
+    if "://" in stripped:
+        parts = urlsplit(stripped)
+        host = parts.hostname or "?"
+        if parts.port:
+            host = f"{host}:{parts.port}"
+        dbname = parts.path.lstrip("/") or "?"
+        return urlunsplit((parts.scheme, host, dbname, "", ""))
+
+    def _unquote(value: str) -> str:
+        if len(value) >= 2 and value[0] == "'" and value[-1] == "'":
+            return value[1:-1].replace("\\'", "'").replace("\\\\", "\\")
+        return value
+
+    fields = {key: _unquote(value) for key, value in _DSN_KV_RE.findall(stripped)}
+    host = fields.get("host", "?")
+    if fields.get("port"):
+        host = f"{host}:{fields['port']}"
+    dbname = fields.get("dbname", "?")
+    return f"host={host} dbname={dbname}"
+
+
+def _import_psycopg() -> Any:
+    """Import ``psycopg``, translating its absence into an actionable message
+    (#2886).
+
+    ``psycopg`` is an optional dependency -- the ``postgres`` extra -- never a
+    base or ``[dev]`` one (see ``pyproject.toml``'s ``[project.optional-
+    dependencies]``): every existing SQLite deployment must keep working
+    without ever pulling it in. Hitting this on an install that never asked
+    for Postgres is therefore the expected, common case, not a bug -- so
+    every Postgres call site in this module that needs the driver
+    (:func:`connect`, :func:`row_factory_for`, :func:`driver_error`) routes
+    its import through here rather than a bare ``import psycopg``, so the
+    failure names the extra to install instead of surfacing a raw
+    ``ModuleNotFoundError: No module named 'psycopg'`` traceback.
+
+    :func:`driver_errors` deliberately does NOT route through here -- it
+    degrades silently to ``(sqlite3.Error,)`` when psycopg is absent (that is
+    its whole contract), so it keeps its own bare ``import psycopg`` inside a
+    caught ``try/except ImportError`` rather than raising through this
+    helper's message just to swallow it unread.
+    """
+    try:
+        import psycopg  # noqa: PLC0415 -- optional dep, see docstring
+    except ImportError as exc:  # ModuleNotFoundError is a subclass
+        raise ModuleNotFoundError(
+            "the Postgres backend needs the `psycopg` driver, which is not "
+            f"installed. Install it with: {POSTGRES_EXTRA_INSTALL_HINT}"
+        ) from exc
+    return psycopg
+
+
 def detect_dialect(conn: Any) -> str:
     """Identify *conn*'s SQL dialect from its concrete connection type.
 
@@ -136,7 +224,7 @@ def connect(
     superseded #2766 decision note.
 
     **Postgres** (``dsn`` required): ``psycopg.connect(dsn)``. ``psycopg`` is
-    an optional dependency (see :func:`row_factory_for`) imported
+    an optional dependency (see :func:`_import_psycopg`) imported
     function-locally, so calling this with ``backend=DIALECT_POSTGRES`` before
     psycopg is installed raises ``ImportError``/``ModuleNotFoundError`` rather
     than breaking import of this module for everyone else. *read_only* has no
@@ -157,7 +245,7 @@ def connect(
     if backend == DIALECT_POSTGRES:
         if not dsn:
             raise ValueError("sql.connect(backend='postgres') requires dsn")
-        import psycopg  # noqa: PLC0415 -- optional dep, see row_factory_for
+        psycopg = _import_psycopg()
 
         return psycopg.connect(dsn)
     raise UnsupportedDialectError(backend)
@@ -348,19 +436,20 @@ def row_factory_for(dialect: str) -> Any:
 
     ``sqlite3.Row`` is returned directly (it's a base-dependency import,
     already used throughout this tree).  ``psycopg.rows.dict_row`` is
-    imported function-locally -- ``psycopg`` is not a base or even a
-    ``server``-extra dependency yet (see ``pyproject.toml``'s ``[project]
-    dependencies`` comment on why third-party imports the base client
-    doesn't need stay function-local) -- so calling this with
-    :data:`DIALECT_POSTGRES` before a Postgres backend is actually installed
-    raises ``ImportError``/``ModuleNotFoundError`` rather than breaking
-    import of this module for everyone else.
+    imported function-locally -- ``psycopg`` is an optional dependency (the
+    ``postgres`` extra, #2886), never a base or ``[dev]`` one (see
+    ``pyproject.toml``'s ``[project.optional-dependencies]``) -- so calling
+    this with :data:`DIALECT_POSTGRES` before the extra is installed raises
+    ``ImportError``/``ModuleNotFoundError``, naming the extra to install
+    (see :func:`_import_psycopg`), rather than breaking import of this
+    module for everyone else.
     """
     if dialect == DIALECT_SQLITE:
         import sqlite3
 
         return sqlite3.Row
     if dialect == DIALECT_POSTGRES:
+        _import_psycopg()  # translate a missing psycopg into an actionable message
         from psycopg.rows import dict_row  # noqa: PLC0415 -- optional dep, see docstring
 
         return dict_row
@@ -440,6 +529,77 @@ def autoincrement_pk_ddl(dialect: str) -> str:
     raise UnsupportedDialectError(dialect)
 
 
+def identity_columns(conn: Any, table: str) -> list[str]:
+    """Column names in *table* declared ``GENERATED { ALWAYS | BY DEFAULT }
+    AS IDENTITY`` -- i.e. produced by :func:`autoincrement_pk_ddl`'s Postgres
+    branch. Always ``[]`` on SQLite: ``AUTOINCREMENT`` is a ROWID alias, not
+    a separate sequence object, so there is nothing to fall out of sync
+    (see :func:`resync_identity_sequence`).
+
+    Used by ``coord.store_migrate.import_table`` -- a bulk import writes
+    explicit ``id`` values into these columns (accepted by
+    ``GENERATED BY DEFAULT``, unlike ``GENERATED ALWAYS``), which does not
+    itself advance the underlying sequence, so the caller must resync it
+    afterward or the next ordinary write collides with an id the import
+    already used.
+    """
+    dialect = detect_dialect(conn)
+    if dialect == DIALECT_SQLITE:
+        return []
+    if dialect == DIALECT_POSTGRES:
+        cur = execute(
+            conn,
+            "SELECT column_name FROM information_schema.columns "
+            "WHERE table_name = ? AND identity_generation IS NOT NULL "
+            "ORDER BY ordinal_position",
+            (table,),
+        )
+        names = []
+        for row in cur.fetchall():
+            try:
+                names.append(row["column_name"])
+            except (KeyError, TypeError, IndexError):
+                names.append(row[0])
+        return names
+    raise UnsupportedDialectError(dialect)
+
+
+def resync_identity_sequence(conn: Any, table: str, column: str) -> None:
+    """Advance *table*.*column*'s identity sequence to match the data
+    actually in the table -- a no-op on SQLite.
+
+    A bulk import that INSERTs explicit ``id`` values into a
+    ``GENERATED BY DEFAULT AS IDENTITY`` column (see
+    :func:`autoincrement_pk_ddl`) does not advance that column's sequence as
+    a side effect -- the sequence only moves when something calls
+    ``nextval()`` on it, which an explicit-value INSERT never does. Left
+    unresynced, the next ordinary write with no explicit id (how every
+    caller in this tree writes today) is handed a value the import already
+    used and rejected as a primary-key violation.
+
+    ``setval(pg_get_serial_sequence(...), ..., is_called)``'s three-arg form
+    is used rather than the two-arg form specifically for the empty-table
+    case: with *is_called* explicitly computed as "does the table have any
+    rows", an empty table correctly leaves the sequence so the *next*
+    ``nextval()`` returns the identity's own start value (1) instead of 2,
+    which the two-arg form (which always behaves as if ``is_called=true``)
+    would get wrong.
+    """
+    dialect = detect_dialect(conn)
+    if dialect == DIALECT_SQLITE:
+        return
+    if dialect == DIALECT_POSTGRES:
+        execute(
+            conn,
+            "SELECT setval(pg_get_serial_sequence(?, ?), "
+            f'COALESCE((SELECT MAX("{column}") FROM "{table}"), 1), '  # noqa: S608 -- column/table from introspection, not user input
+            f'(SELECT MAX("{column}") FROM "{table}") IS NOT NULL)',  # noqa: S608
+            (table, column),
+        )
+        return
+    raise UnsupportedDialectError(dialect)
+
+
 # SQLite has no BOOLEAN type -- every flag column in coord/db.py's schema
 # (e.g. ``pinned INTEGER NOT NULL DEFAULT 0``, ``hold_after INTEGER NOT
 # NULL DEFAULT 0``) is declared ``INTEGER DEFAULT 0``, using 0/1 as
@@ -568,6 +728,71 @@ def table_columns(conn: Any, table: str) -> list[tuple[str, str]]:
     raise UnsupportedDialectError(dialect)
 
 
+def foreign_keys(conn: Any, table: str) -> list[tuple[str, str, str]]:
+    """Return ``[(from_column, ref_table, ref_column), ...]`` for every FK
+    *table* declares (empty if none, or if *table* doesn't exist) --
+    portably across SQLite's ``PRAGMA foreign_key_list(...)`` and Postgres's
+    standard ``information_schema`` constraint views (#828).
+
+    SQLite's FK introspection is a pragma, like ``table_info`` above -- same
+    reasoning, same fix: this is the one place that pragma's statement text
+    may appear outside ``coord/db.py``, so a caller (``coord.store_migrate``,
+    today) never writes it directly. Postgres has no single-pragma
+    equivalent; the standard three-way join across
+    ``information_schema.table_constraints`` /
+    ``key_column_usage`` / ``constraint_column_usage`` is the SQL-standard
+    way to ask "what does this table reference, and through which column"
+    without touching Postgres's own (non-standard) ``pg_catalog`` tables.
+
+    The table name is interpolated into the SQLite ``PRAGMA`` text for the
+    same reason :func:`table_columns` does -- pragmas take no bound
+    parameter for their target object; every call site passes a hardcoded
+    table constant, never user input.
+
+    Known limitation, Postgres branch: the three-way join keys purely on
+    ``constraint_name``/``table_schema``, with no ordinal-position join
+    between ``key_column_usage`` and ``constraint_column_usage``. For a
+    *composite* (multi-column) foreign key this can mis-pair columns --
+    e.g. return ``(col_a, ref_table, ref_col_b)`` instead of the two
+    correctly-paired single-column edges. Not triggered today: the schema
+    has exactly one FK, and it's single-column. Fix before adding a
+    composite FK to ``coord/db.py``'s schema: join on ``ordinal_position``
+    too (Postgres exposes it on both views).
+    """
+    dialect = detect_dialect(conn)
+    if dialect == DIALECT_SQLITE:
+        cur = execute(conn, f"PRAGMA foreign_key_list({table})")  # noqa: S608 -- table name, not user input
+        edges = []
+        for row in cur.fetchall():
+            values = tuple(row)
+            # id, seq, table, from, to, on_update, on_delete, match
+            edges.append((values[3], values[2], values[4] or "rowid"))
+        return edges
+    if dialect == DIALECT_POSTGRES:
+        cur = execute(
+            conn,
+            "SELECT kcu.column_name, ccu.table_name AS ref_table, "
+            "ccu.column_name AS ref_column "
+            "FROM information_schema.table_constraints tc "
+            "JOIN information_schema.key_column_usage kcu "
+            "  ON tc.constraint_name = kcu.constraint_name "
+            "  AND tc.table_schema = kcu.table_schema "
+            "JOIN information_schema.constraint_column_usage ccu "
+            "  ON tc.constraint_name = ccu.constraint_name "
+            "  AND tc.table_schema = ccu.table_schema "
+            "WHERE tc.constraint_type = 'FOREIGN KEY' AND tc.table_name = ?",
+            (table,),
+        )
+        edges = []
+        for row in cur.fetchall():
+            try:
+                edges.append((row["column_name"], row["ref_table"], row["ref_column"]))
+            except (KeyError, TypeError, IndexError):
+                edges.append((row[0], row[1], row[2]))
+        return edges
+    raise UnsupportedDialectError(dialect)
+
+
 # ── WAL (#2782) ───────────────────────────────────────────────────────────
 #
 # WAL is a SQLite storage concept with no Postgres equivalent at all -- unlike
@@ -615,7 +840,7 @@ def driver_error(conn: Any) -> type[BaseException]:
 
         return sqlite3.Error
     if dialect == DIALECT_POSTGRES:
-        import psycopg  # noqa: PLC0415 -- optional dep, see row_factory_for
+        psycopg = _import_psycopg()
 
         return psycopg.Error
     raise UnsupportedDialectError(dialect)
@@ -637,13 +862,15 @@ def driver_errors() -> tuple[type[BaseException], ...]:
     instead of a retried write.
 
     ``sqlite3`` is a stdlib module -- always present, always included.
-    ``psycopg`` is not a declared dependency (see :func:`row_factory_for`),
-    so its absence is the normal case today, not an error: this degrades to
-    ``(sqlite3.Error,)`` rather than raising ``ImportError``, the same
-    "absence is normal" posture :func:`row_factory_for` takes for a
-    *known* dialect with no live connection to detect it from -- except
-    here there is no dialect to detect at all, so degrading silently (not
-    even function-local, deferred-import-style) is correct: a caller doing
+    ``psycopg`` is an optional dependency, not a base or ``[dev]`` one (see
+    :func:`_import_psycopg`), so its absence is the normal case today, not an
+    error: this degrades to ``(sqlite3.Error,)`` rather than raising
+    ``ImportError`` -- unlike every other Postgres call site in this module,
+    this one does NOT route through :func:`_import_psycopg` and its
+    actionable message, precisely because the message would just be
+    swallowed unread by the ``except ImportError`` below; there is no dialect
+    to detect at all here, so degrading silently (not even
+    function-local, deferred-import-style) is correct: a caller doing
     ``except sql.driver_errors():`` on a SQLite-only install must keep
     behaving exactly as ``except sqlite3.OperationalError:`` always did.
 
@@ -656,7 +883,7 @@ def driver_errors() -> tuple[type[BaseException], ...]:
 
     errors: list[type[BaseException]] = [sqlite3.Error]
     try:
-        import psycopg  # noqa: PLC0415 -- optional dep, see row_factory_for
+        import psycopg  # noqa: PLC0415 -- optional dep, absence degrades silently, see docstring
     except ImportError:
         pass
     else: