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

jleechanorg_pr_automation/__init__.py

@@ -16,7 +16,7 @@ from .utils import (
     json_manager,
 )
 
-__version__ = "0.1.0"
+__version__ = "0.1.1"
 __author__ = "jleechan"
 __email__ = "jlee@jleechan.org"
 

jleechanorg_pr_automation/automation_safety_manager.py

@@ -4,7 +4,7 @@ Automation Safety Manager - GREEN Phase Implementation
 
 Minimal implementation to pass the RED phase tests with:
 - PR attempt limits (max 5 per PR)
-- Global run limits (max 50 total)
+- Global run limits (max 50 per day with automatic midnight reset)
 - Manual approval system
 - Thread-safe operations
 - Email notifications
@@ -25,6 +25,12 @@ from email.mime.text import MIMEText
 from email.mime.multipart import MIMEMultipart
 from typing import Dict, Optional, Union
 
+
+REAL_DATETIME = datetime
+
+# Number of characters in the ISO 8601 date prefix ("YYYY-MM-DD").
+ISO_DATE_PREFIX_LENGTH = len("YYYY-MM-DD")
+
 # Optional keyring import for email functionality
 _keyring_spec = importlib.util.find_spec("keyring")
 if _keyring_spec:
@@ -88,9 +94,14 @@ class AutomationSafetyManager:
             self._write_json_file(self.pr_attempts_file, {})
 
         if not os.path.exists(self.global_runs_file):
+            now = datetime.now()
+            today = now.date().isoformat()
             self._write_json_file(self.global_runs_file, {
                 "total_runs": 0,
-                "start_date": datetime.now().isoformat()
+                "start_date": now.isoformat(),
+                "current_date": today,
+                "last_run": None,
+                "last_reset": now.isoformat(),
             })
 
         if not os.path.exists(self.approval_file):
@@ -121,7 +132,6 @@ class AutomationSafetyManager:
             default_config = {
                 "global_limit": self.global_limit,
                 "pr_limit": self.pr_limit,
-                "daily_limit": 100
             }
             self._write_json_file(self.config_file, default_config)
 
@@ -145,11 +155,6 @@ class AutomationSafetyManager:
             # Sync PR attempts - keys already normalized
             self._write_json_file(self.pr_attempts_file, self._pr_attempts_cache)
 
-            # Sync global runs
-            global_data = self._read_json_file(self.global_runs_file)
-            global_data["total_runs"] = self._global_runs_cache
-            self._write_json_file(self.global_runs_file, global_data)
-
             # Sync inflight cache to prevent concurrent processing
             self._write_json_file(self.inflight_file, self._pr_inflight_cache)
 
@@ -218,6 +223,99 @@ class AutomationSafetyManager:
         except Exception as e:
             self.logger.error(f"Exception writing safety data file {file_path}: {e}")
 
+    def _normalize_global_run_payload(
+        self,
+        payload: Optional[dict],
+        *,
+        now: Optional[datetime] = None,
+    ) -> tuple[dict, int, bool]:
+        """Normalize persisted global run data and determine if it is stale."""
+
+        current_time = now or datetime.now()
+        today = current_time.date().isoformat()
+
+        if isinstance(payload, dict):
+            data = dict(payload)
+        else:
+            data = {}
+
+        # Ensure start_date is always present and well-formed
+        start_date = data.get("start_date")
+        if isinstance(start_date, str):
+            try:
+                REAL_DATETIME.fromisoformat(start_date)
+            except ValueError:
+                data["start_date"] = current_time.isoformat()
+        else:
+            data["start_date"] = current_time.isoformat()
+
+        stored_date = data.get("current_date")
+        normalized_date: Optional[str] = None
+        if isinstance(stored_date, str):
+            try:
+                normalized_date = REAL_DATETIME.fromisoformat(stored_date).date().isoformat()
+            except ValueError:
+                # Support legacy data that stored raw dates without full ISO format
+                if len(stored_date) >= ISO_DATE_PREFIX_LENGTH:
+                    candidate = stored_date[:ISO_DATE_PREFIX_LENGTH]
+                    try:
+                        normalized_date = REAL_DATETIME.fromisoformat(candidate).date().isoformat()
+                    except ValueError:
+                        normalized_date = None
+                else:
+                    normalized_date = None
+
+        if normalized_date is None:
+            try:
+                normalized_date = REAL_DATETIME.fromisoformat(data["start_date"]).date().isoformat()
+            except ValueError:
+                normalized_date = None
+
+        is_stale = normalized_date != today
+
+        if is_stale:
+            normalized_date = today
+            data["total_runs"] = 0
+            data["last_reset"] = current_time.isoformat()
+
+        data["current_date"] = normalized_date or today
+
+        raw_total = data.get("total_runs", 0)
+        try:
+            total_runs = int(raw_total)
+        except (TypeError, ValueError):
+            total_runs = 0
+
+        if total_runs < 0:
+            total_runs = 0
+
+        data["total_runs"] = total_runs
+
+        last_run = data.get("last_run")
+        if last_run is not None:
+            if not isinstance(last_run, str):
+                data.pop("last_run", None)
+            else:
+                try:
+                    REAL_DATETIME.fromisoformat(last_run)
+                except ValueError:
+                    data.pop("last_run", None)
+
+        last_reset = data.get("last_reset")
+        if last_reset is not None:
+            if not isinstance(last_reset, str):
+                data.pop("last_reset", None)
+            else:
+                try:
+                    REAL_DATETIME.fromisoformat(last_reset)
+                except ValueError:
+                    data.pop("last_reset", None)
+
+        if "last_reset" not in data:
+            data["last_reset"] = data["start_date"]
+
+        return data, total_runs, is_stale
+
     def can_process_pr(self, pr_number: Union[int, str], repo: str = None, branch: str = None) -> bool:
         """Check if PR can be processed (under attempt limit)"""
         with self.lock:
