diff --git a/org-tools/triage/README.md b/org-tools/triage/README.md
index 790a967..75f4ad1 100644
--- a/org-tools/triage/README.md
+++ b/org-tools/triage/README.md
@@ -1,6 +1,6 @@
 # Central PR Triage Tool
 
-This tool automatically applies the `status:needs-triage` label to eligible Pull Requests (PRs) across multiple repositories in your organization. It is designed to run centrally as a cron job.
+This tool automatically applies the `status:needs-triage` label to eligible Pull Requests (PRs) and marks blocked PRs as `status:stale` if they have been blocked for more than 30 days. It is designed to run centrally as a cron job.
 
 ---
 
@@ -15,11 +15,16 @@ The tool consists of a CLI entry point ([triage_cli.py](scripts/triage_cli.py))
     - **Single PR Mode**: If `--pr` is specified, the tool fetches the specific PR from the target `--repos` (which must contain exactly one repository) and triages it.
     - **Bulk Mode**: If `--pr` is not specified, the tool enters bulk triage mode.
 3.  **Upfront Access Pre-Check (Bulk Mode)**: Iterates through the list of `--repos` and verifies API access for each. If any repository is inaccessible (e.g., 404 or 403), the run is aborted immediately.
-4.  **Candidate PR Query (Bulk Mode)**: Queries the GitHub Search API for open, non-draft PRs in the target repositories that do not have `status:needs-triage` or skip labels (`status:backlog`/`status:stale`/`status:under-review`).
+4.  **Candidate PR Query (Bulk Mode)**: Queries the GitHub Search API for:
+    - Open, non-draft PRs in the target repositories with no labels.
+    - Open, non-draft PRs with `status:blocked` label.
+    - Open, non-draft PRs with `status:under-review` label.
+    - Open, non-draft PRs with `status:stale` label.
+    - Open, non-draft PRs with `status:stale-review` label.
 5.  **Core Triage Loop**: For each candidate PR, the tool:
     - Fetches its live state from the GitHub API.
     - Evaluates the PR against the **Core Triage Rules**.
-    - Applies the `status:needs-triage` label if eligible (or logs the would-be action if running in dry-run mode).
+    - Applies or removes status labels (e.g., `status:needs-triage`, `status:stale`, `status:stale-review`, `status:under-review`) if eligible based on the triage and recovery rules (or logs the would-be action if running in dry-run mode).
 
 ### Key Features
 
@@ -31,18 +36,65 @@ The tool consists of a CLI entry point ([triage_cli.py](scripts/triage_cli.py))
 
 ## Core Triage Rules
 
-When evaluating a PR (either in bulk or single-PR mode), the tool fetches the live state of the PR from GitHub and applies the following rules:
+When evaluating a PR (either in bulk or single-PR mode), the tool applies the following rules:
 
-| PR State   | Has Target Label (`status:needs-triage`) | Has Skip Label (`status:backlog`/`status:stale`/`status:under-review`) |  Action   | Log Message / Reason                                              |
-| :--------- | :--------------------------------------: | :--------------------------------------------------------------------: | :-------: | :---------------------------------------------------------------- |
-| **Closed** |                   Any                    |                                  Any                                   | **Skip**  | `Skipping: PR #<num> is closed (not open).`                       |
-| **Draft**  |                   Any                    |                                  Any                                   | **Skip**  | `Skipping: PR #<num> is a draft.`                                 |
-| **Open**   |                   Yes                    |                                  Any                                   | **Skip**  | `Skipping: PR #<num> already has 'status:needs-triage' label.`    |
-| **Open**   |                    No                    |                                  Yes                                   | **Skip**  | `Skipping: PR #<num> has skip label '<label>'.`                   |
-| **Open**   |                    No                    |                                   No                                   | **Label** | `Success: PR #<num> needs triage. Applied 'status:needs-triage'.` |
+### Status Label Mutual Exclusivity
+
+All `status:*` labels are mutually exclusive. When the tool applies a new status label, it will automatically remove any other existing status labels from the PR.
+
+Status labels include:
+
+- `status:needs-triage`
+- `status:blocked`
+- `status:stale`
+- `status:under-review`
+- `status:stale-review`
+
+### Initial Triage (`status:needs-triage`)
+
+| PR Condition                        |           Action            |
+| :---------------------------------- | :-------------------------: |
+| Open, not draft, and **no labels**  | Apply `status:needs-triage` |
+| Closed, draft, or has **any label** |            Skip             |
+
+### Blocked PRs (`status:stale`)
+
+When a PR has the `status:blocked` label, the tool checks if there has been any activity (comments or reviews) recently:
+
+| PR Condition                                                                        |        Action        |
+| :---------------------------------------------------------------------------------- | :------------------: |
+| Open, has `status:blocked`, lacks `status:stale`, and no activity for **> 30 days** | Apply `status:stale` |
+| Otherwise                                                                           |         Skip         |
+
+### Stale Blocked Recovery
+
+If a PR has the `status:stale` label and new **author activity** (commits or comments) is detected, the tool will apply `status:under-review` (which automatically removes `status:stale` due to mutual exclusivity):
+
+| PR Condition                                      |           Action            |
+| :------------------------------------------------ | :-------------------------: |
+| Open, has `status:stale`, and new author activity | Apply `status:under-review` |
+| Otherwise                                         |            Skip             |
+
+### Stale Reviews (`status:stale-review`)
+
+When a PR has the `status:under-review` label, the tool checks if there has been any activity (comments or reviews) recently:
+
+| PR Condition                                                                                    |           Action            |
+| :---------------------------------------------------------------------------------------------- | :-------------------------: |
+| Open, has `status:under-review`, lacks `status:stale-review`, and no activity for **> 21 days** | Apply `status:stale-review` |
+| Otherwise                                                                                       |            Skip             |
+
+### Stale Review Recovery
+
+If a PR has the `status:stale-review` label and new **reviewer activity** (reviews or comments by a member of the GitHub organization, excluding the PR author) is detected, the tool will apply `status:under-review` (which automatically removes `status:stale-review` due to mutual exclusivity):
+
+| PR Condition                                               |           Action            |
+| :--------------------------------------------------------- | :-------------------------: |
+| Open, has `status:stale-review`, and new reviewer activity | Apply `status:under-review` |
+| Otherwise                                                  |            Skip             |
 
 > [!IMPORTANT]
-> Since the triage tool does not automatically skip PRs with active reviewers or reviews, the `status:under-review` skip label is the primary way to signal that a PR is currently being reviewed and should not be marked as needing triage.
+> Since the triage tool does not automatically skip PRs with active reviewers or reviews, applying any label (such as `status:under-review`) is the primary way to signal that a PR is currently active and should not be marked as needing triage.
 
 ---
 
@@ -60,18 +112,21 @@ Verifying access to all repositories...
 Access verification successful. Starting triage...
 
 Processing Repository: my-org/repo-a
-  Search Query: is:pr is:open -is:draft -label:status:needs-triage -label:status:stale -label:status:backlog -label:status:under-review repo:my-org/repo-a
-  Found 2 PRs needing triage (from search index).
-  Processing PR #145: refactor: update dependencies
-    [DRY RUN] Success: PR #145 needs triage. Would apply 'status:needs-triage'.
-  Processing PR #142: docs: fix typo in README
-    Skipping: PR #142 has skip label 'status:backlog'.
+  Search Query (Needs Triage): is:pr is:open -is:draft no:label repo:my-org/repo-a
+  Search Query (Blocked): is:pr is:open -is:draft label:"status:blocked" repo:my-org/repo-a
+  Found 2 PRs needing initial triage.
+  Found 0 blocked PRs to check.
+  Total unique PRs to process: 2
+  Processing PR #145
+    [DRY RUN] Success: PR #145. Would apply 'status:needs-triage'.
+  Processing PR #142
+    Skipping: PR #142 has other labels: {'status:backlog'}
 
 === PR Triage Completed Successfully ===
 ```
 
 > [!NOTE]
-> Due to the eventual consistency of the GitHub Search index, PRs that were recently labeled with a skip label (e.g., `status:under-review`) might still temporarily appear in the search results. The tool's core triage loop performs an in-memory check using the live PR state to safely skip these cases.
+> Due to the eventual consistency of the GitHub Search index, PRs that were recently labeled might still temporarily appear in the search results for unlabeled PRs. The tool's core triage loop performs an in-memory check using the live PR state to safely skip these cases.
 
 ### Scenario 2: Pre-Check Verification Failure (Aborted Run)
 
@@ -94,12 +149,15 @@ Verifying access to all repositories...
 Access verification successful. Starting triage...
 
 Processing Repository: my-org/repo-a
-  Search Query: is:pr is:open -is:draft -label:status:needs-triage -label:status:stale -label:status:backlog repo:my-org/repo-a
-  Found 2 PRs needing triage (from search index).
-  Processing PR #145: refactor: update dependencies
-    [DRY RUN] Success: PR #145 needs triage. Would apply 'status:needs-triage'.
-  Processing PR #142: docs: fix typo in README
-    Error fetching or parsing PR #142 in my-org/repo-a: GithubException (status 500, ...)
+  Search Query (Needs Triage): is:pr is:open -is:draft no:label repo:my-org/repo-a
+  Search Query (Blocked): is:pr is:open -is:draft label:"status:blocked" repo:my-org/repo-a
+  Found 2 PRs needing initial triage.
+  Found 0 blocked PRs to check.
+  Total unique PRs to process: 2
+  Processing PR #145
+    [DRY RUN] Success: PR #145. Would apply 'status:needs-triage'.
+  Processing PR #142
+    Error processing PR #142 in my-org/repo-a: GithubException (status 500, ...)
 
 === PR Triage Completed Successfully ===
 ```
