steerdev 1.0.60__tar.gz → 1.1.3__tar.gz

{steerdev-1.0.60 → steerdev-1.1.3}/PKG-INFO

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

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

{steerdev-1.0.60 → steerdev-1.1.3}/src/steerdev_agent/prompt/builder.py

@@ -24,6 +24,7 @@ class WaveContext(BaseModel):
 
     wave_number: int = Field(description="Current wave number")
     total_waves: int = Field(description="Total number of waves")
+    wave_name: str = Field(default="", description="Unique wave name (e.g., wave-532d5c)")
     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")

{steerdev-1.0.60 → steerdev-1.1.3}/src/steerdev_agent/runner.py

@@ -111,6 +111,7 @@ def build_wave_context(wave_response: dict[str, Any]) -> WaveContext | None:
     return WaveContext(
         wave_number=wave_info.get("wave_number", 1),
         total_waves=wave_info.get("total_waves", 1),
+        wave_name=wave_info.get("name", ""),
         wave_description=wave_info.get("description", ""),
         wave_tasks_summary=tasks_summary,
         completed_waves_summary=completed_summary,
@@ -187,13 +188,13 @@ def compute_worktree_name(task_id: str, wave_context: WaveContext | None = None)
     """Compute the git worktree name for a task execution.
 
     Naming conventions:
-    - Wave-based: "wave-{wave_number}" (e.g., "wave-3")
+    - Wave-based: "{wave_name}" (e.g., "wave-532d5c")
     - Task-based: "task-{first_8_chars}" (e.g., "task-abc12345")
 
     The worktree lifecycle is managed by Claude CLI via the --worktree flag.
     """
     if wave_context:
-        return f"wave-{wave_context.wave_number}"
+        return wave_context.wave_name or f"wave-{wave_context.wave_number}"
     task_short = task_id[:8] if len(task_id) > 8 else task_id
     return f"task-{task_short}"
 
@@ -643,7 +644,7 @@ class Runner:
 
         wave_id: str | None = None
         if wave_context:
-            wave_id = f"wave-{wave_context.wave_number}"
+            wave_id = wave_context.wave_name or f"wave-{wave_context.wave_number}"
 
         try:
             with ReportsClient(api_key=self._api_key) as client:

{steerdev-1.0.60 → steerdev-1.1.3}/src/steerdev_agent/workspace/preparation.py

@@ -35,6 +35,8 @@ class PreparationResult:
     is_worktree: bool
     error: str | None = None
     warnings: list[str] = field(default_factory=list)
+    repo_directories: list[Path] = field(default_factory=list)
+    """For multi-repo workspaces, the list of prepared git repositories."""
 
 
 async def _run_git(
@@ -145,13 +147,23 @@ class WorkspacePreparation:
         default_branch: str,
         wave_context: WaveContext | None,
     ) -> PreparationResult:
-        """Prepare workspace in the main repository directory."""
+        """Prepare workspace in the main repository directory.
+
+        If the working directory is not itself a git repository, discovers
+        git repos in immediate subdirectories (multi-repo layout) and
+        prepares each one.
+        """
         cwd = self.working_directory
-        warnings: list[str] = []
 
-        # 1. Validate git repo
+        # 1. Check if working directory is a git repo
         rc, _, _ = await _run_git("rev-parse", "--is-inside-work-tree", cwd=cwd, check=False)
-        if rc != 0:
+        if rc == 0:
+            # Single-repo layout: prepare in place
+            return await self._prepare_single_repo(cwd, target_branch, default_branch, wave_context)
+
+        # Not a git repo — check for multi-repo layout (subdirectories that are git repos)
+        repos = await self._discover_git_repos(cwd)
+        if not repos:
             return PreparationResult(
                 success=False,
                 branch_name=target_branch,
@@ -161,10 +173,120 @@ class WorkspacePreparation:
                 error=f"Not a git repository: {cwd}",
             )
 
-        # 2. Check current branch
+        # Multi-repo layout: prepare each discovered repo
+        return await self._prepare_multi_repo(repos, target_branch, default_branch, wave_context)
+
+    async def _discover_git_repos(self, directory: Path) -> list[Path]:
+        """Discover git repositories in immediate subdirectories.
+
+        Args:
+            directory: Parent directory to scan.
+
+        Returns:
+            Sorted list of paths that are git repositories.
+        """
+        repos: list[Path] = []
+        try:
+            for entry in sorted(directory.iterdir()):
+                if entry.is_dir() and not entry.name.startswith("."):
+                    rc, _, _ = await _run_git(
+                        "rev-parse", "--is-inside-work-tree", cwd=entry, check=False
+                    )
+                    if rc == 0:
+                        repos.append(entry)
+        except OSError as exc:
+            logger.warning(f"Failed to scan directory {directory}: {exc}")
+        return repos
+
+    async def _prepare_multi_repo(
+        self,
+        repos: list[Path],
+        target_branch: str,
+        default_branch: str,
+        wave_context: WaveContext | None,
+    ) -> PreparationResult:
+        """Prepare multiple git repositories in a workspace directory.
+
+        Applies the same branch preparation to each discovered repo.
+        Returns success only if all repos are prepared successfully.
+
+        Args:
+            repos: List of git repository paths to prepare.
+            target_branch: Target branch name for the task.
+            default_branch: Default branch to sync from.
+            wave_context: Optional wave context.
+
+        Returns:
+            PreparationResult with the parent directory as working_directory.
+        """
+        parent_dir = self.working_directory
+        all_warnings: list[str] = []
+        prepared_repos: list[Path] = []
+
+        logger.info(
+            f"Multi-repo workspace detected at {parent_dir}: preparing {len(repos)} repositories"
+        )
+
+        for repo_path in repos:
+            repo_name = repo_path.name
+            logger.info(f"Preparing repository: {repo_name}")
+
+            result = await self._prepare_single_repo(
+                repo_path, target_branch, default_branch, wave_context
+            )
+
+            if not result.success:
+                return PreparationResult(
+                    success=False,
+                    branch_name=target_branch,
+                    working_directory=parent_dir,
+                    default_branch=default_branch,
+                    is_worktree=False,
+                    error=f"Failed to prepare repo {repo_name}: {result.error}",
+                    repo_directories=prepared_repos,
+                )
+
+            prepared_repos.append(repo_path)
+            # Prefix per-repo warnings with the repo name for clarity
+            for warning in result.warnings:
+                all_warnings.append(f"[{repo_name}] {warning}")
+
+        logger.info(f"Multi-repo workspace ready: {len(prepared_repos)} repositories prepared")
+
+        return PreparationResult(
+            success=True,
+            branch_name=target_branch,
+            working_directory=parent_dir,
+            default_branch=default_branch,
+            is_worktree=False,
+            warnings=all_warnings,
+            repo_directories=prepared_repos,
+        )
+
+    async def _prepare_single_repo(
+        self,
+        cwd: Path,
+        target_branch: str,
+        default_branch: str,
+        wave_context: WaveContext | None,
+    ) -> PreparationResult:
+        """Prepare a single git repository directory.
+
+        Args:
+            cwd: Path to the git repository.
+            target_branch: Target branch name for the task.
+            default_branch: Default branch to sync from.
+            wave_context: Optional wave context.
+
+        Returns:
+            PreparationResult for this repository.
+        """
+        warnings: list[str] = []
+
+        # 1. Check current branch
         _, current_branch, _ = await _run_git("branch", "--show-current", cwd=cwd, check=False)
 
-        # 3. If continuing a wave on the same branch, just fetch
+        # 2. If continuing a wave on the same branch, just fetch
         if wave_context and current_branch == target_branch:
             logger.info(f"Continuing wave on branch {target_branch}, fetching only")
             await _run_git("fetch", "origin", cwd=cwd, check=False)
@@ -176,17 +298,17 @@ class WorkspacePreparation:
                 is_worktree=False,
             )
 
