steerdev 1.1.6__tar.gz → 1.1.7__tar.gz

{steerdev-1.1.6 → steerdev-1.1.7}/.github/workflows/publish.yml

@@ -53,7 +53,9 @@ jobs:
         run: uv build
 
       - name: Publish to PyPI
-        run: uv publish --trusted-publishing always
+        env:
+          UV_PUBLISH_TOKEN: ${{ secrets.UV_PUBLISH_TOKEN }}
+        run: uv publish
 
       - name: Create git tag and GitHub release
         env:

{steerdev-1.1.6 → steerdev-1.1.7}/PKG-INFO

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

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

{steerdev-1.1.6 → steerdev-1.1.7}/src/steerdev_agent/api/tasks.py

@@ -108,6 +108,7 @@ class TasksClient(SteerDevClient):
         self,
         project_id: str | None = None,
         agent_id: str | None = None,
+        wave_id: str | None = None,
     ) -> dict[str, Any] | None:
         """Fetch the next task with wave-aware scheduling.
 
@@ -117,6 +118,11 @@ class TasksClient(SteerDevClient):
         When agent_id is provided, the server uses conflict-aware scheduling
         to avoid assigning tasks that overlap files with in-flight tasks.
 
+        When wave_id is provided, scheduling is scoped to that wave: the server
+        returns tasks only from that wave and a 404 (→ None) once it is
+        exhausted, so the caller's loop stops instead of bleeding into another
+        wave or an unrelated task.
+
         Returns either:
         - A wave response dict (has "wave" and "context" keys) with full wave context
         - A plain task dict (no wave keys) when no waves exist for the project
@@ -125,6 +131,7 @@ class TasksClient(SteerDevClient):
         Args:
             project_id: Filter by project ID. Falls back to STEERDEV_PROJECT_ID env var.
             agent_id: Agent ID for conflict-aware scheduling.
+            wave_id: Scope scheduling to a single wave (sandbox wave dispatch).
 
         Returns:
             Wave response, plain task, or None.
@@ -136,6 +143,8 @@ class TasksClient(SteerDevClient):
             params["project_id"] = effective_project_id
         if agent_id:
             params["agent_id"] = agent_id
+        if wave_id:
+            params["wave_id"] = wave_id
 
         console.print(f"Fetching next task from {self.api_base}/tasks/next")
         response = self.get("/tasks/next", params=params)

{steerdev-1.1.6 → steerdev-1.1.7}/src/steerdev_agent/cli.py

@@ -1745,6 +1745,16 @@ def run(
             help="Run a specific task by ID (bypasses queue/wave scheduling)",
         ),
     ] = None,
+    wave_id: Annotated[
+        str | None,
+        typer.Option(
+            "--wave-id",
+            help=(
+                "Process every task of a specific wave, then stop. Scopes wave "
+                "scheduling to this wave (used by sandbox wave dispatch)."
+            ),
+        ),
+    ] = None,
 ) -> None:
     """Run the agent for a project!
 
@@ -1814,6 +1824,7 @@ def run(
     max_tasks_display = "unlimited" if max_tasks == 0 else str(max_tasks)
     workflow_status = resolved_workflow_id or "auto (per-task)"
     agent_name_display = agent_name or "(auto from env)"
+    wave_scope_display = wave_id or "(all waves)"
 
     console.print(
         Panel(
@@ -1826,6 +1837,7 @@ def run(
             f"Timeout: {resolved_timeout}s\n"
             f"Workflow: {workflow_status}\n"
             f"Waves: {waves_status}\n"
+            f"Wave Scope: {wave_scope_display}\n"
             f"Canals: {canals_status}\n"
             f"Worktrees: {worktree_status}\n"
             f"Evidence: {evidence_status}\n"
@@ -1872,6 +1884,7 @@ def run(
                 branch_config=resolved_branch_config,
                 task_id=task_id,
                 agent_id=agent_id,
+                wave_id=wave_id,
             )
         )
 

{steerdev-1.1.6 → steerdev-1.1.7}/src/steerdev_agent/runner.py

@@ -288,6 +288,7 @@ class Runner:
         shutdown_event: asyncio.Event | None = None,
         agent_id: str | None = None,
         task_id: str | None = None,
+        wave_id: str | None = None,
     ) -> None:
         """Initialize the runner.
 
@@ -310,6 +311,9 @@ class Runner:
             dry_run: If True, print the command without executing it.
             retry_config: Retry configuration for failed tasks.
             agent_id: Database agent ID for conflict-aware scheduling.
+            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.
         """
         self.project_id = project_id
         self.working_directory = Path(working_directory or Path.cwd())
@@ -336,6 +340,7 @@ class Runner:
         self._enable_canals = enable_canals
         self._agent_id = agent_id
         self._target_task_id = task_id
+        self._target_wave_id = wave_id
 
         # State
         self._state = RunState.STOPPED
@@ -1144,6 +1149,7 @@ class Runner:
                                         client.get_next_wave(
                                             project_id=self.project_id,
                                             agent_id=self._agent_id,
+                                            wave_id=self._target_wave_id,
                                         )
                                     )
                                 )
