orbi-cli 0.7.8__tar.gz → 0.7.9__tar.gz

{orbi_cli-0.7.8 → orbi_cli-0.7.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: orbi-cli
-Version: 0.7.8
+Version: 0.7.9
 Summary: Orbi — local AI development worker: claims GitHub Issues, runs Pi in isolated worktrees, and delivers PRs (GitHub Issues + labels are the only state store).
 Author: xqliu
 License-Expression: AGPL-3.0-only OR LicenseRef-Sustainable-Use-1.0

{orbi_cli-0.7.8 → orbi_cli-0.7.9}/pyproject.toml

@@ -44,7 +44,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "orbi-cli"
-version = "0.7.8"
+version = "0.7.9"
 description = "Orbi — local AI development worker: claims GitHub Issues, runs Pi in isolated worktrees, and delivers PRs (GitHub Issues + labels are the only state store)."
 readme = "README.md"
 requires-python = ">=3.14"

{orbi_cli-0.7.8 → orbi_cli-0.7.9}/src/orbi/__init__.py

@@ -18,4 +18,4 @@ the package would shadow the installed package for every process with
 the checkout root on sys.path. The direct-execution compatibility entry
 is `python3 -m orbi.cli` (development path only).
 """
-__version__ = "0.7.8"
+__version__ = "0.7.9"

{orbi_cli-0.7.8 → orbi_cli-0.7.9}/src/orbi/journal.py

@@ -364,9 +364,11 @@ JOURNAL_EVENTS: dict[str, str] = {
     "merge_gate_issue_blocked": "the source Issue is ai-blocked; the merge was skipped (Issue #1504)",
     "merge_gate_rulesets_unavailable": "the rulesets API is unavailable on the repository plan (Issue #1361)",
     "merged": "the PR merge landed on the reviewed head",
+    "merge_landed_after_error": "the merge call failed but the reviewed head landed on the base branch (Issue #1798)",
     "merge_method_unknown": "the repository merge settings could not be read; --merge is used",
     "confirm_merged_missing_on_base": "the merged commit is missing from the base branch",
-    "confirm_merged_not_merged": "the PR reports merged but GitHub contradicts the state",
+    "confirm_merged_not_merged": "the PR is not merged and its reviewed head is not on the base branch",
+    "confirm_merged_landed_on_base": "the reviewed head landed on the base branch while the PR still reads unmerged (Issue #1798)",
     # Human review gate.
     "human_review_waiting": "the delivery waits for the human review label",
     "human_review_checklist_failed": "publishing the human review checklist failed (bypass)",

{orbi_cli-0.7.8 → orbi_cli-0.7.9}/src/orbi/review_merge.py

@@ -673,20 +673,32 @@ def merge_gate(worktree: Path, pr: dict, base_branch: str,
             "--match-head-commit", pr["head_oid"], merge_method,
         ], cwd=worktree)
     except subprocess.CalledProcessError as exc:
-        preflight = github.merge_gate_preflight(
-            merge_repo, base_branch,
-        )
-        stderr = str(exc.stderr or "")
-        if is_maintainer_actionable(stderr, preflight):
-            failed_preflight = [
-                line for line in preflight
-                if line.startswith("merge_gate: FAILED")
-            ]
-            raise MergeHandoffRequired(
-                f"PR #{pr['number']} is ready for the named maintainer action",
-                preflight=failed_preflight,
-            ) from None
-        raise
+        # Issue #1798: GitHub can create the merge commit and this call still
+        # fail (`502 Bad Gateway`), leaving the PR OPEN with `mergedAt: null`.
+        # `confirm_merged` decides: landed continues like a success (never a
+        # second merge call), "not landed" keeps today's path.
+        try:
+            confirm_merged(worktree, pr, base_branch, repo_dir=repo_dir)
+            landed = True
+        except RuntimeError:
+            landed = False
+        if not landed:
+            preflight = github.merge_gate_preflight(merge_repo, base_branch)
+            stderr = str(exc.stderr or "")
+            if is_maintainer_actionable(stderr, preflight):
+                failed_preflight = [
+                    line for line in preflight
+                    if line.startswith("merge_gate: FAILED")
+                ]
+                raise MergeHandoffRequired(
+                    f"PR #{pr['number']} is ready for the named maintainer "
+                    "action",
+                    preflight=failed_preflight,
+                ) from None
+            raise
+        event("merge_landed_after_error", level=logging.WARNING,
+              pr=pr["number"], head=pr["head_oid"], method=merge_method,
+              returncode=exc.returncode, stderr=str(exc.stderr or "").strip())
     event("merged", pr=pr["number"], head=pr["head_oid"],
           method=merge_method)
     delete_merged_delivery_branch(merge_repo, pr["number"], pr["head_ref"])
@@ -695,27 +707,37 @@ def merge_gate(worktree: Path, pr: dict, base_branch: str,
 
 def confirm_merged(worktree: Path, pr: dict, base_branch: str,
                    *, repo_dir: Path) -> dict:
-    """Confirm the PR is MERGED and origin/<base> contains the merge commit.
+    """Confirm the reviewed PR's merge landed on origin/<base>.
+
+    A MERGED PR answers with its merge commit, which must be on the base
+    branch. Issue #1798: the merge can also land while the merge call
+    itself errors, leaving the PR OPEN/CLOSED with `mergedAt: null` — the
+    reviewed head being on origin/<base> after the fresh fetch is that
+    merge. Anything else is a rejection; a failed read propagates.
 
-    The base fetch updates the shared remote-tracking ref, so it runs
-    under the base-sync lock with the deployment checkout
-    as the lock location.
+    The base fetch updates the shared remote-tracking ref, so it runs under
+    the base-sync lock with the deployment checkout as the lock location.
     """
     state = pr_view(pr["number"], "state,mergedAt,mergeCommit", cwd=worktree)
-    if state.get("state") != "MERGED" or not state.get("mergedAt"):
-        event(
-            "confirm_merged_not_merged", level=logging.ERROR,
-            pr=pr["number"], state=state.get("state"),
-        )
-        raise RuntimeError(
-            f"PR #{pr['number']} is not merged (state={state.get('state')})"
-        )
+    merged = state.get("state") == "MERGED" and bool(state.get("mergedAt"))
     merge_commit = (state.get("mergeCommit") or {}).get("oid")
-    if not merge_commit:
+    if merged and not merge_commit:
         raise RuntimeError(
             f"PR #{pr['number']} is merged but has no merge commit oid"
         )
     fetch_base_ref(repo_dir, base_branch, cwd=worktree)
+    if not merged:
+        # Issue #1798: it can have landed while the merge call errored.
+        merge_commit = run_state.landed_merge_commit(
+            pr["head_oid"], f"origin/{base_branch}", cwd=worktree)
+        if merge_commit is None:
+            event("confirm_merged_not_merged", level=logging.ERROR,
+                  pr=pr["number"], state=state.get("state"))
+            raise RuntimeError(f"PR #{pr['number']} is not merged "
+                               f"(state={state.get('state')})")
+        event("confirm_merged_landed_on_base", pr=pr["number"],
+              head=pr["head_oid"], merge_commit=merge_commit)
+        return {"state": "MERGED", "merge_commit": merge_commit}
     if not _is_ancestor(merge_commit, f"origin/{base_branch}", cwd=worktree):
         event(
             "confirm_merged_missing_on_base", level=logging.ERROR,

{orbi_cli-0.7.8 → orbi_cli-0.7.9}/src/orbi/run_state.py

@@ -58,6 +58,25 @@ def assess_base_freshness(worktree: Path, base_branch: str, *,
     return BaseFreshness.ABSORBABLE
 
 
+def landed_merge_commit(head: str, base_ref: str, *,
+                        cwd: Path) -> str | None:
+    """The commit that landed *head* on *base_ref*, or None (Issue #1798).
+
+    GitHub can create the merge commit while the merge call itself fails
+    (`502 Bad Gateway`), so the PR state alone cannot show that merge: the
+    head being reachable from the base branch is it. `--topo-order
+    --reverse` lists parents before children on that ancestry path, so the
+    first commit is the one that landed the head.
+    """
+    if not _is_ancestor(head, base_ref, cwd=cwd):
+        return None
+    commits = run_command([
+        "git", "rev-list", "--ancestry-path", "--topo-order", "--reverse",
+        f"{head}..{base_ref}",
+    ], cwd=cwd).split()
+    return commits[0] if commits else None
+
+
 def delivery_commit_guard(worktree: Path, *, local_head: str,
                           base_sha: str, branch: str) -> None:
     """Fail the delivery when the task branch carries no real change.

{orbi_cli-0.7.8 → orbi_cli-0.7.9}/src/orbi_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: orbi-cli
-Version: 0.7.8
+Version: 0.7.9
 Summary: Orbi — local AI development worker: claims GitHub Issues, runs Pi in isolated worktrees, and delivers PRs (GitHub Issues + labels are the only state store).
 Author: xqliu
 License-Expression: AGPL-3.0-only OR LicenseRef-Sustainable-Use-1.0

{orbi_cli-0.7.8 → orbi_cli-0.7.9}/tests/test_git_merge_smoke.py

@@ -307,3 +307,141 @@ def test_sync_base_checkout_fails_fast_on_drifted_checkout(
 
     with pytest.raises(RuntimeError, match="cannot fast-forward"):
         review_merge.sync_base_checkout(checkout, "main")
+
+
+# ---------------------------------------------------------------------------
+# Issue #1798: a merge that landed despite an error from the merge call
+# ---------------------------------------------------------------------------
+
+def install_failing_merge_gh(monkeypatch, clone: Path, head_oid: str, *,
+                             landed: bool = True, pr_after=None) -> list:
+    """Run real git; `gh pr merge` lands a real merge and THEN fails.
+
+    This is the Issue #1798 scene (orbi-build/orbi-cloud PR #2652): GitHub
+    creates the merge commit on the base branch and the merge call itself
+    returns `502 Bad Gateway`. `landed=False` models the same error with
+    nothing on the base branch. `pr_after` answers `gh pr view` once the
+    merge call has failed; before it the reviewed head reads OPEN and
+    mergeable.
+    """
+    real_run = runner.run_command
+    calls: list = []
+    failed = False
+
+    def fake_run(command, **kwargs):
+        nonlocal failed
+        if command[0] == "gh" and command[1:3] == ["pr", "view"]:
+            calls.append(command)
+            if failed and pr_after is not None:
+                return pr_after()
+            return make_pr(head_oid)
+        if command[0] == "gh" and command[1] == "pr" and "merge" in command:
+            calls.append(command)
+            if landed:
+                git(clone, "checkout", "main")
+                git(clone, "merge", "--no-ff", command[command.index(
+                    "--match-head-commit") + 1])
+                git(clone, "push", "origin", "main")
+                git(clone, "checkout", "-")
+            failed = True
+            raise subprocess.CalledProcessError(
+                1, command, stderr="HTTP 502: Bad Gateway",
+            )
+        if command[0] == "gh":
+            calls.append(command)
+            return ""
+        return real_run(command, **kwargs)
+
+    monkeypatch.setattr(seam, "run_command", fake_run)
+    return calls
+
+
+def _delivery_pr(clone: Path, head_oid: str) -> dict:
+    return {"number": 4, "url": "u", "base_ref": "main",
+            "base_oid": git(clone, "rev-parse", "origin/main"),
+            "head_ref": "orbi/owner-repo-issue-4", "head_oid": head_oid}
+
+
+def test_merge_gate_accepts_a_merge_that_landed_despite_a_502(
+        clone, monkeypatch, caplog):
+    """Issue #1798 acceptance 1: `gh pr merge` fails 5xx and the PR then
+    reads MERGED with its merge commit on origin/<base> — the delivery
+    continues like a successful merge instead of a fix-needed round."""
+    git(clone, "checkout", "-b", "orbi/owner-repo-issue-4")
+    head_oid = commit_file(clone, "delivery.txt", "delivery")
+    calls = install_failing_merge_gh(
+        monkeypatch, clone, head_oid,
+        pr_after=lambda: make_pr(
+            head_oid, state="MERGED", merged_at="2026-10-19T13:38:31Z",
+            merge_commit=git(clone, "rev-parse", "origin/main"),
+        ),
+    )
+    with caplog.at_level("WARNING"):
+        merged = review_merge.merge_gate(
+            clone, _delivery_pr(clone, head_oid), "main",
+            repo_dir=clone, language_code="en",
+        )
+    assert merged["merged"] is True
+    assert "merge_landed_after_error" in caplog.text
+    # Still exactly one merge call: the error is confirmed, never retried.
+    assert len([c for c in calls
+                if c[0] == "gh" and c[1] == "pr" and "merge" in c]) == 1
+    merge_commit = git(clone, "rev-parse", "origin/main")
+    confirmed = review_merge.confirm_merged(clone, merged, "main",
+                                            repo_dir=clone)
+    assert confirmed == {"state": "MERGED", "merge_commit": merge_commit}
+
+
+def test_merge_gate_accepts_a_landed_head_while_the_pr_reads_open(
+        clone, monkeypatch, caplog):
+    """Issue #1798 acceptance 2 (PR #2652's shape): GitHub created the merge
+    commit on the base branch and never marked the PR merged, so re-reading
+    the PR state cannot recognise the merge. The reviewed head being
+    reachable from origin/<base> does, and the landed merge commit is the
+    one the delivery records."""
+    git(clone, "checkout", "-b", "orbi/owner-repo-issue-4")
+    head_oid = commit_file(clone, "delivery.txt", "delivery")
+    calls = install_failing_merge_gh(monkeypatch, clone, head_oid)
+    with caplog.at_level("INFO"):
+        merged = review_merge.merge_gate(
+            clone, _delivery_pr(clone, head_oid), "main",
+            repo_dir=clone, language_code="en",
+        )
+    assert merged["merged"] is True
+    assert len([c for c in calls
+                if c[0] == "gh" and c[1] == "pr" and "merge" in c]) == 1
+    merge_commit = git(clone, "rev-parse", "origin/main")
+    # The commit that landed the reviewed head is a real merge commit whose
+    # second parent is that head.
+    assert git(clone, "rev-parse", f"{merge_commit}^2") == head_oid
+    with caplog.at_level("INFO"):
+        confirmed = review_merge.confirm_merged(clone, merged, "main",
+                                                repo_dir=clone)
+    assert confirmed == {"state": "MERGED", "merge_commit": merge_commit}
+    assert "confirm_merged_landed_on_base" in caplog.text
+
+
+def test_merge_gate_still_fails_when_the_merge_did_not_land(
+        clone, monkeypatch):
+    """Issue #1798 acceptance 3: the same 5xx with the reviewed head NOT on
+    origin/<base> keeps today's outcome — the error surfaces."""
+    git(clone, "checkout", "-b", "orbi/owner-repo-issue-4")
+    head_oid = commit_file(clone, "delivery.txt", "delivery")
+    pr = _delivery_pr(clone, head_oid)
+    calls = install_failing_merge_gh(monkeypatch, clone, head_oid,
+                                     landed=False)
+    monkeypatch.setattr(
+        seam, "merge_gate_preflight",
+        lambda *args: ["merge_gate: PASS protection readable"],
+    )
+    with pytest.raises(subprocess.CalledProcessError) as raised:
+        review_merge.merge_gate(
+            clone, pr, "main", repo_dir=clone, language_code="en",
+        )
+    assert raised.value.returncode == 1
+    assert "502" in (raised.value.stderr or "")
+    assert len([c for c in calls
+                if c[0] == "gh" and c[1] == "pr" and "merge" in c]) == 1
+    # Nothing landed: the base branch is untouched.
+    assert git(clone, "rev-parse", "origin/main") == pr["base_oid"]
+

{orbi_cli-0.7.8 → orbi_cli-0.7.9}/tests/test_review_merge.py

@@ -1676,6 +1676,13 @@ def test_merge_gate_hands_off_each_actionable_policy_rejection(
             raise subprocess.CalledProcessError(
                 1, command, stderr="the base branch policy prohibits the merge",
             )
+        if command[0] == "git" and command[1] == "merge-base":
+            # The head contains the base, but the base does NOT contain
+            # the reviewed head: this merge did not land (Issue #1798 asks
+            # the ancestry question before treating the error as final).
+            if command[3] == "origin/main":
+                return ""
+            raise subprocess.CalledProcessError(1, command, stderr="no")
         return ""
     monkeypatch.setattr(seam, "run_command", fake_run)
     monkeypatch.setattr(runner.github, "merge_gate_preflight", lambda *a: [
@@ -1697,15 +1704,25 @@ def test_merge_gate_hands_off_each_actionable_policy_rejection(
 ])
 def test_merge_gate_does_not_hand_off_without_failed_preflight(
         monkeypatch, tmp_path, preflight):
-    monkeypatch.setattr(seam, "run_command", lambda command, **kwargs: (
-        (_ for _ in ()).throw(subprocess.CalledProcessError(
-            1, command, stderr="the base branch policy prohibits the merge",
-        )) if command[0] == "gh" and command[1] == "pr" and "merge" in command else (
-            json.dumps({"state": "OPEN", "mergeable": "MERGEABLE",
-                        "headRefOid": "h1", "statusCheckRollup": []})
-            if command[0] == "gh" and command[1] == "pr" and "view" in command else ""
-        )
-    ))
+    def fake_run(command, **kwargs):
+        if command[0] == "gh" and command[1] == "pr" and "merge" in command:
+            raise subprocess.CalledProcessError(
+                1, command, stderr="the base branch policy prohibits the merge",
+            )
+        if command[0] == "gh" and command[1] == "pr" and "view" in command:
+            return json.dumps({
+                "state": "OPEN", "mergeable": "MERGEABLE", "headRefOid": "h1",
+                "statusCheckRollup": [],
+            })
+        if command[0] == "git" and command[1] == "merge-base":
+            # The head contains the base, but the base does NOT contain the
+            # reviewed head: the failed merge did not land (Issue #1798).
+            if command[3] == "origin/main":
+                return ""
+            raise subprocess.CalledProcessError(1, command, stderr="no")
+        return ""
+
+    monkeypatch.setattr(seam, "run_command", fake_run)
     monkeypatch.setattr(
         runner.github, "merge_gate_preflight", lambda *a: preflight,
     )
@@ -2009,12 +2026,21 @@ def test_confirm_merged_fetches_under_the_base_sync_lock(
 
 
 def test_confirm_merged_rejects_unmerged_pr(monkeypatch, tmp_path):
-    monkeypatch.setattr(seam, "run_command",
-        lambda command, **kwargs: json.dumps({
-            "number": 4, "url": "u", "state": "OPEN",
-            "mergedAt": None, "mergeCommit": None,
-        }),
-    )
+    """Issue #1798: an unmerged PR whose reviewed head is NOT on
+    origin/<base> is still a failed confirm — the head's ancestry is the
+    fact that decides it, so this fixture answers it (the reviewed head is
+    not reachable from origin/main)."""
+    def fake_run(command, **kwargs):
+        if command[0] == "gh" and command[1] == "pr" and "view" in command:
+            return json.dumps({
+                "number": 4, "url": "u", "state": "OPEN",
+                "mergedAt": None, "mergeCommit": None,
+            })
+        if command[0] == "git" and command[1] == "merge-base":
+            raise subprocess.CalledProcessError(1, command, stderr="not ancestor")
+        return ""
+
+    monkeypatch.setattr(seam, "run_command", fake_run)
     with pytest.raises(RuntimeError, match="not merged"):
         review_merge.confirm_merged(
             tmp_path, {"number": 4, "url": "u", "base_ref": "main",
@@ -2023,6 +2049,68 @@ def test_confirm_merged_rejects_unmerged_pr(monkeypatch, tmp_path):
         )
 
 
+def test_confirm_merged_accepts_a_reviewed_head_that_landed_on_base(
+        monkeypatch, tmp_path, caplog):
+    """Issue #1798: GitHub creates the merge commit and the merge call
+    still fails, so the PR reads OPEN with `mergedAt: null` and no merge
+    commit. The reviewed head being reachable from origin/<base> is that
+    landed merge; the commit that landed it is the answer.
+
+    `--topo-order --reverse` lists parents before children on the
+    ancestry path, so the first commit is the one that landed the head —
+    verified against a real repository in test_git_merge_smoke.py."""
+    commands = []
+
+    def fake_run(command, **kwargs):
+        commands.append(command)
+        if command[0] == "gh" and command[1] == "pr" and "view" in command:
+            return json.dumps({
+                "number": 4, "url": "u", "state": "OPEN",
+                "mergedAt": None, "mergeCommit": None,
+            })
+        if command[0] == "git" and command[1] == "rev-list":
+            return "m1\nlater\n"
+        return ""
+
+    monkeypatch.setattr(seam, "run_command", fake_run)
+    with caplog.at_level("INFO"):
+        result = review_merge.confirm_merged(
+            tmp_path, {"number": 4, "head_oid": "h1"}, "main",
+            repo_dir=tmp_path,
+        )
+    assert result == {"state": "MERGED", "merge_commit": "m1"}
+    rev_list = [c for c in commands if c[1:2] == ["rev-list"]][0]
+    assert rev_list[2:] == [
+        "--ancestry-path", "--topo-order", "--reverse", "h1..origin/main",
+    ]
+    assert "confirm_merged_landed_on_base" in caplog.text
+
+
+def test_confirm_merged_needs_a_landing_commit_for_an_open_pr(
+        monkeypatch, tmp_path, caplog):
+    """Issue #1798: a head that is an ancestor of origin/<base> with no
+    commit between them names no merge commit, so the confirm stays a
+    rejection instead of inventing one."""
+    def fake_run(command, **kwargs):
+        if command[0] == "gh" and command[1] == "pr" and "view" in command:
+            return json.dumps({
+                "number": 4, "url": "u", "state": "OPEN",
+                "mergedAt": None, "mergeCommit": None,
+            })
+        return ""
+
+    monkeypatch.setattr(seam, "run_command", fake_run)
+    with caplog.at_level("ERROR"), pytest.raises(
+        RuntimeError, match="not merged",
+    ):
+        review_merge.confirm_merged(
+            tmp_path, {"number": 4, "head_oid": "h1"}, "main",
+            repo_dir=tmp_path,
+        )
+    assert "confirm_merged_not_merged" in caplog.text
+    assert "confirm_merged_landed_on_base" not in caplog.text
+
+
 def test_confirm_merged_rejects_merge_commit_missing_from_origin_main(
         monkeypatch, tmp_path, caplog):
     def fake_run(command, **kwargs):