diff --git a/org-tools/triage/scripts/triage_logic.py b/org-tools/triage/scripts/triage_logic.py
index 9d912a7..2fb3d0e 100644
--- a/org-tools/triage/scripts/triage_logic.py
+++ b/org-tools/triage/scripts/triage_logic.py
@@ -21,13 +21,20 @@
 import logging
 import os
 import sys
+from datetime import datetime, timezone
 import github
 
 
 # Configure logging
 logger = logging.getLogger("triage")
 
-TARGET_LABEL = "status:needs-triage"
+NEEDS_TRIAGE_LABEL = "status:needs-triage"
+BLOCKED_LABEL = "status:blocked"
+STALE_LABEL = "status:stale"
+UNDER_REVIEW_LABEL = "status:under-review"
+STALE_REVIEW_LABEL = "status:stale-review"
+BLOCKED_STALE_THRESHOLD_DAYS = 30
+STALE_REVIEW_THRESHOLD_DAYS = 21
 
 
 def log_error(message: str, *args) -> None:
@@ -69,34 +76,102 @@ def __init__(
         self.client = client
         self.repo = repo
         self.dry_run = dry_run
+        self._org = None
+        self._is_org_checked = False
+        self._member_cache = {}
 
     def triage_all_outstanding(self) -> None:
         """Triages the repository using the Search API.
 
-        Finds open, non-draft PRs lacking target/skip labels, and applies the
-        label.
+        Finds open, non-draft PRs needing triage or blocked for too long,
+        and applies appropriate labels.
 
         Raises:
             RuntimeError: If the Search API fails.
         """
         logger.info("\nProcessing Repository: %s", self.repo.full_name)
 
-        # Construct query to find PRs with no labels.
-        query = f"is:pr is:open -is:draft no:label repo:{self.repo.full_name}"
-        logger.info("  Search Query: %s", query)
+        query_needs_triage = (
+            f"is:pr is:open -is:draft no:label repo:{self.repo.full_name}"
+        )
+        query_blocked = f'is:pr is:open -is:draft label:"{BLOCKED_LABEL}" repo:{self.repo.full_name}'
+        query_under_review = f'is:pr is:open -is:draft label:"{UNDER_REVIEW_LABEL}" repo:{self.repo.full_name}'
+        query_stale = (
+            f'is:pr is:open -is:draft label:"{STALE_LABEL}" repo:{self.repo.full_name}'
+        )
+        query_stale_review = f'is:pr is:open -is:draft label:"{STALE_REVIEW_LABEL}" repo:{self.repo.full_name}'
+
+        logger.info("  Search Query (Needs Triage): %s", query_needs_triage)
+        logger.info("  Search Query (Blocked): %s", query_blocked)
+        logger.info("  Search Query (Under Review): %s", query_under_review)
+        logger.info("  Search Query (Stale): %s", query_stale)
+        logger.info("  Search Query (Stale Review): %s", query_stale_review)
+
+        pr_numbers = set()
+
+        try:
+            prs_needs_triage = self.client.search_issues(query_needs_triage)
+            logger.info(
+                "  Found %s PRs needing initial triage.", prs_needs_triage.totalCount
+            )
+            for pr in prs_needs_triage:
+                pr_numbers.add(pr.number)
+        except Exception as e:
+            raise RuntimeError(
+                f"Failed to search PRs needing triage for {self.repo.full_name}: {e}"
+            )
+
+        try:
+            prs_blocked = self.client.search_issues(query_blocked)
+            logger.info("  Found %s blocked PRs to check.", prs_blocked.totalCount)
+            for pr in prs_blocked:
+                pr_numbers.add(pr.number)
+        except Exception as e:
+            raise RuntimeError(
+                f"Failed to search blocked PRs for {self.repo.full_name}: {e}"
+            )
 
         try:
-            prs = self.client.search_issues(query, sort="created", order="desc")
-            count = prs.totalCount
-            logger.info("  Found %s PRs needing triage (from search index).", count)
+            prs_under_review = self.client.search_issues(query_under_review)
+            logger.info(
+                "  Found %s PRs under review to check.", prs_under_review.totalCount
+            )
+            for pr in prs_under_review:
+                pr_numbers.add(pr.number)
         except Exception as e:
-            raise RuntimeError(f"Failed to search PRs for {self.repo.full_name}: {e}")
+            raise RuntimeError(
+                f"Failed to search PRs under review for {self.repo.full_name}: {e}"
+            )
 
-        for pr in prs:
-            logger.info("  Processing PR #%s: %s", pr.number, pr.title)
+        try:
+            prs_stale = self.client.search_issues(query_stale)
+            logger.info("  Found %s stale PRs to check.", prs_stale.totalCount)
+            for pr in prs_stale:
+                pr_numbers.add(pr.number)
+        except Exception as e:
+            raise RuntimeError(
+                f"Failed to search stale PRs for {self.repo.full_name}: {e}"
+            )
+
+        try:
+            prs_stale_review = self.client.search_issues(query_stale_review)
+            logger.info(
+                "  Found %s stale review PRs to check.", prs_stale_review.totalCount
+            )
+            for pr in prs_stale_review:
+                pr_numbers.add(pr.number)
+        except Exception as e:
+            raise RuntimeError(
+                f"Failed to search stale review PRs for {self.repo.full_name}: {e}"
+            )
+
+        logger.info("  Total unique PRs to process: %s", len(pr_numbers))
+
+        for pr_num in sorted(pr_numbers, reverse=True):
+            logger.info("  Processing PR #%s", pr_num)
             try:
                 # Fetch fresh PullRequest object to perform in-memory checks
-                pull = self.repo.get_pull(pr.number)
+                pull = self.repo.get_pull(pr_num)
                 self._triage_pull(pull)
             except Exception as e:
                 # We log the error and continue to process other PRs. This prevents a single
@@ -104,7 +179,7 @@ def triage_all_outstanding(self) -> None:
                 # from blocking the entire run.
                 log_error(
                     "Error processing PR #%s in %s: %s",
-                    pr.number,
+                    pr_num,
                     self.repo.full_name,
                     e,
                 )
@@ -130,9 +205,163 @@ def triage(self, pr_num: int) -> None:
         self._triage_pull(pull)
 
     def _triage_pull(self, pull: github.PullRequest.PullRequest) -> None:
-        """Evaluates rules and applies the label to a single PR if eligible."""
+        """Evaluates rules and applies labels to a single PR."""
+        self._triage_needs_triage(pull)
+        self._triage_blocked_stale(pull)
+        self._triage_stale_review(pull)
+        self._triage_stale_recovery(pull)
+        self._triage_stale_review_recovery(pull)
+
+    def _triage_needs_triage(self, pull: github.PullRequest.PullRequest) -> None:
+        """Checks and applies 'status:needs-triage' if eligible."""
         if self._is_eligible_for_triage(pull):
-            self._apply_label(pull)
+            self._apply_label(pull, NEEDS_TRIAGE_LABEL)
+
+    def _triage_blocked_stale(self, pull: github.PullRequest.PullRequest) -> None:
+        """Checks and applies 'status:stale' if PR is blocked for > 30 days."""
+        if self._is_eligible_for_blocked_stale(pull):
+            self._apply_label(pull, STALE_LABEL)
+
+    def _triage_stale_review(self, pull: github.PullRequest.PullRequest) -> None:
+        """Checks and applies 'status:stale-review' if PR is under review with no activity for > 21 days."""
+        if self._is_eligible_for_stale_review(pull):
+            self._apply_label(pull, STALE_REVIEW_LABEL)
+
+    def _is_eligible_for_blocked_stale(
+        self, pull: github.PullRequest.PullRequest
+    ) -> bool:
+        """Checks if a PR is eligible for being marked stale due to being blocked."""
+        return self._is_eligible_for_stale_by_label(
+            pull, BLOCKED_LABEL, STALE_LABEL, BLOCKED_STALE_THRESHOLD_DAYS
+        )
+
+    def _is_eligible_for_stale_review(
+        self, pull: github.PullRequest.PullRequest
+    ) -> bool:
+        """Checks if a PR is eligible for being marked stale-review."""
+        return self._is_eligible_for_stale_by_label(
+            pull, UNDER_REVIEW_LABEL, STALE_REVIEW_LABEL, STALE_REVIEW_THRESHOLD_DAYS
+        )
+
+    def _is_eligible_for_stale_by_label(
+        self,
+        pull: github.PullRequest.PullRequest,
+        target_label: str,
+        stale_label: str,
+        threshold_days: int,
+    ) -> bool:
+        """Helper to check if a PR is stale based on a label and inactivity."""
+        if pull.state != "open":
+            return False
+        if pull.draft:
+            return False
+
+        labels = {label.name for label in pull.labels}
+        if target_label not in labels:
+            return False
+
+        if stale_label in labels:
+            logger.info(
+                "Skipping: PR #%s already has '%s' label.", pull.number, stale_label
+            )
+            return False
+
+        label_applied_time = self._get_label_applied_time(pull, target_label)
+        if not label_applied_time:
+            logger.warning(
+                "Could not find when '%s' was applied to PR #%s",
+                target_label,
+                pull.number,
+            )
+            return False
+
+        latest_activity = self._get_latest_activity_time_after(pull, label_applied_time)
+        baseline_time = latest_activity if latest_activity else label_applied_time
+
+        now = datetime.now(timezone.utc)
+        duration = now - baseline_time
+        duration_days = duration.total_seconds() / (24 * 3600)
+
+        logger.info(
+            "  PR #%s has been %s with no activity for %.2f days (threshold: %s days).",
+            pull.number,
+            target_label.split(":")[-1],
+            duration_days,
+            threshold_days,
+        )
+
+        return duration_days > threshold_days
+
+    def _get_label_applied_time(
+        self, pull: github.PullRequest.PullRequest, label_name: str
+    ) -> datetime | None:
+        """Returns the latest time a label was applied to a PR, or None."""
+        try:
+            events = pull.get_issue_events()
+            latest_labeled_time = None
+            for event in events:
+                if (
+                    event.event == "labeled"
+                    and event.label
+                    and event.label.name == label_name
+                ):
+                    latest_labeled_time = event.created_at
+
+            if latest_labeled_time:
+                if latest_labeled_time.tzinfo is None:
+                    latest_labeled_time = latest_labeled_time.replace(
+                        tzinfo=timezone.utc
+                    )
+                return latest_labeled_time
+        except Exception as e:
+            log_error(
+                "Error getting label application time for PR #%s in %s: %s",
+                pull.number,
+                self.repo.full_name,
+                e,
+            )
+        return None
+
+    def _get_latest_activity_time_after(
+        self, pull: github.PullRequest.PullRequest, threshold_time: datetime
+    ) -> datetime | None:
+        """Returns the latest activity (comments/reviews) time after the threshold_time, or None."""
+        latest_time = None
+
+        def update_latest(activity_time):
+            nonlocal latest_time
+            if activity_time:
+                if activity_time.tzinfo is None:
+                    activity_time = activity_time.replace(tzinfo=timezone.utc)
+                if activity_time > threshold_time:
+                    if latest_time is None or activity_time > latest_time:
+                        latest_time = activity_time
+
+        try:
+            # 1. Issue comments (main thread)
+            comments = pull.get_issue_comments()
+            for comment in comments:
+                update_latest(comment.created_at)
+
+            # 2. Review comments (inline)
+            review_comments = pull.get_review_comments(since=threshold_time)
+            for comment in review_comments:
+                update_latest(comment.created_at)
+
+            # 3. Reviews
+            reviews = pull.get_reviews()
+            for review in reviews:
+                update_latest(review.submitted_at)
+
+        except Exception as e:
+            log_error(
+                "Error getting latest activity for PR #%s in %s: %s",
+                pull.number,
+                self.repo.full_name,
+                e,
+            )
+
+        return latest_time
 
     def _is_eligible_for_triage(self, pull: github.PullRequest.PullRequest) -> bool:
         """Performs in-memory checks to determine if a PR is eligible for triage.
@@ -148,9 +377,11 @@ def _is_eligible_for_triage(self, pull: github.PullRequest.PullRequest) -> bool:
             return False
 
         labels = {label.name for label in pull.labels}
-        if TARGET_LABEL in labels:
+        if NEEDS_TRIAGE_LABEL in labels:
             logger.info(
-                "Skipping: PR #%s already has '%s' label.", pull.number, TARGET_LABEL
+                "Skipping: PR #%s already has '%s' label.",
+                pull.number,
+                NEEDS_TRIAGE_LABEL,
             )
             return False
 
@@ -160,28 +391,318 @@ def _is_eligible_for_triage(self, pull: github.PullRequest.PullRequest) -> bool:
 
         return True
 
+    def _triage_stale_recovery(self, pull: github.PullRequest.PullRequest) -> None:
+        """Checks if a 'status:stale' PR has new author activity and restores 'status:under-review'."""
+        if self._is_eligible_for_stale_recovery(pull):
+            self._apply_label(pull, UNDER_REVIEW_LABEL)
+
+    def _is_eligible_for_stale_recovery(
+        self, pull: github.PullRequest.PullRequest
+    ) -> bool:
+        """Checks if a 'status:stale' PR has new author activity."""
+        if pull.state != "open":
+            return False
+        if pull.draft:
+            return False
+
+        labels = {label.name for label in pull.labels}
+        if STALE_LABEL not in labels:
+            return False
+
+        label_applied_time = self._get_label_applied_time(pull, STALE_LABEL)
+        if not label_applied_time:
+            return False
+
+        author = pull.user
+        if not author:
+            return False
+
+        # 1. Check comments by author
+        try:
+            comments = pull.get_issue_comments()
+            for comment in comments:
+                if comment.user and comment.user.login == author.login:
+                    comment_time = comment.created_at
+                    if comment_time.tzinfo is None:
+                        comment_time = comment_time.replace(tzinfo=timezone.utc)
+                    if comment_time > label_applied_time:
+                        logger.info(
+                            "  PR #%s has author comment activity (by %s) at %s (stale applied: %s).",
+                            pull.number,
+                            author.login,
+                            comment_time,
+                            label_applied_time,
+                        )
+                        return True
+        except Exception as e:
+            log_error(
+                "Error checking issue comments for stale recovery on PR #%s: %s",
+                pull.number,
+                e,
+            )
+
+        try:
+            review_comments = pull.get_review_comments(since=label_applied_time)
+            for comment in review_comments:
+                if comment.user and comment.user.login == author.login:
+                    comment_time = comment.created_at
+                    if comment_time.tzinfo is None:
+                        comment_time = comment_time.replace(tzinfo=timezone.utc)
+                    if comment_time > label_applied_time:
+                        logger.info(
+                            "  PR #%s has author review comment activity (by %s) at %s (stale applied: %s).",
+                            pull.number,
+                            author.login,
+                            comment_time,
+                            label_applied_time,
+                        )
+                        return True
+        except Exception as e:
+            log_error(
+                "Error checking review comments for stale recovery on PR #%s: %s",
+                pull.number,
+                e,
+            )
+
+        # 2. Check commits by author
+        try:
+            commits = pull.get_commits()
+            for commit in commits:
+                commit_author = commit.author
+                if commit_author and commit_author.login == author.login:
+                    # Use committer date to capture rebases/amends
+                    commit_time = commit.commit.committer.date
+                    if commit_time.tzinfo is None:
+                        commit_time = commit_time.replace(tzinfo=timezone.utc)
+                    if commit_time > label_applied_time:
+                        logger.info(
+                            "  PR #%s has author commit activity (by %s, sha: %s) at %s (stale applied: %s).",
+                            pull.number,
+                            author.login,
+                            commit.sha[:7],
+                            commit_time,
+                            label_applied_time,
+                        )
+                        return True
+        except Exception as e:
+            log_error(
+                "Error checking commits for stale recovery on PR #%s: %s",
+                pull.number,
+                e,
+            )
+
+        return False
+
+    def _triage_stale_review_recovery(
+        self, pull: github.PullRequest.PullRequest
+    ) -> None:
+        """Checks if a 'status:stale-review' PR has new reviewer activity and restores 'status:under-review'."""
+        if self._is_eligible_for_stale_review_recovery(pull):
+            self._apply_label(pull, UNDER_REVIEW_LABEL)
+
+    def _is_eligible_for_stale_review_recovery(
+        self, pull: github.PullRequest.PullRequest
+    ) -> bool:
+        """Checks if a 'status:stale-review' PR has new reviewer activity."""
+        if pull.state != "open":
+            return False
+        if pull.draft:
+            return False
+
+        labels = {label.name for label in pull.labels}
+        if STALE_REVIEW_LABEL not in labels:
+            return False
+
+        label_applied_time = self._get_label_applied_time(pull, STALE_REVIEW_LABEL)
+        if not label_applied_time:
+            return False
+
+        author = pull.user
+        if not author:
+            return False
+
+        # 1. Check comments by non-author org members
+        try:
+            comments = pull.get_issue_comments()
+            for comment in comments:
+                if (
+                    comment.user
+                    and comment.user.login != author.login
+                    and self._is_member(comment.user)
+                ):
+                    comment_time = comment.created_at
+                    if comment_time.tzinfo is None:
+                        comment_time = comment_time.replace(tzinfo=timezone.utc)
+                    if comment_time > label_applied_time:
+                        logger.info(
+                            "  PR #%s has reviewer comment activity (by %s) at %s (stale-review applied: %s).",
+                            pull.number,
+                            comment.user.login,
+                            comment_time,
+                            label_applied_time,
+                        )
+                        return True
+        except Exception as e:
+            log_error(
+                "Error checking issue comments for stale-review recovery on PR #%s: %s",
+                pull.number,
+                e,
+            )
+
+        try:
+            review_comments = pull.get_review_comments(since=label_applied_time)
+            for comment in review_comments:
+                if (
+                    comment.user
+                    and comment.user.login != author.login
+                    and self._is_member(comment.user)
+                ):
+                    comment_time = comment.created_at
+                    if comment_time.tzinfo is None:
+                        comment_time = comment_time.replace(tzinfo=timezone.utc)
+                    if comment_time > label_applied_time:
+                        logger.info(
+                            "  PR #%s has reviewer review comment activity (by %s) at %s (stale-review applied: %s).",
+                            pull.number,
+                            comment.user.login,
+                            comment_time,
+                            label_applied_time,
+                        )
+                        return True
+        except Exception as e:
+            log_error(
+                "Error checking review comments for stale-review recovery on PR #%s: %s",
+                pull.number,
+                e,
+            )
+
+        # 2. Check reviews by non-author org members
+        try:
+            reviews = pull.get_reviews()
+            for review in reviews:
+                if (
+                    review.user
+                    and review.user.login != author.login
+                    and self._is_member(review.user)
+                ):
+                    review_time = review.submitted_at
+                    if review_time:
+                        if review_time.tzinfo is None:
+                            review_time = review_time.replace(tzinfo=timezone.utc)
+                        if review_time > label_applied_time:
+                            logger.info(
+                                "  PR #%s has reviewer review activity (by %s, state: %s) at %s (stale-review applied: %s).",
+                                pull.number,
+                                review.user.login,
+                                review.state,
+                                review_time,
+                                label_applied_time,
+                            )
+                            return True
+        except Exception as e:
+            log_error(
+                "Error checking reviews for stale-review recovery on PR #%s: %s",
+                pull.number,
+                e,
+            )
+
+        return False
+
+    def _get_org(self) -> github.Organization.Organization | None:
+        if not self._is_org_checked:
+            if self.repo.owner.type == "Organization":
+                try:
+                    self._org = self.client.get_organization(self.repo.owner.login)
+                except Exception as e:
+                    log_error(
+                        "Error fetching organization %s: %s",
+                        self.repo.owner.login,
+                        e,
+                    )
+            self._is_org_checked = True
+        return self._org
+
+    def _is_member(self, user: github.NamedUser.NamedUser) -> bool:
+        """Checks if a user is a member of the organization (or collaborator if personal repo)."""
+        if user.login in self._member_cache:
+            return self._member_cache[user.login]
+
+        is_member = False
+        org = self._get_org()
+        if org:
+            try:
+                is_member = org.has_in_members(user)
+            except Exception as e:
+                log_error(
+                    "Error checking org membership for %s in %s: %s",
+                    user.login,
+                    org.login,
+                    e,
+                )
+        else:
+            try:
+                is_member = self.repo.has_in_collaborators(user)
+            except Exception as e:
+                log_error(
+                    "Error checking collaborator status for %s in %s: %s",
+                    user.login,
+                    self.repo.full_name,
+                    e,
+                )
+
+        self._member_cache[user.login] = is_member
+        return is_member
+
     def _apply_label(
         self,
         pull: github.PullRequest.PullRequest,
+        label_name: str,
     ) -> None:
-        """Applies the 'status:needs-triage' label to the given PR."""
+        """Applies the given label to the PR and removes other mutually exclusive status labels."""
+        STATUS_LABELS = {
+            NEEDS_TRIAGE_LABEL,
+            BLOCKED_LABEL,
+            STALE_LABEL,
+            UNDER_REVIEW_LABEL,
+            STALE_REVIEW_LABEL,
+        }
+
         try:
             if not self.dry_run:
-                pull.add_to_labels(TARGET_LABEL)
+                current_labels = {label.name for label in pull.labels}
+                for label in current_labels:
+                    if label in STATUS_LABELS and label != label_name:
+                        logger.info(
+                            "    Removing mutually exclusive label '%s' from PR #%s",
+                            label,
+                            pull.number,
+                        )
+                        pull.remove_from_labels(label)
+
+                pull.add_to_labels(label_name)
                 logger.info(
-                    "    Success: PR #%s needs triage. Applied '%s'.",
+                    "    Success: PR #%s. Applied '%s'.",
                     pull.number,
-                    TARGET_LABEL,
+                    label_name,
                 )
             else:
+                current_labels = {label.name for label in pull.labels}
+                for label in current_labels:
+                    if label in STATUS_LABELS and label != label_name:
+                        logger.info(
+                            "    [DRY RUN] Would remove mutually exclusive label '%s' from PR #%s",
+                            label,
+                            pull.number,
+                        )
                 logger.info(
-                    "    [DRY RUN] Success: PR #%s needs triage. Would apply '%s'.",
+                    "    [DRY RUN] Success: PR #%s. Would apply '%s'.",
                     pull.number,
-                    TARGET_LABEL,
+                    label_name,
                 )
         except Exception as e:
             log_error(
-                "Error applying label to PR #%s in %s: %s",
+                "Error applying label %s to PR #%s in %s: %s",
+                label_name,
                 pull.number,
                 self.repo.full_name,
                 e,
diff --git a/org-tools/triage/tests/test_triage_logic.py b/org-tools/triage/tests/test_triage_logic.py
index e260bdc..d9f19be 100644
--- a/org-tools/triage/tests/test_triage_logic.py
+++ b/org-tools/triage/tests/test_triage_logic.py
@@ -17,6 +17,7 @@
 import os
 import sys
 import unittest
+from datetime import datetime, timezone, timedelta
 from unittest.mock import MagicMock, Mock, call, patch
 from github import GithubException
 import github
@@ -170,17 +171,18 @@ def setUp(self):
         self.mock_repo.full_name = "mock-org/mock-repo"
         self.mock_issue = Mock(spec=github.PullRequest.PullRequest)
         self.mock_issue.number = 1
+        self.mock_issue.labels = []
 
     def test_apply_label_adds_label_when_dry_run_is_false(self):
         """Test that the triage label is added to the PR when dry_run is False."""
         labeler = TriageLabeler(self.mock_client, self.mock_repo, dry_run=False)
-        labeler._apply_label(self.mock_issue)
+        labeler._apply_label(self.mock_issue, "status:needs-triage")
         self.mock_issue.add_to_labels.assert_called_once_with("status:needs-triage")
 
     def test_apply_label_does_not_add_label_when_dry_run_is_true(self):
         """Test that the triage label is not added to the PR when dry_run is True."""
         labeler = TriageLabeler(self.mock_client, self.mock_repo, dry_run=True)
-        labeler._apply_label(self.mock_issue)
+        labeler._apply_label(self.mock_issue, "status:needs-triage")
         self.mock_issue.add_to_labels.assert_not_called()
 
     @patch("triage_logic.log_error")
@@ -188,15 +190,60 @@ def test_apply_label_logs_error_on_api_failure(self, mock_log_error):
         """Test that any exception during label application is caught and logged as an error."""
         labeler = TriageLabeler(self.mock_client, self.mock_repo, dry_run=False)
         self.mock_issue.add_to_labels.side_effect = Exception("API Error")
-        labeler._apply_label(self.mock_issue)
+        labeler._apply_label(self.mock_issue, "status:needs-triage")
         self.mock_issue.add_to_labels.assert_called_once()
         mock_log_error.assert_called_once_with(
-            "Error applying label to PR #%s in %s: %s",
+            "Error applying label %s to PR #%s in %s: %s",
+            "status:needs-triage",
             1,
             "mock-org/mock-repo",
             self.mock_issue.add_to_labels.side_effect,
         )
 
+    def test_apply_label_removes_other_status_labels_when_dry_run_is_false(self):
+        """Test that other mutually exclusive status labels are removed when dry_run is False."""
+        labeler = TriageLabeler(self.mock_client, self.mock_repo, dry_run=False)
+
+        mock_label_blocked = Mock()
+        mock_label_blocked.name = "status:blocked"
+        mock_label_other = Mock()
+        mock_label_other.name = "some-other-label"
+
+        self.mock_issue.labels = [mock_label_blocked, mock_label_other]
+
+        labeler._apply_label(self.mock_issue, "status:stale")
+
+        # Verify it tried to remove "status:blocked"
+        self.mock_issue.remove_from_labels.assert_called_once_with("status:blocked")
+        # Verify it added "status:stale"
+        self.mock_issue.add_to_labels.assert_called_once_with("status:stale")
+
+    def test_apply_label_does_not_remove_other_status_labels_when_dry_run_is_true(self):
+        """Test that status labels are NOT removed when dry_run is True."""
+        labeler = TriageLabeler(self.mock_client, self.mock_repo, dry_run=True)
+
+        mock_label_blocked = Mock()
+        mock_label_blocked.name = "status:blocked"
+        self.mock_issue.labels = [mock_label_blocked]
+
+        labeler._apply_label(self.mock_issue, "status:stale")
+
+        self.mock_issue.remove_from_labels.assert_not_called()
+        self.mock_issue.add_to_labels.assert_not_called()
+
+    def test_apply_label_ignores_non_status_labels(self):
+        """Test that non-status labels are not touched during label application."""
+        labeler = TriageLabeler(self.mock_client, self.mock_repo, dry_run=False)
+
+        mock_label_other = Mock()
+        mock_label_other.name = "some-other-label"
+        self.mock_issue.labels = [mock_label_other]
+
+        labeler._apply_label(self.mock_issue, "status:stale")
+
+        self.mock_issue.remove_from_labels.assert_not_called()
+        self.mock_issue.add_to_labels.assert_called_once_with("status:stale")
+
 
 class TestTriageLabelerBulkExecution(unittest.TestCase):
     """Tests for the bulk triage orchestration logic."""
@@ -273,20 +320,48 @@ def get_pull_side_effect(num):
         mock_triage_pull.assert_called_once_with(mock_pull1)
 
     def test_bulk_triage_verifies_search_query_structure(self):
-        """Test that the constructed search query contains all required filters."""
+        """Test that the constructed search queries contain all required filters."""
         self.mock_client.search_issues.return_value = MagicMock(totalCount=0)
 
         self.labeler.triage_all_outstanding()
 
-        self.mock_client.search_issues.assert_called_once()
-        called_args, _ = self.mock_client.search_issues.call_args
-        query = called_args[0]
-
-        self.assertIn("is:pr", query)
-        self.assertIn("is:open", query)
-        self.assertIn("-is:draft", query)
-        self.assertIn("no:label", query)
-        self.assertIn("repo:mock-org/mock-repo", query)
+        self.assertEqual(self.mock_client.search_issues.call_count, 5)
+        calls = self.mock_client.search_issues.call_args_list
+
+        query1 = calls[0][0][0]
+        self.assertIn("is:pr", query1)
+        self.assertIn("is:open", query1)
+        self.assertIn("-is:draft", query1)
+        self.assertIn("no:label", query1)
+        self.assertIn("repo:mock-org/mock-repo", query1)
+
+        query2 = calls[1][0][0]
+        self.assertIn("is:pr", query2)
+        self.assertIn("is:open", query2)
+        self.assertIn("-is:draft", query2)
+        self.assertIn('label:"status:blocked"', query2)
+        self.assertIn("repo:mock-org/mock-repo", query2)
+
+        query3 = calls[2][0][0]
+        self.assertIn("is:pr", query3)
+        self.assertIn("is:open", query3)
+        self.assertIn("-is:draft", query3)
+        self.assertIn('label:"status:under-review"', query3)
+        self.assertIn("repo:mock-org/mock-repo", query3)
+
+        query4 = calls[3][0][0]
+        self.assertIn("is:pr", query4)
+        self.assertIn("is:open", query4)
+        self.assertIn("-is:draft", query4)
+        self.assertIn('label:"status:stale"', query4)
+        self.assertIn("repo:mock-org/mock-repo", query4)
+
+        query5 = calls[4][0][0]
+        self.assertIn("is:pr", query5)
+        self.assertIn("is:open", query5)
+        self.assertIn("-is:draft", query5)
+        self.assertIn('label:"status:stale-review"', query5)
+        self.assertIn("repo:mock-org/mock-repo", query5)
 
     def test_bulk_triage_raises_runtime_error_on_search_failure(self):
         """Test that a failure during the Search API call raises a RuntimeError."""
@@ -294,7 +369,10 @@ def test_bulk_triage_raises_runtime_error_on_search_failure(self):
 
         with self.assertRaises(RuntimeError) as ctx:
             self.labeler.triage_all_outstanding()
-        self.assertIn("Failed to search PRs for mock-org/mock-repo", str(ctx.exception))
+        self.assertIn(
+            "Failed to search PRs needing triage for mock-org/mock-repo",
+            str(ctx.exception),
+        )
 
 
 class TestTriageLabelerSingleExecution(unittest.TestCase):
@@ -342,5 +420,808 @@ def test_single_pr_triage_raises_runtime_error_on_unexpected_error(self):
         )
 
 
+class TestTriageLabelerBlockedStaleRules(unittest.TestCase):
+    """Tests for blocked-stale eligibility rules in TriageLabeler."""
+
+    def setUp(self):
+        self.mock_client = Mock()
+        self.mock_repo = Mock()
+        self.mock_repo.full_name = "mock-org/mock-repo"
+        self.labeler = TriageLabeler(self.mock_client, self.mock_repo, dry_run=False)
+
+    def test_non_blocked_pr_should_not_be_stale(self):
+        """PR without status:blocked label should not be eligible."""
+        pr = Mock(spec=github.PullRequest.PullRequest)
+        pr.number = 1
+        pr.state = "open"
+        pr.draft = False
+        pr.labels = []
+        self.assertFalse(self.labeler._is_eligible_for_blocked_stale(pr))
+
+    def test_blocked_pr_less_than_30_days_should_not_be_stale(self):
+        """PR blocked for less than 30 days should not be eligible."""
+        pr = Mock(spec=github.PullRequest.PullRequest)
+        pr.number = 1
+        pr.state = "open"
+        pr.draft = False
+
+        mock_label = Mock()
+        mock_label.name = "status:blocked"
+        pr.labels = [mock_label]
+
+        # Mock event: labeled 29 days ago
+        event = Mock()
+        event.event = "labeled"
+        event.label.name = "status:blocked"
+        event.created_at = datetime.now(timezone.utc) - timedelta(days=29)
+        pr.get_issue_events.return_value = [event]
+
+        # Mock no activity
+        pr.get_issue_comments.return_value = []
+        pr.get_review_comments.return_value = []
+        pr.get_reviews.return_value = []
+
+        self.assertFalse(self.labeler._is_eligible_for_blocked_stale(pr))
+
+    def test_blocked_pr_more_than_30_days_should_be_stale(self):
+        """PR blocked for more than 30 days should be eligible."""
+        pr = Mock(spec=github.PullRequest.PullRequest)
+        pr.number = 1
+        pr.state = "open"
+        pr.draft = False
+
+        mock_label = Mock()
+        mock_label.name = "status:blocked"
+        pr.labels = [mock_label]
+
+        # Mock event: labeled 31 days ago
+        event = Mock()
+        event.event = "labeled"
+        event.label.name = "status:blocked"
+        event.created_at = datetime.now(timezone.utc) - timedelta(days=31)
+        pr.get_issue_events.return_value = [event]
+
+        # Mock no activity
+        pr.get_issue_comments.return_value = []
+        pr.get_review_comments.return_value = []
+        pr.get_reviews.return_value = []
+
+        self.assertTrue(self.labeler._is_eligible_for_blocked_stale(pr))
+
+    def test_blocked_pr_with_recent_activity_should_not_be_stale(self):
+        """PR with activity in the last 30 days should not be eligible, even if labeled long ago."""
+        pr = Mock(spec=github.PullRequest.PullRequest)
+        pr.number = 1
+        pr.state = "open"
+        pr.draft = False
+
+        mock_label = Mock()
+        mock_label.name = "status:blocked"
+        pr.labels = [mock_label]
+
+        # Mock event: labeled 35 days ago
+        event = Mock()
+        event.event = "labeled"
+        event.label.name = "status:blocked"
+        event.created_at = datetime.now(timezone.utc) - timedelta(days=35)
+        pr.get_issue_events.return_value = [event]
+
+        # Mock recent comment (10 days ago)
+        comment = Mock()
+        comment.created_at = datetime.now(timezone.utc) - timedelta(days=10)
+        pr.get_issue_comments.return_value = [comment]
+        pr.get_review_comments.return_value = []
+        pr.get_reviews.return_value = []
+
+        self.assertFalse(self.labeler._is_eligible_for_blocked_stale(pr))
+
+    def test_blocked_pr_with_old_activity_should_be_stale(self):
+        """PR with activity > 30 days ago should be eligible if labeled long ago."""
+        pr = Mock(spec=github.PullRequest.PullRequest)
+        pr.number = 1
+        pr.state = "open"
+        pr.draft = False
+
+        mock_label = Mock()
+        mock_label.name = "status:blocked"
+        pr.labels = [mock_label]
+
+        # Mock event: labeled 40 days ago
+        event = Mock()
+        event.event = "labeled"
+        event.label.name = "status:blocked"
+        event.created_at = datetime.now(timezone.utc) - timedelta(days=40)
+        pr.get_issue_events.return_value = [event]
+
+        # Mock old comment (35 days ago)
+        comment = Mock()
+        comment.created_at = datetime.now(timezone.utc) - timedelta(days=35)
+        pr.get_issue_comments.return_value = [comment]
+        pr.get_review_comments.return_value = []
+        pr.get_reviews.return_value = []
+
+        self.assertTrue(self.labeler._is_eligible_for_blocked_stale(pr))
+
+    def test_already_stale_blocked_pr_should_not_be_stale_again(self):
+        """PR that is already marked stale should not be eligible."""
+        pr = Mock(spec=github.PullRequest.PullRequest)
+        pr.number = 1
+        pr.state = "open"
+        pr.draft = False
+
+        mock_blocked = Mock()
+        mock_blocked.name = "status:blocked"
+        mock_stale = Mock()
+        mock_stale.name = "status:stale"
+        pr.labels = [mock_blocked, mock_stale]
+
+        self.assertFalse(self.labeler._is_eligible_for_blocked_stale(pr))
+
+    def test_closed_blocked_pr_should_not_be_stale(self):
+        """Closed PR should not be eligible."""
+        pr = Mock(spec=github.PullRequest.PullRequest)
+        pr.number = 1
+        pr.state = "closed"
+        pr.draft = False
+        mock_label = Mock()
+        mock_label.name = "status:blocked"
+        pr.labels = [mock_label]
+        self.assertFalse(self.labeler._is_eligible_for_blocked_stale(pr))
+
+    def test_draft_blocked_pr_should_not_be_stale(self):
+        """Draft PR should not be eligible."""
+        pr = Mock(spec=github.PullRequest.PullRequest)
+        pr.number = 1
+        pr.state = "open"
+        pr.draft = True
+        mock_label = Mock()
+        mock_label.name = "status:blocked"
+        pr.labels = [mock_label]
+        self.assertFalse(self.labeler._is_eligible_for_blocked_stale(pr))
+
+
+class TestTriageLabelerStaleReviewRules(unittest.TestCase):
+    """Tests for stale-review eligibility rules in TriageLabeler."""
+
+    def setUp(self):
+        self.mock_client = Mock()
+        self.mock_repo = Mock()
+        self.mock_repo.full_name = "mock-org/mock-repo"
+        self.labeler = TriageLabeler(self.mock_client, self.mock_repo, dry_run=False)
+
+    def test_non_under_review_pr_should_not_be_stale_review(self):
+        """PR without status:under-review label should not be eligible."""
+        pr = Mock(spec=github.PullRequest.PullRequest)
+        pr.number = 1
+        pr.state = "open"
+        pr.draft = False
+        pr.labels = []
+        self.assertFalse(self.labeler._is_eligible_for_stale_review(pr))
+
+    def test_under_review_pr_with_recent_label_and_no_activity_should_not_be_stale(
+        self,
+    ):
+        """PR labeled under-review recently with no activity should not be eligible."""
+        pr = Mock(spec=github.PullRequest.PullRequest)
+        pr.number = 1
+        pr.state = "open"
+        pr.draft = False
+
+        mock_label = Mock()
+        mock_label.name = "status:under-review"
+        pr.labels = [mock_label]
+
+        # Mock event: labeled 10 days ago
+        event = Mock()
+        event.event = "labeled"
+        event.label.name = "status:under-review"
+        event.created_at = datetime.now(timezone.utc) - timedelta(days=10)
+        pr.get_issue_events.return_value = [event]
+
+        # Mock no activity
+        pr.get_issue_comments.return_value = []
+        pr.get_review_comments.return_value = []
+        pr.get_reviews.return_value = []
+
+        self.assertFalse(self.labeler._is_eligible_for_stale_review(pr))
+
+    def test_under_review_pr_labeled_long_ago_with_no_activity_should_be_stale(self):
+        """PR labeled under-review > 21 days ago with no activity should be eligible."""
+        pr = Mock(spec=github.PullRequest.PullRequest)
+        pr.number = 1
+        pr.state = "open"
+        pr.draft = False
+
+        mock_label = Mock()
+        mock_label.name = "status:under-review"
+        pr.labels = [mock_label]
+
+        # Mock event: labeled 22 days ago
+        event = Mock()
+        event.event = "labeled"
+        event.label.name = "status:under-review"
+        event.created_at = datetime.now(timezone.utc) - timedelta(days=22)
+        pr.get_issue_events.return_value = [event]
+
+        # Mock no activity
+        pr.get_issue_comments.return_value = []
+        pr.get_review_comments.return_value = []
+        pr.get_reviews.return_value = []
+
+        self.assertTrue(self.labeler._is_eligible_for_stale_review(pr))
+
+    def test_under_review_pr_with_recent_activity_should_not_be_stale(self):
+        """PR with activity in the last 21 days should not be eligible, even if labeled long ago."""
+        pr = Mock(spec=github.PullRequest.PullRequest)
+        pr.number = 1
+        pr.state = "open"
+        pr.draft = False
+
+        mock_label = Mock()
+        mock_label.name = "status:under-review"
+        pr.labels = [mock_label]
+
+        # Mock event: labeled 25 days ago
+        event = Mock()
+        event.event = "labeled"
+        event.label.name = "status:under-review"
+        event.created_at = datetime.now(timezone.utc) - timedelta(days=25)
+        pr.get_issue_events.return_value = [event]
+
+        # Mock recent comment (10 days ago)
+        comment = Mock()
+        comment.created_at = datetime.now(timezone.utc) - timedelta(days=10)
+        pr.get_issue_comments.return_value = [comment]
+        pr.get_review_comments.return_value = []
+        pr.get_reviews.return_value = []
+
+        self.assertFalse(self.labeler._is_eligible_for_stale_review(pr))
+
+    def test_under_review_pr_with_old_activity_should_be_stale(self):
+        """PR with activity > 21 days ago should be eligible if labeled long ago."""
+        pr = Mock(spec=github.PullRequest.PullRequest)
+        pr.number = 1
+        pr.state = "open"
+        pr.draft = False
+
+        mock_label = Mock()
+        mock_label.name = "status:under-review"
+        pr.labels = [mock_label]
+
+        # Mock event: labeled 30 days ago
+        event = Mock()
+        event.event = "labeled"
+        event.label.name = "status:under-review"
+        event.created_at = datetime.now(timezone.utc) - timedelta(days=30)
+        pr.get_issue_events.return_value = [event]
+
+        # Mock old comment (25 days ago)
+        comment = Mock()
+        comment.created_at = datetime.now(timezone.utc) - timedelta(days=25)
+        pr.get_issue_comments.return_value = [comment]
+        pr.get_review_comments.return_value = []
+        pr.get_reviews.return_value = []
+
+        self.assertTrue(self.labeler._is_eligible_for_stale_review(pr))
+
+    def test_already_stale_review_pr_should_not_be_stale_again(self):
+        """PR that is already marked stale-review should be skipped."""
+        pr = Mock(spec=github.PullRequest.PullRequest)
+        pr.number = 1
+        pr.state = "open"
+        pr.draft = False
+
+        mock_ur = Mock()
+        mock_ur.name = "status:under-review"
+        mock_sr = Mock()
+        mock_sr.name = "status:stale-review"
+        pr.labels = [mock_ur, mock_sr]
+
+        self.assertFalse(self.labeler._is_eligible_for_stale_review(pr))
+
+
+class TestTriageLabelerStaleRecoveryRules(unittest.TestCase):
+    """Tests for stale recovery eligibility rules in TriageLabeler."""
+
+    def setUp(self):
+        self.mock_client = Mock()
+        self.mock_repo = Mock()
+        self.mock_repo.full_name = "mock-org/mock-repo"
+        self.labeler = TriageLabeler(self.mock_client, self.mock_repo, dry_run=False)
+
+    def test_non_stale_pr_should_not_be_recovered(self):
+        """PR without status:stale label should not be eligible for recovery."""
+        pr = Mock(spec=github.PullRequest.PullRequest)
+        pr.number = 1
+        pr.state = "open"
+        pr.draft = False
+        pr.labels = []
+        self.assertFalse(self.labeler._is_eligible_for_stale_recovery(pr))
+
+    def test_stale_pr_with_no_activity_should_not_be_recovered(self):
+        """PR with status:stale and no new activity should not be recovered."""
+        pr = Mock(spec=github.PullRequest.PullRequest)
+        pr.number = 1
+        pr.state = "open"
+        pr.draft = False
+
+        mock_label = Mock()
+        mock_label.name = "status:stale"
+        pr.labels = [mock_label]
+
+        # Mock event: labeled stale 5 days ago
+        event = Mock()
+        event.event = "labeled"
+        event.label.name = "status:stale"
+        event.created_at = datetime.now(timezone.utc) - timedelta(days=5)
+        pr.get_issue_events.return_value = [event]
+
+        # Mock author
+        mock_author = Mock()
+        mock_author.login = "pr-author"
+        pr.user = mock_author
+
+        # Mock no activity
+        pr.get_issue_comments.return_value = []
+        pr.get_review_comments.return_value = []
+        pr.get_commits.return_value = []
+
+        self.assertFalse(self.labeler._is_eligible_for_stale_recovery(pr))
+
+    def test_stale_pr_with_author_comment_should_be_recovered(self):
+        """PR with status:stale and a new comment by author should be recovered."""
+        pr = Mock(spec=github.PullRequest.PullRequest)
+        pr.number = 1
+        pr.state = "open"
+        pr.draft = False
+
+        mock_label = Mock()
+        mock_label.name = "status:stale"
+        pr.labels = [mock_label]
+
+        # Mock event: labeled stale 5 days ago
+        event = Mock()
+        event.event = "labeled"
+        event.label.name = "status:stale"
+        event.created_at = datetime.now(timezone.utc) - timedelta(days=5)
+        pr.get_issue_events.return_value = [event]
+
+        # Mock author
+        mock_author = Mock()
+        mock_author.login = "pr-author"
+        pr.user = mock_author
+
+        # Mock author comment (2 days ago)
+        comment = Mock()
+        comment.user.login = "pr-author"
+        comment.created_at = datetime.now(timezone.utc) - timedelta(days=2)
+        pr.get_issue_comments.return_value = [comment]
+        pr.get_review_comments.return_value = []
+        pr.get_commits.return_value = []
+
+        self.assertTrue(self.labeler._is_eligible_for_stale_recovery(pr))
+
+    def test_stale_pr_with_non_author_comment_should_not_be_recovered(self):
+        """PR with status:stale and a new comment by someone else should not be recovered."""
+        pr = Mock(spec=github.PullRequest.PullRequest)
+        pr.number = 1
+        pr.state = "open"
+        pr.draft = False
+
+        mock_label = Mock()
+        mock_label.name = "status:stale"
+        pr.labels = [mock_label]
+
+        # Mock event: labeled stale 5 days ago
+        event = Mock()
+        event.event = "labeled"
+        event.label.name = "status:stale"
+        event.created_at = datetime.now(timezone.utc) - timedelta(days=5)
+        pr.get_issue_events.return_value = [event]
+
+        # Mock author
+        mock_author = Mock()
+        mock_author.login = "pr-author"
+        pr.user = mock_author
+
+        # Mock non-author comment (2 days ago)
+        comment = Mock()
+        comment.user.login = "someone-else"
+        comment.created_at = datetime.now(timezone.utc) - timedelta(days=2)
+        pr.get_issue_comments.return_value = [comment]
+        pr.get_review_comments.return_value = []
+        pr.get_commits.return_value = []
+
+        self.assertFalse(self.labeler._is_eligible_for_stale_recovery(pr))
+
+    def test_stale_pr_with_author_commit_should_be_recovered(self):
+        """PR with status:stale and a new commit by author should be recovered."""
+        pr = Mock(spec=github.PullRequest.PullRequest)
+        pr.number = 1
+        pr.state = "open"
+        pr.draft = False
+
+        mock_label = Mock()
+        mock_label.name = "status:stale"
+        pr.labels = [mock_label]
+
+        # Mock event: labeled stale 5 days ago
+        event = Mock()
+        event.event = "labeled"
+        event.label.name = "status:stale"
+        event.created_at = datetime.now(timezone.utc) - timedelta(days=5)
+        pr.get_issue_events.return_value = [event]
+
+        # Mock author
+        mock_author = Mock()
+        mock_author.login = "pr-author"
+        pr.user = mock_author
+
+        # Mock author commit (2 days ago)
+        commit = Mock()
+        commit.sha = "1234567890"
+        commit.author.login = "pr-author"
+        commit.commit.committer.date = datetime.now(timezone.utc) - timedelta(days=2)
+        pr.get_commits.return_value = [commit]
+
+        pr.get_issue_comments.return_value = []
+        pr.get_review_comments.return_value = []
+
+        self.assertTrue(self.labeler._is_eligible_for_stale_recovery(pr))
+
+    def test_stale_pr_with_old_author_activity_should_not_be_recovered(self):
+        """PR with status:stale and activity by author BEFORE stale label should not be recovered."""
+        pr = Mock(spec=github.PullRequest.PullRequest)
+        pr.number = 1
+        pr.state = "open"
+        pr.draft = False
+
+        mock_label = Mock()
+        mock_label.name = "status:stale"
+        pr.labels = [mock_label]
+
+        # Mock event: labeled stale 5 days ago
+        event = Mock()
+        event.event = "labeled"
+        event.label.name = "status:stale"
+        event.created_at = datetime.now(timezone.utc) - timedelta(days=5)
+        pr.get_issue_events.return_value = [event]
+
+        # Mock author
+        mock_author = Mock()
+        mock_author.login = "pr-author"
+        pr.user = mock_author
+
+        # Mock old author comment (10 days ago)
+        comment = Mock()
+        comment.user.login = "pr-author"
+        comment.created_at = datetime.now(timezone.utc) - timedelta(days=10)
+        pr.get_issue_comments.return_value = [comment]
+        pr.get_review_comments.return_value = []
+        pr.get_commits.return_value = []
+
+        self.assertFalse(self.labeler._is_eligible_for_stale_recovery(pr))
+
+    def test_triage_stale_recovery_applies_under_review(self):
+        """Test that _triage_stale_recovery applies status:under-review when eligible."""
+        pr = Mock(spec=github.PullRequest.PullRequest)
+        pr.number = 1
+        pr.state = "open"
+        pr.draft = False
+
+        mock_label = Mock()
+        mock_label.name = "status:stale"
+        pr.labels = [mock_label]
+
+        # Mock event: labeled stale 5 days ago
+        event = Mock()
+        event.event = "labeled"
+        event.label.name = "status:stale"
+        event.created_at = datetime.now(timezone.utc) - timedelta(days=5)
+        pr.get_issue_events.return_value = [event]
+
+        # Mock author
+        mock_author = Mock()
+        mock_author.login = "pr-author"
+        pr.user = mock_author
+
+        # Mock author comment (2 days ago)
+        comment = Mock()
+        comment.user.login = "pr-author"
+        comment.created_at = datetime.now(timezone.utc) - timedelta(days=2)
+        pr.get_issue_comments.return_value = [comment]
+        pr.get_review_comments.return_value = []
+        pr.get_commits.return_value = []
+
+        self.labeler._triage_stale_recovery(pr)
+
+        # Should remove status:stale (via mutual exclusivity inside _apply_label)
+        pr.remove_from_labels.assert_called_once_with("status:stale")
+        # Should add status:under-review
+        pr.add_to_labels.assert_called_once_with("status:under-review")
+
+
+class TestTriageLabelerStaleReviewRecoveryRules(unittest.TestCase):
+    """Tests for stale-review recovery eligibility rules in TriageLabeler."""
+
+    def setUp(self):
+        self.mock_client = Mock()
+        self.mock_repo = Mock()
+        self.mock_repo.full_name = "mock-org/mock-repo"
+
+        # Mock repo owner as Organization
+        self.mock_repo.owner.type = "Organization"
+        self.mock_repo.owner.login = "mock-org"
+
+        # Mock organization membership
+        self.mock_org = Mock()
+        self.mock_client.get_organization.return_value = self.mock_org
+        # Default: anyone is a member in tests unless overridden
+        self.mock_org.has_in_members.return_value = True
+
+        self.labeler = TriageLabeler(self.mock_client, self.mock_repo, dry_run=False)
+
+    def test_non_stale_review_pr_should_not_be_recovered(self):
+        """PR without status:stale-review label should not be eligible for recovery."""
+        pr = Mock(spec=github.PullRequest.PullRequest)
+        pr.number = 1
+        pr.state = "open"
+        pr.draft = False
+        pr.labels = []
+        self.assertFalse(self.labeler._is_eligible_for_stale_review_recovery(pr))
+
+    def test_stale_review_pr_with_no_activity_should_not_be_recovered(self):
+        """PR with status:stale-review and no new activity should not be recovered."""
+        pr = Mock(spec=github.PullRequest.PullRequest)
+        pr.number = 1
+        pr.state = "open"
+        pr.draft = False
+
+        mock_label = Mock()
+        mock_label.name = "status:stale-review"
+        pr.labels = [mock_label]
+
+        # Mock event: labeled stale-review 5 days ago
+        event = Mock()
+        event.event = "labeled"
+        event.label.name = "status:stale-review"
+        event.created_at = datetime.now(timezone.utc) - timedelta(days=5)
+        pr.get_issue_events.return_value = [event]
+
+        # Mock author
+        mock_author = Mock()
+        mock_author.login = "pr-author"
+        pr.user = mock_author
+
+        # Mock no activity
+        pr.get_issue_comments.return_value = []
+        pr.get_review_comments.return_value = []
+        pr.get_reviews.return_value = []
+
+        self.assertFalse(self.labeler._is_eligible_for_stale_review_recovery(pr))
+
+    def test_stale_review_pr_with_reviewer_comment_should_be_recovered(self):
+        """PR with status:stale-review and a new comment by reviewer should be recovered."""
+        pr = Mock(spec=github.PullRequest.PullRequest)
+        pr.number = 1
+        pr.state = "open"
+        pr.draft = False
+
+        mock_label = Mock()
+        mock_label.name = "status:stale-review"
+        pr.labels = [mock_label]
+
+        # Mock event: labeled stale-review 5 days ago
+        event = Mock()
+        event.event = "labeled"
+        event.label.name = "status:stale-review"
+        event.created_at = datetime.now(timezone.utc) - timedelta(days=5)
+        pr.get_issue_events.return_value = [event]
+
+        # Mock author
+        mock_author = Mock()
+        mock_author.login = "pr-author"
+        pr.user = mock_author
+
+        # Mock reviewer comment (2 days ago)
+        comment = Mock()
+        comment.user.login = "reviewer-1"
+        comment.created_at = datetime.now(timezone.utc) - timedelta(days=2)
+        pr.get_issue_comments.return_value = [comment]
+        pr.get_review_comments.return_value = []
+        pr.get_reviews.return_value = []
+
+        self.assertTrue(self.labeler._is_eligible_for_stale_review_recovery(pr))
+
+    def test_stale_review_pr_with_author_comment_should_not_be_recovered(self):
+        """PR with status:stale-review and a new comment by author should not be recovered."""
+        pr = Mock(spec=github.PullRequest.PullRequest)
+        pr.number = 1
+        pr.state = "open"
+        pr.draft = False
+
+        mock_label = Mock()
+        mock_label.name = "status:stale-review"
+        pr.labels = [mock_label]
+
+        # Mock event: labeled stale-review 5 days ago
+        event = Mock()
+        event.event = "labeled"
+        event.label.name = "status:stale-review"
+        event.created_at = datetime.now(timezone.utc) - timedelta(days=5)
+        pr.get_issue_events.return_value = [event]
+
+        # Mock author
+        mock_author = Mock()
+        mock_author.login = "pr-author"
+        pr.user = mock_author
+
+        # Mock author comment (2 days ago)
+        comment = Mock()
+        comment.user.login = "pr-author"
+        comment.created_at = datetime.now(timezone.utc) - timedelta(days=2)
+        pr.get_issue_comments.return_value = [comment]
+        pr.get_review_comments.return_value = []
+        pr.get_reviews.return_value = []
+
+        self.assertFalse(self.labeler._is_eligible_for_stale_review_recovery(pr))
+
+    def test_stale_review_pr_with_reviewer_review_should_be_recovered(self):
+        """PR with status:stale-review and a new review by reviewer should be recovered."""
+        pr = Mock(spec=github.PullRequest.PullRequest)
+        pr.number = 1
+        pr.state = "open"
+        pr.draft = False
+
+        mock_label = Mock()
+        mock_label.name = "status:stale-review"
+        pr.labels = [mock_label]
+
+        # Mock event: labeled stale-review 5 days ago
+        event = Mock()
+        event.event = "labeled"
+        event.label.name = "status:stale-review"
+        event.created_at = datetime.now(timezone.utc) - timedelta(days=5)
+        pr.get_issue_events.return_value = [event]
+
+        # Mock author
+        mock_author = Mock()
+        mock_author.login = "pr-author"
+        pr.user = mock_author
+
+        # Mock reviewer review (2 days ago)
+        review = Mock()
+        review.user.login = "reviewer-1"
+        review.state = "APPROVED"
+        review.submitted_at = datetime.now(timezone.utc) - timedelta(days=2)
+        pr.get_reviews.return_value = [review]
+
+        pr.get_issue_comments.return_value = []
+        pr.get_review_comments.return_value = []
+
+        self.assertTrue(self.labeler._is_eligible_for_stale_review_recovery(pr))
+
+    def test_triage_stale_review_recovery_applies_under_review(self):
+        """Test that _triage_stale_review_recovery applies status:under-review when eligible."""
+        pr = Mock(spec=github.PullRequest.PullRequest)
+        pr.number = 1
+        pr.state = "open"
+        pr.draft = False
+
+        mock_label = Mock()
+        mock_label.name = "status:stale-review"
+        pr.labels = [mock_label]
+
+        # Mock event: labeled stale-review 5 days ago
+        event = Mock()
+        event.event = "labeled"
+        event.label.name = "status:stale-review"
+        event.created_at = datetime.now(timezone.utc) - timedelta(days=5)
+        pr.get_issue_events.return_value = [event]
+
+        # Mock author
+        mock_author = Mock()
+        mock_author.login = "pr-author"
+        pr.user = mock_author
+
+        # Mock reviewer comment (2 days ago)
+        comment = Mock()
+        comment.user.login = "reviewer-1"
+        comment.created_at = datetime.now(timezone.utc) - timedelta(days=2)
+        pr.get_issue_comments.return_value = [comment]
+        pr.get_review_comments.return_value = []
+        pr.get_reviews.return_value = []
+
+        self.labeler._triage_stale_review_recovery(pr)
+
+        # Should remove status:stale-review (via mutual exclusivity inside _apply_label)
+        pr.remove_from_labels.assert_called_once_with("status:stale-review")
+        # Should add status:under-review
+        pr.add_to_labels.assert_called_once_with("status:under-review")
+
+    def test_stale_review_pr_with_non_member_comment_should_not_be_recovered(self):
+        """PR with status:stale-review and comment by non-member should not be recovered."""
+        pr = Mock(spec=github.PullRequest.PullRequest)
+        pr.number = 1
+        pr.state = "open"
+        pr.draft = False
+
+        mock_label = Mock()
+        mock_label.name = "status:stale-review"
+        pr.labels = [mock_label]
+
+        # Mock event: labeled stale-review 5 days ago
+        event = Mock()
+        event.event = "labeled"
+        event.label.name = "status:stale-review"
+        event.created_at = datetime.now(timezone.utc) - timedelta(days=5)
+        pr.get_issue_events.return_value = [event]
+
+        # Mock author
+        mock_author = Mock()
+        mock_author.login = "pr-author"
+        pr.user = mock_author
+
+        # Mock reviewer who is NOT an org member
+        non_member = Mock()
+        non_member.login = "non-member"
+        self.mock_org.has_in_members.return_value = False
+
+        # Mock comment by non-member (2 days ago)
+        comment = Mock()
+        comment.user = non_member
+        comment.created_at = datetime.now(timezone.utc) - timedelta(days=2)
+        pr.get_issue_comments.return_value = [comment]
+        pr.get_review_comments.return_value = []
+        pr.get_reviews.return_value = []
+
+        self.assertFalse(self.labeler._is_eligible_for_stale_review_recovery(pr))
+
+    def test_stale_review_pr_personal_repo_with_collaborator_comment_should_be_recovered(
+        self,
+    ):
+        """Test recovery on personal repo when comment is by collaborator."""
+        # Re-initialize labeler with personal repo
+        personal_repo = Mock()
+        personal_repo.full_name = "user/repo"
+        personal_repo.owner.type = "User"
+        personal_repo.owner.login = "user"
+        personal_repo.has_in_collaborators.return_value = True
+
+        labeler = TriageLabeler(self.mock_client, personal_repo, dry_run=False)
+
+        pr = Mock(spec=github.PullRequest.PullRequest)
+        pr.number = 1
+        pr.state = "open"
+        pr.draft = False
+
+        mock_label = Mock()
+        mock_label.name = "status:stale-review"
+        pr.labels = [mock_label]
+
+        # Mock event: labeled stale-review 5 days ago
+        event = Mock()
+        event.event = "labeled"
+        event.label.name = "status:stale-review"
+        event.created_at = datetime.now(timezone.utc) - timedelta(days=5)
+        pr.get_issue_events.return_value = [event]
+
+        # Mock author
+        mock_author = Mock()
+        mock_author.login = "pr-author"
+        pr.user = mock_author
+
+        # Mock collaborator comment (2 days ago)
+        comment = Mock()
+        comment.user.login = "collaborator-1"
+        comment.created_at = datetime.now(timezone.utc) - timedelta(days=2)
+        pr.get_issue_comments.return_value = [comment]
+        pr.get_review_comments.return_value = []
+        pr.get_reviews.return_value = []
+
+        self.assertTrue(labeler._is_eligible_for_stale_review_recovery(pr))
+        personal_repo.has_in_collaborators.assert_called_once()
+
+
 if __name__ == "__main__":
     unittest.main()