steerdev 1.1.25__tar.gz → 1.1.27__tar.gz

{steerdev-1.1.25 → steerdev-1.1.27}/PKG-INFO

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

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

{steerdev-1.1.25 → steerdev-1.1.27}/src/steerdev_agent/agent_loop.py

@@ -582,10 +582,15 @@ class AgentLoop(CommandExecutor):
             # Step 2: Recover stale commands
             await self._recover_stale_commands()
 
-            # Step 3: Start heartbeat
+            # Step 3: Reconcile .claude config (hooks) for this checkout, so a
+            # repo that predates newer steerdev hooks (e.g. the PostToolUse
+            # checkpoint-push hook) self-heals before any task launches Claude.
+            self._reconcile_settings()
+
+            # Step 4: Start heartbeat
             self._heartbeat_task = asyncio.create_task(self._heartbeat_loop())
 
-            # Step 4: Main poll loop
+            # Step 5: Main poll loop
             await self._poll_loop()
 
         except AgentLoopError as e:
@@ -647,6 +652,23 @@ class AgentLoop(CommandExecutor):
                 )
                 await self._commands_client.mark_pending(cmd.id)
 
+    def _reconcile_settings(self) -> None:
+        """Re-apply steerdev-owned .claude/settings.json hooks for this checkout.
+
+        Single-project mode runs against an already-existing repo that never
+        went through project bootstrap, so its .claude config can be missing or
+        predate newer steerdev hooks. Reconciling here (idempotent, best-effort)
+        ensures the PostToolUse checkpoint-push hook is present before Claude
+        launches. A setup failure must never block the agent.
+        """
+        from steerdev_agent.setup.claude_setup import ClaudeSetup
+
+        try:
+            setup = ClaudeSetup(self.working_directory, install_target="project")
+            setup.setup_settings(force=False, include_hooks=True)
+        except Exception:
+            logger.exception(f"Failed to reconcile .claude settings for {self.working_directory}")
+
     async def _poll_loop(self) -> None:
         """Main loop: poll for commands and execute them."""
         logger.info("Entering poll loop")

{steerdev-1.1.25 → steerdev-1.1.27}/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.25 → steerdev-1.1.27}/src/steerdev_agent/workspace/preparation.py

@@ -322,6 +322,13 @@ class WorkspacePreparation:
         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)
+            # Persist provenance here too: a wave-continuation task arrives
+            # already on the branch, so it skips the create/checkout path
+            # below where provenance is normally written. Without this, the
+            # second+ task in a wave never records its branch on the task.
+            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 → steerdev-1.1.27}/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.25 → steerdev-1.1.27}/tests/test_agent_loop.py

@@ -72,6 +72,37 @@ class TestAgentLoopError:
         assert str(err) == "test error"
 
 
+class TestAgentLoopReconcileSettings:
+    """Tests for single-project AgentLoop hook reconciliation."""
+
+    def _make_agent_loop(self, working_directory):
+        from steerdev_agent.agent_loop import AgentLoop
+
+        return AgentLoop(
+            project_id="proj-1",
+            agent_name="test-agent",
+            working_directory=working_directory,
+            api_key="test-key",
+        )
+
+    def test_reconciles_settings_at_working_directory(self, tmp_path):
+        agent = self._make_agent_loop(tmp_path)
+
+        with patch("steerdev_agent.setup.claude_setup.ClaudeSetup") as cls:
+            agent._reconcile_settings()
+
+        cls.assert_called_once_with(tmp_path, install_target="project")
+        cls.return_value.setup_settings.assert_called_once_with(force=False, include_hooks=True)
+
+    def test_reconcile_swallows_errors(self, tmp_path):
+        agent = self._make_agent_loop(tmp_path)
+
+        with patch("steerdev_agent.setup.claude_setup.ClaudeSetup") as cls:
+            cls.return_value.setup_settings.side_effect = RuntimeError("disk full")
+            # Must not raise — durability must never block the agent.
+            agent._reconcile_settings()
+
+
 class TestCommandExecutor:
     """Tests for CommandExecutor._execute_command dispatch logic."""
 

{steerdev-1.1.25 → steerdev-1.1.27}/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."""
 

{steerdev-1.1.25 → steerdev-1.1.27}/tests/test_preparation.py

@@ -232,7 +232,10 @@ class TestWorkspacePreparationInPlace:
                 return (0, "", "")
             return (0, "", "")
 
-        with patch("steerdev_agent.workspace.preparation._run_git", side_effect=mock_run_git):
+        with (
+            patch("steerdev_agent.workspace.preparation._run_git", side_effect=mock_run_git),
+            patch("steerdev_agent.workspace.preparation.persist_branch_provenance") as mock_persist,
+        ):
             result = await prep.prepare(sample_task, wave_ctx)
 
         assert result.success is True
@@ -240,6 +243,11 @@ class TestWorkspacePreparationInPlace:
         # Should NOT have checkout commands (stayed on branch)
         checkout_cmds = [c for c in calls if c[0] == "checkout"]
         assert len(checkout_cmds) == 0
+        # Wave-continuation must still record branch provenance on the task,
+        # even though it skips the create/checkout path.
+        mock_persist.assert_awaited_once_with(
+            task_id=sample_task["id"], branch="wave-a1b2c3", base_branch="main"
+        )
 
     @pytest.mark.asyncio
     async def test_dirty_repo_stashes(self, worktree_disabled, default_config, sample_task):