steerdev 1.1.14__tar.gz → 1.1.25__tar.gz

{steerdev-1.1.14 → steerdev-1.1.25}/.github/workflows/publish.yml

@@ -56,7 +56,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.14 → steerdev-1.1.25}/PKG-INFO

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

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

{steerdev-1.1.14 → steerdev-1.1.25}/src/steerdev_agent/api/hooks.py

@@ -8,6 +8,7 @@ from typing import Any
 import httpx
 
 from steerdev_agent.api.client import get_agent_name, get_api_endpoint, get_api_key
+from steerdev_agent.git_ops import checkpoint_push, is_git_commit_command
 
 
 class HooksClient:
@@ -167,3 +168,29 @@ class HooksClient:
             },
         )
         sys.exit(0)
+
+    def post_tool_use(self) -> None:
+        """Process PostToolUse hook event for checkpoint pushes.
+
+        If the tool was a Bash `git commit`, push the current branch to
+        origin as a checkpoint so sandbox work survives a VM teardown.
+        Best-effort: always exits 0, never blocks the agent. Does not
+        report to the activity API.
+        """
+        input_data = self.read_stdin_input()
+        if not isinstance(input_data, dict):
+            sys.exit(0)
+
+        if input_data.get("tool_name") != "Bash":
+            sys.exit(0)
+
+        tool_input = input_data.get("tool_input")
+        if not isinstance(tool_input, dict):
+            sys.exit(0)
+        command = tool_input.get("command")
+        if not is_git_commit_command(command):
+            sys.exit(0)
+
+        cwd = input_data.get("cwd") or "."
+        checkpoint_push(cwd)
+        sys.exit(0)

{steerdev-1.1.14 → steerdev-1.1.25}/src/steerdev_agent/api/tasks.py

@@ -223,6 +223,8 @@ class TasksClient(SteerDevClient):
         result_summary: str | None = None,
         error_message: str | None = None,
         comment: str | None = None,
