@misterhuydo/sentinel 1.5.63 → 1.6.1

package/python/tests/test_fix_engine_json.py

@@ -0,0 +1,95 @@
+"""
+test_fix_engine_json.py — Unit tests for _parse_claude_json().
+
+Parses the single-object JSON emitted by `claude --print --output-format json`.
+Critical: must extract session_id (for resume), cost (for budget tracking),
+and the result text (which contains the patch).
+"""
+import json
+import pytest
+
+from sentinel.fix_engine import _parse_claude_json
+
+
+def _wrap(result_text: str, session_id: str = "abc-123",
+          cost: float = 0.05, is_error: bool = False) -> str:
+    return json.dumps({
+        "type": "result",
+        "subtype": "success" if not is_error else "error",
+        "is_error": is_error,
+        "result": result_text,
+        "session_id": session_id,
+        "total_cost_usd": cost,
+        "duration_ms": 1234,
+        "stop_reason": "end_turn",
+    })
+
+
+# ── happy path ────────────────────────────────────────────────────────────────
+
+def test_extracts_result_session_cost():
+    raw = _wrap("Here is the patch:\n```diff\n...```", "sess-1", 0.07)
+    parsed = _parse_claude_json(raw)
+    assert parsed["session_id"] == "sess-1"
+    assert parsed["total_cost_usd"] == pytest.approx(0.07)
+    assert "patch" in parsed["result"]
+    assert parsed["is_error"] is False
+
+
+def test_handles_zero_cost():
+    raw = _wrap("ok", "sess", 0.0)
+    parsed = _parse_claude_json(raw)
+    assert parsed["total_cost_usd"] == 0.0
+
+
+def test_carries_is_error_flag():
+    raw = _wrap("err msg", "sess", 0.01, is_error=True)
+    parsed = _parse_claude_json(raw)
+    assert parsed["is_error"] is True
+
+
+# ── tolerant inputs ───────────────────────────────────────────────────────────
+
+def test_strips_leading_trailing_whitespace():
+    raw = "   \n" + _wrap("ok", "s", 0.0) + "\n  "
+    parsed = _parse_claude_json(raw)
+    assert parsed["session_id"] == "s"
+    assert parsed["result"] == "ok"
+
+
+def test_finds_json_after_stderr_garbage():
+    """Claude sometimes prints debug lines before the JSON object."""
+    raw = (
+        "Some stderr line\n"
+        "Another warning\n"
+        + _wrap("payload", "s", 0.0)
+    )
+    parsed = _parse_claude_json(raw)
+    assert parsed["session_id"] == "s"
+    assert parsed["result"] == "payload"
+
+
+def test_returns_empty_on_unparseable():
+    parsed = _parse_claude_json("not json at all")
+    assert parsed["session_id"] == ""
+    assert parsed["result"] == ""
+    assert parsed["total_cost_usd"] == 0.0
+    # When unparseable, surface as an error so caller doesn't silently swallow it
+    assert parsed["is_error"] is True
+
+
+def test_returns_empty_on_empty_string():
+    parsed = _parse_claude_json("")
+    assert parsed["session_id"] == ""
+    assert parsed["result"] == ""
+    assert parsed["is_error"] is True
+
+
+def test_handles_missing_fields_gracefully():
+    """If claude omits some fields, extract what's there and default the rest."""
+    raw = json.dumps({"type": "result", "result": "x", "session_id": "s"})
+    parsed = _parse_claude_json(raw)
+    assert parsed["session_id"] == "s"
+    assert parsed["result"] == "x"
+    assert parsed["total_cost_usd"] == 0.0
+    assert parsed["is_error"] is False

package/python/tests/test_fix_engine_prompt.py

