code-coordinator 0.5.202__tar.gz → 0.5.203__tar.gz

{code_coordinator-0.5.202 → code_coordinator-0.5.203}/PKG-INFO

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

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

@@ -586,6 +586,7 @@ tests/test_plan_parser.py
 tests/test_platform_paths.py
 tests/test_portal_bridge.py
 tests/test_portal_config.py
+tests/test_portal_store.py
 tests/test_portal_sync.py
 tests/test_pr_body_lint.py
 tests/test_prereqs.py

{code_coordinator-0.5.202 → code_coordinator-0.5.203}/code_coordinator.egg-info/scm_file_list.json

@@ -648,6 +648,7 @@
     "tests/test_platform_paths.py",
     "tests/test_portal_bridge.py",
     "tests/test_portal_config.py",
+    "tests/test_portal_store.py",
     "tests/test_portal_sync.py",
     "tests/test_pr_body_lint.py",
     "tests/test_prereqs.py",

{code_coordinator-0.5.202 → code_coordinator-0.5.203}/code_coordinator.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.202",
+  "tag": "0.5.203",
   "distance": 0,
-  "node": "ga9e29961ca26348c484ecee55a737e8c98826ac8",
+  "node": "gdac58130113c138d2461927553c0e5039233000e",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-21"

{code_coordinator-0.5.202 → code_coordinator-0.5.203}/coord/commands/portal.py

@@ -31,6 +31,8 @@ follow-up); this is the "fail loud instead of running wrong" half.
 
 from __future__ import annotations
 
+import datetime
+import getpass
 import json
 
 import click
@@ -44,6 +46,13 @@ from coord.portal_bridge import (
 )
 
 
