code-coordinator 0.5.269__tar.gz → 0.5.271__tar.gz

{code_coordinator-0.5.269 → code_coordinator-0.5.271}/PKG-INFO

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

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

@@ -714,6 +714,7 @@ tests/test_split.py
 tests/test_split_work.py
 tests/test_sql_dialect.py
 tests/test_stage_projection.py
+tests/test_stale_busy_reviewer_697.py
 tests/test_stalled_pipeline.py
 tests/test_state.py
 tests/test_state_review_findings_daemon.py

{code_coordinator-0.5.269 → code_coordinator-0.5.271}/code_coordinator.egg-info/scm_file_list.json

@@ -786,6 +786,7 @@
     "tests/test_split_work.py",
     "tests/test_sql_dialect.py",
     "tests/test_stage_projection.py",
+    "tests/test_stale_busy_reviewer_697.py",
     "tests/test_stalled_pipeline.py",
     "tests/test_state.py",
     "tests/test_state_review_findings_daemon.py",

{code_coordinator-0.5.269 → code_coordinator-0.5.271}/code_coordinator.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.269",
+  "tag": "0.5.271",
   "distance": 0,
-  "node": "gfb3b3633ce05c303a5c7243c93486fab73020f5e",
+  "node": "g3a55bb4d487d0d86bef5f81d01ac8744d9ecdf16",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-28"

{code_coordinator-0.5.269 → code_coordinator-0.5.271}/coord/drive.py

@@ -94,7 +94,7 @@ import sys
 import time
 from dataclasses import dataclass, field, replace
 from pathlib import Path