@@ -1153,7 +1159,10 @@ class Runner:
                                     exc_info=True,
                                 )
 
-                        if not task:
+                        # When scoped to a wave, never fall back to single-task
+                        # mode — an empty wave response means the wave is done, so
+                        # the loop should stop rather than pull an unrelated task.
+                        if not task and not self._target_wave_id:
                             task = client.get_next_task(
                                 project_id=self.project_id,
                                 agent_id=self._agent_id,
@@ -1412,6 +1421,7 @@ async def run_agent(
     branch_config: BranchConfig | None = None,
     task_id: str | None = None,
     agent_id: str | None = None,
+    wave_id: str | None = None,
 ) -> dict[str, Any]:
     """Run the steerdev agent.
 
@@ -1461,6 +1471,7 @@ async def run_agent(
         branch_config=branch_config,
         task_id=task_id,
         agent_id=agent_id,
+        wave_id=wave_id,
     )
 
     # Install signal handler that kills the subprocess immediately on Ctrl+C

steerdev-1.1.7/tests/test_wave_scoped_fetch.py

@@ -0,0 +1,60 @@
+"""Tests for wave-scoped task fetching (sandbox wave dispatch).
+
+`steerdev run --wave-id <id>` scopes scheduling to a single wave: the client
+passes `wave_id` to GET /tasks/next, and the server returns tasks only from that
+wave (404 → None once exhausted) so the run loop stops instead of bleeding into
+another wave or an unrelated task.
+"""
+
+from typing import Any
+from unittest.mock import MagicMock, patch
+
+import httpx
+
+from steerdev_agent.api.tasks import TasksClient
+
+
+def _make_response(
+    status_code: int,
+    json_body: dict[str, Any] | None = None,
+    text: str = "",
+) -> MagicMock:
+    resp = MagicMock(spec=httpx.Response)
+    resp.status_code = status_code
+    resp.text = text or (str(json_body) if json_body else "")
+    if json_body is not None:
+        resp.json.return_value = json_body
+    return resp
+
+
+class TestGetNextWaveScoping:
+    def test_wave_id_is_forwarded_as_param(self):
+        with TasksClient(api_key="test-key") as client:
+            mock_resp = _make_response(200, {"wave": {"id": "wave-1"}, "context": {}})
+            with patch.object(client, "get", return_value=mock_resp) as mock_get:
+                client.get_next_wave(
+                    project_id="proj-1",
+                    agent_id="agent-1",
+                    wave_id="wave-1",
+                )
+                params = mock_get.call_args.kwargs["params"]
+                assert params["wave_id"] == "wave-1"
+                assert params["waves"] == "true"
+                assert params["project_id"] == "proj-1"
+                assert params["agent_id"] == "agent-1"
+
+    def test_wave_id_omitted_when_not_scoped(self):
+        with TasksClient(api_key="test-key") as client:
+            mock_resp = _make_response(200, {"id": "task-1"})
+            with patch.object(client, "get", return_value=mock_resp) as mock_get:
+                client.get_next_wave(project_id="proj-1")
+                params = mock_get.call_args.kwargs["params"]
+                assert "wave_id" not in params
+
+    def test_exhausted_wave_returns_none_on_404(self):
+        # A wave-scoped request 404s once the wave is done — the loop stops.
+        with TasksClient(api_key="test-key") as client:
+            mock_resp = _make_response(404, text="No tasks available")
+            with patch.object(client, "get", return_value=mock_resp):
+                result = client.get_next_wave(project_id="proj-1", wave_id="wave-1")
+                assert result is None