autopilot-code 1.0.0 → 2.0.0

package/scripts/run_autopilot.py

@@ -93,8 +93,7 @@ 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
+    config: dict[str, Any] | None = None
 
 
 def load_config(repo_root: Path) -> RepoConfig | None:
@@ -112,7 +111,10 @@ def load_config(repo_root: Path) -> RepoConfig | None:
     allowed_merge_users = list(data.get("allowedMergeUsers", []))
 
     if auto_merge and not allowed_merge_users:
-        print(f"Warning: [{data.get('repo', 'unknown')}] autoMerge is enabled but allowedMergeUsers is empty. Disabling autoMerge for this repo.", flush=True)
+        print(
+            f"Warning: [{data.get('repo', 'unknown')}] autoMerge is enabled but allowedMergeUsers is empty. Disabling autoMerge for this repo.",
+            flush=True,
+        )
         auto_merge = False
 
     auto_resolve_conflicts = data.get("autoResolveConflicts", True)
@@ -144,7 +146,6 @@ 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,
     )
 
@@ -272,7 +273,9 @@ def load_global_state() -> dict[str, Any]:
 
 def write_global_state(state: dict[str, Any]) -> None:
     GLOBAL_CONFIG_DIR.mkdir(parents=True, exist_ok=True)
-    GLOBAL_STATE_FILE.write_text(json.dumps(state, indent=2, sort_keys=True) + "\n", encoding="utf-8")
+    GLOBAL_STATE_FILE.write_text(
+        json.dumps(state, indent=2, sort_keys=True) + "\n", encoding="utf-8"
+    )
 
 
 def flag_autopilot_needs_update() -> None:
@@ -304,14 +307,14 @@ def is_autopilot_repo(repo: str) -> bool:
 def update_autopilot() -> bool:
     """Update autopilot globally and restart service."""
     print("[autopilot] Updating autopilot-code...", flush=True)
-    
+
     try:
         sh(["npm", "install", "-g", "autopilot-code"], check=True)
         print("[autopilot] Successfully installed updated autopilot-code", flush=True)
     except Exception as e:
         print(f"[autopilot] Failed to install autopilot-code: {e}", flush=True)
         return False
-    
+
     try:
         sh(["systemctl", "--user", "restart", "autopilot"], check=True)
         print("[autopilot] Restarted autopilot service", flush=True)
@@ -436,7 +439,7 @@ def find_opencode() -> str | None:
     opencode = shutil.which("opencode")
     if opencode:
         return opencode
-    
+
     # 2. Check common nvm locations
     home = Path.home()
     nvm_dir = home / ".nvm" / "versions" / "node"
@@ -445,7 +448,7 @@ def find_opencode() -> str | None:
             candidate = node_version / "bin" / "opencode"
             if candidate.exists() and candidate.is_file():
                 return str(candidate)
-    
+
     # 3. Other common locations
     for path in [
         home / ".local" / "bin" / "opencode",
@@ -454,28 +457,36 @@ def find_opencode() -> str | None:
     ]:
         if path.exists() and path.is_file():
             return str(path)
-    
+
     return None
 
 
-def resolve_merge_conflicts(cfg: RepoConfig, issue_number: int, pr: dict[str, Any], attempt: int) -> bool:
+def resolve_merge_conflicts(
+    cfg: RepoConfig, issue_number: int, pr: dict[str, Any], attempt: int
+) -> bool:
     """Attempt to resolve merge conflicts using the coding agent. Returns True if resolved."""
     if cfg.agent != "opencode":
-        print(f"[{cfg.repo}] Cannot resolve conflicts: agent '{cfg.agent}' not supported (only 'opencode')", flush=True)
+        print(
+            f"[{cfg.repo}] Cannot resolve conflicts: agent '{cfg.agent}' not supported (only 'opencode')",
+            flush=True,
+        )
         return False
-    
+
     opencode_bin = find_opencode()
     if not opencode_bin:
         print(f"[{cfg.repo}] Cannot resolve conflicts: opencode not found", flush=True)
         return False
-    
+
     pr_number = pr["number"]
     branch = pr.get("headRefName", f"autopilot/issue-{issue_number}")
     worktree = Path(f"/tmp/autopilot-issue-{issue_number}")
