steerdev 1.0.52__tar.gz → 1.0.56__tar.gz

{steerdev-1.0.52 → steerdev-1.0.56}/PKG-INFO

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

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

{steerdev-1.0.52 → steerdev-1.0.56}/src/steerdev_agent/agent_loop.py

@@ -85,6 +85,7 @@ class CommandExecutor:
     _shutdown_event: asyncio.Event
     _current_task: asyncio.Task[bool] | None
     _signal_count: int
+    _agent_id: str | None
     _commands_executed: int
     _commands_succeeded: int
     _commands_failed: int
@@ -179,6 +180,7 @@ class CommandExecutor:
             executor_config=self._executor_config,
             force_workflow_id=None,
             shutdown_event=self._shutdown_event,
+            agent_id=self._agent_id,
         )
 
         # Fetch task details

{steerdev-1.0.52 → steerdev-1.0.56}/src/steerdev_agent/api/tasks.py

@@ -65,7 +65,11 @@ def validate_status_transition(current: str, new: str) -> tuple[bool, str | None
 class TasksClient(SteerDevClient):
     """Client for task management operations."""
 
-    def get_next_task(self, project_id: str | None = None) -> dict[str, Any] | None:
+    def get_next_task(
+        self,
+        project_id: str | None = None,
+        agent_id: str | None = None,
+    ) -> dict[str, Any] | None:
         """Fetch the next task to work on (single-task mode, no waves).
 
         Returns the highest priority task in order:
@@ -75,6 +79,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.
 
         Returns:
             Task data dict or None if no tasks available.
@@ -84,6 +89,8 @@ class TasksClient(SteerDevClient):
         params: dict[str, str] = {"waves": "false"}
         if effective_project_id:
             params["project_id"] = effective_project_id
+        if agent_id:
+            params["agent_id"] = agent_id
 
         console.print(f"Fetching next task from {self.api_base}/tasks/next")
         response = self.get("/tasks/next", params=params if params else None)
@@ -97,12 +104,19 @@ class TasksClient(SteerDevClient):
 
         return response.json()
 
-    def get_next_wave(self, project_id: str | None = None) -> dict[str, Any] | None:
+    def get_next_wave(
+        self,
+        project_id: str | None = None,
+        agent_id: str | None = None,
+    ) -> dict[str, Any] | None:
         """Fetch the next task with wave-aware scheduling.
 
         Calls the API with waves=true. The API tries wave scheduling first,
         then falls back to returning a plain task if no waves exist.
 
+        When agent_id is provided, the server uses conflict-aware scheduling
+        to avoid assigning tasks that overlap files with in-flight tasks.
+
         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
@@ -110,6 +124,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.
 
         Returns:
             Wave response, plain task, or None.
@@ -119,6 +134,8 @@ class TasksClient(SteerDevClient):
         params: dict[str, str] = {"waves": "true"}
         if effective_project_id:
             params["project_id"] = effective_project_id
+        if agent_id:
+            params["agent_id"] = agent_id
 
         console.print(f"Fetching next task from {self.api_base}/tasks/next")
         response = self.get("/tasks/next", params=params)
@@ -413,6 +430,87 @@ class TasksClient(SteerDevClient):
         """
         return self.update_task(task_id, status="canceled", error_message=error_message)
 
+    def report_files(
+        self,
+        task_id: str,
+        actual_files: list[str] | None = None,
+        predicted_files: list[str] | None = None,
+    ) -> bool:
+        """Report files modified by this task for conflict detection.
+
+        Args:
+            task_id: Task ID to update.
+            actual_files: Files actually modified (from git diff).
+            predicted_files: Predicted files (from pre-analysis).
+
+        Returns:
+            True if update succeeded.
+        """
+        payload: dict[str, Any] = {}
+        if actual_files is not None:
+            payload["actual_files"] = actual_files
+        if predicted_files is not None:
+            payload["predicted_files"] = predicted_files
+        payload["source"] = "agent_reported"
+
+        if not payload:
+            return False
+
+        response = self.patch(f"/tasks/{task_id}/files", json=payload)
+        if response.status_code not in (200, 204):
+            logger.warning(f"Failed to report files for task {task_id}: {response.status_code}")
+            return False
+
+        logger.info(f"Reported {len(actual_files or [])} actual files for task {task_id}")
+        return True
+
+    def requeue_task(
+        self,
+        task_id: str,
+        conflict_files: list[str],
+        conflicting_task_id: str | None = None,
+        previous_branch: str | None = None,
+    ) -> bool:
+        """Re-queue a task due to merge conflict.
+
+        The server will increment the retry count and reset the task to unstarted.
+        Returns False if max retries exceeded (409 status).
+
+        Args:
+            task_id: Task ID to re-queue.
+            conflict_files: Files that caused the conflict.
+            conflicting_task_id: ID of the conflicting task, if known.
+            previous_branch: Branch name from the failed attempt.
+
+        Returns:
+            True if re-queue succeeded, False if max retries exceeded or error.
+        """
+        payload: dict[str, Any] = {
+            "conflict_files": conflict_files,
+        }
+        if conflicting_task_id:
+            payload["conflicting_task_id"] = conflicting_task_id
+        if previous_branch:
+            payload["previous_branch"] = previous_branch
+
+        response = self.post(f"/tasks/{task_id}/requeue", json=payload)
+
+        if response.status_code == 409:
+            logger.warning(f"Task {task_id} exceeded max conflict retries")
+            console.print(
+                f"[red]Task {task_id} has exceeded max conflict retries. "
+                f"Manual intervention required.[/red]"
+            )
+            return False
+
+        if response.status_code not in (200, 201):
+            logger.warning(f"Failed to requeue task {task_id}: {response.status_code}")
+            return False
+
+        logger.info(f"Task {task_id} re-queued due to merge conflict")
+        console.print(f"[yellow]Task {task_id} re-queued due to merge conflict[/yellow]")
+        return True
+
 
 def get_priority_display(priority: int | None) -> str:
     """Get human-readable priority display.

{steerdev-1.0.52 → steerdev-1.0.56}/src/steerdev_agent/cli.py

@@ -349,6 +349,54 @@ def tasks_create(
             raise typer.Exit(1) from None
 
 
+@tasks_app.command("requeue")
+def tasks_requeue(
+    task_id: Annotated[
+        str,
+        typer.Argument(help="Task ID (UUID) to re-queue"),
+    ],
+    conflict_files: Annotated[
+        str,
+        typer.Option("--files", "-f", help="Comma-separated list of conflicting file paths"),
+    ],
+    conflicting_task_id: Annotated[
+        str | None,
+        typer.Option("--conflicting-task-id", help="ID of the conflicting task"),
+    ] = None,
+    previous_branch: Annotated[
+        str | None,
+        typer.Option("--branch", "-b", help="Branch name from the failed attempt"),
+    ] = None,
+) -> None:
+    """Re-queue a task due to merge conflict.
+
+    Resets the task to 'unstarted' so it can be retried on a fresh base.
+    Fails with exit code 1 if max retries exceeded (requires manual intervention).
+    """
+    from steerdev_agent.api.tasks import TasksClient
+
+    files = [f.strip() for f in conflict_files.split(",") if f.strip()]
+    if not files:
+        console.print("[red]Error: At least one conflict file is required[/red]")
+        raise typer.Exit(1)
+
+    with TasksClient() as client:
+        if not client.check_api_key():
+            raise typer.Exit(1)
+
+        success = client.requeue_task(
+            task_id=task_id,
+            conflict_files=files,
+            conflicting_task_id=conflicting_task_id,
+            previous_branch=previous_branch,
+        )
+
+        if not success:
+            raise typer.Exit(1)
+
+        console.print(f"[green]Task {task_id} re-queued for retry[/green]")
+
+
 # ============================================================================
 # Hooks Command Group
 # ============================================================================

{steerdev-1.0.52 → steerdev-1.0.56}/src/steerdev_agent/runner.py

@@ -151,6 +151,32 @@ def resolve_merge_flow(
     return "single_task", "single-task-merge"
 
 
+async def _get_modified_files(working_dir: str | Path) -> list[str]:
+    """Get files modified in the current branch compared to the default branch.
+
+    Uses git diff to find files changed in the working tree and staged area.
+
+    Returns:
+        List of file paths relative to the repo root.
+    """
+    try:
+        proc = await asyncio.create_subprocess_exec(
+            "git",
+            "diff",
+            "--name-only",
+            "HEAD",
+            cwd=str(working_dir),
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+        stdout, _ = await proc.communicate()
+        files = [f for f in stdout.decode().strip().split("\n") if f]
+        return files
+    except Exception:
+        logger.debug("Failed to get modified files via git diff", exc_info=True)
+        return []
+
+
 def compute_worktree_name(task_id: str, wave_context: WaveContext | None = None) -> str:
     """Compute the git worktree name for a task execution.
 
@@ -252,6 +278,7 @@ class Runner:
         dry_run: bool = False,
         retry_config: RetryConfig | None = None,
         shutdown_event: asyncio.Event | None = None,
+        agent_id: str | None = None,
     ) -> None:
         """Initialize the runner.
 
@@ -273,6 +300,7 @@ class Runner:
             force_workflow_id: Workflow ID override for multi-phase execution.
             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.
         """
         self.project_id = project_id
         self.working_directory = Path(working_directory or Path.cwd())
@@ -296,6 +324,7 @@ class Runner:
         self._evidence_config = evidence_config or EvidenceConfig()
         self._enable_waves = enable_waves
         self._enable_canals = enable_canals
+        self._agent_id = agent_id
 
         # State
         self._state = RunState.STOPPED
@@ -590,11 +619,22 @@ class Runner:
             current_status = task.get("status", "")
             if current_status in ("unstarted", "backlog"):
                 with TasksClient(api_key=self._api_key) as tasks_client:
-                    if tasks_client.update_task(task_id, status="started"):
-                        logger.info(f"Task {task_id} marked as started")
-                        task["status"] = "started"
-                    else:
-                        logger.warning(f"Failed to mark task {task_id} as started")
+                    # backlog -> unstarted -> started (two-step transition)
+                    if current_status == "backlog":
+                        if tasks_client.update_task(task_id, status="unstarted"):
+                            logger.info(f"Task {task_id} moved from backlog to unstarted")
+                            task["status"] = "unstarted"
+                        else:
+                            logger.warning(
+                                f"Failed to move task {task_id} from backlog to unstarted"
+                            )
+
+                    if task.get("status") == "unstarted":
+                        if tasks_client.update_task(task_id, status="started"):
+                            logger.info(f"Task {task_id} marked as started")
+                            task["status"] = "started"
+                        else:
+                            logger.warning(f"Failed to mark task {task_id} as started")
 
         # Notify observer
         if self._observer:
@@ -762,6 +802,14 @@ class Runner:
                     else:
                         logger.warning(f"Failed to mark task {task_id} as completed")
 
+                    # Report actual files modified (for conflict-aware scheduling)
+                    try:
+                        actual_files = await _get_modified_files(effective_working_dir)
+                        if actual_files:
+                            tasks_client.report_files(task_id, actual_files=actual_files)
+                    except Exception:
+                        logger.debug("Failed to report modified files", exc_info=True)
+
             if self._evidence_config.enabled and not self.dry_run:
                 await self._submit_evidence_report(
                     task=task,
@@ -979,7 +1027,10 @@ class Runner:
                     if self._enable_waves:
                         try:
                             task, wave_ctx, suggested_workflow_id = extract_task_and_wave_context(
-                                client.get_next_wave(project_id=self.project_id)
+                                client.get_next_wave(
+                                    project_id=self.project_id,
+                                    agent_id=self._agent_id,
+                                )
                             )
                         except Exception:
                             logger.debug(
@@ -988,7 +1039,10 @@ class Runner:
                             )
 
                     if not task:
-                        task = client.get_next_task(project_id=self.project_id)
+                        task = client.get_next_task(
+                            project_id=self.project_id,
+                            agent_id=self._agent_id,
+                        )
 
                 if not task:
                     if self._tasks_executed == 0:

{steerdev-1.0.52 → steerdev-1.0.56}/src/steerdev_agent/setup/templates/skills/steerdev-merge-into-canal-skill/SKILL.md

@@ -20,6 +20,26 @@ Use this skill when a workflow phase tells you to merge the **current task branc
 
 Before merging into a canal, verify your current branch has been pushed and has a PR. Do NOT switch branches or sync to main — this skill operates on the current task/wave branch.
 
+## Rebase Before Canal Merge
+
+Before merging into the canal, ensure your branch is up to date:
+
+```bash
+git fetch origin main
+git merge-tree --write-tree origin/main HEAD
+```
+
+- **If clean** (exit 0): Rebase and force-push with lease:
+  ```bash
+  git rebase origin/main
+  git push --force-with-lease origin HEAD
+  ```
+- **If conflicts**: Attempt rebase. If it fails on files you did not modify, abort (`git rebase --abort`) and re-queue the task:
+  ```bash
+  steerdev tasks requeue TASK_ID --files "conflicting/file1.ts,conflicting/file2.ts" --branch "$(git branch --show-current)"
+  ```
+  Do NOT force-push to resolve canal conflicts. If re-queue fails, report as a blocker.
+
 ## Workflow
 
 1. Confirm the workflow phase says the branch is ready for canal integration

{steerdev-1.0.52 → steerdev-1.0.56}/src/steerdev_agent/setup/templates/skills/steerdev-single-task-merge-skill/SKILL.md

@@ -56,12 +56,36 @@ This fetches the task from the API and builds the branch name automatically:
 
 3. Implement the requested changes
 4. Commit with a conventional commit message that explains why the change exists
-5. Push the current branch:
+5. Rebase onto the latest target branch before pushing:
 
 ```bash
-git push -u origin HEAD
+git fetch origin main
 ```
 
+Dry-run merge check (requires git 2.38+):
+```bash
+git merge-tree --write-tree origin/main HEAD
+```
+
+- **If exit code 0** (clean merge): Rebase and push:
+  ```bash
+  git rebase origin/main
+  git push -u origin HEAD
+  ```
+
+- **If exit code non-zero** (conflicts detected): Attempt rebase:
+  ```bash
+  git rebase origin/main
+  ```
+  - If rebase succeeds after resolving conflicts in files you modified: `git push --force-with-lease origin HEAD`
+  - If conflicts are in files you did NOT modify: abort the rebase (`git rebase --abort`) and re-queue the task for a fresh attempt:
+    ```bash
+    steerdev tasks requeue TASK_ID --files "path/to/file1.ts,path/to/file2.ts" --branch "$(git branch --show-current)"
+    ```
+    If re-queue fails (max retries exceeded), report as a blocker using `steerdev activity report`.
+
+**Fallback** (if `git merge-tree` is unavailable): Skip the dry-run and rebase directly. If rebase fails, abort and re-queue as above.
+
 6. Create the pull request:
 
 ```bash

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

@@ -54,12 +54,36 @@ git commit -m "[PROJ-123] feat: add user endpoint"
 git commit -m "[task:abc12345] feat: add user endpoint"
 ```
 
-3. After the wave work is ready for review, push the shared branch:
+3. After the wave work is ready for review, rebase onto the latest target branch:
 
 ```bash
-git push -u origin HEAD
+git fetch origin main
 ```
 
+Dry-run merge check (requires git 2.38+):
+```bash
+git merge-tree --write-tree origin/main HEAD
+```
+
+- **If exit code 0** (clean merge): Rebase and push:
+  ```bash
+  git rebase origin/main
+  git push -u origin HEAD
+  ```
+
+- **If exit code non-zero** (conflicts detected): Attempt rebase:
+  ```bash
+  git rebase origin/main
+  ```
+  - If rebase succeeds after resolving conflicts in files you modified: `git push --force-with-lease origin HEAD`
+  - If conflicts are in files you did NOT modify: abort the rebase (`git rebase --abort`) and re-queue the current task:
+    ```bash
+    steerdev tasks requeue TASK_ID --files "path/to/file1.ts,path/to/file2.ts" --branch "$(git branch --show-current)"
+    ```
+    If re-queue fails (max retries exceeded), report as a blocker using `steerdev activity report`.
+
+**Fallback** (if `git merge-tree` is unavailable): Skip the dry-run and rebase directly. If rebase fails, abort and re-queue as above.
+
 4. Create one pull request for the wave:
 
 ```bash