+        branch: str | None = None,
+        base_branch: str | None = None,
     ) -> bool:
         """Update a task's fields.
 
@@ -235,6 +237,8 @@ class TasksClient(SteerDevClient):
             result_summary: Result summary for completed tasks.
             error_message: Error message for failed tasks.
             comment: Comment to add.
+            branch: Task branch name (provenance).
+            base_branch: Branch the task branch was created from (provenance).
 
         Returns:
             True if update succeeded.
@@ -266,6 +270,10 @@ class TasksClient(SteerDevClient):
             payload["error_message"] = error_message
         if comment:
             payload["comment"] = comment
+        if branch:
+            payload["branch"] = branch
+        if base_branch:
+            payload["base_branch"] = base_branch
 
         if not payload:
             return False

{steerdev-1.1.14 → steerdev-1.1.25}/src/steerdev_agent/cli.py

@@ -460,6 +460,20 @@ def hooks_subagent_stop() -> None:
     client.subagent_stop()
 
 
+@hooks_app.command("post-tool-use")
+def hooks_post_tool_use() -> None:
+    """Hook called after each Claude Code tool use.
+
+    Reads JSON from stdin. If the tool was a Bash `git commit`, pushes the
+    current branch to origin as a checkpoint so sandbox work survives a VM
+    teardown. Best-effort; always exits 0.
+    """
+    from steerdev_agent.api.hooks import HooksClient
+
+    client = HooksClient()
+    client.post_tool_use()
+
+
 # ============================================================================
 # Sessions Command Group
 # ============================================================================
@@ -1272,6 +1286,16 @@ def git_branch(
     branch_name = f"task/{prefix}-{slug}" if slug else f"task/{prefix}"
 
     try:
+        # Capture the base branch (current HEAD) before we switch.
+        base_result = subprocess.run(
+            ["git", "rev-parse", "--abbrev-ref", "HEAD"],
+            capture_output=True,
+            text=True,
+        )
+        base_branch = base_result.stdout.strip() if base_result.returncode == 0 else None
+        if base_branch == "HEAD":
+            base_branch = None
+
         # Check if branch already exists
         result = subprocess.run(
             ["git", "rev-parse", "--verify", branch_name],
@@ -1297,6 +1321,14 @@ def git_branch(
                 )
             )
 
+        # Persist branch provenance (best-effort; never fails the command).
+        try:
+            with TasksClient() as prov_client:
+                if prov_client.check_api_key():
+                    prov_client.update_task(task_id, branch=branch_name, base_branch=base_branch)
+        except Exception as prov_exc:  # provenance is best-effort
+            console.print(f"[yellow]Could not persist branch provenance: {prov_exc}[/yellow]")
+
     except subprocess.CalledProcessError as e:
         console.print(f"[red]Git error: {e}[/red]")
         raise typer.Exit(1) from None
@@ -1344,9 +1376,25 @@ def git_pr(
     # Add steerdev signature
     pr_body += "\n\n---\nCreated with [steerdev](https://steerdev.com)"
 
+    # Prefer the persisted base branch so the PR targets the correct base.
+    from steerdev_agent.api.tasks import TasksClient
+
+    base_branch: str | None = None
+    if task_id:
+        try:
+            with TasksClient() as pr_client:
+                if pr_client.check_api_key():
+                    task = pr_client.get_task(task_id)
+                    if task:
+                        base_branch = task.get("base_branch")
+        except Exception:  # fall back to gh default base
+            base_branch = None
+
     try:
         # Build the gh pr create command
         cmd = ["gh", "pr", "create", "--title", title, "--body", pr_body]
+        if base_branch:
+            cmd += ["--base", base_branch]
         if draft:
             cmd.append("--draft")
 

steerdev-1.1.25/src/steerdev_agent/git_ops.py

@@ -0,0 +1,124 @@
+"""Synchronous git helpers for checkpoint pushes from Claude Code hooks.
+
+Used by the PostToolUse hook to push the current branch after every commit,
+so sandbox work survives a mid-task VM teardown. All functions are
+best-effort and never raise.
+"""
+
+from __future__ import annotations
+
+import re
+import shutil
+import subprocess
+from typing import TYPE_CHECKING
+
+from loguru import logger
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+# Matches a `git commit` invocation that actually creates a commit.
+# Requires `git` to be followed by whitespace (not a hyphen), so that
+# hyphenated wrappers like `git-commit-hook` are not matched.
+_COMMIT_RE = re.compile(r"(?:^|&&|;|\|)\s*git\s+[^&|;]*\bcommit\b")
+
+# Strips quoted substrings ('...' and "...") so that --dry-run inside a
+# commit message is not mistaken for the actual --dry-run flag.
+_QUOTED_RE = re.compile(r"""(['"]).*?\1""")
+
+
+def _strip_quoted(command: str) -> str:
+    """Remove all single- and double-quoted substrings from *command*."""
+    return _QUOTED_RE.sub("", command)
+
+
+def is_git_commit_command(command: str | None) -> bool:
+    """Return True if the shell command runs a real `git commit`.
+
+    Tolerant of flags, paths, and compound commands (&&, ;). Excludes
+    `--dry-run`, which does not create a commit.
+
+    A `--dry-run` flag (outside quoted text) is treated as a non-committing
+    command. If `--dry-run` appears only inside a quoted commit message it is
+    ignored and the command is still considered committing.
+
+    Args:
+        command: The Bash command string from a PostToolUse payload.
+
+    Returns:
+        True if a committing `git commit` is present.
+    """
+    if not command:
+        return False
+    if "--dry-run" in _strip_quoted(command):
+        return False
+    return _COMMIT_RE.search(command) is not None
+
+
+PROTECTED_BRANCHES: frozenset[str] = frozenset({"main", "master", "develop"})
+
+_GIT_TIMEOUT = 25  # seconds; hook timeout is 30s, leave headroom
+
+
+def _git_capture(cwd: str | Path, *args: str) -> tuple[int, str]:
+    """Run git, returning (returncode, stdout). Never raises for git errors."""
+    proc = subprocess.run(
+        ["git", *args],
+        cwd=str(cwd),
+        capture_output=True,
+        text=True,
+        timeout=_GIT_TIMEOUT,
+    )
+    return proc.returncode, (proc.stdout or "").strip()
+
+
+def current_branch(cwd: str | Path) -> str | None:
+    """Return the current branch name, or None if detached/unavailable."""
+    rc, out = _git_capture(cwd, "rev-parse", "--abbrev-ref", "HEAD")
+    if rc != 0 or not out or out == "HEAD":
+        return None
+    return out
+
+
+def checkpoint_push(cwd: str | Path) -> str:
+    """Push the current branch to origin as a best-effort checkpoint.
+
+    Force-with-lease so rebases/amends still checkpoint without ever
+    overwriting others' work. Never raises; returns a status marker.
+
+    Returns one of:
+        "pushed", "skipped_detached", "skipped_protected",
+        "skipped_no_remote", "failed".
+    """
+    try:
+        if shutil.which("git") is None:
+            logger.warning("checkpoint_push: git not found, skipping")
+            return "failed"
+
+        branch = current_branch(cwd)
+        if branch is None:
+            logger.info("checkpoint_push: detached HEAD, skipping")
+            return "skipped_detached"
+
+        if branch in PROTECTED_BRANCHES:
+            logger.info(f"checkpoint_push: protected branch {branch}, skipping")
+            return "skipped_protected"
+
+        rc, _ = _git_capture(cwd, "remote", "get-url", "origin")
+        if rc != 0:
+            logger.info("checkpoint_push: no origin remote, skipping")
+            return "skipped_no_remote"
+
+        rc, out = _git_capture(cwd, "push", "--force-with-lease", "-u", "origin", "HEAD")
+        if rc != 0:
+            logger.warning(f"checkpoint_push: push failed (non-fatal): {out}")
+            return "failed"
+
+        logger.info(f"checkpoint_push: pushed {branch}")
+        return "pushed"
+    except subprocess.TimeoutExpired:
+        logger.warning("checkpoint_push: push timed out (non-fatal)")
+        return "failed"
+    except Exception as exc:  # broad catch intentional: durability must never break the agent
+        logger.warning(f"checkpoint_push: unexpected error (non-fatal): {exc}")
+        return "failed"

{steerdev-1.1.14 → steerdev-1.1.25}/src/steerdev_agent/setup/templates/settings.json

@@ -69,6 +69,18 @@
           }
         ]
       }
