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

jleechanorg_pr_automation/tests/test_fixpr_prompt.py

@@ -0,0 +1,54 @@
+#!/usr/bin/env python3
+"""Tests for fixpr prompt formatting."""
+
+import tempfile
+import unittest
+from pathlib import Path
+from unittest.mock import patch
+
+from automation.jleechanorg_pr_automation import orchestrated_pr_runner as runner
+
+
+class _FakeDispatcher:
+    def __init__(self) -> None:
+        self.task_description = None
+
+    def analyze_task_and_create_agents(self, task_description: str, forced_cli: str = "claude"):
+        self.task_description = task_description
+        return [{"name": "test-agent"}]
+
+    def create_dynamic_agent(self, agent_spec):  # pragma: no cover - simple stub
+        return True
+
+
+class TestFixprPrompt(unittest.TestCase):
+    def test_fixpr_commit_message_includes_mode_and_model(self):
+        pr_payload = {
+            "repo_full": "jleechanorg/worldarchitect.ai",
+            "repo": "worldarchitect.ai",
+            "number": 123,
+            "title": "Test PR",
+            "branch": "feature/test-fixpr",
+        }
+
+        dispatcher = _FakeDispatcher()
+        with tempfile.TemporaryDirectory() as tmpdir:
+            with patch.object(runner, "WORKSPACE_ROOT_BASE", Path(tmpdir)):
+                with patch.object(runner, "kill_tmux_session_if_exists", lambda _: None):
+                    ok = runner.dispatch_agent_for_pr(dispatcher, pr_payload, agent_cli="codex")
+
+        self.assertTrue(ok)
+        self.assertIsNotNone(dispatcher.task_description)
+        self.assertIn(
+            "[fixpr codex-automation-commit] fix PR #123",
+            dispatcher.task_description,
+        )
+        # Verify the prompt instructs fetching ALL feedback sources (inline review comments included).
+        self.assertIn("/pulls/{pr}/comments", dispatcher.task_description)
+        self.assertIn("/pulls/{pr}/reviews", dispatcher.task_description)
+        self.assertIn("/issues/{pr}/comments", dispatcher.task_description)
+        self.assertIn("--paginate", dispatcher.task_description)
+
+
+if __name__ == "__main__":
+    unittest.main()

jleechanorg_pr_automation/tests/test_fixpr_return_value.py

