jleechanorg-pr-automation 0.1.1__py3-none-any.whl → 0.2.45__py3-none-any.whl

jleechanorg_pr_automation/jleechanorg_pr_monitor.py

@@ -7,45 +7,156 @@ posting configurable automation comments with safety limits integration.
 """
 
 import argparse
-import os
-import sys
 import json
-import subprocess
-import logging
+import os
 import re
+import shlex
+import shutil
+import subprocess
+import sys
+import time
 import traceback
+import urllib.request
 from collections import Counter
-from pathlib import Path
 from datetime import datetime, timedelta
-from typing import List, Dict, Optional, Tuple
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple
+
+ROOT_DIR = Path(__file__).resolve().parents[2]
+if str(ROOT_DIR) not in sys.path:
+    sys.path.insert(0, str(ROOT_DIR))
+
+from orchestration.task_dispatcher import CLI_PROFILES, TaskDispatcher
+
 from .automation_safety_manager import AutomationSafetyManager
-from .utils import setup_logging, json_manager
 from .automation_utils import AutomationUtils
-
 from .codex_config import (
     CODEX_COMMIT_MARKER_PREFIX as SHARED_MARKER_PREFIX,
+)
+from .codex_config import (
     CODEX_COMMIT_MARKER_SUFFIX as SHARED_MARKER_SUFFIX,
+)
+from .codex_config import (
+    FIX_COMMENT_MARKER_PREFIX as SHARED_FIX_COMMENT_PREFIX,
+)
+from .codex_config import (
+    FIX_COMMENT_MARKER_SUFFIX as SHARED_FIX_COMMENT_SUFFIX,
+)
+from .codex_config import (
+    FIX_COMMENT_RUN_MARKER_PREFIX as SHARED_FIX_COMMENT_RUN_PREFIX,
+)
+from .codex_config import (
+    FIX_COMMENT_RUN_MARKER_SUFFIX as SHARED_FIX_COMMENT_RUN_SUFFIX,
+)
+from .codex_config import (
+    FIXPR_MARKER_PREFIX as SHARED_FIXPR_PREFIX,
+)
+from .codex_config import (
+    FIXPR_MARKER_SUFFIX as SHARED_FIXPR_SUFFIX,
+)
+from .codex_config import (
+    build_automation_marker,
     build_comment_intro,
 )
+from .orchestrated_pr_runner import (
+    chdir,
+    dispatch_agent_for_pr,
+    dispatch_agent_for_pr_with_task,
+    ensure_base_clone,
+    has_failing_checks,
+    run_fixpr_batch,
+)
+from .utils import json_manager, setup_logging
+
+
+def _parse_fixpr_agent_chain(value: str) -> str:
+    """Parse comma-separated CLI chain for --fixpr-agent (e.g., 'gemini,codex')."""
+    if not isinstance(value, str) or not value.strip():
+        raise argparse.ArgumentTypeError("--fixpr-agent must be a non-empty string")
+
+    parts = [part.strip().lower() for part in value.split(",")]
+    chain = [part for part in parts if part]
+    if not chain:
+        raise argparse.ArgumentTypeError("--fixpr-agent chain is empty")
+
+    invalid = [cli for cli in chain if cli not in CLI_PROFILES]
+    if invalid:
+        raise argparse.ArgumentTypeError(
+            f"Invalid --fixpr-agent CLI(s): {invalid}. Must be subset of {list(CLI_PROFILES.keys())}"
+        )
+
+    # De-duplicate while preserving order
+    seen = set()
+    ordered = []
+    for cli in chain:
+        if cli not in seen:
+            ordered.append(cli)
+            seen.add(cli)
+    return ",".join(ordered)
+
+
+def _positive_int_arg(value: str) -> int:
+    try:
+        parsed = int(value)
+    except (TypeError, ValueError) as exc:
+        raise argparse.ArgumentTypeError(f"Expected integer, got {value!r}") from exc
+    if parsed <= 0:
+        raise argparse.ArgumentTypeError(f"Value must be >= 1, got {parsed}")
+    return parsed
+
+
+def _normalize_model(model: Optional[str]) -> Optional[str]:
+    """Return a sanitized model value compatible with orchestration/TaskDispatcher.
+
+    Rejects values that fail TaskDispatcher's model regex.
+    """
+    if model is None:
+        return None
+
+    raw = str(model).strip()
+    if not raw:
+        return None
+
+    if not re.fullmatch(r"[A-Za-z0-9_.-]+", raw):
+        raise argparse.ArgumentTypeError(
+            f"Invalid --model value {raw!r}. Allowed: letters, numbers, '.', '_', '-'."
+        )
+
+    return raw
 
 
 class JleechanorgPRMonitor:
     """Cross-organization PR monitoring with Codex automation comments"""
 
-    @staticmethod
-    def _redact_email(email: Optional[str]) -> Optional[str]:
+    def _determine_workflow_type(self, fix_comment: bool, fixpr: bool = False) -> str:
+        """Determine workflow type from execution context"""
+        if fix_comment:
+            return "fix_comment"
+        elif fixpr:
+            return "fixpr"
+        else:
+            return "pr_automation"
+
+    def _redact_email(self, email: Optional[str]) -> Optional[str]:
         """Redact email for logging while preserving domain for debugging"""
-        if not email or '@' not in email:
+        if not email or "@" not in email:
             return email
-        user, domain = email.rsplit('@', 1)
+        user, domain = email.rsplit("@", 1)
         if len(user) <= 2:
             return f"***@{domain}"
         return f"{user[:2]}***@{domain}"
 
     CODEX_COMMIT_MARKER_PREFIX = SHARED_MARKER_PREFIX
     CODEX_COMMIT_MARKER_SUFFIX = SHARED_MARKER_SUFFIX
+    FIX_COMMENT_MARKER_PREFIX = SHARED_FIX_COMMENT_PREFIX
+    FIX_COMMENT_MARKER_SUFFIX = SHARED_FIX_COMMENT_SUFFIX
+    FIX_COMMENT_RUN_MARKER_PREFIX = SHARED_FIX_COMMENT_RUN_PREFIX
+    FIX_COMMENT_RUN_MARKER_SUFFIX = SHARED_FIX_COMMENT_RUN_SUFFIX
+    FIXPR_MARKER_PREFIX = SHARED_FIXPR_PREFIX
+    FIXPR_MARKER_SUFFIX = SHARED_FIXPR_SUFFIX
     CODEX_COMMIT_MESSAGE_MARKER = "[codex-automation-commit]"
     CODEX_BOT_IDENTIFIER = "codex"
+    FIX_COMMENT_COMPLETION_MARKER = "Fix-comment automation complete"
     # GitHub short SHAs display with a minimum of 7 characters, while full SHAs are 40 characters.
     CODEX_COMMIT_SHA_LENGTH_RANGE: Tuple[int, int] = (7, 40)
     CODEX_SUMMARY_COMMIT_PATTERNS = [
@@ -104,13 +215,31 @@ class JleechanorgPRMonitor:
         for keyword in _codex_actor_keywords
     ]
     _codex_commit_message_pattern_str = (
-        r"\[(?:" + "|".join(_codex_actor_keywords) + r")-automation-commit\]"
+        r"\[(?:fixpr\s+)?(?:" + "|".join(_codex_actor_keywords) + r")-automation-commit\]"
     )
     _codex_commit_message_pattern = re.compile(
         _codex_commit_message_pattern_str,
         re.IGNORECASE,
     )
 
+    # Known GitHub review bots that may appear without [bot] suffix in API responses.
+    # Note: Some bots (e.g., "coderabbitai", "copilot") appear in both this list and
+    # _codex_actor_keywords. This is intentional:
+    # - KNOWN_GITHUB_BOTS: Detects the review service (e.g., "coderabbitai" or "coderabbitai[bot]")
+    #   whose comments should trigger PR re-processing.
+    # - _codex_actor_keywords: Used to exclude our own automation bots from being
+    #   treated as external review bots when they have the [bot] suffix.
+    # The detection order in _is_github_bot_comment() ensures known bots are detected first.
+    KNOWN_GITHUB_BOTS = frozenset({
+        "github-actions",
+        "coderabbitai",
+        "copilot-swe-agent",
+        "dependabot",
+        "renovate",
+        "codecov",
+        "sonarcloud",
+    })
+
     @staticmethod
     def _extract_actor_fields(
         actor: Optional[Dict],
@@ -124,8 +253,9 @@ class JleechanorgPRMonitor:
         name = actor.get("name")
         return (login, email, name)
 
-    def __init__(self):
+    def __init__(self, *, safety_limits: Optional[Dict[str, int]] = None, no_act: bool = False, automation_username: Optional[str] = None):
         self.logger = setup_logging(__name__)
+        self._explicit_automation_username = automation_username
 
         self.assistant_mentions = os.environ.get(
             "AI_ASSISTANT_MENTIONS",
@@ -133,6 +263,7 @@ class JleechanorgPRMonitor:
         )
 
         self.wrapper_managed = os.environ.get("AUTOMATION_SAFETY_WRAPPER") == "1"
+        self.no_act = bool(no_act)
 
         # Processing history persisted to permanent location
         self.history_base_dir = Path.home() / "Library" / "Logs" / "worldarchitect-automation" / "pr_history"
@@ -142,24 +273,30 @@ class JleechanorgPRMonitor:
         self.organization = "jleechanorg"
         self.base_project_dir = Path.home() / "projects"
 
-        safety_data_dir = os.environ.get('AUTOMATION_SAFETY_DATA_DIR')
+        safety_data_dir = os.environ.get("AUTOMATION_SAFETY_DATA_DIR")
         if not safety_data_dir:
             default_dir = Path.home() / "Library" / "Application Support" / "worldarchitect-automation"
             default_dir.mkdir(parents=True, exist_ok=True)
             safety_data_dir = str(default_dir)
 
-        self.safety_manager = AutomationSafetyManager(safety_data_dir)
+        self.safety_manager = AutomationSafetyManager(safety_data_dir, limits=safety_limits)
+
+        # Resolve automation username (CLI > Env > Dynamic)
+        # Note: CLI arg is passed via __init__ if we update signature, but for now we'll handle it
+        # by checking if it was set after init or passing it in.
+        # Actually, let's update __init__ signature to accept it.
+        self.automation_username = self._resolve_automation_username()
 
-        self.logger.info(f"🏢 Initialized jleechanorg PR monitor")
+        self.logger.info("🏢 Initialized jleechanorg PR monitor")
         self.logger.info(f"📁 History storage: {self.history_base_dir}")
-        self.logger.info(f"💬 Comment-only automation mode")
+        self.logger.info("💬 Comment-only automation mode")
     def _get_history_file(self, repo_name: str, branch_name: str) -> Path:
         """Get history file path for specific repo/branch"""
         repo_dir = self.history_base_dir / repo_name
         repo_dir.mkdir(parents=True, exist_ok=True)
 
         # Replace slashes in branch names to avoid creating nested directories
-        safe_branch_name = branch_name.replace('/', '_')
+        safe_branch_name = branch_name.replace("/", "_")
         return repo_dir / f"{safe_branch_name}.json"
 
     def _load_branch_history(self, repo_name: str, branch_name: str) -> Dict[str, str]:
@@ -192,6 +329,37 @@ class JleechanorgPRMonitor:
         self.logger.info(f"⏭️ Skipping PR {repo_name}/{branch_name}#{pr_number} - already processed commit {current_commit[:8]}")
         return True
 
+    def _resolve_automation_username(self) -> str:
+        """Resolve the automation username from multiple sources."""
+        # 1. Explicitly passed (CLI)
+        if self._explicit_automation_username:
+            self.logger.debug(f"👤 Using explicit automation username: {self._explicit_automation_username}")
+            return self._explicit_automation_username
+
+        # 2. Environment variable
+        env_user = os.environ.get("AUTOMATION_USERNAME")
+        if env_user:
+            self.logger.debug(f"👤 Using environment automation username: {env_user}")
+            return env_user
+
+        # 3. Dynamic discovery from GitHub CLI
+        try:
+            result = AutomationUtils.execute_subprocess_with_timeout(
+                ["gh", "api", "user", "--jq", ".login"],
+                timeout=10,
+                check=False
+            )
+            if result.returncode == 0 and result.stdout.strip():
+                user = result.stdout.strip()
+                self.logger.debug(f"👤 Discovered current GitHub user: {user}")
+                return user
+        except Exception as e:
+            self.logger.warning(f"⚠️ Failed to discover GitHub user: {e}")
+
+        # Fallback (should ideally not happen in real usage, but safe default)
+        self.logger.warning("⚠️ Could not resolve automation username, defaulting to 'unknown'")
+        return "unknown"
+
     def _record_processed_pr(self, repo_name: str, branch_name: str, pr_number: int, commit_sha: str) -> None:
         """Record that we've processed a PR with a specific commit"""
         history = self._load_branch_history(repo_name, branch_name)
