steerdev 1.1.29__tar.gz → 1.1.31__tar.gz

{steerdev-1.1.29 → steerdev-1.1.31}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: steerdev
-Version: 1.1.29
+Version: 1.1.31
 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.29 → steerdev-1.1.31}/pyproject.toml

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

{steerdev-1.1.29 → steerdev-1.1.31}/src/steerdev_agent/prompt/builder.py

@@ -28,6 +28,10 @@ class WaveContext(BaseModel):
     wave_description: str = Field(default="", description="Description of this wave")
     wave_tasks_summary: str = Field(default="", description="Summary of tasks in this wave")
     completed_waves_summary: str = Field(default="", description="Summary of completed waves")
+    predecessor_branch: str | None = Field(
+        default=None,
+        description="Branch of the previous completed wave to stack this wave on",
+    )
 
 
 class TaskContext(BaseModel):

{steerdev-1.1.29 → steerdev-1.1.31}/src/steerdev_agent/runner.py

@@ -110,6 +110,15 @@ def build_wave_context(wave_response: dict[str, Any]) -> WaveContext | None:
     ]
     completed_summary = "\n".join(completed_lines) if completed_lines else ""
 
+    # Stacked-wave base: the server sends the previous completed wave's branch
+    # NAME (never a number — the wave name IS the branch). A blank/absent name
+    # means no valid predecessor, so we leave the base unset and cut from default.
+    predecessor_branch: str | None = None
+    predecessor = wave_info.get("predecessor_wave")
+    if predecessor:
+        name = (predecessor.get("name") or "").strip()
+        predecessor_branch = name or None
+
     return WaveContext(
         wave_number=wave_info.get("wave_number", 1),
         total_waves=wave_info.get("total_waves", 1),
@@ -117,6 +126,7 @@ def build_wave_context(wave_response: dict[str, Any]) -> WaveContext | None:
         wave_description=wave_info.get("description", ""),
         wave_tasks_summary=tasks_summary,
         completed_waves_summary=completed_summary,
+        predecessor_branch=predecessor_branch,
     )
 
 

{steerdev-1.1.29 → steerdev-1.1.31}/src/steerdev_agent/setup/templates/skills/steerdev-wave-tasks-merge-skill/SKILL.md

