code-coordinator 0.5.494__tar.gz → 0.5.495__tar.gz

{code_coordinator-0.5.494 → code_coordinator-0.5.495}/.github/workflows/test.yml

@@ -5,6 +5,8 @@ on:
     branches: [main]
   pull_request:
     branches: [main]
+  # #3392: the `postgres` job below is opt-in and runs ONLY from here.
+  workflow_dispatch:
 
 jobs:
   test:
@@ -371,6 +373,21 @@ jobs:
   # what every other job's `pip install -e ".[dev]"` pulls in.
   postgres:
     runs-on: ubuntu-latest
+    # #3392, 2026-09-18: taken out of automatic CI by operator decision -- the
+    # Postgres migration is not current work, and until it is this job is pure
+    # noise. It gates nothing (`continue-on-error: true` below, and it is not a
+    # required check in branch protection), emits ~3700
+    # ProductionDatabaseGuardError that dominate every `--log-failed` read of
+    # this workflow, and costs 65-70 min of runner time per push to main. It
+    # misdirected #3378 item 1, #3380 and #3385 -- all three were scoped as
+    # "make main green" against a job that cannot redden main.
+    #
+    # RESTORE by deleting this one `if:` line when the migration becomes active
+    # work. Everything below is unchanged and still correct. Sequence then is:
+    # remove the `if:`, work the failure list down, THEN remove
+    # `continue-on-error` -- that last step is what turns this into a real gate
+    # and it is the deliberate END of that work, not the start.
+    if: github.event_name == 'workflow_dispatch'
     continue-on-error: true
     services:
       postgres:

{code_coordinator-0.5.494 → code_coordinator-0.5.495}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.494",
+  "tag": "0.5.495",
   "distance": 0,
-  "node": "g52be7f1fb06c8a23aaf1d850192c29dc4cf8a36f",
+  "node": "ga0310959c08fddb13badabe2d065897c8a64bc04",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-09-18"

{code_coordinator-0.5.494 → code_coordinator-0.5.495}/coord/board_schema.py

@@ -245,6 +245,17 @@ class BoardIssue:
     synced_at: float | None = None
     milestone_number: int | None = None
     milestone_title: str | None = None
+    # #3384: GitHub's own `stateReason` — `"reopened"` when a human explicitly
+    # reopened this issue via `gh issue reopen`, `""` for an issue that has
+    # never been closed. See `coord.drive_queue.IssueFacts.reopened`.
+    #
+    # ABSENT, not `""`, on the wire when it is the empty default: it would
+    # otherwise cost ~20 bytes on every issue row of every poll to say nothing
+    # (`coord.board_wire._drop_default_state_reason`, which is also why it is
+    # not in this DTO's `required` list — it has a default). Read it as
+    # `row.get("state_reason") or ""`; the Rust side gets `#[serde(default)]`
+    # from `coord.codegen`.
+    state_reason: str = ""
 
 
 @dataclasses.dataclass(kw_only=True)

{code_coordinator-0.5.494 → code_coordinator-0.5.495}/coord/board_wire.py

@@ -65,6 +65,19 @@ Rust call site of ``OpenIssue.body`` / ``PipelineIssue.body`` first. So the
 body now leaves the collection wire for open issues too, and
 :func:`bound_issue_row` keeps only the machine-parsed *residue* a client
 cannot re-fetch in time — see :data:`ALLOWED_GLOB_MARKER`.