@@ -330,8 +428,8 @@ class AutomationSafetyManager:
     def can_start_global_run(self) -> bool:
         """Check if a global run can be started"""
         with self.lock:
-            # Use cache for testing, file for production
-            runs = self._global_runs_cache if hasattr(self, '_global_runs_cache') else self.get_global_runs()
+            # Always refresh from file to detect external resets
+            runs = self.get_global_runs()
 
             if runs < self.global_limit:
                 return True
@@ -345,29 +443,58 @@ class AutomationSafetyManager:
             return False
 
     def get_global_runs(self) -> int:
-        """Get total number of global runs"""
+        """Get total number of global runs (resets daily)"""
         with self.lock:
-            # Reload from disk to ensure consistency across multiple managers
-            data = self._read_json_file(self.global_runs_file)
-            self._global_runs_cache = data.get("total_runs", 0)
-            return self._global_runs_cache
+            normalized_total = 0
+
+            def _refresh(payload: Optional[dict]):
+                nonlocal normalized_total
+                normalized, total, _ = self._normalize_global_run_payload(payload)
+                normalized_total = normalized["total_runs"]
+                return normalized
+
+            if not json_manager.update_json(self.global_runs_file, _refresh):
+                self.logger.warning(
+                    "Falling back to manual refresh for global run counter"
+                )
+                payload = self._read_json_file(self.global_runs_file)
+                normalized, total, _ = self._normalize_global_run_payload(payload)
+                normalized_total = total
+                self._write_json_file(self.global_runs_file, normalized)
+
+            self._global_runs_cache = normalized_total
+            return normalized_total
 
     def record_global_run(self):
         """Record a global automation run atomically"""
         with self.lock:
-            try:
-                # Update in-memory cache
-                self._global_runs_cache += 1
-
-                # Sync to file for persistence (atomic operation)
-                data = self._read_json_file(self.global_runs_file)
-                data["total_runs"] = self._global_runs_cache
-                data["last_run"] = datetime.now().isoformat()
-                self._write_json_file(self.global_runs_file, data)
-            except Exception:
-                # Rollback cache if file write failed
-                self._global_runs_cache -= 1
-                raise
+            new_total = 0
+            current_time = datetime.now()
+
+            def _increment(payload: Optional[dict]):
+                nonlocal new_total
+                normalized, total, _ = self._normalize_global_run_payload(payload, now=current_time)
+                total += 1
+                normalized["total_runs"] = total
+                normalized["current_date"] = current_time.date().isoformat()
+                normalized["last_run"] = current_time.isoformat()
+                new_total = total
+                return normalized
+
+            if not json_manager.update_json(self.global_runs_file, _increment):
+                self.logger.warning(
+                    "Falling back to manual increment for global run counter"
+                )
+                payload = self._read_json_file(self.global_runs_file)
+                normalized, total, _ = self._normalize_global_run_payload(payload, now=current_time)
+                total += 1
+                normalized["total_runs"] = total
+                normalized["current_date"] = current_time.date().isoformat()
+                normalized["last_run"] = current_time.isoformat()
+                new_total = total
+                self._write_json_file(self.global_runs_file, normalized)
+
+            self._global_runs_cache = new_total
 
     def requires_manual_approval(self) -> bool:
         """Check if manual approval is required"""
@@ -387,7 +514,7 @@ class AutomationSafetyManager:
                 return False
 
             try:
-                approval_date = datetime.fromisoformat(approval_date_str)
+                approval_date = REAL_DATETIME.fromisoformat(approval_date_str)
             except (TypeError, ValueError):
                 return False
             approval_hours = get_automation_limits()['approval_hours']