@@ -69,6 +69,11 @@ git merge-tree --write-tree origin/<default-branch> HEAD
 steerdev git pr --title "Wave <N>: <description>" --body "..."
 ```
 
+**Do not pass `--base`.** `steerdev git pr` sets the PR base automatically from
+the task's recorded base branch. For a stacked wave (a wave that builds on a
+previous wave of the same PRD) the base is the predecessor wave's branch, so the
+PR shows only this wave's diff. Overriding `--base` would break the stack.
+
 5. Update all related tasks with the shared PR URL
 6. Log progress and completion in the root `docs/` progress files
 
@@ -86,11 +91,27 @@ message so GitHub integrations can link commits to issues:
 It also pushes the wave branch after each commit. Your job is to implement and,
 once the wave is done, rebase and open the PR (steps 3–5).
 
+## Stacked waves (same PRD)
+
+Waves of one PRD are **stacked**: wave-2 is branched off wave-1, wave-3 off
+wave-2, and so on. The CLI handles this for you — it cuts the wave branch off the
+previous wave's branch and records that branch as the PR base. As a result:
+
+- Each wave still gets its own PR, but its diff shows only that wave's changes.
+- The PRs form a chain: `wave-1 → default`, `wave-2 → wave-1`, `wave-3 → wave-2`.
+- **Do not delete a wave's branch until the next wave's PR has merged.** When
+  wave-1's PR merges into the default branch, GitHub automatically retargets
+  wave-2's PR — but only if wave-1's branch still exists.
+- The first wave of a PRD (and any wave with no completed same-PRD predecessor)
+  is cut from the default branch as usual.
+
 ## Conventions
 
 - Use one branch per wave: `wave/<wave-number>`
 - Do not commit task work — the runtime commits and pushes each task automatically
 - Do not create per-task PRs inside the wave
+- Do not pass `--base` to `steerdev git pr` — the base is set automatically
+- Do not delete wave branches until the dependent wave's PR has merged
 - Include the shared PR URL in every related task result
 - Replace `<default-branch>` in commands above with the actual branch name from the Git Branch Configuration section
 

{steerdev-1.1.29 → steerdev-1.1.31}/src/steerdev_agent/workspace/preparation.py

@@ -347,38 +347,91 @@ class WorkspacePreparation:
         # 4. Fetch from origin
         await _run_git("fetch", "origin", cwd=cwd, check=False)
 
-        # 5. Sync to default branch
-        rc, _, _ = await _run_git("checkout", default_branch, cwd=cwd, check=False)
-        if rc != 0:
-            return PreparationResult(
-                success=False,
-                branch_name=target_branch,
-                working_directory=cwd,
-                default_branch=default_branch,
-                is_worktree=False,
-                error=f"Failed to checkout {default_branch}. Does the branch exist?",
-            )
-
-        # Try fast-forward merge
-        rc, _, _ = await _run_git(
-            "merge", "--ff-only", f"origin/{default_branch}", cwd=cwd, check=False
-        )
-        if rc != 0:
-            # Fallback: hard reset to origin
-            logger.warning(f"Fast-forward merge failed for {default_branch}, resetting to origin")
-            await _run_git("reset", "--hard", f"origin/{default_branch}", cwd=cwd, check=False)
-            warnings.append(
-                f"Fast-forward failed, reset {default_branch} to origin/{default_branch}"
+        # 5. Resolve the base this wave stacks on. For a new wave with a
+        # predecessor (stacked-wave mode), branch directly off the predecessor's
+        # remote branch so the wave physically contains the previous wave's work.
+        # If that branch is missing from origin (never pushed / deleted), the
+        # chain is broken — fall back to the default branch and surface a loud
+        # warning rather than silently building on the wrong base.
+        predecessor_branch = wave_context.predecessor_branch if wave_context else None
+        effective_base = default_branch
+        if predecessor_branch:
+            rc, _, _ = await _run_git(
+                "rev-parse", "--verify", f"origin/{predecessor_branch}", cwd=cwd, check=False
             )
+            if rc == 0:
+                effective_base = predecessor_branch
+            else:
+                logger.warning(
+                    f"Predecessor branch origin/{predecessor_branch} missing — "
+                    f"stacked-wave chain broken; cutting {target_branch} from "
+                    f"{default_branch} instead"
+                )
+                warnings.append(
+                    f"Predecessor branch '{predecessor_branch}' not found on origin; "
+                    f"stacked-wave chain broken — cut from '{default_branch}'. This wave "
+                    f"may not contain the previous wave's work."
+                )
 
-        # 6. Create or checkout target branch
+        # 6. Create or checkout the target (wave) branch.
         rc, _, _ = await _run_git("rev-parse", "--verify", target_branch, cwd=cwd, check=False)
         branch_exists = rc == 0
 
         if branch_exists:
-            await _run_git("checkout", target_branch, cwd=cwd)
+            # Branch already present locally (e.g. a continuing wave on a fresh
+            # clone): just switch to it.
+            rc, _, _ = await _run_git("checkout", target_branch, cwd=cwd, check=False)
+            if rc != 0:
+                return PreparationResult(
+                    success=False,
+                    branch_name=target_branch,
+                    working_directory=cwd,
+                    default_branch=default_branch,
+                    is_worktree=False,
+                    error=f"Failed to checkout existing branch {target_branch}",
+                )
             logger.info(f"Switched to existing branch: {target_branch}")
+        elif effective_base != default_branch:
+            # Stacked cut: branch straight off the predecessor's remote branch.
+            # No default-branch sync — the predecessor already carries the work.
+            rc, _, _ = await _run_git(
+                "checkout", "-b", target_branch, f"origin/{effective_base}", cwd=cwd, check=False
+            )
+            if rc != 0:
+                return PreparationResult(
+                    success=False,
+                    branch_name=target_branch,
+                    working_directory=cwd,
+                    default_branch=default_branch,
+                    is_worktree=False,
+                    error=f"Failed to cut {target_branch} from origin/{effective_base}",
+                )
+            logger.info(f"Created {target_branch} stacked on origin/{effective_base}")
         else:
+            # Default cut: sync to the default branch, then branch off it.
+            rc, _, _ = await _run_git("checkout", default_branch, cwd=cwd, check=False)
+            if rc != 0:
+                return PreparationResult(
+                    success=False,
+                    branch_name=target_branch,
+                    working_directory=cwd,
+                    default_branch=default_branch,
+                    is_worktree=False,
+                    error=f"Failed to checkout {default_branch}. Does the branch exist?",
+                )
+
+            rc, _, _ = await _run_git(
+                "merge", "--ff-only", f"origin/{default_branch}", cwd=cwd, check=False
+            )
+            if rc != 0:
+                logger.warning(
+                    f"Fast-forward merge failed for {default_branch}, resetting to origin"
+                )
+                await _run_git("reset", "--hard", f"origin/{default_branch}", cwd=cwd, check=False)
+                warnings.append(
+                    f"Fast-forward failed, reset {default_branch} to origin/{default_branch}"
+                )
+
             await _run_git("checkout", "-b", target_branch, cwd=cwd)
             logger.info(f"Created new branch: {target_branch}")
 
@@ -395,7 +448,7 @@ class WorkspacePreparation:
             )
 
         await persist_branch_provenance(
-            task_id=task_id, branch=target_branch, base_branch=default_branch
+            task_id=task_id, branch=target_branch, base_branch=effective_base
         )
 
         return PreparationResult(

{steerdev-1.1.29 → steerdev-1.1.31}/src/steerdev_agent/worktree.py

@@ -206,6 +206,16 @@ class WorktrunkClient:
         return None
 
 
+def wave_branch_name(name: str | None, wave_number: int) -> str:
+    """The single source of truth for a wave's git branch name.
+
+    A wave branch is its `name` (e.g. "wave-a1b2c3"), falling back to
+    "wave-{wave_number}". Used by `compute_branch_name` for the current wave and
+    by the runner to derive a predecessor wave's branch for stacked-wave cuts.
+    """
+    return name or f"wave-{wave_number}"
+
+
 def compute_branch_name(
     task: dict[str, Any],
     wave_context: WaveContext | None = None,
@@ -225,7 +235,7 @@ def compute_branch_name(
         Branch name string.
     """
     if wave_context:
-        return wave_context.wave_name or f"wave-{wave_context.wave_number}"
+        return wave_branch_name(wave_context.wave_name, wave_context.wave_number)
 
     # Try external ticket ID first (e.g., Linear "PROJ-123")
     external_id = task.get("linear_identifier") or task.get("external_id")

{steerdev-1.1.29 → steerdev-1.1.31}/tests/test_preparation.py

@@ -368,6 +368,141 @@ class TestWorkspacePreparationInPlace:
         assert any("fast-forward" in w.lower() or "reset" in w.lower() for w in result.warnings)
 
 
+class TestWorkspacePreparationStackedWave:
+    """Tests for stacked-wave cuts (wave-N branches off the predecessor wave)."""
+
+    @pytest.mark.asyncio
+    async def test_stacked_cut_branches_off_predecessor(
+        self, worktree_disabled, default_config, sample_task
+    ):
+        """A new wave with a predecessor branches off origin/<predecessor>."""
+        from steerdev_agent.prompt.builder import WaveContext
+
+        wave_ctx = WaveContext(
+            wave_number=2,
+            total_waves=3,
+            wave_name="wave-bbb222",
+            predecessor_branch="wave-aaa111",
+        )
+
+        prep = WorkspacePreparation(
+            working_directory=Path("/tmp/repo"),
+            worktree_config=worktree_disabled,
+            branch_config=default_config,
+        )
+
+        calls = []
+
+        async def mock_run_git(*args, cwd, check=True):
+            calls.append(args)
+            cmd = " ".join(args)
+            if "rev-parse --is-inside-work-tree" in cmd:
+                return (0, "true", "")
+            if "branch --show-current" in cmd:
+                # Start on main; after checkout -b we're on the wave branch.
+                if any("checkout -b" in " ".join(c) for c in calls):
+                    return (0, "wave-bbb222", "")
+                return (0, "main", "")
+            if "status --porcelain" in cmd:
+                return (0, "", "")
+            if "fetch origin" in cmd:
+                return (0, "", "")
+            if "rev-parse --verify origin/wave-aaa111" in cmd:
+                return (0, "deadbeef", "")  # predecessor exists on origin
+            if "rev-parse --verify" in cmd:
+                return (1, "", "")  # local wave branch doesn't exist yet
+            if "checkout -b" in cmd:
+                return (0, "", "")
+            if "checkout" in cmd:
+                return (0, "", "")
+            return (0, "", "")
+
+        with (
+            patch("steerdev_agent.workspace.preparation._run_git", side_effect=mock_run_git),
+            patch("steerdev_agent.workspace.preparation.persist_branch_provenance") as mock_persist,
+        ):
+            result = await prep.prepare(sample_task, wave_ctx)
+
+        assert result.success is True
+        assert result.branch_name == "wave-bbb222"
+        # The new branch is cut directly off the predecessor's remote branch.
+        checkout_b = [c for c in calls if "checkout -b" in " ".join(c)]
+        assert len(checkout_b) == 1
+        assert "origin/wave-aaa111" in " ".join(checkout_b[0])
+        # We must NOT sync to the default branch on the stacked path.
+        assert not any("checkout main" in " ".join(c) for c in calls)
+        # Provenance records the predecessor as the base so `steerdev git pr`
+        # targets it (stacked PR base).
+        mock_persist.assert_awaited_once_with(
+            task_id=sample_task["id"], branch="wave-bbb222", base_branch="wave-aaa111"
+        )
+
+    @pytest.mark.asyncio
+    async def test_missing_predecessor_falls_back_to_default(
+        self, worktree_disabled, default_config, sample_task
+    ):
+        """If origin/<predecessor> is missing, cut from default + warn (degraded)."""
+        from steerdev_agent.prompt.builder import WaveContext
+
+        wave_ctx = WaveContext(
+            wave_number=2,
+            total_waves=3,
+            wave_name="wave-bbb222",
+            predecessor_branch="wave-gone",
+        )
+
+        prep = WorkspacePreparation(
+            working_directory=Path("/tmp/repo"),
+            worktree_config=worktree_disabled,
+            branch_config=default_config,
+        )
+
+        calls = []
+
+        async def mock_run_git(*args, cwd, check=True):
+            calls.append(args)
+            cmd = " ".join(args)
+            if "rev-parse --is-inside-work-tree" in cmd:
+                return (0, "true", "")
+            if "branch --show-current" in cmd:
+                if any("checkout -b" in " ".join(c) for c in calls):
+                    return (0, "wave-bbb222", "")
+                return (0, "main", "")
+            if "status --porcelain" in cmd:
+                return (0, "", "")
+            if "fetch origin" in cmd:
+                return (0, "", "")
+            if "rev-parse --verify origin/wave-gone" in cmd:
+                return (1, "", "")  # predecessor NOT on origin
+            if "rev-parse --verify" in cmd:
+                return (1, "", "")
+            if "checkout main" in cmd:
+                return (0, "", "")
+            if "merge --ff-only" in cmd:
+                return (0, "", "")
+            if "checkout -b" in cmd:
+                return (0, "", "")
+            if "checkout" in cmd:
+                return (0, "", "")
+            return (0, "", "")
+
+        with (
+            patch("steerdev_agent.workspace.preparation._run_git", side_effect=mock_run_git),
+            patch("steerdev_agent.workspace.preparation.persist_branch_provenance"),
+        ):
+            result = await prep.prepare(sample_task, wave_ctx)
+
+        assert result.success is True
+        assert result.branch_name == "wave-bbb222"
+        # Fell back to the default-branch sync path.
+        assert any("checkout main" in " ".join(c) for c in calls)
+        # And surfaced a warning that the chain was broken.
+        assert any(
+            "wave-gone" in w or "predecessor" in w.lower() or "chain" in w.lower()
+            for w in result.warnings
+        )
+
+
 class TestWorkspacePreparationMultiRepo:
     """Tests for multi-repo workspace preparation."""
 

{steerdev-1.1.29 → steerdev-1.1.31}/tests/test_runner_merge_modes.py

@@ -2,12 +2,37 @@
 
 from steerdev_agent.prompt.builder import WaveContext
 from steerdev_agent.runner import (
+    build_wave_context,
     build_workflow_task_context,
     extract_task_and_wave_context,
     resolve_merge_flow,
 )
 
 
+class TestPredecessorBranch:
+    """build_wave_context derives the stacked-wave predecessor branch."""
+
+    def test_no_predecessor_when_field_absent(self):
+        wave = build_wave_context(_make_wave_response())
+        assert wave is not None
+        assert wave.predecessor_branch is None
+
+    def test_uses_predecessor_wave_name_as_branch(self):
+        response = _make_wave_response()
+        response["wave"]["predecessor_wave"] = {"name": "wave-aaa111"}
+        wave = build_wave_context(response)
+        assert wave is not None
+        assert wave.predecessor_branch == "wave-aaa111"
+
+    def test_blank_predecessor_name_yields_no_base(self):
+        # A blank name is not a valid branch — never guess "wave-N".
+        response = _make_wave_response()
+        response["wave"]["predecessor_wave"] = {"name": ""}
+        wave = build_wave_context(response)
+        assert wave is not None
+        assert wave.predecessor_branch is None
+
+
 def _make_wave_context() -> WaveContext:
     return WaveContext(
         wave_number=3,

{steerdev-1.1.29 → steerdev-1.1.31}/tests/test_runner_worktrees.py

@@ -6,7 +6,23 @@ from unittest.mock import patch
 from steerdev_agent.config.models import EvidenceConfig, WorktreeConfig
 from steerdev_agent.prompt.builder import WaveContext
 from steerdev_agent.runner import Runner
-from steerdev_agent.worktree import compute_branch_name
+from steerdev_agent.worktree import compute_branch_name, wave_branch_name
+
+
+class TestWaveBranchName:
+    """The single source of truth for a wave's branch name."""
+
+    def test_uses_name_when_present(self):
+        assert wave_branch_name("wave-a1b2c3", 3) == "wave-a1b2c3"
+
+    def test_falls_back_to_number(self):
+        assert wave_branch_name("", 3) == "wave-3"
+        assert wave_branch_name(None, 4) == "wave-4"
+
+    def test_matches_compute_branch_name_wave_output(self):
+        wave = WaveContext(wave_number=3, total_waves=5, wave_name="wave-a1b2c3")
+        task = {"id": "abc123", "title": "Something"}
+        assert wave_branch_name(wave.wave_name, wave.wave_number) == compute_branch_name(task, wave)
 
 
 class TestComputeBranchName: