qBitrr2 5.6.2__py3-none-any.whl → 5.7.1__py3-none-any.whl

qBitrr/arss.py

@@ -147,36 +147,36 @@ class Arr:
         self.logger = logging.getLogger(f"qBitrr.{self._name}")
         run_logs(self.logger, self._name)
 
+        # Set completed_folder path (used for category creation and file monitoring)
         if not QBIT_DISABLED:
             try:
+                # Check default instance for existing category configuration
                 categories = self.manager.qbit_manager.client.torrent_categories.categories
-                try:
-                    categ = categories[self.category]
-                    path = categ["savePath"]
-                    if path:
-                        self.logger.trace("Category exists with save path [%s]", path)
-                        self.completed_folder = pathlib.Path(path)
-                    else:
-                        self.logger.trace("Category exists without save path")
-                        self.completed_folder = pathlib.Path(COMPLETED_DOWNLOAD_FOLDER).joinpath(
-                            self.category
-                        )
-                except KeyError:
+                categ = categories.get(self.category)
+                if categ and categ.get("savePath"):
+                    self.logger.trace("Category exists with save path [%s]", categ["savePath"])
+                    self.completed_folder = pathlib.Path(categ["savePath"])
+                else:
+                    self.logger.trace("Category does not exist or lacks save path")
                     self.completed_folder = pathlib.Path(COMPLETED_DOWNLOAD_FOLDER).joinpath(
                         self.category
                     )
-                    self.manager.qbit_manager.client.torrent_categories.create_category(
-                        self.category, save_path=self.completed_folder
-                    )
             except Exception as e:
                 self.logger.warning(
-                    "Could not connect to qBittorrent during initialization for %s: %s. Will retry when process starts.",
+                    "Could not connect to qBittorrent during initialization for %s: %s. Using default path.",
                     self._name,
-                    str(e).split("\n")[0] if "\n" in str(e) else str(e),  # First line only
+                    str(e).split("\n")[0] if "\n" in str(e) else str(e),
                 )
                 self.completed_folder = pathlib.Path(COMPLETED_DOWNLOAD_FOLDER).joinpath(
                     self.category
                 )
+            # Ensure category exists on ALL instances (deferred to avoid __init__ failures)
+            try:
+                self._ensure_category_on_all_instances()
+            except Exception as e:
+                self.logger.warning(
+                    "Could not ensure category on all instances during init: %s", e
+                )
         else:
             self.completed_folder = pathlib.Path(COMPLETED_DOWNLOAD_FOLDER).joinpath(self.category)
 
@@ -365,7 +365,7 @@ class Arr:
             f"{name}.EntrySearch.Overseerr.ApprovedOnly", fallback=True
         )
         self.search_requests_every_x_seconds = CONFIG.get(
-            f"{name}.EntrySearch.SearchRequestsEvery", fallback=1800
+            f"{name}.EntrySearch.SearchRequestsEvery", fallback=300
         )
         self._temp_overseer_request_cache: dict[str, set[int | str]] = defaultdict(set)
         if self.ombi_search_requests or self.overseerr_requests:
@@ -465,10 +465,32 @@ class Arr:
                 self.keep_temp_profile,
             )
             self.temp_quality_profile_ids = self.parse_quality_profiles()
+            # Create reverse mapping (temp_id → main_id) for O(1) lookups
+            self.main_quality_profile_ids = {
+                v: k for k, v in self.temp_quality_profile_ids.items()
+            }
+            self.profile_switch_retry_attempts = CONFIG.get(
+                f"{name}.EntrySearch.ProfileSwitchRetryAttempts", fallback=3
+            )
+            self.temp_profile_timeout_minutes = CONFIG.get(
+                f"{name}.EntrySearch.TempProfileResetTimeoutMinutes", fallback=0
+            )
             self.logger.info(
                 "Parsed quality profile mappings: %s",
                 {f"{k}→{v}": f"(main→temp)" for k, v in self.temp_quality_profile_ids.items()},
             )
+            if self.temp_profile_timeout_minutes > 0:
+                self.logger.info(
+                    f"Temp profile timeout enabled: {self.temp_profile_timeout_minutes} minutes"
+                )
+
+            # Check if we should reset all temp profiles on startup
+            force_reset = CONFIG.get(f"{name}.EntrySearch.ForceResetTempProfiles", fallback=False)
+            if force_reset:
+                self.logger.info(
+                    "ForceResetTempProfiles enabled - resetting all temp profiles on startup"
+                )
+                self._reset_all_temp_profiles()
 
         # Cache for valid quality profile IDs to avoid repeated API calls and warnings
         self._quality_profile_cache: dict[int, dict] = {}
@@ -673,6 +695,57 @@ class Arr:
         )
         self.logger.hnotice("Starting %s monitor", self._name)
 
+    def _ensure_category_on_all_instances(self) -> None:
+        """
+        Ensure the Arr category exists on ALL qBittorrent instances.
+
+        Creates the category with the completed_folder save path on each instance.
+        Logs errors but continues if individual instances fail.
+        """
+        if QBIT_DISABLED:
+            return
+
+        qbit_manager = self.manager.qbit_manager
+        all_instances = qbit_manager.get_all_instances()
+
+        self.logger.debug(
+            "Ensuring category '%s' exists on %d qBit instance(s)",
+            self.category,
+            len(all_instances),
+        )
+
+        for instance_name in all_instances:
+            try:
+                client = qbit_manager.get_client(instance_name)
+                if client is None:
+                    self.logger.warning(
+                        "Skipping category creation on instance '%s' (client unavailable)",
+                        instance_name,
+                    )
+                    continue
+
+                categories = client.torrent_categories.categories
+                if self.category not in categories:
+                    client.torrent_categories.create_category(
+                        self.category, save_path=str(self.completed_folder)
+                    )
+                    self.logger.info(
+                        "Created category '%s' on instance '%s'", self.category, instance_name
+                    )
+                else:
+                    self.logger.debug(
+                        "Category '%s' already exists on instance '%s'",
+                        self.category,
+                        instance_name,
+                    )
+            except Exception as e:
+                self.logger.error(
+                    "Failed to ensure category '%s' on instance '%s': %s",
+                    self.category,
+                    instance_name,
+                    str(e).split("\n")[0] if "\n" in str(e) else str(e),
+                )
+
     @staticmethod
     def _humanize_request_tag(tag: str) -> str | None:
         if not tag:
@@ -785,7 +858,9 @@ class Arr:
         """Returns True if the State is categorized as Downloading."""
         return torrent.state_enum in (TorrentStates.DOWNLOADING, TorrentStates.PAUSED_DOWNLOAD)
 
-    def in_tags(self, torrent: TorrentDictionary, tag: str) -> bool:
+    def in_tags(
+        self, torrent: TorrentDictionary, tag: str, instance_name: str = "default"
+    ) -> bool:
         return_value = False
         if TAGLESS:
             if tag == "qBitrr-ignored":
@@ -796,15 +871,20 @@ class Arr:
                     .where(
                         (self.torrents.Hash == torrent.hash)
                         & (self.torrents.Category == torrent.category)
+                        & (self.torrents.QbitInstance == instance_name)
                     )
                     .execute()
                 )
                 if not query:
                     self.torrents.insert(
-                        Hash=torrent.hash, Category=torrent.category
+                        Hash=torrent.hash,
+                        Category=torrent.category,
+                        QbitInstance=instance_name,
                     ).on_conflict_ignore().execute()