-    
-    print(f"[{cfg.repo}] Attempting to resolve merge conflicts for PR #{pr_number} (attempt {attempt}/{cfg.conflict_resolution_max_attempts})", flush=True)
+
+    print(
+        f"[{cfg.repo}] Attempting to resolve merge conflicts for PR #{pr_number} (attempt {attempt}/{cfg.conflict_resolution_max_attempts})",
+        flush=True,
+    )
     print(f"[{cfg.repo}] Using opencode: {opencode_bin}", flush=True)
-    
+
     # Ensure worktree exists and is up to date
     if not worktree.exists():
         print(f"[{cfg.repo}] Creating worktree at {worktree}", flush=True)
@@ -484,38 +495,50 @@ def resolve_merge_conflicts(cfg: RepoConfig, issue_number: int, pr: dict[str, An
         except Exception as e:
             print(f"[{cfg.repo}] Failed to create worktree: {e}", flush=True)
             return False
-    
+
     # Fetch latest and attempt rebase/merge
     try:
         sh(["git", "fetch", "origin", "main"], cwd=worktree)
-        
+
         # Try to rebase onto main
         rebase_result = subprocess.run(
             ["git", "rebase", "origin/main"],
             cwd=str(worktree),
             capture_output=True,
-            text=True
+            text=True,
         )
-        
+
         if rebase_result.returncode == 0:
             # No conflicts, push and we're done
             sh(["git", "push", "-f", "origin", branch], cwd=worktree)
-            print(f"[{cfg.repo}] Rebase successful, no conflicts to resolve", flush=True)
+            print(
+                f"[{cfg.repo}] Rebase successful, no conflicts to resolve", flush=True
+            )
             return True
-        
+
         # There are conflicts - abort the rebase first
-        subprocess.run(["git", "rebase", "--abort"], cwd=str(worktree), capture_output=True)
-        
+        subprocess.run(
+            ["git", "rebase", "--abort"], cwd=str(worktree), capture_output=True
+        )
+
         # Get list of files that would conflict
-        merge_base = sh(["git", "merge-base", "HEAD", "origin/main"], cwd=worktree).strip()
-        diff_output = sh(["git", "diff", "--name-only", merge_base, "origin/main"], cwd=worktree, check=False)
-        conflicting_files = diff_output.strip().split("\n") if diff_output.strip() else []
-        
+        merge_base = sh(
+            ["git", "merge-base", "HEAD", "origin/main"], cwd=worktree
+        ).strip()
+        diff_output = sh(
+            ["git", "diff", "--name-only", merge_base, "origin/main"],
+            cwd=worktree,
+            check=False,
+        )
+        conflicting_files = (
+            diff_output.strip().split("\n") if diff_output.strip() else []
+        )
+
         # Build prompt for the agent
         conflict_prompt = f"""This PR has merge conflicts with main. Please resolve them.
 
 Branch: {branch}
-Files potentially conflicting: {', '.join(conflicting_files[:10])}
+Files potentially conflicting: {", ".join(conflicting_files[:10])}
 
 Steps:
 1. Run `git fetch origin main`
@@ -532,36 +555,60 @@ Work rules:
 - Preserve the intent of both the PR changes and main branch changes
 - If unsure about a conflict, prefer the PR's changes but ensure compatibility
 """
-        
+
         print(f"[{cfg.repo}] Running opencode to resolve conflicts...", flush=True)
-        
+
         # Run opencode in the worktree
         agent_result = subprocess.run(
             [opencode_bin, "run", conflict_prompt],
             cwd=str(worktree),
             capture_output=True,
             text=True,
-            timeout=600  # 10 minute timeout
+            timeout=600,  # 10 minute timeout
         )
-        
+
         if agent_result.returncode != 0:
-            print(f"[{cfg.repo}] Opencode failed: {agent_result.stderr[:500]}", flush=True)
+            print(
+                f"[{cfg.repo}] Opencode failed: {agent_result.stderr[:500]}", flush=True
+            )
             return False
-        
+
         # Check if conflicts are resolved by checking PR status
         time.sleep(5)  # Give GitHub time to update
-        cmd = ["gh", "pr", "view", str(pr_number), "--repo", cfg.repo, "--json", "mergeable,mergeStateStatus"]
+        cmd = [
+            "gh",
+            "pr",
+            "view",
+            str(pr_number),
+            "--repo",
+            cfg.repo,
+            "--json",
+            "mergeable,mergeStateStatus",
+        ]
         pr_status = json.loads(sh(cmd))
-        
+
         if pr_status.get("mergeable") == "MERGEABLE":
             print(f"[{cfg.repo}] Conflicts resolved successfully!", flush=True)
-            sh(["gh", "issue", "comment", str(issue_number), "--repo", cfg.repo, 
-                "--body", f"✅ Autopilot resolved merge conflicts (attempt {attempt})."])
+            sh(
+                [
+                    "gh",
+                    "issue",
+                    "comment",
+                    str(issue_number),
+                    "--repo",
+                    cfg.repo,
+                    "--body",
+                    f"✅ Autopilot resolved merge conflicts (attempt {attempt}).",
+                ]
+            )
             return True
         else:
-            print(f"[{cfg.repo}] Conflicts still present after resolution attempt", flush=True)
+            print(
+                f"[{cfg.repo}] Conflicts still present after resolution attempt",
+                flush=True,
+            )
             return False
-            
+
     except subprocess.TimeoutExpired:
         print(f"[{cfg.repo}] Conflict resolution timed out", flush=True)
         return False
@@ -574,47 +621,77 @@ def try_merge_pr(cfg: RepoConfig, issue_number: int, pr: dict[str, Any]) -> bool
     """Attempt to merge a PR if it's ready. Returns True if merged or closed."""
     pr_number = pr["number"]
     pr_url = pr["url"]
-    
+
     # If already merged or closed, mark issue as done
     if pr.get("mergedAt") or pr.get("closed"):
-        print(f"[{cfg.repo}] PR #{pr_number} is already merged/closed, marking issue #{issue_number} as done", flush=True)
-        sh(["gh", "issue", "edit", str(issue_number), "--repo", cfg.repo, 
-            "--add-label", cfg.label_done, "--remove-label", cfg.label_in_progress])
+        print(
+            f"[{cfg.repo}] PR #{pr_number} is already merged/closed, marking issue #{issue_number} as done",
+            flush=True,
+        )
+        sh(
+            [
+                "gh",
+                "issue",
+                "edit",
+                str(issue_number),
+                "--repo",
+                cfg.repo,
+                "--add-label",
+                cfg.label_done,
+                "--remove-label",
+                cfg.label_in_progress,
+            ]
+        )
         sh(["gh", "issue", "close", str(issue_number), "--repo", cfg.repo])
         return True
-    
+
     # Check if PR is mergeable
     mergeable = pr.get("mergeable")
     merge_state = pr.get("mergeStateStatus")
-    
+
     # Handle merge conflicts
     if mergeable == "CONFLICTING" or merge_state == "DIRTY":
         print(f"[{cfg.repo}] PR #{pr_number} has merge conflicts", flush=True)
-        
+
         if not cfg.auto_resolve_conflicts:
             print(f"[{cfg.repo}] Auto-resolve conflicts disabled, skipping", flush=True)
             return False
-        
+
         # Load state to track resolution attempts
         state = load_state(cfg.root)
         conflict_key = f"conflict_attempts_{issue_number}"
         attempts = state.get(conflict_key, 0)
-        
+
         if attempts >= cfg.conflict_resolution_max_attempts:
-            print(f"[{cfg.repo}] Max conflict resolution attempts ({cfg.conflict_resolution_max_attempts}) reached", flush=True)
+            print(
+                f"[{cfg.repo}] Max conflict resolution attempts ({cfg.conflict_resolution_max_attempts}) reached",
+                flush=True,
+            )
             if attempts == cfg.conflict_resolution_max_attempts:
                 # Only notify once when we hit the limit
-                sh(["gh", "issue", "comment", str(issue_number), "--repo", cfg.repo,
-                    "--body", f"❌ Autopilot failed to resolve merge conflicts after {attempts} attempts. Manual resolution required."])
-                state[conflict_key] = attempts + 1  # Increment to avoid repeat notifications
+                sh(
+                    [
+                        "gh",
+                        "issue",
+                        "comment",
+                        str(issue_number),
+                        "--repo",
+                        cfg.repo,
+                        "--body",
+                        f"❌ Autopilot failed to resolve merge conflicts after {attempts} attempts. Manual resolution required.",
+                    ]
+                )
+                state[conflict_key] = (
+                    attempts + 1
+                )  # Increment to avoid repeat notifications
                 write_state(cfg.root, state)
             return False
-        
+
         # Attempt to resolve
         attempts += 1
         state[conflict_key] = attempts
         write_state(cfg.root, state)
-        
+
         if resolve_merge_conflicts(cfg, issue_number, pr, attempts):
             # Reset attempts on success
             del state[conflict_key]
@@ -623,70 +700,121 @@ def try_merge_pr(cfg: RepoConfig, issue_number: int, pr: dict[str, Any]) -> bool
             return False  # Return False to re-check on next cycle
         else:
             return False
-    
+
     if mergeable != "MERGEABLE":
-        print(f"[{cfg.repo}] PR #{pr_number} is not mergeable (state: {mergeable}/{merge_state}), skipping", flush=True)
+        print(
+            f"[{cfg.repo}] PR #{pr_number} is not mergeable (state: {mergeable}/{merge_state}), skipping",
+            flush=True,
+        )
         return False
-    
+
     # Get PR check status
     cmd = [
-        "gh", "pr", "view", str(pr_number), "--repo", cfg.repo,
-        "--json", "statusCheckRollup",
+        "gh",
+        "pr",
+        "view",
+        str(pr_number),
+        "--repo",
+        cfg.repo,
+        "--json",
+        "statusCheckRollup",
     ]
     try:
         pr_details = json.loads(sh(cmd))
         checks = pr_details.get("statusCheckRollup", [])
-        
+
         if not checks:
             # No checks configured, can merge
             check_status = "PASSED"
         else:
             # Check if any checks are pending or failed
             has_failure = any(c.get("conclusion") == "FAILURE" for c in checks)
-            has_pending = any(c.get("conclusion") in ("PENDING", "QUEUED", None) for c in checks)
-            
+            has_pending = any(
+                c.get("conclusion") in ("PENDING", "QUEUED", None) for c in checks
+            )
+
             # If all checks are pending/queued and there are more than 0, it's pending
             # But we should also check the rollup state if available
-            rollup_state = pr_details.get("statusCheckRollup", {}).get("state") if isinstance(pr_details.get("statusCheckRollup"), dict) else None
-            
+            rollup_state = (
+                pr_details.get("statusCheckRollup", {}).get("state")
+                if isinstance(pr_details.get("statusCheckRollup"), dict)
+                else None
+            )
+
             if has_failure or rollup_state == "FAILURE":
                 check_status = "FAILED"
             elif has_pending or rollup_state == "PENDING":
                 check_status = "PENDING"
             else:
                 check_status = "PASSED"
-        
+
         if check_status != "PASSED":
-            print(f"[{cfg.repo}] PR #{pr_number} checks not ready (status: {check_status})", flush=True)
+            print(
+                f"[{cfg.repo}] PR #{pr_number} checks not ready (status: {check_status})",
+                flush=True,
+            )
             return False
-        
+
         # Checks passed, attempt merge
         print(f"[{cfg.repo}] PR #{pr_number} is ready, attempting merge...", flush=True)
-        
+
         merge_method = "squash"  # Default, could be read from config if needed
-        merge_cmd = ["gh", "pr", "merge", pr_url, "--delete-branch", f"--{merge_method}"]
-        
+        merge_cmd = [
+            "gh",
+            "pr",
+            "merge",
+            pr_url,
+            "--delete-branch",
+            f"--{merge_method}",
+        ]
+
         try:
             sh(merge_cmd)
             print(f"[{cfg.repo}] Successfully merged PR #{pr_number}!", flush=True)
-            
+
             # Comment and close issue
             success_msg = f"✅ Autopilot successfully merged PR #{pr_number} using {merge_method} method.\n\nThe fix has been merged to the main branch."
-            sh(["gh", "issue", "comment", str(issue_number), "--repo", cfg.repo, "--body", success_msg])
-            sh(["gh", "issue", "edit", str(issue_number), "--repo", cfg.repo, 
-                "--add-label", cfg.label_done, "--remove-label", cfg.label_in_progress])
+            sh(
+                [
+                    "gh",
+                    "issue",
+                    "comment",
+                    str(issue_number),
+                    "--repo",
+                    cfg.repo,
+                    "--body",
+                    success_msg,
+                ]
+            )
+            sh(
+                [
+                    "gh",
+                    "issue",
+                    "edit",
+                    str(issue_number),
+                    "--repo",
+                    cfg.repo,
+                    "--add-label",
+                    cfg.label_done,
+                    "--remove-label",
+                    cfg.label_in_progress,
+                ]
+            )
             sh(["gh", "issue", "close", str(issue_number), "--repo", cfg.repo])
-            
+
             # Flag autopilot for update if we merged our own repo
             if is_autopilot_repo(cfg.repo):
-                print(f"[{cfg.repo}] Merged PR to autopilot repo, flagging for self-update", flush=True)
+                print(
+                    f"[{cfg.repo}] Merged PR to autopilot repo, flagging for self-update",
+                    flush=True,
+                )
                 flag_autopilot_needs_update()
-            
+
             return True
         except Exception as e:
             print(f"[{cfg.repo}] Failed to merge PR #{pr_number}: {e}", flush=True)
             return False
-            
+
     except Exception as e:
         print(f"[{cfg.repo}] Error checking PR #{pr_number}: {e}", flush=True)
         return False
@@ -696,34 +824,46 @@ def clean_completed_issues_from_state(cfg: RepoConfig) -> None:
     """Remove completed issues from state.json."""
     state = load_state(cfg.root)
     active_issues = state.get("activeIssues", {})
-    
+
     if not isinstance(active_issues, dict):
         return
-    
+
     # Check each issue to see if it's still open
     issues_to_remove = []
     for issue_num_str, issue_data in active_issues.items():
         if not isinstance(issue_data, dict):
             continue
-        
+
         issue_num = int(issue_data.get("number", -1))
         if issue_num <= 0:
             continue
-        
+
         # Check if issue is closed
         try:
-            cmd = ["gh", "issue", "view", str(issue_num), "--repo", cfg.repo, "--json", "state,closed"]
+            cmd = [
+                "gh",
+                "issue",
+                "view",
+                str(issue_num),
+                "--repo",
+                cfg.repo,
+                "--json",
+                "state,closed",
+            ]
             result = json.loads(sh(cmd, check=False))
             if result.get("state") == "CLOSED" or result.get("closed"):
-                print(f"[{cfg.repo}] Issue #{issue_num} is closed, removing from state", flush=True)
+                print(
+                    f"[{cfg.repo}] Issue #{issue_num} is closed, removing from state",
+                    flush=True,
+                )
                 issues_to_remove.append(issue_num_str)
         except Exception:
             pass
-    
+
     # Remove completed issues
     for issue_num_str in issues_to_remove:
         del active_issues[issue_num_str]
-    
+
     if issues_to_remove:
         state["activeIssues"] = active_issues
         write_state(cfg.root, state)
@@ -760,55 +900,20 @@ 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.
+    Run the agent on an issue using the Python state machine runner.
     """
-    use_new_runner = cfg.config.get("useNewRunner", True)
-    
-    if not use_new_runner:
-        import logging
-        logger = logging.getLogger(__name__)
-        logger.warning(
-            "Legacy bash runner is deprecated and will be removed in a future version. "
-            "Please migrate to new runner by removing 'useNewRunner: false' from config."
-        )
-    
-    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
-    )
-    
+
+    runner = IssueRunner(repo=cfg.repo, repo_root=cfg.root, config=cfg.config or {})
+
     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
+    return success
 
 
 def run_cycle(
@@ -823,30 +928,36 @@ def run_cycle(
 
     for cfg in all_configs:
         print(f"[{cfg.repo}] Scanning for issues...", flush=True)
-        
+
         # 0) Clean up completed issues from state
         if not dry_run:
             clean_completed_issues_from_state(cfg)
-        
+
         # 1) Check in-progress issues
         inprog = list_in_progress_issues(cfg)
         for it in inprog:
             issue_num = int(it["number"])
-            
+
             # First check if we should mark as blocked due to stale heartbeat
             if not dry_run:
                 # Only mark blocked if heartbeat is stale
                 if not is_heartbeat_fresh(cfg, issue_num):
                     maybe_mark_blocked(cfg, it)
                     continue
-                
+
                 # If heartbeat is fresh and autoMerge is enabled, try to merge PR
                 if cfg.auto_merge:
                     pr = check_pr_for_issue(cfg, issue_num)
                     if pr:
-                        print(f"[{cfg.repo}] Found PR for issue #{issue_num}, checking if ready to merge...", flush=True)
+                        print(
+                            f"[{cfg.repo}] Found PR for issue #{issue_num}, checking if ready to merge...",
+                            flush=True,
+                        )
                         if try_merge_pr(cfg, issue_num, pr):
-                            print(f"[{cfg.repo}] Issue #{issue_num} completed!", flush=True)
+                            print(
+                                f"[{cfg.repo}] Issue #{issue_num} completed!",
+                                flush=True,
+                            )
                         else:
                             # Touch heartbeat to keep it alive while waiting for checks
                             touch_heartbeat(cfg, issue_num)
@@ -873,11 +984,14 @@ def run_cycle(
             continue
 
         for issue in issues[:max_to_claim]:
-            print(f"[{cfg.repo}] next issue: #{issue['number']} {issue['title']}", flush=True)
+            print(
+                f"[{cfg.repo}] next issue: #{issue['number']} {issue['title']}",
+                flush=True,
+            )
             if dry_run:
                 claimed_count += 1
                 continue
-            
+
             # Post initial claim comment
             claim_msg = (
                 f"Autopilot claimed this issue at {time.strftime('%Y-%m-%d %H:%M:%S %Z')}.\n\n"
@@ -889,7 +1003,18 @@ def run_cycle(
 
             # Post comment indicating agent is about to start
             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])
+            sh(
+                [
+                    "gh",
+                    "issue",
+                    "comment",
+                    str(issue["number"]),
+                    "--repo",
+                    cfg.repo,
+                    "--body",
+                    start_msg,
+                ]
+            )
 
             # Run the issue using the appropriate runner
             if cfg.agent == "opencode":
@@ -898,19 +1023,27 @@ def run_cycle(
     # Check if autopilot needs to update
     if not dry_run and check_autopilot_needs_update():
         print("[autopilot] Detected need for self-update", flush=True)
-        
+
         # Check if any repo has auto_update enabled
         any_auto_update = any(cfg.auto_update for cfg in all_configs)
-        
+
         if any_auto_update:
             print("[autopilot] Performing self-update...", flush=True)
             if update_autopilot():
                 clear_autopilot_update_flag()
-                print("[autopilot] Self-update completed, service restarted", flush=True)
+                print(
+                    "[autopilot] Self-update completed, service restarted", flush=True
+                )
             else:
-                print("[autopilot] Self-update failed, flag preserved for next cycle", flush=True)
+                print(
+                    "[autopilot] Self-update failed, flag preserved for next cycle",
+                    flush=True,
+                )
         else:
-            print("[autopilot] auto_update is disabled for all repos, skipping self-update", flush=True)
+            print(
+                "[autopilot] auto_update is disabled for all repos, skipping self-update",
+                flush=True,
+            )
             clear_autopilot_update_flag()
 
     return claimed_count
@@ -949,8 +1082,14 @@ def main() -> int:
         default=None,
         help="Run in loop mode with this interval between cycles (for foreground service mode)",
     )
-    ap.add_argument("--min-priority", help="Override minPriority for all discovered repos")
-    ap.add_argument("--ignore-labels", nargs="+", help="Override ignoreIssueLabels for all discovered repos")
+    ap.add_argument(
+        "--min-priority", help="Override minPriority for all discovered repos"
+    )
+    ap.add_argument(
+        "--ignore-labels",
+        nargs="+",
+        help="Override ignoreIssueLabels for all discovered repos",
+    )
     args = ap.parse_args()
 
     all_configs: list[RepoConfig] = []
@@ -963,14 +1102,14 @@ def main() -> int:
             print(f"Warning: root path {root} is not a directory, skipping", flush=True)
             continue
         configs = discover_repos(root, max_depth=args.max_depth)
-        
+
         # Apply overrides
         for cfg in configs:
             if args.min_priority:
                 cfg.min_priority = args.min_priority
             if args.ignore_labels:
                 cfg.ignore_issue_labels = args.ignore_labels
-        
+
         all_configs.extend(configs)
 
     if not all_configs:
@@ -987,13 +1126,18 @@ def main() -> int:
 
         def signal_handler(signum: int, frame: Any) -> None:
             nonlocal shutdown_requested
-            print("\nShutdown requested (Ctrl+C), finishing current cycle...", flush=True)
+            print(
+                "\nShutdown requested (Ctrl+C), finishing current cycle...", flush=True
+            )
             shutdown_requested = True
 
         signal.signal(signal.SIGINT, signal_handler)
         signal.signal(signal.SIGTERM, signal_handler)
 
-        print(f"Running in foreground mode with {args.interval_seconds}s interval", flush=True)
+        print(
+            f"Running in foreground mode with {args.interval_seconds}s interval",
+            flush=True,
+        )
         print("Press Ctrl+C to shut down cleanly\n", flush=True)
 
         cycle_num = 0