@@ -532,6 +659,9 @@ This is an automated notification from the WorldArchitect.AI automation system.
             data = self._read_json_file(self.global_runs_file)
             data["total_runs"] = 0
             data["last_run"] = None
+            now = datetime.now()
+            data["current_date"] = now.date().isoformat()
+            data["last_reset"] = now.isoformat()
             self._write_json_file(self.global_runs_file, data)
 
     def _clear_pr_attempts(self):

jleechanorg_pr_automation/codex_config.py

@@ -7,9 +7,23 @@ from dataclasses import dataclass
 
 DEFAULT_ASSISTANT_HANDLE = "coderabbitai"
 
-# Core instruction template with hardcoded AI assistant mentions
+
+def compose_assistant_mentions(assistant_handle: str) -> str:
+    """Return the canonical mention list for the supplied assistant handle."""
+
+    return f"@codex @{assistant_handle} @copilot @cursor"
+
+
+DEFAULT_ASSISTANT_MENTIONS = compose_assistant_mentions(DEFAULT_ASSISTANT_HANDLE)
+
+CODEX_COMMENT_INTRO_BODY = (
+    "[AI automation] Codex will implement the code updates while {review_assistants_clause} "
+    "review support. Please make the following changes to this PR."
+)
+
+# Core instruction template with shared AI assistant intro text
 CODEX_COMMENT_TEMPLATE = (
-    "@codex @coderabbitai @copilot @cursor [AI automation] Please make the following changes to this PR\n\n"
+    "{comment_intro}\n\n"
     "Use your judgment to fix comments from everyone or explain why it should not be fixed. "
     "Follow binary response protocol - every comment needs \"DONE\" or \"NOT DONE\" classification "
     "explicitly with an explanation. Address all comments on this PR. Fix any failing tests and "
@@ -32,11 +46,63 @@ def normalise_handle(assistant_handle: str | None) -> str:
     return cleaned or DEFAULT_ASSISTANT_HANDLE
 
 
+def _extract_review_assistants(assistant_mentions: str) -> list[str]:
+    """Return the assistant mentions that participate in review support."""
+
+    tokens = assistant_mentions.split()
+    return [
+        token
+        for token in tokens
+        if token.startswith("@") and token.lower() != "@codex"
+    ]
+
+
+def _format_review_assistants(review_assistants: list[str]) -> str:
+    """Return a human readable list of review assistants for prose usage."""
+
+    if not review_assistants:
+        return "the review assistants"
+
+    # Strip leading "@" handles so we don't ping reviewers twice inside the prose.
+    prose_names = [assistant.lstrip("@") or assistant for assistant in review_assistants]
+
+    if len(prose_names) == 1:
+        return prose_names[0]
+
+    if len(prose_names) == 2:
+        return f"{prose_names[0]} and {prose_names[1]}"
+
+    return ", ".join(prose_names[:-1]) + f", and {prose_names[-1]}"
+
+
+def build_comment_intro(
+    assistant_mentions: str | None = None,
+    assistant_handle: str | None = None,
+) -> str:
+    """Return the shared Codex automation intro text for comment bodies."""
+
+    mentions = assistant_mentions
+    if mentions is None:
+        mentions = compose_assistant_mentions(normalise_handle(assistant_handle))
+    review_assistants = _extract_review_assistants(mentions)
+    assistants_text = _format_review_assistants(review_assistants)
+    if len(review_assistants) == 1:
+        clause = f"{assistants_text} focuses on"
+    else:
+        clause = f"{assistants_text} focus on"
+    intro_body = CODEX_COMMENT_INTRO_BODY.format(
+        review_assistants_clause=clause
+    )
+    intro_prefix = f"{mentions} " if mentions else ""
+    return f"{intro_prefix}{intro_body}"
+
+
 def build_default_comment(assistant_handle: str | None = None) -> str:
     """Return the default Codex instruction text for the given handle."""
 
-    handle = normalise_handle(assistant_handle)
-    return CODEX_COMMENT_TEMPLATE.format(assistant_handle=handle)
+    return CODEX_COMMENT_TEMPLATE.format(
+        comment_intro=build_comment_intro(assistant_handle=assistant_handle)
+    )
 
 
 @dataclass(frozen=True)

jleechanorg_pr_automation/jleechanorg_pr_monitor.py

@@ -25,10 +25,13 @@ from .automation_utils import AutomationUtils
 from .codex_config import (
     CODEX_COMMIT_MARKER_PREFIX as SHARED_MARKER_PREFIX,
     CODEX_COMMIT_MARKER_SUFFIX as SHARED_MARKER_SUFFIX,
+    build_comment_intro,
 )
 
 
 class JleechanorgPRMonitor:
+    """Cross-organization PR monitoring with Codex automation comments"""
+
     @staticmethod
     def _redact_email(email: Optional[str]) -> Optional[str]:
         """Redact email for logging while preserving domain for debugging"""
@@ -38,7 +41,6 @@ class JleechanorgPRMonitor:
         if len(user) <= 2:
             return f"***@{domain}"
         return f"{user[:2]}***@{domain}"
-    """Cross-organization PR monitoring with Codex automation comments"""
 
     CODEX_COMMIT_MARKER_PREFIX = SHARED_MARKER_PREFIX
     CODEX_COMMIT_MARKER_SUFFIX = SHARED_MARKER_SUFFIX
@@ -531,6 +533,10 @@ class JleechanorgPRMonitor:
         repo_full = self._normalize_repository_name(repository)
         self.logger.info(f"💬 Requesting Codex support for {repo_full} PR #{pr_number}")
 
+        # Extract repo name and branch from PR data
+        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
@@ -543,12 +549,9 @@ class JleechanorgPRMonitor:
                     repo_full,
                     pr_number,
                 )