-                condition = (self.torrents.Hash == torrent.hash) & (
-                    self.torrents.Category == torrent.category
+                condition = (
+                    (self.torrents.Hash == torrent.hash)
+                    & (self.torrents.Category == torrent.category)
+                    & (self.torrents.QbitInstance == instance_name)
                 )
                 if tag == "qBitrr-allowed_seeding":
                     condition &= self.torrents.AllowedSeeding == True
@@ -832,7 +912,9 @@ class Arr:
             self.logger.trace("Tag %s not in %s", tag, torrent.name)
             return False
 
-    def remove_tags(self, torrent: TorrentDictionary, tags: list) -> None:
+    def remove_tags(
+        self, torrent: TorrentDictionary, tags: list, instance_name: str = "default"
+    ) -> None:
         for tag in tags:
             self.logger.trace("Removing tag %s from %s", tag, torrent.name)
         if TAGLESS:
@@ -842,32 +924,39 @@ class Arr:
                     .where(
                         (self.torrents.Hash == torrent.hash)
                         & (self.torrents.Category == torrent.category)
+                        & (self.torrents.QbitInstance == instance_name)
                     )
                     .execute()
                 )
                 if not query:
                     self.torrents.insert(
-                        Hash=torrent.hash, Category=torrent.category
+                        Hash=torrent.hash,
+                        Category=torrent.category,
+                        QbitInstance=instance_name,
                     ).on_conflict_ignore().execute()
                 if tag == "qBitrr-allowed_seeding":
                     self.torrents.update(AllowedSeeding=False).where(
                         (self.torrents.Hash == torrent.hash)
                         & (self.torrents.Category == torrent.category)
+                        & (self.torrents.QbitInstance == instance_name)
                     ).execute()
                 elif tag == "qBitrr-imported":
                     self.torrents.update(Imported=False).where(
                         (self.torrents.Hash == torrent.hash)
                         & (self.torrents.Category == torrent.category)
+                        & (self.torrents.QbitInstance == instance_name)
                     ).execute()
                 elif tag == "qBitrr-allowed_stalled":
                     self.torrents.update(AllowedStalled=False).where(
                         (self.torrents.Hash == torrent.hash)
                         & (self.torrents.Category == torrent.category)
+                        & (self.torrents.QbitInstance == instance_name)
                     ).execute()
                 elif tag == "qBitrr-free_space_paused":
                     self.torrents.update(FreeSpacePaused=False).where(
                         (self.torrents.Hash == torrent.hash)
                         & (self.torrents.Category == torrent.category)
+                        & (self.torrents.QbitInstance == instance_name)
                     ).execute()
         else:
             with contextlib.suppress(Exception):
@@ -883,7 +972,9 @@ class Arr:
                     ),
                 )
 
-    def add_tags(self, torrent: TorrentDictionary, tags: list) -> None:
+    def add_tags(
+        self, torrent: TorrentDictionary, tags: list, instance_name: str = "default"
+    ) -> None:
         for tag in tags:
             self.logger.trace("Adding tag %s from %s", tag, torrent.name)
         if TAGLESS:
@@ -893,32 +984,39 @@ class Arr:
                     .where(
                         (self.torrents.Hash == torrent.hash)
                         & (self.torrents.Category == torrent.category)
+                        & (self.torrents.QbitInstance == instance_name)
                     )
                     .execute()
                 )
                 if not query:
                     self.torrents.insert(
-                        Hash=torrent.hash, Category=torrent.category
+                        Hash=torrent.hash,
+                        Category=torrent.category,
+                        QbitInstance=instance_name,
                     ).on_conflict_ignore().execute()
                 if tag == "qBitrr-allowed_seeding":
                     self.torrents.update(AllowedSeeding=True).where(
                         (self.torrents.Hash == torrent.hash)
                         & (self.torrents.Category == torrent.category)
+                        & (self.torrents.QbitInstance == instance_name)
                     ).execute()
                 elif tag == "qBitrr-imported":
                     self.torrents.update(Imported=True).where(
                         (self.torrents.Hash == torrent.hash)
                         & (self.torrents.Category == torrent.category)
+                        & (self.torrents.QbitInstance == instance_name)
                     ).execute()
                 elif tag == "qBitrr-allowed_stalled":
                     self.torrents.update(AllowedStalled=True).where(
                         (self.torrents.Hash == torrent.hash)
                         & (self.torrents.Category == torrent.category)
+                        & (self.torrents.QbitInstance == instance_name)
                     ).execute()
                 elif tag == "qBitrr-free_space_paused":
                     self.torrents.update(FreeSpacePaused=True).where(
                         (self.torrents.Hash == torrent.hash)
                         & (self.torrents.Category == torrent.category)
+                        & (self.torrents.QbitInstance == instance_name)
                     ).execute()
         else:
             with contextlib.suppress(Exception):
@@ -966,7 +1064,16 @@ class Arr:
                 if not results:
                     break
                 for entry in results:
+                    # NOTE: 'type' field is not documented in official Overseerr API spec
+                    # but exists in practice. May break if Overseerr changes API.
                     type__ = entry.get("type")
+                    if not type__:
+                        self.logger.debug(
+                            "Overseerr request missing 'type' field (entry ID: %s). "
+                            "This may indicate an API change.",
+                            entry.get("id", "unknown"),
+                        )
+                        continue
                     if type__ == "movie":
                         id__ = entry.get("media", {}).get("tmdbId")
                     elif type__ == "tv":
@@ -976,6 +1083,8 @@ class Arr:
                     if not id__ or type_ != type__:
                         continue
                     media = entry.get("media") or {}
+                    # NOTE: 'status4k' field is not documented in official Overseerr API spec
+                    # but exists for 4K request tracking. Falls back to 'status' for non-4K.
                     status_key = "status4k" if entry.get("is4k") else "status"
                     status_value = _normalize_media_status(media.get(status_key))
                     if entry.get("is4k"):
@@ -998,7 +1107,7 @@ class Arr:
                         try:
                             if type_ == "movie":
                                 _entry = self.session.get(
-                                    url=f"{self.overseerr_uri}/api/v1/movies/{id__}",
+                                    url=f"{self.overseerr_uri}/api/v1/movie/{id__}",
                                     headers={"X-Api-Key": self.overseerr_api_key},
                                     timeout=5,
                                 )
@@ -1159,7 +1268,7 @@ class Arr:
     def _process_imports(self) -> None:
         if self.import_torrents:
             self.needs_cleanup = True
-            for torrent in self.import_torrents:
+            for torrent, instance_name in self.import_torrents:
                 if torrent.hash in self.sent_to_scan:
                     continue
                 path = validate_and_return_torrent_file(torrent.content_path)
@@ -1245,7 +1354,7 @@ class Arr:
                         self.import_mode,
                         ex,
                     )
-                self.add_tags(torrent, ["qBitrr-imported"])
+                self.add_tags(torrent, ["qBitrr-imported"], instance_name)
                 self.sent_to_scan.add(path)
             self.import_torrents.clear()
 
@@ -2842,6 +2951,10 @@ class Arr:
                             # Only apply temp profiles for truly missing content (no file)
                             # Do NOT apply for quality/custom format unmet or upgrade searches
                             has_file = episode.get("hasFile", False)
+                            profile_switch_timestamp = None
+                            original_profile_for_db = None
+                            current_profile_for_db = None
+
                             self.logger.trace(
                                 "Temp quality profile check for '%s': searched=%s, has_file=%s, current_profile_id=%s, keep_temp=%s",
                                 db_entry.get("title", "Unknown"),
@@ -2852,22 +2965,31 @@ class Arr:
                             )
                             if (
                                 searched
-                                and quality_profile_id in self.temp_quality_profile_ids.values()
+                                and quality_profile_id in self.main_quality_profile_ids.keys()
                                 and not self.keep_temp_profile
                             ):