-from typing import Any, Callable, Protocol, Sequence
+from typing import Any, Callable, NamedTuple, Protocol, Sequence
 
 from coord.filelock import FileLock, LockBusy, notify_lock_path
 from coord.drive_state import (
@@ -628,9 +628,34 @@ def _format_age(seconds: float) -> str:
     return f"{seconds / 86400:.1f}d"
 
 
+class RefusedPolicyStaleness(NamedTuple):
+    """The verdict :func:`_refused_policy_staleness` reaches, plus WHY —
+    #2881: collapsing "no title resolved" and "title unchanged" to the same
+    ``False`` (as the original #2871 boolean-only version did) is what let
+    the #2881 bug (``title`` missing from the daemon-host payload,
+    ``coord/drive_state.py``'s ``_local_issue_rows``) hide for a whole
+    release: every real drive landed in ``uncertain`` silently, read
+    identically to a confidently-checked ``unchanged``, and the operator-
+    facing message could not tell the two apart either.
+    """
+
+    is_stale: bool
+    uncertain: bool
+    detail: str
+
+
 def _refused_policy_is_stale(state: IssueState) -> bool:
     """True when a terminal ``refused_policy`` work row no longer describes
-    the issue as it stands now (#2871).
+    the issue as it stands now (#2871). Thin bool wrapper around
+    :func:`_refused_policy_staleness` — see that function for the reasoning
+    and for the ``uncertain``/``detail`` distinction #2881 added.
+    """
+    return _refused_policy_staleness(state).is_stale
+
+
+def _refused_policy_staleness(state: IssueState) -> RefusedPolicyStaleness:
+    """Does a terminal ``refused_policy`` work row still describe the issue
+    as it stands now (#2871), and how confident is that answer (#2881)?
 
     A worker refuses pre-dispatch work exactly once, correctly, for the ask
     it was shown — the refusal says nothing about a DIFFERENT ask on the same
@@ -639,16 +664,50 @@ def _refused_policy_is_stale(state: IssueState) -> bool:
     ``issue-{N}-{slugify(title)}`` at dispatch time, see
     ``coord.agent``'s ``branch_name`` construction) no longer matches what a
     fresh dispatch would name — that mismatch is the signal a retarget
-    happened. Conservative on every uncertainty (no branch recorded, no
-    title resolved): returns ``False`` — i.e. still treated as blocking —
-    rather than risk waving a genuinely-unresolved refusal through.
+    happened.
+
+    Conservative on every uncertainty (no branch recorded, no title
+    resolved): ``is_stale=False`` — i.e. still treated as blocking — rather
+    than risk waving a genuinely-unresolved refusal through. #2881: those two
+    uncertain cases are NOT the same situation as a confidently-resolved
+    "title unchanged", so ``uncertain=True`` and a specific ``detail`` come
+    back for the caller to surface — a die()/audit message that confidently
+    tells the operator "retarget the issue" is actively wrong when the code
+    could not even check, e.g. because the daemon-host board payload dropped
+    ``title`` again.
     """
-    if not state.work_branch or not state.issue_title:
-        return False
+    if not state.work_branch:
+        return RefusedPolicyStaleness(
+            is_stale=False,
+            uncertain=True,
+            detail=(
+                "no branch was recorded on the refused_policy row, so "
+                "whether the issue was retargeted since could not be checked"
+            ),
+        )
+    if not state.issue_title:
+        return RefusedPolicyStaleness(
+            is_stale=False,
+            uncertain=True,
+            detail=(
+                "the issue's current title did not resolve from this "
+                "drive's board payload, so whether it was retargeted since "
+                "could not be checked (#2881 — if this fires in production, "
+                "suspect the daemon-host local-DB payload again)"
+            ),
+        )
     from coord.agent import _slugify  # noqa: PLC0415
 
     expected_branch = f"issue-{state.issue}-{_slugify(state.issue_title)}"
-    return state.work_branch != expected_branch
+    if state.work_branch != expected_branch:
+        return RefusedPolicyStaleness(
+            is_stale=True, uncertain=False, detail="retargeted since the refusal",
+        )
+    return RefusedPolicyStaleness(
+        is_stale=False,
+        uncertain=False,
+        detail="the issue's title is unchanged since the refusal",
+    )
 
 
 # ── oracle-loop JIT slice authoring (#1453) ─────────────────────────────────
@@ -2104,7 +2163,8 @@ def decide(
             else None
         )
         age = _format_age(age_seconds) if age_seconds is not None else "unknown age"
-        if _refused_policy_is_stale(state):
+        staleness = _refused_policy_staleness(state)
+        if staleness.is_stale:
             bypass_summary = (
                 f"pre-dispatch: bypassing stale refused_policy assignment "
                 f"{state.work_aid} ({age} old) on issue {state.repo}#{state.issue} "
@@ -2141,17 +2201,38 @@ def decide(
         # this exit as a transient death — the same "cannot change on retry"
         # principle #1844 already applies pre-dispatch, applied here
         # post-dispatch.
+        #
+        # #2881: `staleness.uncertain` distinguishes "checked, and the title
+        # really is unchanged" from "could not check at all" — the original
+        # #2871 message collapsed both to the same confident "retarget the
+        # issue, the next drive will see it" prose, which is actively wrong
+        # advice in the uncertain case (the operator may have ALREADY
+        # retargeted, and the driver simply couldn't tell).
+        if staleness.uncertain:
+            remedy = (
+                "Needs the coordinator: do the work directly. Retargeting "
+                "(rewriting the issue's title) SHOULD make the next `coord "
+                f"drive` dispatch fresh work automatically (#2871), but "
+                f"{staleness.detail} — so THIS run could not confirm that "
+                "either way. If a retarget was already tried and this is "
+                "still blocking, that's worth investigating on its own "
+                "(#2881) rather than assuming the retarget silently failed."
+            )
+        else:
+            remedy = (
+                "Needs the coordinator: do the work directly, OR retarget "
+                "the issue (rewrite its title so the deliverable matches "
+                "what should actually be dispatched) — the next `coord "
+                "drive` detects the retarget and dispatches fresh work "
+                f"automatically (#2871), so `coord drive-queue remove "
+                f"{state.repo} {state.issue}` + `add` then genuinely clears "
+                "this once the issue is retargeted."
+            )
         return _die(
             f"pre-dispatch refusal on assignment {state.work_aid} "
             f"(refused_policy, {age} old) — work refused on a standing "
             "repo-rule prohibition rather than doing the dispatched work; "
-            "the worker did the CORRECT thing (#2234). Needs the "
-            "coordinator: do the work directly, OR retarget the issue "
-            "(rewrite its title so the deliverable matches what should "
-            "actually be dispatched) — the next `coord drive` detects the "
-            "retarget and dispatches fresh work automatically (#2871), so "
-            f"`coord drive-queue remove {state.repo} {state.issue}` + `add` "
-            "then genuinely clears this once the issue is retargeted.\n"
+            f"the worker did the CORRECT thing (#2234). {remedy}\n"
             f"   inspect: coord log {state.work_aid} --machine "
             f"{state.work_machine or machine}\n"
             f"   {POLICY_REFUSAL_MARKER}"

{code_coordinator-0.5.269 → code_coordinator-0.5.271}/coord/drive_state.py

@@ -993,11 +993,33 @@ def _local_issue_rows() -> list[dict]:
     ``coord.db.get_connection()`` singleton
     ``coord.commands.drive_queue._local_issue_rows`` already uses for its own
     (narrower — ``repo_name, number, state`` only) top-up of the same
-    standalone-payload gap; this one additionally selects ``milestone_number``
-    / ``milestone_title`` / ``labels`` / ``body`` — what :func:`project`'s
-    oracle-loop resolution and :func:`coord.milestone_order.
-    milestone_work_order_membership` need that the narrower query doesn't
-    carry.
+    standalone-payload gap; this one additionally selects ``title`` /
+    ``milestone_number`` / ``milestone_title`` / ``labels`` / ``body`` /
+    ``synced_at`` — what :func:`project`'s oracle-loop resolution,
+    :func:`coord.milestone_order.milestone_work_order_membership`, and
+    ``coord.drive_queue.build_board_view``'s ``#2858`` staleness check need
+    that the narrower query doesn't carry.
+
+    #2881: ``title`` was missing from this SELECT even though :func:`project`
+    has read ``oi.get("title")`` since #2871 — so on every daemon-host drive
+    (the ONLY host that runs `coord drive-queue tick`, i.e. every real
+    dispatch) ``issue_title`` resolved to ``""`` for every issue, and
+    ``_refused_policy_is_stale`` in ``coord/drive.py`` hit its
+    "uncertain ⇒ still blocking" guard unconditionally — the retarget-bypass
+    it exists to provide could never fire in production. The HTTP `/board`
+    path (`coord.dao.SqliteStore` → `board_schema.BoardIssue`, which DOES
+    declare ``title``) was never broken; nothing that dispatches drives goes
+    through it. Auditing this SELECT against ``BoardIssue`` (#2881's other
+    ask, "the two projections drift and the hooks cannot prevent it")
+    surfaced the identical gap one field over: ``synced_at`` was ALSO
+    missing, silently defeating ``build_board_view``'s ``#2858``
+    fresh-vs-stale-cache read the same way on the same daemon host — fixed
+    here alongside ``title`` rather than filed as a follow-up, since it is
+    the same SELECT and the same root cause. See
+    :func:`coord.drive._refused_policy_is_stale` and
+    ``tests/test_drive_state.py::test_fetch_local_issue_rows_and_http_board_expose_the_same_issue_keys``,
+    which guards this SELECT and the HTTP shape against drifting apart
+    again.
 
     Deliberately queries ``get_connection()`` rather than
     ``coord.dao.SqliteStore`` — see :meth:`BoardFetcher._fetch_local`'s
@@ -1014,8 +1036,8 @@ def _local_issue_rows() -> list[dict]:
     try:
         rows = sql.execute(
             get_connection(),
-            "SELECT repo_name, number, state, milestone_number, milestone_title, "
-            "labels, body FROM issues",
+            "SELECT repo_name, number, title, state, milestone_number, "
+            "milestone_title, labels, body, synced_at FROM issues",
         ).fetchall()
     except Exception:  # noqa: BLE001 — see the fail-soft note above
         return []

{code_coordinator-0.5.269 → code_coordinator-0.5.271}/coord/review.py

@@ -1090,6 +1090,104 @@ class ReviewerChoice:
     rationale: str
 
 
+# #697: how far past a row's OWN needs-attention threshold a `pending`/
+# `running` row must sit before reviewer selection stops counting its machine
+# as busy.  One hour of margin on top of a threshold that is itself measured
+# in tens of minutes: comfortably longer than any reap path needs
+# (`coord.reconcile._reconcile_no_agent_record` on the daemon's 30s tick,
+# `coord.diagnose.sweep_dead_running_rows` on `coord-notify.timer`'s 5min
+# cadence), so a row still counted busy here is one every reaper has already
+# had many chances at.
+STALE_BUSY_BUFFER_SECONDS = 3600.0
+
+# The same horizon for rows whose type has NO wall-clock threshold at all —
+# `PipelineConfig.attention_threshold_for` returns `inf` for the attended
+# chat/troubleshoot/audit family (#1133).  Those are exactly the rows #697
+# observed at 51h and 70h, so "never expires" is not an option here; a flat,
+# deliberately generous day is.  A human really attending a chat session for
+# a full day is far rarer than a tmux session that died without being reaped.
+STALE_BUSY_INTERACTIVE_SECONDS = 24 * 3600.0
+
+
+def _is_stale_busy_row(a: Assignment, config: Config, now: float) -> bool:
+    """True when *a* is too old to still be believed as occupying its machine (#697).
+
+    Reviewer selection's ``busy`` set used to count **every** ``pending``/
+    ``running`` board row, which is how a zombie row broke dispatch in #697:
+    rows whose worker had been dead for hours-to-days kept inflating the set,
+    so real machines looked occupied and selection was pushed onto whatever
+    candidate happened to look "free" — on #669 that was an *offline* machine,
+    and the review could not be dispatched at all.
+
+    This is deliberately **not** a liveness probe, and deliberately **not** a
+    reap.  The reapers (``coord.reconcile._reconcile_no_agent_record``,
+    ``coord.interactive.reap_stale_interactive_sessions``,
+    ``coord.diagnose.sweep_dead_running_rows``) own the "is it actually dead?"
+    question, they answer it with a positive disproof or a real tmux/agent
+    probe, and they are the only things allowed to write a terminal status.
+    Guessing from age alone would be #1870's mistake if it gated a *write*.
+
+    Here it gates only a *ranking*, where being wrong is cheap and
+    self-correcting in both directions:
+
+    * Wrong about a genuinely-live row → its machine is ranked as idle and may
+      receive the review.  That is the SAME outcome fallback 1
+      ("different machine, currently busy — review will queue") already
+      produces on a one-other-machine fleet, and a genuinely-saturated agent
+      answers with a rejection that ``_ranked_reviewer_candidates`` already
+      falls through on (#904).
+    * Wrong about a dead row (age not yet reached) → status quo ante: the
+      machine stays "busy" and merely ranks lower.
+
+    A row with no ``dispatched_at`` is never stale — there is nothing to
+    compute an age from, and this path never guesses, mirroring
+    ``sweep_dead_running_rows``.
+    """
+    dispatched_at = getattr(a, "dispatched_at", None)
+    if not dispatched_at:
+        return False
+    try:
+        dispatched = float(dispatched_at)
+    except (TypeError, ValueError):
+        return False
+
+    threshold = config.pipeline.attention_threshold_for(
+        a.type or "work",
+        provider_name=a.provider_name,
+        review_of_assignment_id=a.review_of_assignment_id,
+    )
+    if threshold == float("inf"):
+        horizon = STALE_BUSY_INTERACTIVE_SECONDS
+    else:
+        horizon = threshold + STALE_BUSY_BUFFER_SECONDS
+    return (now - dispatched) > horizon
+
+
+def busy_machine_names(
+    board: Board,
+    config: Config,
+    *,
+    now: float | None = None,
+) -> set[str]:
+    """Machines with at least one *believable* in-flight row (#697).
+
+    The shared ``busy`` set for :func:`pick_reviewer_machine` and
+    :func:`_ranked_reviewer_candidates` — a ``pending``/``running`` row whose
+    age is past :func:`_is_stale_busy_row`'s horizon is presumed dead and no
+    longer holds its machine down.  See that function for why an age-only
+    heuristic is the right instrument *for a ranking* and the wrong one for a
+    reap.
+    """
+    if now is None:
+        now = time.time()
+    return {
+        a.machine_name
+        for a in board.active
+        if a.status in ("pending", "running")
+        and not _is_stale_busy_row(a, config, now)
+    }
+
+
 def pick_reviewer_machine(
     worker_machine_name: str,
     repo_name: str,
@@ -1111,6 +1209,11 @@ def pick_reviewer_machine(
     cordon blocked the review, the unreviewable entry stayed `running`, the
     running entry deferred the roll, and the deferred roll left the cordon
     up. Explicit pauses and quiet hours still apply.
+
+    #697: the ``busy`` set is :func:`busy_machine_names`, which drops
+    ``pending``/``running`` rows too old to still be believed — a zombie row
+    used to make a real machine look occupied indefinitely and push selection
+    onto an offline "free" candidate.
     """
     from coord.machine_pause import follow_on_paused_set
     paused = follow_on_paused_set(config.machines)
@@ -1121,7 +1224,7 @@ def pick_reviewer_machine(
     if not candidates:
         return None
 
-    busy = {a.machine_name for a in board.active if a.status in ("pending", "running")}
+    busy = busy_machine_names(board, config)
 
     different = [
         m for m in candidates
@@ -1191,6 +1294,9 @@ def _ranked_reviewer_candidates(
     literal "no eligible reviewer machine configured for repo
     'claude-coordinator'" that a cordoned fleet answered every review
     dispatch with for 70 minutes.
+
+    #697: shares :func:`busy_machine_names` with ``pick_reviewer_machine``, so
+    tier 1 vs tier 2 here is decided on *believable* in-flight rows only.
     """
     from coord.machine_pause import follow_on_paused_set  # noqa: PLC0415
 
@@ -1202,7 +1308,7 @@ def _ranked_reviewer_candidates(
     if not candidates:
         return []
 
-    busy = {a.machine_name for a in board.active if a.status in ("pending", "running")}
+    busy = busy_machine_names(board, config)
 
     result: list[tuple[Machine, bool]] = []
     for m in candidates:

{code_coordinator-0.5.269 → code_coordinator-0.5.271}/tests/test_drive.py

@@ -1905,6 +1905,42 @@ def test_refused_policy_is_not_bypassed_when_the_title_is_unchanged():
     assert action.audit_event is None
 
 
+def test_refused_policy_still_blocking_distinguishes_uncertain_from_confident():
+    """#2881: the original #2871 message collapsed "title didn't resolve
+    from the board payload" and "title resolved but is unchanged" into the
+    identical confident "retarget the issue, the next drive will see it"
+    prose — which is exactly why the #2881 payload bug (``title`` missing
+    from the daemon-host ``_local_issue_rows()`` SELECT) went unnoticed for a
+    release cycle: every real drive silently landed in the uncertain case and
+    nothing in the operator-facing text said so. The uncertain case (no
+    branch recorded, or no title resolved) must say the driver could not
+    confirm either way; the confident case (title resolved, branch
+    unchanged) keeps the original #2871 remedy verbatim.
+    """
+    uncertain = step(
+        state(work_aid="w1", work_status="refused_policy", work_finished_at=1000.0)
+    )
+    assert uncertain.is_exit
+    assert "could not confirm" in uncertain.message.lower()
+    assert "the next `coord drive` detects the retarget" not in uncertain.message
+
+    from coord.agent import _slugify  # noqa: PLC0415
+
+    title = "Exactly the title this branch was named from"
+    confident = step(
+        state(
+            work_aid="w1",
+            work_status="refused_policy",
+            work_branch=f"issue-{ISSUE}-{_slugify(title)}",
+            issue_title=title,
+            work_finished_at=1000.0,
+        )
+    )
+    assert confident.is_exit
+    assert "could not confirm" not in confident.message.lower()
+    assert "the next `coord drive` detects the retarget" in confident.message
+
+
 def test_an_unknown_terminal_status_refuses_to_guess():
     """No terminal status may fall through to a bare wait (PR #1386)."""
     action = step(state(work_aid="w1", work_status="wat"))

{code_coordinator-0.5.269 → code_coordinator-0.5.271}/tests/test_drive_state.py

@@ -1490,6 +1490,98 @@ def test_fetch_tops_up_issues_and_milestone_work_orders_when_standalone(
     assert state.milestone_tracking_issue == 1120
 
 
+def test_fetch_local_issue_rows_carries_title_so_project_resolves_issue_title(
+    monkeypatch, tmp_path, coord_db
+):
+    """#2881: ``_local_issue_rows()``'s SELECT dropped ``title`` even though
+    :func:`project` has read ``oi.get("title")`` off this exact payload since
+    #2871 — so on the daemon host (the ONLY host that runs `coord
+    drive-queue tick`, i.e. every real dispatch) ``issue_title`` resolved to
+    ``""`` for every issue, and ``coord.drive._refused_policy_is_stale``
+    (keyed on ``issue_title``) hit its "uncertain ⇒ still blocking" guard
+    unconditionally — the retarget-bypass it exists to provide could never
+    fire in production.
+
+    Drives the REAL local-DB payload path end to end — ``BoardFetcher.fetch()``
+    → ``_local_issue_rows()`` → :func:`project` — against the ``coord_db``
+    fixture's real schema-migrated ``:memory:`` DB, exactly like #2040's own
+    top-up test above. A hand-built ``IssueState`` (what #2871's own tests
+    did) cannot catch this: the bug is entirely in what the SELECT carries,
+    not in how ``project()`` reads it once it has a title. This fails the
+    instant ``title`` is dropped from that SELECT again.
+    """
+    monkeypatch.setattr("coord.client.resolve_board_service", lambda *a, **k: None)
+    monkeypatch.setattr("coord.board_service.read_board", lambda: "BOARD")
+    monkeypatch.setattr("coord.client.serialize_board", lambda b: {"from": b})
+
+    coord_db.execute(
+        "INSERT INTO issues (repo_name, number, title, state, labels, body) "
+        "VALUES (?, ?, ?, ?, ?, ?)",
+        (
+            REPO, 916, "Composed regression test for the rebase-bounce flow",
+            "open", "[]", "",
+        ),
+    )
+    coord_db.commit()
+
+    payload = BoardFetcher(cache_dir=tmp_path).fetch()
+    state = project(payload, REPO, 916, make_config())
+
+    assert state.issue_title == "Composed regression test for the rebase-bounce flow"
+
+
+def test_fetch_local_issue_rows_and_http_board_expose_the_same_issue_keys(
+    tmp_path, coord_db
+):
+    """#2881: silent divergence between the HTTP ``/board`` ``issues``
+    projection (``coord.dao.SqliteStore`` → ``board_schema.BoardIssue``) and
+    this daemon-host standalone path (``_local_issue_rows``) has now caused
+    three separate bugs (#2040, #2182, #2881) — a consumer starts reading a
+    new field, the HTTP path (backed by the declared DTO) carries it, and the
+    local-DB top-up silently doesn't, because nothing keeps the two SELECTs
+    in sync. Rather than wait for the next consumer to discover the next
+    gap, assert the two ``issues`` row shapes expose the same key set
+    directly — against a REAL on-disk schema-migrated DB for the HTTP side
+    (mirrors ``tests/test_dao.py``'s ``read_db`` fixture) and the real
+    ``coord_db`` fixture for the local side. This fails the instant one
+    drifts from the other, regardless of which field it is.
+    """
+    from coord.dao import SqliteStore
+    from coord.db import _ensure_schema
+    from coord.drive_state import _local_issue_rows
+
+    db_path = tmp_path / "coord.db"
+    conn = sqlite3.connect(str(db_path))
+    conn.row_factory = sqlite3.Row
+    _ensure_schema(conn)
+    conn.execute(
+        "INSERT INTO issues (repo_name, number, title, state, labels, body) "
+        "VALUES (?, ?, ?, ?, ?, ?)",
+        (REPO, 1, "t", "open", "[]", ""),
+    )
+    conn.commit()
+    conn.close()
+    http_rows = SqliteStore(db_path).list_issues()
+    assert len(http_rows) == 1
+
+    coord_db.execute(
+        "INSERT INTO issues (repo_name, number, title, state, labels, body) "
+        "VALUES (?, ?, ?, ?, ?, ?)",
+        (REPO, 1, "t", "open", "[]", ""),
+    )
+    coord_db.commit()
+    local_rows = _local_issue_rows()
+    assert len(local_rows) == 1
+
+    assert set(local_rows[0]) == set(http_rows[0]), (
+        "_local_issue_rows() and SqliteStore.list_issues() (the /board HTTP "
+        "path) must expose the same issues-row keys — one side carrying a "
+        "field the other doesn't is exactly the #2040/#2182/#2881 shape "
+        "(a consumer added on one side silently sees None/empty on the "
+        "daemon-host path)"
+    )
+
+
 def test_fetch_local_issue_rows_fail_soft_on_an_unreadable_table(monkeypatch, tmp_path):
     """Mirrors ``coord.commands.drive_queue._local_issue_rows``'s fail-soft
     posture: an unreadable ``issues``/``merge_queue`` table degrades the