@@ -0,0 +1,140 @@
+#!/usr/bin/env python3
+"""
+Test for fixpr workflow return value handling.
+
+Regression test for cursor[bot] bug report (Comment ID 2674134633):
+"FixPR workflow ignores queued comment posting failure"
+
+Tests that _process_pr_fixpr correctly captures and handles the return value
+from _post_fixpr_queued, matching the behavior of _process_pr_fix_comment.
+"""
+
+import unittest
+from unittest.mock import Mock, patch, MagicMock, call
+
+from jleechanorg_pr_automation.jleechanorg_pr_monitor import JleechanorgPRMonitor
+
+
+class TestFixprReturnValue(unittest.TestCase):
+    """Test fixpr workflow return value handling"""
+
+    def setUp(self):
+        """Set up test environment with comprehensive mocking"""
+        # Patch AutomationSafetyManager during JleechanorgPRMonitor initialization
+        with patch('jleechanorg_pr_automation.jleechanorg_pr_monitor.AutomationSafetyManager'):
+            self.monitor = JleechanorgPRMonitor(automation_username="test-automation-user")
+            self.monitor.safety_manager.fixpr_limit = 10
+
+        # Mock logger to avoid logging issues
+        self.monitor.logger = MagicMock()
+
+    @patch('jleechanorg_pr_automation.jleechanorg_pr_monitor.dispatch_agent_for_pr')
+    @patch('jleechanorg_pr_automation.jleechanorg_pr_monitor.ensure_base_clone')
+    @patch('jleechanorg_pr_automation.jleechanorg_pr_monitor.chdir')
+    @patch('jleechanorg_pr_automation.jleechanorg_pr_monitor.TaskDispatcher')
+    def test_fixpr_returns_partial_when_queued_comment_fails(
+        self,
+        mock_dispatcher,
+        mock_chdir,
+        mock_clone,
+        mock_dispatch_agent,
+    ):
+        """
+        Test that _process_pr_fixpr returns 'partial' when _post_fixpr_queued fails.
+
+        Regression test for cursor[bot] bug: Method was ignoring return value and
+        always returning 'posted' even when comment posting failed.
+        """
+        # Setup mocks
+        mock_clone.return_value = "/tmp/fake/repo"
+        mock_dispatch_agent.return_value = True  # Agent dispatch succeeds
+
+        pr_data = {
+            "number": 1234,
+            "title": "Test PR",
+            "headRefName": "test-branch",
+            "baseRefName": "main",
+            "url": "https://github.com/test/repo/pull/1234",
+            "headRepository": {"owner": {"login": "test"}},
+            "headRefOid": "abc123",
+            "statusCheckRollup": [],
+            "mergeable": "MERGEABLE",
+        }
+
+        # Comprehensive mocking to avoid all side effects
+        with patch.object(self.monitor, '_normalize_repository_name', return_value="test/repo"):
+            with patch.object(self.monitor, '_get_pr_comment_state', return_value=("abc123", [])):
+                with patch.object(self.monitor, '_should_skip_pr', return_value=False):
+                    with patch.object(self.monitor, '_count_workflow_comments', return_value=5):  # Under limit
+                        with patch.object(self.monitor, '_post_fixpr_queued', return_value=False) as mock_post_queued:  # FAILS
+                            with patch.object(self.monitor, '_record_processed_pr'):
+                                result = self.monitor._process_pr_fixpr(
+                                    repository="test/repo",
+                                    pr_number=1234,
+                                    pr_data=pr_data,
+                                )
+
+        # CRITICAL: Should return "partial" when queued comment fails
+        self.assertEqual(
+            result,
+            "partial",
+            "REGRESSION BUG: _process_pr_fixpr should return 'partial' when _post_fixpr_queued fails, "
+            "not ignore the return value. This causes failed marker posts to not count against fixpr_limit."
+        )
+        # Verify _post_fixpr_queued was called
+        mock_post_queued.assert_called_once()
+
+    @patch('jleechanorg_pr_automation.jleechanorg_pr_monitor.dispatch_agent_for_pr')
+    @patch('jleechanorg_pr_automation.jleechanorg_pr_monitor.ensure_base_clone')
+    @patch('jleechanorg_pr_automation.jleechanorg_pr_monitor.chdir')
+    @patch('jleechanorg_pr_automation.jleechanorg_pr_monitor.TaskDispatcher')
+    def test_fixpr_returns_posted_when_queued_comment_succeeds(
+        self,
+        mock_dispatcher,
+        mock_chdir,
+        mock_clone,
+        mock_dispatch_agent,
+    ):
+        """
+        Test that _process_pr_fixpr returns 'posted' when _post_fixpr_queued succeeds.
+
+        This is the happy path - verifies correct behavior when comment posting works.
+        """
+        # Setup mocks
+        mock_clone.return_value = "/tmp/fake/repo"
+        mock_dispatch_agent.return_value = True  # Agent dispatch succeeds
+
+        pr_data = {
+            "number": 1234,
+            "title": "Test PR",
+            "headRefName": "test-branch",
+            "baseRefName": "main",
+            "url": "https://github.com/test/repo/pull/1234",
+            "headRepository": {"owner": {"login": "test"}},
+            "headRefOid": "abc123",
+            "statusCheckRollup": [],
+            "mergeable": "MERGEABLE",
+        }
+
+        # Comprehensive mocking to avoid all side effects
+        with patch.object(self.monitor, '_normalize_repository_name', return_value="test/repo"):
+            with patch.object(self.monitor, '_get_pr_comment_state', return_value=("abc123", [])):
+                with patch.object(self.monitor, '_should_skip_pr', return_value=False):
+                    with patch.object(self.monitor, '_count_workflow_comments', return_value=5):  # Under limit
+                        with patch.object(self.monitor, '_post_fixpr_queued', return_value=True) as mock_post_queued:  # SUCCEEDS
+                            with patch.object(self.monitor, '_record_processed_pr'):
+                                result = self.monitor._process_pr_fixpr(
+                                    repository="test/repo",
+                                    pr_number=1234,
+                                    pr_data=pr_data,
+                                )
+
+        # Should return "posted" when everything succeeds
+        self.assertEqual(result, "posted")
+        # Verify _post_fixpr_queued was called
+        mock_post_queued.assert_called_once()
+
+
+
+if __name__ == "__main__":
+    unittest.main()

jleechanorg_pr_automation/tests/test_graphql_error_handling.py

@@ -13,51 +13,51 @@ class TestGraphQLErrorHandling(unittest.TestCase):
     """Validate robust error handling for GraphQL API failures."""
 
     def setUp(self) -> None:
-        self.monitor = JleechanorgPRMonitor()
+        self.monitor = JleechanorgPRMonitor(automation_username="test-automation-user")
 
-    @patch('jleechanorg_pr_automation.automation_utils.AutomationUtils.execute_subprocess_with_timeout')
+    @patch("jleechanorg_pr_automation.automation_utils.AutomationUtils.execute_subprocess_with_timeout")
     def test_handles_api_timeout(self, mock_exec) -> None:
         """Should return None when GraphQL API times out"""
-        mock_exec.side_effect = subprocess.TimeoutExpired(['gh'], 30)
+        mock_exec.side_effect = subprocess.TimeoutExpired(["gh"], 30)
 
-        result = self.monitor._get_head_commit_details('org/repo', 123)
+        result = self.monitor._get_head_commit_details("org/repo", 123)
 
         self.assertIsNone(result, "Should return None on API timeout")
 
-    @patch('jleechanorg_pr_automation.automation_utils.AutomationUtils.execute_subprocess_with_timeout')
+    @patch("jleechanorg_pr_automation.automation_utils.AutomationUtils.execute_subprocess_with_timeout")
     def test_handles_malformed_json(self, mock_exec) -> None:
         """Should return None when GraphQL returns invalid JSON"""
         mock_exec.return_value = MagicMock(
             stdout='{"invalid": json, missing quotes}'
         )
 
-        result = self.monitor._get_head_commit_details('org/repo', 123)
+        result = self.monitor._get_head_commit_details("org/repo", 123)
 
         self.assertIsNone(result, "Should return None on malformed JSON")
 
-    @patch('jleechanorg_pr_automation.automation_utils.AutomationUtils.execute_subprocess_with_timeout')
+    @patch("jleechanorg_pr_automation.automation_utils.AutomationUtils.execute_subprocess_with_timeout")
     def test_handles_missing_data_field(self, mock_exec) -> None:
         """Should handle missing 'data' field in GraphQL response"""
         mock_exec.return_value = MagicMock(
             stdout='{"errors": [{"message": "Field error"}]}'
         )
 
-        result = self.monitor._get_head_commit_details('org/repo', 123)
+        result = self.monitor._get_head_commit_details("org/repo", 123)
 
         self.assertIsNone(result, "Should return None when data field missing")
 
-    @patch('jleechanorg_pr_automation.automation_utils.AutomationUtils.execute_subprocess_with_timeout')
+    @patch("jleechanorg_pr_automation.automation_utils.AutomationUtils.execute_subprocess_with_timeout")
     def test_handles_missing_repository_field(self, mock_exec) -> None:
         """Should handle missing 'repository' field gracefully"""
         mock_exec.return_value = MagicMock(
             stdout='{"data": {}}'
         )
 
-        result = self.monitor._get_head_commit_details('org/repo', 123)
+        result = self.monitor._get_head_commit_details("org/repo", 123)
 
         self.assertIsNone(result, "Should return None when repository field missing")
 
-    @patch('jleechanorg_pr_automation.automation_utils.AutomationUtils.execute_subprocess_with_timeout')
+    @patch("jleechanorg_pr_automation.automation_utils.AutomationUtils.execute_subprocess_with_timeout")
     def test_handles_missing_commits(self, mock_exec) -> None:
         """Should handle missing commits array gracefully"""
         response = {
@@ -69,11 +69,11 @@ class TestGraphQLErrorHandling(unittest.TestCase):
         }
         mock_exec.return_value = MagicMock(stdout=json.dumps(response))
 
-        result = self.monitor._get_head_commit_details('org/repo', 123)
+        result = self.monitor._get_head_commit_details("org/repo", 123)
 
         self.assertIsNone(result, "Should return None when commits missing")
 
-    @patch('jleechanorg_pr_automation.automation_utils.AutomationUtils.execute_subprocess_with_timeout')
+    @patch("jleechanorg_pr_automation.automation_utils.AutomationUtils.execute_subprocess_with_timeout")
     def test_handles_empty_commits_array(self, mock_exec) -> None:
         """Should handle empty commits array gracefully"""
         response = {
@@ -87,66 +87,66 @@ class TestGraphQLErrorHandling(unittest.TestCase):
         }
         mock_exec.return_value = MagicMock(stdout=json.dumps(response))
 
-        result = self.monitor._get_head_commit_details('org/repo', 123)
+        result = self.monitor._get_head_commit_details("org/repo", 123)
 
         self.assertIsNone(result, "Should return None when commits array empty")
 
-    @patch('jleechanorg_pr_automation.automation_utils.AutomationUtils.execute_subprocess_with_timeout')
+    @patch("jleechanorg_pr_automation.automation_utils.AutomationUtils.execute_subprocess_with_timeout")
     def test_handles_called_process_error(self, mock_exec) -> None:
         """Should handle subprocess CalledProcessError gracefully"""
         mock_exec.side_effect = subprocess.CalledProcessError(
             returncode=1,
-            cmd=['gh', 'api'],
-            stderr='API rate limit exceeded'
+            cmd=["gh", "api"],
+            stderr="API rate limit exceeded"
         )
 
-        result = self.monitor._get_head_commit_details('org/repo', 123)
+        result = self.monitor._get_head_commit_details("org/repo", 123)
 
         self.assertIsNone(result, "Should return None on CalledProcessError")
 
-    @patch('jleechanorg_pr_automation.automation_utils.AutomationUtils.execute_subprocess_with_timeout')
+    @patch("jleechanorg_pr_automation.automation_utils.AutomationUtils.execute_subprocess_with_timeout")
     def test_handles_generic_exception(self, mock_exec) -> None:
         """Should handle unexpected exceptions gracefully"""
         mock_exec.side_effect = RuntimeError("Unexpected error")
 
-        result = self.monitor._get_head_commit_details('org/repo', 123)
+        result = self.monitor._get_head_commit_details("org/repo", 123)
 
         self.assertIsNone(result, "Should return None on unexpected exception")
 
     def test_validates_invalid_repo_format(self) -> None:
         """Should return None for invalid repository format"""
-        result = self.monitor._get_head_commit_details('invalid-no-slash', 123)
+        result = self.monitor._get_head_commit_details("invalid-no-slash", 123)
 
         self.assertIsNone(result, "Should reject repo without slash separator")
 
     def test_validates_empty_repo_name(self) -> None:
         """Should return None for empty repository parts"""
-        result = self.monitor._get_head_commit_details('/repo', 123)
+        result = self.monitor._get_head_commit_details("/repo", 123)
 
         self.assertIsNone(result, "Should reject empty owner")
 
     def test_validates_invalid_github_owner_name(self) -> None:
         """Should return None for invalid GitHub owner/repo names"""
         # GitHub names cannot start with hyphen
-        result = self.monitor._get_head_commit_details('-invalid/repo', 123)
+        result = self.monitor._get_head_commit_details("-invalid/repo", 123)
 
         self.assertIsNone(result, "Should reject owner starting with hyphen")
 
     def test_validates_invalid_pr_number_string(self) -> None:
         """Should return None for non-integer PR number"""
-        result = self.monitor._get_head_commit_details('org/repo', "not-a-number")
+        result = self.monitor._get_head_commit_details("org/repo", "not-a-number")
 
         self.assertIsNone(result, "Should reject string PR number")
 
     def test_validates_negative_pr_number(self) -> None:
         """Should return None for negative PR number"""
-        result = self.monitor._get_head_commit_details('org/repo', -1)
+        result = self.monitor._get_head_commit_details("org/repo", -1)
 
         self.assertIsNone(result, "Should reject negative PR number")
 
     def test_validates_zero_pr_number(self) -> None:
         """Should return None for zero PR number"""
-        result = self.monitor._get_head_commit_details('org/repo', 0)
+        result = self.monitor._get_head_commit_details("org/repo", 0)
 
         self.assertIsNone(result, "Should reject zero PR number")
 

jleechanorg_pr_automation/tests/test_model_parameter.py