-                                new_profile_id = list(self.temp_quality_profile_ids.keys())[
-                                    list(self.temp_quality_profile_ids.values()).index(
-                                        quality_profile_id
-                                    )
-                                ]
-                                data: JsonObject = {"qualityProfileId": new_profile_id}
-                                self.logger.info(
-                                    "Upgrading quality profile for '%s': %s (ID:%s) → main profile (ID:%s) [Episode searched, reverting to main]",
-                                    db_entry.get("title", "Unknown"),
-                                    quality_profile_id,
-                                    quality_profile_id,
-                                    new_profile_id,
+                                new_profile_id = self.main_quality_profile_ids.get(
+                                    quality_profile_id
                                 )
+                                if new_profile_id is None:
+                                    self.logger.warning(
+                                        f"Profile ID {quality_profile_id} not found in current temp→main mappings. "
+                                        "Config may have changed. Skipping profile upgrade."
+                                    )
+                                else:
+                                    data: JsonObject = {"qualityProfileId": new_profile_id}
+                                    self.logger.info(
+                                        "Upgrading quality profile for '%s': temp profile (ID:%s) → main profile (ID:%s) [Episode searched, reverting to main]",
+                                        db_entry.get("title", "Unknown"),
+                                        quality_profile_id,
+                                        new_profile_id,
+                                    )
+                                # Reverting to main - clear tracking fields
+                                from datetime import datetime
+
+                                profile_switch_timestamp = datetime.now()
+                                original_profile_for_db = None
+                                current_profile_for_db = None
                             elif (
                                 not searched
                                 and not has_file
@@ -2881,6 +3003,12 @@ class Arr:
                                     quality_profile_id,
                                     new_profile_id,
                                 )
+                                # Downgrading to temp - track original and switch time
+                                from datetime import datetime
+
+                                profile_switch_timestamp = datetime.now()
+                                original_profile_for_db = quality_profile_id
+                                current_profile_for_db = new_profile_id
                             else:
                                 self.logger.trace(
                                     "No quality profile change for '%s': searched=%s, profile_id=%s (in_temps=%s, in_mains=%s)",
@@ -2891,18 +3019,34 @@ class Arr:
                                     quality_profile_id in self.temp_quality_profile_ids.keys(),
                                 )
                             if data:
-                                while True:
+                                profile_update_success = False
+                                for attempt in range(self.profile_switch_retry_attempts):
                                     try:
                                         self.client.upd_episode(episode["id"], data)
+                                        profile_update_success = True
                                         break
                                     except (
                                         requests.exceptions.ChunkedEncodingError,
                                         requests.exceptions.ContentDecodingError,
                                         requests.exceptions.ConnectionError,
                                         JSONDecodeError,
-                                    ):
+                                    ) as e:
+                                        if attempt == self.profile_switch_retry_attempts - 1:
+                                            self.logger.error(
+                                                "Failed to update episode profile after %d attempts: %s",
+                                                self.profile_switch_retry_attempts,
+                                                e,
+                                            )
+                                            break
+                                        time.sleep(1)
                                         continue
 
+                                # If profile update failed, don't track the change
+                                if not profile_update_success:
+                                    profile_switch_timestamp = None
+                                    original_profile_for_db = None
+                                    current_profile_for_db = None
+
                         EntryId = episode.get("id")
                         SeriesTitle = episode.get("series", {}).get("title")
                         SeasonNumber = episode.get("seasonNumber")
@@ -2960,6 +3104,14 @@ class Arr:
                             self.model_file.Reason: reason,
                         }
 
+                        # Add profile tracking fields if temp profile feature is enabled
+                        if self.use_temp_for_missing and profile_switch_timestamp is not None:
+                            to_update[self.model_file.LastProfileSwitchTime] = (
+                                profile_switch_timestamp
+                            )
+                            to_update[self.model_file.OriginalProfileId] = original_profile_for_db
+                            to_update[self.model_file.CurrentProfileId] = current_profile_for_db
+
                         self.logger.debug(
                             "Updating database entry | %s | S%02dE%03d [Searched:%s][Upgrade:%s][QualityMet:%s][CustomFormatMet:%s]",
                             SeriesTitle.ljust(60, "."),
@@ -3076,46 +3228,42 @@ class Arr:
                             searched = totalEpisodeCount == episodeFileCount
                         else:
                             searched = (episodeCount + monitoredEpisodeCount) == episodeFileCount
+                        # Sonarr series-level temp profile logic
+                        # NOTE: Sonarr only supports quality profiles at the series level (not episode level).
+                        # Individual episodes inherit the series profile. This is intentional and correct.
+                        # If ANY episodes are missing, the entire series uses temp profile to maximize
+                        # the chance of finding missing content (priority #1).
                         if self.use_temp_for_missing:
                             try:
                                 quality_profile_id = db_entry.get("qualityProfileId")
                                 if (
                                     searched
-                                    and quality_profile_id
-                                    in self.temp_quality_profile_ids.values()
+                                    and quality_profile_id in self.main_quality_profile_ids.keys()
                                     and not self.keep_temp_profile
                                 ):
-                                    db_entry["qualityProfileId"] = list(
-                                        self.temp_quality_profile_ids.keys()
-                                    )[
-                                        list(self.temp_quality_profile_ids.values()).index(
-                                            quality_profile_id
-                                        )
-                                    ]
+                                    new_main_id = self.main_quality_profile_ids[quality_profile_id]
+                                    db_entry["qualityProfileId"] = new_main_id
                                     self.logger.debug(
                                         "Updating quality profile for %s to %s",
                                         db_entry["title"],
-                                        db_entry["qualityProfileId"],
+                                        new_main_id,
                                     )
                                 elif (
                                     not searched
                                     and quality_profile_id in self.temp_quality_profile_ids.keys()
                                 ):
-                                    db_entry["qualityProfileId"] = self.temp_quality_profile_ids[
-                                        quality_profile_id
-                                    ]
+                                    new_temp_id = self.temp_quality_profile_ids[quality_profile_id]
+                                    db_entry["qualityProfileId"] = new_temp_id
                                     self.logger.debug(
                                         "Updating quality profile for %s to %s",
                                         db_entry["title"],
-                                        self.temp_quality_profile_ids[
-                                            db_entry["qualityProfileId"]
-                                        ],
+                                        new_temp_id,
                                     )
                             except KeyError:
                                 self.logger.warning(
                                     "Check quality profile settings for %s", db_entry["title"]
                                 )
-                            while True:
+                            for attempt in range(self.profile_switch_retry_attempts):
                                 try:
                                     self.client.upd_series(db_entry)
                                     break
@@ -3124,7 +3272,15 @@ class Arr:
                                     requests.exceptions.ContentDecodingError,
                                     requests.exceptions.ConnectionError,
                                     JSONDecodeError,
-                                ):
+                                ) as e:
+                                    if attempt == self.profile_switch_retry_attempts - 1:
+                                        self.logger.error(
+                                            "Failed to update series profile after %d attempts: %s",
+                                            self.profile_switch_retry_attempts,
+                                            e,
+                                        )
+                                        break
+                                    time.sleep(1)
                                     continue
 
                         Title = seriesMetadata.get("title")
@@ -3248,6 +3404,10 @@ class Arr:
                             self.model_queue.EntryId == db_entry["id"]
                         ).execute()
 
+                    profile_switch_timestamp = None
+                    original_profile_for_db = None
+                    current_profile_for_db = None
+
                     if self.use_temp_for_missing:
                         quality_profile_id = db_entry.get("qualityProfileId")
                         # Only apply temp profiles for truly missing content (no file)
@@ -3255,46 +3415,69 @@ class Arr:
                         has_file = db_entry.get("hasFile", False)
                         if (
                             searched
-                            and quality_profile_id in self.temp_quality_profile_ids.values()
+                            and quality_profile_id in self.main_quality_profile_ids.keys()
                             and not self.keep_temp_profile
                         ):