+
+**#3384: a defaulted flag costs its bytes on EVERY row.** The reopen witness
+``issues.state_reason`` carries a value on the handful of rows GitHub
+actually set one on, and the empty default on every other issue on the
+board — and an empty-but-present key is ~20 bytes of wire per row per poll,
+which on the #1791 guard's 3000-row seed is ~57 KB and pushed the payload
+straight through :data:`BOARD_PAYLOAD_BYTE_BUDGET`. So the default is
+dropped from the wire entirely (:func:`_drop_default_state_reason`) and the
+key is present only when it says something. This is the same additive-only
+convention the ``<field>_truncated`` flags already follow, and it is the
+rule to apply to the NEXT defaulted field somebody adds to
+``coord/board_schema.py``: an always-present default is a per-row tax on a
+payload that is polled every few seconds and whose ETag never matches.
 """
 
 from __future__ import annotations
@@ -253,9 +266,52 @@ def _machine_readable_residue(body: str) -> str:
     )
 
 
+def _drop_default_state_reason(row: dict) -> None:
+    """#3384: drop ``state_reason`` from the wire when it is the empty default.
+
+    ``issues.state_reason`` is GitHub's own ``stateReason``: ``"reopened"``
+    on an issue a human explicitly reopened, and ``''`` on every issue that
+    has never been closed — i.e. on essentially the whole board.  Shipping
+    the empty default costs ~20 bytes on EVERY issue row of EVERY poll (~57 KB
+    on the #1791 guard's 3000-row seed, enough on its own to breach
+    :data:`BOARD_PAYLOAD_BYTE_BUDGET`) to tell a client something it already
+    assumes.
+
+    Safe because absent and empty are the SAME answer to every consumer, by
+    construction rather than by luck:
+
+    * ``coord.drive_queue.build_board_view`` reads it as
+      ``str(row.get("state_reason") or "").lower() == "reopened"`` — the one
+      question anything asks of this field — so a missing key and an empty
+      one both yield ``IssueFacts.reopened is False``.  That is also what
+      keeps this wire cut from splitting the answer in two: the daemon-host
+      local path (``coord.drive_state._local_issue_rows``, which never runs
+      through this module) still carries ``''``, and both paths land on the
+      identical fact.
+    * The Rust ``OpenIssue.state_reason`` is generated with
+      ``#[serde(default)]`` (``coord.codegen._rust_auto_field``), so an
+      absent key deserializes to ``String::new()``.
+    * ``state_reason`` is not in ``BoardIssue``'s ``required`` list in
+      ``/openapi.json`` (it has a dataclass default), so omitting it stays
+      inside the published contract.
+
+    A NON-empty value is always kept — this drops the default, it does not
+    filter for ``"reopened"`` specifically, so a value GitHub starts sending
+    that we do not yet interpret still reaches clients intact.
+    """
+    if not row.get("state_reason"):
+        row.pop("state_reason", None)
+
+
 def bound_issue_row(row: dict) -> None:
     """Apply the wire policy to one ``/board`` issue row (mutates).
 