@@ -219,23 +387,53 @@ class JleechanorgPRMonitor:
     def is_pr_actionable(self, pr_data: Dict) -> bool:
         """Determine if a PR is actionable (should be processed)"""
         # Closed PRs are not actionable
-        if pr_data.get('state', '').lower() != 'open':
+        if pr_data.get("state", "").lower() != "open":
+            return False
+
+        # Draft PRs are not actionable for automation
+        if pr_data.get("isDraft"):
             return False
 
         # PRs with no commits are not actionable
-        head_ref_oid = pr_data.get('headRefOid')
+        head_ref_oid = pr_data.get("headRefOid")
         if not head_ref_oid:
             return False
 
         # Check if already processed with this commit
-        repo_name = pr_data.get('repository', '')
-        branch_name = pr_data.get('headRefName', '')
-        pr_number = pr_data.get('number', 0)
+        repo_name = pr_data.get("repository", "")
+        branch_name = pr_data.get("headRefName", "")
+        pr_number = pr_data.get("number", 0)
 
         if self._should_skip_pr(repo_name, branch_name, pr_number, head_ref_oid):
+            # Even if commit was processed, check for new bot comments that need attention
+            repo_full = pr_data.get("repositoryFullName") or ""
+
+            if not repo_full:
+                if repo_name:
+                    repo_full = self._normalize_repository_name(repo_name)
+                else:
+                    self.logger.warning(
+                        "Skipping PR comment state check: missing repository information "
+                        f"(pr_number={pr_number})"
+                    )
+                    return False
+
+            owner_repo = repo_full.split("/", 1)
+            if len(owner_repo) != 2 or not owner_repo[0].strip() or not owner_repo[1].strip():
+                self.logger.warning(
+                    "Skipping PR comment state check due to invalid repository identifier "
+                    f"repo_full='{repo_full}' (pr_number={pr_number})"
+                )
+                return False
+            _, comments = self._get_pr_comment_state(repo_full, pr_number)
+            if self._has_new_bot_comments_since_codex(comments):
+                self.logger.info(
+                    f"🤖 PR {repo_name}#{pr_number} has new bot comments since last processing - marking actionable"
+                )
+                return True
             return False
 
-        # Open PRs (including drafts) with new commits are actionable
+        # Open non-draft PRs with new commits are actionable
         return True
 
     def filter_eligible_prs(self, pr_list: List[Dict]) -> List[Dict]:
@@ -268,12 +466,64 @@ class JleechanorgPRMonitor:
         eligible_prs = self.filter_eligible_prs(all_prs)
         return eligible_prs[:limit]
 
+    def list_actionable_prs(self, cutoff_hours: int = 24, max_prs: int = 20, mode: str = "fixpr", single_repo: Optional[str] = None) -> List[Dict]:
+        """
+        Return PRs that would be processed for fixpr (merge conflicts or failing checks).
+        """
+        try:
+            prs = self.discover_open_prs(cutoff_hours=cutoff_hours)
+        except TypeError:
+            # Backwards-compatible with older stubs/mocks that don't accept cutoff_hours.
+            prs = self.discover_open_prs()
+        if single_repo:
+            prs = [pr for pr in prs if pr.get("repository") == single_repo]
+
+        actionable = []
+        for pr in prs:
+            repo = pr.get("repository")
+            owner = pr.get("owner", "jleechanorg")
+            pr_number = pr.get("number")
+            if not repo or pr_number is None:
+                continue
+            repo_full = f"{owner}/{repo}"
+
+            mergeable = pr.get("mergeable")
+            if mergeable is None:
+                try:
+                    result = AutomationUtils.execute_subprocess_with_timeout(
+                        ["gh", "pr", "view", str(pr_number), "--repo", repo_full, "--json", "mergeable"],
+                        timeout=30,
+                        check=False,
+                    )
+                    if result.returncode == 0:
+                        data = json.loads(result.stdout or "{}")
+                        mergeable = data.get("mergeable")
+                except Exception:
+                    mergeable = None
+
+            if mergeable == "CONFLICTING":
+                actionable.append({**pr, "repo_full": repo_full})
+                continue
+
+            try:
+                if has_failing_checks(repo_full, pr_number):
+                    actionable.append({**pr, "repo_full": repo_full})
+            except Exception:
+                # Skip on error to avoid blocking listing
+                continue
+
+        actionable = actionable[:max_prs]
+        print(f"🔎 Eligible for fixpr: {len(actionable)}")
+        for pr in actionable:
+            print(f"  • {pr.get('repository')} PR #{pr.get('number')}: {pr.get('title')}")
+        return actionable
+
     def run_monitoring_cycle_with_actionable_count(self, target_actionable_count: int = 20) -> Dict:
         """Enhanced monitoring cycle that processes exactly target actionable PRs"""
         all_prs = self.discover_open_prs()
 
         # Sort by most recently updated first
-        all_prs.sort(key=lambda pr: pr.get('updatedAt', ''), reverse=True)
+        all_prs.sort(key=lambda pr: pr.get("updatedAt", ""), reverse=True)
 
         actionable_processed = 0
         skipped_count = 0
@@ -293,9 +543,9 @@ class JleechanorgPRMonitor:
                 continue  # Already counted in skipped above
 
             # Attempt to process the PR
-            repo_name = pr.get('repository', '')
-            pr_number = pr.get('number', 0)
-            repo_full = pr.get('repositoryFullName', f"jleechanorg/{repo_name}")
+            repo_name = pr.get("repository", "")
+            pr_number = pr.get("number", 0)
+            repo_full = pr.get("repositoryFullName", f"jleechanorg/{repo_name}")
 
             # Reserve a processing slot for this PR
             if not self.safety_manager.try_process_pr(pr_number, repo=repo_full):
@@ -317,17 +567,17 @@ class JleechanorgPRMonitor:
                 self.safety_manager.release_pr_slot(pr_number, repo=repo_full)
 
         return {
-            'actionable_processed': actionable_processed,
-            'total_discovered': len(all_prs),
-            'skipped_count': skipped_count,
-            'processing_failures': processing_failures
+            "actionable_processed": actionable_processed,
+            "total_discovered": len(all_prs),
+            "skipped_count": skipped_count,
+            "processing_failures": processing_failures
         }
 
     def _process_pr_comment(self, repo_name: str, pr_number: int, pr_data: Dict) -> bool:
         """Process a PR by posting a comment (used by tests and enhanced monitoring)"""
         try:
             # Use the existing comment posting method
-            repo_full_name = pr_data.get('repositoryFullName', f"jleechanorg/{repo_name}")
+            repo_full_name = pr_data.get("repositoryFullName", f"jleechanorg/{repo_name}")
             result = self.post_codex_instruction_simple(repo_full_name, pr_number, pr_data)
             # Return True only if comment was actually posted
             return result == "posted"
@@ -335,16 +585,16 @@ class JleechanorgPRMonitor:
             self.logger.error(f"Error processing comment for PR {repo_name}#{pr_number}: {e}")
             return False
 
-    def discover_open_prs(self) -> List[Dict]:
-        """Discover open PRs updated in the last 24 hours across the organization."""
+    def discover_open_prs(self, cutoff_hours: int = 24) -> List[Dict]:
+        """Discover open PRs updated in the last specified hours across the organization."""
 
-        self.logger.info(f"🔍 Discovering open PRs in {self.organization} organization (last 24 hours)")
+        self.logger.info(f"🔍 Discovering open PRs in {self.organization} organization (last {cutoff_hours} hours)")
 
         now = datetime.utcnow()
-        one_day_ago = now - timedelta(hours=24)
-        self.logger.info("📅 Filtering PRs updated since: %s UTC", one_day_ago.strftime('%Y-%m-%d %H:%M:%S'))
+        one_day_ago = now - timedelta(hours=cutoff_hours)
+        self.logger.info("📅 Filtering PRs updated since: %s UTC", one_day_ago.strftime("%Y-%m-%d %H:%M:%S"))
 