-                            db_entry["qualityProfileId"] = list(
-                                self.temp_quality_profile_ids.keys()
-                            )[
-                                list(self.temp_quality_profile_ids.values()).index(
-                                    quality_profile_id
-                                )
-                            ]
+                            new_main_id = self.main_quality_profile_ids[quality_profile_id]
+                            db_entry["qualityProfileId"] = new_main_id
                             self.logger.debug(
                                 "Updating quality profile for %s to %s",
                                 db_entry["title"],
-                                db_entry["qualityProfileId"],
+                                new_main_id,
                             )
+                            # Reverting to main - clear tracking fields
+                            from datetime import datetime
+
+                            profile_switch_timestamp = datetime.now()
+                            original_profile_for_db = None
+                            current_profile_for_db = None
                         elif (
                             not searched
                             and not has_file
                             and quality_profile_id in self.temp_quality_profile_ids.keys()
                         ):
-                            db_entry["qualityProfileId"] = self.temp_quality_profile_ids[
-                                quality_profile_id
-                            ]
+                            new_temp_id = self.temp_quality_profile_ids[quality_profile_id]
+                            db_entry["qualityProfileId"] = new_temp_id
                             self.logger.debug(
                                 "Updating quality profile for %s to %s",
                                 db_entry["title"],
-                                db_entry["qualityProfileId"],
+                                new_temp_id,
                             )
-                        while True:
+                            # Downgrading to temp - track original and switch time
+                            from datetime import datetime
+
+                            profile_switch_timestamp = datetime.now()
+                            original_profile_for_db = quality_profile_id
+                            current_profile_for_db = new_temp_id
+
+                        profile_update_success = False
+                        for attempt in range(self.profile_switch_retry_attempts):
                             try:
                                 self.client.upd_movie(db_entry)
+                                profile_update_success = True
                                 break
                             except (
                                 requests.exceptions.ChunkedEncodingError,
                                 requests.exceptions.ContentDecodingError,
                                 requests.exceptions.ConnectionError,
                                 JSONDecodeError,
-                            ):
+                            ) as e:
+                                if attempt == self.profile_switch_retry_attempts - 1:
+                                    self.logger.error(
+                                        "Failed to update movie profile after %d attempts: %s",
+                                        self.profile_switch_retry_attempts,
+                                        e,
+                                    )
+                                    break
+                                time.sleep(1)
                                 continue
 
+                        # If profile update failed, don't track the change
+                        if not profile_update_success:
+                            profile_switch_timestamp = None
+                            original_profile_for_db = None
+                            current_profile_for_db = None
+
                     title = db_entry["title"]
                     monitored = db_entry["monitored"]
                     tmdbId = db_entry["tmdbId"]
@@ -3347,6 +3530,12 @@ class Arr:
                         self.model_file.QualityProfileName: qualityProfileName,
                     }
 
+                    # Add profile tracking fields if temp profile feature is enabled
+                    if self.use_temp_for_missing and profile_switch_timestamp is not None:
+                        to_update[self.model_file.LastProfileSwitchTime] = profile_switch_timestamp
+                        to_update[self.model_file.OriginalProfileId] = original_profile_for_db
+                        to_update[self.model_file.CurrentProfileId] = current_profile_for_db
+
                     if request:
                         to_update[self.model_file.IsRequest] = request
 
@@ -3794,18 +3983,17 @@ class Arr:
 
                         # Temp profile management for Lidarr artists
                         # Quality profiles in Lidarr are set at artist level, not album level
+                        # NOTE: Lidarr uses sizeOnDisk instead of hasFile because the Lidarr API
+                        # doesn't provide a hasFile boolean at artist level. sizeOnDisk > 0 is
+                        # equivalent to hasFile=True for Lidarr.
                         if self.use_temp_for_missing and quality_profile_id:
                             if (
                                 searched
-                                and quality_profile_id in self.temp_quality_profile_ids.values()
+                                and quality_profile_id in self.main_quality_profile_ids.keys()
                                 and not self.keep_temp_profile
                             ):
                                 # Artist has files, switch from temp back to main profile
-                                main_profile_id = list(self.temp_quality_profile_ids.keys())[
-                                    list(self.temp_quality_profile_ids.values()).index(
-                                        quality_profile_id
-                                    )
-                                ]
+                                main_profile_id = self.main_quality_profile_ids[quality_profile_id]
                                 artistMetadata["qualityProfileId"] = main_profile_id
                                 self.client.upd_artist(artistMetadata)
                                 quality_profile_id = main_profile_id
@@ -4448,27 +4636,85 @@ class Arr:
 
         return payload
 
+    def _get_torrents_from_all_instances(
+        self,
+    ) -> list[tuple[str, qbittorrentapi.TorrentDictionary]]:
+        """
+        Get torrents from ALL qBittorrent instances for this Arr's category.
+
+        Returns:
+            list[tuple[str, TorrentDictionary]]: List of (instance_name, torrent) tuples
+        """
+        all_torrents = []
+        qbit_manager = self.manager.qbit_manager
+
+        for instance_name in qbit_manager.get_all_instances():
+            if not qbit_manager.is_instance_alive(instance_name):
+                self.logger.debug(
+                    "Skipping unhealthy instance '%s' during torrent scan", instance_name
+                )
+                continue
+
+            client = qbit_manager.get_client(instance_name)
+            if client is None:
+                continue
+
+            try:
+                torrents = client.torrents.info(
+                    status_filter="all",
+                    category=self.category,
+                    sort="added_on",
+                    reverse=False,
+                )
+                # Tag each torrent with its instance name
+                for torrent in torrents:
+                    if hasattr(torrent, "category"):
+                        all_torrents.append((instance_name, torrent))
+
+                self.logger.trace(
+                    "Retrieved %d torrents from instance '%s' for category '%s'",
+                    len(torrents),
+                    instance_name,
+                    self.category,
+                )
+            except (qbittorrentapi.exceptions.APIError, JSONDecodeError) as e:
+                self.logger.warning(
+                    "Failed to get torrents from instance '%s': %s", instance_name, e
+                )
+                continue
+
+        self.logger.debug(
+            "Total torrents across %d instances: %d",
+            len(qbit_manager.get_all_instances()),
+            len(all_torrents),
+        )
+        return all_torrents
+
     def process_torrents(self):
         try:
             try:
                 while True:
                     try:
-                        torrents = self.manager.qbit_manager.client.torrents.info(
-                            status_filter="all",
-                            category=self.category,
-                            sort="added_on",
-                            reverse=False,
-                        )
+                        # Multi-instance: Scan all qBit instances for category-matching torrents
+                        torrents_with_instances = self._get_torrents_from_all_instances()
                         break
                     except (qbittorrentapi.exceptions.APIError, JSONDecodeError) as e:
                         if "JSONDecodeError" in str(e):
                             continue
                         else:
                             raise qbittorrentapi.exceptions.APIError
-                torrents = [t for t in torrents if hasattr(t, "category")]
-                self.category_torrent_count = len(torrents)
-                if not len(torrents):
+
+                # Filter torrents that have category attribute
+                torrents_with_instances = [
+                    (instance, t)
+                    for instance, t in torrents_with_instances
+                    if hasattr(t, "category")
+                ]
+                self.category_torrent_count = len(torrents_with_instances)
+                if not len(torrents_with_instances):
                     raise DelayLoopException(length=LOOP_SLEEP_TIMER, type="no_downloads")