+def _actor() -> str:
+    try:
+        return getpass.getuser()
+    except Exception:  # noqa: BLE001 — no passwd entry in some containers
+        return "unknown"
+
+
 def _refuse_if_thin_client(cmd_name: str) -> None:
     """Refuse *cmd_name* when this machine isn't the daemon host (#2336).
 
@@ -194,6 +203,87 @@ def portal_push(config_path, submission_id: str, revision: int, status: str) ->
     raise SystemExit(1)
 
 
+# ── #2507: milestone ↔ portal submission linkage ────────────────────────────
+
+
+@portal_group.command("link")
+@_CONFIG_OPTION
+@click.argument("repo")
+@click.argument("milestone_number", type=int)
+@click.argument("submission_id", required=False)
+def portal_link(
+    config_path, repo: str, milestone_number: int, submission_id: str | None
+) -> None:
+    """Record, or read, one milestone's portal submission_id link (#2507).
+
+    With SUBMISSION_ID: link REPO's milestone MILESTONE_NUMBER to it.
+    Operator-run — submission creation is driven by the portal's own intake
+    flow, not by coord, so there is currently no automatic way for coord to
+    learn a submission exists at all.
+
+    Without SUBMISSION_ID: report the current link, mirroring `coord gate-a`'s
+    read/write dual-mode shape.
+
+    Nothing downstream resolves this automatically yet — PDR-3's auto-push
+    and PDR-4's verdict consumer (the epic's later legs, #2506) are what will
+    read it once they exist.
+    """
+    _refuse_if_thin_client("link")
+
+    from coord import portal_store  # noqa: PLC0415
+    from coord.audit import record_audit  # noqa: PLC0415
+
+    cfg = _load_config(config_path)
+    repo_cfg = cfg.repo(repo)
+    if repo_cfg is None:
+        click.secho(f"error: unknown repo {repo!r}", fg="red")
+        raise SystemExit(2)
+
+    if submission_id is None:
+        link = portal_store.get_milestone_link(
+            repo_name=repo_cfg.name, milestone_number=milestone_number
+        )
+        if link is None:
+            click.echo(f"{repo_cfg.name} ms-{milestone_number}: not linked")
+            raise SystemExit(1)
+        when = datetime.datetime.fromtimestamp(
+            link.linked_at, tz=datetime.timezone.utc
+        ).strftime("%Y-%m-%d %H:%M UTC")
+        click.echo(
+            f"{repo_cfg.name} ms-{milestone_number}: "
+            f"submission_id={link.submission_id} "
+            f"(linked by {link.actor or 'unknown'} at {when})"
+        )
+        return
+
+    link = portal_store.link_milestone(
+        repo_name=repo_cfg.name,
+        milestone_number=milestone_number,
+        submission_id=submission_id,
+        actor=_actor(),
+    )
+    record_audit(
+        tier="business",
+        category="portal",
+        event_type="portal_link",
+        actor=link.actor,
+        summary=(
+            f"linked {repo_cfg.name} ms-{milestone_number} to portal "
+            f"submission {submission_id}"
+        ),
+        repo=repo_cfg.name,
+        details={
+            "milestone_number": milestone_number,
+            "submission_id": submission_id,
+        },
+    )
+    click.secho(
+        f"linked: {repo_cfg.name} ms-{milestone_number} -> "
+        f"submission_id={submission_id}",
+        fg="green",
+    )
+
+
 # ── #1982: the sync loop's operator surface ─────────────────────────────────
 
 

{code_coordinator-0.5.202 → code_coordinator-0.5.203}/coord/portal_bridge.py

@@ -13,9 +13,13 @@ those are separate, harder design questions and belong to follow-up issues:
 * It does not decide **when** to push. Nothing here reads coord's board or
   watches assignment status transitions. Callers hand it
   ``(submission_id, revision, status)`` and it sends that; where those three
-  values come from — the submission↔work association, and the mapping from
-  coord's internal states to the portal's pinned customer vocabulary — is
-  out of scope here.
+  values come from is out of scope here. The submission↔work association is
+  now resolvable — :func:`coord.portal_store.get_milestone_link` reads the
+  durable ``(repo, milestone_number) -> submission_id`` mapping an operator
+  records with ``coord portal link`` (#2507) — but nothing in this module
+  calls it: this client still just sends whatever ``submission_id`` a caller
+  hands it. The mapping from coord's internal states to the portal's pinned
+  customer vocabulary is a separate, still-unaddressed question.
 * It does not persist a revision counter. The portal is idempotent by
   ``(submission_id, revision)`` and ignores anything at or below its stored
   watermark (see ``applyUpdate`` in coord-portal's ``src/bridge/updates.ts``),

{code_coordinator-0.5.202 → code_coordinator-0.5.203}/coord/portal_store.py

@@ -762,3 +762,135 @@ def note_error(error: str) -> None:
 
 def clear_error() -> None:
     _update_sync_state(last_error="")
+
+
+# ── #2507: milestone ↔ portal submission linkage ────────────────────────────
+#
+# Every table above is part of the sync bridge's own SQLite schema
+# (``coord.db``'s ``_ensure_schema``) and, per the module docstring, is
+# deliberately daemon-host-only. The link between a coord milestone and a
+# portal ``submission_id`` is a DIFFERENT kind of fact — nothing here creates
+# or drives it (the portal's own intake flow does, out of coord's sight) —
+# but it still needs the same durability and the same "read anywhere, write
+# on the daemon host" story, so it is persisted through
+# :mod:`coord.state`'s ``portal_links`` board_meta seam (same shape as
+# ``coord.gate_a``'s ``GateAApproval`` / ``gate_a_approvals``) rather than a
+# fifth table here. This is the domain half — :mod:`coord.state` only knows
+# plain dicts, this is where the dict shape is pinned down and given a
+# tolerant decoder.
+#
+# Consumers: PDR-3's auto-push (resolve a milestone's outbox destination) and
+# PDR-4's verdict consumer (resolve an inbound portal event back to a
+# milestone) both need exactly this lookup and have nowhere else to get it
+# (#2507 — confirmed by grep, ``submission_id`` appeared in neither
+# ``coord/config.py``, ``coord/milestone*.py``, nor ``coord/gate_a.py``
+# before this).
+
+_LINK_SCHEMA = 1
+
+
+@dataclass(frozen=True)
+class PortalLink:
+    """One durable ``(repo_name, milestone_number)`` → portal ``submission_id``
+    mapping, set by an operator with ``coord portal link`` once a submission
+    exists on the portal side.
+    """
+
+    repo_name: str
+    milestone_number: int
+    submission_id: str
+    linked_at: float = 0.0
+    actor: str = ""
+    schema: int = _LINK_SCHEMA
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "repo_name": self.repo_name,
+            "milestone_number": self.milestone_number,
+            "submission_id": self.submission_id,
+            "linked_at": self.linked_at,
+            "actor": self.actor,
+            "schema": self.schema,
+        }
+
+    @classmethod
+    def from_dict(cls, raw: Any) -> "PortalLink | None":
+        """Tolerant decode — ``None`` for anything this build can't read.
+
+        Same posture as :meth:`coord.gate_a.GateAApproval.from_dict`: a
+        record written by a newer schema, or a corrupt one, degrades to "no
+        link recorded" rather than crashing a caller that resolves one
+        milestone at a time.
+        """
+        if not isinstance(raw, dict):
+            return None
+        if int(raw.get("schema", _LINK_SCHEMA) or _LINK_SCHEMA) != _LINK_SCHEMA:
+            return None
+        repo_name = raw.get("repo_name")
+        if not isinstance(repo_name, str) or not repo_name:
+            return None
+        milestone_number = _as_int_or_none(raw.get("milestone_number"))
+        if milestone_number is None:
+            return None
+        submission_id = raw.get("submission_id")
+        if not isinstance(submission_id, str) or not submission_id:
+            return None
+        return cls(
+            repo_name=repo_name,
+            milestone_number=milestone_number,
+            submission_id=submission_id,
+            linked_at=float(raw.get("linked_at") or 0.0),
+            actor=str(raw.get("actor") or ""),
+        )
+
+
+def _as_int_or_none(value: Any) -> int | None:
+    try:
+        return int(value)
+    except (TypeError, ValueError):
+        return None
+
+
+def link_milestone(
+    *,
+    repo_name: str,
+    milestone_number: int,
+    submission_id: str,
+    actor: str = "",
+    now: float | None = None,
+) -> PortalLink:
+    """Record (or overwrite) the portal submission_id for one milestone.
+
+    Overwrite, not append: there is exactly one live submission_id per
+    milestone, matching :func:`coord.state.save_gate_a_approval`'s semantics
+    for the same reason. Relinking is expected — an operator fixing a typo'd
+    submission_id, or correcting an id entered against the wrong milestone —
+    not an error case.
+    """
+    from coord import state  # noqa: PLC0415
+
+    record = PortalLink(
+        repo_name=repo_name,
+        milestone_number=int(milestone_number),
+        submission_id=submission_id,
+        linked_at=time.time() if now is None else now,
+        actor=actor,
+    )
+    state.save_portal_link(record.to_dict())
+    return record
+
+
+def get_milestone_link(*, repo_name: str, milestone_number: int) -> PortalLink | None:
+    """The current portal link for one milestone, or ``None`` if unlinked."""
+    from coord import state  # noqa: PLC0415
+
+    raw = state.get_portal_link(repo_name=repo_name, milestone_number=milestone_number)
+    return PortalLink.from_dict(raw) if raw is not None else None
+
+
+def list_milestone_links() -> list[PortalLink]:
+    """Every recorded milestone ↔ submission link."""
+    from coord import state  # noqa: PLC0415
+
+    links = [PortalLink.from_dict(raw) for raw in state.list_portal_links()]
+    return [link for link in links if link is not None]

{code_coordinator-0.5.202 → code_coordinator-0.5.203}/coord/state.py

@@ -3843,6 +3843,104 @@ def _load_gate_a_approvals_raw(conn: sqlite3.Connection) -> list[dict]:
     return [d for d in data if isinstance(d, dict)]
 
 
+# ── #2507: milestone ↔ portal submission linkage ────────────────────────────
+#
+# One JSON record per ``(repo_name, milestone_number)`` under the
+# ``portal_links`` board_meta key — the same seam and the same
+# whole-list-rewrite shape as ``gate_a_approvals`` above (the row count is
+# "milestones actually linked to a portal submission", i.e. single digits,
+# and one board read answers "does this milestone have a submission_id").
+#
+# Unlike ``gate_a_approvals``, this is deliberately LOCAL ONLY — no
+# ``_route_write``/``_board_service`` daemon routing. The rest of the portal
+# bridge's durable state (:mod:`coord.portal_store`'s four ``portal_*``
+# tables) has no daemon proxy either: every state-touching ``coord portal``
+# command is a daemon-host command, run over ``ssh``, and refuses outright on
+# a thin client (``coord.commands.portal._refuse_if_thin_client``, #2336).
+# This mapping follows that already-established rule — read/write via
+# ``coord portal link`` on the daemon host — rather than inventing a second
+# I/O story for one record type. Giving the whole bridge real cross-machine
+# routing is Option A in #2336, left for a follow-up.
+#
+# The domain shape (``PortalLink``, tolerant ``from_dict``) lives in
+# :mod:`coord.portal_store`, which calls the functions below the same way
+# :mod:`coord.gate_a` calls :func:`save_gate_a_approval` /
+# :func:`get_gate_a_approval` — this module only knows about plain dicts.
+
+
+def save_portal_link(record: dict) -> None:
+    """Upsert one milestone's portal ``submission_id`` link.
+
+    Keyed on ``(repo_name, milestone_number)``; an existing link for that
+    pair is replaced wholesale — relinking a milestone to a different
+    ``submission_id`` is a plain overwrite, matching
+    :func:`save_gate_a_approval`'s semantics for the same reason (exactly one
+    live link per milestone).
+    """
+    _save_portal_link_local(record)
+
+
+def _save_portal_link_local(record: dict) -> None:
+    repo_name = record.get("repo_name")
+    milestone_number = record.get("milestone_number")
+    if not isinstance(repo_name, str) or not repo_name or milestone_number is None:
+        raise ValueError("portal link needs repo_name + milestone_number")
+    milestone_number = int(milestone_number)
+    record = {**record, "milestone_number": milestone_number}
+
+    conn = get_connection()
+    with conn:
+        links = _load_portal_links_raw(conn)
+        key = (repo_name, milestone_number)
+        remaining = [
+            link for link in links
+            if (link.get("repo_name"), _as_int(link.get("milestone_number"))) != key
+        ]
+        remaining.append(record)
+        conn.execute(
+            "INSERT OR REPLACE INTO board_meta (key, value) VALUES "
+            "('portal_links', ?)",
+            (json.dumps(remaining),),
+        )
+
+
+def list_portal_links() -> list[dict]:
+    """Every recorded milestone ↔ submission link (local DB only)."""
+    conn = get_connection()
+    return _load_portal_links_raw(conn)
+
+
+def get_portal_link(*, repo_name: str, milestone_number: int) -> dict | None:
+    """One milestone's portal link, or ``None`` if nobody has recorded one.
+
+    Local-DB only, like :func:`list_portal_links` — see the section docstring
+    above for why this does not route to the daemon like
+    :func:`get_gate_a_approval` does.
+    """
+    for link in list_portal_links():
+        if (
+            link.get("repo_name") == repo_name
+            and _as_int(link.get("milestone_number")) == milestone_number
+        ):
+            return link
+    return None
+
+
+def _load_portal_links_raw(conn: sqlite3.Connection) -> list[dict]:
+    row = conn.execute(
+        "SELECT value FROM board_meta WHERE key = 'portal_links'"
+    ).fetchone()
+    if row is None:
+        return []
+    try:
+        data = json.loads(row["value"])
+    except (TypeError, ValueError):
+        return []
+    if not isinstance(data, list):
+        return []
+    return [d for d in data if isinstance(d, dict)]
+
+
 def delete_milestone_gate(*, repo_name: str, tracking_issue: int) -> None:
     """Drop a milestone from gate control.
 

