pycastle 0.1.3.9.dev0__tar.gz → 0.1.3.10.dev0__tar.gz

{pycastle-0.1.3.9.dev0 → pycastle-0.1.3.10.dev0}/CONTEXT.md

@@ -73,6 +73,12 @@
 | **clean merge** | A `git merge --no-edit` that exits zero and requires no conflict resolution | conflict-free merge, successful merge |
 | **conflicting branch** | A branch whose `git merge --no-edit` exits non-zero; `git merge --abort` is run immediately and the branch is collected for the Merger | failed merge branch |
 | **RALPH** | The required commit message prefix for all Implementer commits (e.g. `RALPH: fix auth bug`) | — |
+| **RALPH: Review -** | The required commit message prefix for all Reviewer commits (e.g. `RALPH: Review - improve error handling`); distinguished from Implementer commits by the `Review -` infix; each agent produces exactly one commit per branch | — |
+| **in-flight issue** | An open issue that has an existing `pycastle/issue-<n>` branch or worktree from a previous interrupted iteration; signals that implement or review work is already partially or fully complete | mid-flight issue, resumed issue |
+| **merge-time preflight skip** | The behavior when the Merger's Pre-flight phase returns failures: `merge_phase` logs a diagnostic, skips the Merger, and returns normally with conflict issues still pending; the next iteration's pre-planning preflight detects the broken baseline and recovers via the preflight-fix path | merge preflight abort |
+| **planning skip** | The behavior in `run_iteration` when at least one open issue is in-flight: the Planner is not invoked and only the in-flight issues are used as the working set for the current iteration; issues with neither a branch nor a worktree are deferred | plan bypass |
+| **implement skip** | The behavior in `run_issue` when a branch already has a `RALPH:` (non-review) commit: the Implementer is not spawned and the Reviewer runs directly via the existing-branch path | — |
+| **review skip** | The behavior in `run_issue` when a branch already has a `RALPH: Review -` commit: both the Implementer and Reviewer are skipped and the issue is counted as completed immediately | — |
 | **plan** | The structured JSON output by the Planner listing which issues to work on and the branch name for each; after parsing, `plan_phase()` sorts issues by ascending issue number so the orchestrator always processes older issues first | plan output, plan JSON |
 | **issue** | A GitHub issue labeled for agent processing, representing one unit of work | ticket, task, card |
 | **AFK issue** | An issue the Planner assigns to an Implementer because it can be resolved autonomously; labeled `ready-for-agent` | agent issue, auto issue |
@@ -216,6 +222,8 @@
 - The **HITL verdict** is read by the orchestrator from the GitHub issue label after the **preflight-issue agent** completes; `ready-for-agent` triggers the **preflight-fix path**, `ready-for-human` aborts with a non-zero exit code.
 - On the **preflight-fix path**, the Planner is skipped; one Implementer is spawned for the preflight issue, followed by one Reviewer, then a merge; a new iteration then begins.
 - The **Planner** and all **Implementer** worktrees are created from the pinned **safe SHA**, never from HEAD directly; this guarantees every agent sees the same verified-clean committed state regardless of external commits that land on main after preflight passes.
+- The **planning skip** is checked before every Planner invocation; it takes priority over normal planning when any open issue is **in-flight**. The **implement skip** and **review skip** are checked inside `run_issue` before any worktree is created; they are mutually exclusive with normal agent spawning for that phase. Both skips are triggered by commit prefix detection (`RALPH: Review -` → review skip; `RALPH:` without `Review -` → implement skip only).
+- A **merge-time preflight skip** leaves conflict issues open; they become **in-flight issues** on the next iteration, triggering the **planning skip** and then the **implement skip** or **review skip** as appropriate once the baseline is fixed.
 - In **sequential mode** (`max_parallel = 1`), the iteration processes issues one by one: after each issue's merge the safe SHA is re-pinned to the new HEAD, and the next Implementer starts from that SHA; a failed issue is skipped (remains `ready-for-agent`) and the queue continues; the Merger remains available as a fallback for unexpected conflicts; no additional pre-flight checks run between issues.
 - The **Pre-flight phase** (agent lifecycle) runs quality checks inside the container and returns a list of failure tuples to the orchestrator; it never spawns agents internally.
 - An **orphan sweep** runs once at orchestrator startup; **collision detection** uses a per-branch `asyncio.Lock` held in `implement_phase` for the full duration of each `run_issue` call — from first worktree creation to final worktree teardown.

