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

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

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

@@ -510,6 +510,7 @@ tests/test_cli_issue_comment.py
 tests/test_cli_issue_create_label.py
 tests/test_cli_issue_reopen.py
 tests/test_cli_issue_view_list.py
+tests/test_cli_issues.py
 tests/test_cli_merge.py
 tests/test_cli_milestone_assign.py
 tests/test_cli_milestone_capture.py

{code_coordinator-0.5.512 → code_coordinator-0.5.514}/code_coordinator.egg-info/scm_file_list.json

@@ -536,6 +536,7 @@
     "tests/test_cli_issue_create_label.py",
     "tests/test_cli_issue_reopen.py",
     "tests/test_cli_issue_view_list.py",
+    "tests/test_cli_issues.py",
     "tests/test_cli_merge.py",
     "tests/test_cli_milestone_assign.py",
     "tests/test_cli_milestone_capture.py",

{code_coordinator-0.5.512 → code_coordinator-0.5.514}/code_coordinator.egg-info/scm_version.json

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

{code_coordinator-0.5.512 → 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.512 → code_coordinator-0.5.514}/coord/commands/issues.py

@@ -418,7 +418,13 @@ def issue_comment_cmd(
         "instead of a single freeform paragraph, so a later contract.md "
         "author (hand or agent) doesn't have to re-derive them from prose. "
         "All four are required together, and mutually exclusive with "
-        "--body/--body-file."
+        "--body/--body-file.\n\n"
+        "--milestone (number or title, resolved the same way as `coord "
+        "milestone assign`) attaches the new issue to a milestone in the "
+        "same step, routed through the same daemon seam "
+        "(`POST /issue-milestone`) so the local issues cache is updated "
+        "immediately. An unresolvable milestone is reported *before* the "
+        "issue is created (#3432)."
     ),
 )
 @click.argument("repo")
@@ -436,6 +442,16 @@ def issue_comment_cmd(
     multiple=True,
     help="Label to add (repeatable). The label must already exist in the repo.",
 )
