steerdev 1.1.43__tar.gz → 1.1.44__tar.gz

{steerdev-1.1.43 → steerdev-1.1.44}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: steerdev
-Version: 1.1.43
+Version: 1.1.44
 Summary: Backend task runner for steerdev.com - orchestrates CLI coding agents with activity reporting
 Project-URL: Homepage, https://github.com/pentoai/steerdev-agent
 Project-URL: Repository, https://github.com/pentoai/steerdev-agent

{steerdev-1.1.43 → steerdev-1.1.44}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "steerdev"
-version = "1.1.43"
+version = "1.1.44"
 description = "Backend task runner for steerdev.com - orchestrates CLI coding agents with activity reporting"
 readme = "README.md"
 authors = [

{steerdev-1.1.43 → steerdev-1.1.44}/src/steerdev_agent/cli.py

@@ -1365,7 +1365,11 @@ def git_pr(
         steerdev git pr --title "Add auth" --body "Implements JWT auth"
         steerdev git pr --title "Add auth" --task-id abc123...
     """
-    import subprocess
+    from steerdev_agent.git.pr import (
+        STEERDEV_SIGNATURE,
+        create_pr,
+        resolve_task_base_branch,
+    )
 
     # Build PR body
     pr_body = body or ""
@@ -1374,49 +1378,23 @@ def git_pr(
         pr_body += task_ref
 
     # Add steerdev signature
-    pr_body += "\n\n---\nCreated with [steerdev](https://steerdev.com)"
+    pr_body += STEERDEV_SIGNATURE
 
     # Prefer the persisted base branch so the PR targets the correct base.
-    from steerdev_agent.api.tasks import TasksClient
+    base_branch = resolve_task_base_branch(task_id)
 
-    base_branch: str | None = None
-    if task_id:
-        try:
-            with TasksClient() as pr_client:
-                if pr_client.check_api_key():
-                    task = pr_client.get_task(task_id)
-                    if task:
-                        base_branch = task.get("base_branch")
-        except Exception:  # fall back to gh default base
-            base_branch = None
-
-    try:
-        # Build the gh pr create command
-        cmd = ["gh", "pr", "create", "--title", title, "--body", pr_body]
-        if base_branch:
-            cmd += ["--base", base_branch]
-        if draft:
-            cmd.append("--draft")
-
-        result = subprocess.run(cmd, capture_output=True, text=True)
-
-        if result.returncode != 0:
-            console.print(f"[red]Error creating PR: {result.stderr}[/red]")
-            raise typer.Exit(1)
+    result = create_pr(title, pr_body, base_branch=base_branch, draft=draft)
+    if not result.created:
+        console.print(f"[red]Error creating PR: {result.error}[/red]")
+        raise typer.Exit(1)
 
-        # Extract PR URL from output
-        pr_url = result.stdout.strip()
-        console.print(
-            Panel(
-                f"[bold green]Pull request created[/bold green]\n\nTitle: {title}\nURL: {pr_url}",
-                title="Success",
-                border_style="green",
-            )
+    console.print(
+        Panel(
+            f"[bold green]Pull request created[/bold green]\n\nTitle: {title}\nURL: {result.url}",
+            title="Success",
+            border_style="green",
         )
-
-    except FileNotFoundError:
-        console.print("[red]Error: gh not found. Install GitHub CLI: https://cli.github.com[/red]")
-        raise typer.Exit(1) from None
+    )
 
 
 @git_app.command("status")

steerdev-1.1.44/src/steerdev_agent/git/pr.py

@@ -0,0 +1,192 @@
+"""Pull-request helpers shared by the CLI and the runner's wave PR safety net.
+
+The wave-tasks-merge skill instructs the agent to open a PR at wave end, but
+nothing guarantees the agent does. `ensure_wave_pr` is the deterministic
+fallback: at wave completion the runner checks whether a PR already exists for
+the wave branch and creates one if not.
+
+All functions are best-effort and never raise — a PR failure must never break
+the run. Synchronous, mirroring `git_ops` (these run once at wave end, outside
+the hot path).
+"""
+
+from __future__ import annotations
+
+import json
+import shutil
+import subprocess
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any
+
+from loguru import logger
+
+from steerdev_agent.git_ops import current_branch
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+    from steerdev_agent.prompt.builder import WaveContext
+
+_GH_TIMEOUT = 60  # seconds; gh talks to the GitHub API
+
+STEERDEV_SIGNATURE = "\n\n---\nCreated with [steerdev](https://steerdev.com)"
+
+
+@dataclass
+class PrResult:
+    """Outcome of a `gh pr create` invocation."""
+
+    created: bool
+    url: str | None = None
+    error: str | None = None
+
+
+def _run_gh(cwd: str | Path | None, *args: str) -> tuple[int, str, str]:
+    """Run gh, returning (returncode, stdout, stderr). Raises only on missing gh/timeout."""
+    proc = subprocess.run(
+        ["gh", *args],
+        cwd=str(cwd) if cwd else None,
+        capture_output=True,
+        text=True,
+        timeout=_GH_TIMEOUT,
+    )
+    return proc.returncode, (proc.stdout or "").strip(), (proc.stderr or "").strip()
+
+
+def find_existing_pr(cwd: str | Path | None, branch: str) -> str:
+    """Check whether a PR (any state) already exists for *branch*.
+
+    Returns one of:
+        "exists", "none", "unknown" (gh missing or the lookup failed).
+    """
+    try:
+        if shutil.which("gh") is None:
+            logger.warning("find_existing_pr: gh not found")
+            return "unknown"
+        rc, out, err = _run_gh(
+            cwd, "pr", "list", "--head", branch, "--state", "all", "--json", "number,state"
+        )
+        if rc != 0:
+            logger.warning(f"find_existing_pr: gh pr list failed (non-fatal): {err}")
+            return "unknown"
+        return "exists" if json.loads(out or "[]") else "none"
+    except Exception as exc:  # broad catch intentional: durability must never break the run
+        logger.warning(f"find_existing_pr: unexpected error (non-fatal): {exc}")
+        return "unknown"
+
+
+def create_pr(
+    title: str,
+    body: str,
+    *,
+    cwd: str | Path | None = None,
+    base_branch: str | None = None,
+    draft: bool = False,
+) -> PrResult:
+    """Create a PR for the current branch via `gh pr create`. Never raises."""
+    try:
+        cmd = ["pr", "create", "--title", title, "--body", body]
+        if base_branch:
+            cmd += ["--base", base_branch]
+        if draft:
+            cmd.append("--draft")
+
+        rc, out, err = _run_gh(cwd, *cmd)
+        if rc != 0:
+            return PrResult(created=False, error=err or out)
+        return PrResult(created=True, url=out)
+    except FileNotFoundError:
+        return PrResult(
+            created=False, error="gh not found. Install GitHub CLI: https://cli.github.com"
+        )
+    except Exception as exc:  # broad catch intentional: durability must never break the run
+        return PrResult(created=False, error=str(exc))
+
+
+def resolve_task_base_branch(task_id: str | None, api_key: str | None = None) -> str | None:
+    """Resolve the persisted PR base from a task's `base_branch`, if available.
+
+    For a stacked wave this is the predecessor wave's branch. Falls back to
+    None (gh's default base) on any failure.
+    """
+    if not task_id:
+        return None
+    try:
+        from steerdev_agent.api.tasks import TasksClient
+
+        with TasksClient(api_key=api_key) as client:
+            if not client.check_api_key():
+                return None
+            task = client.get_task(task_id)
+            return task.get("base_branch") if task else None
+    except Exception:  # fall back to gh default base
+        logger.debug("resolve_task_base_branch: lookup failed", exc_info=True)
+        return None
+
+
+def build_wave_pr_title(wave_context: WaveContext) -> str:
+    """Build the fallback PR title for a completed wave."""
+    name = (wave_context.wave_name or "").strip()
+    if name and name != f"wave-{wave_context.wave_number}":
+        return f"Wave {wave_context.wave_number}: {name}"
+    return f"Wave {wave_context.wave_number}"
+
+
+def build_wave_pr_body(completed_tasks: list[dict[str, Any]]) -> str:
+    """Build the fallback PR body: one bullet per completed task, plus signature."""
+    lines = ["## Completed tasks", ""]
+    for task in completed_tasks:
+        task_id = task.get("id", "unknown")
+        short = task_id[:8] if len(task_id) > 8 else task_id
+        title = (task.get("title") or "").strip() or "(untitled)"
+        lines.append(f"- `{short}` {title}")
+    if not completed_tasks:
+        lines.append("- (no task summary available)")
+    return "\n".join(lines) + STEERDEV_SIGNATURE
+
+
+def ensure_wave_pr(
+    cwd: str | Path,
+    wave_context: WaveContext,
+    completed_tasks: list[dict[str, Any]],
+    api_key: str | None = None,
+) -> str:
+    """Create the wave PR if the agent didn't. Best-effort; never raises.
+
+    Returns one of:
+        "created", "already_exists", "skipped_detached", "failed".
+    """
+    try:
+        branch = current_branch(cwd)
+        if branch is None:
+            logger.info("ensure_wave_pr: detached HEAD, skipping")
+            return "skipped_detached"
+
+        existing = find_existing_pr(cwd, branch)
+        if existing == "exists":
+            logger.info(f"ensure_wave_pr: PR already exists for {branch}, skipping")
+            return "already_exists"
+        if existing == "unknown":
+            logger.warning("ensure_wave_pr: could not check for existing PR, skipping")
+            return "failed"
+
+        last_task = completed_tasks[-1] if completed_tasks else None
+        base_branch = resolve_task_base_branch(
+            last_task.get("id") if last_task else None, api_key=api_key
+        )
+
+        result = create_pr(
+            build_wave_pr_title(wave_context),
+            build_wave_pr_body(completed_tasks),
+            cwd=cwd,
+            base_branch=base_branch,
+        )
+        if not result.created:
+            logger.warning(f"ensure_wave_pr: PR creation failed (non-fatal): {result.error}")
+            return "failed"
+
+        logger.info(f"ensure_wave_pr: created PR for {branch}: {result.url}")
+        return "created"
+    except Exception as exc:  # broad catch intentional: durability must never break the run
+        logger.warning(f"ensure_wave_pr: unexpected error (non-fatal): {exc}")
+        return "failed"

{steerdev-1.1.43 → steerdev-1.1.44}/src/steerdev_agent/runner.py

@@ -30,6 +30,7 @@ from steerdev_agent.executor import ExecutorFactory
 from steerdev_agent.executor.base import AgentExecutor, EventType, StreamEvent
 from steerdev_agent.executor.claude import ClaudeExecutorError
 from steerdev_agent.git.commit import commit_task_boundary
+from steerdev_agent.git.pr import ensure_wave_pr
 from steerdev_agent.git_ops import checkpoint_push
 from steerdev_agent.prompt.builder import (
     ProjectContext,
@@ -248,6 +249,11 @@ def compute_worktree_name(task_id: str, wave_context: WaveContext | None = None)
     return f"task-{task_short}"
 
 
+def wave_identity(wave_context: WaveContext) -> str:
+    """Stable identity for a wave; matches the wave branch/worktree naming."""
+    return wave_context.wave_name or f"wave-{wave_context.wave_number}"
+
+
 def build_workflow_task_context(
     task: dict[str, Any],
     wave_context: WaveContext | None,
@@ -409,6 +415,11 @@ class Runner:
         self._tasks_failed = 0
         self._events_sent = 0
 
+        # Wave PR safety-net state (see _maybe_create_wave_pr)
+        self._last_wave_ctx: WaveContext | None = None
+        self._wave_completed_tasks: list[dict[str, Any]] = []
+        self._wave_working_dir: str | None = None
+
         # Components
         self._sessions_client: SessionsClient | None = None
         self._events_client: EventsClient | None = None
@@ -983,6 +994,7 @@ class Runner:
                 "exit_code": exit_code,
                 "agent_session_id": agent_session_id,
                 "events_sent": self._events_sent,
+                "working_dir": str(effective_working_dir),
             }
 
         except (KeyboardInterrupt, asyncio.CancelledError):
@@ -1140,6 +1152,7 @@ class Runner:
                 "phases_completed": phases_completed,
                 "phases_failed": phases_failed,
                 "total_phases": total_phases,
+                "working_dir": str(effective_working_dir),
             }
 
         except Exception as e:
@@ -1267,8 +1280,20 @@ class Runner:
                         console.print("[yellow]No tasks available[/yellow]")
                     else:
                         console.print("[yellow]No more tasks available[/yellow]")
+                    # No more wave tasks → the wave is done; make sure its PR exists.
+                    self._maybe_create_wave_pr()
                     break
 
+                # Moving on to a different wave means the previous one
+                # completed — flush its PR safety net before tracking the new
+                # wave.
+                if (
+                    wave_ctx is not None
+                    and self._last_wave_ctx is not None
+                    and wave_identity(wave_ctx) != wave_identity(self._last_wave_ctx)
+                ):
+                    self._maybe_create_wave_pr()
+
                 # Resolve workflow: force override > API suggestion > none
                 per_task_workflow_id = self.workflow_id or suggested_workflow_id
 
@@ -1296,6 +1321,14 @@ class Runner:
                 if result.get("success"):
                     self._tasks_succeeded += 1
                     console.print("[green]Task completed successfully[/green]")
+                    if wave_ctx is not None:
+                        # Track wave progress for the PR safety net.
+                        self._last_wave_ctx = wave_ctx
+                        self._wave_completed_tasks.append(
+                            {"id": task.get("id"), "title": task.get("title")}
+                        )
+                        if result.get("working_dir"):
+                            self._wave_working_dir = result["working_dir"]
                 else:
                     self._tasks_failed += 1
                     console.print(f"[red]Task failed: {result.get('error', 'Unknown')}[/red]")
@@ -1388,6 +1421,37 @@ class Runner:
             "error": str(run_error) if run_error else None,
         }
 
+    def _maybe_create_wave_pr(self) -> None:
+        """Wave PR safety net: create the wave PR if the agent didn't.
+
+        Fires when a wave finishes — either no more wave tasks come back, or
+        the run moves on to a different wave. The wave-tasks-merge skill
+        normally has the agent create a richer PR; this only acts when no PR
+        exists for the wave branch yet. Best-effort: never raises, never fails
+        the run. Always resets the tracked wave state.
+        """
+        wave_ctx = self._last_wave_ctx
+        try:
+            if wave_ctx is None or self.dry_run:
+                return
+            working_dir = self._wave_working_dir or str(self.working_directory)
+            status = ensure_wave_pr(
+                working_dir,
+                wave_ctx,
+                self._wave_completed_tasks,
+                api_key=self._api_key,
+            )
+            if status == "created":
+                console.print("[green]Wave PR created (safety net)[/green]")
+            else:
+                logger.info(f"Wave PR safety net: {status}")
+        except Exception:  # broad catch intentional: safety net must never break the run
+            logger.warning("Wave PR safety net failed (non-fatal)", exc_info=True)
+        finally:
+            self._last_wave_ctx = None
+            self._wave_completed_tasks = []
+            self._wave_working_dir = None
+
     async def resume(
         self,
         session_id: str,

steerdev-1.1.44/tests/test_git_pr.py

@@ -0,0 +1,210 @@
+"""Tests for the shared PR helpers (steerdev_agent.git.pr)."""
+
+from unittest.mock import MagicMock, patch
+
+from steerdev_agent.git.pr import (
+    STEERDEV_SIGNATURE,
+    build_wave_pr_body,
+    build_wave_pr_title,
+    create_pr,
+    ensure_wave_pr,
+    find_existing_pr,
+)
+from tests.test_runner_merge_modes import _make_wave_context
+
+
+def _proc(returncode=0, stdout="", stderr=""):
+    proc = MagicMock()
+    proc.returncode = returncode
+    proc.stdout = stdout
+    proc.stderr = stderr
+    return proc
+
+
+# ---------------------------------------------------------------- create_pr
+
+
+def test_create_pr_builds_gh_command():
+    with patch("steerdev_agent.git.pr.subprocess.run") as run:
+        run.return_value = _proc(stdout="https://github.com/o/r/pull/1\n")
+        result = create_pr("My title", "My body", base_branch="wave-1", draft=True)
+
+    assert result.created
+    assert result.url == "https://github.com/o/r/pull/1"
+    cmd = run.call_args.args[0]
+    assert cmd == [
+        "gh",
+        "pr",
+        "create",
+        "--title",
+        "My title",
+        "--body",
+        "My body",
+        "--base",
+        "wave-1",
+        "--draft",
+    ]
+
+
+def test_create_pr_omits_base_and_draft_by_default():
+    with patch("steerdev_agent.git.pr.subprocess.run") as run:
+        run.return_value = _proc(stdout="url")
+        create_pr("t", "b")
+
+    cmd = run.call_args.args[0]
+    assert "--base" not in cmd
+    assert "--draft" not in cmd
+
+
+def test_create_pr_failure_returns_error():
+    with patch("steerdev_agent.git.pr.subprocess.run") as run:
+        run.return_value = _proc(returncode=1, stderr="no commits between main and wave-1")
+        result = create_pr("t", "b")
+
+    assert not result.created
+    assert "no commits" in (result.error or "")
+
+
+def test_create_pr_handles_missing_gh():
+    with patch("steerdev_agent.git.pr.subprocess.run", side_effect=FileNotFoundError):
+        result = create_pr("t", "b")
+
+    assert not result.created
+    assert "gh not found" in (result.error or "")
+
+
+# ---------------------------------------------------------- find_existing_pr
+
+
+def test_find_existing_pr_exists(tmp_path):
+    with (
+        patch("steerdev_agent.git.pr.shutil.which", return_value="/usr/bin/gh"),
+        patch("steerdev_agent.git.pr.subprocess.run") as run,
+    ):
+        run.return_value = _proc(stdout='[{"number": 7, "state": "OPEN"}]')
+        assert find_existing_pr(tmp_path, "wave-1") == "exists"
+
+
+def test_find_existing_pr_none(tmp_path):
+    with (
+        patch("steerdev_agent.git.pr.shutil.which", return_value="/usr/bin/gh"),
+        patch("steerdev_agent.git.pr.subprocess.run") as run,
+    ):
+        run.return_value = _proc(stdout="[]")
+        assert find_existing_pr(tmp_path, "wave-1") == "none"
+
+
+def test_find_existing_pr_unknown_when_gh_missing(tmp_path):
+    with patch("steerdev_agent.git.pr.shutil.which", return_value=None):
+        assert find_existing_pr(tmp_path, "wave-1") == "unknown"
+
+
+def test_find_existing_pr_unknown_on_gh_failure(tmp_path):
+    with (
+        patch("steerdev_agent.git.pr.shutil.which", return_value="/usr/bin/gh"),
+        patch("steerdev_agent.git.pr.subprocess.run") as run,
+    ):
+        run.return_value = _proc(returncode=1, stderr="auth error")
+        assert find_existing_pr(tmp_path, "wave-1") == "unknown"
+
+
+# ---------------------------------------------------------------- builders
+
+
+def test_build_wave_pr_title_with_distinct_name():
+    ctx = _make_wave_context()
+    ctx.wave_number = 2
+    ctx.wave_name = "wave-532d5c"
+    assert build_wave_pr_title(ctx) == "Wave 2: wave-532d5c"
+
+
+def test_build_wave_pr_title_without_name():
+    ctx = _make_wave_context()
+    ctx.wave_number = 2
+    ctx.wave_name = ""
+    assert build_wave_pr_title(ctx) == "Wave 2"
+
+
+def test_build_wave_pr_title_with_default_name():
+    ctx = _make_wave_context()
+    ctx.wave_number = 2
+    ctx.wave_name = "wave-2"
+    assert build_wave_pr_title(ctx) == "Wave 2"
+
+
+def test_build_wave_pr_body_lists_tasks():
+    body = build_wave_pr_body(
+        [
+            {"id": "abcdef0123456789", "title": "Add auth"},
+            {"id": "short", "title": ""},
+        ]
+    )
+    assert "- `abcdef01` Add auth" in body
+    assert "- `short` (untitled)" in body
+    assert body.endswith(STEERDEV_SIGNATURE)
+
+
+def test_build_wave_pr_body_empty():
+    body = build_wave_pr_body([])
+    assert "no task summary available" in body
+
+
+# ------------------------------------------------------------- ensure_wave_pr
+
+
+def test_ensure_wave_pr_creates_when_missing(tmp_path):
+    tasks = [{"id": "abcdef0123456789", "title": "Add auth"}]
+    with (
+        patch("steerdev_agent.git.pr.current_branch", return_value="wave-1"),
+        patch("steerdev_agent.git.pr.find_existing_pr", return_value="none"),
+        patch("steerdev_agent.git.pr.resolve_task_base_branch", return_value="main") as base,
+        patch("steerdev_agent.git.pr.create_pr") as create,
+    ):
+        create.return_value = MagicMock(created=True, url="https://github.com/o/r/pull/1")
+        assert ensure_wave_pr(tmp_path, _make_wave_context(), tasks) == "created"
+
+    base.assert_called_once_with("abcdef0123456789", api_key=None)
+    assert create.call_args.kwargs["base_branch"] == "main"
+
+
+def test_ensure_wave_pr_skips_when_pr_exists(tmp_path):
+    with (
+        patch("steerdev_agent.git.pr.current_branch", return_value="wave-1"),
+        patch("steerdev_agent.git.pr.find_existing_pr", return_value="exists"),
+        patch("steerdev_agent.git.pr.create_pr") as create,
+    ):
+        assert ensure_wave_pr(tmp_path, _make_wave_context(), []) == "already_exists"
+
+    create.assert_not_called()
+
+
+def test_ensure_wave_pr_skips_when_check_fails(tmp_path):
+    with (
+        patch("steerdev_agent.git.pr.current_branch", return_value="wave-1"),
+        patch("steerdev_agent.git.pr.find_existing_pr", return_value="unknown"),
+        patch("steerdev_agent.git.pr.create_pr") as create,
+    ):
+        assert ensure_wave_pr(tmp_path, _make_wave_context(), []) == "failed"
+
+    create.assert_not_called()
+
+
+def test_ensure_wave_pr_detached_head(tmp_path):
+    with patch("steerdev_agent.git.pr.current_branch", return_value=None):
+        assert ensure_wave_pr(tmp_path, _make_wave_context(), []) == "skipped_detached"
+
+
+def test_ensure_wave_pr_failed_create(tmp_path):
+    with (
+        patch("steerdev_agent.git.pr.current_branch", return_value="wave-1"),
+        patch("steerdev_agent.git.pr.find_existing_pr", return_value="none"),
+        patch("steerdev_agent.git.pr.resolve_task_base_branch", return_value=None),
+        patch("steerdev_agent.git.pr.create_pr") as create,
+    ):
+        create.return_value = MagicMock(created=False, error="boom")
+        assert ensure_wave_pr(tmp_path, _make_wave_context(), []) == "failed"
+
+
+def test_ensure_wave_pr_never_raises(tmp_path):
+    with patch("steerdev_agent.git.pr.current_branch", side_effect=RuntimeError("boom")):
+        assert ensure_wave_pr(tmp_path, _make_wave_context(), []) == "failed"

steerdev-1.1.44/tests/test_runner_wave_pr.py

@@ -0,0 +1,83 @@
+"""Tests for the runner's wave PR safety net."""
+
+from pathlib import Path
+from unittest.mock import patch
+
+from steerdev_agent.runner import Runner, wave_identity
+from tests.test_runner_merge_modes import _make_wave_context
+
+
+def _make_runner(**kwargs) -> Runner:
+    return Runner(project_id="p", api_key="k", working_directory=Path("/code/repo"), **kwargs)
+
+
+class TestWaveIdentity:
+    def test_uses_wave_name(self):
+        ctx = _make_wave_context()
+        assert wave_identity(ctx) == "wave-a1b2c3"
+
+    def test_falls_back_to_wave_number(self):
+        ctx = _make_wave_context()
+        ctx.wave_name = ""
+        assert wave_identity(ctx) == "wave-3"
+
+
+class TestMaybeCreateWavePr:
+    def test_creates_pr_for_tracked_wave(self):
+        runner = _make_runner()
+        ctx = _make_wave_context()
+        runner._last_wave_ctx = ctx
+        runner._wave_completed_tasks = [{"id": "abc", "title": "do work"}]
+        runner._wave_working_dir = "/code/repo/.worktrees/wave-a1b2c3"
+
+        with patch("steerdev_agent.runner.ensure_wave_pr", return_value="created") as ensure:
+            runner._maybe_create_wave_pr()
+
+        ensure.assert_called_once_with(
+            "/code/repo/.worktrees/wave-a1b2c3",
+            ctx,
+            [{"id": "abc", "title": "do work"}],
+            api_key="k",
+        )
+        # State is reset so the next wave starts clean.
+        assert runner._last_wave_ctx is None
+        assert runner._wave_completed_tasks == []
+        assert runner._wave_working_dir is None
+
+    def test_noop_without_wave_context(self):
+        runner = _make_runner()
+
+        with patch("steerdev_agent.runner.ensure_wave_pr") as ensure:
+            runner._maybe_create_wave_pr()
+
+        ensure.assert_not_called()
+
+    def test_noop_in_dry_run(self):
+        runner = _make_runner(dry_run=True)
+        runner._last_wave_ctx = _make_wave_context()
+        runner._wave_completed_tasks = [{"id": "abc", "title": "do work"}]
+
+        with patch("steerdev_agent.runner.ensure_wave_pr") as ensure:
+            runner._maybe_create_wave_pr()
+
+        ensure.assert_not_called()
+        # Dry-run still resets tracked state.
+        assert runner._last_wave_ctx is None
+
+    def test_falls_back_to_runner_working_directory(self):
+        runner = _make_runner()
+        runner._last_wave_ctx = _make_wave_context()
+
+        with patch("steerdev_agent.runner.ensure_wave_pr", return_value="created") as ensure:
+            runner._maybe_create_wave_pr()
+
+        assert ensure.call_args.args[0] == str(Path("/code/repo"))
+
+    def test_never_raises(self):
+        runner = _make_runner()
+        runner._last_wave_ctx = _make_wave_context()
+
+        with patch("steerdev_agent.runner.ensure_wave_pr", side_effect=RuntimeError("boom")):
+            runner._maybe_create_wave_pr()  # must not raise
+
+        assert runner._last_wave_ctx is None