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

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

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

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

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

{code_coordinator-0.5.513 → code_coordinator-0.5.514}/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.514}/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.514}/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.514}/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.514}/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.514}/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.514}/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.514}/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.514}/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.514}/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"
+        )

{code_coordinator-0.5.513 → code_coordinator-0.5.514}/tests/test_reconcile.py

@@ -412,7 +412,7 @@ class TestReassignLivenessGate:
     ) -> None:
         result = _reassign(
             _failed(), Board(), _plain_cfg(),
-            issue_liveness_fetcher=lambda repo, num: (True, False),
+            issue_liveness_fetcher=lambda repo, num, branch=None: (True, False),
         )
         assert result is None
         mock_post.assert_not_called()
@@ -425,7 +425,7 @@ class TestReassignLivenessGate:
     ) -> None:
         result = _reassign(
             _failed(), Board(), _plain_cfg(),
-            issue_liveness_fetcher=lambda repo, num: (False, True),
+            issue_liveness_fetcher=lambda repo, num, branch=None: (False, True),
         )
         assert result is None
         mock_post.assert_not_called()
@@ -438,11 +438,34 @@ class TestReassignLivenessGate:
         mock_post.return_value = resp
         result = _reassign(
             _failed(), Board(), _plain_cfg(),
-            issue_liveness_fetcher=lambda repo, num: (False, False),
+            issue_liveness_fetcher=lambda repo, num, branch=None: (False, False),
         )
         assert result is not None
         mock_post.assert_called_once()
 
+    @patch("coord.reconcile.httpx.post")
+    def test_passes_failed_branch_to_the_fetcher(
+        self, mock_post: MagicMock,
+    ) -> None:
+        """#3436: the fetcher must see the FAILED ROW'S OWN branch, not
+        just `(repo_name, issue_number)` — a merged, zero-commit
+        `issue-{N}-*` sibling must not be able to answer for a retry that
+        would actually land on a different, unmerged branch."""
+        resp = MagicMock()
+        resp.json.return_value = {"id": "newid"}
+        mock_post.return_value = resp
+        seen: list[tuple] = []
+
+        def fetcher(repo, num, branch=None):
+            seen.append((repo, num, branch))
+            return False, False
+
+        _reassign(
+            _failed(branch="issue-1-real-work"), Board(), _plain_cfg(),
+            issue_liveness_fetcher=fetcher,
+        )
+        assert seen == [("api", 1, "issue-1-real-work")]
+
 
 class TestIssueLivenessFromCache:
     """#3376: `_issue_liveness_from_cache` — the real fetcher `reconcile()`
@@ -479,6 +502,36 @@ class TestIssueLivenessFromCache:
         assert closed is False
         assert merged is True
 
+    def test_merged_scoped_to_branch_ignores_merged_sibling(self) -> None:
+        """#3436: a merged completed row for the same issue but on a
+        DIFFERENT branch (e.g. a review-leg branch cut from the default
+        branch) must not report "merged" for a retry that targets the
+        issue's real, unmerged work branch."""
+        from coord.reconcile import _issue_liveness_from_cache
+
+        board = Board(
+            completed=[
+                _failed(
+                    status="merged", issue_number=42, type="review",
+                    branch="issue-42-review-fix-1",
+                ),
+            ]
+        )
+        # No branch given: falls back to the issue-scoped check, which
+        # still reports the merged sibling (unchanged fallback behaviour).
+        closed, merged = _issue_liveness_from_cache(board, "api", 42)
+        assert merged is True
+        # Scoped to the real work branch: must NOT report merged.
+        closed, merged = _issue_liveness_from_cache(
+            board, "api", 42, "issue-42-real-work"
+        )
+        assert merged is False
+        # Scoped to the merged sibling itself: correctly reports merged.
+        closed, merged = _issue_liveness_from_cache(
+            board, "api", 42, "issue-42-review-fix-1"
+        )
+        assert merged is True
+
 
 class TestReassignCapabilityGate:
     """`_reassign` must apply the same #1711 structural