steerdev 1.1.16__tar.gz → 1.1.26__tar.gz

{steerdev-1.1.16 → steerdev-1.1.26}/.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.16 → steerdev-1.1.26}/PKG-INFO

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

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

{steerdev-1.1.16 → steerdev-1.1.26}/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.16 → steerdev-1.1.26}/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.16 → steerdev-1.1.26}/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.26/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.16 → steerdev-1.1.26}/src/steerdev_agent/setup/claude_setup.py

@@ -14,6 +14,43 @@ from loguru import logger
 
 from steerdev_agent.config.platform import PlatformConfig
 
+# Commands owned by steerdev are reconciled to the template; anything else in
+# an existing settings file is treated as user-added and left untouched.
+_STEERDEV_HOOK_PREFIX = "steerdev hooks"
+
+
+def _is_steerdev_hook_entry(entry: dict) -> bool:
+    """Return True if a hook matcher-group entry is steerdev-owned.
+
+    An entry is steerdev-owned when any of its commands invoke
+    `steerdev hooks ...`. Used to reconcile only our own hooks while
+    preserving user-added hooks on the same event.
+    """
+    for hook in entry.get("hooks", []):
+        if isinstance(hook, dict) and str(hook.get("command", "")).strip().startswith(
+            _STEERDEV_HOOK_PREFIX
+        ):
+            return True
+    return False
+
+
+def _merge_steerdev_hooks(existing_hooks: dict, template_hooks: dict) -> None:
+    """Reconcile steerdev-owned hooks into *existing_hooks* in place.
+
+    For each event in the template, drop any existing steerdev-owned entries
+    (so stale/missing definitions are replaced) while keeping user-added
+    entries, then append the template's entries. Events not in the template
+    are left untouched.
+    """
+    for event, template_entries in template_hooks.items():
+        user_entries = [
+            entry
+            for entry in existing_hooks.get(event, [])
+            if isinstance(entry, dict) and not _is_steerdev_hook_entry(entry)
+        ]
+        existing_hooks[event] = user_entries + template_entries
+
+
 # ---------------------------------------------------------------------------
 # CLI dependency checking
 # ---------------------------------------------------------------------------
@@ -319,13 +356,18 @@ class ClaudeSetup:
                 if rule not in existing["permissions"]["allow"]:
                     existing["permissions"]["allow"].append(rule)
 
-            # Merge hooks configuration if include_hooks=True
+            # Reconcile hooks configuration if include_hooks=True.
+            #
+            # The template hooks are steerdev-owned (their commands all start
+            # with `steerdev hooks`). We reconcile them by command identity so
+            # that pre-existing settings files self-heal when new steerdev
+            # hooks are added (e.g. the PostToolUse checkpoint-push hook) or
+            # when an existing steerdev hook's definition changes. Any
+            # user-added hooks on the same event are preserved untouched.
             if include_hooks and "hooks" in new_settings:
                 if "hooks" not in existing:
                     existing["hooks"] = {}
-                for hook_event, hook_configs in new_settings["hooks"].items():
-                    if hook_event not in existing["hooks"]:
-                        existing["hooks"][hook_event] = hook_configs
+                _merge_steerdev_hooks(existing["hooks"], new_settings["hooks"])
 
             settings_path.write_text(json.dumps(existing, indent=2) + "\n")
             logger.info(f"Updated existing settings: {settings_path}")

{steerdev-1.1.16 → steerdev-1.1.26}/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.16 → steerdev-1.1.26}/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.16 → steerdev-1.1.26}/src/steerdev_agent/workspace/project_manager.py

@@ -45,6 +45,10 @@ class ProjectManager:
             local_path = self._resolve_path(assignment)
             if local_path and local_path.is_dir():
                 self._path_cache[assignment.project_id] = local_path
+                # Existing checkout: reconcile .claude config so settings files
+                # that predate newer steerdev hooks (e.g. the PostToolUse
+                # checkpoint-push hook) self-heal on every dispatch.
+                self._reconcile_settings(local_path)
                 continue
 
             # Project not found locally — bootstrap it
