autopilot-code 0.6.0 → 0.8.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "autopilot-code",
-  "version": "0.6.0",
+  "version": "0.8.0",
   "private": false,
   "description": "Repo-issue–driven autopilot runner",
   "license": "MIT",

package/scripts/issue_runner/__init__.py

@@ -1 +1,20 @@
 from .git_ops import GitOperations, GitResult, MergeStatus
+from .states import IssueStep, StateData, STEP_STATUS_MESSAGES, STEP_LABELS
+from .github_state import GitHubStateManager
+from .agents import BaseAgent, AgentResult, get_agent
+from .runner import IssueRunner
+
+__all__ = [
+    "GitOperations",
+    "GitResult",
+    "MergeStatus",
+    "IssueStep",
+    "StateData",
+    "STEP_STATUS_MESSAGES",
+    "STEP_LABELS",
+    "GitHubStateManager",
+    "BaseAgent",
+    "AgentResult",
+    "get_agent",
+    "IssueRunner",
+]

package/scripts/issue_runner/agents/__init__.py

@@ -1,4 +1,32 @@
 from .base import BaseAgent, AgentResult
 from .opencode import OpenCodeAgent
+from .claude import ClaudeCodeAgent
 
-__all__ = ["BaseAgent", "AgentResult", "OpenCodeAgent"]
+__all__ = ["BaseAgent", "AgentResult", "OpenCodeAgent", "ClaudeCodeAgent"]
+
+
+def get_agent(agent_type: str, config: dict) -> BaseAgent:
+    """
+    Factory function to create the appropriate agent.
+
+    Args:
+        agent_type: "opencode" or "claude"
+        config: Agent configuration from autopilot.json
+
+    Returns:
+        Configured agent instance
+
+    Raises:
+        ValueError: If agent_type is unknown
+    """
+    agents = {
+        "opencode": OpenCodeAgent,
+        "claude": ClaudeCodeAgent,
+    }
+
+    if agent_type not in agents:
+        raise ValueError(
+            f"Unknown agent type: {agent_type}. Available: {list(agents.keys())}"
+        )
+
+    return agents[agent_type](config)

package/scripts/issue_runner/agents/claude.py