+@click.option(
+    "--milestone",
+    default=None,
+    help=(
+        "Milestone number or title to attach the new issue to. Resolved "
+        "before the issue is created — an unresolvable milestone (bad "
+        "number, unmatched or ambiguous title) is an error and no issue is "
+        "created."
+    ),
+)
 @click.option(
     "--expected", default=None,
     help="Bug-lane intake field: what should happen, in observable terms.",
@@ -462,6 +478,7 @@ def issue_create_cmd(
     body: str | None,
     body_file: Path | None,
     labels: tuple[str, ...],
+    milestone: str | None,
     expected: str | None,
     actual: str | None,
     repro: str | None,
@@ -496,6 +513,26 @@ def issue_create_cmd(
     slug = _resolve_repo_slug(cfg, repo)
     if body_file is not None:
         body = sys.stdin.read() if str(body_file) == "-" else Path(body_file).read_text()
+
+    # Resolve --milestone *before* creating the issue (#3432) — creating the
+    # issue and then failing to attach it would silently reproduce the bug
+    # this closes (an issue that looks healthy but is unreachable from
+    # `coord.plans.aggregate_repo_plans`, which keys on milestone
+    # membership).
+    milestone_number: int | None = None
+    milestone_title: str | None = None
+    if milestone is not None:
+        from coord.commands.milestone import (  # noqa: PLC0415
+            MilestoneResolutionError,
+            resolve_milestone_ref,
+        )
+
+        try:
+            milestone_number, milestone_title = resolve_milestone_ref(slug, milestone)
+        except MilestoneResolutionError as e:
+            click.echo(f"error: {e}", err=True)
+            sys.exit(1)
+
     from coord.state import create_issue as _create_issue  # noqa: PLC0415
 
     try:
@@ -509,6 +546,31 @@ def issue_create_cmd(
         sys.exit(1)
     click.echo(f"#{result['number']} ({slug}) created")
 
+    if milestone_number is not None:
+        from coord.state import assign_issue_milestone  # noqa: PLC0415
+
+        try:
+            assign_issue_milestone(
+                repo,
+                result["number"],
+                milestone_number,
+                milestone_title=milestone_title,
+                repo_github=slug,
+            )
+        except Exception as e:  # noqa: BLE001
+            click.echo(
+                f"error: issue #{result['number']} created but milestone "
+                f"assign failed: {e}",
+                err=True,
+            )
+            sys.exit(1)
+        ms_label = (
+            f"{milestone_title!r} (#{milestone_number})"
+            if milestone_title
+            else f"#{milestone_number}"
+        )
+        click.echo(f"#{result['number']} ({slug}) assigned to milestone {ms_label}")
+
 
 @issue_group.command(
     "label",

{code_coordinator-0.5.512 → code_coordinator-0.5.514}/coord/commands/milestone.py

@@ -165,6 +165,52 @@ def milestone_edit_cmd(
     click.echo(f"milestone #{number} updated ({repo_entry.github})")
 
 
+class MilestoneResolutionError(Exception):
+    """Raised by :func:`resolve_milestone_ref` when MILESTONE can't be
+    resolved to a number."""
+
+
+def resolve_milestone_ref(repo_github: str, milestone: str) -> tuple[int, str | None]:
+    """Resolve a milestone CLI argument (number or title) to ``(number,
+    title)`` against ``repo_github``'s open milestones.
+
+    Shared by `coord milestone assign` and `coord issue create --milestone`
+    (#3432) so there is exactly one place milestone-reference resolution
+    happens — raises :class:`MilestoneResolutionError` (never exits) on any
+    failure: an unfetchable numeric milestone, an unmatched title, or an
+    ambiguous title. Callers decide how to report/exit.
+    """
+    from coord import github_ops  # noqa: PLC0415
+
+    try:
+        milestone_number = int(milestone)
+    except ValueError:
+        try:
+            all_ms = github_ops.get_repo_milestones(repo_github)
+        except RuntimeError as e:
+            raise MilestoneResolutionError(f"could not list milestones: {e}") from e
+        matches = [m for m in all_ms if m.get("title") == milestone]
+        if not matches:
+            raise MilestoneResolutionError(
+                f"no open milestone with title {milestone!r} in {repo_github}"
+            )
+        if len(matches) > 1:
+            raise MilestoneResolutionError(
+                f"multiple open milestones match {milestone!r} — use the "
+                "milestone number instead"
+            )
+        return matches[0]["number"], matches[0].get("title")
+
+    # Resolve the title from the number so the cache can store it.
+    try:
+        ms_data = github_ops.get_milestone(repo_github, milestone_number)
+    except RuntimeError as e:
+        raise MilestoneResolutionError(
+            f"could not fetch milestone #{milestone_number}: {e}"
+        ) from e
+    return milestone_number, ms_data.get("title")
+
+
 @milestone_group.command(
     "assign",
     help=(
@@ -194,47 +240,15 @@ def milestone_assign_cmd(
         click.echo(f"error: unknown repo {repo!r}", err=True)
         sys.exit(2)
 
-    from coord import github_ops  # noqa: PLC0415
     from coord.state import assign_issue_milestone  # noqa: PLC0415
 
-    # Resolve milestone argument: numeric → number, string → title lookup.
-    milestone_number: int
-    milestone_title: str | None
-
     try:
-        milestone_number = int(milestone)
-        # Resolve the title from the number so the cache can store it.
-        try:
-            ms_data = github_ops.get_milestone(repo_entry.github, milestone_number)
-            milestone_title = ms_data.get("title")
-        except RuntimeError as e:
-            click.echo(
-                f"error: could not fetch milestone #{milestone_number}: {e}", err=True
-            )
-            sys.exit(1)
-    except ValueError:
-        # Treat the argument as a title and resolve to a number.
-        try:
-            all_ms = github_ops.get_repo_milestones(repo_entry.github)
-        except RuntimeError as e:
-            click.echo(f"error: could not list milestones: {e}", err=True)
-            sys.exit(1)
-        matches = [m for m in all_ms if m.get("title") == milestone]
-        if not matches:
-            click.echo(
-                f"error: no open milestone with title {milestone!r} in {repo_entry.github}",
-                err=True,
-            )
-            sys.exit(1)
-        if len(matches) > 1:
-            click.echo(
-                f"error: multiple open milestones match {milestone!r} — "
-                "use the milestone number instead",
-                err=True,
-            )
-            sys.exit(1)
-        milestone_number = matches[0]["number"]
-        milestone_title = matches[0].get("title")
+        milestone_number, milestone_title = resolve_milestone_ref(
+            repo_entry.github, milestone
+        )
+    except MilestoneResolutionError as e:
+        click.echo(f"error: {e}", err=True)
+        sys.exit(1)
 
     try:
         assign_issue_milestone(

{code_coordinator-0.5.512 → 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.512 → 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.512 → 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.512 → 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.512 → 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.512 → 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 ─────────────