autopilot-code 0.7.0 → 0.9.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "autopilot-code",
-  "version": "0.7.0",
+  "version": "0.9.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/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)

package/scripts/run_autopilot.py

@@ -25,6 +25,12 @@ from dataclasses import dataclass
 from pathlib import Path
 from typing import Any
 import shutil
+from sys import path as sys_path
+
+# Add scripts directory to path for imports
+script_dir = Path(__file__).parent
+sys_path.insert(0, str(script_dir))
+from issue_runner import IssueRunner
 
 STATE_DIR = ".autopilot"
 STATE_FILE = "state.json"
@@ -87,6 +93,8 @@ class RepoConfig:
     auto_fix_checks: bool
     auto_fix_checks_max_attempts: int
     auto_update: bool
+    use_new_runner: bool = False
+    config: dict[str, Any] = None
 
 
 def load_config(repo_root: Path) -> RepoConfig | None:
@@ -136,6 +144,8 @@ def load_config(repo_root: Path) -> RepoConfig | None:
         auto_fix_checks=auto_fix_checks,
         auto_fix_checks_max_attempts=auto_fix_checks_max_attempts,
         auto_update=data.get("autoUpdate", False),
+        use_new_runner=data.get("useNewRunner", False),
+        config=data,
     )
 
 
@@ -366,6 +376,18 @@ def claim_issue(cfg: RepoConfig, issue: dict[str, Any], note: str) -> None:
     touch_heartbeat(cfg, num)
 
 
+def clear_active_issue(cfg: RepoConfig, issue_number: int) -> None:
+    """Clear an issue from active issues state."""
+    state = load_state(cfg.root)
+    active_issues = state.get("activeIssues", {})
+    if isinstance(active_issues, dict):
+        issue_key = str(issue_number)
+        if issue_key in active_issues:
+            del active_issues[issue_key]
+            state["activeIssues"] = active_issues
+            write_state(cfg.root, state)
+
+
 def list_in_progress_issues(cfg: RepoConfig, limit: int = 20) -> list[dict[str, Any]]:
     cmd = [
         "gh",
@@ -736,6 +758,49 @@ def maybe_mark_blocked(cfg: RepoConfig, issue: dict[str, Any]) -> None:
     )
 
 
+def run_issue(cfg: RepoConfig, issue_number: int) -> bool:
+    """
+    Run the agent on an issue.
+    
+    Uses either the new Python runner or legacy bash script
+    based on configuration.
+    """
+    if cfg.use_new_runner:
+        return run_issue_new(cfg, issue_number)
+    else:
+        return run_issue_legacy(cfg, issue_number)
+
+
+def run_issue_new(cfg: RepoConfig, issue_number: int) -> bool:
+    """Run issue using new Python state machine runner."""
+    # Touch heartbeat before starting
+    touch_heartbeat(cfg, issue_number)
+    
+    runner = IssueRunner(
+        repo=cfg.repo,
+        repo_root=cfg.root,
+        config=cfg.config
+    )
+    
+    try:
+        success = runner.run(issue_number)
+    finally:
+        # Clear from active issues when done
+        clear_active_issue(cfg, issue_number)
+    
+    return success
+
+
+def run_issue_legacy(cfg: RepoConfig, issue_number: int) -> bool:
+    """Run issue using legacy bash script (existing behavior)."""
+    script_path = Path(__file__).parent / "run_opencode_issue.sh"
+    result = subprocess.run(
+        [str(script_path), str(cfg.root), str(issue_number)],
+        cwd=cfg.root
+    )
+    return result.returncode == 0
+
+
 def run_cycle(
     all_configs: list[RepoConfig],
     dry_run: bool = False,
@@ -816,18 +881,9 @@ def run_cycle(
             start_msg = f"🚀 Autopilot is now starting work on issue #{issue['number']}.\n\nI'll post regular progress updates as I work through the implementation."
             sh(["gh", "issue", "comment", str(issue["number"]), "--repo", cfg.repo, "--body", start_msg])
 
-            # If agent==opencode, delegate to bash script
+            # Run the issue using the appropriate runner
             if cfg.agent == "opencode":
-                # Script is in the same directory as this Python file
-                script_dir = Path(__file__).parent
-                script_path = script_dir / "run_opencode_issue.sh"
-                sh(
-                    [
-                        str(script_path),
-                        str(cfg.root),
-                        str(issue["number"]),
-                    ]
-                )
+                run_issue(cfg, issue["number"])
 
     # Check if autopilot needs to update
     if not dry_run and check_autopilot_needs_update():