@@ -55,6 +59,19 @@ class ProjectManager:
             except Exception:
                 logger.exception(f"Failed to setup project {assignment.project_id}")
 
+    def _reconcile_settings(self, project_dir: Path) -> None:
+        """Re-apply steerdev-owned .claude/settings.json hooks for an existing
+        checkout. Idempotent and best-effort: a setup failure must never block
+        an otherwise-usable project.
+        """
+        from steerdev_agent.setup.claude_setup import ClaudeSetup
+
+        try:
+            setup = ClaudeSetup(project_dir, install_target="project")
+            setup.setup_settings(force=False, include_hooks=True)
+        except Exception:
+            logger.exception(f"Failed to reconcile .claude settings for {project_dir}")
+
     async def setup_project(self, assignment: ProjectAssignment) -> Path | None:
         """Bootstrap a project using existing setup primitives.
 

{steerdev-1.1.16 → steerdev-1.1.26}/tests/test_claude_setup.py

@@ -51,6 +51,76 @@ class TestClaudeSetup:
         )  # skill now references merge skills by name
 
 
+class TestSettingsHookReconciliation:
+    """Tests for steerdev-owned hook reconciliation in setup_settings."""
+
+    @staticmethod
+    def _commands(settings: dict, event: str) -> list[str]:
+        commands = []
+        for entry in settings.get("hooks", {}).get(event, []):
+            for hook in entry.get("hooks", []):
+                commands.append(hook.get("command"))
+        return commands
+
+    def test_fresh_create_includes_post_tool_use(self, tmp_path):
+        import json
+
+        setup = ClaudeSetup(project_dir=tmp_path)
+
+        path = setup.setup_settings(force=False, include_hooks=True)
+        settings = json.loads(path.read_text())
+
+        assert "steerdev hooks post-tool-use" in self._commands(settings, "PostToolUse")
+
+    def test_stale_file_self_heals_post_tool_use(self, tmp_path):
+        """A settings file predating the PostToolUse hook gains it on re-run."""
+        import json
+
+        stale = {
+            "permissions": {"allow": ["Bash(git commit:*)"]},
+            "hooks": {
+                "SessionStart": [
+                    {"hooks": [{"type": "command", "command": "steerdev hooks session-start"}]}
+                ]
+            },
+        }
+        claude_dir = tmp_path / ".claude"
+        claude_dir.mkdir(parents=True)
+        (claude_dir / "settings.json").write_text(json.dumps(stale))
+
+        setup = ClaudeSetup(project_dir=tmp_path)
+        path = setup.setup_settings(force=False, include_hooks=True)
+        settings = json.loads(path.read_text())
+
+        assert "steerdev hooks post-tool-use" in self._commands(settings, "PostToolUse")
+        # Pre-existing steerdev hook is reconciled, not duplicated.
+        assert self._commands(settings, "SessionStart").count("steerdev hooks session-start") == 1
+
+    def test_user_added_hooks_preserved(self, tmp_path):
+        import json
+
+        existing = {
+            "hooks": {
+                "PostToolUse": [
+                    {
+                        "matcher": "Write",
+                        "hooks": [{"type": "command", "command": "my-custom-linter"}],
+                    }
+                ]
+            },
+        }
+        claude_dir = tmp_path / ".claude"
+        claude_dir.mkdir(parents=True)
+        (claude_dir / "settings.json").write_text(json.dumps(existing))
+
+        setup = ClaudeSetup(project_dir=tmp_path)
+        path = setup.setup_settings(force=False, include_hooks=True)
+        commands = self._commands(json.loads(path.read_text()), "PostToolUse")
+
+        assert "my-custom-linter" in commands
+        assert "steerdev hooks post-tool-use" in commands
+
+
 class TestCheckCliDependencies:
     """Tests for CLI dependency checking."""