{pycastle-0.1.3.9.dev0 → pycastle-0.1.3.10.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pycastle
-Version: 0.1.3.9.dev0
+Version: 0.1.3.10.dev0
 Summary: Python orchestrator for autonomous Claude Code agents in Docker
 License: MIT License
         

{pycastle-0.1.3.9.dev0 → pycastle-0.1.3.10.dev0}/src/pycastle/defaults/prompts/implement-prompt.md

@@ -1,15 +1,5 @@
 # Workflow
 
-### 0. Prior Run Detection
-
-Before starting, check whether prior RALPH work exists on this branch.
-
-Run `git log main..HEAD --oneline`. If any commits are present, prior RALPH work is already done — emit `<promise>COMPLETE</promise>` and stop.
-
-Otherwise, run `git status`. If the working tree is dirty, review the existing uncommitted changes and continue from the current state rather than starting over.
-
-If both checks show a clean, empty branch, fall through to step 1 and proceed normally.
-
 ### 1. Task
 
 Fix issue #{{ISSUE_NUMBER}}: {{ISSUE_TITLE}}

{pycastle-0.1.3.9.dev0 → pycastle-0.1.3.10.dev0}/src/pycastle/iteration/__init__.py

@@ -2,6 +2,7 @@ import dataclasses
 from typing import TypeAlias
 
 from ..agent_result import CancellationToken, PreflightFailure
+from ..worktree import worktree_name_for_branch, worktree_path
 from ._deps import Deps
 from .implement import branch_for, implement_phase
 from .merge import merge_phase
@@ -32,6 +33,14 @@ class AbortedUsageLimit:
 IterationOutcome: TypeAlias = Continue | Done | AbortedHITL | AbortedUsageLimit
 
 
+def _is_in_flight(issue: dict, deps: Deps) -> bool:
+    branch = branch_for(issue["number"])
+    if deps.git_svc.verify_ref_exists(branch, deps.repo_root):
+        return True
+    name = worktree_name_for_branch(branch)
+    return worktree_path(name, deps).exists()
+
+
 async def run_iteration(deps: Deps) -> IterationOutcome:
     deps.status_display.register("Preflight")
     try:
@@ -51,7 +60,10 @@ async def run_iteration(deps: Deps) -> IterationOutcome:
             return Done()
         sha = preflight_result.sha
         open_issues = preflight_result.issues
-        if len(open_issues) >= 2:
+        in_flight = [i for i in open_issues if _is_in_flight(i, deps)]
+        if in_flight:
+            issues = in_flight
+        elif len(open_issues) >= 2:
             deps.status_display.register("Plan")
             try:
                 plan_result = await planning_phase(deps, sha, open_issues)

{pycastle-0.1.3.9.dev0 → pycastle-0.1.3.10.dev0}/src/pycastle/iteration/implement.py

@@ -98,26 +98,34 @@ async def run_issue(
         await lock.acquire()
 
     try:
-        async with _agent_worktree(_branch, sha, _token, deps) as impl_mount_path:
-            result = await _bounded_run_agent(
-                RunRequest(
-                    name=f"Implement Agent #{issue['number']}",
-                    prompt_file=deps.cfg.prompts_dir / "implement-prompt.md",
-                    mount_path=impl_mount_path,
-                    role=AgentRole.IMPLEMENTER,
-                    prompt_args=prompt_args,
-                    model=deps.cfg.implement_override.model,
-                    effort=deps.cfg.implement_override.effort,
-                    stage="pre-implementation",
-                    skip_preflight=True,
-                    status_display=deps.status_display,
-                    issue_title=issue["title"],
-                    work_body=f'implementing "{issue["title"]}"',
-                    token=_token,
+        subjects = deps.git_svc.get_branch_commit_subjects(_branch, deps.repo_root)
+        review_done = any(s.startswith("RALPH: Review -") for s in subjects)
+        implement_done = any(s.startswith("RALPH:") for s in subjects)
+
+        if review_done:
+            return issue
+
+        if not implement_done:
+            async with _agent_worktree(_branch, sha, _token, deps) as impl_mount_path:
+                result = await _bounded_run_agent(
+                    RunRequest(
+                        name=f"Implement Agent #{issue['number']}",
+                        prompt_file=deps.cfg.prompts_dir / "implement-prompt.md",
+                        mount_path=impl_mount_path,
+                        role=AgentRole.IMPLEMENTER,
+                        prompt_args=prompt_args,
+                        model=deps.cfg.implement_override.model,
+                        effort=deps.cfg.implement_override.effort,
+                        stage="pre-implementation",
+                        skip_preflight=True,
+                        status_display=deps.status_display,
+                        issue_title=issue["title"],
+                        work_body=f'implementing "{issue["title"]}"',
+                        token=_token,
+                    )
                 )
-            )
-            if isinstance(result, PreflightFailure):
-                return result
+                if isinstance(result, PreflightFailure):
+                    return result
 
         async with _agent_worktree(_branch, None, _token, deps) as review_mount_path:
             await _bounded_run_agent(

{pycastle-0.1.3.9.dev0 → pycastle-0.1.3.10.dev0}/src/pycastle/iteration/merge.py

@@ -90,9 +90,12 @@ async def merge_phase(completed: list[dict], deps: Deps) -> MergeResult:
                     )
                 )
                 if isinstance(merger_result, PreflightFailure):
-                    raise RuntimeError(
-                        "Merger preflight checks failed; merge did not complete"
+                    deps.status_display.print(
+                        "",
+                        "Merge-time preflight failed; skipping conflict branch merge. "
+                        "Conflict issues remain open for recovery in the next iteration.",
                     )
+                    return MergeResult(clean=clean_issues, conflicts=conflict_issues)
                 deps.git_svc.fast_forward_branch(
                     deps.repo_root, target_branch, MERGE_SANDBOX
                 )

{pycastle-0.1.3.9.dev0 → pycastle-0.1.3.10.dev0}/src/pycastle/services/git_service.py

@@ -202,6 +202,17 @@ class GitService(_SubprocessService):
             cwd=repo_path,
         )
 
+    def get_branch_commit_subjects(self, branch: str, repo_path: Path) -> list[str]:
+        result = self._run(
+            ["git", "log", f"main..{branch}", "--format=%s"],
+            cwd=repo_path,
+            capture_output=True,
+        )
+        if result.returncode != 0:
+            return []
+        output = self._decode(result.stdout)
+        return [line for line in output.splitlines() if line]
+
     def remove_worktree(self, repo_path: Path, worktree_path: Path) -> None:
         result = self._run(
             ["git", "worktree", "remove", "--force", str(worktree_path)],

{pycastle-0.1.3.9.dev0 → pycastle-0.1.3.10.dev0}/src/pycastle.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pycastle
-Version: 0.1.3.9.dev0
+Version: 0.1.3.10.dev0
 Summary: Python orchestrator for autonomous Claude Code agents in Docker
 License: MIT License
         

{pycastle-0.1.3.9.dev0 → pycastle-0.1.3.10.dev0}/tests/test_git_service.py

@@ -98,6 +98,53 @@ def test_get_user_name_strips_trailing_newline():
         assert svc.get_user_name() == "Bob"
 
 
+# ── get_branch_commit_subjects() ──────────────────────────────────────────────
+
+
+def test_get_branch_commit_subjects_returns_subjects_most_recent_first():
+    svc = GitService(_cfg)
+    with patch(
+        "subprocess.run",
+        return_value=MagicMock(
+            returncode=0,
+            stdout=b"RALPH: Review - fix auth\nRALPH: implement auth\n",
+            stderr=b"",
+        ),
+    ):
+        result = svc.get_branch_commit_subjects("pycastle/issue-1", Path("/repo"))
+    assert result == ["RALPH: Review - fix auth", "RALPH: implement auth"]
+
+
+def test_get_branch_commit_subjects_returns_empty_list_when_no_commits_ahead():
+    svc = GitService(_cfg)
+    with patch(
+        "subprocess.run",
+        return_value=MagicMock(returncode=0, stdout=b"", stderr=b""),
+    ):
+        result = svc.get_branch_commit_subjects("pycastle/issue-1", Path("/repo"))
+    assert result == []
+
+
+def test_get_branch_commit_subjects_returns_empty_list_when_branch_missing():
+    svc = GitService(_cfg)
+    with patch(
+        "subprocess.run",
+        return_value=MagicMock(returncode=128, stdout=b"", stderr=b"unknown revision"),
+    ):
+        result = svc.get_branch_commit_subjects("pycastle/issue-99", Path("/repo"))
+    assert result == []
+
+
+def test_get_branch_commit_subjects_raises_git_timeout_error_on_timeout():
+    svc = GitService(_cfg)
+    with patch(
+        "subprocess.run",
+        side_effect=subprocess.TimeoutExpired(cmd="git", timeout=30),
+    ):
+        with pytest.raises(GitTimeoutError):
+            svc.get_branch_commit_subjects("pycastle/issue-1", Path("/repo"))
+
+
 # ── get_user_email() ───────────────────────────────────────────────────────────
 
 

{pycastle-0.1.3.9.dev0 → pycastle-0.1.3.10.dev0}/tests/test_implement.py

@@ -667,6 +667,95 @@ def test_run_issue_does_not_create_reviewer_worktree_on_preflight_failure(tmp_pa
     assert deps.git_svc.create_worktree.call_count == 1
 
 
+# ── run_issue: RALPH commit prefix skip logic ────────────────────────────────
+
+
+def test_run_issue_review_skip_returns_issue_without_invoking_any_agent(tmp_path):
+    """When branch has a RALPH: Review - commit, run_issue returns the issue without spawning agents."""
+    fake = FakeAgentRunner([])
+    deps = _make_deps(tmp_path, fake)
+    deps.git_svc.get_branch_commit_subjects.return_value = ["RALPH: Review - fix auth"]
+
+    issue = {"number": 20, "title": "Fix auth"}
+    result = asyncio.run(run_issue(issue, deps))
+
+    assert result == issue
+    assert fake.calls == []
+
+
+def test_run_issue_review_skip_creates_no_worktree(tmp_path):
+    """When branch has a RALPH: Review - commit, no worktree is created."""
+    fake = FakeAgentRunner([])
+    deps = _make_deps(tmp_path, fake)
+    deps.git_svc.get_branch_commit_subjects.return_value = ["RALPH: Review - fix auth"]
+
+    issue = {"number": 21, "title": "Fix auth"}
+    asyncio.run(run_issue(issue, deps))
+
+    deps.git_svc.create_worktree.assert_not_called()
+
+
+def test_run_issue_implement_skip_invokes_only_reviewer(tmp_path):
+    """When branch has a RALPH: (non-review) commit, run_issue skips Implementer and runs only Reviewer."""
+    fake = FakeAgentRunner([CompletionOutput()])
+    deps = _make_deps(tmp_path, fake)
+    deps.git_svc.get_branch_commit_subjects.return_value = ["RALPH: Fix auth"]
+
+    issue = {"number": 22, "title": "Fix auth"}
+    result = asyncio.run(run_issue(issue, deps))
+
+    assert result == issue
+    assert len(fake.calls) == 1
+    assert "Review Agent" in fake.calls[0].name
+
+
+def test_run_issue_implement_skip_creates_no_implementer_worktree(tmp_path):
+    """When branch has a RALPH: (non-review) commit, no Implementer worktree is created."""
+    fake = FakeAgentRunner([CompletionOutput()])
+    deps = _make_deps(tmp_path, fake)
+    deps.git_svc.get_branch_commit_subjects.return_value = ["RALPH: Fix auth"]
+    deps.git_svc.is_working_tree_clean.return_value = True
+
+    issue = {"number": 23, "title": "Fix auth"}
+    asyncio.run(run_issue(issue, deps))
+
+    assert deps.git_svc.create_worktree.call_count == 1
+    branch_arg = deps.git_svc.create_worktree.call_args[0][2]
+    assert branch_arg == "pycastle/issue-23"
+
+
+def test_run_issue_no_ralph_commit_runs_both_agents(tmp_path):
+    """When branch has no RALPH: commit, run_issue runs both Implementer and Reviewer normally."""
+    fake = FakeAgentRunner([CompletionOutput()] * 2)
+    deps = _make_deps(tmp_path, fake)
+    deps.git_svc.get_branch_commit_subjects.return_value = []
+
+    issue = {"number": 24, "title": "Fix auth"}
+    result = asyncio.run(run_issue(issue, deps))
+
+    assert result == issue
+    assert len(fake.calls) == 2
+    assert "Implement Agent" in fake.calls[0].name
+    assert "Review Agent" in fake.calls[1].name
+
+
+def test_run_issue_releases_lock_when_get_branch_commit_subjects_raises(tmp_path):
+    """If get_branch_commit_subjects raises, run_issue must still release the branch lock."""
+    from pycastle.services import GitTimeoutError
+
+    fake = FakeAgentRunner([])
+    deps = _make_deps(tmp_path, fake)
+    deps.git_svc.get_branch_commit_subjects.side_effect = GitTimeoutError("timed out")
+
+    branch_locks: dict[str, asyncio.Lock] = {}
+    issue = {"number": 25, "title": "Fix auth"}
+
+    with pytest.raises(GitTimeoutError):
+        asyncio.run(run_issue(issue, deps, branch_locks=branch_locks))
+
+    assert not branch_locks["pycastle/issue-25"].locked()
+
+
 def test_run_issue_reviewer_worktree_uses_no_sha(tmp_path):
     """run_issue must create the Reviewer worktree without a pinned SHA (existing-branch path)."""
     fake = FakeAgentRunner([CompletionOutput()] * 2)

{pycastle-0.1.3.9.dev0 → pycastle-0.1.3.10.dev0}/tests/test_iteration.py

@@ -44,6 +44,7 @@ def git_svc():
     svc.is_working_tree_clean.return_value = True
     svc.try_merge.return_value = True
     svc.is_ancestor.return_value = True
+    svc.verify_ref_exists.return_value = False
     return svc
 
 
@@ -731,3 +732,165 @@ def test_run_iteration_registers_preflight_row_before_preflight_phase(
     assert register_idx is not None, "Preflight row must be registered"
     assert remove_idx is not None, "Preflight row must be removed"
     assert register_idx < remove_idx
+
+
+# ── Planning skip when in-flight branches or worktrees exist ─────────────────
+
+
+def test_run_iteration_skips_planning_when_all_issues_have_existing_branches(
+    tmp_path, git_svc, logger
+):
+    """When all open issues have an existing branch, planning_phase is not invoked
+    and the iteration proceeds with those issues as the working set."""
+    github_svc = MagicMock(spec=GithubService)
+    github_svc.get_open_issues.return_value = [
+        {"number": 1, "title": "Fix A"},
+        {"number": 2, "title": "Fix B"},
+    ]
+    git_svc.verify_ref_exists.return_value = True
+
+    agent_names: list[str] = []
+
+    async def _fake_agent(request: RunRequest):
+        agent_names.append(request.name)
+        return CompletionOutput()
+
+    deps = _make_deps(
+        tmp_path, _fake_agent, git_svc=git_svc, github_svc=github_svc, logger=logger
+    )
+    result = asyncio.run(run_iteration(deps))
+
+    assert isinstance(result, Continue)
+    assert "Plan Agent" not in agent_names, (
+        "Plan Agent must not be called when all branches exist"
+    )
+    assert any("Implement Agent" in n for n in agent_names), (
+        "Implement Agent must still run"
+    )
+
+
+def test_run_iteration_skips_planning_when_all_issues_have_existing_worktrees(
+    tmp_path, git_svc, logger
+):
+    """When all open issues have an existing worktree directory (but no branch),
+    planning_phase is not invoked."""
+    github_svc = MagicMock(spec=GithubService)
+    github_svc.get_open_issues.return_value = [
+        {"number": 3, "title": "Fix C"},
+        {"number": 4, "title": "Fix D"},
+    ]
+    git_svc.verify_ref_exists.return_value = False
+    for n in [3, 4]:
+        (tmp_path / "pycastle" / ".worktrees" / f"issue-{n}").mkdir(parents=True)
+
+    agent_names: list[str] = []
+
+    async def _fake_agent(request: RunRequest):
+        agent_names.append(request.name)
+        return CompletionOutput()
+
+    deps = _make_deps(
+        tmp_path, _fake_agent, git_svc=git_svc, github_svc=github_svc, logger=logger
+    )
+    result = asyncio.run(run_iteration(deps))
+
+    assert isinstance(result, Continue)
+    assert "Plan Agent" not in agent_names, (
+        "Plan Agent must not be called when all worktrees exist"
+    )
+
+
+def test_run_iteration_uses_only_in_flight_issues_when_some_have_existing_branch(
+    tmp_path, git_svc, logger
+):
+    """When only some open issues have an existing branch, only those in-flight issues
+    are used as the working set and planning_phase is not invoked."""
+    github_svc = MagicMock(spec=GithubService)
+    github_svc.get_open_issues.return_value = [
+        {"number": 5, "title": "In flight"},
+        {"number": 6, "title": "Deferred"},
+    ]
+    git_svc.verify_ref_exists.side_effect = lambda ref, path: ref == "pycastle/issue-5"
+
+    agent_names: list[str] = []
+
+    async def _fake_agent(request: RunRequest):
+        agent_names.append(request.name)
+        return CompletionOutput()
+
+    deps = _make_deps(
+        tmp_path, _fake_agent, git_svc=git_svc, github_svc=github_svc, logger=logger
+    )
+    result = asyncio.run(run_iteration(deps))
+
+    assert isinstance(result, Continue)
+    assert "Plan Agent" not in agent_names, (
+        "Plan Agent must not be called when some branches exist"
+    )
+    assert "Implement Agent #5" in agent_names, "In-flight issue must be implemented"
+    assert not any("Implement Agent #6" in n for n in agent_names), (
+        "Deferred issue must not be implemented"
+    )
+
+
+def test_run_iteration_uses_preflight_sha_for_in_flight_issues(
+    tmp_path, git_svc, logger
+):
+    """When in-flight issues are used, the implement phase receives the preflight SHA
+    unchanged — the in-flight path must not re-pin the SHA from a plan-sandbox."""
+    github_svc = MagicMock(spec=GithubService)
+    github_svc.get_open_issues.return_value = [{"number": 7, "title": "In flight"}]
+    git_svc.verify_ref_exists.return_value = True
+    git_svc.get_head_sha.return_value = "preflight-sha-abc"
+
+    async def _fake_agent(request: RunRequest):
+        return CompletionOutput()
+
+    deps = _make_deps(
+        tmp_path, _fake_agent, git_svc=git_svc, github_svc=github_svc, logger=logger
+    )
+    asyncio.run(run_iteration(deps))
+
+    implement_shas = {
+        c.args[3]
+        for c in git_svc.create_worktree.call_args_list
+        if c.args[3] is not None
+    }
+    assert "preflight-sha-abc" in implement_shas, (
+        "Implement phase must use the preflight SHA, not a re-pinned SHA"
+    )
+
+
+def test_run_iteration_detects_in_flight_via_both_branch_and_worktree_signals(
+    tmp_path, git_svc, logger
+):
+    """Both detection signals (branch and worktree) are checked independently:
+    an issue with only a branch, an issue with only a worktree directory, and
+    an issue with neither are handled correctly in a single iteration."""
+    github_svc = MagicMock(spec=GithubService)
+    github_svc.get_open_issues.return_value = [
+        {"number": 8, "title": "Branch only"},
+        {"number": 9, "title": "Worktree only"},
+        {"number": 10, "title": "Deferred"},
+    ]
+    git_svc.verify_ref_exists.side_effect = lambda ref, path: ref == "pycastle/issue-8"
+    (tmp_path / "pycastle" / ".worktrees" / "issue-9").mkdir(parents=True)
+
+    agent_names: list[str] = []
+
+    async def _fake_agent(request: RunRequest):
+        agent_names.append(request.name)
+        return CompletionOutput()
+
+    deps = _make_deps(
+        tmp_path, _fake_agent, git_svc=git_svc, github_svc=github_svc, logger=logger
+    )
+    result = asyncio.run(run_iteration(deps))
+
+    assert isinstance(result, Continue)
+    assert "Plan Agent" not in agent_names
+    assert "Implement Agent #8" in agent_names, "Branch-only in-flight issue must run"
+    assert "Implement Agent #9" in agent_names, "Worktree-only in-flight issue must run"
+    assert not any("Implement Agent #10" in n for n in agent_names), (
+        "Deferred issue must not run"
+    )

{pycastle-0.1.3.9.dev0 → pycastle-0.1.3.10.dev0}/tests/test_merge.py

@@ -16,7 +16,7 @@ from pycastle.iteration._deps import (
     RecordingStatusDisplay,
 )
 from pycastle.status_display import PlainStatusDisplay
-from pycastle.iteration.merge import merge_phase
+from pycastle.iteration.merge import MergeResult, merge_phase
 
 
 @pytest.fixture
@@ -247,40 +247,103 @@ def test_incomplete_merger_raises_and_does_not_fast_forward(
     git_svc.fast_forward_branch.assert_not_called()
 
 
-def test_preflight_failure_from_merger_raises_and_does_not_fast_forward(
+# ── Graceful merge-time preflight skip ───────────────────────────────────────
+
+
+def _preflight_failure_deps(tmp_path, git_svc, github_svc):
+    from pycastle.agent_result import PreflightFailure
+
+    failure = PreflightFailure(failures=(("ruff", "ruff check .", "E501"),))
+    git_svc.try_merge.return_value = False
+    return _make_deps(tmp_path, git_svc, github_svc, FakeAgentRunner([failure]))
+
+
+def test_preflight_failure_returns_merge_result_without_raising(
+    tmp_path, git_svc, github_svc
+):
+    local_deps = _preflight_failure_deps(tmp_path, git_svc, github_svc)
+    issues = [{"number": 1, "title": "Conflict"}]
+    result = _run(issues, local_deps)
+    assert isinstance(result, MergeResult)
+
+
+def test_preflight_failure_result_separates_clean_and_conflict_issues(
     tmp_path, git_svc, github_svc
 ):
     from pycastle.agent_result import PreflightFailure
 
-    git_svc.try_merge.return_value = False
     failure = PreflightFailure(failures=(("ruff", "ruff check .", "E501"),))
-    fake = FakeAgentRunner([failure])
-    local_deps = _make_deps(tmp_path, git_svc, github_svc, fake)
+    git_svc.try_merge.side_effect = _conflict_on([2])
+    local_deps = _make_deps(tmp_path, git_svc, github_svc, FakeAgentRunner([failure]))
+    issues = [{"number": 1, "title": "Clean"}, {"number": 2, "title": "Conflict"}]
+    result = _run(issues, local_deps)
+    assert result.clean == [{"number": 1, "title": "Clean"}]
+    assert result.conflicts == [{"number": 2, "title": "Conflict"}]
+
+
+def test_preflight_failure_does_not_close_conflict_issue(tmp_path, git_svc, github_svc):
+    local_deps = _preflight_failure_deps(tmp_path, git_svc, github_svc)
+    issues = [{"number": 5, "title": "Conflict"}]
+    _run(issues, local_deps)
+    closed = [call.args[0] for call in local_deps.github_svc.close_issue.call_args_list]
+    assert 5 not in closed
+
+
+def test_preflight_failure_does_not_delete_conflict_branch(
+    tmp_path, git_svc, github_svc
+):
+    local_deps = _preflight_failure_deps(tmp_path, git_svc, github_svc)
+    issues = [{"number": 5, "title": "Conflict"}]
+    _run(issues, local_deps)
+    deleted = [call.args[0] for call in local_deps.git_svc.delete_branch.call_args_list]
+    assert "pycastle/issue-5" not in deleted
+
+
+def test_preflight_failure_does_not_fast_forward(tmp_path, git_svc, github_svc):
+    local_deps = _preflight_failure_deps(tmp_path, git_svc, github_svc)
     issues = [{"number": 1, "title": "Conflict"}]
-    with pytest.raises(RuntimeError, match="preflight"):
-        _run(issues, local_deps)
-    git_svc.fast_forward_branch.assert_not_called()
+    _run(issues, local_deps)
+    local_deps.git_svc.fast_forward_branch.assert_not_called()
 
 
-def test_preflight_failure_from_merger_still_removes_worktree(
+def test_preflight_failure_prints_skip_message(tmp_path, git_svc, github_svc):
+    recording = RecordingStatusDisplay()
+    local_deps = dataclasses.replace(
+        _preflight_failure_deps(tmp_path, git_svc, github_svc),
+        status_display=recording,
+    )
+    issues = [{"number": 1, "title": "Conflict"}]
+    _run(issues, local_deps)
+    print_messages = [c[2] for c in recording.calls if c[0] == "print"]
+    assert any("preflight" in msg.lower() for msg in print_messages)
+
+
+def test_preflight_failure_closes_parent_issues_for_clean_issues(
     tmp_path, git_svc, github_svc
 ):
     from pycastle.agent_result import PreflightFailure
 
-    git_svc.try_merge.return_value = False
-    failure = PreflightFailure(failures=(("mypy", "mypy .", "error"),))
-    fake = FakeAgentRunner([failure])
-    local_deps = _make_deps(tmp_path, git_svc, github_svc, fake)
+    failure = PreflightFailure(failures=(("ruff", "ruff check .", "E501"),))
+    git_svc.try_merge.side_effect = _conflict_on([2])
+    local_deps = _make_deps(tmp_path, git_svc, github_svc, FakeAgentRunner([failure]))
+    issues = [{"number": 1, "title": "Clean"}, {"number": 2, "title": "Conflict"}]
+    _run(issues, local_deps)
+    local_deps.github_svc.close_completed_parent_issues.assert_called_once()
+
+
+def test_preflight_failure_worktree_still_removed(tmp_path, git_svc, github_svc):
+    local_deps = _preflight_failure_deps(tmp_path, git_svc, github_svc)
     issues = [{"number": 1, "title": "Conflict"}]
-    with pytest.raises(RuntimeError):
-        _run(issues, local_deps)
+    _run(issues, local_deps)
     expected_path = (
         local_deps.repo_root
         / local_deps.cfg.pycastle_dir
         / ".worktrees"
         / "merge-sandbox"
     )
-    git_svc.remove_worktree.assert_called_once_with(local_deps.repo_root, expected_path)
+    local_deps.git_svc.remove_worktree.assert_called_once_with(
+        local_deps.repo_root, expected_path
+    )
 
 
 # ── Exception safety ──────────────────────────────────────────────────────────
@@ -632,8 +695,7 @@ def test_merge_row_not_removed_with_failed_style_after_row_already_removed(
     )
     git_svc.try_merge.return_value = False
 
-    with pytest.raises(RuntimeError, match="preflight"):
-        asyncio.run(merge_phase([{"number": 1, "title": "Conflict"}], deps))
+    asyncio.run(merge_phase([{"number": 1, "title": "Conflict"}], deps))
 
     assert ("remove", "Merge", "failed", "error") not in recording.calls
 

{pycastle-0.1.3.9.dev0 → pycastle-0.1.3.10.dev0}/tests/test_orchestrator.py

@@ -58,7 +58,14 @@ def _make_git_svc(try_merge_side_effect=None, is_ancestor=True):
         wt.mkdir(parents=True, exist_ok=True)
         (wt / "pyproject.toml").write_text("[project]\nname='t'\n")
 
+    def _fake_remove_worktree(repo, wt):
+        import shutil
+
+        if isinstance(wt, Path) and wt.exists():
+            shutil.rmtree(wt)
+
     mock_svc.create_worktree.side_effect = _fake_create_worktree
+    mock_svc.remove_worktree.side_effect = _fake_remove_worktree
     return mock_svc