+    ],
+    "PostToolUse": [
+      {
+        "matcher": "Bash",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "steerdev hooks post-tool-use",
+            "timeout": 30
+          }
+        ]
+      }
     ]
   }
 }

{steerdev-1.1.14 → steerdev-1.1.25}/src/steerdev_agent/workspace/preparation.py

@@ -13,6 +13,8 @@ from typing import TYPE_CHECKING, Any
 
 from loguru import logger
 
+from steerdev_agent.api.tasks import TasksClient
+
 if TYPE_CHECKING:
     from pathlib import Path
 
@@ -78,6 +80,27 @@ async def _run_git(
     return proc.returncode or 0, stdout, stderr
 
 
+async def persist_branch_provenance(
+    task_id: str | None,
+    branch: str,
+    base_branch: str,
+) -> None:
+    """Persist the task branch and its base to the API, best-effort.
+
+    Written at branch-creation time so an orphaned task (sandbox killed
+    mid-run) remains recoverable. Never raises.
+    """
+    if not task_id:
+        return
+    try:
+        with TasksClient() as client:
+            if not client.check_api_key():
+                return
+            client.update_task(task_id, branch=branch, base_branch=base_branch)
+    except Exception as exc:  # provenance is best-effort
+        logger.warning(f"Failed to persist branch provenance for {task_id}: {exc}")
+
+
 class WorkspacePreparation:
     """Prepares the git workspace before task execution.
 
@@ -120,7 +143,9 @@ class WorkspacePreparation:
             return await self._prepare_worktree(target_branch, default_branch)
 
         # Non-worktree mode: prepare in-place
-        return await self._prepare_in_place(target_branch, default_branch, wave_context)
+        return await self._prepare_in_place(
+            target_branch, default_branch, wave_context, task.get("id")
+        )
 
     async def _prepare_worktree(
         self,
@@ -146,6 +171,7 @@ class WorkspacePreparation:
         target_branch: str,
         default_branch: str,
         wave_context: WaveContext | None,
+        task_id: str | None = None,
     ) -> PreparationResult:
         """Prepare workspace in the main repository directory.
 
@@ -159,7 +185,9 @@ class WorkspacePreparation:
         rc, _, _ = await _run_git("rev-parse", "--is-inside-work-tree", cwd=cwd, check=False)
         if rc == 0:
             # Single-repo layout: prepare in place
-            return await self._prepare_single_repo(cwd, target_branch, default_branch, wave_context)
+            return await self._prepare_single_repo(
+                cwd, target_branch, default_branch, wave_context, task_id
+            )
 
         # Not a git repo — check for multi-repo layout (subdirectories that are git repos)
         repos = await self._discover_git_repos(cwd)
@@ -174,7 +202,9 @@ class WorkspacePreparation:
             )
 
         # Multi-repo layout: prepare each discovered repo