{code_coordinator-0.5.202 → code_coordinator-0.5.203}/tests/test_cli_portal.py

@@ -84,7 +84,7 @@ def run(*args):
 def test_portal_group_is_registered():
     result = run("portal", "--help")
     assert result.exit_code == 0
-    for sub in ("status", "heartbeat", "push"):
+    for sub in ("status", "heartbeat", "push", "link"):
         assert sub in result.output
 
 
@@ -223,6 +223,55 @@ def test_push_reports_rejection_as_failure(config_path, monkeypatch):
     assert "unknown_submission" in result.output
 
 
+# ── #2507: milestone ↔ portal submission linkage ────────────────────────────
+
+
+def test_link_reports_unlinked_by_default(config_path):
+    result = run("portal", "link", "--config", config_path, "coord", "3")
+    assert result.exit_code != 0
+    assert "not linked" in result.output
+
+
+def test_link_writes_then_reads_back(config_path):
+    write = run(
+        "portal", "link", "--config", config_path, "coord", "3", "sub_abc123"
+    )
+    assert write.exit_code == 0, write.output
+    assert "linked" in write.output
+    assert "sub_abc123" in write.output
+
+    read = run("portal", "link", "--config", config_path, "coord", "3")
+    assert read.exit_code == 0, read.output
+    assert "submission_id=sub_abc123" in read.output
+
+
+def test_link_relink_overwrites_not_appends(config_path):
+    run("portal", "link", "--config", config_path, "coord", "3", "sub_typo")
+    run("portal", "link", "--config", config_path, "coord", "3", "sub_fixed")
+
+    read = run("portal", "link", "--config", config_path, "coord", "3")
+    assert read.exit_code == 0, read.output
+    assert "submission_id=sub_fixed" in read.output
+    assert "sub_typo" not in read.output
+
+
+def test_link_is_scoped_to_milestone_number(config_path):
+    """Same repo, different milestone — distinct links, no cross-talk."""
+    run("portal", "link", "--config", config_path, "coord", "3", "sub_ms3")
+    run("portal", "link", "--config", config_path, "coord", "9", "sub_ms9")
+
+    ms3 = run("portal", "link", "--config", config_path, "coord", "3")
+    ms9 = run("portal", "link", "--config", config_path, "coord", "9")
+    assert "submission_id=sub_ms3" in ms3.output
+    assert "submission_id=sub_ms9" in ms9.output
+
+
+def test_link_rejects_unknown_repo(config_path):
+    result = run("portal", "link", "--config", config_path, "nope", "3", "sub_1")
+    assert result.exit_code != 0
+    assert "unknown repo" in result.output
+
+
 # ── #1982: the sync loop's operator surface ─────────────────────────────────
 
 