-        graphql_query = '''
+        graphql_query = """
         query($searchQuery: String!, $cursor: String) {
           search(type: ISSUE, query: $searchQuery, first: 100, after: $cursor) {
             nodes {
@@ -366,7 +616,7 @@ class JleechanorgPRMonitor:
             pageInfo { hasNextPage endCursor }
           }
         }
-        '''
+        """
 
         search_query = f"org:{self.organization} is:pr is:open"
         cursor: Optional[str] = None
@@ -395,57 +645,57 @@ class JleechanorgPRMonitor:
                 self.logger.error("❌ Failed to parse GraphQL response: %s", exc)
                 raise
 
-            search_data = api_data.get('data', {}).get('search')
+            search_data = api_data.get("data", {}).get("search")
             if not search_data:
                 break
 
-            nodes = search_data.get('nodes', [])
+            nodes = search_data.get("nodes", [])
             for node in nodes:
-                if node.get('__typename') != 'PullRequest':
+                if node.get("__typename") != "PullRequest":
                     continue
 
-                updated_str = node.get('updatedAt')
+                updated_str = node.get("updatedAt")
                 if not updated_str:
                     continue
 
                 try:
-                    updated_time = datetime.fromisoformat(updated_str.replace('Z', '+00:00')).replace(tzinfo=None)
+                    updated_time = datetime.fromisoformat(updated_str.replace("Z", "+00:00")).replace(tzinfo=None)
                 except ValueError:
                     self.logger.debug(
-                        "⚠️ Invalid date format for PR %s: %s", node.get('number'), updated_str
+                        "⚠️ Invalid date format for PR %s: %s", node.get("number"), updated_str
                     )
                     continue
 
                 if updated_time < one_day_ago:
                     continue
 
-                repo_info = node.get('repository') or {}
-                author_info = node.get('author') or {}
-                if 'login' not in author_info:
-                    author_info = {**author_info, 'login': author_info.get('login')}
+                repo_info = node.get("repository") or {}
+                author_info = node.get("author") or {}
+                if "login" not in author_info:
+                    author_info = {**author_info, "login": author_info.get("login")}
 
                 normalized = {
-                    'number': node.get('number'),
-                    'title': node.get('title'),
-                    'headRefName': node.get('headRefName'),
-                    'baseRefName': node.get('baseRefName'),
-                    'updatedAt': updated_str,
-                    'url': node.get('url'),
-                    'author': author_info,
-                    'headRefOid': node.get('headRefOid'),
-                    'state': node.get('state'),
-                    'isDraft': node.get('isDraft'),
-                    'repository': repo_info.get('name'),
-                    'repositoryFullName': repo_info.get('nameWithOwner'),
-                    'updated_datetime': updated_time,
+                    "number": node.get("number"),
+                    "title": node.get("title"),
+                    "headRefName": node.get("headRefName"),
+                    "baseRefName": node.get("baseRefName"),
+                    "updatedAt": updated_str,
+                    "url": node.get("url"),
+                    "author": author_info,
+                    "headRefOid": node.get("headRefOid"),
+                    "state": node.get("state"),
+                    "isDraft": node.get("isDraft"),
+                    "repository": repo_info.get("name"),
+                    "repositoryFullName": repo_info.get("nameWithOwner"),
+                    "updated_datetime": updated_time,
                 }
                 recent_prs.append(normalized)
 
-            page_info = search_data.get('pageInfo') or {}
-            if not page_info.get('hasNextPage'):
+            page_info = search_data.get("pageInfo") or {}
+            if not page_info.get("hasNextPage"):
                 break
 
-            cursor = page_info.get('endCursor')
+            cursor = page_info.get("endCursor")
             if not cursor:
                 break
 
@@ -453,9 +703,9 @@ class JleechanorgPRMonitor:
             self.logger.info("📭 No recent open PRs discovered")
             return []
 
-        recent_prs.sort(key=lambda x: x.get('updated_datetime', datetime.min), reverse=True)
+        recent_prs.sort(key=lambda x: x.get("updated_datetime", datetime.min), reverse=True)
 
-        repo_counter = Counter(pr.get('repository') for pr in recent_prs if pr.get('repository'))
+        repo_counter = Counter(pr.get("repository") for pr in recent_prs if pr.get("repository"))
         for repo_name, count in repo_counter.items():
             self.logger.info("📋 %s: %s recent PRs", repo_name, count)
 
@@ -463,8 +713,8 @@ class JleechanorgPRMonitor:
 
         self.logger.info("📊 Most recently updated PRs:")
         for i, pr in enumerate(recent_prs[:5], 1):
-            updated_str = pr['updated_datetime'].strftime('%Y-%m-%d %H:%M')
-            self.logger.info("  %s. %s #%s - %s", i, pr['repositoryFullName'], pr['number'], updated_str)
+            updated_str = pr["updated_datetime"].strftime("%Y-%m-%d %H:%M")
+            self.logger.info("  %s. %s #%s - %s", i, pr["repositoryFullName"], pr["number"], updated_str)
 
         return recent_prs
 
@@ -533,30 +783,48 @@ class JleechanorgPRMonitor:
         repo_full = self._normalize_repository_name(repository)
         self.logger.info(f"💬 Requesting Codex support for {repo_full} PR #{pr_number}")
 
+        if self.no_act:
+            self.logger.info("🧪 --no-act enabled: skipping comment post for %s #%s", repo_full, pr_number)
+            return "skipped"
+
         # Extract repo name and branch from PR data
-        repo_name = repo_full.split('/')[-1]
-        branch_name = pr_data.get('headRefName', 'unknown')
+        repo_name = repo_full.split("/")[-1]
+        branch_name = pr_data.get("headRefName", "unknown")
 
         # Get current PR state including commit SHA
         head_sha, comments = self._get_pr_comment_state(repo_full, pr_number)
         head_commit_details = None
+        # Flag to bypass skip checks when new bot comments require attention
+        force_process_due_to_bot_comments = False
+
         if head_sha:
             head_commit_details = self._get_head_commit_details(repo_full, pr_number, head_sha)
             if head_commit_details and self._is_head_commit_from_codex(head_commit_details):
-                self.logger.debug(
-                    "🆔 Head commit %s for %s#%s already attributed to Codex",
-                    head_sha[:8],
-                    repo_full,
-                    pr_number,
-                )
-                self._record_processed_pr(repo_name, branch_name, pr_number, head_sha)
-                return "skipped"
+                # Check if there are new bot comments that need attention
+                if self._has_new_bot_comments_since_codex(comments):
+                    self.logger.info(
+                        "🤖 Head commit %s for %s#%s is from Codex, but new bot comments detected - forcing re-run",
+                        head_sha[:8],
+                        repo_full,
+                        pr_number,
+                    )
+                    force_process_due_to_bot_comments = True
+                else:
+                    self.logger.debug(
+                        "🆔 Head commit %s for %s#%s already attributed to Codex",
+                        head_sha[:8],
+                        repo_full,
+                        pr_number,
+                    )
+                    self._record_processed_pr(repo_name, branch_name, pr_number, head_sha)
+                    return "skipped"
 
         if not head_sha:
             self.logger.warning(
                 f"⚠️ Could not determine commit SHA for PR #{pr_number}; proceeding without marker gating"
             )
-        else:
+        elif not force_process_due_to_bot_comments:
+            # Only apply skip checks if we're not forcing a re-run due to new bot comments
             # Check if we should skip this PR based on commit-based tracking
             if self._should_skip_pr(repo_name, branch_name, pr_number, head_sha):
                 self.logger.info(f"⏭️ Skipping PR #{pr_number} - already processed this commit")
@@ -592,9 +860,21 @@ class JleechanorgPRMonitor:
                 "--body", comment_body
             ]
 
-            result = AutomationUtils.execute_subprocess_with_timeout(comment_cmd, timeout=30)
+            result = AutomationUtils.execute_subprocess_with_timeout(
+                comment_cmd,
+                timeout=30,
+                retry_attempts=5,
+                retry_backoff_seconds=1.0,
+                retry_backoff_multiplier=2.0,
+                retry_on_stderr_substrings=(
+                    "was submitted too quickly",
+                    "secondary rate limit",
+                    "API rate limit exceeded",
+                ),
+            )
 
             self.logger.info(f"✅ Posted Codex instruction comment on PR #{pr_number} ({repo_full})")
+            time.sleep(2.0)
 
             # Record that we've processed this PR with this commit when available
             if head_sha:
@@ -630,7 +910,7 @@ class JleechanorgPRMonitor:
             ], timeout=30)
 
             pr_status = json.loads(result.stdout)
-            status_checks = pr_status.get('statusCheckRollup', [])
+            status_checks = pr_status.get("statusCheckRollup", [])
 
             # If no status checks are configured, assume tests are failing
             if not status_checks:
@@ -639,7 +919,7 @@ class JleechanorgPRMonitor:
 
             # Check if all status checks are successful
             for check in status_checks:
-                if check.get('state') not in ['SUCCESS', 'NEUTRAL']:
+                if check.get("state") not in ["SUCCESS", "NEUTRAL"]:
                     self.logger.debug(f"❌ Status check failed: {check.get('name')} - {check.get('state')}")
                     return False
 
@@ -697,127 +977,790 @@ Use your judgment to fix comments from everyone or explain why it should not be
 
         return comment_body
 
-    def _get_pr_comment_state(self, repo_full_name: str, pr_number: int) -> Tuple[Optional[str], List[Dict]]:
-        """Fetch PR comment data needed for Codex comment gating"""
-        view_cmd = [
-            "gh",
-            "pr",
-            "view",
-            str(pr_number),
-            "--repo",
-            repo_full_name,
-            "--json",
-            "headRefOid,comments",
+    def _compose_fix_comment_mentions(self) -> str:
+        mentions = [
+            token for token in (self.assistant_mentions or "").split() if token.startswith("@")
         ]
+        lower_mentions = {token.lower() for token in mentions}
+        if "@greptile" not in lower_mentions:
+            mentions.append("@greptile")
+        return " ".join(mentions)
 
-        try:
-            result = AutomationUtils.execute_subprocess_with_timeout(
-                view_cmd,
-                timeout=30
-            )
-            pr_data = json.loads(result.stdout or "{}")
-            head_sha = pr_data.get("headRefOid")
-
-            # Handle different comment structures from GitHub API
-            comments_data = pr_data.get("comments", [])
-            if isinstance(comments_data, dict):
-                comments = comments_data.get("nodes", [])
-            elif isinstance(comments_data, list):
-                comments = comments_data
-            else:
-                comments = []
+    def _build_fix_comment_prompt_body(
+        self,
+        repository: str,
+        pr_number: int,
+        pr_data: Dict,
+        head_sha: Optional[str],
+        agent_cli: str,
+    ) -> str:
+        cli_chain = [part.strip().lower() for part in str(agent_cli).split(",") if part.strip()]
+        commit_marker_cli = cli_chain[0] if cli_chain else "claude"
+
+        return (
+            f"FIX-COMMENT TASK (SELF-CONTAINED): Update PR #{pr_number} in {repository} "
+            f"(branch {pr_data.get('headRefName', 'unknown')}).\n"
+            "Goal: address all review comments with explicit action-based replies, "
+            "fix failing tests, and resolve merge conflicts.\n\n"
+            f"CLI chain: {agent_cli}. Start immediately.\n\n"
+            "Steps:\n"
+            f"1) gh pr checkout {pr_number}\n\n"
+            "2) Fetch ALL PR feedback sources (pagination-safe) using correct GitHub API endpoints:\n"
+            f"   - Issue comments: `gh api /repos/{repository}/issues/{pr_number}/comments --paginate -F per_page=100`\n"
+            f"   - Review summaries: `gh api /repos/{repository}/pulls/{pr_number}/reviews --paginate -F per_page=100`\n"
+            f"   - Inline review comments: `gh api /repos/{repository}/pulls/{pr_number}/comments --paginate -F per_page=100`\n"
+            "   ⚠️ WARNING: `gh pr view --json comments` ONLY fetches issue comments, NOT inline review comments.\n\n"
+            "3) Apply code changes to address feedback, then reply to **100%** of comments INDIVIDUALLY.\n"
+            "   Threading rules:\n"
+            "   - Inline review comments MUST use threaded replies via the GitHub API.\n"
+            "   - Issue/PR comments do not support threading (they are top-level only).\n\n"
+            "   **Response Protocol** (use ONE of these categories for EACH comment):\n"
+            "   - **FIXED**: Issue implemented with working code → include files modified, tests added, verification\n"
+            "   - **DEFERRED**: Created issue for future work → include issue URL and reason\n"
+            "   - **ACKNOWLEDGED**: Noted but not actionable → include explanation\n"
+            "   - **NOT DONE**: Cannot implement → include specific technical reason\n\n"
+            "   **Reply Methods**:\n"
+            f"   - Inline review comments: `gh api /repos/{repository}/pulls/{pr_number}/comments/{{comment_id}}/replies -f body='[Response text]'`\n"
+            f"   - Issue/PR comments: `gh pr comment {pr_number} --body '[Response text]'`\n"
+            "   - Do NOT post mega-comments consolidating multiple responses; reply individually to each comment.\n\n"
+            "4) Run tests and fix failures (block completion on critical/blocking test failures)\n\n"
+            "5) Resolve merge conflicts (prefer merge over rebase)\n\n"
+            f"6) git add -A && git commit -m \"[{commit_marker_cli}-automation-commit] fix PR #{pr_number} review feedback\" && git push\n\n"
+            f"7) Write completion report to /tmp/orchestration_results/pr-{pr_number}_results.json "
+            "with comments addressed, files modified, tests run, and remaining issues\n\n"
+            "**PR Details:**\n"
+            f"- Title: {pr_data.get('title', 'Unknown')}\n"
+            f"- Author: {pr_data.get('author', {}).get('login', 'unknown')}\n"
+            f"- Branch: {pr_data.get('headRefName', 'unknown')}\n"
+            f"- Commit: {head_sha[:8] if head_sha else 'unknown'} ({head_sha or 'unknown'})\n"
+        )
 
-            # Ensure comments are sorted by creation time (oldest first)
-            # GitHub API should return them sorted, but let's be explicit
-            comments.sort(
-                key=lambda c: (c.get('createdAt') or c.get('updatedAt') or '')
-            )
+    def _build_fix_comment_queued_body(
+        self,
+        repository: str,
+        pr_number: int,
+        pr_data: Dict,
+        head_sha: Optional[str],
+        agent_cli: str = "claude",
+    ) -> str:
+        comment_body = (
+            f"[AI automation - {agent_cli}] Fix-comment run queued for this PR. "
+            "A review request will follow after updates are pushed.\n\n"
+            "**PR Details:**\n"
+            f"- Title: {pr_data.get('title', 'Unknown')}\n"
+            f"- Author: {pr_data.get('author', {}).get('login', 'unknown')}\n"
+            f"- Branch: {pr_data.get('headRefName', 'unknown')}\n"
+            f"- Commit: {head_sha[:8] if head_sha else 'unknown'} ({head_sha or 'unknown'})\n"
+            f"- Agent: {agent_cli}"
+        )
 
-            return head_sha, comments
-        except subprocess.CalledProcessError as e:
-            error_message = e.stderr.strip() if e.stderr else str(e)
-            self.logger.warning(
-                f"⚠️ Failed to fetch PR comment state for PR #{pr_number}: {error_message}"
-            )
-        except json.JSONDecodeError as e:
-            self.logger.warning(
-                f"⚠️ Failed to parse PR comment state for PR #{pr_number}: {e}"
-            )
+        # Always add marker for limit counting, even when head_sha is unavailable.
+        # Use enhanced format: workflow:agent:commit
+        sha_value = head_sha or "unknown"
+        # Extract first CLI from chain (e.g., "gemini,codex" -> "gemini")
+        cli_chain = [part.strip().lower() for part in str(agent_cli).split(",") if part.strip()]
+        marker_cli = cli_chain[0] if cli_chain else "claude"
+        marker = build_automation_marker("fix-comment-run", marker_cli, sha_value)
+        comment_body += f"\n\n{marker}"
 
-        return None, []
+        return comment_body
 
-    def _get_head_commit_details(
+    def _build_fixpr_queued_body(
         self,
-        repo_full_name: str,
+        repository: str,
         pr_number: int,
-        expected_sha: Optional[str] = None,
-    ) -> Optional[Dict[str, Optional[str]]]:
-        """Fetch metadata for the PR head commit using the GitHub GraphQL API."""
+        pr_data: Dict,
+        head_sha: Optional[str],
+        agent_cli: str = "claude",
+    ) -> str:
+        comment_body = (
+            f"[AI automation - {agent_cli}] FixPR run queued for this PR.\n\n"
+            "**PR Details:**\n"
+            f"- Title: {pr_data.get('title', 'Unknown')}\n"
+            f"- Author: {pr_data.get('author', {}).get('login', 'unknown')}\n"
+            f"- Branch: {pr_data.get('headRefName', 'unknown')}\n"
+            f"- Commit: {head_sha[:8] if head_sha else 'unknown'} ({head_sha or 'unknown'})\n"
+            f"- Agent: {agent_cli}"
+        )
 
-        if "/" not in repo_full_name:
-            self.logger.debug(
-                "⚠️ Cannot fetch commit details for %s - invalid repo format",
-                repo_full_name,
-            )
-            return None
+        # Always add marker for limit counting, even when head_sha is unavailable
+        # Use enhanced format: workflow:agent:commit
+        sha_value = head_sha or "unknown"
+        # Extract first CLI from chain (e.g., "gemini,codex" -> "gemini")
+        cli_chain = [part.strip().lower() for part in str(agent_cli).split(",") if part.strip()]
+        marker_cli = cli_chain[0] if cli_chain else "claude"
+        marker = build_automation_marker("fixpr-run", marker_cli, sha_value)
+        comment_body += f"\n\n{marker}"
 
-        owner, name = repo_full_name.split("/", 1)
+        return comment_body
 
-        # Validate GitHub naming constraints (alphanumeric, hyphens, periods, underscores, max 100 chars)
-        import re
-        github_name_pattern = re.compile(r'^[a-zA-Z0-9]([a-zA-Z0-9\-\._]{0,98}[a-zA-Z0-9])?$')
-        if not github_name_pattern.match(owner) or not github_name_pattern.match(name):
-            self.logger.warning(
-                "⚠️ Invalid GitHub identifiers: owner='%s', name='%s'",
-                owner,
-                name,
-            )
-            return None
+    def _build_fix_comment_review_body(
+        self,
+        repository: str,
+        pr_number: int,
+        pr_data: Dict,
+        head_sha: Optional[str],
+        agent_cli: str = "claude",
+    ) -> str:
+        mentions = self._compose_fix_comment_mentions()
+        intro = f"{mentions} [AI automation] {self.FIX_COMMENT_COMPLETION_MARKER}. Please review the updates."
+
+        comment_body = (
+            f"{intro}\n\n"
+            "**Review Request:**\n"
+            "Please review the latest changes, leave feedback, and flag any remaining issues. "
+            "If further fixes are needed, add explicit DONE/NOT DONE guidance.\n\n"
+            "**PR Details:**\n"
+            f"- Title: {pr_data.get('title', 'Unknown')}\n"
+            f"- Author: {pr_data.get('author', {}).get('login', 'unknown')}\n"
+            f"- Branch: {pr_data.get('headRefName', 'unknown')}\n"
+            f"- Commit: {head_sha[:8] if head_sha else 'unknown'} ({head_sha or 'unknown'})\n"
+        )
 
-        # Validate PR number is positive integer
-        if not isinstance(pr_number, int) or pr_number <= 0:
-            self.logger.warning("⚠️ Invalid PR number: %s", pr_number)
-            return None
+        if head_sha:
+            # Extract first CLI from chain (e.g., "gemini,codex" -> "gemini")
+            cli_chain = [part.strip().lower() for part in str(agent_cli).split(",") if part.strip()]
+            marker_cli = cli_chain[0] if cli_chain else "claude"
+            marker = build_automation_marker("fix-comment", marker_cli, head_sha)
+            comment_body += f"\n{marker}"
 
-        cmd = [
+        return comment_body
+
+    def _get_fix_comment_watch_state(
+        self,
+        repo_full: str,
+        pr_number: int,
+    ) -> Tuple[Dict, Optional[str], List[Dict], List[str]]:
+        view_cmd = [
             "gh",
-            "api",
-            "graphql",
-            "-f",
-            f"query={self._HEAD_COMMIT_DETAILS_QUERY}",
-            "-f",
-            f"owner={owner}",
-            "-f",
-            f"name={name}",
-            "-F",
-            f"prNumber={pr_number}",
+            "pr",
+            "view",
+            str(pr_number),
+            "--repo",
+            repo_full,
+            "--json",
+            "title,headRefName,headRefOid,author,comments,commits",
         ]
+        result = AutomationUtils.execute_subprocess_with_timeout(view_cmd, timeout=30, check=False)
+        if result.returncode != 0:
+            raise RuntimeError(result.stderr or f"gh pr view failed for {repo_full}#{pr_number}")
+
+        pr_data = json.loads(result.stdout or "{}")
+        head_sha = pr_data.get("headRefOid")
+
+        comments_data = pr_data.get("comments", [])
+        if isinstance(comments_data, dict):
+            comments = comments_data.get("nodes", [])
+        elif isinstance(comments_data, list):
+            comments = comments_data
+        else:
+            comments = []
+
+        commits_data = pr_data.get("commits", [])
+        if isinstance(commits_data, dict):
+            commit_nodes = commits_data.get("nodes", [])
+        elif isinstance(commits_data, list):
+            commit_nodes = commits_data
+        else:
+            commit_nodes = []
+
+        headlines = []
+        for node in commit_nodes:
+            # Handle both nested 'commit' node structure and flat structure
+            commit_obj = node.get("commit") if isinstance(node, dict) and "commit" in node else node
+            headline = commit_obj.get("messageHeadline") if isinstance(commit_obj, dict) else None
+            if headline:
+                headlines.append(headline)
+
+        return pr_data, head_sha, comments, headlines
+
+    def _post_fix_comment_review(
+        self,
+        repository: str,
+        pr_number: int,
+        pr_data: Dict,
+        head_sha: Optional[str],
+        agent_cli: str = "claude",
+    ) -> bool:
+        repo_full = self._normalize_repository_name(repository)
+        comment_body = self._build_fix_comment_review_body(
+            repo_full,
+            pr_number,
+            pr_data,
+            head_sha,
+            agent_cli,
+        )
 
         try:
-            result = AutomationUtils.execute_subprocess_with_timeout(cmd, timeout=30)
-        except subprocess.CalledProcessError as exc:
-            self.logger.debug(
-                "⚠️ Failed to fetch head commit details for %s#%s: %s",
-                repo_full_name,
+            comment_cmd = [
+                "gh",
+                "pr",
+                "comment",
+                str(pr_number),
+                "--repo",
+                repo_full,
+                "--body",
+                comment_body,
+            ]
+            AutomationUtils.execute_subprocess_with_timeout(
+                comment_cmd,
+                timeout=30,
+                retry_attempts=5,
+                retry_backoff_seconds=1.0,
+                retry_backoff_multiplier=2.0,
+                retry_on_stderr_substrings=(
+                    "was submitted too quickly",
+                    "secondary rate limit",
+                    "API rate limit exceeded",
+                ),
+            )
+            self.logger.info(
+                "✅ Posted fix-comment review request on PR #%s (%s)",
                 pr_number,
-                exc.stderr or exc,
+                repo_full,
             )
-            return None
+            time.sleep(2.0)
+            return True
         except Exception as exc:
-            self.logger.debug(
-                "⚠️ Error executing head commit lookup for %s#%s: %s",
-                repo_full_name,
+            self.logger.error(
+                "❌ Failed to post fix-comment review request on PR #%s: %s",
                 pr_number,
                 exc,
             )
-            return None
+            return False
 
-        try:
-            data = json.loads(result.stdout or "{}")
-        except json.JSONDecodeError as exc:
-            self.logger.debug(
-                "⚠️ Failed to decode commit details for %s#%s: %s",
-                repo_full_name,
+    def _post_fix_comment_queued(
+        self,
+        repository: str,
+        pr_number: int,
+        pr_data: Dict,
+        head_sha: Optional[str],
+        agent_cli: str = "claude",
+    ) -> bool:
+        repo_full = self._normalize_repository_name(repository)
+        comment_body = self._build_fix_comment_queued_body(
+            repo_full,
+            pr_number,
+            pr_data,
+            head_sha,
+            agent_cli=agent_cli,
+        )
+
+        try:
+            queued_cmd = [
+                "gh",
+                "pr",
+                "comment",
+                str(pr_number),
+                "--repo",
+                repo_full,
+                "--body",
+                comment_body,
+            ]
+            AutomationUtils.execute_subprocess_with_timeout(
+                queued_cmd,
+                timeout=30,
+                retry_attempts=5,
+                retry_backoff_seconds=1.0,
+                retry_backoff_multiplier=2.0,
+                retry_on_stderr_substrings=(
+                    "was submitted too quickly",
+                    "secondary rate limit",
+                    "API rate limit exceeded",
+                ),
+            )
+            self.logger.info(
+                "✅ Posted fix-comment queued notice on PR #%s (%s)",
+                pr_number,
+                repo_full,
+            )
+            time.sleep(2.0)
+            return True
+        except Exception as exc:
+            self.logger.error(
+                "❌ Failed to post fix-comment queued notice on PR #%s: %s",
+                pr_number,
+                exc,
+            )
+            return False
+
+    def _post_fixpr_queued(
+        self,
+        repository: str,
+        pr_number: int,
+        pr_data: Dict,
+        head_sha: Optional[str],
+        agent_cli: str = "claude",
+    ) -> bool:
+        repo_full = self._normalize_repository_name(repository)
+        comment_body = self._build_fixpr_queued_body(
+            repo_full,
+            pr_number,
+            pr_data,
+            head_sha,
+            agent_cli=agent_cli,
+        )
+
+        try:
+            queued_cmd = [
+                "gh",
+                "pr",
+                "comment",
+                str(pr_number),
+                "--repo",
+                repo_full,
+                "--body",
+                comment_body,
+            ]
+            AutomationUtils.execute_subprocess_with_timeout(
+                queued_cmd,
+                timeout=30,
+                retry_attempts=5,
+                retry_backoff_seconds=1.0,
+                retry_backoff_multiplier=2.0,
+                retry_on_stderr_substrings=(
+                    "was submitted too quickly",
+                    "secondary rate limit",
+                    "API rate limit exceeded",
+                ),
+            )
+            self.logger.info(
+                "✅ Posted fixpr queued notice on PR #%s (%s)",
+                pr_number,
+                repo_full,
+            )
+            time.sleep(2.0)
+            return True
+        except Exception as exc:
+            self.logger.error(
+                "❌ Failed to post fixpr queued notice on PR #%s: %s",
+                pr_number,
+                exc,
+            )
+            return False
+
+    def _start_fix_comment_review_watcher(
+        self,
+        repository: str,
+        pr_number: int,
+        agent_cli: str,
+    ) -> bool:
+        repo_full = self._normalize_repository_name(repository)
+        env = os.environ.copy()
+        pythonpath_parts = [str(ROOT_DIR), str(ROOT_DIR / "automation")]
+        if env.get("PYTHONPATH"):
+            pythonpath_parts.append(env["PYTHONPATH"])
+        env["PYTHONPATH"] = ":".join(pythonpath_parts)
+
+        cmd = [
+            sys.executable,
+            "-m",
+            "jleechanorg_pr_automation.jleechanorg_pr_monitor",
+            "--fix-comment-watch",
+            "--target-pr",
+            str(pr_number),
+            "--target-repo",
+            repo_full,
+            "--fixpr-agent",
+            agent_cli,
+        ]
+        try:
+            subprocess.Popen(
+                cmd,
+                cwd=str(ROOT_DIR),
+                env=env,
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+                start_new_session=True,
+            )
+            self.logger.info(
+                "🧭 Started fix-comment review watcher for PR #%s (%s)",
+                pr_number,
+                repo_full,
+            )
+            return True
+        except Exception as exc:
+            self.logger.error(
+                "❌ Failed to start fix-comment review watcher for PR #%s: %s",
+                pr_number,
+                exc,
+            )
+            return False
+
+    def run_fix_comment_review_watcher(
+        self,
+        pr_number: int,
+        repository: str,
+        agent_cli: str = "claude",
+    ) -> bool:
+        repo_full = self._normalize_repository_name(repository)
+        cli_chain = [part.strip().lower() for part in str(agent_cli).split(",") if part.strip()]
+        commit_marker_cli = cli_chain[0] if cli_chain else "claude"
+        commit_marker = f"[{commit_marker_cli}-automation-commit]"
+        timeout_seconds = int(os.environ.get("FIX_COMMENT_WATCH_TIMEOUT", "3600"))
+        poll_interval = float(os.environ.get("FIX_COMMENT_WATCH_POLL", "30"))
+        deadline = time.time() + timeout_seconds
+
+        while time.time() < deadline:
+            try:
+                pr_data, head_sha, comments, headlines = self._get_fix_comment_watch_state(
+                    repo_full,
+                    pr_number,
+                )
+            except Exception as exc:
+                self.logger.warning(
+                    "⚠️ Fix-comment watcher failed to fetch PR state for #%s: %s",
+                    pr_number,
+                    exc,
+                )
+                time.sleep(poll_interval)
+                continue
+
+            if head_sha and self._has_fix_comment_comment_for_commit(comments, head_sha):
+                self.logger.info(
+                    "✅ Fix-comment review already posted for PR #%s",
+                    pr_number,
+                )
+                return True
+
+            if any(commit_marker in headline for headline in headlines):
+                if self._post_fix_comment_review(repo_full, pr_number, pr_data, head_sha, agent_cli):
+                    return True
+                return False
+
+            time.sleep(poll_interval)
+
+        self.logger.warning(
+            "⏳ Fix-comment watcher timed out for PR #%s after %ss",
+            pr_number,
+            timeout_seconds,
+        )
+        return False
+
+    def dispatch_fix_comment_agent(
+        self,
+        repository: str,
+        pr_number: int,
+        pr_data: Dict,
+        agent_cli: str = "claude",
+        model: str = None,
+    ) -> bool:
+        repo_full = self._normalize_repository_name(repository)
+        repo_name = repo_full.split("/")[-1]
+        branch = pr_data.get("headRefName", "")
+        if not branch:
+            branch = f"pr-{pr_number}"
+
+        head_sha = pr_data.get("headRefOid")
+        task_description = self._build_fix_comment_prompt_body(
+            repo_full,
+            pr_number,
+            pr_data,
+            head_sha,
+            agent_cli,
+        )
+
+        pr_payload = {
+            "repo_full": repo_full,
+            "repo": repo_name,
+            "number": pr_number,
+            "branch": branch,
+        }
+
+        try:
+            base_dir = ensure_base_clone(repo_full)
+            with chdir(base_dir):
+                dispatcher = TaskDispatcher()
+                return dispatch_agent_for_pr_with_task(
+                    dispatcher,
+                    pr_payload,
+                    task_description,
+                    agent_cli=agent_cli,
+                    model=model,
+                )
+        except Exception as exc:
+            self.logger.error(
+                "❌ Failed to dispatch fix-comment agent for %s #%s: %s",
+                repo_full,
+                pr_number,
+                exc,
+            )
+            return False
+
+    def _process_pr_fix_comment(
+        self,
+        repository: str,
+        pr_number: int,
+        pr_data: Dict,
+        agent_cli: str = "claude",
+        model: str = None,
+    ) -> str:
+        repo_full = self._normalize_repository_name(repository)
+        repo_name = repo_full.split("/")[-1]
+        branch_name = pr_data.get("headRefName", "unknown")
+
+        if self.no_act:
+            self.logger.info("🧪 --no-act enabled: skipping fix-comment dispatch for %s #%s", repo_full, pr_number)
+            return "skipped"
+
+        head_sha, comments = self._get_pr_comment_state(repo_full, pr_number)
+        if head_sha and pr_data.get("headRefOid") != head_sha:
+            pr_data = {**pr_data, "headRefOid": head_sha}
+
+        # Check workflow-specific safety limits for fix-comment
+        fix_comment_count = self._count_workflow_comments(comments, "fix_comment")
+        if fix_comment_count >= self.safety_manager.fix_comment_limit:
+            self.logger.info(
+                f"🚫 Safety limits exceeded for PR {repo_full} #{pr_number} (fix-comment); "
+                f"{fix_comment_count}/{self.safety_manager.fix_comment_limit} fix-comment automation comments"
+            )
+            return "skipped"
+
+        # Check if we've already processed this PR with this commit
+        if head_sha and self._should_skip_pr(repo_name, branch_name, pr_number, head_sha):
+            self.logger.info(
+                "⏭️ Skipping PR #%s - already processed commit %s",
+                pr_number,
+                head_sha[:8],
+            )
+            return "skipped"
+
+        if head_sha and self._has_fix_comment_comment_for_commit(comments, head_sha):
+            self.logger.info(
+                "♻️ Fix-comment automation already posted for commit %s on PR #%s, skipping",
+                head_sha[:8],
+                pr_number,
+            )
+            self._record_processed_pr(repo_name, branch_name, pr_number, head_sha)
+            return "skipped"
+
+        if not self.dispatch_fix_comment_agent(repo_full, pr_number, pr_data, agent_cli=agent_cli, model=model):
+            return "failed"
+
+        queued_posted = self._post_fix_comment_queued(repo_full, pr_number, pr_data, head_sha, agent_cli=agent_cli)
+
+        if head_sha:
+            self._record_processed_pr(repo_name, branch_name, pr_number, head_sha)
+
+        if not self._start_fix_comment_review_watcher(
+            repo_full,
+            pr_number,
+            agent_cli=agent_cli,
+        ):
+            self.logger.warning(
+                "⚠️ Failed to start review watcher for PR #%s, but agent is dispatched",
+                pr_number,
+            )
+            return "failed"
+
+        if not queued_posted:
+            self.logger.warning(
+                "⚠️ Queued comment failed for PR #%s, but agent and watcher are running",
+                pr_number,
+            )
+            return "partial"
+
+        return "posted"
+
+    def _process_pr_fixpr(
+        self,
+        repository: str,
+        pr_number: int,
+        pr_data: Dict,
+        agent_cli: str = "claude",
+        model: Optional[str] = None,
+    ) -> str:
+        repo_full = self._normalize_repository_name(repository)
+        repo_name = repo_full.split("/")[-1]
+        branch_name = pr_data.get("headRefName", "unknown")
+
+        if self.no_act:
+            self.logger.info("🧪 --no-act enabled: skipping fixpr dispatch for %s #%s", repo_full, pr_number)
+            return "skipped"
+
+        head_sha, comments = self._get_pr_comment_state(repo_full, pr_number)
+        if head_sha and pr_data.get("headRefOid") != head_sha:
+            pr_data = {**pr_data, "headRefOid": head_sha}
+
+        # Check workflow-specific safety limits for fixpr
+        fixpr_count = self._count_workflow_comments(comments, "fixpr")
+        if fixpr_count >= self.safety_manager.fixpr_limit:
+            self.logger.info(
+                f"🚫 Safety limits exceeded for PR {repo_full} #{pr_number} (fixpr); "
+                f"{fixpr_count}/{self.safety_manager.fixpr_limit} fixpr automation comments"
+            )
+            return "skipped"
+
+        # Check if we've already processed this PR with this commit (reusing skip logic)
+        # FixPR logic typically runs on every push unless skipped by other means.
+        # But for now, let's assume we don't want to loop infinitely on the same commit.
+        if head_sha and self._should_skip_pr(repo_name, branch_name, pr_number, head_sha):
+            self.logger.info(
+                "⏭️ Skipping PR #%s - already processed commit %s",
+                pr_number,
+                head_sha[:8],
+            )
+            return "skipped"
+
+        # Dispatch agent for fixpr
+        try:
+            base_dir = ensure_base_clone(repo_full)
+            with chdir(base_dir):
+                dispatcher = TaskDispatcher()
+                # Prepare PR dict for dispatch_agent_for_pr
+                pr_info = {
+                    "repo_full": repo_full,
+                    "repo": repo_name,
+                    "number": pr_number,
+                    "branch": branch_name,
+                }
+                success = dispatch_agent_for_pr(dispatcher, pr_info, agent_cli=agent_cli, model=model)
+
+                if success:
+                    queued_posted = self._post_fixpr_queued(repo_full, pr_number, pr_data, head_sha, agent_cli=agent_cli)
+                    # Record processing so we don't loop
+                    if head_sha:
+                        self._record_processed_pr(repo_name, branch_name, pr_number, head_sha)
+
+                    if not queued_posted:
+                        self.logger.warning(
+                            "⚠️ Queued comment failed for PR #%s, but agent is dispatched",
+                            pr_number,
+                        )
+                        return "partial"
+
+                    return "posted" # "posted" means action taken
+                else:
+                    return "failed"
+        except Exception as exc:
+            self.logger.error(
+                "❌ Failed to dispatch fixpr agent for %s #%s: %s",
+                repo_full,
+                pr_number,
+                exc,
+            )
+            return "failed"
+
+    def _get_pr_comment_state(self, repo_full_name: str, pr_number: int) -> Tuple[Optional[str], List[Dict]]:
+        """Fetch PR comment data needed for Codex comment gating"""
+        view_cmd = [
+            "gh",
+            "pr",
+            "view",
+            str(pr_number),
+            "--repo",
+            repo_full_name,
+            "--json",
+            "headRefOid,comments",
+        ]
+
+        try:
+            result = AutomationUtils.execute_subprocess_with_timeout(
+                view_cmd,
+                timeout=30
+            )
+            pr_data = json.loads(result.stdout or "{}")
+            head_sha = pr_data.get("headRefOid")
+
+            # Handle different comment structures from GitHub API
+            comments_data = pr_data.get("comments", [])
+            if isinstance(comments_data, dict):
+                comments = comments_data.get("nodes", [])
+            elif isinstance(comments_data, list):
+                comments = comments_data
+            else:
+                comments = []
+
+            # Ensure comments are sorted by creation time (oldest first)
+            # GitHub API should return them sorted, but let's be explicit
+            comments.sort(
+                key=lambda c: (c.get("createdAt") or c.get("updatedAt") or "")
+            )
+
+            return head_sha, comments
+        except subprocess.CalledProcessError as e:
+            error_message = e.stderr.strip() if e.stderr else str(e)
+            self.logger.warning(
+                f"⚠️ Failed to fetch PR comment state for PR #{pr_number}: {error_message}"
+            )
+        except json.JSONDecodeError as e:
+            self.logger.warning(
+                f"⚠️ Failed to parse PR comment state for PR #{pr_number}: {e}"
+            )
+
+        return None, []
+
+    def _get_head_commit_details(
+        self,
+        repo_full_name: str,
+        pr_number: int,
+        expected_sha: Optional[str] = None,
+    ) -> Optional[Dict[str, Optional[str]]]:
+        """Fetch metadata for the PR head commit using the GitHub GraphQL API."""
+
+        if "/" not in repo_full_name:
+            self.logger.debug(
+                "⚠️ Cannot fetch commit details for %s - invalid repo format",
+                repo_full_name,
+            )
+            return None
+
+        owner, name = repo_full_name.split("/", 1)
+
+        # Validate GitHub naming constraints (alphanumeric, hyphens, periods, underscores, max 100 chars)
+        github_name_pattern = re.compile(r"^[a-zA-Z0-9]([a-zA-Z0-9\-\._]{0,98}[a-zA-Z0-9])?$")
+        if not github_name_pattern.match(owner) or not github_name_pattern.match(name):
+            self.logger.warning(
+                "⚠️ Invalid GitHub identifiers: owner='%s', name='%s'",
+                owner,
+                name,
+            )
+            return None
+
+        # Validate PR number is positive integer
+        if not isinstance(pr_number, int) or pr_number <= 0:
+            self.logger.warning("⚠️ Invalid PR number: %s", pr_number)
+            return None
+
+        cmd = [
+            "gh",
+            "api",
+            "graphql",
+            "-f",
+            f"query={self._HEAD_COMMIT_DETAILS_QUERY}",
+            "-f",
+            f"owner={owner}",
+            "-f",
+            f"name={name}",
+            "-F",
+            f"prNumber={pr_number}",
+        ]
+
+        try:
+            result = AutomationUtils.execute_subprocess_with_timeout(cmd, timeout=30)
+        except subprocess.CalledProcessError as exc:
+            self.logger.debug(
+                "⚠️ Failed to fetch head commit details for %s#%s: %s",
+                repo_full_name,
+                pr_number,
+                exc.stderr or exc,
+            )
+            return None
+        except Exception as exc:
+            self.logger.debug(
+                "⚠️ Error executing head commit lookup for %s#%s: %s",
+                repo_full_name,
+                pr_number,
+                exc,
+            )
+            return None
+
+        try:
+            data = json.loads(result.stdout or "{}")
+        except json.JSONDecodeError as exc:
+            self.logger.debug(
+                "⚠️ Failed to decode commit details for %s#%s: %s",
+                repo_full_name,
                 pr_number,
                 exc,
             )
@@ -886,6 +1829,32 @@ Use your judgment to fix comments from everyone or explain why it should not be
 
         return comment_body[start_index:end_index].strip()
 
+    def _extract_fix_comment_marker(self, comment_body: str) -> Optional[str]:
+        """Extract commit SHA from fix-comment automation comments.
+        
+        Handles both old format (SHA) and new format (SHA:cli).
+        Returns just the SHA portion for comparison.
+        """
+        if not comment_body:
+            return None
+
+        prefix_index = comment_body.find(self.FIX_COMMENT_MARKER_PREFIX)
+        if prefix_index == -1:
+            return None
+
+        start_index = prefix_index + len(self.FIX_COMMENT_MARKER_PREFIX)
+        end_index = comment_body.find(self.FIX_COMMENT_MARKER_SUFFIX, start_index)
+        if end_index == -1:
+            return None
+
+        marker_content = comment_body[start_index:end_index].strip()
+        # Handle new format: SHA:cli -> extract just SHA
+        # Also handles old format: SHA (no colon)
+        if ":" in marker_content:
+            marker_content = marker_content.split(":")[0]
+        
+        return marker_content
+
     def _has_codex_comment_for_commit(self, comments: List[Dict], head_sha: str) -> bool:
         """Determine if Codex instruction already exists for the latest commit"""
         if not head_sha:
@@ -899,6 +1868,19 @@ Use your judgment to fix comments from everyone or explain why it should not be
 
         return False
 
+    def _has_fix_comment_comment_for_commit(self, comments: List[Dict], head_sha: str) -> bool:
+        """Determine if fix-comment automation already ran for the latest commit."""
+        if not head_sha:
+            return False
+
+        for comment in comments:
+            body = comment.get("body", "")
+            marker_sha = self._extract_fix_comment_marker(body)
+            if marker_sha and marker_sha == head_sha and self.FIX_COMMENT_COMPLETION_MARKER in body:
+                return True
+
+        return False
+
     def _is_head_commit_from_codex(
         self, commit_details: Optional[Dict[str, Optional[str]]]
     ) -> bool:
@@ -933,6 +1915,172 @@ Use your judgment to fix comments from everyone or explain why it should not be
 
         return False
 
+    def _is_github_bot_comment(self, comment: Dict) -> bool:
+        """Check if comment is from a GitHub bot (not Codex/AI automation).
+
+        Detection order matters:
+        1. Check KNOWN_GITHUB_BOTS first (these are review bots we want to detect)
+        2. Then check [bot] suffix for other bots
+        3. Only exclude codex patterns for bots NOT in our known list
+        """
+        author_login = self._get_comment_author_login(comment)
+        if not author_login:
+            return False
+
+        lower_login = author_login.lower()
+
+        # Strip [bot] suffix for known bot comparison (handles both "coderabbitai" and "coderabbitai[bot]")
+        base_login = lower_login.removesuffix("[bot]")
+
+        # Check known review bots FIRST (before codex pattern exclusion)
+        # These are legitimate review bots whose comments should trigger re-processing
+        if base_login in self.KNOWN_GITHUB_BOTS:
+            return True
+
+        # GitHub bots have [bot] suffix - but exclude our own automation bots
+        # Use case-insensitive check for robustness
+        if lower_login.endswith("[bot]"):
+            # Exclude our own Codex/AI automation bots (chatgpt-codex-connector[bot], etc.)
+            for pattern in self._codex_actor_patterns:
+                if pattern.search(lower_login):
+                    return False
+            return True
+
+        return False
+
+    def _get_last_codex_automation_comment_time(self, comments: List[Dict]) -> Optional[str]:
+        """Find the timestamp of the last automation comment (any workflow marker).
+
+        Note: Despite the method name, this checks ALL automation workflow markers
+        (codex, fix-comment, fixpr) to prevent rerun gating misfires with multiple workflows.
+        """
+        last_time = None
+
+        for comment in comments:
+            body = comment.get("body", "")
+            # Check if this is ANY automation comment (any workflow marker)
+            if (
+                self.CODEX_COMMIT_MARKER_PREFIX in body
+                or self.FIX_COMMENT_MARKER_PREFIX in body
+                or self.FIX_COMMENT_RUN_MARKER_PREFIX in body
+                or self.FIXPR_MARKER_PREFIX in body
+            ):
+                created_at = comment.get("createdAt") or comment.get("updatedAt")
+                if created_at and (last_time is None or created_at > last_time):
+                    last_time = created_at
+
+        return last_time
+
+    def _count_codex_automation_comments(self, comments: List[Dict]) -> int:
+        """Count the number of Codex automation comments (with commit marker).
+
+        This is used for safety limits - we only count comments that contain
+        the CODEX_COMMIT_MARKER_PREFIX, not all comments from jleechan2015.
+        """
+        count = 0
+        for comment in comments:
+            body = comment.get("body", "")
+            if self.CODEX_COMMIT_MARKER_PREFIX in body or self.FIX_COMMENT_MARKER_PREFIX in body:
+                count += 1
+        return count
+
+    def _count_workflow_comments(self, comments: List[Dict], workflow_type: str) -> int:
+        """Count automation comments for a specific workflow type.
+
+        Args:
+            comments: List of PR comments
+            workflow_type: One of 'pr_automation', 'fix_comment', 'codex_update', 'fixpr'
+
+        Returns:
+            Count of comments matching the workflow type
+
+        Note: codex_update workflow operates via browser automation (not PR comments),
+        so count is always 0. The limit is configured but unused, reserved for future
+        compatibility if codex_update ever posts PR comments.
+        """
+        # codex_update doesn't post PR comments, so always returns 0
+        # Limit is configured but unused (reserved for future compatibility)
+        if workflow_type == "codex_update":
+            return 0
+
+        count = 0
+        for comment in comments:
+            body = comment.get("body", "")
+
+            if workflow_type == "pr_automation":
+                # PR automation uses codex-automation-commit marker (but not fix-comment or fixpr)
+                if (
+                    self.CODEX_COMMIT_MARKER_PREFIX in body
+                    and self.FIX_COMMENT_MARKER_PREFIX not in body
+                    and self.FIX_COMMENT_RUN_MARKER_PREFIX not in body
+                    and self.FIXPR_MARKER_PREFIX not in body
+                ):
+                    count += 1
+            elif workflow_type == "fix_comment":
+                # Fix-comment workflow uses dedicated markers for queued runs + completion.
+                # Only count if posted by the automation user, not bots echoing the marker
+                if self.FIX_COMMENT_RUN_MARKER_PREFIX in body or self.FIX_COMMENT_MARKER_PREFIX in body:
+                    author = self._get_comment_author_login(comment)
+                    # Only count comments from the automation user
+                    # Exclude bot replies that might echo the marker in quoted text or scripts
+                    if author == self.automation_username:
+                        count += 1
+            elif workflow_type == "fixpr":
+                # FixPR workflow uses a dedicated marker in its queued comment.
+                # Only count if posted by the automation user, not bots echoing the marker
+                if self.FIXPR_MARKER_PREFIX in body:
+                    author = self._get_comment_author_login(comment)
+                    if author == self.automation_username:
+                        count += 1
+            else:
+                # Fallback: count all automation comments
+                if (
+                    self.CODEX_COMMIT_MARKER_PREFIX in body
+                    or self.FIX_COMMENT_MARKER_PREFIX in body
+                    or self.FIX_COMMENT_RUN_MARKER_PREFIX in body
+                    or self.FIXPR_MARKER_PREFIX in body
+                ):
+                    count += 1
+        return count
+
+    def _has_new_bot_comments_since_codex(self, comments: List[Dict]) -> bool:
+        """Check if there are new GitHub bot comments since the last Codex automation comment.
+
+        This allows automation to run even when head commit is from Codex if
+        there are new bot comments (like CI failures, review bot comments) that
+        need attention.
+        """
+        last_codex_time = self._get_last_codex_automation_comment_time(comments)
+
+        # If no Codex automation comment exists, treat any bot comment as new
+        if not last_codex_time:
+            for comment in comments:
+                if self._is_github_bot_comment(comment):
+                    created_at = comment.get("createdAt") or comment.get("updatedAt")
+                    self.logger.debug(
+                        "🤖 Found bot comment from %s at %s with no prior Codex automation comment",
+                        self._get_comment_author_login(comment),
+                        created_at,
+                    )
+                    return True
+            return False
+
+        for comment in comments:
+            if not self._is_github_bot_comment(comment):
+                continue
+
+            created_at = comment.get("createdAt") or comment.get("updatedAt")
+            if created_at and created_at > last_codex_time:
+                self.logger.debug(
+                    "🤖 Found new bot comment from %s at %s (after Codex comment at %s)",
+                    self._get_comment_author_login(comment),
+                    created_at,
+                    last_codex_time,
+                )
+                return True
+
+        return False
+
     def _get_comment_author_login(self, comment: Dict) -> str:
         """Return normalized author login for a comment."""
         author = comment.get("author") or comment.get("user") or {}
@@ -977,7 +2125,16 @@ Use your judgment to fix comments from everyone or explain why it should not be
 
         return False
 
-    def process_single_pr_by_number(self, pr_number: int, repository: str) -> bool:
+    def process_single_pr_by_number(
+        self,
+        pr_number: int,
+        repository: str,
+        *,
+        fix_comment: bool = False,
+        fixpr: bool = False,
+        agent_cli: str = "claude",
+        model: str = None,
+    ) -> bool:
         """Process a specific PR by number and repository"""
         repo_full = self._normalize_repository_name(repository)
         self.logger.info(f"🎯 Processing target PR: {repo_full} #{pr_number}")
@@ -988,9 +2145,41 @@ Use your judgment to fix comments from everyone or explain why it should not be
             return False
 
         try:
+            # Check workflow-specific safety limits
+            workflow_type = self._determine_workflow_type(fix_comment, fixpr)
+            _, comments = self._get_pr_comment_state(repo_full, pr_number)
+            automation_comment_count = self._count_workflow_comments(comments, workflow_type)
+
+            # Get workflow-specific limit
+            if workflow_type == "fix_comment":
+                workflow_limit = self.safety_manager.fix_comment_limit
+            elif workflow_type == "fixpr":
+                workflow_limit = self.safety_manager.fixpr_limit
+            elif workflow_type == "pr_automation":
+                workflow_limit = self.safety_manager.pr_automation_limit
+            else:
+                workflow_limit = self.safety_manager.pr_limit  # Fallback
+
+            if automation_comment_count >= workflow_limit:
+                self.logger.warning(
+                    f"🚫 Safety limits exceeded for PR {repo_full} #{pr_number} ({workflow_type}); "
+                    f"{automation_comment_count}/{workflow_limit} automation comments"
+                )
+                # Not an execution failure: we're intentionally skipping to avoid spamming.
+                return True
+
+            if self.no_act:
+                self.logger.info(
+                    "🧪 --no-act enabled: skipping processing for %s #%s (would run %s)",
+                    repo_full,
+                    pr_number,
+                    workflow_type,
+                )
+                return True
+
             # Check safety limits for this specific PR first
             if not self.safety_manager.try_process_pr(pr_number, repo=repo_full):
-                self.logger.warning(f"🚫 Safety limits exceeded for PR {repo_full} #{pr_number}")
+                self.logger.warning(f"🚫 Internal safety limits exceeded for PR {repo_full} #{pr_number}")
                 return False
 
             # Only record global run AFTER confirming we can process the PR
@@ -1007,25 +2196,43 @@ Use your judgment to fix comments from everyone or explain why it should not be
             try:
                 # Get PR details using gh CLI
                 result = AutomationUtils.execute_subprocess_with_timeout(
-                    ["gh", "pr", "view", str(pr_number), "--repo", repo_full, "--json", "title,headRefName,baseRefName,url,author"],
+                    ["gh", "pr", "view", str(pr_number), "--repo", repo_full, "--json", "title,headRefName,baseRefName,url,author,headRefOid,mergeable"],
                     timeout=30
                 )
                 pr_data = json.loads(result.stdout)
 
                 self.logger.info(f"📝 Found PR: {pr_data['title']}")
 
-                # Post codex instruction comment
-                comment_result = self.post_codex_instruction_simple(repo_full, pr_number, pr_data)
-                success = comment_result == "posted"
-
-                # Record PR processing attempt with result
-                result = "success" if success else "failure"
-                self.safety_manager.record_pr_attempt(
-                    pr_number,
-                    result,
-                    repo=repo_full,
-                    branch=pr_data.get('headRefName'),
-                )
+                if fix_comment:
+                    comment_result = self._process_pr_fix_comment(
+                        repo_full,
+                        pr_number,
+                        pr_data,
+                        agent_cli=agent_cli,
+                        model=model,
+                    )
+                elif fixpr:
+                    comment_result = self._process_pr_fixpr(
+                        repo_full,
+                        pr_number,
+                        pr_data,
+                        agent_cli=agent_cli,
+                        model=model,
+                    )
+                else:
+                    # Post codex instruction comment
+                    comment_result = self.post_codex_instruction_simple(repo_full, pr_number, pr_data)
+                # Treat "skipped" as a neutral outcome: do not count it as failure,
+                # and avoid recording an unbounded stream of skipped attempts.
+                success = comment_result in {"posted", "skipped"}
+                if comment_result != "skipped":
+                    result = "success" if comment_result == "posted" else "failure"
+                    self.safety_manager.record_pr_attempt(
+                        pr_number,
+                        result,
+                        repo=repo_full,
+                        branch=pr_data.get("headRefName"),
+                    )
 
                 if success:
                     self.logger.info(f"✅ Successfully processed target PR {repo_full} #{pr_number}")
@@ -1049,9 +2256,10 @@ Use your judgment to fix comments from everyone or explain why it should not be
             self.logger.debug("Traceback: %s", traceback.format_exc())
             return False
 
-    def run_monitoring_cycle(self, single_repo=None, max_prs=10):
+    def run_monitoring_cycle(self, single_repo=None, max_prs=10, cutoff_hours: int = 24, fix_comment: bool = False, fixpr: bool = False, agent_cli: str = "claude", model: str = None):
         """Run a complete monitoring cycle with actionable PR counting"""
-        self.logger.info("🚀 Starting jleechanorg PR monitoring cycle")
+        mode_label = "fix-comment" if fix_comment else ("fixpr" if fixpr else "comment")
+        self.logger.info("🚀 Starting jleechanorg PR monitoring cycle (%s mode)", mode_label)
 
         if not self.safety_manager.can_start_global_run():
             current_runs = self.safety_manager.get_global_runs()
@@ -1066,7 +2274,7 @@ Use your judgment to fix comments from everyone or explain why it should not be
         global_run_recorded = self.wrapper_managed
 
         try:
-            open_prs = self.discover_open_prs()
+            open_prs = self.discover_open_prs(cutoff_hours=cutoff_hours)
         except Exception as exc:
             self.logger.error("❌ Failed to discover PRs: %s", exc)
             self.logger.debug("Traceback: %s", traceback.format_exc())
@@ -1102,11 +2310,68 @@ Use your judgment to fix comments from everyone or explain why it should not be
                 skipped_count += 1
                 continue
 
-            branch_name = pr.get('headRefName', 'unknown')
+            # For fixpr, perform additional eligibility check (conflicts or failing checks)
+            if fixpr:
+                # We need to fetch more details to know if it's eligible
+                # This mirrors logic in list_actionable_prs/run_fixpr_batch
+                try:
+                    # Check mergeable status first (lightweight if available in discover_open_prs? No, it's not)
+                    # We need to query it.
+                    # Let's assume we need to check failing checks too.
+                    # We can use has_failing_checks from orchestrated_pr_runner
+                    is_conflicting = False # We'd need to fetch mergeable status
+
+                    # Fetch mergeable status
+                    result = AutomationUtils.execute_subprocess_with_timeout(
+                        ["gh", "pr", "view", str(pr_number), "--repo", repo_full_name, "--json", "mergeable"],
+                        timeout=30, check=False
+                    )
+                    if result.returncode == 0:
+                        data = json.loads(result.stdout)
+                        if data.get("mergeable") == "CONFLICTING":
+                            is_conflicting = True
+
+                    is_failing = has_failing_checks(repo_full_name, pr_number)
+
+                    if not (is_conflicting or is_failing):
+                        self.logger.debug(f"⏭️ Skipping PR #{pr_number} (fixpr) - no conflicts or failing checks")
+                        skipped_count += 1
+                        continue
+
+                except Exception as e:
+                    self.logger.warning(f"⚠️ Error checking fixpr eligibility for #{pr_number} ({type(e).__name__}): {e}")
+                    skipped_count += 1
+                    continue
+
+            branch_name = pr.get("headRefName", "unknown")
+
+            # Check automation comment count on GitHub (not internal attempts)
+            # Determine workflow type based on mode
+            workflow_type = self._determine_workflow_type(fix_comment, fixpr)
+            _, comments = self._get_pr_comment_state(repo_full_name, pr_number)
+            automation_comment_count = self._count_workflow_comments(comments, workflow_type)
+
+            # Get workflow-specific limit
+            if workflow_type == "fix_comment":
+                workflow_limit = self.safety_manager.fix_comment_limit
+            elif workflow_type == "fixpr":
+                workflow_limit = self.safety_manager.fixpr_limit
+            elif workflow_type == "pr_automation":
+                workflow_limit = self.safety_manager.pr_automation_limit
+            else:
+                workflow_limit = self.safety_manager.pr_limit  # Fallback
+
+            if automation_comment_count >= workflow_limit:
+                self.logger.info(
+                    f"🚫 Safety limits exceeded for PR {repo_full_name} #{pr_number} ({workflow_type}); "
+                    f"{automation_comment_count}/{workflow_limit} automation comments"
+                )
+                skipped_count += 1
+                continue
 
             if not self.safety_manager.try_process_pr(pr_number, repo=repo_full_name, branch=branch_name):
                 self.logger.info(
-                    f"🚫 Safety limits exceeded for PR {repo_full_name} #{pr_number}; skipping"
+                    f"🚫 Internal safety limits exceeded for PR {repo_full_name} #{pr_number}; skipping"
                 )
                 skipped_count += 1
                 continue
@@ -1125,24 +2390,56 @@ Use your judgment to fix comments from everyone or explain why it should not be
                         self.safety_manager.global_limit,
                     )
 
-                # Post codex instruction comment directly (comment-only approach)
-                comment_result = self.post_codex_instruction_simple(repo_full_name, pr_number, pr)
-                success = comment_result == "posted"
-
-                result = "success" if success else "failure"
-                self.safety_manager.record_pr_attempt(
-                    pr_number,
-                    result,
-                    repo=repo_full_name,
-                    branch=branch_name,
-                )
-                attempt_recorded = True
+                if fix_comment:
+                    comment_result = self._process_pr_fix_comment(
+                        repo_full_name,
+                        pr_number,
+                        pr,
+                        agent_cli=agent_cli,
+                        model=model,
+                    )
+                elif fixpr:
+                    comment_result = self._process_pr_fixpr(
+                        repo_full_name,
+                        pr_number,
+                        pr,
+                        agent_cli=agent_cli,
+                        model=model,
+                    )
+                else:
+                    # Post codex instruction comment directly (comment-only approach)
+                    comment_result = self.post_codex_instruction_simple(repo_full_name, pr_number, pr)
+
+                # Treat "skipped" as a neutral outcome: do not count it as failure,
+                # and avoid recording an unbounded stream of skipped attempts.
+                success = comment_result in {"posted", "skipped"}
+                if comment_result != "skipped":
+                    result = "success" if comment_result == "posted" else "failure"
+                    self.safety_manager.record_pr_attempt(
+                        pr_number,
+                        result,
+                        repo=repo_full_name,
+                        branch=branch_name,
+                    )
+                    attempt_recorded = True
 
                 if success:
-                    self.logger.info(f"✅ Successfully processed PR {repo_full_name} #{pr_number}")
-                    actionable_processed += 1
+                    # Only count as processed when we actually posted; skips should not inflate stats.
+                    if comment_result == "posted":
+                        actionable_processed += 1
+                    self.logger.info(
+                        "✅ Successfully processed PR %s #%s (result=%s)",
+                        repo_full_name,
+                        pr_number,
+                        comment_result,
+                    )
                 else:
-                    self.logger.error(f"❌ Failed to process PR {repo_full_name} #{pr_number}")
+                    self.logger.error(
+                        "❌ Failed to process PR %s #%s (result=%s)",
+                        repo_full_name,
+                        pr_number,
+                        comment_result,
+                    )
             except Exception as e:
                 self.logger.error(f"❌ Exception processing PR {repo_full_name} #{pr_number}: {e}")
                 self.logger.debug("Traceback: %s", traceback.format_exc())
@@ -1157,30 +2454,436 @@ Use your judgment to fix comments from everyone or explain why it should not be
         self.logger.info(f"🏁 Monitoring cycle complete: {actionable_processed} actionable PRs processed, {skipped_count} skipped")
 
 
+def check_chrome_cdp_accessible(port=9222, host="127.0.0.1", timeout=5):
+    """
+    Validate that Chrome DevTools Protocol is accessible.
+
+    Args:
+        port: CDP port (default 9222)
+        host: CDP host (default 127.0.0.1)
+        timeout: Connection timeout in seconds
+
+    Returns:
+        tuple: (bool, str) - (success, message)
+    """
+    url_host = _format_cdp_host_for_url(host)
+    url = f"http://{url_host}:{port}/json/version"
+    try:
+        req = urllib.request.Request(url, headers={"User-Agent": "Mozilla/5.0"})
+        with urllib.request.urlopen(req, timeout=timeout) as response:
+            data = json.loads(response.read().decode())
+            browser_version = data.get("Browser", "Unknown")
+            return True, f"✅ Chrome CDP accessible (version: {browser_version})"
+    except urllib.error.URLError as e:
+        return False, f"❌ Chrome CDP not accessible at {host}:{port} - {e.reason}"
+    except Exception as e:
+        return False, f"❌ Failed to connect to Chrome CDP: {e}"
+
+
+def _parse_bool_env(name: str, default: bool = True) -> bool:
+    raw = os.environ.get(name)
+    if raw is None:
+        return default
+    raw = raw.strip()
+    if not raw:
+        return default
+    return raw.lower() not in {"0", "false", "no", "off"}
+
+
+def _validate_cdp_host(raw_host: str) -> str:
+    allowed_hosts = {"127.0.0.1", "localhost", "::1"}
+    host = (raw_host or "").strip()
+    if host in allowed_hosts:
+        return host
+
+    print(
+        f"WARNING: Ignoring unsafe CODEX_CDP_HOST value {host!r}; "
+        "only localhost/127.0.0.1/::1 are allowed. Falling back to 127.0.0.1.",
+        file=sys.stderr,
+    )
+    return "127.0.0.1"
+
+
+def _format_cdp_host_for_url(host: str) -> str:
+    if ":" in host and not (host.startswith("[") and host.endswith("]")):
+        return f"[{host}]"
+    return host
+
+
+def _resolve_cdp_host_port() -> Tuple[str, int]:
+    raw_host = os.environ.get("CODEX_CDP_HOST", "127.0.0.1")
+    host = _validate_cdp_host(raw_host)
+    port_raw = os.environ.get("CODEX_CDP_PORT", "9222")
+    try:
+        port = int(port_raw)
+        if not (1 <= port <= 65535):
+            raise ValueError(f"Port {port} out of range")
+    except ValueError:
+        port = 9222
+    return host, port
+
+
+def _detect_chrome_binary() -> Optional[str]:
+    if sys.platform == "win32":
+        win_candidates = [
+            Path(os.environ.get("PROGRAMFILES", "C:\\Program Files"))
+            / "Google/Chrome/Application/chrome.exe",
+            Path(os.environ.get("PROGRAMFILES(X86)", "C:\\Program Files (x86)"))
+            / "Google/Chrome/Application/chrome.exe",
+        ]
+        for candidate in win_candidates:
+            if candidate.exists():
+                return str(candidate)
+
+    if sys.platform == "darwin":
+        mac_candidates = [
+            "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+            "/Applications/Chromium.app/Contents/MacOS/Chromium",
+        ]
+        for candidate in mac_candidates:
+            if Path(candidate).exists():
+                return candidate
+
+    for command in ("google-chrome", "google-chrome-stable", "chromium", "chromium-browser"):
+        found = shutil.which(command)
+        if found:
+            return found
+    return None
+
+
+def _start_chrome_debug(port: int, user_data_dir: str) -> Tuple[bool, str]:
+    start_script = os.environ.get("CODEX_CDP_START_SCRIPT")
+    if start_script:
+        try:
+            cmd = shlex.split(start_script)
+        except ValueError as exc:
+            return False, f"❌ Invalid CODEX_CDP_START_SCRIPT value ({start_script}): {exc}"
+        if not cmd:
+            return False, "❌ CODEX_CDP_START_SCRIPT is set but empty after parsing"
+
+        script_path = Path(cmd[0]).expanduser()
+        if not script_path.is_file():
+            return False, f"❌ CODEX_CDP_START_SCRIPT target does not exist or is not a file: {script_path}"
+        try:
+            script_path_resolved = script_path.resolve()
+        except OSError as exc:
+            return False, f"❌ Failed to resolve CODEX_CDP_START_SCRIPT path ({script_path}): {exc}"
+
+        cmd[0] = str(script_path_resolved)
+        cmd.append(str(port))
+        try:
+            subprocess.Popen(
+                cmd,
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+                start_new_session=True,
+            )
+            return True, f"🚀 Started Chrome via script {script_path_resolved} on port {port}"
+        except Exception as exc:
+            return False, f"❌ Failed to run CODEX_CDP_START_SCRIPT ({script_path_resolved}): {exc}"
+
+    chrome_path = _detect_chrome_binary()
+    if not chrome_path:
+        return False, "❌ Could not find Chrome or Chromium binary"
+
+    resolved_user_data_dir = Path(user_data_dir).expanduser()
+    if not resolved_user_data_dir.is_absolute():
+        resolved_user_data_dir = (Path.home() / resolved_user_data_dir).resolve()
+    else:
+        resolved_user_data_dir = resolved_user_data_dir.resolve()
+    home_dir = Path.home().resolve()
+    try:
+        resolved_user_data_dir.relative_to(home_dir)
+    except ValueError:
+        return False, (
+            "❌ CODEX_CDP_USER_DATA_DIR must reside under your home directory; "
+            f"got {resolved_user_data_dir}"
+        )
+    resolved_user_data_dir.mkdir(parents=True, exist_ok=True)
+    command = [
+        chrome_path,
+        f"--remote-debugging-port={port}",
+        f"--user-data-dir={resolved_user_data_dir}",
+        "--window-size=1920,1080",
+        "https://chatgpt.com/",
+    ]
+    try:
+        subprocess.Popen(
+            command,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+            start_new_session=True,
+        )
+        return True, f"🚀 Started Chrome with CDP on port {port}"
+    except Exception as exc:
+        return False, f"❌ Failed to start Chrome with CDP: {exc}"
+
+
+def ensure_chrome_cdp_accessible(timeout: Optional[int] = None) -> Tuple[bool, str]:
+    host, port = _resolve_cdp_host_port()
+    if timeout is None:
+        timeout_raw = os.environ.get("CODEX_CDP_START_TIMEOUT", "20")
+        try:
+            timeout = int(timeout_raw)
+        except ValueError:
+            timeout = 20
+    try:
+        timeout = int(timeout)
+    except (TypeError, ValueError):
+        timeout = 20
+    if timeout <= 0:
+        timeout = 20
+    ok, message = check_chrome_cdp_accessible(port=port, host=host)
+    if ok:
+        return True, message
+
+    auto_start = _parse_bool_env("CODEX_CDP_AUTO_START", default=True)
+    if not auto_start:
+        return False, message
+
+    user_data_dir = os.environ.get("CODEX_CDP_USER_DATA_DIR", str(Path.home() / ".chrome-automation-profile"))
+    started, start_message = _start_chrome_debug(port, user_data_dir)
+    if not started:
+        return False, start_message
+
+    deadline = time.time() + timeout
+    last_message = message
+    while True:
+        remaining = deadline - time.time()
+        if remaining <= 0:
+            break
+        per_check_timeout = min(1.0, remaining)
+        ok, last_message = check_chrome_cdp_accessible(
+            port=port,
+            host=host,
+            timeout=per_check_timeout,
+        )
+        if ok:
+            return True, f"{start_message}\n{last_message}"
+        remaining = deadline - time.time()
+        if remaining <= 0:
+            break
+        time.sleep(min(1.0, remaining))
+
+    return False, f"{start_message}\n❌ Chrome CDP still not reachable after {timeout}s ({last_message})"
+
+
 def main():
     """CLI interface for jleechanorg PR monitor"""
 
-    parser = argparse.ArgumentParser(description='jleechanorg PR Monitor')
-    parser.add_argument('--dry-run', action='store_true',
-                        help='Discover PRs but do not process them')
-    parser.add_argument('--single-repo',
-                        help='Process only specific repository')
-    parser.add_argument('--max-prs', type=int, default=5,
-                        help='Maximum PRs to process per cycle')
-    parser.add_argument('--target-pr', type=int,
-                        help='Process specific PR number')
-    parser.add_argument('--target-repo',
-                        help='Repository for target PR (required with --target-pr)')
+    parser = argparse.ArgumentParser(description="jleechanorg PR Monitor")
+    parser.add_argument(
+        "--no-act",
+        action="store_true",
+        help="Do not post comments or dispatch agents (useful for evidence/testing).",
+    )
+    parser.add_argument("--dry-run", action="store_true",
+                        help="Discover PRs but do not process them")
+    parser.add_argument("--fixpr", action="store_true",
+                        help="Run /fixpr-only orchestrated flow for conflicts/failing checks (skips drafts)")
+    parser.add_argument("--fix-comment", action="store_true",
+                        help="Run fix-comment orchestration flow to resolve PR review comments")
+    parser.add_argument("--fix-comment-watch", action="store_true",
+                        help="Watch a PR for automation commits and post review request when detected")
+    parser.add_argument("--cutoff-hours", type=int, default=24,
+                        help="Look-back window in hours for PR updates (default: 24)")
+    parser.add_argument("--single-repo",
+                        help="Process only specific repository")
+    parser.add_argument("--max-prs", type=int, default=5,
+                        help="Maximum PRs to process per cycle")
+    parser.add_argument("--target-pr", type=int,
+                        help="Process specific PR number")
+    parser.add_argument("--target-repo",
+                        help="Repository for target PR (required with --target-pr)")
+    parser.add_argument(
+        "--fixpr-agent",
+        type=_parse_fixpr_agent_chain,
+        default="claude",
+        help="AI CLI (or comma-separated chain) for --fixpr mode (default: claude). Example: gemini,codex",
+    )
+    parser.add_argument(
+        "--model",
+        type=str,
+        default=None,
+        help="Model to use for agent CLI. Examples: sonnet/opus/haiku (Claude), gemini-3-pro-preview/gemini-3-auto (Gemini), composer-1 (Cursor). If not specified, CLI-specific defaults are used.",
+    )
+    parser.add_argument("--list-eligible", action="store_true",
+                        help="Dry-run listing of PRs eligible for fixpr (conflicts/failing checks)")
+    parser.add_argument("--codex-update", action="store_true",
+                        help="Run Codex automation to update tasks via browser automation (use --codex-task-limit; default: 50)")
+    parser.add_argument(
+        "--codex-task-limit",
+        type=_positive_int_arg,
+        default=50,
+        help="Task limit for --codex-update (default: 50, max: 200).",
+    )
+
+    # Safety limits (params; no environment variables).
+    parser.add_argument("--pr-limit", type=_positive_int_arg, default=None, help="Max failed attempts per PR (default: 10).")
+    parser.add_argument("--global-limit", type=_positive_int_arg, default=None, help="Max global runs per day (default: 50).")
+    parser.add_argument("--approval-hours", type=_positive_int_arg, default=None, help="Manual approval validity in hours (default: 24).")
+    parser.add_argument("--subprocess-timeout", type=_positive_int_arg, default=None, help="Default subprocess timeout seconds (default: 300).")
+    parser.add_argument("--pr-automation-limit", type=_positive_int_arg, default=None, help="Max PR automation comments per PR (default: 10).")
+    parser.add_argument("--fix-comment-limit", type=_positive_int_arg, default=None, help="Max fix-comment comments per PR (default: 10).")
+    parser.add_argument("--fixpr-limit", type=_positive_int_arg, default=None, help="Max fixpr comments per PR (default: 10).")
+    parser.add_argument("--automation-user", help="Override automation username for marker validation")
 
     args = parser.parse_args()
 
+    try:
+        args.model = _normalize_model(args.model)
+    except argparse.ArgumentTypeError as exc:
+        parser.error(str(exc))
+
     # Validate target PR arguments
     if args.target_pr and not args.target_repo:
-        parser.error('--target-repo is required when using --target-pr')
+        parser.error("--target-repo is required when using --target-pr")
     if args.target_repo and not args.target_pr:
-        parser.error('--target-pr is required when using --target-repo')
+        parser.error("--target-pr is required when using --target-repo")
+    if args.fixpr and args.fix_comment:
+        parser.error("--fixpr and --fix-comment are mutually exclusive")
+    if args.fix_comment_watch and not (args.target_pr and args.target_repo):
+        parser.error("--fix-comment-watch requires --target-pr and --target-repo")
+
+    safety_limits: Dict[str, int] = {}
+    if args.pr_limit is not None:
+        safety_limits["pr_limit"] = args.pr_limit
+    if args.global_limit is not None:
+        safety_limits["global_limit"] = args.global_limit
+    if args.approval_hours is not None:
+        safety_limits["approval_hours"] = args.approval_hours
+    if args.subprocess_timeout is not None:
+        safety_limits["subprocess_timeout"] = args.subprocess_timeout
+    if args.pr_automation_limit is not None:
+        safety_limits["pr_automation_limit"] = args.pr_automation_limit
+    if args.fix_comment_limit is not None:
+        safety_limits["fix_comment_limit"] = args.fix_comment_limit
+    if args.fixpr_limit is not None:
+        safety_limits["fixpr_limit"] = args.fixpr_limit
+
+    monitor = JleechanorgPRMonitor(
+        safety_limits=safety_limits or None,
+        no_act=args.no_act,
+        automation_username=getattr(args, 'automation_user', None)
+    )
 
-    monitor = JleechanorgPRMonitor()
+    if args.fix_comment_watch:
+        success = monitor.run_fix_comment_review_watcher(
+            args.target_pr,
+            args.target_repo,
+            agent_cli=args.fixpr_agent,
+        )
+        sys.exit(0 if success else 1)
+
+    if args.codex_update:
+        if args.no_act:
+            print("🧪 --no-act enabled: skipping codex-update run")
+            sys.exit(0)
+
+        task_limit = min(args.codex_task_limit, 200)
+
+        print(f"🤖 Running Codex automation (first {task_limit} tasks)...")
+
+        # Validate Chrome CDP is accessible before running (auto-starts if needed)
+        cdp_ok, cdp_msg = ensure_chrome_cdp_accessible()
+        print(cdp_msg)
+        if not cdp_ok:
+            print("\n⚠️ Skipping Codex automation (Chrome CDP unavailable).")
+            print("💡 TIP: Start Chrome with CDP enabled first:")
+            print("   ./automation/jleechanorg_pr_automation/openai_automation/start_chrome_debug.sh")
+            print("   Or set CODEX_CDP_START_SCRIPT to a custom launcher path.")
+            sys.exit(0)
+
+        try:
+            host, port = _resolve_cdp_host_port()
+            # Call the codex automation module with limit
+            # Use -m to run as module (works with installed package)
+            # Requires Chrome with CDP enabled on port 9222
+            timeout_seconds = max(300, int(task_limit * 12))  # ~12s/task, min 5 minutes
+            result = subprocess.run(
+                [
+                    "python3",
+                    "-m",
+                    "jleechanorg_pr_automation.openai_automation.codex_github_mentions",
+                    "--use-existing-browser",
+                    "--cdp-host",
+                    host,
+                    "--cdp-port",
+                    str(port),
+                    "--limit",
+                    str(task_limit),
+                ],
+                check=False, capture_output=True,
+                text=True,
+                timeout=timeout_seconds
+            )
+            print(result.stdout)
+            if result.stderr:
+                print(result.stderr, file=sys.stderr)
+            sys.exit(result.returncode)
+        except subprocess.TimeoutExpired:
+            print(f"❌ Codex automation timed out after {timeout_seconds // 60} minutes")
+            sys.exit(1)
+        except Exception as e:
+            print(f"❌ Failed to run Codex automation: {e}")
+            sys.exit(1)
+
+    if args.fixpr:
+        if args.target_pr and args.target_repo:
+            print(f"🎯 Processing target PR (fixpr): {args.target_repo} #{args.target_pr}")
+            success = monitor.process_single_pr_by_number(
+                args.target_pr,
+                args.target_repo,
+                fixpr=True,
+                agent_cli=args.fixpr_agent,
+                model=args.model,
+            )
+            sys.exit(0 if success else 1)
+
+        monitor.run_monitoring_cycle(
+            single_repo=args.single_repo,
+            max_prs=args.max_prs,
+            cutoff_hours=args.cutoff_hours,
+            fixpr=True,
+            agent_cli=args.fixpr_agent,
+            model=args.model,
+        )
+        return
+
+    if args.fix_comment:
+        # Handle target PR processing
+        if args.target_pr and args.target_repo:
+            print(f"🎯 Processing target PR (fix-comment): {args.target_repo} #{args.target_pr}")
+            success = monitor.process_single_pr_by_number(
+                args.target_pr,
+                args.target_repo,
+                fix_comment=True,
+                agent_cli=args.fixpr_agent,
+                model=args.model,
+            )
+            sys.exit(0 if success else 1)
+
+        if args.dry_run:
+            print("🔍 DRY RUN: Discovering PRs only")
+            prs = monitor.discover_open_prs(cutoff_hours=args.cutoff_hours)
+
+            if args.single_repo:
+                prs = [pr for pr in prs if pr["repository"] == args.single_repo]
+
+            print(f"📋 Found {len(prs)} open PRs:")
+            for pr in prs[:args.max_prs]:
+                print(f"  • {pr['repository']} PR #{pr['number']}: {pr['title']}")
+            return
+
+        monitor.run_monitoring_cycle(
+            single_repo=args.single_repo,
+            max_prs=args.max_prs,
+            cutoff_hours=args.cutoff_hours,
+            fix_comment=True,
+            agent_cli=args.fixpr_agent,
+            model=args.model,
+        )
+        return
 
     # Handle target PR processing
     if args.target_pr and args.target_repo:
@@ -1190,7 +2893,7 @@ def main():
 
     if args.dry_run:
         print("🔍 DRY RUN: Discovering PRs only")
-        prs = monitor.discover_open_prs()
+        prs = monitor.discover_open_prs(cutoff_hours=args.cutoff_hours)
 
         if args.single_repo:
             prs = [pr for pr in prs if pr["repository"] == args.single_repo]
@@ -1198,9 +2901,26 @@ def main():
         print(f"📋 Found {len(prs)} open PRs:")
         for pr in prs[:args.max_prs]:
             print(f"  • {pr['repository']} PR #{pr['number']}: {pr['title']}")
+
+        if args.list_eligible:
+            print("\n🔎 Eligible for fixpr (conflicts/failing checks):")
+            monitor.list_actionable_prs(
+                cutoff_hours=args.cutoff_hours,
+                max_prs=args.max_prs,
+                single_repo=args.single_repo,
+            )
+    elif args.list_eligible:
+        monitor.list_actionable_prs(
+            cutoff_hours=args.cutoff_hours,
+            max_prs=args.max_prs,
+            single_repo=args.single_repo,
+        )
     else:
-        monitor.run_monitoring_cycle(single_repo=args.single_repo, max_prs=args.max_prs)
+        monitor.run_monitoring_cycle(
+            cutoff_hours=args.cutoff_hours,
+            model=args.model,
+        )
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()