@@ -0,0 +1,157 @@
+import subprocess
+import shutil
+import os
+from pathlib import Path
+from typing import Optional
+
+from .base import BaseAgent, AgentResult
+
+
+class ClaudeCodeAgent(BaseAgent):
+    """
+    Agent implementation for Claude Code CLI (Anthropic's official CLI).
+
+    Claude Code is invoked via: claude [options] "<prompt>"
+
+    Session support: Claude Code supports --resume <session_id> to continue sessions.
+    Sessions maintain full conversation history and context.
+    """
+
+    @property
+    def name(self) -> str:
+        return "Claude Code"
+
+    @property
+    def supports_sessions(self) -> bool:
+        return True  # Claude Code supports --resume
+
+    def find_binary(self) -> str:
+        """
+        Locate the claude binary.
+
+        Search order:
+        1. agentPath from config
+        2. PATH
+        3. Common npm global locations
+        4. Homebrew location (macOS)
+        """
+        # 1. Config-specified path
+        agent_path = self.config.get("agentPath", "")
+        if agent_path and os.path.isfile(agent_path) and os.access(agent_path, os.X_OK):
+            return agent_path
+
+        # 2. Already in PATH
+        which_result = shutil.which("claude")
+        if which_result:
+            return which_result
+
+        # 3. Common locations
+        home = Path.home()
+        common_paths = [
+            home / ".local" / "bin" / "claude",
+            Path("/usr/local/bin/claude"),
+            home / ".npm-global" / "bin" / "claude",
+            Path("/opt/homebrew/bin/claude"),  # macOS Homebrew
+        ]
+
+        # Also check nvm locations
+        nvm_dir = home / ".nvm" / "versions" / "node"
+        if nvm_dir.exists():
+            for node_dir in nvm_dir.iterdir():
+                claude_path = node_dir / "bin" / "claude"
+                if claude_path.exists() and os.access(claude_path, os.X_OK):
+                    return str(claude_path)
+
+        for path in common_paths:
+            if path.exists() and os.access(path, os.X_OK):
+                return str(path)
+
+        raise FileNotFoundError(
+            "claude not found. Install via 'npm install -g @anthropic-ai/claude-code' "
+            "or set 'agentPath' in autopilot.json."
+        )
+
+    def run(
+        self, worktree: Path, prompt: str, session_id: Optional[str] = None
+    ) -> AgentResult:
+        """
+        Run Claude Code with the given prompt.
+
+        Args:
+            worktree: Working directory for the agent
+            prompt: The task/prompt
+            session_id: Previous session ID to resume (if any)
+
+        Returns:
+            AgentResult with session_id for future continuation
+        """
+        cmd = [self.binary_path]
+
+        # Add session resume if we have a previous session
+        if session_id and self.supports_sessions:
+            cmd.extend(["--resume", session_id])
+
+        # Add print mode for non-interactive execution
+        cmd.extend(["--print", "--dangerously-skip-permissions"])
+
+        # Add the prompt
+        cmd.extend(["-p", prompt])
+
+        try:
+            result = subprocess.run(
+                cmd,
+                cwd=worktree,
+                capture_output=True,
+                text=True,
+                timeout=1800,  # 30 minute timeout
+                env={**os.environ, "CLAUDE_CODE_HEADLESS": "1"},
+            )
+
+            # Extract session ID from output
+            # Claude Code outputs the session ID which we can capture
+            new_session_id = (
+                self._extract_session_id(result.stdout, result.stderr) or session_id
+            )
+
+            return AgentResult(
+                success=result.returncode == 0,
+                session_id=new_session_id,
+                output=result.stdout,
+                error=result.stderr if result.returncode != 0 else None,
+            )
+        except subprocess.TimeoutExpired:
+            return AgentResult(
+                success=False,
+                session_id=session_id,
+                output="",
+                error="Agent timed out after 30 minutes",
+            )
+        except Exception as e:
+            return AgentResult(
+                success=False, session_id=session_id, output="", error=str(e)
+            )
+
+    def _extract_session_id(self, stdout: str, stderr: str) -> Optional[str]:
+        """
+        Extract session ID from Claude Code output.
+
+        Claude Code outputs session information that we can parse to get
+        the session ID for future --resume calls.
+        """
+        import re
+
+        # Check both stdout and stderr for session info
+        for output in [stdout, stderr]:
+            # Look for session ID patterns
+            # Claude Code may output something like "Session ID: abc123" or similar
+            patterns = [
+                r"session[_\s]?id[:\s]+([a-zA-Z0-9_-]+)",
+                r"resume[:\s]+([a-zA-Z0-9_-]+)",
+                r"--resume\s+([a-zA-Z0-9_-]+)",
+            ]
+            for pattern in patterns:
+                match = re.search(pattern, output, re.IGNORECASE)
+                if match:
+                    return match.group(1)
+
+        return None

package/scripts/issue_runner/runner.py