+                self._record_processed_pr(repo_name, branch_name, pr_number, head_sha)
                 return "skipped"
 
-        # Extract repo name and branch from PR data
-        repo_name = repo_full.split('/')[-1]
-        branch_name = pr_data.get('headRefName', 'unknown')
-
         if not head_sha:
             self.logger.warning(
                 f"⚠️ Could not determine commit SHA for PR #{pr_number}; proceeding without marker gating"
@@ -656,7 +659,8 @@ class JleechanorgPRMonitor:
     ) -> str:
         """Build comment body that tells all AI assistants to fix PR comments, tests, and merge conflicts"""
 
-        comment_body = f"""{self.assistant_mentions} [AI automation] Please make the following changes to this PR
+        intro_line = build_comment_intro(assistant_mentions=self.assistant_mentions)
+        comment_body = f"""{intro_line}
 
 **Summary (Execution Flow):**
 1. Review every outstanding PR comment to understand required fixes and clarifications.

jleechanorg_pr_automation/tests/test_automation_over_running_reproduction.py

@@ -37,14 +37,20 @@ class TestAutomationOverRunningReproduction(unittest.TestCase):
 
         Manual override allows up to 2x the normal limit (100 runs) but no more.
         """
-        # Set up scenario: we're at the 50 run limit
-        self.manager._global_runs_cache = 50
+        # Set up scenario: we're at the 2x limit + 1 (101 runs)
+        # We need to write to the file since get_global_runs() reads from file
+        today = datetime.now().date().isoformat()
+        data = {
+            "total_runs": 101,
+            "start_date": datetime.now().isoformat(),
+            "current_date": today
+        }
+        self.manager._write_json_file(self.manager.global_runs_file, data)
 
         # Manual approval should NOT allow unlimited runs
         self.manager.grant_manual_approval("test@example.com")
 
         # This should be FALSE after 2x the limit (100 runs)
-        self.manager._global_runs_cache = 101
         result = self.manager.can_start_global_run()
 
         # FIXED: This should now be FALSE (blocked) at 101 runs
@@ -91,14 +97,18 @@ class TestAutomationOverRunningReproduction(unittest.TestCase):
 
         The system now blocks excessive runs even with manual override.
         """
-        # Simulate the exact scenario from the bug report
-        self.manager._global_runs_cache = 0
-
         # Grant approval (simulating what happened Sept 27)
         self.manager.grant_manual_approval("jleechan@anthropic.com")
 
         # Simulate running 346 times (what actually happened)
-        self.manager._global_runs_cache = 346
+        # We need to write to the file since get_global_runs() reads from file
+        today = datetime.now().date().isoformat()
+        data = {
+            "total_runs": 346,
+            "start_date": datetime.now().isoformat(),
+            "current_date": today
+        }
+        self.manager._write_json_file(self.manager.global_runs_file, data)
 
         # This should now be FALSE (blocked) with fixed logic
         result = self.manager.can_start_global_run()

jleechanorg_pr_automation/tests/test_automation_safety_limits.py

@@ -264,6 +264,128 @@ class TestAutomationSafetyLimits(unittest.TestCase):
         self.assertEqual(manager.pr_limit, 5)
         self.assertEqual(manager.global_limit, 50)
 
