code-coordinator 0.5.513__tar.gz → 0.5.515__tar.gz

{code_coordinator-0.5.513 → code_coordinator-0.5.515}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.513",
+  "tag": "0.5.515",
   "distance": 0,
-  "node": "g62d2f7e1d36394c598063480dfdc2028204abbf1",
+  "node": "ge613e87191b4cc036d660b56820c2096be20c180",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-09-21"

{code_coordinator-0.5.513 → code_coordinator-0.5.515}/coord/ci_store.py

@@ -539,6 +539,25 @@ CI_RERUN_POLL_INTERVAL_SECONDS = 10.0
 CI_RERUN_MAX_WAIT_SECONDS = 360.0
 
 
+def is_unreadable_check_name(name: str) -> bool:
+    """The name-only half of :func:`is_unreadable_check` (#3438).
+
+    Split out so a caller holding only a bare check *name* — not a full
+    ``CheckRun`` with a ``.conclusion`` — can still recognize the #1525
+    synthetic stand-in. This is exactly the shape of
+    ``QueuedMerge.ci_seen_check_names_json`` (:mod:`coord.merge_queue`'s
+    #3263 shrinkage guard persists names, not whole ``CheckRun`` objects),
+    so a row poisoned before #3438's write-side fix — one whose stored JSON
+    already contains a synthetic name — can be filtered on *read* too,
+    recovering in place rather than needing manual DB repair.
+
+    One question, one answer: :func:`is_unreadable_check` delegates here for
+    its own name check rather than re-deriving the same prefix/substring
+    test, so the two can never drift apart.
+    """
+    return name.startswith("coord: ") and "read CI status" in name
+
+
 def is_unreadable_check(check) -> bool:
     """True for the #1525 synthetic "could not read CI status" / "gh too
     old" stand-ins (``coord.ci_github._unreadable_check`` /
@@ -570,11 +589,7 @@ def is_unreadable_check(check) -> bool:
     than the prose these three call sites already commit to.
     """
     name = str(getattr(check, "name", ""))
-    return (
-        getattr(check, "conclusion", None) == "unknown"
-        and name.startswith("coord: ")
-        and "read CI status" in name
-    )
+    return getattr(check, "conclusion", None) == "unknown" and is_unreadable_check_name(name)
 
 
 @dataclass

{code_coordinator-0.5.513 → code_coordinator-0.5.515}/coord/claim.py

@@ -454,20 +454,38 @@ def _default_branch_lookup(repo_github: str, issue_number: int) -> list[str]:
     return _drop_merged_branches(repo_github, branches)
 
 