@@ -0,0 +1,93 @@
+"""
+test_fix_engine_prompt.py — Spot-checks for the multi-repo prompt builder.
+
+The prompt is mostly free text — these tests assert *presence* of key
+instructions, not exact wording, so they tolerate cosmetic edits.
+"""
+from sentinel.fix_engine import _build_prompt
+from sentinel.config_loader import RepoConfig
+
+
+def _mk_event():
+    """Minimal ErrorEvent-like duck for the prompt builder."""
+    class E:
+        source = "MyService"
+        severity = "ERROR"
+        message = "NullPointerException in Foo.bar()"
+        body = ""
+        stack_trace = []
+        def full_text(self):
+            return f"{self.message}\n  at Foo.bar"
+    return E()
+
+
+def _mk_repo(name: str) -> RepoConfig:
+    return RepoConfig(
+        repo_name=name,
+        local_path=f"/proj/repos/{name}",
+        branch="main",
+    )
+
+
+def test_prompt_lists_all_repos_in_project():
+    repos = [_mk_repo("repo-a"), _mk_repo("repo-b"), _mk_repo("repo-c")]
+    prompt = _build_prompt(_mk_event(), repos[0], log_file=None,
+                           marker="sentinel-deadbeef",
+                           all_repos=repos, project_root="/proj")
+    assert "repo-a" in prompt
+    assert "repo-b" in prompt
+    assert "repo-c" in prompt
+
+
+def test_prompt_names_primary_repo_as_origin():
+    repos = [_mk_repo("primary"), _mk_repo("other")]
+    prompt = _build_prompt(_mk_event(), repos[0], log_file=None,
+                           marker="m", all_repos=repos, project_root="/p")
+    # Primary repo must be clearly identified as where the error originated
+    assert "primary" in prompt
+    # Sanity: project root is referenced, not the per-repo path
+    assert "/p" in prompt
+
+
+def test_prompt_explains_repos_prefix_path_format():
+    repos = [_mk_repo("r1")]
+    prompt = _build_prompt(_mk_event(), repos[0], log_file=None,
+                           marker="m", all_repos=repos, project_root="/p")
+    # Must instruct claude to use the repos/<name>/ path prefix
+    assert "repos/" in prompt
+    # And explain the multi-repo header
+    assert "Affected repos" in prompt
+
+
+def test_prompt_instructs_cairn_checkpoint_call():
+    repos = [_mk_repo("r1")]
+    prompt = _build_prompt(_mk_event(), repos[0], log_file=None,
+                           marker="m", all_repos=repos, project_root="/p")
+    assert "cairn_checkpoint" in prompt
+
+
+def test_prompt_keeps_marker_instruction():
+    """Sentinel marker injection is still required for verification flow."""
+    repos = [_mk_repo("r1")]
+    prompt = _build_prompt(_mk_event(), repos[0], log_file=None,
+                           marker="sentinel-abc12345",
+                           all_repos=repos, project_root="/p")
+    assert "sentinel-abc12345" in prompt
+
+
+def test_prompt_keeps_escalation_keywords():
+    """NEEDS_HUMAN / BOSS_ESCALATE keywords must remain — main.py keys off them."""
+    repos = [_mk_repo("r1")]
+    prompt = _build_prompt(_mk_event(), repos[0], log_file=None,
+                           marker="m", all_repos=repos, project_root="/p")
+    assert "NEEDS_HUMAN:" in prompt
+    assert "BOSS_ESCALATE:" in prompt
+
+
+def test_prompt_works_with_single_repo_project():
+    """Single-repo projects should still get a sensible prompt — no list weirdness."""
+    repo = _mk_repo("only-repo")
+    prompt = _build_prompt(_mk_event(), repo, log_file=None, marker="m",
+                           all_repos=[repo], project_root="/p")
+    assert "only-repo" in prompt
+    assert "repos/" in prompt  # prefix instruction still present

package/python/tests/test_multi_repo_apply.py