@@ -0,0 +1,678 @@
+import logging
+from pathlib import Path
+from typing import Optional
+from dataclasses import replace
+from datetime import datetime
+import subprocess
+import json
+
+from .states import IssueStep, StateData, STEP_STATUS_MESSAGES
+from .github_state import GitHubStateManager
+from .git_ops import GitOperations, MergeStatus
+from .agents import BaseAgent, get_agent
+
+logger = logging.getLogger(__name__)
+
+
+class IssueRunner:
+    """
+    State-machine-based issue runner with full resumability.
+
+    State is persisted to GitHub after each transition, allowing
+    the runner to resume from any step if interrupted.
+    """
+
+    def __init__(
+        self,
+        repo: str,
+        repo_root: Path,
+        config: dict,
+        agent: Optional[BaseAgent] = None,
+    ):
+        """
+        Args:
+            repo: GitHub repo in "owner/repo" format
+            repo_root: Path to the repository root
+            config: Full autopilot.json configuration
+            agent: Agent to use (created from config if not provided)
+        """
+        self.repo = repo
+        self.repo_root = repo_root
+        self.config = config
+        self.github = GitHubStateManager(repo)
+        self.git = GitOperations(repo_root)
+
+        # Create agent from config if not provided
+        if agent is None:
+            agent_type = config.get("agent", "opencode")
+            agent = get_agent(agent_type, config)
+        self.agent = agent
+
+    def run(self, issue_number: int) -> bool:
+        """
+        Run the issue workflow to completion.
+
+        Resumes from stored state if available, otherwise starts fresh.
+
+        Args:
+            issue_number: GitHub issue number to process
+
+        Returns:
+            True if completed successfully, False if failed
+        """
+        # Load existing state or create new
+        state = self._load_or_create_state(issue_number)
+
+        logger.info(f"Starting issue #{issue_number} from step: {state.step.value}")
+
+        # Run state machine until terminal state
+        terminal_states = {IssueStep.DONE, IssueStep.FAILED}
+
+        while state.step not in terminal_states:
+            try:
+                state = self._transition(state)
+                self._save_state(state)
+            except Exception as e:
+                logger.exception(f"Error in step {state.step.value}")
+                state = replace(
+                    state,
+                    step=IssueStep.FAILED,
+                    error_message=str(e),
+                    updated_at=datetime.utcnow().isoformat() + "Z",
+                )
+                self._save_state(state, f"❌ Failed at step {state.step.value}: {e}")
+                return False
+
+        return state.step == IssueStep.DONE
+
+    def _load_or_create_state(self, issue_number: int) -> StateData:
+        """Load existing state from GitHub or create initial state."""
+        existing = self.github.load_state(issue_number)
+
+        if existing:
+            logger.info(f"Resuming from step: {existing.step.value}")
+            return existing
+
+        # Create initial state
+        branch = f"{self.config.get('branchPrefix', 'autopilot/')}issue-{issue_number}"
+        worktree = f"/tmp/autopilot-issue-{issue_number}"
+
+        return StateData(
+            issue_number=issue_number,
+            step=IssueStep.INIT,
+            branch=branch,
+            worktree=worktree,
+        )
+
+    def _save_state(self, state: StateData, message: Optional[str] = None) -> None:
+        """Persist state to GitHub."""
+        if message is None:
+            message = STEP_STATUS_MESSAGES.get(state.step, f"Step: {state.step.value}")
+        self.github.save_state(state.issue_number, state, message)
+
+    def _transition(self, state: StateData) -> StateData:
+        """Execute one state transition."""
+        handlers = {
+            IssueStep.INIT: self._handle_init,
+            IssueStep.WORKTREE_READY: self._handle_deps,
+            IssueStep.DEPS_INSTALLED: self._handle_fetch_issue,
+            IssueStep.ISSUE_FETCHED: self._handle_planning,
+            IssueStep.PLAN_POSTED: self._handle_implementation,
+            IssueStep.IMPLEMENTED: self._handle_commit,
+            IssueStep.COMMITTED: self._handle_push,
+            IssueStep.PUSHED: self._handle_pr_creation,
+            IssueStep.PR_CREATED: self._handle_conflict_check,
+            IssueStep.CONFLICTS_RESOLVING: self._handle_conflict_resolution,
+            IssueStep.CONFLICTS_RESOLVED: self._handle_checks_wait,
+            IssueStep.CHECKS_WAITING: self._handle_checks_poll,
+            IssueStep.CHECKS_FIXING: self._handle_checks_fix,
+            IssueStep.CHECKS_PASSED: self._handle_merge,
+            IssueStep.MERGED: self._handle_cleanup,
+        }
+
+        handler = handlers.get(state.step)
+        if handler is None:
+            raise ValueError(f"No handler for step: {state.step}")
+
+        return handler(state)
+
+    # === State Handlers ===
+
+    def _handle_init(self, state: StateData) -> StateData:
+        """Create git worktree."""
+        logger.info(f"Creating worktree at {state.worktree}")
+
+        result = self.git.create_worktree(
+            Path(state.worktree),
+            state.branch,
+            self.config.get("allowedBaseBranch", "main"),
+        )
+
+        if not result.success:
+            raise RuntimeError(f"Failed to create worktree: {result.error}")
+
+        return replace(state, step=IssueStep.WORKTREE_READY)
+
+    def _handle_deps(self, state: StateData) -> StateData:
+        """Install dependencies if needed."""
+        worktree = Path(state.worktree)
+
+        if (worktree / "package.json").exists():
+            logger.info("Installing npm dependencies...")
+            result = subprocess.run(
+                ["npm", "install", "--silent"],
+                cwd=worktree,
+                capture_output=True,
+                text=True,
+            )
+            if result.returncode != 0:
+                logger.warning(f"npm install failed: {result.stderr}")
+
+        return replace(state, step=IssueStep.DEPS_INSTALLED)
+
+    def _handle_fetch_issue(self, state: StateData) -> StateData:
+        """Fetch issue title and body."""
+        # Issue details are fetched when needed by agent
+        # This step just marks that we're ready for planning
+        return replace(state, step=IssueStep.ISSUE_FETCHED)
+
+    def _handle_planning(self, state: StateData) -> StateData:
+        """Run planning step if enabled."""
+        if not self.config.get("enablePlanningStep", True):
+            logger.info("Planning step disabled, skipping")
+            return replace(state, step=IssueStep.PLAN_POSTED)
+
+        logger.info("Running planning step...")
+
+        title, body = self.github.get_issue_details(state.issue_number)
+
+        result = self.agent.run_planning(
+            Path(state.worktree), state.issue_number, title, body, state.session_id
+        )
+
+        if not result.success:
+            logger.warning(f"Planning step failed: {result.error}")
+            # Continue anyway - planning is optional
+
+        # Post plan as comment
+        if result.output:
+            plan_comment = f"""## 📋 Implementation Plan
+
+I've analyzed the issue and codebase. Here's my planned approach:
+
+```
+{result.output[:2000]}  # Truncate if too long
+```
+
+I will now proceed with implementation."""
+            self.github.add_progress_comment(state.issue_number, plan_comment)
+
+        return replace(state, step=IssueStep.PLAN_POSTED, session_id=result.session_id)
+
+    def _handle_implementation(self, state: StateData) -> StateData:
+        """Run the agent to implement the issue."""
+        logger.info("Running implementation step...")
+
+        title, body = self.github.get_issue_details(state.issue_number)
+
+        result = self.agent.run_implementation(
+            Path(state.worktree),
+            state.issue_number,
+            title,
+            body,
+            state.branch,
+            state.session_id,
+        )
+
+        if not result.success:
+            raise RuntimeError(f"Implementation failed: {result.error}")
+
+        self.github.add_progress_comment(
+            state.issue_number, "✅ Implementation complete. Now committing changes..."
+        )
+
+        return replace(state, step=IssueStep.IMPLEMENTED, session_id=result.session_id)
+
+    def _handle_commit(self, state: StateData) -> StateData:
+        """Commit changes."""
+        worktree = Path(state.worktree)
+
+        if not self.git.has_changes(worktree):
+            logger.info("No changes to commit")
+            self.github.add_progress_comment(
+                state.issue_number,
+                "ℹ️ No changes were made. The issue may already be resolved.",
+            )
+            return replace(state, step=IssueStep.COMMITTED)
+
+        self.git.stage_all(worktree)
+        result = self.git.commit(
+            worktree, f"autopilot: work for issue #{state.issue_number}"
+        )
+
+        if not result.success:
+            raise RuntimeError(f"Commit failed: {result.error}")
+
+        sha = self.git.get_commit_sha(worktree)
+        count = self.git.get_changed_files_count(worktree)
+
+        self.github.add_progress_comment(
+            state.issue_number,
+            f"📝 Changes committed.\n\n- Commit: `{sha}`\n- Files changed: {count}",
+        )
+
+        return replace(state, step=IssueStep.COMMITTED)
+
+    def _handle_push(self, state: StateData) -> StateData:
+        """Push branch to remote."""
+        result = self.git.push(state.branch, set_upstream=True)
+
+        if not result.success:
+            raise RuntimeError(f"Push failed: {result.error}")
+
+        self.github.add_progress_comment(
+            state.issue_number, f"📤 Changes pushed to branch `{state.branch}`."
+        )
+
+        return replace(state, step=IssueStep.PUSHED)
+
+    def _handle_pr_creation(self, state: StateData) -> StateData:
+        """Create PR if it doesn't exist."""
+        # Check if PR already exists
+        result = self.git._run_gh(
+            [
+                "pr",
+                "view",
+                "--repo",
+                self.repo,
+                "--head",
+                state.branch,
+                "--json",
+                "number",
+            ]
+        )
+
+        if result.success:
+            # PR already exists
+            try:
+                pr_data = json.loads(result.output)
+                pr_number = pr_data.get("number")
+                logger.info(f"PR already exists: #{pr_number}")
+                return replace(state, step=IssueStep.PR_CREATED, pr_number=pr_number)
+            except json.JSONDecodeError:
+                pass
+
+        # Create new PR
+        title, body = self.github.get_issue_details(state.issue_number)
+        pr_title = f"Autopilot: Issue #{state.issue_number} - {title}"
+        pr_body = f"""Closes #{state.issue_number}
+
+This PR is automatically created by Autopilot to implement issue #{state.issue_number}."""
+
+        result = self.git._run_gh(
+            [
+                "pr",
+                "create",
+                "--repo",
+                self.repo,
+                "--title",
+                pr_title,
+                "--body",
+                pr_body,
+                "--base",
+                self.config.get("allowedBaseBranch", "main"),
+                "--head",
+                state.branch,
+            ]
+        )
+
+        if not result.success:
+            raise RuntimeError(f"Failed to create PR: {result.error}")
+
+        # Extract PR number from output
+        # gh outputs: "https://github.com/owner/repo/pull/123"
+        pr_url = result.output.strip()
+        try:
+            pr_number = int(pr_url.split("/")[-1])
+        except (ValueError, IndexError):
+            # Fallback: query for the PR
+            result = self.git._run_gh(
+                [
+                    "pr",
+                    "view",
+                    "--repo",
+                    self.repo,
+                    "--head",
+                    state.branch,
+                    "--json",
+                    "number",
+                ]
+            )
+            pr_data = json.loads(result.output)
+            pr_number = pr_data["number"]
+            pr_url = f"https://github.com/{self.repo}/pull/{pr_number}"
+
+        self.github.add_progress_comment(
+            state.issue_number, f"🔀 Pull request created: [{pr_number}]({pr_url})"
+        )
+
+        return replace(state, step=IssueStep.PR_CREATED, pr_number=pr_number)
+
+    def _handle_conflict_check(self, state: StateData) -> StateData:
+        """Check for merge conflicts."""
+        if not self.config.get("autoResolveConflicts", True):
+            return replace(state, step=IssueStep.CONFLICTS_RESOLVED)
+
+        status = self.git.get_pr_merge_status(self.repo, state.branch)
+
+        if status == MergeStatus.CONFLICTING:
+            logger.info("PR has merge conflicts")
+            return replace(state, step=IssueStep.CONFLICTS_RESOLVING)
+
+        return replace(state, step=IssueStep.CONFLICTS_RESOLVED)
+
+    def _handle_conflict_resolution(self, state: StateData) -> StateData:
+        """Attempt to resolve merge conflicts."""
+        max_attempts = self.config.get("conflictResolutionMaxAttempts", 3)
+
+        if state.conflict_attempts >= max_attempts:
+            raise RuntimeError(
+                f"Failed to resolve conflicts after {max_attempts} attempts"
+            )
+
+        logger.info(
+            f"Attempting conflict resolution ({state.conflict_attempts + 1}/{max_attempts})"
+        )
+
+        worktree = Path(state.worktree)
+
+        # Strategy 1: Try rebase
+        if state.conflict_attempts == 0:
+            logger.info("Attempting rebase strategy...")
+            self.git.fetch()
+            rebase_result = self.git.rebase(worktree)
+
+            if rebase_result.success and not self.git.has_conflicts(worktree):
+                # Rebase succeeded, push force
+                self.git.push(state.branch, force=True)
+                logger.info("Rebase succeeded")
+                return replace(
+                    state,
+                    step=IssueStep.CONFLICTS_RESOLVED,
+                    conflict_attempts=state.conflict_attempts + 1,
+                )
+
+            # If rebase had conflicts, abort and try merge
+            self.git.abort_rebase(worktree)
+
+        # Strategy 2: Try merge
+        if state.conflict_attempts == 1:
+            logger.info("Attempting merge strategy...")
+            merge_result = self.git.merge(worktree)
+
+            if merge_result.success and not self.git.has_conflicts(worktree):
+                # Merge succeeded, push force
+                self.git.push(state.branch, force=True)
+                logger.info("Merge succeeded")
+                return replace(
+                    state,
+                    step=IssueStep.CONFLICTS_RESOLVED,
+                    conflict_attempts=state.conflict_attempts + 1,
+                )
+
+            # If merge had conflicts, abort
+            self.git.abort_merge(worktree)
+
+        # Strategy 3: Use agent to resolve conflicts
+        logger.info("Attempting agent-based conflict resolution...")
+
+        conflicted_files = self.git.get_conflicted_files(worktree)
+        logger.info(f"Conflicted files: {conflicted_files}")
+
+        result = self.agent.run_conflict_resolution(worktree, state.session_id)
+
+        if not result.success:
+            raise RuntimeError(f"Conflict resolution failed: {result.error}")
+
+        # Stage resolved files
+        for file in conflicted_files:
+            self.git._run_git(["add", str(file)], cwd=worktree)
+
+        # Commit if in merge state
+        if self.git.is_merge_in_progress(worktree):
+            commit_result = self.git.commit(
+                worktree, "autopilot: resolve merge conflicts"
+            )
+            if not commit_result.success:
+                raise RuntimeError(
+                    f"Failed to commit conflict resolution: {commit_result.error}"
+                )
+
+        # Push force to update remote
+        push_result = self.git.push(state.branch, force=True)
+        if not push_result.success:
+            raise RuntimeError(
+                f"Failed to push after conflict resolution: {push_result.error}"
+            )
+
+        self.github.add_progress_comment(
+            state.issue_number,
+            f"✅ Merge conflicts resolved (attempt {state.conflict_attempts + 1}/{max_attempts})",
+        )
+
+        return replace(
+            state,
+            step=IssueStep.CONFLICTS_RESOLVED,
+            conflict_attempts=state.conflict_attempts + 1,
+            session_id=result.session_id,
+        )
+
+    def _handle_checks_wait(self, state: StateData) -> StateData:
+        """Start waiting for CI checks."""
+        self.github.add_progress_comment(
+            state.issue_number, "⏳ Waiting for CI checks to complete..."
+        )
+        return replace(state, step=IssueStep.CHECKS_WAITING)
+
+    def _handle_checks_poll(self, state: StateData) -> StateData:
+        """Poll CI check status."""
+        result = self.git._run_gh(
+            [
+                "pr",
+                "checks",
+                "--repo",
+                self.repo,
+                "--head",
+                state.branch,
+                "--json",
+                "name,conclusion,status",
+                "--jq",
+                '.[] | "\(.name):\(.status):\(.conclusion)"',
+            ]
+        )
+
+        if not result.success:
+            # Assume still waiting if we can't get status
+            return replace(state, step=IssueStep.CHECKS_WAITING)
+
+        checks = result.output.strip().split("\n") if result.output.strip() else []
+        has_pending = False
+        has_failed = False
+        failure_context = ""
+
+        for check in checks:
+            parts = check.split(":")
+            if len(parts) >= 3:
+                name, status, conclusion = parts[0], parts[1], parts[2]
+                if status == "in_progress" or status == "queued" or status == "pending":
+                    has_pending = True
+                elif conclusion == "failure":
+                    has_failed = True
+                    failure_context += f"\n❌ {name}: {conclusion}\n"
+                elif conclusion == "action_required":
+                    has_failed = True
+                    failure_context += f"\n⚠️ {name}: {conclusion}\n"
+
+        if has_pending:
+            # Still waiting for checks
+            return replace(state, step=IssueStep.CHECKS_WAITING)
+
+        if has_failed and self.config.get("autoFixChecks", True):
+            # Some checks failed
+            logger.info("CI checks failed, attempting to fix...")
+            self.github.add_progress_comment(
+                state.issue_number,
+                f"⚠️ Some CI checks failed. Attempting to fix...\n{failure_context}",
+            )
+            return replace(state, step=IssueStep.CHECKS_FIXING)
+
+        if has_failed:
+            # Checks failed but auto-fix is disabled
+            error_msg = f"CI checks failed but auto-fix is disabled:\n{failure_context}"
+            raise RuntimeError(error_msg)
+
+        # All checks passed
+        logger.info("All CI checks passed!")
+        return replace(state, step=IssueStep.CHECKS_PASSED)
+
+    def _handle_checks_fix(self, state: StateData) -> StateData:
+        """Attempt to fix failing CI checks."""
+        max_attempts = self.config.get("autoFixChecksMaxAttempts", 3)
+
+        if state.ci_fix_attempts >= max_attempts:
+            raise RuntimeError(f"Failed to fix CI after {max_attempts} attempts")
+
+        logger.info(
+            f"Attempting CI fix (attempt {state.ci_fix_attempts + 1}/{max_attempts})"
+        )
+
+        # Get failure details
+        result = self.git._run_gh(
+            [
+                "pr",
+                "checks",
+                "--repo",
+                self.repo,
+                "--head",
+                state.branch,
+                "--json",
+                "name,conclusion,logUrl",
+                "--jq",
+                '.[] | select(.conclusion == "failure" or .conclusion == "action_required") | "\(.name): \(.logUrl)"',
+            ]
+        )
+
+        failure_context = (
+            result.output if result.success else "Could not fetch failure details"
+        )
+
+        worktree = Path(state.worktree)
+
+        # Pull latest changes first
+        self.git.fetch()
+        result = self.git._run_git(["pull", "origin", state.branch], cwd=worktree)
+        if not result.success:
+            logger.warning(f"Failed to pull latest changes: {result.error}")
+
+        # Run agent to fix
+        agent_result = self.agent.run_ci_fix(
+            worktree,
+            failure_context,
+            state.ci_fix_attempts + 1,
+            max_attempts,
+            state.branch,
+            state.session_id,
+        )
+
+        if not agent_result.success:
+            raise RuntimeError(f"CI fix attempt failed: {agent_result.error}")
+
+        # Commit and push changes
+        if self.git.has_changes(worktree):
+            self.git.stage_all(worktree)
+            commit_msg = f"autopilot: fix CI check failures (attempt {state.ci_fix_attempts + 1}/{max_attempts})"
+            commit_result = self.git.commit(worktree, commit_msg)
+            if not commit_result.success:
+                raise RuntimeError(f"Failed to commit CI fix: {commit_result.error}")
+
+            push_result = self.git.push(state.branch)
+            if not push_result.success:
+                raise RuntimeError(f"Failed to push CI fix: {push_result.error}")
+
+        self.github.add_progress_comment(
+            state.issue_number,
+            f"🔧 CI fix attempt {state.ci_fix_attempts + 1}/{max_attempts} complete. Re-running checks...",
+        )
+
+        return replace(
+            state,
+            step=IssueStep.CHECKS_WAITING,  # Go back to polling
+            ci_fix_attempts=state.ci_fix_attempts + 1,
+            session_id=agent_result.session_id,
+        )
+
+    def _handle_merge(self, state: StateData) -> StateData:
+        """Merge the PR."""
+        if not self.config.get("autoMerge", True):
+            logger.info("Auto-merge is disabled")
+            self.github.add_progress_comment(
+                state.issue_number,
+                "ℹ️ Auto-merge is disabled. Please review and merge manually.",
+            )
+            return replace(state, step=IssueStep.DONE)
+
+        # Check if allowed merge user is configured
+        allowed_users = self.config.get("allowedMergeUsers", [])
+        if not allowed_users:
+            logger.warning("No allowedMergeUsers configured, auto-merge disabled")
+            self.github.add_progress_comment(
+                state.issue_number,
+                "⚠️ No allowedMergeUsers configured. Please review and merge manually.",
+            )
+            return replace(state, step=IssueStep.DONE)
+
+        # Merge the PR
+        result = self.git._run_gh(
+            [
+                "pr",
+                "merge",
+                str(state.pr_number),
+                "--repo",
+                self.repo,
+                "--merge",
+            ]
+        )
+
+        if not result.success:
+            raise RuntimeError(f"Failed to merge PR: {result.error}")
+
+        self.github.add_progress_comment(
+            state.issue_number, f"✅ PR #{state.pr_number} merged successfully!"
+        )
+
+        return replace(state, step=IssueStep.MERGED)
+
+    def _handle_cleanup(self, state: StateData) -> StateData:
+        """Close issue and cleanup."""
+        # Close the issue
+        result = self.git._run_gh(
+            [
+                "issue",
+                "close",
+                str(state.issue_number),
+                "--repo",
+                self.repo,
+            ]
+        )
+
+        if result.success:
+            self.github.add_progress_comment(
+                state.issue_number, "✅ Issue closed. Work complete! 🎉"
+            )
+
+        # Cleanup worktree
+        worktree = Path(state.worktree)
+        if self.git.worktree_exists(worktree):
+            self.git.remove_worktree(worktree)
+
+        return replace(state, step=IssueStep.DONE)