-        # 4. Stash if dirty
+        # 3. Stash if dirty
         rc, status_output, _ = await _run_git("status", "--porcelain", cwd=cwd, check=False)
         if status_output:
             logger.info("Working directory dirty, stashing changes")
             await _run_git("stash", "push", "-m", "steerdev-preflight", cwd=cwd, check=False)
             warnings.append("Stashed uncommitted changes (steerdev-preflight)")
 
-        # 5. Fetch from origin
+        # 4. Fetch from origin
         await _run_git("fetch", "origin", cwd=cwd, check=False)
 
-        # 6. Sync to default branch
+        # 5. Sync to default branch
         rc, _, _ = await _run_git("checkout", default_branch, cwd=cwd, check=False)
         if rc != 0:
             return PreparationResult(
@@ -210,7 +332,7 @@ class WorkspacePreparation:
                 f"Fast-forward failed, reset {default_branch} to origin/{default_branch}"
             )
 
-        # 7. Create or checkout target branch
+        # 6. Create or checkout target branch
         rc, _, _ = await _run_git("rev-parse", "--verify", target_branch, cwd=cwd, check=False)
         branch_exists = rc == 0
 
@@ -221,7 +343,7 @@ class WorkspacePreparation:
             await _run_git("checkout", "-b", target_branch, cwd=cwd)
             logger.info(f"Created new branch: {target_branch}")
 