@@ -361,6 +410,8 @@ def thin_client(monkeypatch):
         ("portal", "sync"),
         ("portal", "outbox"),
         ("portal", "events"),
+        ("portal", "link", "coord", "3"),
+        ("portal", "link", "coord", "3", "sub_1"),
         ("portal", "enqueue-status", "sub_1", "shipped"),
         ("portal", "enqueue-design-round", "sub_1", "{}"),
         ("portal", "enqueue-preview", "sub_1", "https://pr-1.example.pages.dev"),

code_coordinator-0.5.203/tests/test_portal_store.py

@@ -0,0 +1,176 @@
+"""#2507: milestone <-> portal submission_id linkage.
+
+Covers the domain layer (`coord.portal_store.PortalLink` + its wrapper
+functions) and the underlying board_meta persistence in `coord.state`, the
+same split `tests/test_gate_a.py`'s `TestPersistence` covers for
+`GateAApproval` / `save_gate_a_approval` — this is the analogous seam, one
+level over in the portal bridge.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+
+class TestPortalLinkFromDict:
+    def test_round_trips_through_to_dict(self) -> None:
+        from coord.portal_store import PortalLink
+
+        link = PortalLink(
+            repo_name="acme-portal",
+            milestone_number=3,
+            submission_id="sub_abc123",
+            linked_at=1000.0,
+            actor="john",
+        )
+        again = PortalLink.from_dict(link.to_dict())
+        assert again == link
+
+    def test_rejects_not_a_dict(self) -> None:
+        from coord.portal_store import PortalLink
+
+        assert PortalLink.from_dict(None) is None
+        assert PortalLink.from_dict("sub_abc123") is None
+
+    def test_rejects_missing_repo_name(self) -> None:
+        from coord.portal_store import PortalLink
+
+        assert PortalLink.from_dict(
+            {"milestone_number": 3, "submission_id": "sub_1"}
+        ) is None
+
+    def test_rejects_missing_milestone_number(self) -> None:
+        from coord.portal_store import PortalLink
+
+        assert PortalLink.from_dict(
+            {"repo_name": "acme-portal", "submission_id": "sub_1"}
+        ) is None
+
+    def test_rejects_missing_submission_id(self) -> None:
+        from coord.portal_store import PortalLink
+
+        assert PortalLink.from_dict(
+            {"repo_name": "acme-portal", "milestone_number": 3}
+        ) is None
+
+    def test_rejects_a_newer_schema(self) -> None:
+        from coord.portal_store import PortalLink
+
+        assert PortalLink.from_dict(
+            {
+                "repo_name": "acme-portal",
+                "milestone_number": 3,
+                "submission_id": "sub_1",
+                "schema": 999,
+            }
+        ) is None
+
+    def test_tolerates_a_stringy_milestone_number(self) -> None:
+        from coord.portal_store import PortalLink
+
+        link = PortalLink.from_dict(
+            {
+                "repo_name": "acme-portal",
+                "milestone_number": "3",
+                "submission_id": "sub_1",
+            }
+        )
+        assert link is not None
+        assert link.milestone_number == 3
+
+
+class TestLinkMilestone:
+    def test_link_then_get(self, coord_db) -> None:
+        from coord.portal_store import get_milestone_link, link_milestone
+
+        link_milestone(
+            repo_name="acme-portal",
+            milestone_number=3,
+            submission_id="sub_abc123",
+            actor="john",
+            now=1000.0,
+        )
+        found = get_milestone_link(repo_name="acme-portal", milestone_number=3)
+        assert found is not None
+        assert found.submission_id == "sub_abc123"
+        assert found.actor == "john"
+        assert found.linked_at == 1000.0
+
+    def test_get_returns_none_when_unlinked(self, coord_db) -> None:
+        from coord.portal_store import get_milestone_link
+
+        assert get_milestone_link(repo_name="acme-portal", milestone_number=3) is None
+
+    def test_relink_overwrites_not_appends(self, coord_db) -> None:
+        from coord.portal_store import (
+            get_milestone_link,
+            link_milestone,
+            list_milestone_links,
+        )
+
+        link_milestone(
+            repo_name="acme-portal", milestone_number=3, submission_id="sub_typo"
+        )
+        link_milestone(
+            repo_name="acme-portal", milestone_number=3, submission_id="sub_fixed"
+        )
+        links = [
+            link
+            for link in list_milestone_links()
+            if link.repo_name == "acme-portal" and link.milestone_number == 3
+        ]
+        assert len(links) == 1
+        assert links[0].submission_id == "sub_fixed"
+        assert (
+            get_milestone_link(repo_name="acme-portal", milestone_number=3).submission_id
+            == "sub_fixed"
+        )
+
+    def test_different_milestones_coexist(self, coord_db) -> None:
+        from coord.portal_store import get_milestone_link, link_milestone
+
+        link_milestone(
+            repo_name="acme-portal", milestone_number=3, submission_id="sub_ms3"
+        )
+        link_milestone(
+            repo_name="acme-portal", milestone_number=9, submission_id="sub_ms9"
+        )
+        assert (
+            get_milestone_link(repo_name="acme-portal", milestone_number=3).submission_id
+            == "sub_ms3"
+        )
+        assert (
+            get_milestone_link(repo_name="acme-portal", milestone_number=9).submission_id
+            == "sub_ms9"
+        )
+
+    def test_different_repos_do_not_collide(self, coord_db) -> None:
+        from coord.portal_store import get_milestone_link, link_milestone
+
+        link_milestone(repo_name="repo-a", milestone_number=3, submission_id="sub_a")
+        link_milestone(repo_name="repo-b", milestone_number=3, submission_id="sub_b")
+        assert (
+            get_milestone_link(repo_name="repo-a", milestone_number=3).submission_id
+            == "sub_a"
+        )
+        assert (
+            get_milestone_link(repo_name="repo-b", milestone_number=3).submission_id
+            == "sub_b"
+        )
+
+
+class TestStatePersistenceDirect:
+    """The board_meta seam itself — `coord.state`'s half, exercised the same
+    way `TestPersistence` in `tests/test_gate_a.py` exercises the sibling
+    `gate_a_approvals` seam."""
+
+    def test_record_without_a_key_is_rejected(self, coord_db) -> None:
+        from coord.state import _save_portal_link_local
+
+        with pytest.raises(ValueError):
+            _save_portal_link_local({"submission_id": "sub_1"})
+
+    def test_list_is_empty_by_default(self, coord_db) -> None:
+        from coord.state import list_portal_links
+
+        assert list_portal_links() == []