+    # Matrix 8: Daily Reset Functionality (50 runs per day)
+    def test_daily_reset_first_run_of_day(self):
+        """RED: First run of the day should be allowed with counter at 0"""
+        result = self.automation_manager.can_start_global_run()
+        self.assertTrue(result)
+        self.assertEqual(self.automation_manager.get_global_runs(), 0)
+
+    def test_daily_reset_49th_run_same_day(self):
+        """RED: 49th run on same day should be allowed"""
+        # Record 48 runs on same day
+        for _ in range(48):
+            self.automation_manager.record_global_run()
+
+        result = self.automation_manager.can_start_global_run()
+        self.assertTrue(result)
+        self.assertEqual(self.automation_manager.get_global_runs(), 48)
+
+    def test_daily_reset_50th_run_same_day(self):
+        """RED: 50th run on same day should be allowed (at limit)"""
+        # Record 49 runs on same day
+        for _ in range(49):
+            self.automation_manager.record_global_run()
+
+        result = self.automation_manager.can_start_global_run()
+        self.assertTrue(result)
+        self.assertEqual(self.automation_manager.get_global_runs(), 49)
+
+    def test_daily_reset_51st_run_same_day_blocked(self):
+        """RED: 51st run on same day should be blocked"""
+        # Record 50 runs on same day (hit daily limit)
+        for _ in range(50):
+            self.automation_manager.record_global_run()
+
+        result = self.automation_manager.can_start_global_run()
+        self.assertFalse(result)
+        self.assertEqual(self.automation_manager.get_global_runs(), 50)
+
+    def test_daily_reset_missing_current_date_resets_counter(self):
+        """Legacy counters without current_date should reset after upgrade"""
+        legacy_data = {
+            "total_runs": 50,
+            "start_date": datetime(2025, 9, 30, 12, 0, 0).isoformat()
+        }
+        with open(self.global_runs_file, 'w') as f:
+            json.dump(legacy_data, f)
+
+        if hasattr(self, '_automation_manager'):
+            del self._automation_manager
+
+        # First run after upgrade should reset the stale counter
+        self.assertTrue(self.automation_manager.can_start_global_run())
+        self.assertEqual(self.automation_manager.get_global_runs(), 0)
+
+    @patch('jleechanorg_pr_automation.automation_safety_manager.datetime')
+    def test_daily_reset_new_day_resets_counter(self, mock_datetime):
+        """RED: Counter should reset to 0 when a new day starts"""
+        # Day 1: Record 50 runs
+        day1 = datetime(2025, 10, 1, 10, 0, 0)
+        mock_datetime.now.return_value = day1
+        mock_datetime.side_effect = lambda *args, **kw: datetime(*args, **kw)
+
+        for _ in range(50):
+            self.automation_manager.record_global_run()
+
+        # Should be at limit on Day 1
+        self.assertEqual(self.automation_manager.get_global_runs(), 50)
+        self.assertFalse(self.automation_manager.can_start_global_run())
+
+        # Day 2: Counter should reset
+        day2 = datetime(2025, 10, 2, 10, 0, 0)
+        mock_datetime.now.return_value = day2
+
+        # Should allow runs again with reset counter
+        result = self.automation_manager.can_start_global_run()
+        self.assertTrue(result)
+        self.assertEqual(self.automation_manager.get_global_runs(), 0)
+
+    @patch('jleechanorg_pr_automation.automation_safety_manager.datetime')
+    def test_daily_reset_multiple_days(self, mock_datetime):
+        """RED: Counter should reset each day for multiple days"""
+        mock_datetime.side_effect = lambda *args, **kw: datetime(*args, **kw)
+
+        # Day 1: 50 runs
+        day1 = datetime(2025, 10, 1, 10, 0, 0)
+        mock_datetime.now.return_value = day1
+        for _ in range(50):
+            self.automation_manager.record_global_run()
+        self.assertEqual(self.automation_manager.get_global_runs(), 50)
+
+        # Day 2: Reset to 0, then 30 runs
+        day2 = datetime(2025, 10, 2, 10, 0, 0)
+        mock_datetime.now.return_value = day2
+        self.assertEqual(self.automation_manager.get_global_runs(), 0)
+        for _ in range(30):
+            self.automation_manager.record_global_run()
+        self.assertEqual(self.automation_manager.get_global_runs(), 30)
+
+        # Day 3: Reset to 0 again
+        day3 = datetime(2025, 10, 3, 10, 0, 0)
+        mock_datetime.now.return_value = day3
+        self.assertEqual(self.automation_manager.get_global_runs(), 0)
+
+    @patch('jleechanorg_pr_automation.automation_safety_manager.datetime')
+    def test_daily_reset_midnight_transition(self, mock_datetime):
+        """RED: Counter should reset at midnight transition"""
+        mock_datetime.side_effect = lambda *args, **kw: datetime(*args, **kw)
+
+        # 23:59:59 on Day 1 - at limit
+        before_midnight = datetime(2025, 10, 1, 23, 59, 59)
+        mock_datetime.now.return_value = before_midnight
+        for _ in range(50):
+            self.automation_manager.record_global_run()
+        self.assertFalse(self.automation_manager.can_start_global_run())
+
+        # 00:00:01 on Day 2 - should reset
+        after_midnight = datetime(2025, 10, 2, 0, 0, 1)
+        mock_datetime.now.return_value = after_midnight
+
+        result = self.automation_manager.can_start_global_run()
+        self.assertTrue(result)
+        self.assertEqual(self.automation_manager.get_global_runs(), 0)
+
     @property
     def automation_manager(self):
         """RED: This property will fail - no AutomationSafetyManager exists yet"""