+
+                # Internet check: Use default instance for backward compatibility
                 if not has_internet(self.manager.qbit_manager.client):
                     self.manager.qbit_manager.should_delay_torrent_scan = True
                     raise DelayLoopException(length=NO_INTERNET_SLEEP_TIMER, type="internet")
@@ -4507,9 +4753,10 @@ class Arr:
 
                 self.api_calls()
                 self.refresh_download_queue()
-                for torrent in torrents:
+                # Multi-instance: Process torrents from all instances
+                for instance_name, torrent in torrents_with_instances:
                     with contextlib.suppress(qbittorrentapi.NotFound404Error):
-                        self._process_single_torrent(torrent)
+                        self._process_single_torrent(torrent, instance_name=instance_name)
                 self.process()
             except NoConnectionrException as e:
                 self.logger.error(e.message)
@@ -4527,42 +4774,70 @@ class Arr:
                 current_time = time.time()
 
                 # Track consecutive database errors for exponential backoff
+                # Initialize tracking on first error ever
+                if not hasattr(self, "_db_first_error_time"):
+                    self._db_first_error_time = current_time
+
+                # Reset if >5min since last error (new error sequence)
                 if (
                     current_time - self._db_last_error_time > 300
                 ):  # Reset if >5min since last error
                     self._db_error_count = 0
+                    self._db_first_error_time = current_time
+
                 self._db_error_count += 1
                 self._db_last_error_time = current_time
 
+                # Check if errors have persisted for more than 5 minutes
+                time_since_first_error = current_time - self._db_first_error_time
+                if time_since_first_error > 300:  # 5 minutes
+                    self.logger.critical(
+                        "Database errors have persisted for %.1f minutes. "
+                        "Signaling coordinated restart of ALL processes for database recovery...",
+                        time_since_first_error / 60,
+                    )
+                    # Signal all processes to restart (shared database affects everyone)
+                    self.manager.qbit_manager.database_restart_event.set()
+                    # Exit this process - main will restart all
+                    sys.exit(1)
+
                 # Calculate exponential backoff: 2min, 5min, 10min, 20min, 30min (max)
                 delay_seconds = min(120 * (2 ** (self._db_error_count - 1)), 1800)
 
                 # Log detailed error information based on error type
+                # Use escalating severity: WARNING (1-2 errors), ERROR (3-4), CRITICAL (5+)
+                if self._db_error_count <= 2:
+                    log_func = self.logger.warning
+                elif self._db_error_count <= 4:
+                    log_func = self.logger.error
+                else:
+                    log_func = self.logger.critical
+
                 if "disk i/o error" in error_msg:
-                    self.logger.critical(
-                        "Persistent database I/O error detected (consecutive error #%d). "
-                        "This indicates disk issues, filesystem corruption, or resource exhaustion. "
+                    log_func(
+                        "Database I/O error detected (consecutive error #%d). "
+                        "This may indicate disk issues, filesystem corruption, or resource exhaustion. "
                         "Attempting automatic recovery and retrying in %d seconds...",
                         self._db_error_count,
                         delay_seconds,
                     )
                 elif "database is locked" in error_msg:
-                    self.logger.error(
+                    log_func(
                         "Database locked error (consecutive error #%d). "
                         "Retrying in %d seconds...",
                         self._db_error_count,
                         delay_seconds,
                     )
                 elif "disk image is malformed" in error_msg:
-                    self.logger.critical(
+                    log_func(
                         "Database corruption detected (consecutive error #%d). "
                         "Attempting automatic recovery and retrying in %d seconds...",
                         self._db_error_count,
                         delay_seconds,
                     )
                 else:
-                    self.logger.error(
-                        "Database error (consecutive error #%d): %s. " "Retrying in %d seconds...",
+                    log_func(
+                        "Database error (consecutive error #%d): %s. Retrying in %d seconds...",
                         self._db_error_count,
                         error_msg,
                         delay_seconds,
@@ -4977,7 +5252,10 @@ class Arr:
         self.recheck.add(torrent.hash)
 
     def _process_single_torrent_fully_completed_torrent(
-        self, torrent: qbittorrentapi.TorrentDictionary, leave_alone: bool
+        self,
+        torrent: qbittorrentapi.TorrentDictionary,
+        leave_alone: bool,
+        instance_name: str = "default",
     ):
         if leave_alone or torrent.state_enum == TorrentStates.FORCED_UPLOAD:
             self.logger.trace(
@@ -4995,7 +5273,7 @@ class Arr:
                 torrent.name,
                 torrent.hash,
             )
-        elif not self.in_tags(torrent, "qBitrr-imported"):
+        elif not self.in_tags(torrent, "qBitrr-imported", instance_name):
             self.logger.info(
                 "Importing Completed torrent: "
                 "[Progress: %s%%][Added On: %s]"
@@ -5020,7 +5298,7 @@ class Arr:
                 else:
                     torrent_folder = content_path
             self.files_to_cleanup.add((torrent.hash, torrent_folder))
-            self.import_torrents.append(torrent)
+            self.import_torrents.append((torrent, instance_name))
 
     def _process_single_torrent_missing_files(self, torrent: qbittorrentapi.TorrentDictionary):
         # Sometimes Sonarr/Radarr does not automatically remove the
@@ -5388,7 +5666,7 @@ class Arr:
         return data_settings, data_torrent
 
     def _should_leave_alone(
-        self, torrent: qbittorrentapi.TorrentDictionary
+        self, torrent: qbittorrentapi.TorrentDictionary, instance_name: str = "default"
     ) -> tuple[bool, int, bool]:
         return_value = True
         remove_torrent = False
@@ -5414,18 +5692,18 @@ class Arr:
         return_value = not self.torrent_limit_check(torrent, seeding_time_limit, ratio_limit)
         if data_settings.get("super_seeding", False) or data_torrent.get("super_seeding", False):
             return_value = True
-        if self.in_tags(torrent, "qBitrr-free_space_paused"):
+        if self.in_tags(torrent, "qBitrr-free_space_paused", instance_name):
             return_value = True
         if (
             return_value
-            and not self.in_tags(torrent, "qBitrr-allowed_seeding")
-            and not self.in_tags(torrent, "qBitrr-free_space_paused")
+            and not self.in_tags(torrent, "qBitrr-allowed_seeding", instance_name)
+            and not self.in_tags(torrent, "qBitrr-free_space_paused", instance_name)
         ):
-            self.add_tags(torrent, ["qBitrr-allowed_seeding"])
+            self.add_tags(torrent, ["qBitrr-allowed_seeding"], instance_name)
         elif (
-            not return_value and self.in_tags(torrent, "qBitrr-allowed_seeding")
-        ) or self.in_tags(torrent, "qBitrr-free_space_paused"):
-            self.remove_tags(torrent, ["qBitrr-allowed_seeding"])
+            not return_value and self.in_tags(torrent, "qBitrr-allowed_seeding", instance_name)
+        ) or self.in_tags(torrent, "qBitrr-free_space_paused", instance_name):
+            self.remove_tags(torrent, ["qBitrr-allowed_seeding"], instance_name)
 
         self.logger.trace("Config Settings returned [%s]: %r", torrent.name, data_settings)
         return (
@@ -5591,9 +5869,14 @@ class Arr:
             current_tags = set(torrent.tags.split(", "))
             add_tags = unique_tags.difference(current_tags)
             if add_tags:
-                self.add_tags(torrent, add_tags)
+                self.add_tags(torrent, add_tags, instance_name)
 
-    def _stalled_check(self, torrent: qbittorrentapi.TorrentDictionary, time_now: float) -> bool:
+    def _stalled_check(
+        self,
+        torrent: qbittorrentapi.TorrentDictionary,
+        time_now: float,
+        instance_name: str = "default",
+    ) -> bool:
         stalled_ignore = True
         if not self.allowed_stalled:
             self.logger.trace("Stalled check: Stalled delay disabled")
@@ -5630,15 +5913,15 @@ class Arr:
             (
                 torrent.state_enum
                 in (TorrentStates.METADATA_DOWNLOAD, TorrentStates.STALLED_DOWNLOAD)
-                and not self.in_tags(torrent, "qBitrr-ignored")
-                and not self.in_tags(torrent, "qBitrr-free_space_paused")
+                and not self.in_tags(torrent, "qBitrr-ignored", instance_name)
+                and not self.in_tags(torrent, "qBitrr-free_space_paused", instance_name)
             )
             or (
                 torrent.availability < 1
                 and torrent.hash in self.cleaned_torrents
                 and torrent.state_enum in (TorrentStates.DOWNLOADING)
-                and not self.in_tags(torrent, "qBitrr-ignored")
-                and not self.in_tags(torrent, "qBitrr-free_space_paused")
+                and not self.in_tags(torrent, "qBitrr-ignored", instance_name)
+                and not self.in_tags(torrent, "qBitrr-free_space_paused", instance_name)
             )
         ) and self.allowed_stalled:
             if (
@@ -5648,8 +5931,8 @@ class Arr:
             ):
                 stalled_ignore = False
                 self.logger.trace("Process stalled, delay expired: %s", torrent.name)
-            elif not self.in_tags(torrent, "qBitrr-allowed_stalled"):
-                self.add_tags(torrent, ["qBitrr-allowed_stalled"])
+            elif not self.in_tags(torrent, "qBitrr-allowed_stalled", instance_name):
+                self.add_tags(torrent, ["qBitrr-allowed_stalled"], instance_name)
                 if self.re_search_stalled:
                     self.logger.trace(
                         "Stalled, adding tag, blocklosting and re-searching: %s", torrent.name
@@ -5666,7 +5949,7 @@ class Arr:
                             )
                 else:
                     self.logger.trace("Stalled, adding tag: %s", torrent.name)
-            elif self.in_tags(torrent, "qBitrr-allowed_stalled"):
+            elif self.in_tags(torrent, "qBitrr-allowed_stalled", instance_name):
                 self.logger.trace(
                     "Stalled: %s [Current:%s][Last Activity:%s][Limit:%s]",
                     torrent.name,
@@ -5677,8 +5960,8 @@ class Arr:
                     ),
                 )
 
-        elif self.in_tags(torrent, "qBitrr-allowed_stalled"):
-            self.remove_tags(torrent, ["qBitrr-allowed_stalled"])
+        elif self.in_tags(torrent, "qBitrr-allowed_stalled", instance_name):
+            self.remove_tags(torrent, ["qBitrr-allowed_stalled"], instance_name)
             stalled_ignore = False
             self.logger.trace("Not stalled, removing tag: %s", torrent.name)
         else:
@@ -5686,13 +5969,17 @@ class Arr:
             self.logger.trace("Not stalled: %s", torrent.name)
         return stalled_ignore
 
-    def _process_single_torrent(self, torrent: qbittorrentapi.TorrentDictionary):
+    def _process_single_torrent(
+        self, torrent: qbittorrentapi.TorrentDictionary, instance_name: str = "default"
+    ):
         if torrent.category != RECHECK_CATEGORY:
             self.manager.qbit_manager.cache[torrent.hash] = torrent.category
         self._process_single_torrent_trackers(torrent)
         self.manager.qbit_manager.name_cache[torrent.hash] = torrent.name
         time_now = time.time()
-        leave_alone, _tracker_max_eta, remove_torrent = self._should_leave_alone(torrent)
+        leave_alone, _tracker_max_eta, remove_torrent = self._should_leave_alone(
+            torrent, instance_name
+        )
         self.logger.trace(
             "Torrent [%s]: Leave Alone (allow seeding): %s, Max ETA: %s, State[%s]",
             torrent.name,
@@ -5707,20 +5994,22 @@ class Arr:
             TorrentStates.STALLED_DOWNLOAD,
             TorrentStates.DOWNLOADING,
         ):
-            stalled_ignore = self._stalled_check(torrent, time_now)
+            stalled_ignore = self._stalled_check(torrent, time_now, instance_name)
         else:
             stalled_ignore = False
 
-        if self.in_tags(torrent, "qBitrr-ignored"):
-            self.remove_tags(torrent, ["qBitrr-allowed_seeding", "qBitrr-free_space_paused"])
+        if self.in_tags(torrent, "qBitrr-ignored", instance_name):
+            self.remove_tags(
+                torrent, ["qBitrr-allowed_seeding", "qBitrr-free_space_paused"], instance_name
+            )
 
         if (
             self.custom_format_unmet_search
             and self.custom_format_unmet_check(torrent)
-            and not self.in_tags(torrent, "qBitrr-ignored")
-            and not self.in_tags(torrent, "qBitrr-free_space_paused")
+            and not self.in_tags(torrent, "qBitrr-ignored", instance_name)
+            and not self.in_tags(torrent, "qBitrr-free_space_paused", instance_name)
         ):
-            self._process_single_torrent_delete_cfunmet(torrent)
+            self._process_single_torrent_delete_cfunmet(torrent, instance_name)
         elif remove_torrent and not leave_alone and torrent.amount_left == 0:
             self._process_single_torrent_delete_ratio_seed(torrent)
         elif torrent.category == FAILED_CATEGORY:
@@ -5733,8 +6022,8 @@ class Arr:
             self._process_single_torrent_ignored(torrent)
         elif (
             torrent.state_enum in (TorrentStates.METADATA_DOWNLOAD, TorrentStates.STALLED_DOWNLOAD)
-            and not self.in_tags(torrent, "qBitrr-ignored")
-            and not self.in_tags(torrent, "qBitrr-free_space_paused")
+            and not self.in_tags(torrent, "qBitrr-ignored", instance_name)
+            and not self.in_tags(torrent, "qBitrr-free_space_paused", instance_name)
             and not stalled_ignore
         ):
             self._process_single_torrent_stalled_torrent(torrent, "Stalled State")
@@ -5755,15 +6044,15 @@ class Arr:
         elif (
             torrent.state_enum == TorrentStates.PAUSED_DOWNLOAD
             and torrent.amount_left != 0
-            and not self.in_tags(torrent, "qBitrr-free_space_paused")
-            and not self.in_tags(torrent, "qBitrr-ignored")
+            and not self.in_tags(torrent, "qBitrr-free_space_paused", instance_name)
+            and not self.in_tags(torrent, "qBitrr-ignored", instance_name)
         ):
             self._process_single_torrent_paused(torrent)
         elif (
             torrent.progress <= self.maximum_deletable_percentage
             and not self.is_complete_state(torrent)
-            and not self.in_tags(torrent, "qBitrr-ignored")
-            and not self.in_tags(torrent, "qBitrr-free_space_paused")
+            and not self.in_tags(torrent, "qBitrr-ignored", instance_name)
+            and not self.in_tags(torrent, "qBitrr-free_space_paused", instance_name)
             and not stalled_ignore
         ) and torrent.hash in self.cleaned_torrents:
             self._process_single_torrent_percentage_threshold(torrent, maximum_eta)
@@ -5810,8 +6099,8 @@ class Arr:
             and time_now > torrent.added_on + self.ignore_torrents_younger_than
             and 0 < maximum_eta < torrent.eta
             and not self.do_not_remove_slow
-            and not self.in_tags(torrent, "qBitrr-ignored")
-            and not self.in_tags(torrent, "qBitrr-free_space_paused")
+            and not self.in_tags(torrent, "qBitrr-ignored", instance_name)
+            and not self.in_tags(torrent, "qBitrr-free_space_paused", instance_name)
             and not stalled_ignore
         ):
             self._process_single_torrent_delete_slow(torrent)
@@ -5826,8 +6115,8 @@ class Arr:
                 )
                 and torrent.hash in self.cleaned_torrents
                 and self.is_downloading_state(torrent)
-                and not self.in_tags(torrent, "qBitrr-ignored")
-                and not self.in_tags(torrent, "qBitrr-free_space_paused")
+                and not self.in_tags(torrent, "qBitrr-ignored", instance_name)
+                and not self.in_tags(torrent, "qBitrr-free_space_paused", instance_name)
                 and not stalled_ignore
             ):
                 self._process_single_torrent_stalled_torrent(torrent, "Unavailable")
@@ -5919,27 +6208,30 @@ class Arr:
     def torrent_limit_check(
         self, torrent: qbittorrentapi.TorrentDictionary, seeding_time_limit, ratio_limit
     ) -> bool:
-        if (
+        # -1 = Never remove (regardless of ratio/time limits)
+        if self.seeding_mode_global_remove_torrent == -1:
+            return False
+        # 4 = AND (remove when BOTH ratio AND time limits met)
+        elif (
             self.seeding_mode_global_remove_torrent == 4
             and torrent.ratio >= ratio_limit
             and torrent.seeding_time >= seeding_time_limit
         ):
             return True
-        if self.seeding_mode_global_remove_torrent == 3 and (
+        # 3 = OR (remove when EITHER ratio OR time limit met)
+        elif self.seeding_mode_global_remove_torrent == 3 and (
             torrent.ratio >= ratio_limit or torrent.seeding_time >= seeding_time_limit
         ):
             return True
+        # 2 = Time only (remove when seeding time limit met)
         elif (
             self.seeding_mode_global_remove_torrent == 2
             and torrent.seeding_time >= seeding_time_limit
         ):
             return True
+        # 1 = Ratio only (remove when upload ratio limit met)
         elif self.seeding_mode_global_remove_torrent == 1 and torrent.ratio >= ratio_limit:
             return True
-        elif self.seeding_mode_global_remove_torrent == -1 and (
-            torrent.ratio >= ratio_limit and torrent.seeding_time >= seeding_time_limit
-        ):
-            return True
         else:
             return False
 
@@ -6064,6 +6356,15 @@ class Arr:
             self.files_to_explicitly_delete = iter(_path_filter.copy())
 
     def parse_quality_profiles(self) -> dict[int, int]:
+        """
+        Parse quality profile name mappings into ID mappings.
+
+        Converts the configured profile name mappings (e.g., {"HD-1080p": "SD"})
+        into ID mappings (e.g., {2: 1}) for faster lookups during profile switching.
+
+        Returns:
+            dict[int, int]: Mapping of main_profile_id → temp_profile_id
+        """
         temp_quality_profile_ids: dict[int, int] = {}
 
         self.logger.debug(
@@ -6148,6 +6449,171 @@ class Arr:
 
         return temp_quality_profile_ids
 
+    def _reset_all_temp_profiles(self):
+        """Reset all items using temp profiles back to their original main profiles on startup."""
+        reset_count = 0
+
+        try:
+            # Get all items from Arr instance
+            if self._name.lower().startswith("radarr"):
+                items = self.client.get_movie()
+                item_type = "movie"
+            elif self._name.lower().startswith("sonarr") or self._name.lower().startswith(
+                "animarr"
+            ):
+                items = self.client.get_series()
+                item_type = "series"
+            elif self._name.lower().startswith("lidarr"):
+                items = self.client.get_artist()
+                item_type = "artist"
+            else:
+                self.logger.warning(f"Unknown Arr type for temp profile reset: {self._name}")
+                return
+
+            self.logger.info(f"Checking {len(items)} {item_type}s for temp profile resets...")
+
+            for item in items:
+                profile_id = item.get("qualityProfileId")
+
+                # Check if item is currently using a temp profile
+                if profile_id in self.main_quality_profile_ids.keys():
+                    # This is a temp profile - get the original main profile
+                    original_id = self.main_quality_profile_ids[profile_id]
+                    item["qualityProfileId"] = original_id
+
+                    # Update via API with retry logic
+                    for attempt in range(self.profile_switch_retry_attempts):
+                        try:
+                            if item_type == "movie":
+                                self.client.upd_movie(item)
+                            elif item_type == "series":
+                                self.client.upd_series(item)
+                            elif item_type == "artist":
+                                self.client.upd_artist(item)
+
+                            reset_count += 1
+                            self.logger.info(
+                                f"Reset {item_type} '{item.get('title', item.get('artistName', 'Unknown'))}' "
+                                f"from temp profile (ID:{profile_id}) to main profile (ID:{original_id})"
+                            )
+                            break
+                        except (
+                            requests.exceptions.ChunkedEncodingError,
+                            requests.exceptions.ContentDecodingError,
+                            requests.exceptions.ConnectionError,
+                            JSONDecodeError,
+                        ) as e:
+                            if attempt == self.profile_switch_retry_attempts - 1:
+                                self.logger.error(
+                                    f"Failed to reset {item_type} profile after {self.profile_switch_retry_attempts} attempts: {e}"
+                                )
+                            else:
+                                time.sleep(1)
+                                continue
+
+            if reset_count > 0:
+                self.logger.info(
+                    f"ForceResetTempProfiles: Reset {reset_count} {item_type}s from temp to main profiles"
+                )
+            else:
+                self.logger.info(
+                    f"ForceResetTempProfiles: No {item_type}s found using temp profiles"
+                )
+
+        except Exception as e:
+            self.logger.error(f"Error during temp profile reset: {e}", exc_info=True)
+
+    def _check_temp_profile_timeouts(self):
+        """Check for items with temp profiles that have exceeded the timeout and reset them."""
+        if self.temp_profile_timeout_minutes == 0:
+            return  # Feature disabled
+
+        from datetime import timedelta
+
+        timeout_threshold = datetime.now() - timedelta(minutes=self.temp_profile_timeout_minutes)
+        reset_count = 0
+
+        try:
+            # Query database for items with expired temp profiles
+            db1, db2, db3, db4, db5 = self._get_models()
+
+            # Determine which model to use
+            if self._name.lower().startswith("radarr"):
+                model = self.movies_file_model
+                item_type = "movie"
+            elif self._name.lower().startswith("sonarr") or self._name.lower().startswith(
+                "animarr"
+            ):
+                model = self.model_file  # episodes
+                item_type = "episode"
+            elif self._name.lower().startswith("lidarr"):
+                model = self.artists_file_model
+                item_type = "artist"
+            else:
+                return
+
+            # Find items with temp profiles that have exceeded timeout
+            expired_items = model.select().where(
+                (model.LastProfileSwitchTime.is_null(False))
+                & (model.LastProfileSwitchTime < timeout_threshold)
+                & (model.CurrentProfileId.is_null(False))
+                & (model.OriginalProfileId.is_null(False))
+            )
+
+            for db_item in expired_items:
+                entry_id = db_item.EntryId
+                current_profile = db_item.CurrentProfileId
+                original_profile = db_item.OriginalProfileId
+
+                # Verify current profile is still a temp profile in our mappings
+                if current_profile not in self.main_quality_profile_ids.keys():
+                    # Not a temp profile anymore, clear tracking
+                    model.update(
+                        LastProfileSwitchTime=None, CurrentProfileId=None, OriginalProfileId=None
+                    ).where(model.EntryId == entry_id).execute()
+                    continue
+
+                # Reset to original profile via Arr API
+                try:
+                    if item_type == "movie":
+                        item = self.client.get_movie(entry_id)
+                        item["qualityProfileId"] = original_profile
+                        self.client.upd_movie(item)
+                    elif item_type == "episode":
+                        # For episodes, we need to update the series
+                        series_id = db_item.SeriesId
+                        series = self.client.get_series(series_id)
+                        series["qualityProfileId"] = original_profile
+                        self.client.upd_series(series)
+                    elif item_type == "artist":
+                        artist = self.client.get_artist(entry_id)
+                        artist["qualityProfileId"] = original_profile
+                        self.client.upd_artist(artist)
+
+                    # Clear tracking fields in database
+                    model.update(
+                        LastProfileSwitchTime=None, CurrentProfileId=None, OriginalProfileId=None
+                    ).where(model.EntryId == entry_id).execute()
+
+                    reset_count += 1
+                    self.logger.info(
+                        f"Timeout reset: {item_type} ID {entry_id} from temp profile (ID:{current_profile}) "
+                        f"to main profile (ID:{original_profile}) after {self.temp_profile_timeout_minutes} minutes"
+                    )
+
+                except Exception as e:
+                    self.logger.error(
+                        f"Failed to reset {item_type} ID {entry_id} after timeout: {e}"
+                    )
+
+            if reset_count > 0:
+                self.logger.info(
+                    f"TempProfileTimeout: Reset {reset_count} {item_type}s from temp to main profiles"
+                )
+
+        except Exception as e:
+            self.logger.error(f"Error checking temp profile timeouts: {e}", exc_info=True)
+
     def register_search_mode(self):
         if self.search_setup_completed:
             return
@@ -6501,6 +6967,18 @@ class Arr:
 
     def run_search_loop(self) -> NoReturn:
         run_logs(self.logger)
+        self.logger.info(
+            "Search loop starting for %s (SearchMissing=%s, DoUpgradeSearch=%s, "
+            "QualityUnmetSearch=%s, CustomFormatUnmetSearch=%s, "
+            "Overseerr=%s, Ombi=%s)",
+            self._name,
+            self.search_missing,
+            self.do_upgrade_search,
+            self.quality_unmet_search,
+            self.custom_format_unmet_search,
+            self.overseerr_requests,
+            self.ombi_search_requests,
+        )
         try:
             if not (
                 self.search_missing
@@ -6517,6 +6995,7 @@ class Arr:
             totcommands = -1
             self.db_update_processed = False
             event = self.manager.qbit_manager.shutdown_event
+            self.logger.info("Search loop initialized successfully, entering main loop")
             while not event.is_set():
                 if self.loop_completed:
                     years_index = 0
@@ -6535,7 +7014,13 @@ class Arr:
                     self.db_maybe_reset_entry_searched_state()
                     self.refresh_download_queue()
                     self.db_update()
-                    # self.run_request_search()
+
+                    # Check for expired temp profiles if feature is enabled
+                    if self.use_temp_for_missing and self.temp_profile_timeout_minutes > 0:
+                        self._check_temp_profile_timeouts()
+
+                    # Check for new Overseerr/Ombi requests and trigger searches
+                    self.run_request_search()
                     try:
                         if self.search_by_year:
                             if years.index(self.search_current_year) != years_count - 1:
@@ -6658,6 +7143,16 @@ class Arr:
         except KeyboardInterrupt:
             self.logger.hnotice("Detected Ctrl+C - Terminating process")
             sys.exit(0)
+        except Exception as e:
+            self.logger.critical(
+                "Search loop crashed unexpectedly for %s: %s",
+                self._name,
+                e,
+                exc_info=True,
+            )
+            raise
+        finally:
+            self.logger.warning("Search loop terminated for %s", self._name)
 
     def run_torrent_loop(self) -> NoReturn:
         run_logs(self.logger)
@@ -7050,7 +7545,7 @@ class FreeSpaceManager(Arr):
         )
         self.pause.add(torrent.hash)
 
-    def _process_single_torrent(self, torrent):
+    def _process_single_torrent(self, torrent, instance_name: str = "default"):
         if self.is_downloading_state(torrent):
             free_space_test = self.current_free_space
             free_space_test -= torrent["amount_left"]
@@ -7069,8 +7564,8 @@ class FreeSpaceManager(Arr):
                     format_bytes(torrent.amount_left),
                     format_bytes(-free_space_test),
                 )
-                self.add_tags(torrent, ["qBitrr-free_space_paused"])
-                self.remove_tags(torrent, ["qBitrr-allowed_seeding"])
+                self.add_tags(torrent, ["qBitrr-free_space_paused"], instance_name)
+                self.remove_tags(torrent, ["qBitrr-allowed_seeding"], instance_name)
                 self._process_single_torrent_pause_disk_space(torrent)
             elif torrent.state_enum == TorrentStates.PAUSED_DOWNLOAD and free_space_test < 0:
                 self.logger.info(
@@ -7080,8 +7575,8 @@ class FreeSpaceManager(Arr):
                     format_bytes(torrent.amount_left),
                     format_bytes(-free_space_test),
                 )
-                self.add_tags(torrent, ["qBitrr-free_space_paused"])
-                self.remove_tags(torrent, ["qBitrr-allowed_seeding"])
+                self.add_tags(torrent, ["qBitrr-free_space_paused"], instance_name)
+                self.remove_tags(torrent, ["qBitrr-allowed_seeding"], instance_name)
             elif torrent.state_enum != TorrentStates.PAUSED_DOWNLOAD and free_space_test > 0:
                 self.logger.info(
                     "Continuing download (sufficient space) | Torrent: %s | Available: %s | Space after: %s",
@@ -7090,7 +7585,7 @@ class FreeSpaceManager(Arr):
                     format_bytes(free_space_test + self._min_free_space_bytes),
                 )
                 self.current_free_space = free_space_test
-                self.remove_tags(torrent, ["qBitrr-free_space_paused"])
+                self.remove_tags(torrent, ["qBitrr-free_space_paused"], instance_name)
             elif torrent.state_enum == TorrentStates.PAUSED_DOWNLOAD and free_space_test > 0:
                 self.logger.info(
                     "Resuming download (space available) | Torrent: %s | Available: %s | Space after: %s",
@@ -7099,16 +7594,16 @@ class FreeSpaceManager(Arr):
                     format_bytes(free_space_test + self._min_free_space_bytes),
                 )
                 self.current_free_space = free_space_test
-                self.remove_tags(torrent, ["qBitrr-free_space_paused"])
+                self.remove_tags(torrent, ["qBitrr-free_space_paused"], instance_name)
         elif not self.is_downloading_state(torrent) and self.in_tags(
-            torrent, "qBitrr-free_space_paused"
+            torrent, "qBitrr-free_space_paused", instance_name
         ):
             self.logger.info(
                 "Torrent completed, removing free space tag | Torrent: %s | Available: %s",
                 torrent.name,
                 format_bytes(self.current_free_space + self._min_free_space_bytes),
             )
-            self.remove_tags(torrent, ["qBitrr-free_space_paused"])
+            self.remove_tags(torrent, ["qBitrr-free_space_paused"], instance_name)
 
     def process(self):
         self._process_paused()
@@ -7138,7 +7633,7 @@ class FreeSpaceManager(Arr):
                 torrents = [t for t in torrents if "qBitrr-ignored" not in t.tags]
                 self.category_torrent_count = len(torrents)
                 self.free_space_tagged_count = sum(
-                    1 for t in torrents if self.in_tags(t, "qBitrr-free_space_paused")
+                    1 for t in torrents if self.in_tags(t, "qBitrr-free_space_paused", "default")
                 )
                 if not len(torrents):
                     raise DelayLoopException(length=LOOP_SLEEP_TIMER, type="no_downloads")