steerdev 1.1.29__tar.gz → 1.1.43__tar.gz

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

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

@@ -1,6 +1,6 @@
 [project]
 name = "steerdev"
-version = "1.1.29"
+version = "1.1.43"
 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.43}/src/steerdev_agent/cli.py

@@ -1806,6 +1806,16 @@ def run(
             ),
         ),
     ] = None,
+    base_branch: Annotated[
+        str | None,
+        typer.Option(
+            "--base-branch",
+            help=(
+                "Branch to cut a new wave/task branch from (overrides the "
+                "auto-chosen predecessor/default). Falls back to STEERDEV_BASE_BRANCH."
+            ),
+        ),
+    ] = None,
 ) -> None:
     """Run the agent for a project!
 
@@ -1841,6 +1851,9 @@ def run(
         console.print("[red]Error: --project-id required (or set via env/config)[/red]")
         raise typer.Exit(1)
 
+    # Resolve base branch override: CLI > env > None
+    resolved_base_branch = base_branch or os.environ.get("STEERDEV_BASE_BRANCH") or None
+
     # Resolve other options: CLI > config > hardcoded default
     resolved_model = model if model is not None else config.agent.model
     resolved_max_turns = max_turns if max_turns is not None else config.agent.max_turns
@@ -1937,6 +1950,7 @@ def run(
                 task_id=task_id,
                 agent_id=agent_id,
                 wave_id=wave_id,
+                base_branch_override=resolved_base_branch,
             )
         )
 

{steerdev-1.1.29 → steerdev-1.1.43}/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.43}/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,
     )
 
 
@@ -328,6 +338,7 @@ class Runner:
         agent_id: str | None = None,
         task_id: str | None = None,
         wave_id: str | None = None,
+        base_branch_override: str | None = None,
     ) -> None:
         """Initialize the runner.
 
@@ -353,6 +364,8 @@ class Runner:
             task_id: Run a single specific task (bypasses queue/wave scheduling).
             wave_id: Scope scheduling to a single wave; the loop processes every
                 task of that wave and stops when it is exhausted.
+            base_branch_override: Override the base branch used when preparing
+                each task's workspace.
         """
         self.project_id = project_id
         self.working_directory = Path(working_directory or Path.cwd())
@@ -380,6 +393,7 @@ class Runner:
         self._agent_id = agent_id
         self._target_task_id = task_id
         self._target_wave_id = wave_id
+        self._base_branch_override = base_branch_override
 
         # State
         self._state = RunState.STOPPED
@@ -826,6 +840,7 @@ class Runner:
                 working_directory=self.working_directory,
                 worktree_config=self._worktree_config,
                 branch_config=self._branch_config,
+                base_branch_override=self._base_branch_override,
             )
             prep_result = await preparation.prepare(task, wave_context)
             if not prep_result.success:
@@ -1043,6 +1058,7 @@ class Runner:
             working_directory=self.working_directory,
             worktree_config=self._worktree_config,
             branch_config=self._branch_config,
+            base_branch_override=self._base_branch_override,
         )
         prep_result = await preparation.prepare(task, wave_context)
         if not prep_result.success:
@@ -1500,6 +1516,7 @@ async def run_agent(
     task_id: str | None = None,
     agent_id: str | None = None,
     wave_id: str | None = None,
+    base_branch_override: str | None = None,
 ) -> dict[str, Any]:
     """Run the steerdev agent.
 
@@ -1550,6 +1567,7 @@ async def run_agent(
         task_id=task_id,
         agent_id=agent_id,
         wave_id=wave_id,
+        base_branch_override=base_branch_override,
     )
 
     # Install signal handler that kills the subprocess immediately on Ctrl+C

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

@@ -63,12 +63,34 @@ git merge-tree --write-tree origin/<default-branch> HEAD
 
 **Fallback** (if `git merge-tree` is unavailable): Skip the dry-run and rebase directly. If rebase fails, abort and re-queue as above.
 
+### Before pushing: reconcile concurrent work on the wave branch
+
+Another task of this wave may have pushed to the wave branch while you worked.
+Before any push to the wave branch:
+
+```bash
+git fetch origin "$(git branch --show-current)"
+git rebase "origin/$(git branch --show-current)"
+```
+
+- If the rebase is clean, continue.
+- If it conflicts, resolve the conflicts in the files in your working tree
+  (you have full context for the change you just made), then
+  `git rebase --continue`.
+- If you genuinely cannot resolve them, abort (`git rebase --abort`) and report
+  a blocker with `steerdev activity report`.
+
 4. Create one pull request for the wave:
 
 ```bash
 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 +108,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.43}/src/steerdev_agent/workspace/preparation.py

@@ -114,10 +114,12 @@ class WorkspacePreparation:
         working_directory: Path,
         worktree_config: WorktreeConfig,
         branch_config: BranchConfig,
+        base_branch_override: str | None = None,
     ) -> None:
         self.working_directory = working_directory
         self._worktree_config = worktree_config
         self._branch_config = branch_config
+        self._base_branch_override = base_branch_override
 
     async def prepare(
         self,
@@ -294,6 +296,48 @@ class WorkspacePreparation:
             repo_directories=prepared_repos,
         )
 
+    async def _claim_or_adopt(self, cwd: Path, target_branch: str) -> tuple[bool, bool]:
+        """Push the freshly-cut branch to claim it (plain push, no force).
+
+        Returns (success, adopted). A push rejected because the branch already
+        exists on origin (another VM won the race) is adopted: we fetch and
+        reset to the remote branch and continue its commits. Any OTHER push
+        failure (network, auth, ...) is a hard error, not a lost race — we do
+        not adopt, so the caller surfaces a real failure rather than silently
+        building on an unexpected branch. adopted=True means continuation
+        (don't persist base).
+        """
+        rc, out, err = await _run_git("push", "origin", target_branch, cwd=cwd, check=False)
+        if rc == 0:
+            logger.info(f"Claimed branch {target_branch} on origin")
+            return True, False
+
+        # Only a ref-already-exists / non-fast-forward rejection means we lost
+        # the race. Match git's rejection wording; treat anything else as fatal.
+        message = f"{out}\n{err}".lower()
+        is_lost_race = (
+            "[rejected]" in message
+            or "fetch first" in message
+            or "already exists" in message
+            or "non-fast-forward" in message
+        )
+        if not is_lost_race:
+            logger.warning(f"Claim push for {target_branch} failed (not a rejection): {err or out}")
+            return False, False
+
+        logger.info(
+            f"Claim of {target_branch} rejected ({err or out}); adopting existing "
+            f"origin/{target_branch}"
+        )
+        rc_fetch, _, _ = await _run_git("fetch", "origin", target_branch, cwd=cwd, check=False)
+        if rc_fetch != 0:
+            logger.warning(f"Failed to fetch origin/{target_branch} for adoption")
+            return False, True
+        rc, _, _ = await _run_git(
+            "checkout", "-B", target_branch, f"origin/{target_branch}", cwd=cwd, check=False
+        )
+        return rc == 0, True
+
     async def _prepare_single_repo(
         self,
         cwd: Path,
@@ -347,40 +391,180 @@ 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?",
-            )
+        # 5. Create or checkout the target (wave) branch.
+        #
+        # Branch resolution priority — a wave has exactly ONE branch, so an
+        # already-existing wave branch must always be CONTINUED, never re-cut:
+        #   a) local branch exists           → checkout (same VM, mid-run)
+        #   b) branch exists on origin        → checkout tracking it (fresh clone
+        #                                       / resume — continue prior commits)
+        #   c) new wave with predecessor      → stacked cut off origin/<predecessor>
+        #   d) otherwise                      → default cut
+        # Cases (a)/(b) are continuations: they do NOT re-persist base_branch
+        # (task 1 already recorded the wave's base — don't clobber it). The base
+        # is resolved ONLY on the cut paths (c)/(d), so a continuation never
+        # surfaces a spurious "predecessor missing / chain broken" warning.
+
+        # Does the wave branch already exist? (origin is authoritative for a
+        # fresh clone). If so we CONTINUE it — no base resolution / no cut.
+        rc, _, _ = await _run_git("rev-parse", "--verify", target_branch, cwd=cwd, check=False)
+        branch_exists_local = rc == 0
 
-        # Try fast-forward merge
         rc, _, _ = await _run_git(
-            "merge", "--ff-only", f"origin/{default_branch}", cwd=cwd, check=False
+            "rev-parse", "--verify", f"origin/{target_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}"
-            )
+        branch_exists_origin = rc == 0
 
-        # 6. Create or checkout target branch
-        rc, _, _ = await _run_git("rev-parse", "--verify", target_branch, cwd=cwd, check=False)
-        branch_exists = rc == 0
+        is_continuation = False
+        effective_base = default_branch
 
-        if branch_exists:
-            await _run_git("checkout", target_branch, cwd=cwd)
+        if branch_exists_local:
+            # Branch already present locally (same VM, continuing the wave).
+            is_continuation = True
+            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 branch_exists_origin:
+            # Wave branch exists on origin but not locally — a fresh clone / resume
+            # continuing a wave another VM started. Track it and continue its
+            # commits; NEVER re-cut (that would drop the earlier tasks' work).
+            is_continuation = True
+            rc, _, _ = await _run_git(
+                "checkout", "-b", target_branch, f"origin/{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 track existing branch origin/{target_branch}",
+                )
+            logger.info(f"Continuing wave branch from origin/{target_branch}")
         else:
-            await _run_git("checkout", "-b", target_branch, cwd=cwd)
-            logger.info(f"Created new branch: {target_branch}")
+            # New branch — NOW resolve the base a NEW wave branch is cut from.
+            # Existence is judged on ORIGIN (a sandbox is a fresh clone).
+            # Priority: explicit user override > predecessor wave > default
+            # branch. A chosen base that is missing from origin falls back to
+            # default with a loud warning. Warnings are emitted ONLY here, on
+            # the cut path — never on a continuation.
+            async def _origin_has(branch: str) -> bool:
+                rc, _, _ = await _run_git(
+                    "rev-parse", "--verify", f"origin/{branch}", cwd=cwd, check=False
+                )
+                return rc == 0
+
+            override = self._base_branch_override
+            predecessor_branch = wave_context.predecessor_branch if wave_context else None
+
+            if override:
+                if await _origin_has(override):
+                    effective_base = override
+                else:
+                    logger.warning(
+                        f"Chosen base branch origin/{override} missing — "
+                        f"cutting {target_branch} from {default_branch} instead"
+                    )
+                    warnings.append(
+                        f"Chosen base branch '{override}' not found on origin; "
+                        f"cut from '{default_branch}' instead."
+                    )
+            elif predecessor_branch:
+                if await _origin_has(predecessor_branch):
+                    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."
+                    )
+
+            if 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}")
+                ok, adopted = await self._claim_or_adopt(cwd, target_branch)
+                if not ok:
+                    return PreparationResult(
+                        success=False,
+                        branch_name=target_branch,
+                        working_directory=cwd,
+                        default_branch=default_branch,
+                        is_worktree=False,
+                        error=f"Failed to claim/adopt {target_branch}",
+                    )
+                is_continuation = adopted
+            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}")
+                ok, adopted = await self._claim_or_adopt(cwd, target_branch)
+                if not ok:
+                    return PreparationResult(
+                        success=False,
+                        branch_name=target_branch,
+                        working_directory=cwd,
+                        default_branch=default_branch,
+                        is_worktree=False,
+                        error=f"Failed to claim/adopt {target_branch}",
+                    )
+                is_continuation = adopted
 
         # 7. Validate current branch
         _, actual_branch, _ = await _run_git("branch", "--show-current", cwd=cwd, check=False)
@@ -394,9 +578,13 @@ class WorkspacePreparation:
                 error=f"Branch mismatch: expected {target_branch}, got {actual_branch}",
             )
 
-        await persist_branch_provenance(
-            task_id=task_id, branch=target_branch, base_branch=default_branch
-        )
+        # Record provenance only when this task actually CUT the branch. A
+        # continuation (the branch already existed locally or on origin) must not
+        # overwrite the base the wave's first task recorded.
+        if not is_continuation:
+            await persist_branch_provenance(
+                task_id=task_id, branch=target_branch, base_branch=effective_base
+            )
 
         return PreparationResult(
             success=True,

{steerdev-1.1.29 → steerdev-1.1.43}/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")