@@ -0,0 +1,254 @@
+"""
+test_multi_repo_apply.py — Tests for apply_and_commit_multi().
+
+The flow under test:
+  Phase 1 (atomic) — every affected repo's sub-patch is dry-run.
+                     If any fails, ALL are marked "aborted" with no mutations.
+  Phase 2 (per-repo)— apply + test + commit, serially. Per-repo failures
+                     don't abort the others (partial-success allowed at this point).
+
+Tests mock _git and _run_tests so they're fast and deterministic.
+"""
+from pathlib import Path
+from unittest.mock import patch, MagicMock
+from types import SimpleNamespace
+
+import pytest
+
+from sentinel import git_manager
+from sentinel.config_loader import RepoConfig
+
+
+def _mk_event(fingerprint="deadbeef00000001", source="src"):
+    e = SimpleNamespace()
+    e.fingerprint = fingerprint
+    e.source = source
+    e.message = "boom"
+    e.stack_trace = []
+    e.timestamp = "2026-04-24T10:00:00Z"
+    e.log_file = ""
+    e.short_summary = lambda: "boom in foo"
+    return e
+
+
+def _mk_repo(tmp_path: Path, name: str) -> RepoConfig:
+    p = tmp_path / "repos" / name
+    p.mkdir(parents=True, exist_ok=True)
+    return RepoConfig(repo_name=name, local_path=str(p), branch="main")
+
+
+def _mk_cfg(tmp_path: Path):
+    cfg = SimpleNamespace()
+    cfg.workspace_dir = str(tmp_path / "workspace")
+    Path(cfg.workspace_dir).mkdir(exist_ok=True)
+    cfg.project_name = "test-project"
+    cfg.github_token = ""
+    cfg.slack_bot_token = ""
+    cfg.slack_channel = ""
+    return cfg
+
+
+def _ok():
+    """Mock _git result indicating success."""
+    return SimpleNamespace(returncode=0, stdout="", stderr="")
+
+
+def _fail(err="bad"):
+    return SimpleNamespace(returncode=1, stdout="", stderr=err)
+
+
+def _git_dispatch(returns_per_cmd: dict):
+    """Build a fake _git that returns based on the command verb (args[0]).
+
+    `returns_per_cmd` maps verb → list of CompletedProcess results (one per call).
+    Falls back to _ok() if a verb isn't listed.
+    """
+    counters = {k: 0 for k in returns_per_cmd}
+    def fake_git(args, cwd, env=None, timeout=git_manager.GIT_TIMEOUT):
+        verb = args[0]
+        if verb in returns_per_cmd:
+            results = returns_per_cmd[verb]
+            i = counters[verb]
+            counters[verb] = min(i + 1, len(results) - 1) if results else 0
+            return results[i] if i < len(results) else results[-1]
+        if verb == "rev-parse":
+            return SimpleNamespace(returncode=0, stdout="abc1234567890def\n", stderr="")
+        return _ok()
+    return fake_git
+
+
+# ── helpers to build patches ──────────────────────────────────────────────────
+
+def _patch_one_repo(repo_name="r1") -> str:
+    return (
+        f"diff --git a/repos/{repo_name}/src/F.java b/repos/{repo_name}/src/F.java\n"
+        f"--- a/repos/{repo_name}/src/F.java\n"
+        f"+++ b/repos/{repo_name}/src/F.java\n"
+        f"@@ -1 +1 @@\n-old\n+new\n"
+    )
+
+
+def _patch_two_repos(lib="lib", consumer="consumer") -> str:
+    return (
+        f"# Affected repos: {lib}, {consumer}\n"
+        f"diff --git a/repos/{lib}/src/A.java b/repos/{lib}/src/A.java\n"
+        f"--- a/repos/{lib}/src/A.java\n+++ b/repos/{lib}/src/A.java\n"
+        f"@@ -1 +1 @@\n-a\n+b\n"
+        f"diff --git a/repos/{consumer}/pom.xml b/repos/{consumer}/pom.xml\n"
+        f"--- a/repos/{consumer}/pom.xml\n+++ b/repos/{consumer}/pom.xml\n"
+        f"@@ -1 +1 @@\n-1.0\n+1.1\n"
+    )
+
+
+# ── empty / unknown ───────────────────────────────────────────────────────────
+
+def test_empty_patch_returns_empty(tmp_path):
+    patch_file = tmp_path / "empty.diff"
+    patch_file.write_text("")
+    cfg = _mk_cfg(tmp_path)
+    repos = [_mk_repo(tmp_path, "r1")]
+    result = git_manager.apply_and_commit_multi(_mk_event(), patch_file, repos, cfg)
+    assert result == []
+
+
+def test_patch_with_unknown_repo_returns_empty(tmp_path):
+    patch_file = tmp_path / "x.diff"
+    patch_file.write_text(_patch_one_repo("ghost-repo"))
+    cfg = _mk_cfg(tmp_path)
+    repos = [_mk_repo(tmp_path, "real-repo")]
+    result = git_manager.apply_and_commit_multi(_mk_event(), patch_file, repos, cfg)
+    # ghost-repo is unknown → nothing applied
+    assert result == []
+
+
+# ── single-repo happy path ────────────────────────────────────────────────────
+
+def test_single_repo_happy_path(tmp_path):
+    patch_file = tmp_path / "s.diff"
+    patch_file.write_text(_patch_one_repo("r1"))
+    cfg = _mk_cfg(tmp_path)
+    repos = [_mk_repo(tmp_path, "r1")]
+
+    with patch.object(git_manager, "_git", side_effect=_git_dispatch({})), \
+         patch.object(git_manager, "_run_tests", return_value=True), \
+         patch.object(git_manager, "_check_protected_paths", return_value=False), \
+         patch.object(git_manager, "_append_changelog"):
+        result = git_manager.apply_and_commit_multi(_mk_event(), patch_file, repos, cfg)
+
+    assert len(result) == 1
+    r = result[0]
+    assert r["repo_name"] == "r1"
+    assert r["status"] == "committed"
+    assert r["commit_hash"].startswith("abc")
+    assert r["apply_order"] == 0
+
+
+# ── two-repo happy path with header order ─────────────────────────────────────
+
+def test_two_repos_happy_path_preserves_apply_order(tmp_path):
+    patch_file = tmp_path / "m.diff"
+    patch_file.write_text(_patch_two_repos("lib", "consumer"))
+    cfg = _mk_cfg(tmp_path)
+    repos = [_mk_repo(tmp_path, "lib"), _mk_repo(tmp_path, "consumer")]
+
+    with patch.object(git_manager, "_git", side_effect=_git_dispatch({})), \
+         patch.object(git_manager, "_run_tests", return_value=True), \
+         patch.object(git_manager, "_check_protected_paths", return_value=False), \
+         patch.object(git_manager, "_append_changelog"):
+        result = git_manager.apply_and_commit_multi(_mk_event(), patch_file, repos, cfg)
+
+    assert [r["repo_name"] for r in result] == ["lib", "consumer"]
+    assert [r["apply_order"] for r in result] == [0, 1]
+    assert all(r["status"] == "committed" for r in result)
+
+
+# ── atomic abort — one dry-run failure aborts ALL ─────────────────────────────
+
+def test_dry_run_failure_aborts_all_repos(tmp_path):
+    patch_file = tmp_path / "m.diff"
+    patch_file.write_text(_patch_two_repos("lib", "consumer"))
+    cfg = _mk_cfg(tmp_path)
+    repos = [_mk_repo(tmp_path, "lib"), _mk_repo(tmp_path, "consumer")]
+
+    # dry-run is `git apply --check ...`. We make the FIRST `apply --check` fail
+    # by making the apply verb fail on the second call (consumer's dry-run).
+    apply_results = [_ok(), _fail("conflict in consumer")]
+
+    with patch.object(git_manager, "_git",
+                      side_effect=_git_dispatch({"apply": apply_results})), \
+         patch.object(git_manager, "_run_tests", return_value=True), \
+         patch.object(git_manager, "_check_protected_paths", return_value=False), \
+         patch.object(git_manager, "_append_changelog"):
+        result = git_manager.apply_and_commit_multi(_mk_event(), patch_file, repos, cfg)
+
+    # Both repos must be marked aborted (atomic invariant)
+    assert len(result) == 2
+    assert all(r["status"] == "aborted" for r in result)
+    # No commits anywhere
+    assert all(r["commit_hash"] == "" for r in result)
+    # Reason should mention which repo's dry-run failed
+    assert any("consumer" in r["reason"] for r in result)
+
+
+def test_protected_paths_aborts_immediately(tmp_path):
+    patch_file = tmp_path / "x.diff"
+    patch_file.write_text(_patch_one_repo("r1"))
+    cfg = _mk_cfg(tmp_path)
+    repos = [_mk_repo(tmp_path, "r1")]
+
+    with patch.object(git_manager, "_git", side_effect=_git_dispatch({})), \
+         patch.object(git_manager, "_run_tests", return_value=True), \
+         patch.object(git_manager, "_check_protected_paths", return_value=True):
+        result = git_manager.apply_and_commit_multi(_mk_event(), patch_file, repos, cfg)
+
+    assert len(result) == 1
+    assert result[0]["status"] == "aborted"
+    assert "protected" in result[0]["reason"].lower()
+
+
+# ── per-repo failure in phase 2 ──────────────────────────────────────────────
+
+def test_phase2_test_failure_marks_only_that_repo(tmp_path):
+    """If tests fail for one repo in phase 2, the other repos still get committed."""
+    patch_file = tmp_path / "m.diff"
+    patch_file.write_text(_patch_two_repos("lib", "consumer"))
+    cfg = _mk_cfg(tmp_path)
+    repos = [_mk_repo(tmp_path, "lib"), _mk_repo(tmp_path, "consumer")]
+
+    # _run_tests returns True for lib, False for consumer
+    test_results = [True, False]
+    test_iter = iter(test_results)
+
+    with patch.object(git_manager, "_git", side_effect=_git_dispatch({})), \
+         patch.object(git_manager, "_run_tests", side_effect=lambda *a, **kw: next(test_iter)), \
+         patch.object(git_manager, "_check_protected_paths", return_value=False), \
+         patch.object(git_manager, "_append_changelog"):
+        result = git_manager.apply_and_commit_multi(_mk_event(), patch_file, repos, cfg)
+
+    by_name = {r["repo_name"]: r for r in result}
+    assert by_name["lib"]["status"] == "committed"
+    assert by_name["consumer"]["status"] == "failed"
+    assert "test" in by_name["consumer"]["reason"].lower()
+
+
+# ── sub-patch files written to disk ──────────────────────────────────────────
+
+def test_sub_patch_files_are_written(tmp_path):
+    """Each affected repo gets its own per-repo .diff file for traceability."""
+    patch_file = tmp_path / "m.diff"
+    patch_file.write_text(_patch_two_repos("lib", "consumer"))
+    cfg = _mk_cfg(tmp_path)
+    repos = [_mk_repo(tmp_path, "lib"), _mk_repo(tmp_path, "consumer")]
+
+    with patch.object(git_manager, "_git", side_effect=_git_dispatch({})), \
+         patch.object(git_manager, "_run_tests", return_value=True), \
+         patch.object(git_manager, "_check_protected_paths", return_value=False), \
+         patch.object(git_manager, "_append_changelog"):
+        result = git_manager.apply_and_commit_multi(_mk_event(), patch_file, repos, cfg)
+
+    for r in result:
+        sub_path = r["sub_patch_path"]
+        assert Path(sub_path).exists(), f"sub-patch missing for {r['repo_name']}"
+        contents = Path(sub_path).read_text()
+        # Path prefix was stripped — repos/<name>/ should NOT appear
+        assert f"repos/{r['repo_name']}" not in contents

package/python/tests/test_multi_repo_publish.py

@@ -0,0 +1,175 @@
+"""
+test_multi_repo_publish.py — Tests for publish_multi().
+
+publish_multi() takes the list of per-repo results from apply_and_commit_multi()
+and pushes / opens PRs per repo. PR bodies note the sibling repos in the same
+multi-repo fix, so reviewers can find them by branch name.
+
+Single-repo behavior must remain identical to today.
+"""
+from pathlib import Path
+from unittest.mock import patch
+from types import SimpleNamespace
+
+import pytest
+
+from sentinel import git_manager
+from sentinel.config_loader import RepoConfig
+
+
+def _mk_event(fp="deadbeef00000001"):
+    e = SimpleNamespace()
+    e.fingerprint = fp
+    e.source = "src"
+    e.message = "boom"
+    e.stack_trace = []
+    e.timestamp = "2026-04-24T10:00:00Z"
+    e.log_file = ""
+    e.short_summary = lambda: "boom in foo"
+    return e
+
+
+def _mk_repo(tmp_path: Path, name: str, auto_commit=False) -> RepoConfig:
+    p = tmp_path / "repos" / name
+    p.mkdir(parents=True, exist_ok=True)
+    return RepoConfig(
+        repo_name=name,
+        repo_url=f"git@github.com:org/{name}.git",
+        local_path=str(p),
+        branch="main",
+        auto_commit=auto_commit,
+    )
+
+
+def _mk_cfg():
+    cfg = SimpleNamespace()
+    cfg.project_name = "test-project"
+    cfg.github_token = "ghp_test"
+    cfg.slack_bot_token = ""
+    cfg.slack_channel = ""
+    cfg.auto_commit = False
+    cfg.auto_release = False
+    return cfg
+
+
+def _ok():
+    return SimpleNamespace(returncode=0, stdout="", stderr="")
+
+
+# ── single-repo PR mode (unchanged behaviour) ────────────────────────────────
+
+def test_single_committed_repo_opens_one_pr(tmp_path):
+    cfg = _mk_cfg()
+    repo = _mk_repo(tmp_path, "r1")
+    results = [{
+        "repo_name": "r1", "repo": repo, "status": "committed",
+        "commit_hash": "abc1234", "branch": "main", "apply_order": 0,
+        "reason": "", "sub_patch_path": tmp_path / "x.diff",
+    }]
+
+    pr_url = "https://github.com/org/r1/pull/42"
+    with patch.object(git_manager, "_git", return_value=_ok()), \
+         patch.object(git_manager, "_open_github_pr", return_value=pr_url) as open_pr, \
+         patch.object(git_manager, "remote_fix_exists", return_value=False):
+        out = git_manager.publish_multi(_mk_event(), results, cfg)
+
+    assert open_pr.call_count == 1
+    assert out[0]["pr_url"] == pr_url
+
+
+# ── multi-repo: each PR body lists sibling repos by name ──────────────────────
+
+def test_two_repos_each_pr_body_mentions_siblings(tmp_path):
+    cfg = _mk_cfg()
+    lib = _mk_repo(tmp_path, "lib")
+    consumer = _mk_repo(tmp_path, "consumer")
+    results = [
+        {"repo_name": "lib", "repo": lib, "status": "committed",
+         "commit_hash": "aaa1111", "branch": "main", "apply_order": 0,
+         "reason": "", "sub_patch_path": tmp_path / "lib.diff"},
+        {"repo_name": "consumer", "repo": consumer, "status": "committed",
+         "commit_hash": "bbb2222", "branch": "main", "apply_order": 1,
+         "reason": "", "sub_patch_path": tmp_path / "consumer.diff"},
+    ]
+
+    captured_extras: list[str] = []
+
+    def fake_open_pr(event, repo, cfg, branch, commit_hash, extra_body=""):
+        captured_extras.append(extra_body)
+        return f"https://github.com/org/{repo.repo_name}/pull/1"
+
+    with patch.object(git_manager, "_git", return_value=_ok()), \
+         patch.object(git_manager, "_open_github_pr", side_effect=fake_open_pr), \
+         patch.object(git_manager, "remote_fix_exists", return_value=False):
+        out = git_manager.publish_multi(_mk_event(), results, cfg)
+
+    assert len(captured_extras) == 2
+    # lib's PR body mentions consumer; consumer's PR body mentions lib
+    assert "consumer" in captured_extras[0]
+    assert "lib"      in captured_extras[1]
+    # Both PRs are recorded back into results
+    assert all(r["pr_url"] for r in out if r["status"] == "committed")
+
+
+# ── failed entries are not pushed ─────────────────────────────────────────────
+
+def test_failed_entries_are_skipped_for_publish(tmp_path):
+    cfg = _mk_cfg()
+    repo = _mk_repo(tmp_path, "r1")
+    results = [{
+        "repo_name": "r1", "repo": repo, "status": "failed",
+        "commit_hash": "", "branch": "", "apply_order": 0,
+        "reason": "tests failed", "sub_patch_path": tmp_path / "x.diff",
+    }]
+
+    with patch.object(git_manager, "_git", return_value=_ok()) as git_call, \
+         patch.object(git_manager, "_open_github_pr") as open_pr, \
+         patch.object(git_manager, "remote_fix_exists", return_value=False):
+        out = git_manager.publish_multi(_mk_event(), results, cfg)
+
+    open_pr.assert_not_called()
+    git_call.assert_not_called()
+    assert out[0]["status"] == "failed"
+
+
+# ── auto_commit mode pushes directly to main, no PR ──────────────────────────
+
+def test_auto_commit_mode_pushes_no_pr(tmp_path):
+    cfg = _mk_cfg()
+    cfg.auto_commit = True   # global default
+    repo = _mk_repo(tmp_path, "r1", auto_commit=True)
+    results = [{
+        "repo_name": "r1", "repo": repo, "status": "committed",
+        "commit_hash": "abc1234", "branch": "main", "apply_order": 0,
+        "reason": "", "sub_patch_path": tmp_path / "x.diff",
+    }]
+
+    with patch.object(git_manager, "_git", return_value=_ok()), \
+         patch.object(git_manager, "_open_github_pr") as open_pr:
+        out = git_manager.publish_multi(_mk_event(), results, cfg)
+
+    open_pr.assert_not_called()
+    assert out[0]["pr_url"] == ""
+    # branch stays as repo.branch (main)
+    assert out[0]["branch"] == "main"
+
+
+# ── duplicate PR detection ───────────────────────────────────────────────────
+
+def test_existing_remote_branch_skips_push(tmp_path):
+    cfg = _mk_cfg()
+    repo = _mk_repo(tmp_path, "r1")
+    results = [{
+        "repo_name": "r1", "repo": repo, "status": "committed",
+        "commit_hash": "abc1234", "branch": "main", "apply_order": 0,
+        "reason": "", "sub_patch_path": tmp_path / "x.diff",
+    }]
+
+    with patch.object(git_manager, "_git", return_value=_ok()), \
+         patch.object(git_manager, "_open_github_pr") as open_pr, \
+         patch.object(git_manager, "remote_fix_exists", return_value=True):
+        out = git_manager.publish_multi(_mk_event(), results, cfg)
+
+    # remote branch already exists → don't open a duplicate PR
+    open_pr.assert_not_called()
+    assert out[0].get("pr_url", "") == ""