+    **The empty ``state_reason`` default is dropped from every issue row**
+    (#3384), tracking issues included — see
+    :func:`_drop_default_state_reason`.  Deliberately above the epic
+    early-return below, so the wire shape of that field does not depend on
+    which kind of issue a row happens to be.
+
     **Tracking (epic) issues are exempt from the body cap.**  The TUI's
     Milestone DAG parses ``## Work order`` out of the tracking issue's body
     *client-side* (`milestone_dag.rs::milestones_with_work_orders` — it does
@@ -282,6 +338,7 @@ def bound_issue_row(row: dict) -> None:
     exactly as for a closed issue, which is what arms that hydration
     (``pipeline.rs::issue_body_fetch_target``).
     """
+    _drop_default_state_reason(row)
     if _is_tracking_issue(row):
         return
     if _is_closed_issue(row):

{code_coordinator-0.5.494 → code_coordinator-0.5.495}/coord/commands/drive_queue.py

@@ -2815,13 +2815,21 @@ def _local_issue_rows() -> list[dict]:
 
     Fail-soft: an unreadable/absent table degrades to ``[]``, which puts the
     daemon host back on the assignment-only signals rather than aborting.
+
+    #3384: ``state_reason`` selected alongside ``state`` — this IS the
+    ``coord drive-queue tick`` daemon-host path, so without it
+    ``coord.drive_queue.IssueFacts.reopened`` would never populate on the
+    one host that actually ticks the queue, and a reopened issue's stale
+    ``merged`` witness would keep short-circuiting entries straight to
+    ``done`` there regardless of the fix in ``build_board_view``.
     """
     from coord import sql  # noqa: PLC0415
     from coord.db import get_connection  # noqa: PLC0415
 
     try:
         rows = sql.execute(
-            get_connection(), "SELECT repo_name, number, state FROM issues"
+            get_connection(),
+            "SELECT repo_name, number, state, state_reason FROM issues",
         ).fetchall()
     except Exception:  # noqa: BLE001 — see the fail-soft note above
         return []

{code_coordinator-0.5.494 → code_coordinator-0.5.495}/coord/db.py

@@ -1049,7 +1049,16 @@ def retry_on_locked(
 # ("confirmed"/"unconfirmed"/"refuted"/"baseline_red") for a `test_state`
 # write, alongside `coord.state._record_test_verdict_local`. See
 # coord.models.Assignment.test_confirmation.
-_DB_SCHEMA_VERSION = 18
+#
+# #3384: bumped 18 -> 19 for the new `issues.state_reason` column appended
+# to `_migrate_add_columns` below — carries GitHub's own `stateReason`
+# (`"reopened"` when a human explicitly reopened a closed issue) so
+# `coord.drive_queue.IssueFacts.reopened`/`.landed` can tell "this issue was
+# reopened for incomplete work" apart from "this issue never closed in the
+# first place" (a quadraui-style merge into a non-default branch) — both
+# read identically as `merged=True, issue_state="open"` otherwise. See
+# `coord.drive_queue.IssueFacts.landed`'s docstring.
+_DB_SCHEMA_VERSION = 19
 
 
 def _read_schema_version(conn: sqlite3.Connection) -> int:
@@ -2490,6 +2499,17 @@ _MIGRATE_ADD_COLUMNS: list[str] = [
     # See coord.models.Assignment.test_confirmation and
     # coord.confirm_test.TEST_CONFIRMATION_VALUES for the exhaustive set.
     "ALTER TABLE assignments ADD COLUMN test_confirmation TEXT",
+    # #3384: GitHub's own `stateReason` for this issue — `''`/NULL for every
+    # row predating this migration and for an issue that has never closed,
+    # `"reopened"` (lowercased on write — see
+    # `coord.state._upsert_open_issues_local`) when a human explicitly
+    # reopened a previously-closed issue via `gh issue reopen`. This is the
+    # ONLY witness that lets `coord.drive_queue.IssueFacts.landed` tell a
+    # genuine reopen (the work is NOT done, no matter what an earlier PR
+    # merge recorded) apart from a quadraui-style repo whose merged PRs never
+    # auto-close the linked issue at all — both look identical as
+    # `merged=True, issue_state="open"` without it.
+    "ALTER TABLE issues ADD COLUMN state_reason TEXT NOT NULL DEFAULT ''",
 ]
 
 

{code_coordinator-0.5.494 → code_coordinator-0.5.495}/coord/drive_queue.py

@@ -1194,6 +1194,19 @@ class IssueFacts:
     # see `issue_cache_stale` for the ONE thing this changes.
     issue_synced_at: float | None = None
     merged: bool = False  # a work-like assignment with status == 'merged'
+    # #3384: GitHub's own witness that a human explicitly reopened this
+    # issue (`stateReason == "reopened"` off `gh issue list`/`get_open_
+    # issues`) — `False` for an issue that has simply never been closed.
+    # `merged` above is a permanent historical record: once any work-like
+    # assignment for this issue reaches `status == "merged"` it never
+    # un-merges, even after the issue is reopened for incomplete work
+    # (claude-coordinator#3384 — a PR merged with its goal unmet, reopened,
+    # and a freshly re-queued entry still short-circuited straight to
+    # `done` on the strength of that stale record). `reopened` is what lets
+    # `landed` below tell that apart from quadraui-style repos whose merged
+    # PRs never auto-close the linked issue at all — both otherwise read
+    # identically as `merged=True, issue_state="open"`.
+    reopened: bool = False
     active_work: bool = False  # a NON-terminal work-like assignment
     # #3239: a work-like assignment with status == 'done' — completed
     # successfully but not yet merged (still owed Test/Review/Merge). Unlike
@@ -1315,8 +1328,25 @@ class IssueFacts:
         rows the merge projection can miss, and quadraui-style repos can merge
         a PR into ``develop`` while the linked issue stays open — so neither
         signal alone is reliable.
+
+        #3384: `reopened` is the one override neither of those signals sees.
+        `closed` wins outright whenever it is true — a merge that legitimately
+        re-closed a reopened issue is done, full stop. But when the issue is
+        currently OPEN and carries GitHub's own "a human explicitly reopened
+        this" witness, a bare `merged` reading must NOT count: it is provably
+        stale — the very act of reopening is an operator's statement that an
+        earlier merge did not finish the work, and trusting the merge record
+        over it is claude-coordinator#3380's incident replayed (a PR merged
+        with its goal unmet, reopened, and every entry gated `--after` it
+        released anyway). An issue that has simply never closed (the
+        quadraui case above) never sets `reopened`, so this changes nothing
+        for it.
         """
-        return self.merged or self.closed
+        if self.closed:
+            return True
+        if self.reopened:
+            return False
+        return self.merged
 
 
 def _issue_cache_stale(facts: IssueFacts, now: float | None) -> bool:
@@ -1435,6 +1465,10 @@ def build_board_view(
         synced_at = row.get("synced_at")
         if isinstance(synced_at, (int, float)):
             entry["issue_synced_at"] = float(synced_at)
+        # #3384: GitHub's own witness that this issue was explicitly
+        # reopened — see `IssueFacts.reopened`'s docstring for why `merged`
+        # alone cannot be trusted once this is set.
+        entry["reopened"] = str(row.get("state_reason") or "").lower() == "reopened"
 
     # #1891: `merge_ci_pending` — mirrors `drive_state._merge_entry`'s OWN
     # reason resolution exactly (live `merge_plan` reason, falling back to

{code_coordinator-0.5.494 → code_coordinator-0.5.495}/coord/drive_state.py

@@ -1125,6 +1125,13 @@ def _local_issue_rows() -> list[dict]:
     which guards this SELECT and the HTTP shape against drifting apart
     again.
 
+    #3384: ``state_reason`` added alongside the rest — what
+    ``coord.drive_queue.build_board_view`` needs to populate
+    ``IssueFacts.reopened``, without which a reopened issue's stale
+    ``merged`` witness would keep reading as ``landed`` on this exact
+    daemon-host path forever (the one that runs every real
+    ``coord drive-queue tick``).
+
     Deliberately queries ``get_connection()`` rather than
     ``coord.dao.SqliteStore`` — see :meth:`BoardFetcher._fetch_local`'s
     docstring for why the latter is wrong for anything running in-process
@@ -1141,7 +1148,7 @@ def _local_issue_rows() -> list[dict]:
         rows = sql.execute(
             get_connection(),
             "SELECT repo_name, number, title, state, milestone_number, "
-            "milestone_title, labels, body, synced_at FROM issues",
+            "milestone_title, labels, body, synced_at, state_reason FROM issues",
         ).fetchall()
     except Exception:  # noqa: BLE001 — see the fail-soft note above
         return []

{code_coordinator-0.5.494 → code_coordinator-0.5.495}/coord/github_ops.py

@@ -701,6 +701,13 @@ def get_open_issues(repo: str, *, force_through_backoff: bool = False) -> list[d
     _sync_issues_tick`` once ``coord.issues_sync_status.is_starved(repo)``
     says this repo has gone too long without a successful sync — see
     :func:`coord.github_ops._gh`'s docstring for what it actually changes.
+
+    #3384: ``stateReason`` is requested alongside the rest — GitHub sets it
+    to ``"reopened"`` on an issue a human explicitly reopened via ``gh issue
+    reopen`` (and leaves it ``null`` for an issue that has simply never been
+    closed). ``coord.state._upsert_open_issues_local`` persists it so
+    ``coord.drive_queue.IssueFacts.landed`` can refuse to treat a reopened
+    issue as done on the strength of a stale merge record.
     """
     # #658: raised from 100 → 500 so repos with many open issues don't silently
     # skip old issue numbers during coord sync.  GitHub paginates the REST list
@@ -708,7 +715,7 @@ def get_open_issues(repo: str, *, force_through_backoff: bool = False) -> list[d
     # repo — acceptable for a background sync.
     return _gh_json(
         "issue", "list", "--repo", repo, "--state", "open",
-        "--json", "number,title,labels,milestone,body,assignees",
+        "--json", "number,title,labels,milestone,body,assignees,stateReason",
         "--limit", "500",
         default=[],
         force_through_backoff=force_through_backoff, caller="github_ops.get_open_issues")

{code_coordinator-0.5.494 → code_coordinator-0.5.495}/coord/state.py

@@ -7705,11 +7705,17 @@ def _upsert_open_issues_local(repo_name: str, issues: list[dict]) -> None:
         milestone = issue.get("milestone") or {}
         milestone_number = milestone.get("number") if milestone else None
         milestone_title = milestone.get("title") if milestone else None
+        # #3384: `gh issue list --json stateReason` — `"reopened"` when a
+        # human explicitly reopened this issue, `""`/null for an issue that
+        # has simply never been closed. Lowercased on write so
+        # `coord.drive_queue.build_board_view`'s `== "reopened"` compare
+        # never has to guess GitHub's casing.
+        state_reason = str(issue.get("stateReason") or "").lower()
         sql.execute(conn,
             """
             INSERT INTO issues (repo_name, number, title, body, state, labels, synced_at,
-                                milestone_number, milestone_title)
-            VALUES (?, ?, ?, ?, 'open', ?, ?, ?, ?)
+                                milestone_number, milestone_title, state_reason)
+            VALUES (?, ?, ?, ?, 'open', ?, ?, ?, ?, ?)
             ON CONFLICT (repo_name, number) DO UPDATE SET
                 title            = excluded.title,
                 body             = excluded.body,
@@ -7717,7 +7723,8 @@ def _upsert_open_issues_local(repo_name: str, issues: list[dict]) -> None:
                 labels           = excluded.labels,
                 synced_at        = excluded.synced_at,
                 milestone_number = excluded.milestone_number,
-                milestone_title  = excluded.milestone_title
+                milestone_title  = excluded.milestone_title,
+                state_reason     = excluded.state_reason
             """,
             (
                 repo_name,
@@ -7728,6 +7735,7 @@ def _upsert_open_issues_local(repo_name: str, issues: list[dict]) -> None:
                 now,
                 milestone_number,
                 milestone_title,
+                state_reason,
             ),
         )
     # #603: the per-issue context digest is short-lived — drop it for any issue

{code_coordinator-0.5.494 → code_coordinator-0.5.495}/tests/test_board_wire.py

@@ -395,3 +395,172 @@ def test_active_work_never_dropped_regardless_of_terminal_history_size(
     issue = next(i for i in board["issues"] if i["number"] == 99999)
     assert issue["state"] == "open"
     assert issue["body"] == "the open body"  # open issue body untouched by the closed-body drop
+
+
+# ── #3384: the reopen witness must survive the wire's byte policy ──────────
+#
+# `issues.state_reason` (GitHub's own `stateReason`) is the ONLY witness that
+# lets `coord.drive_queue.IssueFacts.landed` tell "a human reopened this
+# issue because the merged PR did not finish the work" apart from "this repo
+# merges into develop and never auto-closes the issue" — both otherwise read
+# as `merged=True, issue_state="open"`. It is also a defaulted field on every
+# one of the board's ~800 issue rows, which is ~20 bytes each, per poll: on
+# the 3000-row seed above, 57 KB, enough on its own to breach
+# BOARD_PAYLOAD_BYTE_BUDGET. `bound_issue_row` therefore drops the EMPTY
+# default from the wire and keeps every non-empty value.
+#
+# These guard both halves at once — the cheap shape (the default is gone) and
+# the expensive one that actually matters (a real reopen still reaches the
+# consumer, over the real HTTP wire, and still flips `landed` to False). A
+# byte-saving cut that silently took the witness with it would pass the
+# budget guard above and re-open #3384; it fails here instead.
+
+
+def _board_over_http(db_path: Path, cfg_path: Path) -> dict:
+    cfg = load_config(cfg_path)
+    app = build_app(SqliteStore(db_path), cfg)
+    with TestClient(app) as cli:
+        resp = cli.get("/board")
+    assert resp.status_code == 200
+    return resp.json()
+
+
+def _seed_reopened_and_control(conn: sqlite3.Connection) -> None:
+    """One issue merged-then-reopened, one merged-and-never-closed control.
+
+    Both carry a merged work assignment, so `IssueFacts.merged` is True for
+    each and `state_reason` is the ONLY thing that can tell them apart.
+    """
+    conn.executemany(
+        "INSERT INTO assignments (assignment_id, machine_name, repo_name, "
+        "issue_number, issue_title, status, type, dispatched_at, finished_at) "
+        "VALUES (?,?,?,?,?,?,?,?,?)",
+        [
+            ("a-reopened", "m", "api", 3380, "reopened", "merged", "work", NOW, NOW),
+            ("a-control", "m", "api", 3381, "never closed", "merged", "work", NOW, NOW),
+        ],
+    )
+    conn.executemany(
+        "INSERT INTO issues (repo_name, number, title, body, state, labels, "
+        "synced_at, state_reason) VALUES (?,?,?,?,?,?,?,?)",
+        [
+            ("api", 3380, "reopened", "", "open", "[]", NOW, "reopened"),
+            ("api", 3381, "never closed", "", "open", "[]", NOW, ""),
+        ],
+    )
+    conn.commit()
+
+
+def test_bound_issue_row_drops_the_empty_state_reason_default() -> None:
+    """The byte cut: an empty `state_reason` leaves the wire entirely rather
+    than shipping `""` on every issue row of every poll."""
+    row = {"state": "open", "body": "", "state_reason": ""}
+    bound_issue_row(row)
+    assert "state_reason" not in row
+
+
+def test_bound_issue_row_keeps_a_reopened_state_reason() -> None:
+    """...and the witness itself is never the thing that gets cut."""
+    row = {"state": "open", "body": "", "state_reason": "reopened"}
+    bound_issue_row(row)
+    assert row["state_reason"] == "reopened"
+
+
+def test_bound_issue_row_keeps_a_state_reason_it_does_not_interpret() -> None:
+    """The cut drops the DEFAULT, not "anything that isn't 'reopened'" — a
+    value GitHub starts sending that coord has no opinion about still reaches
+    clients intact."""
+    row = {"state": "closed", "body": "", "state_reason": "not_planned"}
+    bound_issue_row(row)
+    assert row["state_reason"] == "not_planned"
+
+
+def test_state_reason_policy_is_the_same_for_a_tracking_issue() -> None:
+    """Epics take an early return out of `bound_issue_row` for the body cap
+    (#1791/#1939); the `state_reason` policy is applied above it, so the wire
+    shape of that field does not depend on which kind of issue a row is."""
+    from coord.milestone_order import TRACKING_ISSUE_LABEL
+
+    epic = {"state": "open", "body": "x", "labels": [TRACKING_ISSUE_LABEL],
+            "state_reason": ""}
+    bound_issue_row(epic)
+    assert "state_reason" not in epic
+
+    reopened_epic = {"state": "open", "body": "x", "labels": [TRACKING_ISSUE_LABEL],
+                     "state_reason": "reopened"}
+    bound_issue_row(reopened_epic)
+    assert reopened_epic["state_reason"] == "reopened"
+
+
+def test_a_reopened_issue_is_still_not_landed_after_the_http_wire(
+    tmp_path: Path, valid_config_path: Path
+) -> None:
+    """#3384 end to end over the REAL wire: serve `/board` from a seeded DB,
+    reduce the response exactly as `coord drive-queue tick` does, and assert
+    the reopened issue's stale `merged` record still does NOT read as landed
+    — while the control issue (merged, never closed, the quadraui case) still
+    does. This is the assertion the byte cut could break."""
+    from coord.drive_queue import build_board_view, entry_key
+
+    db = tmp_path / "reopened.db"
+    conn = _ensure_schema_db(db)
+    _seed_reopened_and_control(conn)
+    conn.close()
+
+    board = _board_over_http(db, valid_config_path)
+    view = build_board_view(board)
+
+    reopened = view.facts(entry_key("api", 3380))
+    assert reopened.merged is True  # the stale record is still on the board
+    assert reopened.reopened is True  # ...and the witness survived the wire
+    assert reopened.landed is False  # ...so the entry is NOT waved through
+
+    control = view.facts(entry_key("api", 3381))
+    assert control.merged is True
+    assert control.reopened is False
+    assert control.landed is True
+
+
+def test_the_wire_and_the_daemon_host_local_path_agree_on_reopened(
+    tmp_path: Path, valid_config_path: Path, coord_db
+) -> None:
+    """One question, one answer (#2085): `reopened` is asked on two surfaces
+    — the HTTP `/board` wire (thin clients) and the daemon host's own local
+    SELECTs, which never run through `coord.board_wire` at all. Dropping the
+    empty default on only one of them would put the two surfaces on different
+    answers for the same DB. Assert all three reductions agree, row for row.
+    """
+    from coord.commands.drive_queue import _local_issue_rows as tick_rows
+    from coord.drive_queue import build_board_view, entry_key
+    from coord.drive_state import _local_issue_rows as drive_rows
+
+    db = tmp_path / "reopened.db"
+    conn = _ensure_schema_db(db)
+    _seed_reopened_and_control(conn)
+    conn.close()
+
+    # Same rows again, this time in the autouse `coord_db` the local paths read.
+    _seed_reopened_and_control(coord_db)
+
+    board = _board_over_http(db, valid_config_path)
+    assignments = board["assignments"]
+    views = {
+        "http": build_board_view(board),
+        "drive_state": build_board_view(
+            {"assignments": assignments, "issues": drive_rows()}
+        ),
+        "tick": build_board_view(
+            {"assignments": assignments, "issues": tick_rows()}
+        ),
+    }
+    for number, expected in ((3380, True), (3381, False)):
+        key = entry_key("api", number)
+        answers = {name: v.facts(key).reopened for name, v in views.items()}
+        assert set(answers.values()) == {expected}, (
+            f"api#{number}: the three surfaces disagree about `reopened` "
+            f"({answers}) — a split-brain, whichever one is right"
+        )
+        landed = {name: v.facts(key).landed for name, v in views.items()}
+        assert set(landed.values()) == {not expected}, (
+            f"api#{number}: the three surfaces disagree about `landed` ({landed})"
+        )

{code_coordinator-0.5.494 → code_coordinator-0.5.495}/tests/test_db.py

@@ -2465,7 +2465,10 @@ class TestUatStateAndReasonColumns:
 # #3357 bumped this to (18, 96): `assignments.test_confirmation` —
 # machine-readable provenance for a `test_state` write (confirmed by a real
 # out-of-band re-run, or merely carried forward from the worker's claim).
-_PINNED_SCHEMA_VERSION_AND_MIGRATION_COUNT = (18, 96)
+# #3384 bumped this to (19, 97): `issues.state_reason` — GitHub's own witness
+# that an issue was explicitly reopened, distinguishing that from an issue
+# that merged without ever auto-closing.
+_PINNED_SCHEMA_VERSION_AND_MIGRATION_COUNT = (19, 97)
 
 
 class TestMigrateAddColumnsVersionGuard: