steerdev 1.1.31__tar.gz → 1.1.43__tar.gz

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

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

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

@@ -338,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.
 
@@ -363,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())
@@ -390,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
@@ -836,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:
@@ -1053,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:
@@ -1510,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.
 
@@ -1560,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.31 → steerdev-1.1.43}/src/steerdev_agent/setup/templates/skills/steerdev-wave-tasks-merge-skill/SKILL.md

@@ -63,6 +63,23 @@ 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-1.1.31 → 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,39 +391,36 @@ class WorkspacePreparation:
         # 4. Fetch from origin
         await _run_git("fetch", "origin", cwd=cwd, check=False)
 
-        # 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 the target (wave) branch.
+        # 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 = rc == 0
+        branch_exists_local = rc == 0
+
+        rc, _, _ = await _run_git(
+            "rev-parse", "--verify", f"origin/{target_branch}", cwd=cwd, check=False
+        )
+        branch_exists_origin = rc == 0
 
-        if branch_exists:
-            # Branch already present locally (e.g. a continuing wave on a fresh
-            # clone): just switch to it.
+        is_continuation = False
+        effective_base = default_branch
+
+        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(
@@ -391,11 +432,13 @@ class WorkspacePreparation:
                     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.
+        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/{effective_base}", cwd=cwd, check=False
+                "checkout", "-b", target_branch, f"origin/{target_branch}", cwd=cwd, check=False
             )
             if rc != 0:
                 return PreparationResult(
@@ -404,36 +447,124 @@ class WorkspacePreparation:
                     working_directory=cwd,
                     default_branch=default_branch,
                     is_worktree=False,
-                    error=f"Failed to cut {target_branch} from origin/{effective_base}",
+                    error=f"Failed to track existing branch origin/{target_branch}",
                 )
-            logger.info(f"Created {target_branch} stacked on origin/{effective_base}")
+            logger.info(f"Continuing wave branch from origin/{target_branch}")
         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?",
+            # 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."
+                    )
 
-            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"
+            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,
                 )
-                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}"
+                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}")
+                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)
@@ -447,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=effective_base
-        )
+        # 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,