@@ -273,7 +395,7 @@ class TestAutomationSafetyLimits(unittest.TestCase):
         return self._automation_manager
 
 
-# Matrix 8: Integration with Existing Automation
+# Matrix 9: Integration with Existing Automation
 class TestAutomationIntegration(unittest.TestCase):
     """Integration tests with existing simple_pr_batch.sh script"""
 

jleechanorg_pr_automation/tests/test_automation_safety_manager_comprehensive.py

@@ -16,6 +16,7 @@ from unittest.mock import Mock, patch, MagicMock
 
 # Import the automation safety manager using proper Python module path
 from jleechanorg_pr_automation.automation_safety_manager import AutomationSafetyManager
+from jleechanorg_pr_automation.utils import json_manager
 
 
 class TestAutomationSafetyManagerInit:
@@ -150,6 +151,49 @@ class TestGlobalLimits:
         manager._clear_global_runs()
         assert manager.get_global_runs() == 0
 
+    def test_global_runs_auto_resets_daily(self, manager):
+        """Daily reset should clear the counter and allow automation without manual approval."""
+        manager._clear_global_runs()
+
+        # Simulate crossing the daily limit
+        for _ in range(manager.global_limit):
+            manager.record_global_run()
+
+        assert manager.requires_manual_approval() is True
+
+        now = datetime.now()
+        stale_payload = {
+            "total_runs": manager.global_limit,
+            "start_date": (now - timedelta(days=4)).isoformat(),
+            "current_date": (now - timedelta(days=1)).date().isoformat(),
+            "last_run": (now - timedelta(hours=2)).isoformat(),
+            "last_reset": (now - timedelta(days=2)).isoformat(),
+        }
+        json_manager.write_json(manager.global_runs_file, stale_payload)
+
+        refreshed_runs = manager.get_global_runs()
+        expected_today = datetime.now().date().isoformat()
+        assert refreshed_runs == 0
+        assert manager.requires_manual_approval() is False
+
+        normalized = manager._read_json_file(manager.global_runs_file)
+        assert normalized["current_date"] == expected_today
+        assert normalized["total_runs"] == 0
+
+        # Ensure the reset timestamp is updated and sane
+        last_reset = normalized.get("last_reset")
+        assert last_reset is not None
+        parsed_reset = datetime.fromisoformat(last_reset)
+        assert (
+            parsed_reset is not None
+        ), "last_reset should be a valid ISO datetime"
+
+        # Record another run and verify counters/log fields move forward
+        manager.record_global_run()
+        normalized = manager._read_json_file(manager.global_runs_file)
+        assert normalized["total_runs"] == 1
+        assert datetime.fromisoformat(normalized["last_run"])
+
 
 class TestPRLimits:
     """Test suite for per-PR automation limits"""

jleechanorg_pr_automation/tests/test_pr_filtering_matrix.py

@@ -408,7 +408,7 @@ class TestPRFilteringMatrix(unittest.TestCase):
             mock_has_comment.assert_not_called()
             mock_build_body.assert_not_called()
             mock_subprocess.assert_not_called()
-            mock_record_processed.assert_not_called()
+            mock_record_processed.assert_called_once_with('repo', 'feature', 456, 'sha123')
 
     def test_process_pr_comment_only_returns_true_for_posted(self):
         """GREEN: _process_pr_comment should only return True when comment actually posted"""

jleechanorg_pr_automation/tests/test_pr_targeting.py

@@ -5,6 +5,7 @@ Test PR targeting functionality for jleechanorg_pr_monitor - Codex Strategy Test
 
 import unittest
 
+from jleechanorg_pr_automation.codex_config import build_comment_intro
 from jleechanorg_pr_automation.jleechanorg_pr_monitor import JleechanorgPRMonitor
 
 
@@ -14,10 +15,32 @@ class TestPRTargeting(unittest.TestCase):
     def test_extract_commit_marker(self):
         """Commit markers can be parsed from Codex comments"""
         monitor = JleechanorgPRMonitor()