-        return await self._prepare_multi_repo(repos, target_branch, default_branch, wave_context)
+        return await self._prepare_multi_repo(
+            repos, target_branch, default_branch, wave_context, task_id
+        )
 
     async def _discover_git_repos(self, directory: Path) -> list[Path]:
         """Discover git repositories in immediate subdirectories.
@@ -204,6 +234,7 @@ class WorkspacePreparation:
         target_branch: str,
         default_branch: str,
         wave_context: WaveContext | None,
+        task_id: str | None = None,
     ) -> PreparationResult:
         """Prepare multiple git repositories in a workspace directory.
 
@@ -232,7 +263,7 @@ class WorkspacePreparation:
             logger.info(f"Preparing repository: {repo_name}")
 
             result = await self._prepare_single_repo(
-                repo_path, target_branch, default_branch, wave_context
+                repo_path, target_branch, default_branch, wave_context, task_id
             )
 
             if not result.success:
@@ -269,6 +300,7 @@ class WorkspacePreparation:
         target_branch: str,
         default_branch: str,
         wave_context: WaveContext | None,
+        task_id: str | None = None,
     ) -> PreparationResult:
         """Prepare a single git repository directory.
 
@@ -355,6 +387,10 @@ 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
+        )
+
         return PreparationResult(
             success=True,
             branch_name=target_branch,

steerdev-1.1.25/tests/test_git_ops.py

@@ -0,0 +1,133 @@
+"""Tests for the git_ops module (commit detection and checkpoint push)."""
+
+import subprocess
+from pathlib import Path
+
+from steerdev_agent.git_ops import PROTECTED_BRANCHES, checkpoint_push, is_git_commit_command
+
+
+def test_detects_plain_commit():
+    assert is_git_commit_command("git commit -m 'msg'") is True
+
+
+def test_detects_commit_with_amend():
+    assert is_git_commit_command("git commit --amend --no-edit") is True
+
+
+def test_detects_commit_in_compound_command():
+    assert is_git_commit_command("git add -A && git commit -m 'x'") is True
+
+
+def test_ignores_dry_run():
+    assert is_git_commit_command("git commit --dry-run") is False
+
+
+def test_ignores_non_commit_git():
+    assert is_git_commit_command("git status") is False
+    assert is_git_commit_command("git log --oneline") is False
+
+
+def test_ignores_unrelated_command():
+    assert is_git_commit_command("echo git commit") is False
+    assert is_git_commit_command("ls -la") is False
+
+
+def test_handles_empty():
+    assert is_git_commit_command("") is False
+    assert is_git_commit_command(None) is False
+
+
+def test_ignores_hyphenated_git_wrapper():
+    assert is_git_commit_command("git-commit-hook") is False
+    assert is_git_commit_command("build && git-commit-hook") is False
+
+
+def test_detects_commit_with_extra_spaces():
+    assert is_git_commit_command("git   commit -m x") is True
+
+
+def test_dry_run_inside_message_still_commits():
+    assert is_git_commit_command('git commit -m "talk about --dry-run"') is True
+    assert is_git_commit_command("git commit -m 'fix --dry-run bug'") is True
+
+
+def _git(cwd: Path, *args: str) -> None:
+    subprocess.run(["git", *args], cwd=cwd, check=True, capture_output=True)
+
+
+def _make_repo_with_origin(tmp_path: Path) -> Path:
+    origin = tmp_path / "origin.git"
+    subprocess.run(["git", "init", "--bare", str(origin)], check=True, capture_output=True)
+    work = tmp_path / "work"
+    work.mkdir()
+    _git(work, "init")
+    _git(work, "config", "user.email", "t@t.dev")
+    _git(work, "config", "user.name", "t")
+    _git(work, "remote", "add", "origin", str(origin))
+    (work / "f.txt").write_text("a")
+    _git(work, "add", "-A")
+    _git(work, "commit", "-m", "init")
+    return work
+
+
+def _remote_has_branch(work: Path, branch: str) -> bool:
+    out = subprocess.run(
+        ["git", "ls-remote", "--heads", "origin", branch],
+        cwd=work,
+        capture_output=True,
+        text=True,
+        check=True,
+    )
+    return bool(out.stdout.strip())
+
+
+def test_pushes_task_branch(tmp_path):
+    work = _make_repo_with_origin(tmp_path)
+    _git(work, "checkout", "-b", "task/PROJ-1-x")
+    (work / "f.txt").write_text("b")
+    _git(work, "add", "-A")
+    _git(work, "commit", "-m", "work")
+
+    assert checkpoint_push(work) == "pushed"
+    assert _remote_has_branch(work, "task/PROJ-1-x") is True
+
+
+def test_skips_protected_branch(tmp_path):
+    work = _make_repo_with_origin(tmp_path)
+    current = subprocess.run(
+        ["git", "branch", "--show-current"], cwd=work, capture_output=True, text=True, check=True
+    ).stdout.strip()
+    assert current in PROTECTED_BRANCHES  # main or master
+    assert checkpoint_push(work) == "skipped_protected"
+
+
+def test_skips_detached_head(tmp_path):
+    work = _make_repo_with_origin(tmp_path)
+    sha = subprocess.run(
+        ["git", "rev-parse", "HEAD"], cwd=work, capture_output=True, text=True, check=True
+    ).stdout.strip()
+    _git(work, "checkout", sha)  # detached
+    assert checkpoint_push(work) == "skipped_detached"
+
+
+def test_skips_when_no_origin(tmp_path):
+    work = tmp_path / "noorigin"
+    work.mkdir()
+    _git(work, "init")
+    _git(work, "config", "user.email", "t@t.dev")
+    _git(work, "config", "user.name", "t")
+    (work / "f.txt").write_text("a")
+    _git(work, "add", "-A")
+    _git(work, "commit", "-m", "init")
+    _git(work, "checkout", "-b", "task/x")
+    assert checkpoint_push(work) == "skipped_no_remote"
+
+
+def test_returns_failed_without_raising_on_unreachable_remote(tmp_path):
+    work = _make_repo_with_origin(tmp_path)
+    _git(work, "remote", "set-url", "origin", str(tmp_path / "does-not-exist.git"))
+    _git(work, "checkout", "-b", "task/x")
+    (work / "f.txt").write_text("b")
+    _git(work, "add", "-A")
+    _git(work, "commit", "-m", "work")
+    assert checkpoint_push(work) == "failed"

steerdev-1.1.25/tests/test_hooks_post_tool_use.py

@@ -0,0 +1,78 @@
+import io
+import json
+from unittest.mock import patch
+
+import pytest
+
+from steerdev_agent.api.hooks import HooksClient
+
+
+def _run_with_stdin(payload: dict, monkeypatch) -> str | None:
+    """Drive post_tool_use with a fake stdin; capture the cwd it pushed (or None)."""
+    monkeypatch.setattr("sys.stdin", io.StringIO(json.dumps(payload)))
+    captured: dict = {}
+
+    def fake_push(cwd):
+        captured["cwd"] = str(cwd)
+        return "pushed"
+
+    with (
+        patch("steerdev_agent.api.hooks.checkpoint_push", side_effect=fake_push),
+        pytest.raises(SystemExit) as exc,
+    ):
+        HooksClient().post_tool_use()
+    assert exc.value.code == 0
+    return captured.get("cwd")
+
+
+def test_pushes_on_git_commit(monkeypatch):
+    payload = {
+        "tool_name": "Bash",
+        "tool_input": {"command": "git commit -m 'x'"},
+        "cwd": "/work/repo",
+    }
+    assert _run_with_stdin(payload, monkeypatch) == "/work/repo"
+
+
+def test_no_push_on_non_commit_bash(monkeypatch):
+    payload = {"tool_name": "Bash", "tool_input": {"command": "ls"}, "cwd": "/work/repo"}
+    assert _run_with_stdin(payload, monkeypatch) is None
+
+
+def test_no_push_on_non_bash_tool(monkeypatch):
+    payload = {"tool_name": "Edit", "tool_input": {"file_path": "a.py"}, "cwd": "/work/repo"}
+    assert _run_with_stdin(payload, monkeypatch) is None
+
+
+def test_exits_zero_on_malformed_stdin(monkeypatch):
+    monkeypatch.setattr("sys.stdin", io.StringIO("not json"))
+    with (
+        patch("steerdev_agent.api.hooks.checkpoint_push") as push,
+        pytest.raises(SystemExit) as exc,
+    ):
+        HooksClient().post_tool_use()
+    assert exc.value.code == 0
+    push.assert_not_called()
+
+
+def test_exits_zero_on_null_tool_input(monkeypatch):
+    payload = {"tool_name": "Bash", "tool_input": None, "cwd": "/work/repo"}
+    assert _run_with_stdin(payload, monkeypatch) is None
+
+
+def test_exits_zero_on_non_dict_stdin(monkeypatch):
+    """A truthy non-dict JSON payload must not raise (never-block invariant)."""
+    monkeypatch.setattr("sys.stdin", io.StringIO("42"))
+    with (
+        patch("steerdev_agent.api.hooks.checkpoint_push") as push,
+        pytest.raises(SystemExit) as exc,
+    ):
+        HooksClient().post_tool_use()
+    assert exc.value.code == 0
+    push.assert_not_called()
+
+
+def test_exits_zero_on_string_tool_input(monkeypatch):
+    """A truthy non-dict tool_input must not raise."""
+    payload = {"tool_name": "Bash", "tool_input": "git commit -m x", "cwd": "/work/repo"}
+    assert _run_with_stdin(payload, monkeypatch) is None

steerdev-1.1.25/tests/test_preparation_provenance.py

@@ -0,0 +1,42 @@
+import asyncio
+from unittest.mock import MagicMock, patch
+
+from steerdev_agent.workspace.preparation import persist_branch_provenance
+
+
+def test_persist_calls_update_task_with_branch_and_base():
+    fake_client = MagicMock()
+    fake_client.check_api_key.return_value = True
+    fake_client.__enter__.return_value = fake_client
+    fake_client.__exit__.return_value = False
+
+    with patch("steerdev_agent.workspace.preparation.TasksClient", return_value=fake_client):
+        asyncio.run(
+            persist_branch_provenance(
+                task_id="task-9", branch="task/PROJ-1-x", base_branch="develop"
+            )
+        )
+
+    fake_client.update_task.assert_called_once_with(
+        "task-9", branch="task/PROJ-1-x", base_branch="develop"
+    )
+
+
+def test_persist_swallows_errors():
+    fake_client = MagicMock()
+    fake_client.check_api_key.return_value = True
+    fake_client.__enter__.return_value = fake_client
+    fake_client.__exit__.return_value = False
+    fake_client.update_task.side_effect = RuntimeError("network down")
+
+    with patch("steerdev_agent.workspace.preparation.TasksClient", return_value=fake_client):
+        # Must not raise.
+        asyncio.run(
+            persist_branch_provenance(task_id="task-9", branch="task/x", base_branch="main")
+        )
+
+
+def test_persist_noop_without_task_id():
+    with patch("steerdev_agent.workspace.preparation.TasksClient") as cls:
+        asyncio.run(persist_branch_provenance(task_id=None, branch="b", base_branch="m"))
+    cls.assert_not_called()

steerdev-1.1.25/tests/test_tasks_update_branch.py

@@ -0,0 +1,32 @@
+from unittest.mock import MagicMock, patch
+
+from steerdev_agent.api.tasks import TasksClient
+
+
+def _client() -> TasksClient:
+    # Bypass __init__ network/key setup; we only test payload building.
+    client = TasksClient.__new__(TasksClient)
+    client.api_base = "https://api.test/v1"
+    return client
+
+
+def test_update_task_sends_branch_and_base():
+    client = _client()
+    resp = MagicMock(status_code=200)
+    with patch.object(client, "patch", return_value=resp) as mock_patch:
+        ok = client.update_task("task-123", branch="task/PROJ-1-x", base_branch="develop")
+    assert ok is True
+    args, kwargs = mock_patch.call_args
+    assert args[0] == "/tasks/task-123"
+    assert kwargs["json"]["branch"] == "task/PROJ-1-x"
+    assert kwargs["json"]["base_branch"] == "develop"
+
+
+def test_update_task_omits_branch_when_not_given():
+    client = _client()
+    resp = MagicMock(status_code=200)
+    with patch.object(client, "patch", return_value=resp) as mock_patch:
+        client.update_task("task-123", result_summary="done")
+    _, kwargs = mock_patch.call_args
+    assert "branch" not in kwargs["json"]
+    assert "base_branch" not in kwargs["json"]