-        # 8. Validate current branch
+        # 7. Validate current branch
         _, actual_branch, _ = await _run_git("branch", "--show-current", cwd=cwd, check=False)
         if actual_branch != target_branch:
             return PreparationResult(

{steerdev-1.0.60 → steerdev-1.1.3}/src/steerdev_agent/worktree.py

@@ -213,7 +213,7 @@ def compute_branch_name(
     """Compute the branch name for a task or wave.
 
     Naming conventions aligned with merge skill branch patterns:
-    - Wave: "wave/{wave_number}" (e.g., "wave/3")
+    - Wave: "{wave_name}" (e.g., "wave-532d5c")
     - Task with external ID: "task/{TICKET-ID}-{slug}" (e.g., "task/PROJ-123-add-auth")
     - Task without external ID: "task/{short-id}-{slug}" (e.g., "task/abc12345-add-auth")
 
@@ -225,7 +225,7 @@ def compute_branch_name(
         Branch name string.
     """
     if wave_context:
-        return f"wave/{wave_context.wave_number}"
+        return wave_context.wave_name or f"wave-{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.0.60 → steerdev-1.1.3}/tests/test_preparation.py

@@ -211,7 +211,7 @@ class TestWorkspacePreparationInPlace:
         """Continuing a wave stays on the wave branch, only fetches."""
         from steerdev_agent.prompt.builder import WaveContext
 
-        wave_ctx = WaveContext(wave_number=3, total_waves=5)
+        wave_ctx = WaveContext(wave_number=3, total_waves=5, wave_name="wave-a1b2c3")
 
         prep = WorkspacePreparation(
             working_directory=Path("/tmp/repo"),
@@ -227,7 +227,7 @@ class TestWorkspacePreparationInPlace:
             if "rev-parse --is-inside-work-tree" in cmd:
                 return (0, "true", "")
             if "branch --show-current" in cmd:
-                return (0, "wave/3", "")  # Already on wave branch
+                return (0, "wave-a1b2c3", "")  # Already on wave branch
             if "fetch origin" in cmd:
                 return (0, "", "")
             return (0, "", "")
@@ -236,7 +236,7 @@ class TestWorkspacePreparationInPlace:
             result = await prep.prepare(sample_task, wave_ctx)
 
         assert result.success is True
-        assert result.branch_name == "wave/3"
+        assert result.branch_name == "wave-a1b2c3"
         # Should NOT have checkout commands (stayed on branch)
         checkout_cmds = [c for c in calls if c[0] == "checkout"]
         assert len(checkout_cmds) == 0
@@ -290,10 +290,12 @@ class TestWorkspacePreparationInPlace:
         assert len(stash_cmds) > 0
 
     @pytest.mark.asyncio
-    async def test_not_git_repo_fails(self, worktree_disabled, default_config, sample_task):
-        """Non-git directory returns failure."""
+    async def test_not_git_repo_no_subrepos_fails(
+        self, worktree_disabled, default_config, sample_task, tmp_path
+    ):
+        """Non-git directory with no sub-repos returns failure."""
         prep = WorkspacePreparation(
-            working_directory=Path("/tmp/not-a-repo"),
+            working_directory=tmp_path,
             worktree_config=worktree_disabled,
             branch_config=default_config,
         )
@@ -356,3 +358,307 @@ class TestWorkspacePreparationInPlace:
         reset_cmds = [c for c in calls if "reset" in " ".join(c)]
         assert len(reset_cmds) > 0
         assert any("fast-forward" in w.lower() or "reset" in w.lower() for w in result.warnings)
+
+
+class TestWorkspacePreparationMultiRepo:
+    """Tests for multi-repo workspace preparation."""
+
+    @pytest.fixture
+    def worktree_disabled(self):
+        return WorktreeConfig(enabled=False)
+
+    @pytest.fixture
+    def default_config(self):
+        return BranchConfig(default_branch="main")
+
+    @pytest.fixture
+    def sample_task(self):
+        return {
+            "id": "abc12345-6789-0000-0000-000000000000",
+            "title": "Add user authentication",
+            "prompt": "Implement user auth",
+            "status": "started",
+        }
+
+    @pytest.mark.asyncio
+    async def test_multi_repo_discovers_and_prepares_all(
+        self, worktree_disabled, default_config, sample_task, tmp_path
+    ):
+        """Multi-repo layout: discovers sub-repos and prepares each one."""
+        # Create subdirectories to simulate multi-repo layout
+        (tmp_path / "repo_a").mkdir()
+        (tmp_path / "repo_b").mkdir()
+        (tmp_path / ".hidden").mkdir()  # should be skipped
+
+        prep = WorkspacePreparation(
+            working_directory=tmp_path,
+            worktree_config=worktree_disabled,
+            branch_config=default_config,
+        )
+
+        calls: list[tuple[tuple[str, ...], Path]] = []
+
+        async def mock_run_git(*args, cwd, check=True):
+            calls.append((args, Path(cwd)))
+            cmd = " ".join(args)
+            cwd_path = Path(cwd)
+
+            if "rev-parse --is-inside-work-tree" in cmd:
+                # Parent dir is NOT a repo; subdirs ARE repos
+                if cwd_path == tmp_path:
+                    return (128, "", "fatal: not a git repository")
+                if cwd_path.name in ("repo_a", "repo_b"):
+                    return (0, "true", "")
+                return (128, "", "fatal: not a git repository")
+            if "branch --show-current" in cmd:
+                # Track per-repo calls to return correct branch after checkout
+                show_current_calls = [
+                    c
+                    for c in calls
+                    if "branch --show-current" in " ".join(c[0]) and c[1] == cwd_path
+                ]
+                if len(show_current_calls) <= 1:
+                    return (0, "main", "")
+                return (0, "task/abc12345-add-user-authentication", "")
+            if "status --porcelain" in cmd:
+                return (0, "", "")
+            if "fetch origin" in cmd:
+                return (0, "", "")
+            if "checkout main" in cmd:
+                return (0, "", "")
+            if "merge --ff-only" in cmd:
+                return (0, "", "")
+            if "rev-parse --verify" in cmd:
+                return (1, "", "")  # branch doesn't exist
+            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):
+            result = await prep.prepare(sample_task)
+
+        assert result.success is True
+        assert result.working_directory == tmp_path  # parent dir preserved
+        assert len(result.repo_directories) == 2
+        assert tmp_path / "repo_a" in result.repo_directories
+        assert tmp_path / "repo_b" in result.repo_directories
+        # Verify git operations ran against both repos
+        repo_a_checkouts = [
+            c for c in calls if c[1] == tmp_path / "repo_a" and "checkout -b" in " ".join(c[0])
+        ]
+        repo_b_checkouts = [
+            c for c in calls if c[1] == tmp_path / "repo_b" and "checkout -b" in " ".join(c[0])
+        ]
+        assert len(repo_a_checkouts) == 1
+        assert len(repo_b_checkouts) == 1
+
+    @pytest.mark.asyncio
+    async def test_multi_repo_fails_if_one_repo_fails(
+        self, worktree_disabled, default_config, sample_task, tmp_path
+    ):
+        """Multi-repo: failure in one repo fails the whole preparation."""
+        (tmp_path / "repo_a").mkdir()
+        (tmp_path / "repo_b").mkdir()
+
+        prep = WorkspacePreparation(
+            working_directory=tmp_path,
+            worktree_config=worktree_disabled,
+            branch_config=default_config,
+        )
+
+        # Track per-repo branch --show-current calls
+        branch_calls_per_repo: dict[str, int] = {}
+
+        async def mock_run_git(*args, cwd, check=True):
+            cmd = " ".join(args)
+            cwd_path = Path(cwd)
+            repo_name = cwd_path.name
+
+            if "rev-parse --is-inside-work-tree" in cmd:
+                if cwd_path == tmp_path:
+                    return (128, "", "fatal: not a git repository")
+                if repo_name in ("repo_a", "repo_b"):
+                    return (0, "true", "")
+                return (128, "", "")
+            if "branch --show-current" in cmd:
+                branch_calls_per_repo[repo_name] = branch_calls_per_repo.get(repo_name, 0) + 1
+                if branch_calls_per_repo[repo_name] <= 1:
+                    return (0, "main", "")
+                return (0, "task/abc12345-add-user-authentication", "")
+            if "status --porcelain" in cmd:
+                return (0, "", "")
+            if "fetch origin" in cmd:
+                return (0, "", "")
+            if "checkout main" in cmd:
+                # repo_b fails to checkout default branch
+                if repo_name == "repo_b":
+                    return (1, "", "error: pathspec 'main' did not match")
+                return (0, "", "")
+            if "merge --ff-only" in cmd:
+                return (0, "", "")
+            if "rev-parse --verify" in cmd:
+                return (1, "", "")
+            if "checkout -b" in cmd:
+                return (0, "", "")
+            return (0, "", "")
+
+        with patch("steerdev_agent.workspace.preparation._run_git", side_effect=mock_run_git):
+            result = await prep.prepare(sample_task)
+
+        assert result.success is False
+        assert "repo_b" in (result.error or "")
+        # repo_a was prepared before repo_b failed
+        assert len(result.repo_directories) == 1
+        assert tmp_path / "repo_a" in result.repo_directories
+
+    @pytest.mark.asyncio
+    async def test_multi_repo_collects_warnings_with_prefix(
+        self, worktree_disabled, default_config, sample_task, tmp_path
+    ):
+        """Multi-repo: warnings are prefixed with repo name."""
+        (tmp_path / "repo_a").mkdir()
+
+        prep = WorkspacePreparation(
+            working_directory=tmp_path,
+            worktree_config=worktree_disabled,
+            branch_config=default_config,
+        )
+
+        branch_call_count = [0]
+
+        async def mock_run_git(*args, cwd, check=True):
+            cmd = " ".join(args)
+            cwd_path = Path(cwd)
+
+            if "rev-parse --is-inside-work-tree" in cmd:
+                if cwd_path == tmp_path:
+                    return (128, "", "fatal: not a git repository")
+                return (0, "true", "")
+            if "branch --show-current" in cmd:
+                # Return target branch on validation check
+                branch_call_count[0] += 1
+                if branch_call_count[0] > 1:
+                    return (0, "task/abc12345-add-user-authentication", "")
+                return (0, "main", "")
+            if "status --porcelain" in cmd:
+                return (0, "M  dirty.py", "")  # dirty repo
+            if "stash push" in cmd:
+                return (0, "", "")
+            if "fetch origin" in cmd:
+                return (0, "", "")
+            if "checkout main" in cmd:
+                return (0, "", "")
+            if "merge --ff-only" in cmd:
+                return (0, "", "")
+            if "rev-parse --verify" in cmd:
+                return (1, "", "")
+            if "checkout -b" in cmd:
+                return (0, "", "")
+            return (0, "", "")
+
+        with patch("steerdev_agent.workspace.preparation._run_git", side_effect=mock_run_git):
+            result = await prep.prepare(sample_task)
+
+        assert result.success is True
+        assert any("[repo_a]" in w for w in result.warnings)
+
+    @pytest.mark.asyncio
+    async def test_multi_repo_skips_hidden_and_non_repo_dirs(
+        self, worktree_disabled, default_config, sample_task, tmp_path
+    ):
+        """Multi-repo: hidden dirs and non-repo dirs are skipped."""
+        (tmp_path / ".hidden_repo").mkdir()
+        (tmp_path / "not_a_repo").mkdir()
+        (tmp_path / "actual_repo").mkdir()
+
+        prep = WorkspacePreparation(
+            working_directory=tmp_path,
+            worktree_config=worktree_disabled,
+            branch_config=default_config,
+        )
+
+        calls_by_cwd: dict[str, list[str]] = {}
+
+        async def mock_run_git(*args, cwd, check=True):
+            cmd = " ".join(args)
+            cwd_path = Path(cwd)
+            calls_by_cwd.setdefault(cwd_path.name, []).append(cmd)
+
+            if "rev-parse --is-inside-work-tree" in cmd:
+                if cwd_path == tmp_path:
+                    return (128, "", "fatal: not a git repository")
+                if cwd_path.name == "actual_repo":
+                    return (0, "true", "")
+                return (128, "", "fatal: not a git repository")
+            if "branch --show-current" in cmd:
+                branch_calls = [
+                    c for c in calls_by_cwd.get(cwd_path.name, []) if "branch --show-current" in c
+                ]
+                if len(branch_calls) <= 1:
+                    return (0, "main", "")
+                return (0, "task/abc12345-add-user-authentication", "")
+            if "status --porcelain" in cmd:
+                return (0, "", "")
+            if "fetch origin" in cmd:
+                return (0, "", "")
+            if "checkout main" in cmd:
+                return (0, "", "")
+            if "merge --ff-only" in cmd:
+                return (0, "", "")
+            if "rev-parse --verify" in cmd:
+                return (1, "", "")
+            if "checkout -b" in cmd:
+                return (0, "", "")
+            return (0, "", "")
+
+        with patch("steerdev_agent.workspace.preparation._run_git", side_effect=mock_run_git):
+            result = await prep.prepare(sample_task)
+
+        assert result.success is True
+        assert len(result.repo_directories) == 1
+        assert tmp_path / "actual_repo" in result.repo_directories
+        # Hidden dir should never have been checked
+        assert ".hidden_repo" not in calls_by_cwd
+
+    @pytest.mark.asyncio
+    async def test_single_repo_still_works(self, worktree_disabled, default_config, sample_task):
+        """Single-repo layout still works as before (no regressions)."""
+        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 len([c for c in calls if "branch --show-current" in " ".join(c)]) <= 1:
+                    return (0, "main", "")
+                return (0, "task/abc12345-add-user-authentication", "")
+            if "status --porcelain" in cmd:
+                return (0, "", "")
+            if "fetch origin" in cmd:
+                return (0, "", "")
+            if "checkout main" in cmd:
+                return (0, "", "")
+            if "merge --ff-only" in cmd:
+                return (0, "", "")
+            if "rev-parse --verify" in cmd:
+                return (1, "", "")
+            if "checkout -b" in cmd:
+                return (0, "", "")
+            return (0, "", "")
+
+        with patch("steerdev_agent.workspace.preparation._run_git", side_effect=mock_run_git):
+            result = await prep.prepare(sample_task)
+
+        assert result.success is True
+        assert result.repo_directories == []  # single-repo: no repo_directories
+        assert result.working_directory == Path("/tmp/repo")

{steerdev-1.0.60 → steerdev-1.1.3}/tests/test_runner_merge_modes.py

@@ -12,6 +12,7 @@ def _make_wave_context() -> WaveContext:
     return WaveContext(
         wave_number=3,
         total_waves=5,
+        wave_name="wave-a1b2c3",
         wave_description="User management improvements",
         wave_tasks_summary="  [todo] Add user endpoint",
         completed_waves_summary="  - Wave 2: Auth cleanup",
@@ -23,6 +24,7 @@ def _make_wave_response(task_id: str = "task-123") -> dict:
         "wave": {
             "wave_number": 3,
             "total_waves": 5,
+            "name": "wave-a1b2c3",
             "description": "User management improvements",
         },
         "context": {

{steerdev-1.0.60 → steerdev-1.1.3}/tests/test_runner_worktrees.py

@@ -25,13 +25,13 @@ class TestComputeBranchName:
 
     def test_wave_based(self):
         task = {"id": "abc123", "title": "Something"}
-        wave = WaveContext(wave_number=3, total_waves=5)
-        assert compute_branch_name(task, wave) == "wave/3"
+        wave = WaveContext(wave_number=3, total_waves=5, wave_name="wave-a1b2c3")
+        assert compute_branch_name(task, wave) == "wave-a1b2c3"
 
     def test_wave_takes_precedence(self):
         task = {"id": "abc12345xyz", "title": "Add auth", "linear_identifier": "PROJ-123"}
-        wave = WaveContext(wave_number=2, total_waves=4)
-        assert compute_branch_name(task, wave) == "wave/2"
+        wave = WaveContext(wave_number=2, total_waves=4, wave_name="wave-f1e2d3")
+        assert compute_branch_name(task, wave) == "wave-f1e2d3"
 
     def test_title_slugified(self):
         task = {"id": "abc12345xyz", "title": "Add User Authentication & OAuth 2.0"}

{steerdev-1.0.60 → steerdev-1.1.3}/tests/test_worktree.py

@@ -37,8 +37,8 @@ class TestComputeBranchName:
         from steerdev_agent.prompt.builder import WaveContext
 
         task = {"id": "abc", "title": "test"}
-        wave = WaveContext(wave_number=5, total_waves=10)
-        assert compute_branch_name(task, wave) == "wave/5"
+        wave = WaveContext(wave_number=5, total_waves=10, wave_name="wave-d4e5f6")
+        assert compute_branch_name(task, wave) == "wave-d4e5f6"
 
     def test_task_with_linear_id(self):
         task = {"id": "abc12345xyz", "title": "Add auth", "linear_identifier": "PROJ-42"}