@@ -0,0 +1,317 @@
+#!/usr/bin/env python3
+"""
+Tests for --model parameter support in orchestration and automation.
+
+Validates that model parameter is correctly passed through the automation pipeline.
+"""
+
+import argparse
+import unittest
+from types import SimpleNamespace
+from unittest.mock import MagicMock, patch
+
+from jleechanorg_pr_automation.jleechanorg_pr_monitor import (
+    JleechanorgPRMonitor,
+    _normalize_model,
+)
+
+
+class TestModelParameter(unittest.TestCase):
+    """Test suite for model parameter functionality."""
+
+    def setUp(self):
+        """Set up test fixtures."""
+        self.monitor = JleechanorgPRMonitor(automation_username="test-automation-user")
+
+    def test_process_single_pr_accepts_model_parameter(self):
+        """Test that process_single_pr_by_number accepts model parameter."""
+        with patch.object(self.monitor, 'safety_manager') as mock_safety:
+            with patch('jleechanorg_pr_automation.jleechanorg_pr_monitor.AutomationUtils'):
+                mock_safety.can_start_global_run.return_value = True
+                mock_safety.try_process_pr.return_value = True
+
+                # Should not raise TypeError for model parameter
+                try:
+                    self.monitor.process_single_pr_by_number(
+                        pr_number=1234,
+                        repository="test/repo",
+                        fix_comment=True,
+                        agent_cli="claude",
+                        model="sonnet"  # Test model parameter
+                    )
+                except TypeError as e:
+                    if "model" in str(e):
+                        self.fail(f"process_single_pr_by_number does not accept model parameter: {e}")
+                except Exception:
+                    # Other exceptions are okay for this test - we just want to verify signature
+                    pass
+
+    def test_dispatch_fix_comment_agent_accepts_model_parameter(self):
+        """Test that dispatch_fix_comment_agent accepts model parameter."""
+        with patch('jleechanorg_pr_automation.jleechanorg_pr_monitor.ensure_base_clone') as mock_clone,              patch('jleechanorg_pr_automation.jleechanorg_pr_monitor.chdir'),              patch('jleechanorg_pr_automation.jleechanorg_pr_monitor.TaskDispatcher'),              patch('jleechanorg_pr_automation.jleechanorg_pr_monitor.dispatch_agent_for_pr_with_task') as mock_dispatch:
+            
+            mock_clone.return_value = "/tmp/fake/repo"
+            mock_dispatch.return_value = True
+
+            pr_data = {
+                "number": 1234,
+                "title": "Test PR",
+                "headRefName": "test-branch",
+                "url": "https://github.com/test/repo/pull/1234"
+            }
+
+            # Should not raise TypeError for model parameter
+            try:
+                self.monitor.dispatch_fix_comment_agent(
+                    repository="test/repo",
+                    pr_number=1234,
+                    pr_data=pr_data,
+                    agent_cli="claude",
+                    model="opus"  # Test model parameter
+                )
+                # Verify it was passed through
+                mock_dispatch.assert_called_once()
+                call_kwargs = mock_dispatch.call_args[1]
+                self.assertEqual(call_kwargs.get("model"), "opus")
+            except TypeError as e:
+                if "model" in str(e):
+                    self.fail(f"dispatch_fix_comment_agent does not accept model parameter: {e}")
+
+    def test_model_parameter_passed_to_dispatcher(self):
+        """Test that model parameter is passed through to dispatcher."""
+        with patch('jleechanorg_pr_automation.jleechanorg_pr_monitor.TaskDispatcher'),              patch('jleechanorg_pr_automation.jleechanorg_pr_monitor.ensure_base_clone'),              patch('jleechanorg_pr_automation.jleechanorg_pr_monitor.chdir'),              patch('jleechanorg_pr_automation.jleechanorg_pr_monitor.dispatch_agent_for_pr_with_task') as mock_dispatch,              patch.object(self.monitor, '_post_fix_comment_queued') as mock_queued,              patch.object(self.monitor, '_start_fix_comment_review_watcher') as mock_watcher,              patch.object(self.monitor, '_get_pr_comment_state', return_value=(None, [])):
+            
+            mock_dispatch.return_value = True
+            mock_queued.return_value = True
+            mock_watcher.return_value = True
+
+            pr_data = {
+                "number": 1234,
+                "title": "Test PR",
+                "headRefName": "test-branch",
+                "baseRefName": "main",
+                "url": "https://github.com/test/repo/pull/1234",
+                "headRepository": {"owner": {"login": "test"}},
+                "headRefOid": "abc123"
+            }
+
+            # Process fix-comment with model parameter
+            self.monitor._process_pr_fix_comment(
+                repository="test/repo",
+                pr_number=1234,
+                pr_data=pr_data,
+                agent_cli="claude",
+                model="haiku"  # Test model parameter
+            )
+
+            # Verify dispatcher was called with model parameter
+            mock_dispatch.assert_called_once()
+            call_kwargs = mock_dispatch.call_args[1]
+            self.assertEqual(call_kwargs.get("model"), "haiku")
+
+    def test_cli_argument_parser_has_model_flag(self):
+        """Test that CLI argument parser includes --model flag."""
+        # Get the argument parser from the module
+        parser = argparse.ArgumentParser()
+
+        # Add the expected arguments (mimicking what main() does)
+        parser.add_argument("--model", type=str, default=None,
+                          help="Model to use for Claude CLI")
+
+        # Should not raise error
+        args = parser.parse_args(["--model", "sonnet"])
+        self.assertEqual(args.model, "sonnet")
+
+    def test_model_defaults_to_none(self):
+        """Test that model parameter defaults to None when not provided."""
+        parser = argparse.ArgumentParser()
+        parser.add_argument("--model", type=str, default=None)
+
+        # Parse without --model flag
+        args = parser.parse_args([])
+        self.assertIsNone(args.model)
+
+    def test_multiple_model_values(self):
+        """Test different valid model values."""
+        valid_models = ["sonnet", "opus", "haiku", "gemini-3-pro-preview", "composer-1"]
+
+        for model in valid_models:
+            with self.subTest(model=model):
+                with patch.object(self.monitor, 'safety_manager') as mock_safety:
+                    with patch('jleechanorg_pr_automation.jleechanorg_pr_monitor.AutomationUtils'):
+                        mock_safety.can_start_global_run.return_value = True
+                        mock_safety.try_process_pr.return_value = True
+
+                        try:
+                            self.monitor.process_single_pr_by_number(
+                                pr_number=1234,
+                                repository="test/repo",
+                                fix_comment=True,
+                                agent_cli="claude",
+                                model=model
+                            )
+                        except TypeError as e:
+                            if "model" in str(e):
+                                self.fail(f"Model parameter not accepted for value '{model}': {e}")
+                        except Exception:
+                            # Other exceptions are okay
+                            pass
+
+    def test_fixpr_run_monitoring_cycle_threads_model(self):
+        """FixPR mode should pass --model through to _process_pr_fixpr."""
+        monitor = JleechanorgPRMonitor()
+        pr = {
+            "repository": "test/repo",
+            "repositoryFullName": "test/repo",
+            "number": 123,
+            "title": "Test PR",
+            "headRefName": "feature/test",
+        }
+
+        with patch.object(monitor, "discover_open_prs", return_value=[pr]), \
+             patch.object(monitor, "is_pr_actionable", return_value=True), \
+             patch.object(monitor, "_get_pr_comment_state", return_value=(None, [])), \
+             patch.object(monitor, "_process_pr_fixpr", return_value="skipped") as mock_fixpr, \
+             patch("jleechanorg_pr_automation.jleechanorg_pr_monitor.has_failing_checks", return_value=True), \
+             patch("jleechanorg_pr_automation.jleechanorg_pr_monitor.AutomationUtils.execute_subprocess_with_timeout",
+                   return_value=SimpleNamespace(returncode=0, stdout='{\"mergeable\":\"MERGEABLE\"}')):
+
+            with patch.object(monitor, "safety_manager") as mock_safety:
+                mock_safety.can_start_global_run.return_value = True
+                mock_safety.try_process_pr.return_value = True
+                mock_safety.get_global_runs.return_value = 1
+                mock_safety.global_limit = 50
+                mock_safety.fixpr_limit = 10
+                mock_safety.pr_limit = 10
+                mock_safety.pr_automation_limit = 10
+                mock_safety.fix_comment_limit = 10
+
+                monitor.run_monitoring_cycle(
+                    max_prs=1,
+                    cutoff_hours=24,
+                    fixpr=True,
+                    agent_cli="claude",
+                    model="sonnet",
+                )
+
+            self.assertTrue(mock_fixpr.called)
+            self.assertEqual(mock_fixpr.call_args[1].get("model"), "sonnet")
+
+    def test_fixpr_process_pr_threads_model_to_dispatch(self):
+        """_process_pr_fixpr should forward model through to dispatch_agent_for_pr."""
+        monitor = JleechanorgPRMonitor()
+        pr_data = {
+            "number": 123,
+            "title": "Test PR",
+            "headRefName": "feature/test",
+            "url": "https://github.com/test/repo/pull/123",
+            "headRefOid": "abc123",
+        }
+
+        with patch.object(monitor, "_get_pr_comment_state", return_value=(None, [])), \
+             patch.object(monitor, "_should_skip_pr", return_value=False), \
+             patch.object(monitor, "_post_fixpr_queued", return_value=True), \
+             patch("jleechanorg_pr_automation.jleechanorg_pr_monitor.ensure_base_clone", return_value="/tmp/fake/repo"), \
+             patch("jleechanorg_pr_automation.jleechanorg_pr_monitor.chdir"), \
+             patch("jleechanorg_pr_automation.jleechanorg_pr_monitor.TaskDispatcher"), \
+             patch("jleechanorg_pr_automation.jleechanorg_pr_monitor.dispatch_agent_for_pr", return_value=True) as mock_dispatch:
+
+            monitor.safety_manager.fixpr_limit = 10
+            result = monitor._process_pr_fixpr(
+                repository="test/repo",
+                pr_number=123,
+                pr_data=pr_data,
+                agent_cli="claude",
+                model="sonnet",
+            )
+
+        self.assertEqual(result, "posted")
+        self.assertEqual(mock_dispatch.call_args[1].get("model"), "sonnet")
+
+
+    def test_normalize_model_none_returns_none(self):
+        """Test that _normalize_model returns None for None input."""
+        result = _normalize_model(None)
+        self.assertIsNone(result)
+
+    def test_normalize_model_empty_string_returns_none(self):
+        """Test that _normalize_model returns None for empty string."""
+        result = _normalize_model("")
+        self.assertIsNone(result)
+        
+        result = _normalize_model("   ")
+        self.assertIsNone(result)
+
+    def test_normalize_model_valid_names(self):
+        """Test that _normalize_model accepts valid model names."""
+        valid_models = [
+            "sonnet",
+            "opus",
+            "haiku",
+            "gemini-3-pro-preview",
+            "gemini-3-auto",
+            "composer-1",
+            "model_name",
+            "model.name",
+            "model_name_123",
+            "a",
+            "123",
+        ]
+        
+        for model in valid_models:
+            with self.subTest(model=model):
+                result = _normalize_model(model)
+                self.assertEqual(result, model.strip())
+                
+                # Test with whitespace
+                result = _normalize_model(f"  {model}  ")
+                self.assertEqual(result, model)
+
+    def test_normalize_model_invalid_names_raises_error(self):
+        """Test that _normalize_model rejects invalid model names."""
+        invalid_models = [
+            "model with spaces",
+            "model@invalid",
+            "model#invalid",
+            "model$invalid",
+            "model%invalid",
+            "model&invalid",
+            "model*invalid",
+            "model+invalid",
+            "model=invalid",
+            "model[invalid",
+            "model]invalid",
+            "model{invalid",
+            "model}invalid",
+            "model|invalid",
+            "model\\invalid",
+            "model/invalid",
+            "model<invalid",
+            "model>invalid",
+            "model,invalid",
+            "model;invalid",
+            "model:invalid",
+            "model'invalid",
+            'model"invalid',
+            "model`invalid",
+            "model~invalid",
+            "model!invalid",
+            "model?invalid",
+        ]
+        
+        for model in invalid_models:
+            with self.subTest(model=model):
+                with self.assertRaises(argparse.ArgumentTypeError):
+                    _normalize_model(model)
+
+    def test_normalize_model_strips_whitespace(self):
+        """Test that _normalize_model strips whitespace from valid names."""
+        result = _normalize_model("  sonnet  ")
+        self.assertEqual(result, "sonnet")
+        
+        result = _normalize_model("\tgemini-3-auto\n")
+        self.assertEqual(result, "gemini-3-auto")
+
+
+if __name__ == '__main__':
+    unittest.main()