-        test_comment = f"@codex @coderabbitai @copilot @cursor [AI automation] Test comment\n\n{monitor.CODEX_COMMIT_MARKER_PREFIX}abc123{monitor.CODEX_COMMIT_MARKER_SUFFIX}"
+        intro_line = build_comment_intro(
+            assistant_mentions=monitor.assistant_mentions
+        )
+        test_comment = (
+            f"{intro_line} Test comment\n\n"
+            f"{monitor.CODEX_COMMIT_MARKER_PREFIX}abc123{monitor.CODEX_COMMIT_MARKER_SUFFIX}"
+        )
         marker = monitor._extract_commit_marker(test_comment)
         self.assertEqual(marker, "abc123")
 
+    def test_intro_prose_avoids_duplicate_mentions(self):
+        """Review assistants should not retain '@' prefixes in prose text."""
+
+        intro_line = build_comment_intro(
+            assistant_mentions="@codex @coderabbitai @copilot @cursor"
+        )
+        _, _, intro_body = intro_line.partition("] ")
+        self.assertIn("coderabbitai", intro_body)
+        self.assertNotIn("@coderabbitai", intro_body)
+
+    def test_intro_without_mentions_has_no_leading_space(self):
+        """Explicitly blank mention lists should not add stray whitespace."""
+
+        intro_line = build_comment_intro(assistant_mentions="")
+        self.assertTrue(intro_line.startswith("[AI automation]"))
+
     def test_detect_pending_codex_commit(self):
         """Codex bot summary comments referencing head commit trigger pending detection."""
         monitor = JleechanorgPRMonitor()

{jleechanorg_pr_automation-0.1.0.dist-info → jleechanorg_pr_automation-0.1.1.dist-info}/METADATA

@@ -1,16 +1,15 @@
 Metadata-Version: 2.4
 Name: jleechanorg-pr-automation
-Version: 0.1.0
+Version: 0.1.1
 Summary: GitHub PR automation system with safety limits and actionable counting
 Author-email: jleechan <jlee@jleechan.org>
-License: MIT
+License-Expression: MIT
 Project-URL: Homepage, https://github.com/jleechanorg/worldarchitect.ai
 Project-URL: Repository, https://github.com/jleechanorg/worldarchitect.ai
 Project-URL: Issues, https://github.com/jleechanorg/worldarchitect.ai/issues
 Keywords: github,automation,pr,pull-request,monitoring
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
@@ -206,6 +205,12 @@ MIT License - see LICENSE file for details.
 
 ## Changelog
 
+### 0.1.1 (2025-10-06)
+
+- Fix daily reset of global automation limit so automation never stalls overnight
+- Track latest reset timestamp in safety data for observability
+- Expand safety manager tests to cover daily rollover behaviour
+
 ### 0.1.0 (2025-09-28)
 
 - Initial release

{jleechanorg_pr_automation-0.1.0.dist-info → jleechanorg_pr_automation-0.1.1.dist-info}/RECORD

@@ -1,23 +1,23 @@
-jleechanorg_pr_automation/__init__.py,sha256=qYUTmbETCH775SM_6ln8jX05WzAGPErD-JN7OTIzXrY,852
-jleechanorg_pr_automation/automation_safety_manager.py,sha256=La3GStljdkxsSJBklWVj8CKAx6ndCsyI_aS6tSBZGJ8,27531
+jleechanorg_pr_automation/__init__.py,sha256=3-fg5lcfMZsBZYAF9ZspC55gAVDVhj7lIkMxozQWItc,852
+jleechanorg_pr_automation/automation_safety_manager.py,sha256=0cNfrHV2VXGqIpFnVBUMjovn8zKOdM4H3_x8NVR2eLs,32247
 jleechanorg_pr_automation/automation_safety_wrapper.py,sha256=Oa88wGH7XKfOywVnDMxwL0EP_v5YHvkKaSHxTvyiR48,4059
 jleechanorg_pr_automation/automation_utils.py,sha256=MInKTLuQSPwIXga8em70JtgGED3KU_OsV3cvX-4tN-Y,11608
 jleechanorg_pr_automation/check_codex_comment.py,sha256=ccs4XjPLPnsuMiSS_pXo_u-EzNldR34PqyWTlu0U0H0,2221
 jleechanorg_pr_automation/codex_branch_updater.py,sha256=490tjJDOCm58LoRS3F7vslOINVBU4F2C__2dWYRKcFs,9135