-def any_matching_branch_merged(repo_github: str, issue_number: int) -> bool:
-    """#3376: True when at least one remote branch matching `issue-{N}-*`
-    has already merged into the repo's default branch — the `branch_merged`
-    predicate `coord.dispatch_liveness.check_dispatch_liveness` needs,
-    backed by a live GitHub check.
-
-    Reuses the exact merge-detection `_drop_merged_branches` already
-    performs for claim detection (PR-merged OR `ahead_by == 0` ancestry,
-    survives squash merges — #3103): this is just "did filtering drop
-    anything", with the fail-open direction flipped to match a REFUSAL
-    predicate rather than a claim-signal — no matching branch at all, or
-    any lookup failure, returns `False` ("not merged, don't refuse
+def any_matching_branch_merged(
+    repo_github: str, issue_number: int, *, branch: str | None = None
+) -> bool:
+    """#3376: True when the branch a dispatch is about to act on has already
+    merged into the repo's default branch — the `branch_merged` predicate
+    `coord.dispatch_liveness.check_dispatch_liveness` needs, backed by a
+    live GitHub check.
+
+    #3436: when *branch* is given — the exact branch the dispatch targets,
+    e.g. an `Assignment.branch` or `Proposal.target_branch` — this checks
+    ONLY that branch and ignores every other `issue-{N}-*` sibling. Without
+    this, the issue-scoped fallback below answers "has ANY branch for this
+    issue merged", which a single zero-commit review-leg branch (cut from
+    the then-current default-branch tip and never diverged — routine
+    residue of a review/scoped-review leg, not evidence the real work
+    landed) trips forever, permanently refusing dispatch for an issue whose
+    actual work branch sits unmerged with real commits on it.
+
+    Falls back to the original issue-scoped "has ANY matching branch
+    merged" behaviour only when *branch* is `None` — a caller with nothing
+    assigned yet (a pre-dispatch check before any branch exists) has no
+    single branch to ask about, so the issue-scoped signal is the best one
+    available. Reuses the exact merge-detection `_drop_merged_branches`
+    already performs for claim detection (PR-merged OR `ahead_by == 0`
+    ancestry, survives squash merges — #3103): this is just "did filtering
+    drop anything", with the fail-open direction flipped to match a
+    REFUSAL predicate rather than a claim-signal — no matching branch at
+    all, or any lookup failure, returns `False` ("not merged, don't refuse
     dispatch on this"), never `True`.
     """
+    if branch is not None:
+        return not _drop_merged_branches(repo_github, [branch])
     branches = list_matching_remote_branches(repo_github, issue_number)
     if not branches:
         return False

{code_coordinator-0.5.513 → code_coordinator-0.5.515}/coord/dispatch.py

@@ -653,12 +653,16 @@ def dispatch(
     like every caller that predates this parameter — same opt-in shape as
     *status_fetcher*.
 
-    *issue_liveness_fetcher* (#3376) is `(repo_name: str, issue_number: int)
-    -> (issue_closed: bool, branch_merged: bool)` — the other two
-    predicates of the same STRUCTURAL DISPATCH-LIVENESS GATE. `None` (the
-    default) performs no check at all and refuses nothing, same opt-in
-    shape as *credential_fetcher*. See `coord.dispatch_liveness` for the
-    single function all three predicates funnel through.
+    *issue_liveness_fetcher* (#3376) is `(repo_name: str, issue_number: int,
+    branch: str | None) -> (issue_closed: bool, branch_merged: bool)` — the
+    other two predicates of the same STRUCTURAL DISPATCH-LIVENESS GATE.
+    `None` (the default) performs no check at all and refuses nothing, same
+    opt-in shape as *credential_fetcher*. `branch` (#3436) is
+    `proposal.target_branch` — the exact branch THIS dispatch would land
+    on, not merely some `issue-{N}-*` sibling — so a zero-commit review-leg
+    branch cut from the default branch never masquerades as "this issue's
+    work already merged". See `coord.dispatch_liveness` for the single
+    function all three predicates funnel through.
     """
     machine = next(
         (m for m in config.machines if m.name == proposal.machine_name), None
@@ -865,7 +869,7 @@ def dispatch(
     branch_merged: bool | None = None
     if issue_liveness_fetcher is not None:
         issue_closed, branch_merged = issue_liveness_fetcher(
-            proposal.repo_name, proposal.issue_number
+            proposal.repo_name, proposal.issue_number, proposal.target_branch
         )
     machine_healthy: bool | None = None
     if credential_fetcher is not None:

{code_coordinator-0.5.513 → code_coordinator-0.5.515}/coord/dispatch_liveness.py

@@ -148,8 +148,8 @@ def check_dispatch_liveness(
 
 def github_issue_liveness_fetcher(
     config: "Config",
-) -> Callable[[str, int], tuple[bool, bool]]:
-    """Build a REAL `(repo_name, issue_number) -> (issue_closed,
+) -> Callable[[str, int, str | None], tuple[bool, bool]]:
+    """Build a REAL `(repo_name, issue_number, branch) -> (issue_closed,
     branch_merged)` fetcher, backed by live GitHub calls — the piece #3376
     review round 1 found missing: `check_dispatch_liveness`'s two new
     predicates existed and were unit-tested, but every actual dispatch
@@ -165,30 +165,37 @@ def github_issue_liveness_fetcher(
 
     Resolves `repo_name` (coordinator.yml's internal name) to `owner/repo`
     via *config* — every fetcher call inside `coord.dispatch.dispatch()`
-    only ever hands this `(proposal.repo_name, proposal.issue_number)`, so
-    the GitHub-repo mapping has to happen inside the closure, not at the
-    call site.
+    only ever hands this `(proposal.repo_name, proposal.issue_number,
+    proposal.target_branch)`, so the GitHub-repo mapping has to happen
+    inside the closure, not at the call site.
 
     issue_closed: `coord.github_ops.issue_is_closed` — one `gh` call.
-    branch_merged: `coord.claim.any_matching_branch_merged` — is there a
-    remote `issue-{N}-*` branch (any slug, not a title-guessed one — a
-    dispatch site has no reliable way to know which title a PRIOR dispatch
-    used to slugify its branch, and issue titles can be edited after the
-    fact) whose current tip has already merged. Both fail open (`False`) on
-    any GitHub/network hiccup — same "never refuse on evidence we don't
-    have" posture `claude_credential_reachable` documents for the third
-    predicate, and matching `issue_is_closed`'s/`pr_is_merged`'s own
-    documented fail-open contracts.
+    branch_merged: `coord.claim.any_matching_branch_merged` — #3436: when
+    *branch* is given (the dispatch's actual target — e.g. `Assignment.
+    branch`/`Proposal.target_branch`), asks whether THAT branch has merged
+    and ignores every other `issue-{N}-*` sibling, so a zero-commit
+    review-leg branch cut from the default-branch tip can no longer
+    permanently refuse dispatch for the issue's real, unmerged work
+    branch. `branch=None` (a caller with nothing dispatched yet) falls
+    back to the original issue-scoped "any matching branch merged" check.
+    Both fail open (`False`) on any GitHub/network hiccup — same "never
+    refuse on evidence we don't have" posture `claude_credential_reachable`
+    documents for the third predicate, and matching `issue_is_closed`'s/
+    `pr_is_merged`'s own documented fail-open contracts.
     """
 
-    def fetcher(repo_name: str, issue_number: int) -> tuple[bool, bool]:
+    def fetcher(
+        repo_name: str, issue_number: int, branch: str | None = None
+    ) -> tuple[bool, bool]:
         from coord import github_ops  # noqa: PLC0415
         from coord.claim import any_matching_branch_merged  # noqa: PLC0415
 
         repo_cfg = config.repo(repo_name)
         repo_github = repo_cfg.github if repo_cfg is not None else repo_name
         issue_closed = github_ops.issue_is_closed(repo_github, issue_number)
-        branch_merged = any_matching_branch_merged(repo_github, issue_number)
+        branch_merged = any_matching_branch_merged(
+            repo_github, issue_number, branch=branch
+        )
         return issue_closed, branch_merged
 
     return fetcher

{code_coordinator-0.5.513 → code_coordinator-0.5.515}/coord/merge_queue.py

@@ -38,6 +38,7 @@ from coord.ci_store import (
     failed_checks,
     in_flight_checks,
     is_unreadable_check,
+    is_unreadable_check_name,
     is_verdictless_job,
     shrunk_check_names,
     summarize,
@@ -2442,7 +2443,11 @@ def _ci_seen_check_names(entry: "QueuedMerge") -> frozenset[str]:
         return frozenset()
     if not isinstance(names, list):
         return frozenset()
-    return frozenset(str(n) for n in names)
+    # #3438: filter defensively on READ too, not just at the #3438 write-side
+    # fix in `_ci_record_seen_check_names` — a row already poisoned in the
+    # wild (written before this fix) recovers on its very next read here,
+    # rather than being stuck until someone hand-edits the DB.
+    return frozenset(str(n) for n in names if not is_unreadable_check_name(str(n)))
 
 
 def _ci_record_seen_check_names(entry: "QueuedMerge", checks: list[CheckRun]) -> None:
@@ -2462,9 +2467,20 @@ def _ci_record_seen_check_names(entry: "QueuedMerge", checks: list[CheckRun]) ->
     that disappears for more than one consecutive tick keeps being flagged
     rather than being silently dropped from the record the moment it first
     vanishes.
+
+    #3438: the #1525 synthetic "could not read CI status" stand-in
+    (:func:`coord.ci_store.is_unreadable_check`) is excluded from
+    *current_names* on BOTH branches. That stand-in only ever appears in a
+    read where the real checks could not be fetched at all; memoizing its
+    name would poison this entry permanently, because the only read that
+    could ever re-supply it (another failed fetch) would simultaneously
+    fail to report every real check name too, which the #3263 guard would
+    also reject as shrinkage — a closed loop with no exit. Filtering here,
+    at the point of record, means it never enters
+    ``ci_seen_check_names_json`` in the first place, on either branch.
     """
     sha = entry.branch_head_sha or ""
-    current_names = {c.name for c in checks}
+    current_names = {c.name for c in checks if not is_unreadable_check(c)}
     if entry.ci_seen_checks_sha != sha:
         entry.ci_seen_checks_sha = sha
         entry.ci_seen_check_names_json = json.dumps(sorted(current_names))

{code_coordinator-0.5.513 → code_coordinator-0.5.515}/coord/milestone_dispatch.py

@@ -1092,10 +1092,12 @@ def dispatch_entry(
     assign`), matching the same check ``_dispatch_headless`` performs.
 
     *issue_liveness_fetcher* (#3376) is an optional ``(repo_name: str,
-    issue_number: int) -> (issue_closed: bool, branch_merged: bool)``
-    callable threaded straight through to :func:`coord.dispatch.dispatch`'s
-    parameter of the same name — the STRUCTURAL DISPATCH-LIVENESS GATE's
-    other two predicates. ``None`` (the default) performs no check and
+    issue_number: int, branch: str | None) -> (issue_closed: bool,
+    branch_merged: bool)`` callable threaded straight through to
+    :func:`coord.dispatch.dispatch`'s parameter of the same name — the
+    STRUCTURAL DISPATCH-LIVENESS GATE's other two predicates (#3436:
+    ``dispatch()`` itself supplies the branch, from ``proposal.
+    target_branch``). ``None`` (the default) performs no check and
     refuses nothing, same opt-in shape as every other fetcher in this
     module; the daemon's auto-drain/gate ticks (``coord.serve_app``'s
     ``_milestone_drain_tick``/``_milestone_gate_tick``) are the production

{code_coordinator-0.5.513 → code_coordinator-0.5.515}/coord/reconcile.py

@@ -1752,7 +1752,10 @@ def _resolve_retry_provider(
 
 
 def _issue_liveness_from_cache(
-    board: Board, repo_name: str, issue_number: int
+    board: Board,
+    repo_name: str,
+    issue_number: int,
+    branch: str | None = None,
 ) -> tuple[bool, bool]:
     """#3376: local-only ``issue_liveness_fetcher`` for `_reassign` —
     "issue closed" from the local `issues` cache table (`coord.state.
@@ -1763,6 +1766,14 @@ def _issue_liveness_from_cache(
     ``"merged"``). Neither call touches GitHub — same "no live probe from
     a passive tick" posture as the ``cached_labels`` lookup beside this
     function's one caller.
+
+    #3436: when *branch* is given (the failed row's own `Assignment.
+    branch` — the branch a retry would actually land on), the "merged"
+    scan is additionally scoped to rows on THAT branch, not merely any
+    completed row for the issue — a merged review-leg row for the same
+    issue on a *different*, zero-commit branch must not read as "this
+    issue's work already merged" and block a retry of the real, unmerged
+    work branch. `branch=None` keeps the original issue-scoped behaviour.
     """
     from coord.state import get_cached_issue_state  # noqa: PLC0415
 
@@ -1771,6 +1782,7 @@ def _issue_liveness_from_cache(
         a.repo_name == repo_name
         and a.issue_number == issue_number
         and a.status == "merged"
+        and (branch is None or a.branch == branch)
         for a in board.completed
     )
     return issue_closed, branch_merged
@@ -1812,20 +1824,23 @@ def _reassign(
     entry point.
 
     *issue_liveness_fetcher* (#3376) is an optional ``(repo_name: str,
-    issue_number: int) -> (issue_closed: bool, branch_merged: bool)``
-    callable — the other two predicates of the same STRUCTURAL DISPATCH-
-    LIVENESS GATE `coord.dispatch.dispatch()` itself checks (see
-    `coord.dispatch_liveness`). `None` (the default here) performs no
-    check and skips nothing — same opt-in shape as *credential_fetcher*
-    above, for the same reason: the real wiring happens at `reconcile()`'s
-    own call site. Unlike *credential_fetcher* (a machine FILTER — an
-    unhealthy machine is simply excluded from *candidates*), a positive
-    hit here means the auto-reassign attempt itself is pointless — #3367's
-    own incident was exactly this shape one layer up (four auto-retried
-    review dispatches against a dead host); #3376 generalizes it to "is
-    the thing being retried still real at all", so this returns ``None``
-    (skip, exactly like "no candidate machines") rather than trying
-    another machine.
+    issue_number: int, branch: str | None) -> (issue_closed: bool,
+    branch_merged: bool)`` callable — the other two predicates of the same
+    STRUCTURAL DISPATCH-LIVENESS GATE `coord.dispatch.dispatch()` itself
+    checks (see `coord.dispatch_liveness`). `None` (the default here)
+    performs no check and skips nothing — same opt-in shape as
+    *credential_fetcher* above, for the same reason: the real wiring
+    happens at `reconcile()`'s own call site. Unlike *credential_fetcher*
+    (a machine FILTER — an unhealthy machine is simply excluded from
+    *candidates*), a positive hit here means the auto-reassign attempt
+    itself is pointless — #3367's own incident was exactly this shape one
+    layer up (four auto-retried review dispatches against a dead host);
+    #3376 generalizes it to "is the thing being retried still real at
+    all", so this returns ``None`` (skip, exactly like "no candidate
+    machines") rather than trying another machine. #3436: *branch* is
+    ``failed.branch`` — the exact branch a retry would land on — so a
+    merged sibling branch for the same issue no longer masquerades as
+    "this issue's work already merged".
 
     Raises :class:`UnsupportedRetryType` when ``failed.type`` is not in
     :data:`coord.models.WORK_LIKE_TYPES` — a ``smoke``/``review``/other
@@ -1842,7 +1857,7 @@ def _reassign(
 
     if issue_liveness_fetcher is not None:
         issue_closed, branch_merged = issue_liveness_fetcher(
-            failed.repo_name, failed.issue_number
+            failed.repo_name, failed.issue_number, failed.branch
         )
         refusal = check_dispatch_liveness(
             repo_name=failed.repo_name,
@@ -2797,8 +2812,8 @@ def reconcile(board: Board, config: Config) -> list[str]:
                 reassigned = _reassign(
                     failed_a, board, config, issue_labels=cached_labels,
                     credential_fetcher=claude_credential_reachable,
-                    issue_liveness_fetcher=lambda repo, num: (
-                        _issue_liveness_from_cache(board, repo, num)
+                    issue_liveness_fetcher=lambda repo, num, branch=None: (
+                        _issue_liveness_from_cache(board, repo, num, branch)
                     ),
                 )
             except RetryProviderMismatch:

{code_coordinator-0.5.513 → code_coordinator-0.5.515}/coord/smoke.py

@@ -3033,7 +3033,9 @@ def dispatch_pending_smoke(
     *,
     now: float | None = None,
     gh_ops: "GhOps | None" = None,
-    issue_liveness_fetcher: Callable[[str, int], tuple[bool, bool]] | None = None,
+    issue_liveness_fetcher: (
+        Callable[[str, int, str | None], tuple[bool, bool]] | None
+    ) = None,
 ) -> list[Assignment]:
     """Bulk Test-stage dispatch — the smoke analogue of
     :func:`coord.review.dispatch_pending_reviews`.
@@ -3066,10 +3068,15 @@ def dispatch_pending_smoke(
     live gate check in this codebase hands `merge_queue`'s gate functions.
 
     #3375: *issue_liveness_fetcher* is the SAME opt-in
-    ``(repo_name, issue_number) -> (issue_closed, branch_merged)`` contract
-    `coord.dispatch_liveness.check_dispatch_liveness` already gates
-    `coord.dispatch.dispatch()` with (#3376) — but this stage never went
-    through that call path. `dispatch_smoke`/`_dispatch_smoke_legs` POST
+    ``(repo_name, issue_number, branch) -> (issue_closed, branch_merged)``
+    contract `coord.dispatch_liveness.check_dispatch_liveness` already
+    gates `coord.dispatch.dispatch()` with (#3376) — but this stage never
+    went through that call path. #3436: *branch* is `completed.branch` —
+    the row's own branch, not merely some `issue-{N}-*` sibling — so a
+    zero-commit review-leg branch cut from the default branch can no
+    longer masquerade as "this issue's work already merged" and
+    permanently skip the Test stage for the real, unmerged work branch.
+    `dispatch_smoke`/`_dispatch_smoke_legs` POST
     straight to a machine's `/assign` over `httpx`, so #3376's dispatch-time
     gate never saw a Test-stage dispatch at all, and the five-smoke-agents
     incident that motivated both issues could still reproduce after #3376
@@ -3316,7 +3323,7 @@ def dispatch_pending_smoke(
             )
 
             issue_closed, branch_merged = issue_liveness_fetcher(
-                completed.repo_name, completed.issue_number
+                completed.repo_name, completed.issue_number, completed.branch
             )
             refusal = check_dispatch_liveness(
                 repo_name=completed.repo_name,

{code_coordinator-0.5.513 → code_coordinator-0.5.515}/tests/test_ci_store.py

@@ -218,6 +218,46 @@ class TestShrunkCheckNames:
         assert shrunk_check_names(seen, checks) == frozenset({"a", "b"})
 
 
+class TestIsUnreadableCheckName:
+    """#3438: the name-only half of `is_unreadable_check`, split out so a
+    caller holding only a bare check NAME (e.g. `coord.merge_queue`'s
+    persisted `ci_seen_check_names_json`, which stores names, not whole
+    `CheckRun` objects) can still recognize the #1525 synthetic stand-in."""
+
+    def test_matches_the_unreadable_check_stand_in_name(self) -> None:
+        from coord.ci_store import is_unreadable_check_name
+        name = "coord: could not read CI status for acme/api#99 (HTTP 503)"
+        assert is_unreadable_check_name(name) is True
+
+    def test_matches_the_gh_too_old_stand_in_name(self) -> None:
+        from coord.ci_store import is_unreadable_check_name
+        name = "coord: gh is too old to read CI status for acme/api#99 (v1.0)"
+        assert is_unreadable_check_name(name) is True
+
+    def test_does_not_match_a_real_check_name(self) -> None:
+        from coord.ci_store import is_unreadable_check_name
+        assert is_unreadable_check_name("cargo-test") is False
+
+    def test_does_not_match_the_gate_snapshot_stale_stand_in(self) -> None:
+        """A different `coord: `-prefixed synthetic, for a different local
+        condition (#2347's own documented distinction) — must not match
+        just because it shares the prefix."""
+        from coord.ci_store import is_unreadable_check_name
+        name = "coord: gate snapshot stale (120s)"
+        assert is_unreadable_check_name(name) is False
+
+    def test_agrees_with_is_unreadable_check_on_full_check_objects(self) -> None:
+        """One question, one answer: `is_unreadable_check` must delegate
+        here rather than re-deriving the same test, so the two can never
+        drift apart."""
+        from coord.ci_github import _unreadable_check
+        from coord.ci_store import is_unreadable_check, is_unreadable_check_name
+
+        check = _unreadable_check("acme/api", 99, "HTTP 503")
+        assert is_unreadable_check(check) is True
+        assert is_unreadable_check_name(check.name) is True
+
+
 class _FakeClock:
     """Deterministic (clock, sleep) pair for `wait_for_ci_settle` tests
     (#1925) — `sleep` advances the same counter `clock` reads, so a bounded

{code_coordinator-0.5.513 → code_coordinator-0.5.515}/tests/test_claim.py

@@ -873,6 +873,40 @@ def test_any_matching_branch_merged_false_on_gh_error(monkeypatch) -> None:
     assert claim_mod.any_matching_branch_merged("acme/api", 9) is False
 
 
+def test_any_matching_branch_merged_scoped_branch_ignores_merged_siblings(
+    monkeypatch,
+) -> None:
+    """#3436: reproduces vimcode#1156's shape — several MERGED, zero-commit
+    `issue-{N}-*` review-leg branches (cut from the default-branch tip,
+    never diverged) alongside the one real, unmerged work branch. The
+    issue-scoped (no ``branch=``) check is tripped by the merged siblings —
+    the documented fallback behaviour for a caller with nothing dispatched
+    yet — but a caller that names the ACTUAL branch in play must get an
+    answer scoped to just that branch, not "did anything for this issue
+    ever merge"."""
+    import coord.claim as claim_mod
+
+    monkeypatch.setattr(
+        "coord.github_ops._gh",
+        _gh_stub_with_matching_refs(
+            ["issue-1156-review-fix-1", "issue-1156-real-work"],
+            "main",
+            {"issue-1156-review-fix-1": 0, "issue-1156-real-work": 5},
+        ),
+    )
+    # No branch named: falls back to the issue-scoped check, which still
+    # trips on the merged sibling (unchanged pre-#3436 fallback behaviour).
+    assert claim_mod.any_matching_branch_merged("acme/api", 1156) is True
+    # Scoped to the real, unmerged work branch: must NOT report merged.
+    assert claim_mod.any_matching_branch_merged(
+        "acme/api", 1156, branch="issue-1156-real-work"
+    ) is False
+    # Scoped to the merged sibling itself: correctly reports merged.
+    assert claim_mod.any_matching_branch_merged(
+        "acme/api", 1156, branch="issue-1156-review-fix-1"
+    ) is True
+
+
 # ── #1553: has_active_work_followup keys on the EFFECTIVE issue ─────────────
 
 

{code_coordinator-0.5.513 → code_coordinator-0.5.515}/tests/test_cli_network.py

@@ -480,7 +480,7 @@ class TestApproveProviderAwareModel:
         with patch("coord.dispatch.httpx.post", return_value=mock_resp) as mock_post, \
              patch(
                  "coord.dispatch_liveness.github_issue_liveness_fetcher",
-                 return_value=lambda _repo, _issue: (False, False),
+                 return_value=lambda _repo, _issue, _branch=None: (False, False),
              ), \
              patch("coord.github_ops.get_issue") as mock_get_issue, \
              patch("coord.github_ops.post_issue_comment"):

{code_coordinator-0.5.513 → code_coordinator-0.5.515}/tests/test_dispatch.py

@@ -2610,6 +2610,28 @@ class TestDispatchLivenessGate:
         dispatch(proposal, config)
         mock_post.assert_called_once()
 
+    @patch("coord.dispatch.httpx.post")
+    def test_passes_proposal_target_branch_to_the_fetcher(
+        self, mock_post: MagicMock, config: Config, proposal: Proposal,
+    ) -> None:
+        """#3436: the fetcher must see the DISPATCH'S OWN target branch, not
+        just `(repo_name, issue_number)` — the whole point being that a
+        merged, zero-commit `issue-{N}-*` sibling (e.g. a review-leg
+        branch) must not be able to answer for the real work branch this
+        exact dispatch is about to land on."""
+        mock_resp = MagicMock()
+        mock_resp.json.return_value = {"id": "abc"}
+        mock_post.return_value = mock_resp
+        proposal.target_branch = "issue-10-fix-auth"
+        seen: list[tuple] = []
+
+        def fetcher(repo, num, branch=None):
+            seen.append((repo, num, branch))
+            return False, False
+
+        dispatch(proposal, config, issue_liveness_fetcher=fetcher)
+        assert seen == [("api", 10, "issue-10-fix-auth")]
+
     @patch("coord.dispatch.record_dispatch_refusal")
     @patch("coord.dispatch.httpx.post")
     def test_refuses_a_closed_issue(
@@ -2619,7 +2641,7 @@ class TestDispatchLivenessGate:
         with pytest.raises(DispatchRefused, match="already closed"):
             dispatch(
                 proposal, config,
-                issue_liveness_fetcher=lambda repo, num: (True, False),
+                issue_liveness_fetcher=lambda repo, num, branch=None: (True, False),
             )
         mock_post.assert_not_called()
         mock_record.assert_called_once()
@@ -2633,7 +2655,7 @@ class TestDispatchLivenessGate:
         with pytest.raises(DispatchRefused, match="already merged"):
             dispatch(
                 proposal, config,
-                issue_liveness_fetcher=lambda repo, num: (False, True),
+                issue_liveness_fetcher=lambda repo, num, branch=None: (False, True),
             )
         mock_post.assert_not_called()
         mock_record.assert_called_once()
@@ -2647,7 +2669,7 @@ class TestDispatchLivenessGate:
         mock_post.return_value = mock_resp
         dispatch(
             proposal, config,
-            issue_liveness_fetcher=lambda repo, num: (False, False),
+            issue_liveness_fetcher=lambda repo, num, branch=None: (False, False),
         )
         mock_post.assert_called_once()
 
@@ -2662,7 +2684,7 @@ class TestDispatchLivenessGate:
         with pytest.raises(ValueError, match="not routable"):
             dispatch(
                 proposal, config,
-                issue_liveness_fetcher=lambda repo, num: (False, False),
+                issue_liveness_fetcher=lambda repo, num, branch=None: (False, False),
                 credential_fetcher=lambda m: False,
             )
         mock_post.assert_not_called()
@@ -2680,17 +2702,17 @@ class TestDispatchLivenessGate:
         with pytest.raises(DispatchRefused):
             dispatch(
                 proposal, config,
-                issue_liveness_fetcher=lambda repo, num: (True, False),
+                issue_liveness_fetcher=lambda repo, num, branch=None: (True, False),
             )
         with pytest.raises(DispatchRefused):
             dispatch(
                 proposal, config,
-                issue_liveness_fetcher=lambda repo, num: (False, True),
+                issue_liveness_fetcher=lambda repo, num, branch=None: (False, True),
             )
         with pytest.raises(DispatchRefused):
             dispatch(
                 proposal, config,
-                issue_liveness_fetcher=lambda repo, num: (False, False),
+                issue_liveness_fetcher=lambda repo, num, branch=None: (False, False),
                 credential_fetcher=lambda m: False,
             )
         mock_post.assert_not_called()

{code_coordinator-0.5.513 → code_coordinator-0.5.515}/tests/test_dispatch_liveness.py

@@ -140,7 +140,7 @@ class TestGithubIssueLivenessFetcher:
         assert issue_closed is True
         assert branch_merged is False
         mock_closed.assert_called_once_with("acme/api", 42)
-        mock_merged.assert_called_once_with("acme/api", 42)
+        mock_merged.assert_called_once_with("acme/api", 42, branch=None)
 
     @patch("coord.claim.any_matching_branch_merged", return_value=True)
     @patch("coord.github_ops.issue_is_closed", return_value=False)
@@ -167,4 +167,22 @@ class TestGithubIssueLivenessFetcher:
         assert issue_closed is False
         assert branch_merged is False
         mock_closed.assert_called_once_with("ghost", 1)
-        mock_merged.assert_called_once_with("ghost", 1)
+        mock_merged.assert_called_once_with("ghost", 1, branch=None)
+
+    @patch("coord.claim.any_matching_branch_merged", return_value=False)
+    @patch("coord.github_ops.issue_is_closed", return_value=False)
+    def test_passes_the_target_branch_through(
+        self, mock_closed: MagicMock, mock_merged: MagicMock,
+    ) -> None:
+        """#3436: a caller that names a specific branch (the dispatch's
+        actual target — e.g. `Proposal.target_branch`/`Assignment.branch`)
+        must have it forwarded to `any_matching_branch_merged`'s
+        branch-scoped check, not silently dropped in favour of the
+        issue-scoped fallback."""
+        fetcher = github_issue_liveness_fetcher(self._config())
+        issue_closed, branch_merged = fetcher("api", 42, "issue-42-real-work")
+        assert issue_closed is False
+        assert branch_merged is False
+        mock_merged.assert_called_once_with(
+            "acme/api", 42, branch="issue-42-real-work"
+        )