-jleechanorg_pr_automation/codex_config.py,sha256=JOrAzVwdDac9gHdLFSYDco0fJ13pdOQT22kAiMYRHhg,2101
-jleechanorg_pr_automation/jleechanorg_pr_monitor.py,sha256=6WDl0zwbJJKrRrHLZQ87J-680FC2DbLCZJ4Q2Cn62dU,48700
+jleechanorg_pr_automation/codex_config.py,sha256=WFWh-jXEXIkrbtr4QsMiBnyD4cG3nERbRx0QGOaB0nw,4229
+jleechanorg_pr_automation/jleechanorg_pr_monitor.py,sha256=RB8l2racnmzYPkEJuzu_4UPis1l7ewA6NvUKnGPSa_4,48824
 jleechanorg_pr_automation/utils.py,sha256=nhPyR7_wm2Bh-D2aE6ueqWVWLelzzXz_BCwkdC920ig,8168
 jleechanorg_pr_automation/tests/conftest.py,sha256=GVE-RLmzVM9yBNVgfZOHu39onmZPMPjN_vrIsmcWlvU,388
 jleechanorg_pr_automation/tests/test_actionable_counting_matrix.py,sha256=rQxFH6ontV3GpZigFRiHCXRkX0mEnespJv73L1DfPw0,12174
-jleechanorg_pr_automation/tests/test_automation_over_running_reproduction.py,sha256=X1sIKr-ZpAp-lks0wVGnNDM4Yas1uCrgSokW6rYGm38,5759
-jleechanorg_pr_automation/tests/test_automation_safety_limits.py,sha256=xFQIxLsXlP0VLnZRueFEUYOFhX1d9fxXXJf_1EzBY2Q,13340
-jleechanorg_pr_automation/tests/test_automation_safety_manager_comprehensive.py,sha256=CLyWuhl3TQrMKDoLxUikpuMtSotm6FZZZXT_WPBCI_w,22740
+jleechanorg_pr_automation/tests/test_automation_over_running_reproduction.py,sha256=UP8DqJ5bn525Cx3TdpIApb7ts9Fi0GSJfubI3xyB21U,6230
+jleechanorg_pr_automation/tests/test_automation_safety_limits.py,sha256=IUOs0VgX9EhGKOJ1Tz2tVQjwGn8jp_IKtLaILV6NRiQ,18678
+jleechanorg_pr_automation/tests/test_automation_safety_manager_comprehensive.py,sha256=6mUp4uDesecqYr9sjU4m2oZXTUUzxo3LSFNbXrOxNuY,24619
 jleechanorg_pr_automation/tests/test_codex_actor_matching.py,sha256=rY6AGM1DatKrYwGIryM36zYLBBK--ydOwJwkH2T7uRk,5252
 jleechanorg_pr_automation/tests/test_graphql_error_handling.py,sha256=Fv0BWLSF-eQ4n5gHwf_JSc42Y0RizrjPPlCB4THLzaI,6401
-jleechanorg_pr_automation/tests/test_pr_filtering_matrix.py,sha256=IBRn9APpNBSpedsvmKVb26ZRrHHj0EzE4F5AvCH9mP8,21415
-jleechanorg_pr_automation/tests/test_pr_targeting.py,sha256=YXyWUGQj2LzUDyZ1NU57SoRXtNcUCuRNMtgCcqrcoGU,3798
-jleechanorg_pr_automation-0.1.0.dist-info/METADATA,sha256=IUHkLXylUcpFalTqBYu82Rk35s1XmHYTSB-0_lHWUOQ,6333
-jleechanorg_pr_automation-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-jleechanorg_pr_automation-0.1.0.dist-info/entry_points.txt,sha256=QD8UUHJ4H09_beMvHzZ5SOy5cRbthvD11mXLzaWjwrg,178
-jleechanorg_pr_automation-0.1.0.dist-info/top_level.txt,sha256=1DJKrq0Be2B5_NL5jTICV1rvnqaMXFmyJpuOTUatcig,26
-jleechanorg_pr_automation-0.1.0.dist-info/RECORD,,
+jleechanorg_pr_automation/tests/test_pr_filtering_matrix.py,sha256=PC87Vp4dp_TcHPzTIyJpckFK3Zjc10JbLdBMIhxN4II,21453
+jleechanorg_pr_automation/tests/test_pr_targeting.py,sha256=RN8-3SsiCp7ARvK0x8qKLwrIj3YqjFHSh5QliXH5JoM,4671
+jleechanorg_pr_automation-0.1.1.dist-info/METADATA,sha256=g-_YGo6-iKIc02V9zKrJbU40aM3jN9vrPbBncYERwsY,6528
+jleechanorg_pr_automation-0.1.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+jleechanorg_pr_automation-0.1.1.dist-info/entry_points.txt,sha256=QD8UUHJ4H09_beMvHzZ5SOy5cRbthvD11mXLzaWjwrg,178
+jleechanorg_pr_automation-0.1.1.dist-info/top_level.txt,sha256=1DJKrq0Be2B5_NL5jTICV1rvnqaMXFmyJpuOTUatcig,26
+jleechanorg_pr_automation-0.1.1.dist-info/RECORD,,