qBitrr2 4.10.15__py3-none-any.whl → 5.4.5__py3-none-any.whl

qBitrr/arss.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import atexit
 import contextlib
 import itertools
 import logging
@@ -19,9 +20,9 @@ import qbittorrentapi
 import qbittorrentapi.exceptions
 import requests
 from packaging import version as version_parser
-from peewee import SqliteDatabase
-from pyarr import RadarrAPI, SonarrAPI
-from pyarr.exceptions import PyarrResourceNotFound
+from peewee import Model, SqliteDatabase
+from pyarr import LidarrAPI, RadarrAPI, SonarrAPI
+from pyarr.exceptions import PyarrResourceNotFound, PyarrServerError
 from pyarr.types import JsonObject
 from qbittorrentapi import TorrentDictionary, TorrentStates
 from ujson import JSONDecodeError
@@ -31,7 +32,6 @@ from qBitrr.config import (
     AUTO_PAUSE_RESUME,
     COMPLETED_DOWNLOAD_FOLDER,
     CONFIG,
-    ENABLE_LOGS,
     FAILED_CATEGORY,
     FREE_SPACE,
     FREE_SPACE_FOLDER,
@@ -51,9 +51,16 @@ from qBitrr.errors import (
     SkipException,
     UnhandledError,
 )
-from qBitrr.home_path import HOME_PATH
 from qBitrr.logger import run_logs
+from qBitrr.search_activity_store import (
+    clear_search_activity,
+    fetch_search_activities,
+    record_search_activity,
+)
 from qBitrr.tables import (
+    AlbumFilesModel,
+    AlbumQueueModel,
+    ArtistFilesModel,
     EpisodeFilesModel,
     EpisodeQueueModel,
     FilesQueued,
@@ -61,22 +68,65 @@ from qBitrr.tables import (
     MoviesFilesModel,
     SeriesFilesModel,
     TorrentLibrary,
+    TrackFilesModel,
 )
 from qBitrr.utils import (
     ExpiringSet,
     absolute_file_paths,
+    format_bytes,
     has_internet,
     parse_size,
     validate_and_return_torrent_file,
+    with_retry,
 )
 
+
+def _mask_secret(secret: str | None) -> str:
+    if not secret:
+        return ""
+    return "[redacted]"
+
+
+def _normalize_media_status(value: int | str | None) -> str:
+    """Normalise Overseerr media status values across API versions."""
+    int_mapping = {
+        1: "UNKNOWN",
+        2: "PENDING",
+        3: "PROCESSING",
+        4: "PARTIALLY_AVAILABLE",
+        5: "AVAILABLE",
+        6: "DELETED",
+    }
+    if value is None:
+        return "UNKNOWN"
+    if isinstance(value, str):
+        token = value.strip().upper().replace("-", "_").replace(" ", "_")
+        # Newer Overseerr builds can return strings such as "PARTIALLY_AVAILABLE"
+        return token or "UNKNOWN"
+    try:
+        return int_mapping.get(int(value), "UNKNOWN")
+    except (TypeError, ValueError):
+        return "UNKNOWN"
+
+
+def _is_media_available(status: str) -> bool:
+    return status in {"AVAILABLE", "DELETED"}
+
+
+def _is_media_processing(status: str) -> bool:
+    return status in {"PROCESSING", "PARTIALLY_AVAILABLE"}
+
+
 if TYPE_CHECKING:
     from qBitrr.main import qBitManager
 
 
 class Arr:
     def __init__(
-        self, name: str, manager: ArrManager, client_cls: type[Callable | RadarrAPI | SonarrAPI]
+        self,
+        name: str,
+        manager: ArrManager,
+        client_cls: type[Callable | RadarrAPI | SonarrAPI | LidarrAPI],
     ):
         if name in manager.groups:
             raise OSError(f"Group '{name}' has already been registered.")
@@ -94,19 +144,7 @@ class Arr:
         self.manager = manager
         self._LOG_LEVEL = self.manager.qbit_manager.logger.level
         self.logger = logging.getLogger(f"qBitrr.{self._name}")
-        if ENABLE_LOGS:
-            logs_folder = HOME_PATH.joinpath("logs")
-            logs_folder.mkdir(parents=True, exist_ok=True)
-            logs_folder.chmod(mode=0o777)
-            logfile = logs_folder.joinpath(self._name + ".log")
-            if pathlib.Path(logfile).is_file():
-                logold = logs_folder.joinpath(self._name + ".log.old")
-                if pathlib.Path(logold).exists():
-                    logold.unlink()
-                logfile.rename(logold)
-            fh = logging.FileHandler(logfile)
-            self.logger.addHandler(fh)
-        run_logs(self.logger)
+        run_logs(self.logger, self._name)
 
         if not QBIT_DISABLED:
             categories = self.manager.qbit_manager.client.torrent_categories.categories
@@ -191,19 +229,33 @@ class Arr:
         self.seeding_mode_global_bad_tracker_msg = CONFIG.get(
             f"{name}.Torrent.SeedingMode.RemoveTrackerWithMessage", fallback=[]
         )
+        if isinstance(self.seeding_mode_global_bad_tracker_msg, str):
+            self.seeding_mode_global_bad_tracker_msg = [self.seeding_mode_global_bad_tracker_msg]
+        else:
+            self.seeding_mode_global_bad_tracker_msg = list(
+                self.seeding_mode_global_bad_tracker_msg
+            )
 
         self.monitored_trackers = CONFIG.get(f"{name}.Torrent.Trackers", fallback=[])
         self._remove_trackers_if_exists: set[str] = {
-            i.get("URI") for i in self.monitored_trackers if i.get("RemoveIfExists") is True
+            uri
+            for i in self.monitored_trackers
+            if i.get("RemoveIfExists") is True and (uri := (i.get("URI") or "").strip())
         }
         self._monitored_tracker_urls: set[str] = {
-            r
+            uri
             for i in self.monitored_trackers
-            if not (r := i.get("URI")) not in self._remove_trackers_if_exists
+            if (uri := (i.get("URI") or "").strip()) and uri not in self._remove_trackers_if_exists
         }
         self._add_trackers_if_missing: set[str] = {
-            i.get("URI") for i in self.monitored_trackers if i.get("AddTrackerIfMissing") is True
+            uri
+            for i in self.monitored_trackers
+            if i.get("AddTrackerIfMissing") is True and (uri := (i.get("URI") or "").strip())
         }
+        self._normalized_bad_tracker_msgs: set[str] = {
+            msg.lower() for msg in self.seeding_mode_global_bad_tracker_msg if isinstance(msg, str)
+        }
+
         if (
             self.auto_delete is True
             and not self.completed_folder.parent.exists()
@@ -250,7 +302,7 @@ class Arr:
 
         self.do_not_remove_slow = CONFIG.get(f"{name}.Torrent.DoNotRemoveSlow", fallback=False)
         self.re_search_stalled = CONFIG.get(f"{name}.Torrent.ReSearchStalled", fallback=False)
-        self.stalled_delay = CONFIG.get(f"{name}.Torrent.StalledDelay", fallback=0)
+        self.stalled_delay = CONFIG.get(f"{name}.Torrent.StalledDelay", fallback=15)
         self.allowed_stalled = True if self.stalled_delay != -1 else False
 
         self.search_current_year = None
@@ -258,6 +310,7 @@ class Arr:
             self._delta = 1
         else:
             self._delta = -1
+
         self._app_data_folder = APPDATA_FOLDER
         self.search_db_file = self._app_data_folder.joinpath(f"{self._name}.db")
 
@@ -267,7 +320,14 @@ class Arr:
         self.overseerr_requests = CONFIG.get(
             f"{name}.EntrySearch.Overseerr.SearchOverseerrRequests", fallback=False
         )
-        self.series_search = CONFIG.get(f"{name}.EntrySearch.SearchBySeries", fallback=False)
+        # SearchBySeries can be: True (always series), False (always episode), or "smart" (automatic)
+        series_search_config = CONFIG.get(f"{name}.EntrySearch.SearchBySeries", fallback=False)
+        if isinstance(series_search_config, str) and series_search_config.lower() == "smart":
+            self.series_search = "smart"
+        elif series_search_config in (True, "true", "True", "TRUE", 1):
+            self.series_search = True
+        else:
+            self.series_search = False
         if self.ombi_search_requests:
             self.ombi_uri = CONFIG.get_or_raise(f"{name}.EntrySearch.Ombi.OmbiURI")
             self.ombi_api_key = CONFIG.get_or_raise(f"{name}.EntrySearch.Ombi.OmbiAPIKey")
@@ -339,6 +399,18 @@ class Arr:
             self.type = "sonarr"
         elif isinstance(self.client, RadarrAPI):
             self.type = "radarr"
+        elif isinstance(self.client, LidarrAPI):
+            self.type = "lidarr"
+
+        # Disable unsupported features for Lidarr
+        if self.type == "lidarr":
+            self.search_by_year = False
+            self.ombi_search_requests = False
+            self.overseerr_requests = False
+            self.ombi_uri = None
+            self.ombi_api_key = None
+            self.overseerr_uri = None
+            self.overseerr_api_key = None
 
         try:
             version_info = self.client.get_update()
@@ -368,6 +440,10 @@ class Arr:
         if self.use_temp_for_missing:
             self.temp_quality_profile_ids = self.parse_quality_profiles()
 
+        # Cache for valid quality profile IDs to avoid repeated API calls and warnings
+        self._quality_profile_cache: dict[int, dict] = {}
+        self._invalid_quality_profiles: set[int] = set()
+
         if self.rss_sync_timer > 0:
             self.rss_sync_timer_last_checked = datetime(1970, 1, 1)
         else:
@@ -399,7 +475,12 @@ class Arr:
         self.missing_files_post_delete = set()
         self.downloads_with_bad_error_message_blocklist = set()
         self.needs_cleanup = False
-        self.recently_queue = {}
+
+        self.last_search_description: str | None = None
+        self.last_search_timestamp: str | None = None
+        self.queue_active_count: int = 0
+        self.category_torrent_count: int = 0
+        self.free_space_tagged_count: int = 0
 
         self.timed_ignore_cache = ExpiringSet(max_age_seconds=self.ignore_torrents_younger_than)
         self.timed_ignore_cache_2 = ExpiringSet(
@@ -413,6 +494,7 @@ class Arr:
         self.cleaned_torrents = set()
         self.search_api_command = None
 
+        self._webui_db_loaded = False
         self.manager.completed_folders.add(self.completed_folder)
         self.manager.category_allowlist.add(self.category)
 
@@ -432,7 +514,7 @@ class Arr:
             self.re_search,
             self.category,
             self.uri,
-            self.apikey,
+            _mask_secret(self.apikey),
             self.refresh_downloads_timer,
             self.rss_sync_timer,
         )
@@ -478,24 +560,34 @@ class Arr:
             self.logger.debug("Script Config:  SearchOmbiRequests=%s", self.ombi_search_requests)
             if self.ombi_search_requests:
                 self.logger.debug("Script Config:  OmbiURI=%s", self.ombi_uri)
-                self.logger.debug("Script Config:  OmbiAPIKey=%s", self.ombi_api_key)
+                self.logger.debug("Script Config:  OmbiAPIKey=%s", _mask_secret(self.ombi_api_key))
                 self.logger.debug("Script Config:  ApprovedOnly=%s", self.ombi_approved_only)
             self.logger.debug(
                 "Script Config:  SearchOverseerrRequests=%s", self.overseerr_requests
             )
             if self.overseerr_requests:
                 self.logger.debug("Script Config:  OverseerrURI=%s", self.overseerr_uri)
-                self.logger.debug("Script Config:  OverseerrAPIKey=%s", self.overseerr_api_key)
+                self.logger.debug(
+                    "Script Config:  OverseerrAPIKey=%s", _mask_secret(self.overseerr_api_key)
+                )
             if self.ombi_search_requests or self.overseerr_requests:
                 self.logger.debug(
                     "Script Config:  SearchRequestsEvery=%s", self.search_requests_every_x_seconds
                 )
 
-            if self.type == "sonarr":
-                if self.quality_unmet_search or self.do_upgrade_search:
-                    self.search_api_command = "SeriesSearch"
-                else:
-                    self.search_api_command = "MissingEpisodeSearch"
+        if self.type == "sonarr":
+            if (
+                self.quality_unmet_search
+                or self.do_upgrade_search
+                or self.custom_format_unmet_search
+                or self.series_search == True
+            ):
+                self.search_api_command = "SeriesSearch"
+            elif self.series_search == "smart":
+                # In smart mode, the command will be determined dynamically
+                self.search_api_command = "SeriesSearch"  # Default, will be overridden per search
+            else:
+                self.search_api_command = "MissingEpisodeSearch"
 
         if not QBIT_DISABLED and not TAGLESS:
             self.manager.qbit_manager.client.torrents_create_tags(
@@ -509,13 +601,83 @@ class Arr:
         elif not QBIT_DISABLED and TAGLESS:
             self.manager.qbit_manager.client.torrents_create_tags(["qBitrr-ignored"])
         self.search_setup_completed = False
-        self.model_file: EpisodeFilesModel | MoviesFilesModel = None
-        self.series_file_model: SeriesFilesModel = None
-        self.model_queue: EpisodeQueueModel | MovieQueueModel = None
-        self.persistent_queue: FilesQueued = None
-        self.torrents: TorrentLibrary = None
+        self.model_file: Model | None = None
+        self.series_file_model: Model | None = None
+        self.model_queue: Model | None = None
+        self.persistent_queue: Model | None = None
+        self.track_file_model: Model | None = None
+        self.torrents: TorrentLibrary | None = None
+        self.torrent_db: SqliteDatabase | None = None
+        self.db: SqliteDatabase | None = None
+        # Initialize search mode (and torrent tag-emulation DB in TAGLESS)
+        # early and fail fast if it cannot be set up.
+        self.register_search_mode()
+        atexit.register(
+            lambda: (
+                hasattr(self, "db") and self.db and not self.db.is_closed() and self.db.close()
+            )
+        )
+        atexit.register(
+            lambda: (
+                hasattr(self, "torrent_db")
+                and self.torrent_db
+                and not self.torrent_db.is_closed()
+                and self.torrent_db.close()
+            )
+        )
         self.logger.hnotice("Starting %s monitor", self._name)
 
+    @staticmethod
+    def _humanize_request_tag(tag: str) -> str | None:
+        if not tag:
+            return None
+        cleaned = tag.strip().strip(": ")
+        cleaned = cleaned.strip("[]")
+        upper = cleaned.upper()
+        if "OVERSEERR" in upper:
+            return "Overseerr request"
+        if "OMBI" in upper:
+            return "Ombi request"
+        if "PRIORITY SEARCH - TODAY" in upper:
+            return "Today's releases"
+        return cleaned or None
+
+    def _record_search_activity(
+        self,
+        description: str | None,
+        *,
+        context: str | None = None,
+        detail: str | None = None,
+    ) -> None:
+        self.last_search_description = description
+        self.last_search_timestamp = datetime.now(timezone.utc).isoformat()
+        if detail == "loop-complete":
+            detail = "Searches completed, waiting till next loop"
+        elif detail == "no-pending-searches":
+            detail = "No pending searches"
+            self.last_search_description = None if description is None else description
+        segments = [
+            segment for segment in (context, self.last_search_description, detail) if segment
+        ]
+        if segments and segments.count("No pending searches") > 1:
+            seen = set()
+            deduped = []
+            for segment in segments:
+                key = segment.strip().lower()
+                if key == "no pending searches" and key in seen:
+                    continue
+                seen.add(key)
+                deduped.append(segment)
+            segments = deduped
+        if not segments:
+            return
+        self.last_search_description = " · ".join(segments)
+        record_search_activity(
+            str(self.category),
+            self.last_search_description,
+            self.last_search_timestamp,
+        )
+
     @property
     def is_alive(self) -> bool:
         try:
@@ -580,17 +742,29 @@ class Arr:
             if tag == "qBitrr-ignored":
                 return_value = "qBitrr-ignored" in torrent.tags
             else:
-                condition = (
-                    self.torrents.Hash == torrent.hash & self.torrents.Category == torrent.category
+                query = (
+                    self.torrents.select()
+                    .where(
+                        (self.torrents.Hash == torrent.hash)
+                        & (self.torrents.Category == torrent.category)
+                    )
+                    .execute()
+                )
+                if not query:
+                    self.torrents.insert(
+                        Hash=torrent.hash, Category=torrent.category
+                    ).on_conflict_ignore().execute()
+                condition = (self.torrents.Hash == torrent.hash) & (
+                    self.torrents.Category == torrent.category
                 )
                 if tag == "qBitrr-allowed_seeding":
-                    condition &= self.torrents.AllowedSeeding is True
+                    condition &= self.torrents.AllowedSeeding == True
                 elif tag == "qBitrr-imported":
-                    condition &= self.torrents.Imported is True
+                    condition &= self.torrents.Imported == True
                 elif tag == "qBitrr-allowed_stalled":
-                    condition &= self.torrents.AllowedStalled is True
+                    condition &= self.torrents.AllowedStalled == True
                 elif tag == "qBitrr-free_space_paused":
-                    condition &= self.torrents.FreeSpacePaused is True
+                    condition &= self.torrents.FreeSpacePaused == True
                 query = self.torrents.select().where(condition).execute()
                 if query:
                     return_value = True
@@ -612,13 +786,13 @@ class Arr:
     def remove_tags(self, torrent: TorrentDictionary, tags: list) -> None:
         for tag in tags:
             self.logger.trace("Removing tag %s from %s", tag, torrent.name)
-            if TAGLESS:
+        if TAGLESS:
+            for tag in tags:
                 query = (
                     self.torrents.select()
                     .where(
-                        self.torrents.Hash
-                        == torrent.hash & self.torrents.Category
-                        == torrent.category
+                        (self.torrents.Hash == torrent.hash)
+                        & (self.torrents.Category == torrent.category)
                     )
                     .execute()
                 )
@@ -628,48 +802,48 @@ class Arr:
                     ).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.Hash == torrent.hash)
+                        & (self.torrents.Category == torrent.category)
+                    ).execute()
                 elif tag == "qBitrr-imported":
                     self.torrents.update(Imported=False).where(
-                        self.torrents.Hash
-                        == torrent.hash & self.torrents.Category
-                        == torrent.category
-                    )
+                        (self.torrents.Hash == torrent.hash)
+                        & (self.torrents.Category == torrent.category)
+                    ).execute()
                 elif tag == "qBitrr-allowed_stalled":
                     self.torrents.update(AllowedStalled=False).where(
-                        self.torrents.Hash
-                        == torrent.hash & self.torrents.Category
-                        == torrent.category
-                    )
+                        (self.torrents.Hash == torrent.hash)
+                        & (self.torrents.Category == torrent.category)
+                    ).execute()
                 elif tag == "qBitrr-free_space_paused":
                     self.torrents.update(FreeSpacePaused=False).where(
-                        self.torrents.Hash
-                        == torrent.hash & self.torrents.Category
-                        == torrent.category
-                    )
-            else:
-                if tag == "qBitrr-allowed_seeding":
-                    torrent.remove_tags(["qBitrr-allowed_seeding"])
-                elif tag == "qBitrr-imported":
-                    torrent.remove_tags(["qBitrr-imported"])
-                elif tag == "qBitrr-allowed_stalled":
-                    torrent.remove_tags(["qBitrr-allowed_stalled"])
-                elif tag == "qBitrr-free_space_paused":
-                    torrent.remove_tags(["qBitrr-free_space_paused"])
+                        (self.torrents.Hash == torrent.hash)
+                        & (self.torrents.Category == torrent.category)
+                    ).execute()
+        else:
+            with contextlib.suppress(Exception):
+                with_retry(
+                    lambda: torrent.remove_tags(tags),
+                    retries=3,
+                    backoff=0.5,
+                    max_backoff=3,
+                    exceptions=(
+                        qbittorrentapi.exceptions.APIError,
+                        qbittorrentapi.exceptions.APIConnectionError,
+                        requests.exceptions.RequestException,
+                    ),
+                )
 
     def add_tags(self, torrent: TorrentDictionary, tags: list) -> None:
         for tag in tags:
             self.logger.trace("Adding tag %s from %s", tag, torrent.name)
-            if TAGLESS:
+        if TAGLESS:
+            for tag in tags:
                 query = (
                     self.torrents.select()
                     .where(
-                        self.torrents.Hash
-                        == torrent.hash & self.torrents.Category
-                        == torrent.category
+                        (self.torrents.Hash == torrent.hash)
+                        & (self.torrents.Category == torrent.category)
                     )
                     .execute()
                 )
@@ -679,137 +853,138 @@ class Arr:
                     ).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.Hash == torrent.hash)
+                        & (self.torrents.Category == torrent.category)
+                    ).execute()
                 elif tag == "qBitrr-imported":
                     self.torrents.update(Imported=True).where(
-                        self.torrents.Hash
-                        == torrent.hash & self.torrents.Category
-                        == torrent.category
-                    )
+                        (self.torrents.Hash == torrent.hash)
+                        & (self.torrents.Category == torrent.category)
+                    ).execute()
                 elif tag == "qBitrr-allowed_stalled":
                     self.torrents.update(AllowedStalled=True).where(
-                        self.torrents.Hash
-                        == torrent.hash & self.torrents.Category
-                        == torrent.category
-                    )
+                        (self.torrents.Hash == torrent.hash)
+                        & (self.torrents.Category == torrent.category)
+                    ).execute()
                 elif tag == "qBitrr-free_space_paused":
                     self.torrents.update(FreeSpacePaused=True).where(
-                        self.torrents.Hash
-                        == torrent.hash & self.torrents.Category
-                        == torrent.category
-                    )
-            else:
-                if tag == "qBitrr-allowed_seeding":
-                    torrent.add_tags(["qBitrr-allowed_seeding"])
-                elif tag == "qBitrr-imported":
-                    torrent.add_tags(["qBitrr-imported"])
-                elif tag == "qBitrr-allowed_stalled":
-                    torrent.add_tags(["qBitrr-allowed_stalled"])
-                elif tag == "qBitrr-free_space_paused":
-                    torrent.add_tags(["qBitrr-free_space_paused"])
-
-    def _get_models(
-        self,
-    ) -> tuple[
-        type[EpisodeFilesModel] | type[MoviesFilesModel],
-        type[EpisodeQueueModel] | type[MovieQueueModel],
-        type[SeriesFilesModel] | None,
-        type[TorrentLibrary] | None,
-    ]:
-        if self.type == "sonarr":
-            if self.series_search:
-                return (
-                    EpisodeFilesModel,
-                    EpisodeQueueModel,
-                    SeriesFilesModel,
-                    TorrentLibrary if TAGLESS else None,
-                )
-            return EpisodeFilesModel, EpisodeQueueModel, None, TorrentLibrary if TAGLESS else None
-        elif self.type == "radarr":
-            return MoviesFilesModel, MovieQueueModel, None, TorrentLibrary if TAGLESS else None
+                        (self.torrents.Hash == torrent.hash)
+                        & (self.torrents.Category == torrent.category)
+                    ).execute()
         else:
-            raise UnhandledError(f"Well you shouldn't have reached here, Arr.type={self.type}")
+            with contextlib.suppress(Exception):
+                with_retry(
+                    lambda: torrent.add_tags(tags),
+                    retries=3,
+                    backoff=0.5,
+                    max_backoff=3,
+                    exceptions=(
+                        qbittorrentapi.exceptions.APIError,
+                        qbittorrentapi.exceptions.APIConnectionError,
+                        requests.exceptions.RequestException,
+                    ),
+                )
 
     def _get_oversee_requests_all(self) -> dict[str, set]:
         try:
-            key = "approved" if self.overseerr_approved_only else "unavailable"
             data = defaultdict(set)
-            response = self.session.get(
-                url=f"{self.overseerr_uri}/api/v1/request",
-                headers={"X-Api-Key": self.overseerr_api_key},
-                params={"take": 100, "skip": 0, "sort": "added", "filter": key},
-                timeout=2,
-            )
-            response = response.json().get("results", [])
+            key = "approved" if self.overseerr_approved_only else "unavailable"
+            take = 100
+            skip = 0
             type_ = None
             if self.type == "radarr":
                 type_ = "movie"
             elif self.type == "sonarr":
                 type_ = "tv"
             _now = datetime.now()
-            for entry in response:
-                type__ = entry.get("type")
-                if type__ == "movie":
-                    id__ = entry.get("media", {}).get("tmdbId")
-                elif type__ == "tv":
-                    id__ = entry.get("media", {}).get("tvdbId")
-                if type_ != type__:
-                    continue
-                if self.overseerr_is_4k and entry.get("is4k"):
-                    if self.overseerr_approved_only:
-                        if entry.get("media", {}).get("status4k") != 3:
+            while True:
+                response = self.session.get(
+                    url=f"{self.overseerr_uri}/api/v1/request",
+                    headers={"X-Api-Key": self.overseerr_api_key},
+                    params={"take": take, "skip": skip, "sort": "added", "filter": key},
+                    timeout=5,
+                )
+                response.raise_for_status()
+                payload = response.json()
+                results = []
+                if isinstance(payload, list):
+                    results = payload
+                elif isinstance(payload, dict):
+                    if isinstance(payload.get("results"), list):
+                        results = payload["results"]
+                    elif isinstance(payload.get("data"), list):
+                        results = payload["data"]
+                if not results:
+                    break
+                for entry in results:
+                    type__ = entry.get("type")
+                    if type__ == "movie":
+                        id__ = entry.get("media", {}).get("tmdbId")
+                    elif type__ == "tv":
+                        id__ = entry.get("media", {}).get("tvdbId")
+                    else:
+                        id__ = None
+                    if not id__ or type_ != type__:
+                        continue
+                    media = entry.get("media") or {}
+                    status_key = "status4k" if entry.get("is4k") else "status"
+                    status_value = _normalize_media_status(media.get(status_key))
+                    if entry.get("is4k"):
+                        if not self.overseerr_is_4k:
                             continue
-                    elif entry.get("media", {}).get("status4k") == 5:
+                    elif self.overseerr_is_4k:
                         continue
-                elif not self.overseerr_is_4k and not entry.get("is4k"):
                     if self.overseerr_approved_only:
-                        if entry.get("media", {}).get("status") != 3:
+                        if not _is_media_processing(status_value):
                             continue
-                    elif entry.get("media", {}).get("status") == 5:
-                        continue
-                else:
-                    continue
-                if id__ in self.overseerr_requests_release_cache:
-                    date = self.overseerr_requests_release_cache[id__]
-                else:
-                    date = datetime(day=1, month=1, year=1970)
-                    date_string_backup = f"{_now.year}-{_now.month:02}-{_now.day:02}"
-                    date_string = None
-                    try:
-                        if type_ == "movie":
-                            _entry_data = self.session.get(
-                                url=f"{self.overseerr_uri}/api/v1/movies/{id__}",
-                                headers={"X-Api-Key": self.overseerr_api_key},
-                                timeout=2,
-                            )
-                            date_string = _entry_data.json().get("releaseDate")
-                        elif type__ == "tv":
-                            _entry_data = self.session.get(
-                                url=f"{self.overseerr_uri}/api/v1/tv/{id__}",
-                                headers={"X-Api-Key": self.overseerr_api_key},
-                                timeout=2,
-                            )
-                            # We don't do granular (episode/season) searched here so no need to
-                            # suppose them
-                            date_string = _entry_data.json().get("firstAirDate")
-                        if not date_string:
-                            date_string = date_string_backup
-                        date = datetime.strptime(date_string, "%Y-%m-%d")
-                        if date > _now:
+                    else:
+                        if _is_media_available(status_value):
                             continue
-                        self.overseerr_requests_release_cache[id__] = date
-                    except Exception as e:
-                        self.logger.warning("Failed to query release date from Overseerr: %s", e)
-                if media := entry.get("media"):
-                    if imdbId := media.get("imdbId"):
-                        data["ImdbId"].add(imdbId)
-                    if self.type == "sonarr" and (tvdbId := media.get("tvdbId")):
-                        data["TvdbId"].add(tvdbId)
-                    elif self.type == "radarr" and (tmdbId := media.get("tmdbId")):
-                        data["TmdbId"].add(tmdbId)
+                    if id__ in self.overseerr_requests_release_cache:
+                        date = self.overseerr_requests_release_cache[id__]
+                    else:
+                        date = datetime(day=1, month=1, year=1970)
+                        date_string_backup = f"{_now.year}-{_now.month:02}-{_now.day:02}"
+                        date_string = None
+                        try:
+                            if type_ == "movie":
+                                _entry = self.session.get(
+                                    url=f"{self.overseerr_uri}/api/v1/movies/{id__}",
+                                    headers={"X-Api-Key": self.overseerr_api_key},
+                                    timeout=5,
+                                )
+                                _entry.raise_for_status()
+                                date_string = _entry.json().get("releaseDate")
+                            elif type__ == "tv":
+                                _entry = self.session.get(
+                                    url=f"{self.overseerr_uri}/api/v1/tv/{id__}",
+                                    headers={"X-Api-Key": self.overseerr_api_key},
+                                    timeout=5,
+                                )
+                                _entry.raise_for_status()
+                                # We don't do granular (episode/season) searched here so no need to
+                                # suppose them
+                                date_string = _entry.json().get("firstAirDate")
+                            if not date_string:
+                                date_string = date_string_backup
+                            date = datetime.strptime(date_string[:10], "%Y-%m-%d")
+                            if date > _now:
+                                continue
+                            self.overseerr_requests_release_cache[id__] = date
+                        except Exception as e:
+                            self.logger.warning(
+                                "Failed to query release date from Overseerr: %s", e
+                            )
+                    if media:
+                        if imdbId := media.get("imdbId"):
+                            data["ImdbId"].add(imdbId)
+                        if self.type == "sonarr" and (tvdbId := media.get("tvdbId")):
+                            data["TvdbId"].add(tvdbId)
+                        elif self.type == "radarr" and (tmdbId := media.get("tmdbId")):
+                            data["TmdbId"].add(tmdbId)
+                if len(results) < take:
+                    break
+                skip += take
             self._temp_overseer_request_cache = data
         except requests.exceptions.ConnectionError:
             self.logger.warning("Couldn't connect to Overseerr")
@@ -847,15 +1022,24 @@ class Arr:
             extras = "/api/v1/Request/movie/total"
         else:
             raise UnhandledError(f"Well you shouldn't have reached here, Arr.type={self.type}")
+        total = 0
         try:
             response = self.session.get(
-                url=f"{self.ombi_uri}{extras}", headers={"ApiKey": self.ombi_api_key}
+                url=f"{self.ombi_uri}{extras}", headers={"ApiKey": self.ombi_api_key}, timeout=5
             )
+            response.raise_for_status()
+            payload = response.json()
+            if isinstance(payload, dict):
+                for key in ("total", "count", "totalCount", "totalRecords", "pending", "value"):
+                    value = payload.get(key)
+                    if isinstance(value, int):
+                        total = value
+                        break
+            elif isinstance(payload, list):
+                total = len(payload)
         except Exception as e:
             self.logger.exception(e, exc_info=sys.exc_info())
-            return 0
-        else:
-            return response.json()
+        return total
 
     def _get_ombi_requests(self) -> list[dict]:
         if self.type == "sonarr":
@@ -866,9 +1050,18 @@ class Arr:
             raise UnhandledError(f"Well you shouldn't have reached here, Arr.type={self.type}")
         try:
             response = self.session.get(
-                url=f"{self.ombi_uri}{extras}", headers={"ApiKey": self.ombi_api_key}
+                url=f"{self.ombi_uri}{extras}", headers={"ApiKey": self.ombi_api_key}, timeout=5
             )
-            return response.json()
+            response.raise_for_status()
+            payload = response.json()
+            if isinstance(payload, list):
+                return payload
+            if isinstance(payload, dict):
+                for key in ("result", "results", "requests", "data", "items"):
+                    value = payload.get(key)
+                    if isinstance(value, list):
+                        return value
+            return []
         except Exception as e:
             self.logger.exception(e, exc_info=sys.exc_info())
             return []
@@ -900,7 +1093,18 @@ class Arr:
                 self.logger.debug(
                     "Pausing %s (%s)", i, self.manager.qbit_manager.name_cache.get(i)
                 )
-            self.manager.qbit.torrents_pause(torrent_hashes=self.pause)
+            with contextlib.suppress(Exception):
+                with_retry(
+                    lambda: self.manager.qbit.torrents_pause(torrent_hashes=self.pause),
+                    retries=3,
+                    backoff=0.5,
+                    max_backoff=3,
+                    exceptions=(
+                        qbittorrentapi.exceptions.APIError,
+                        qbittorrentapi.exceptions.APIConnectionError,
+                        requests.exceptions.RequestException,
+                    ),
+                )
             self.pause.clear()
 
     def _process_imports(self) -> None:
@@ -925,41 +1129,65 @@ class Arr:
                 self.sent_to_scan_hashes.add(torrent.hash)
                 try:
                     if self.type == "sonarr":
-                        while True:
-                            try:
-                                self.client.post_command(
-                                    "DownloadedEpisodesScan",
-                                    path=str(path),
-                                    downloadClientId=torrent.hash.upper(),
-                                    importMode=self.import_mode,
-                                )
-                                break
-                            except (
+                        with_retry(
+                            lambda: self.client.post_command(
+                                "DownloadedEpisodesScan",
+                                path=str(path),
+                                downloadClientId=torrent.hash.upper(),
+                                importMode=self.import_mode,
+                            ),
+                            retries=3,
+                            backoff=0.5,
+                            max_backoff=3,
+                            exceptions=(
                                 requests.exceptions.ChunkedEncodingError,
                                 requests.exceptions.ContentDecodingError,
                                 requests.exceptions.ConnectionError,
                                 JSONDecodeError,
-                            ):
-                                continue
+                                requests.exceptions.RequestException,
+                            ),
+                        )
                         self.logger.success("DownloadedEpisodesScan: %s", path)
                     elif self.type == "radarr":
-                        while True:
-                            try:
-                                self.client.post_command(
-                                    "DownloadedMoviesScan",
-                                    path=str(path),
-                                    downloadClientId=torrent.hash.upper(),
-                                    importMode=self.import_mode,
-                                )
-                                break
-                            except (
+                        with_retry(
+                            lambda: self.client.post_command(
+                                "DownloadedMoviesScan",
+                                path=str(path),
+                                downloadClientId=torrent.hash.upper(),
+                                importMode=self.import_mode,
+                            ),
+                            retries=3,
+                            backoff=0.5,
+                            max_backoff=3,
+                            exceptions=(
                                 requests.exceptions.ChunkedEncodingError,
                                 requests.exceptions.ContentDecodingError,
                                 requests.exceptions.ConnectionError,
                                 JSONDecodeError,
-                            ):
-                                continue
+                                requests.exceptions.RequestException,
+                            ),
+                        )
                         self.logger.success("DownloadedMoviesScan: %s", path)
+                    elif self.type == "lidarr":
+                        with_retry(
+                            lambda: self.client.post_command(
+                                "DownloadedAlbumsScan",
+                                path=str(path),
+                                downloadClientId=torrent.hash.upper(),
+                                importMode=self.import_mode,
+                            ),
+                            retries=3,
+                            backoff=0.5,
+                            max_backoff=3,
+                            exceptions=(
+                                requests.exceptions.ChunkedEncodingError,
+                                requests.exceptions.ContentDecodingError,
+                                requests.exceptions.ConnectionError,
+                                JSONDecodeError,
+                                requests.exceptions.RequestException,
+                            ),
+                        )
+                        self.logger.success("DownloadedAlbumsScan: %s", path)
                 except Exception as ex:
                     self.logger.error(
                         "Downloaded scan error: [%s][%s][%s][%s]",
@@ -990,8 +1218,6 @@ class Arr:
             self.delete_from_queue(
                 id_=entry, remove_from_client=remove_from_client, blacklist=False
             )
-        if hash_ in self.recently_queue:
-            del self.recently_queue[hash_]
         object_id = self.requeue_cache.get(entry)
         if self.re_search and object_id:
             if self.type == "sonarr":
@@ -1141,6 +1367,48 @@ class Arr:
                         continue
                 if self.persistent_queue:
                     self.persistent_queue.insert(EntryId=object_id).on_conflict_ignore()
+            elif self.type == "lidarr":
+                self.logger.trace("Requeue cache entry: %s", object_id)
+                while True:
+                    try:
+                        data = self.client.get_album(object_id)
+                        name = data.get("title")
+                        if name:
+                            artist_title = data.get("artist", {}).get("artistName", "")
+                            foreign_album_id = data.get("foreignAlbumId", "")
+                            self.logger.notice(
+                                "Re-Searching album: %s - %s | [foreignAlbumId=%s|id=%s]",
+                                artist_title,
+                                name,
+                                foreign_album_id,
+                                object_id,
+                            )
+                        else:
+                            self.logger.notice("Re-Searching album: %s", object_id)
+                        break
+                    except (
+                        requests.exceptions.ChunkedEncodingError,
+                        requests.exceptions.ContentDecodingError,
+                        requests.exceptions.ConnectionError,
+                        JSONDecodeError,
+                        AttributeError,
+                    ):
+                        continue
+                if object_id in self.queue_file_ids:
+                    self.queue_file_ids.remove(object_id)
+                while True:
+                    try:
+                        self.client.post_command("AlbumSearch", albumIds=[object_id])
+                        break
+                    except (
+                        requests.exceptions.ChunkedEncodingError,
+                        requests.exceptions.ContentDecodingError,
+                        requests.exceptions.ConnectionError,
+                        JSONDecodeError,
+                    ):
+                        continue
+                if self.persistent_queue:
+                    self.persistent_queue.insert(EntryId=object_id).on_conflict_ignore()
 
     def _process_errored(self) -> None:
         # Recheck all torrents marked for rechecking.
@@ -1158,10 +1426,6 @@ class Arr:
         to_delete_all = self.delete.union(
             self.missing_files_post_delete, self.downloads_with_bad_error_message_blocklist
         )
-        if self.missing_files_post_delete or self.downloads_with_bad_error_message_blocklist:
-            delete_ = True
-        else:
-            delete_ = False
         skip_blacklist = {
             i.upper() for i in self.skip_blacklist.union(self.missing_files_post_delete)
         }
@@ -1190,7 +1454,7 @@ class Arr:
                     del self.manager.qbit_manager.name_cache[h]
                 if h in self.manager.qbit_manager.cache:
                     del self.manager.qbit_manager.cache[h]
-        if delete_:
+        if self.missing_files_post_delete or self.downloads_with_bad_error_message_blocklist:
             self.missing_files_post_delete.clear()
             self.downloads_with_bad_error_message_blocklist.clear()
         self.skip_blacklist.clear()
@@ -1247,17 +1511,19 @@ class Arr:
             self.rss_sync_timer_last_checked is not None
             and self.rss_sync_timer_last_checked < now - timedelta(minutes=self.rss_sync_timer)
         ):
-            while True:
-                try:
-                    self.client.post_command("RssSync")
-                    break
-                except (
+            with_retry(
+                lambda: self.client.post_command("RssSync"),
+                retries=3,
+                backoff=0.5,
+                max_backoff=3,
+                exceptions=(
                     requests.exceptions.ChunkedEncodingError,
                     requests.exceptions.ContentDecodingError,
                     requests.exceptions.ConnectionError,
                     JSONDecodeError,
-                ):
-                    continue
+                    requests.exceptions.RequestException,
+                ),
+            )
             self.rss_sync_timer_last_checked = now
 
         if (
@@ -1265,22 +1531,24 @@ class Arr:
             and self.refresh_downloads_timer_last_checked
             < now - timedelta(minutes=self.refresh_downloads_timer)
         ):
-            while True:
-                try:
-                    self.client.post_command("RefreshMonitoredDownloads")
-                    break
-                except (
+            with_retry(
+                lambda: self.client.post_command("RefreshMonitoredDownloads"),
+                retries=3,
+                backoff=0.5,
+                max_backoff=3,
+                exceptions=(
                     requests.exceptions.ChunkedEncodingError,
                     requests.exceptions.ContentDecodingError,
                     requests.exceptions.ConnectionError,
                     JSONDecodeError,
-                ):
-                    continue
+                    requests.exceptions.RequestException,
+                ),
+            )
             self.refresh_downloads_timer_last_checked = now
 
     def arr_db_query_commands_count(self) -> int:
         search_commands = 0
-        if not self.search_missing:
+        if not (self.search_missing or self.do_upgrade_search):
             return 0
         while True:
             try:
@@ -1324,11 +1592,55 @@ class Arr:
     ) -> Iterable[
         tuple[MoviesFilesModel | EpisodeFilesModel | SeriesFilesModel, bool, bool, bool, int]
     ]:
-        if self.type == "sonarr" and self.series_search:
+        if self.type == "sonarr" and self.series_search == True:
             serieslist = self.db_get_files_series()
             for series in serieslist:
                 yield series[0], series[1], series[2], series[2] is not True, len(serieslist)
-        elif self.type == "sonarr" and not self.series_search:
+        elif self.type == "sonarr" and self.series_search == "smart":
+            # Smart mode: decide dynamically based on what needs to be searched
+            episodelist = self.db_get_files_episodes()
+            if episodelist:
+                # Group episodes by series to determine if we should search by series or episode
+                series_episodes_map = {}
+                for episode_entry in episodelist:
+                    episode = episode_entry[0]
+                    series_id = episode.SeriesId
+                    if series_id not in series_episodes_map:
+                        series_episodes_map[series_id] = []
+                    series_episodes_map[series_id].append(episode_entry)
+
+                # Process each series
+                for series_id, episodes in series_episodes_map.items():
+                    if len(episodes) > 1:
+                        # Multiple episodes from same series - use series search (smart decision)
+                        self.logger.info(
+                            "[SMART MODE] Using series search for %s episodes from series ID %s",
+                            len(episodes),
+                            series_id,
+                        )
+                        # Create a series entry for searching
+                        series_model = (
+                            self.series_file_model.select()
+                            .where(self.series_file_model.EntryId == series_id)
+                            .first()
+                        )
+                        if series_model:
+                            yield series_model, episodes[0][1], episodes[0][2], True, len(
+                                episodelist
+                            )
+                    else:
+                        # Single episode - use episode search (smart decision)
+                        episode = episodes[0][0]
+                        self.logger.info(
+                            "[SMART MODE] Using episode search for single episode: %s S%02dE%03d",
+                            episode.SeriesTitle,
+                            episode.SeasonNumber,
+                            episode.EpisodeNumber,
+                        )
+                        yield episodes[0][0], episodes[0][1], episodes[0][2], False, len(
+                            episodelist
+                        )
+        elif self.type == "sonarr" and self.series_search == False:
             episodelist = self.db_get_files_episodes()
             for episodes in episodelist:
                 yield episodes[0], episodes[1], episodes[2], False, len(episodelist)
@@ -1336,6 +1648,10 @@ class Arr:
             movielist = self.db_get_files_movies()
             for movies in movielist:
                 yield movies[0], movies[1], movies[2], False, len(movielist)
+        elif self.type == "lidarr":
+            albumlist = self.db_get_files_movies()  # This calls the lidarr section we added
+            for albums in albumlist:
+                yield albums[0], albums[1], albums[2], False, len(albumlist)
 
     def db_maybe_reset_entry_searched_state(self):
         if self.type == "sonarr":
@@ -1343,6 +1659,8 @@ class Arr:
             self.db_reset__episode_searched_state()
         elif self.type == "radarr":
             self.db_reset__movie_searched_state()
+        elif self.type == "lidarr":
+            self.db_reset__album_searched_state()
         self.loop_completed = False
 
     def db_reset__series_searched_state(self):
@@ -1353,7 +1671,7 @@ class Arr:
             self.loop_completed and self.reset_on_completion and self.series_search
         ):  # Only wipe if a loop completed was tagged
             self.series_file_model.update(Searched=False, Upgrade=False).where(
-                self.series_file_model.Searched is True
+                self.series_file_model.Searched == True
             ).execute()
             while True:
                 try:
@@ -1380,7 +1698,7 @@ class Arr:
             self.loop_completed is True and self.reset_on_completion
         ):  # Only wipe if a loop completed was tagged
             self.model_file.update(Searched=False, Upgrade=False).where(
-                self.model_file.Searched is True
+                self.model_file.Searched == True
             ).execute()
             while True:
                 try:
@@ -1407,7 +1725,7 @@ class Arr:
             self.loop_completed is True and self.reset_on_completion
         ):  # Only wipe if a loop completed was tagged
             self.model_file.update(Searched=False, Upgrade=False).where(
-                self.model_file.Searched is True
+                self.model_file.Searched == True
             ).execute()
             while True:
                 try:
@@ -1425,9 +1743,36 @@ class Arr:
             self.model_file.delete().where(self.model_file.EntryId.not_in(ids)).execute()
             self.loop_completed = False
 
+    def db_reset__album_searched_state(self):
+        ids = []
+        self.model_file: AlbumFilesModel
+        if (
+            self.loop_completed is True and self.reset_on_completion
+        ):  # Only wipe if a loop completed was tagged
+            self.model_file.update(Searched=False, Upgrade=False).where(
+                self.model_file.Searched == True
+            ).execute()
+            while True:
+                try:
+                    artists = self.client.get_artist()
+                    for artist in artists:
+                        albums = self.client.get_album(artistId=artist["id"])
+                        for album in albums:
+                            ids.append(album["id"])
+                    break
+                except (
+                    requests.exceptions.ChunkedEncodingError,
+                    requests.exceptions.ContentDecodingError,
+                    requests.exceptions.ConnectionError,
+                    JSONDecodeError,
+                ):
+                    continue
+            self.model_file.delete().where(self.model_file.EntryId.not_in(ids)).execute()
+            self.loop_completed = False
+
     def db_get_files_series(self) -> list[list[SeriesFilesModel, bool, bool]] | None:
         entries = []
-        if not self.search_missing:
+        if not (self.search_missing or self.do_upgrade_search):
             return None
         elif not self.series_search:
             return None
@@ -1439,21 +1784,18 @@ class Arr:
                 condition &= self.model_file.Upgrade == False
             else:
                 if self.quality_unmet_search and not self.custom_format_unmet_search:
-                    condition &= (
-                        self.model_file.Searched == False | self.model_file.QualityMet == False
+                    condition &= (self.model_file.Searched == False) | (
+                        self.model_file.QualityMet == False
                     )
                 elif not self.quality_unmet_search and self.custom_format_unmet_search:
-                    condition &= (
-                        self.model_file.Searched
-                        == False | self.model_file.CustomFormatMet
-                        == False
+                    condition &= (self.model_file.Searched == False) | (
+                        self.model_file.CustomFormatMet == False
                     )
                 elif self.quality_unmet_search and self.custom_format_unmet_search:
                     condition &= (
-                        self.model_file.Searched
-                        == False | self.model_file.QualityMet
-                        == False | self.model_file.CustomFormatMet
-                        == False
+                        (self.model_file.Searched == False)
+                        | (self.model_file.QualityMet == False)
+                        | (self.model_file.CustomFormatMet == False)
                     )
                 else:
                     condition &= self.model_file.EpisodeFileId == 0
@@ -1496,7 +1838,7 @@ class Arr:
 
     def db_get_files_episodes(self) -> list[list[EpisodeFilesModel, bool, bool]] | None:
         entries = []
-        if not self.search_missing:
+        if not (self.search_missing or self.do_upgrade_search):
             return None
         elif self.type == "sonarr":
             condition = self.model_file.AirDateUtc.is_null(False)
@@ -1506,21 +1848,18 @@ class Arr:
                 condition &= self.model_file.Upgrade == False
             else:
                 if self.quality_unmet_search and not self.custom_format_unmet_search:
-                    condition &= (
-                        self.model_file.Searched == False | self.model_file.QualityMet == False
+                    condition &= (self.model_file.Searched == False) | (
+                        self.model_file.QualityMet == False
                     )
                 elif not self.quality_unmet_search and self.custom_format_unmet_search:
-                    condition &= (
-                        self.model_file.Searched
-                        == False | self.model_file.CustomFormatMet
-                        == False
+                    condition &= (self.model_file.Searched == False) | (
+                        self.model_file.CustomFormatMet == False
                     )
                 elif self.quality_unmet_search and self.custom_format_unmet_search:
                     condition &= (
-                        self.model_file.Searched
-                        == False | self.model_file.QualityMet
-                        == False | self.model_file.CustomFormatMet
-                        == False
+                        (self.model_file.Searched == False)
+                        | (self.model_file.QualityMet == False)
+                        | (self.model_file.CustomFormatMet == False)
                     )
                 else:
                     condition &= self.model_file.EpisodeFileId == 0
@@ -1564,7 +1903,7 @@ class Arr:
 
     def db_get_files_movies(self) -> list[list[MoviesFilesModel, bool, bool]] | None:
         entries = []
-        if not self.search_missing:
+        if not (self.search_missing or self.do_upgrade_search):
             return None
         if self.type == "radarr":
             condition = self.model_file.Year.is_null(False)
@@ -1572,21 +1911,18 @@ class Arr:
                 condition &= self.model_file.Upgrade == False
             else:
                 if self.quality_unmet_search and not self.custom_format_unmet_search:
-                    condition &= (
-                        self.model_file.Searched == False | self.model_file.QualityMet == False
+                    condition &= (self.model_file.Searched == False) | (
+                        self.model_file.QualityMet == False
                     )
                 elif not self.quality_unmet_search and self.custom_format_unmet_search:
-                    condition &= (
-                        self.model_file.Searched
-                        == False | self.model_file.CustomFormatMet
-                        == False
+                    condition &= (self.model_file.Searched == False) | (
+                        self.model_file.CustomFormatMet == False
                     )
                 elif self.quality_unmet_search and self.custom_format_unmet_search:
                     condition &= (
-                        self.model_file.Searched
-                        == False | self.model_file.QualityMet
-                        == False | self.model_file.CustomFormatMet
-                        == False
+                        (self.model_file.Searched == False)
+                        | (self.model_file.QualityMet == False)
+                        | (self.model_file.CustomFormatMet == False)
                     )
                 else:
                     condition &= self.model_file.MovieFileId == 0
@@ -1601,24 +1937,54 @@ class Arr:
             ):
                 entries.append([entry, False, False])
             return entries
-
-    def db_get_request_files(self) -> Iterable[tuple[MoviesFilesModel | EpisodeFilesModel, int]]:
-        entries = []
-        self.logger.trace("Getting request files")
-        if self.type == "sonarr":
-            condition = self.model_file.IsRequest == True
-            condition &= self.model_file.AirDateUtc.is_null(False)
-            condition &= self.model_file.EpisodeFileId == 0
-            condition &= self.model_file.Searched == False
-            condition &= self.model_file.AirDateUtc < (
-                datetime.now(timezone.utc) - timedelta(days=1)
-            )
-            entries = list(
-                self.model_file.select()
-                .where(condition)
-                .order_by(
-                    self.model_file.SeriesTitle,
-                    self.model_file.SeasonNumber.desc(),
+        elif self.type == "lidarr":
+            condition = True  # Placeholder, will be refined
+            if self.do_upgrade_search:
+                condition &= self.model_file.Upgrade == False
+            else:
+                if self.quality_unmet_search and not self.custom_format_unmet_search:
+                    condition &= (self.model_file.Searched == False) | (
+                        self.model_file.QualityMet == False
+                    )
+                elif not self.quality_unmet_search and self.custom_format_unmet_search:
+                    condition &= (self.model_file.Searched == False) | (
+                        self.model_file.CustomFormatMet == False
+                    )
+                elif self.quality_unmet_search and self.custom_format_unmet_search:
+                    condition &= (
+                        (self.model_file.Searched == False)
+                        | (self.model_file.QualityMet == False)
+                        | (self.model_file.CustomFormatMet == False)
+                    )
+                else:
+                    condition &= self.model_file.AlbumFileId == 0
+                    condition &= self.model_file.Searched == False
+            for entry in (
+                self.model_file.select()
+                .where(condition)
+                .order_by(self.model_file.AlbumFileId.asc())
+                .execute()
+            ):
+                entries.append([entry, False, False])
+            return entries
+
+    def db_get_request_files(self) -> Iterable[tuple[MoviesFilesModel | EpisodeFilesModel, int]]:
+        entries = []
+        self.logger.trace("Getting request files")
+        if self.type == "sonarr":
+            condition = self.model_file.IsRequest == True
+            condition &= self.model_file.AirDateUtc.is_null(False)
+            condition &= self.model_file.EpisodeFileId == 0
+            condition &= self.model_file.Searched == False
+            condition &= self.model_file.AirDateUtc < (
+                datetime.now(timezone.utc) - timedelta(days=1)
+            )
+            entries = list(
+                self.model_file.select()
+                .where(condition)
+                .order_by(
+                    self.model_file.SeriesTitle,
+                    self.model_file.SeasonNumber.desc(),
                     self.model_file.AirDateUtc.desc(),
                 )
                 .execute()
@@ -1781,17 +2147,28 @@ class Arr:
                 self.logger.debug("No episode releases found for today")
 
     def db_update(self):
-        if not self.search_missing:
-            return
-        self.db_update_todays_releases()
-        if self.db_update_processed and not self.search_by_year:
+        if not (
+            self.search_missing
+            or self.do_upgrade_search
+            or self.quality_unmet_search
+            or self.custom_format_unmet_search
+        ):
             return
-        if self.search_by_year:
-            self.logger.info("Started updating database for %s", self.search_current_year)
-        else:
+        placeholder_summary = "Updating database"
+        placeholder_set = False
+        try:
+            self._webui_db_loaded = False
+            try:
+                self._record_search_activity(placeholder_summary)
+                placeholder_set = True
+            except Exception:
+                pass
+            self.db_update_todays_releases()
+            if self.db_update_processed:
+                return
             self.logger.info("Started updating database")
-        if self.type == "sonarr":
-            if not self.series_search:
+            if self.type == "sonarr":
+                # Always fetch series list for both episode and series-level tracking
                 while True:
                     try:
                         series = self.client.get_series()
@@ -1803,62 +2180,35 @@ class Arr:
                         JSONDecodeError,
                     ):
                         continue
-                if self.search_by_year:
-                    for s in series:
-                        if isinstance(s, str):
-                            continue
-                        episodes = self.client.get_episode(s["id"], True)
-                        for e in episodes:
-                            if isinstance(e, str):
-                                continue
-                            if "airDateUtc" in e:
-                                if datetime.strptime(
-                                    e["airDateUtc"], "%Y-%m-%dT%H:%M:%SZ"
-                                ).replace(tzinfo=timezone.utc) > datetime.now(timezone.utc):
-                                    continue
-                                if (
-                                    datetime.strptime(e["airDateUtc"], "%Y-%m-%dT%H:%M:%SZ")
-                                    .replace(tzinfo=timezone.utc)
-                                    .date()
-                                    < datetime(
-                                        month=1, day=1, year=int(self.search_current_year)
-                                    ).date()
-                                ):
-                                    continue
-                                if (
-                                    datetime.strptime(e["airDateUtc"], "%Y-%m-%dT%H:%M:%SZ")
-                                    .replace(tzinfo=timezone.utc)
-                                    .date()
-                                    > datetime(
-                                        month=12, day=31, year=int(self.search_current_year)
-                                    ).date()
-                                ):
-                                    continue
-                                if not self.search_specials and e["seasonNumber"] == 0:
-                                    continue
-                                self.db_update_single_series(db_entry=e)
 
-                else:
-                    for s in series:
-                        if isinstance(s, str):
+                # Process episodes for episode-level tracking (all episodes)
+                for s in series:
+                    if isinstance(s, str):
+                        continue
+                    episodes = self.client.get_episode(s["id"], True)
+                    for e in episodes:
+                        if isinstance(e, str):
                             continue
-                        episodes = self.client.get_episode(s["id"], True)
-                        for e in episodes:
-                            if isinstance(e, str):
+                        if "airDateUtc" in e:
+                            if datetime.strptime(e["airDateUtc"], "%Y-%m-%dT%H:%M:%SZ").replace(
+                                tzinfo=timezone.utc
+                            ) > datetime.now(timezone.utc):
                                 continue
-                            if "airDateUtc" in e:
-                                if datetime.strptime(
-                                    e["airDateUtc"], "%Y-%m-%dT%H:%M:%SZ"
-                                ).replace(tzinfo=timezone.utc) > datetime.now(timezone.utc):
-                                    continue
-                                if not self.search_specials and e["seasonNumber"] == 0:
-                                    continue
-                                self.db_update_single_series(db_entry=e)
+                            if not self.search_specials and e["seasonNumber"] == 0:
+                                continue
+                            self.db_update_single_series(db_entry=e, series=False)
+
+                # Process series for series-level tracking (all series)
+                for s in series:
+                    if isinstance(s, str):
+                        continue
+                    self.db_update_single_series(db_entry=s, series=True)
+
                 self.db_update_processed = True
-            else:
+            elif self.type == "radarr":
                 while True:
                     try:
-                        series = self.client.get_series()
+                        movies = self.client.get_movie()
                         break
                     except (
                         requests.exceptions.ChunkedEncodingError,
@@ -1867,49 +2217,70 @@ class Arr:
                         JSONDecodeError,
                     ):
                         continue
-                if self.search_by_year:
-                    for s in series:
-                        if isinstance(s, str):
-                            continue
-                        if s["year"] < self.search_current_year:
-                            continue
-                        if s["year"] > self.search_current_year:
-                            continue
-                        self.db_update_single_series(db_entry=s, series=True)
-                else:
-                    for s in series:
-                        if isinstance(s, str):
-                            continue
-                        self.db_update_single_series(db_entry=s, series=True)
-                self.db_update_processed = True
-        elif self.type == "radarr":
-            while True:
-                try:
-                    movies = self.client.get_movie()
-                    break
-                except (
-                    requests.exceptions.ChunkedEncodingError,
-                    requests.exceptions.ContentDecodingError,
-                    requests.exceptions.ConnectionError,
-                    JSONDecodeError,
-                ):
-                    continue
-            if self.search_by_year:
+                # Process all movies
                 for m in movies:
                     if isinstance(m, str):
                         continue
-                    if m["year"] < self.search_current_year:
+                    self.db_update_single_series(db_entry=m)
+                self.db_update_processed = True
+            elif self.type == "lidarr":
+                while True:
+                    try:
+                        artists = self.client.get_artist()
+                        break
+                    except (
+                        requests.exceptions.ChunkedEncodingError,
+                        requests.exceptions.ContentDecodingError,
+                        requests.exceptions.ConnectionError,
+                        JSONDecodeError,
+                    ):
                         continue
-                    if m["year"] > self.search_current_year:
+                for artist in artists:
+                    if isinstance(artist, str):
                         continue
-                    self.db_update_single_series(db_entry=m)
-            else:
-                for m in movies:
-                    if isinstance(m, str):
+                    while True:
+                        try:
+                            # allArtistAlbums=True includes full album data with media/tracks
+                            albums = self.client.get_album(
+                                artistId=artist["id"], allArtistAlbums=True
+                            )
+                            break
+                        except (
+                            requests.exceptions.ChunkedEncodingError,
+                            requests.exceptions.ContentDecodingError,
+                            requests.exceptions.ConnectionError,
+                            JSONDecodeError,
+                        ):
+                            continue
+                    for album in albums:
+                        if isinstance(album, str):
+                            continue
+                        # For Lidarr, we don't have a specific releaseDate field
+                        # Check if album has been released
+                        if "releaseDate" in album:
+                            release_date = datetime.strptime(
+                                album["releaseDate"], "%Y-%m-%dT%H:%M:%SZ"
+                            )
+                            if release_date > datetime.now():
+                                continue
+                        self.db_update_single_series(db_entry=album)
+                # Process artists for artist-level tracking
+                for artist in artists:
+                    if isinstance(artist, str):
                         continue
-                    self.db_update_single_series(db_entry=m)
-            self.db_update_processed = True
-        self.logger.trace("Finished updating database")
+                    self.db_update_single_series(db_entry=artist, artist=True)
+                self.db_update_processed = True
+            self.logger.trace("Finished updating database")
+        finally:
+            if placeholder_set:
+                try:
+                    activities = fetch_search_activities()
+                    entry = activities.get(str(self.category))
+                    if entry and entry.get("summary") == placeholder_summary:
+                        clear_search_activity(str(self.category))
+                except Exception:
+                    pass
+            self._webui_db_loaded = True
 
     def minimum_availability_check(self, db_entry: JsonObject) -> bool:
         inCinemas = (
@@ -2144,9 +2515,18 @@ class Arr:
             return False
 
     def db_update_single_series(
-        self, db_entry: JsonObject = None, request: bool = False, series: bool = False
+        self,
+        db_entry: JsonObject = None,
+        request: bool = False,
+        series: bool = False,
+        artist: bool = False,
     ):
-        if not self.search_missing:
+        if not (
+            self.search_missing
+            or self.do_upgrade_search
+            or self.quality_unmet_search
+            or self.custom_format_unmet_search
+        ):
             return
         try:
             searched = False
@@ -2167,38 +2547,60 @@ class Arr:
                             JSONDecodeError,
                         ):
                             continue
-                    if episode["monitored"] or self.search_unmonitored:
+                    if episode.get("monitored", True) or self.search_unmonitored:
                         while True:
                             try:
-                                if episodeData:
-                                    if not episodeData.MinCustomFormatScore:
-                                        minCustomFormat = self.client.get_quality_profile(
-                                            episode["series"]["qualityProfileId"]
-                                        )["minFormatScore"]
-                                    else:
-                                        minCustomFormat = episodeData.MinCustomFormatScore
-                                    if episode["hasFile"]:
-                                        if (
-                                            episode["episodeFile"]["id"]
-                                            != episodeData.EpisodeFileId
-                                        ):
-                                            customFormat = self.client.get_episode_file(
-                                                episode["episodeFile"]["id"]
-                                            )["customFormatScore"]
-                                        else:
-                                            customFormat = 0
+                                series_info = episode.get("series") or {}
+                                if isinstance(series_info, dict):
+                                    quality_profile_id = series_info.get("qualityProfileId")
+                                else:
+                                    quality_profile_id = getattr(
+                                        series_info, "qualityProfileId", None
+                                    )
+                                if not quality_profile_id:
+                                    quality_profile_id = db_entry.get("qualityProfileId")
+                                minCustomFormat = (
+                                    getattr(episodeData, "MinCustomFormatScore", 0)
+                                    if episodeData
+                                    else 0
+                                )
+                                if not minCustomFormat:
+                                    if quality_profile_id:
+                                        profile = (
+                                            self.client.get_quality_profile(quality_profile_id)
+                                            or {}
+                                        )
+                                        minCustomFormat = profile.get("minFormatScore") or 0
                                     else:
-                                        customFormat = 0
+                                        self.logger.warning(
+                                            "Episode %s missing qualityProfileId; defaulting custom format threshold to 0",
+                                            episode.get("id"),
+                                        )
+                                        minCustomFormat = 0
+                                episode_file = episode.get("episodeFile") or {}
+                                if isinstance(episode_file, dict):
+                                    episode_file_id = episode_file.get("id")
                                 else:
-                                    minCustomFormat = self.client.get_quality_profile(
-                                        episode["series"]["qualityProfileId"]
-                                    )["minFormatScore"]
-                                    if episode["hasFile"]:
-                                        customFormat = self.client.get_episode_file(
-                                            episode["episodeFile"]["id"]
-                                        )["customFormatScore"]
+                                    episode_file_id = getattr(episode_file, "id", None)
+                                has_file = bool(episode.get("hasFile"))
+                                episode_data_file_id = (
+                                    getattr(episodeData, "EpisodeFileId", None)
+                                    if episodeData
+                                    else None
+                                )
+                                if has_file and episode_file_id:
+                                    if (
+                                        episode_data_file_id
+                                        and episode_file_id == episode_data_file_id
+                                    ):
+                                        customFormat = getattr(episodeData, "CustomFormatScore", 0)
                                     else:
-                                        customFormat = 0
+                                        file_info = (
+                                            self.client.get_episode_file(episode_file_id) or {}
+                                        )
+                                        customFormat = file_info.get("customFormatScore") or 0
+                                else:
+                                    customFormat = 0
                                 break
                             except (
                                 requests.exceptions.ChunkedEncodingError,
@@ -2207,9 +2609,6 @@ class Arr:
                                 JSONDecodeError,
                             ):
                                 continue
-                            except KeyError:
-                                self.logger.warning("Key Error [%s]", db_entry["id"])
-                                continue
 
                         QualityUnmet = (
                             episode["episodeFile"]["qualityCutoffNotMet"]
@@ -2229,72 +2628,60 @@ class Arr:
                             ).execute()
 
                         if self.use_temp_for_missing:
-                            try:
-                                self.logger.trace(
-                                    "Temp quality profile [%s][%s]",
-                                    searched,
-                                    db_entry["qualityProfileId"],
-                                )
-                                if (
-                                    searched
-                                    and db_entry["qualityProfileId"]
-                                    in self.temp_quality_profile_ids.values()
-                                    and not self.keep_temp_profile
-                                ):
-                                    data: JsonObject = {
-                                        "qualityProfileId": list(
-                                            self.temp_quality_profile_ids.keys()
-                                        )[
-                                            list(self.temp_quality_profile_ids.values()).index(
-                                                db_entry["qualityProfileId"]
-                                            )
-                                        ]
-                                    }
-                                    self.logger.debug(
-                                        "Upgrading quality profile for %s to %s",
-                                        db_entry["title"],
-                                        list(self.temp_quality_profile_ids.keys())[
-                                            list(self.temp_quality_profile_ids.values()).index(
-                                                db_entry["qualityProfileId"]
-                                            )
-                                        ],
-                                    )
-                                elif (
-                                    not searched
-                                    and db_entry["qualityProfileId"]
-                                    in self.temp_quality_profile_ids.keys()
-                                ):
-                                    data: JsonObject = {
-                                        "qualityProfileId": self.temp_quality_profile_ids[
-                                            db_entry["qualityProfileId"]
-                                        ]
-                                    }
-                                    self.logger.debug(
-                                        "Downgrading quality profile for %s to %s",
-                                        db_entry["title"],
-                                        self.temp_quality_profile_ids[
+                            data = None
+                            quality_profile_id = db_entry.get("qualityProfileId")
+                            self.logger.trace(
+                                "Temp quality profile [%s][%s]",
+                                searched,
+                                quality_profile_id,
+                            )
+                            if (
+                                searched
+                                and quality_profile_id in self.temp_quality_profile_ids.values()
+                                and not self.keep_temp_profile
+                            ):
+                                data: JsonObject = {
+                                    "qualityProfileId": list(self.temp_quality_profile_ids.keys())[
+                                        list(self.temp_quality_profile_ids.values()).index(
+                                            quality_profile_id
+                                        )
+                                    ]
+                                }
+                                self.logger.debug(
+                                    "Upgrading quality profile for %s to %s",
+                                    db_entry["title"],
+                                    list(self.temp_quality_profile_ids.keys())[
+                                        list(self.temp_quality_profile_ids.values()).index(
                                             db_entry["qualityProfileId"]
-                                        ],
-                                    )
-                            except KeyError:
-                                self.logger.warning(
-                                    "Check quality profile settings for %s", db_entry["title"]
+                                        )
+                                    ],
                                 )
-                            try:
-                                if data:
-                                    while True:
-                                        try:
-                                            self.client.upd_episode(episode["id"], data)
-                                            break
-                                        except (
-                                            requests.exceptions.ChunkedEncodingError,
-                                            requests.exceptions.ContentDecodingError,
-                                            requests.exceptions.ConnectionError,
-                                            JSONDecodeError,
-                                        ):
-                                            continue
-                            except UnboundLocalError:
-                                pass
+                            elif (
+                                not searched
+                                and quality_profile_id in self.temp_quality_profile_ids.keys()
+                            ):
+                                data: JsonObject = {
+                                    "qualityProfileId": self.temp_quality_profile_ids[
+                                        quality_profile_id
+                                    ]
+                                }
+                                self.logger.debug(
+                                    "Downgrading quality profile for %s to %s",
+                                    db_entry["title"],
+                                    self.temp_quality_profile_ids[quality_profile_id],
+                                )
+                            if data:
+                                while True:
+                                    try:
+                                        self.client.upd_episode(episode["id"], data)
+                                        break
+                                    except (
+                                        requests.exceptions.ChunkedEncodingError,
+                                        requests.exceptions.ContentDecodingError,
+                                        requests.exceptions.ConnectionError,
+                                        JSONDecodeError,
+                                    ):
+                                        continue
 
                         EntryId = episode["id"]
                         SeriesTitle = episode.get("series", {}).get("title")
@@ -2314,11 +2701,12 @@ class Arr:
                             else None
                         )
                         AirDateUtc = episode["airDateUtc"]
-                        Monitored = episode["monitored"]
+                        Monitored = episode.get("monitored", True)
                         QualityMet = not QualityUnmet if db_entry["hasFile"] else False
-                        customFormatMet = customFormat > minCustomFormat
+                        customFormatMet = customFormat >= minCustomFormat
 
                         if not episode["hasFile"]:
+                            # Episode is missing a file - always mark as Missing
                             reason = "Missing"
                         elif self.quality_unmet_search and QualityUnmet:
                             reason = "Quality"
@@ -2326,8 +2714,11 @@ class Arr:
                             reason = "CustomFormat"
                         elif self.do_upgrade_search:
                             reason = "Upgrade"
+                        elif searched:
+                            # Episode has file and search is complete
+                            reason = "Not being searched"
                         else:
-                            reason = None
+                            reason = "Not being searched"
 
                         to_update = {
                             self.model_file.Monitored: Monitored,
@@ -2393,17 +2784,39 @@ class Arr:
                 else:
                     self.series_file_model: SeriesFilesModel
                     EntryId = db_entry["id"]
-                    seriesData = self.model_file.get_or_none(self.model_file.EntryId == EntryId)
+                    seriesData = self.series_file_model.get_or_none(
+                        self.series_file_model.EntryId == EntryId
+                    )
                     if db_entry["monitored"] or self.search_unmonitored:
                         while True:
                             try:
-                                seriesMetadata = self.client.get_series(id_=EntryId)
+                                seriesMetadata = self.client.get_series(id_=EntryId) or {}
+                                quality_profile_id = None
+                                if isinstance(seriesMetadata, dict):
+                                    quality_profile_id = seriesMetadata.get("qualityProfileId")
+                                else:
+                                    quality_profile_id = getattr(
+                                        seriesMetadata, "qualityProfileId", None
+                                    )
                                 if not seriesData:
-                                    minCustomFormat = self.client.get_quality_profile(
-                                        seriesMetadata["qualityProfileId"]
-                                    )["minFormatScore"]
+                                    if quality_profile_id:
+                                        profile = (
+                                            self.client.get_quality_profile(quality_profile_id)
+                                            or {}
+                                        )
+                                        minCustomFormat = profile.get("minFormatScore") or 0
+                                    else:
+                                        self.logger.warning(
+                                            "Series %s (%s) missing qualityProfileId; "
+                                            "defaulting custom format score to 0",
+                                            db_entry.get("title"),
+                                            EntryId,
+                                        )
+                                        minCustomFormat = 0
                                 else:
-                                    minCustomFormat = seriesMetadata.MinCustomFormatScore
+                                    minCustomFormat = getattr(
+                                        seriesData, "MinCustomFormatScore", 0
+                                    )
                                 break
                             except (
                                 requests.exceptions.ChunkedEncodingError,
@@ -2412,11 +2825,6 @@ class Arr:
                                 JSONDecodeError,
                             ):
                                 continue
-                            except KeyError:
-                                self.logger.warning(
-                                    "Key Error [%s][%s]", db_entry["id"], seriesMetadata
-                                )
-                                continue
                         episodeCount = 0
                         episodeFileCount = 0
                         totalEpisodeCount = 0
@@ -2450,9 +2858,10 @@ class Arr:
                             searched = (episodeCount + monitoredEpisodeCount) == episodeFileCount
                         if self.use_temp_for_missing:
                             try:
+                                quality_profile_id = db_entry.get("qualityProfileId")
                                 if (
                                     searched
-                                    and db_entry["qualityProfileId"]
+                                    and quality_profile_id
                                     in self.temp_quality_profile_ids.values()
                                     and not self.keep_temp_profile
                                 ):
@@ -2460,7 +2869,7 @@ class Arr:
                                         self.temp_quality_profile_ids.keys()
                                     )[
                                         list(self.temp_quality_profile_ids.values()).index(
-                                            db_entry["qualityProfileId"]
+                                            quality_profile_id
                                         )
                                     ]
                                     self.logger.debug(
@@ -2470,11 +2879,10 @@ class Arr:
                                     )
                                 elif (
                                     not searched
-                                    and db_entry["qualityProfileId"]
-                                    in self.temp_quality_profile_ids.keys()
+                                    and quality_profile_id in self.temp_quality_profile_ids.keys()
                                 ):
                                     db_entry["qualityProfileId"] = self.temp_quality_profile_ids[
-                                        db_entry["qualityProfileId"]
+                                        quality_profile_id
                                     ]
                                     self.logger.debug(
                                         "Updating quality profile for %s to %s",
@@ -2528,6 +2936,9 @@ class Arr:
                             conflict_target=[self.series_file_model.EntryId], update=to_update
                         )
                         db_commands.execute()
+
+                        # Note: Episodes are now handled separately in db_update()
+                        # No need to recursively process episodes here to avoid duplication
                     else:
                         db_commands = self.series_file_model.delete().where(
                             self.series_file_model.EntryId == EntryId
@@ -2556,7 +2967,7 @@ class Arr:
                                             db_entry["movieFile"]["id"]
                                         )["customFormatScore"]
                                     else:
-                                        customFormat = 0
+                                        customFormat = movieData.CustomFormatScore
                                 else:
                                     customFormat = 0
                             else:
@@ -2575,14 +2986,11 @@ class Arr:
                             requests.exceptions.ContentDecodingError,
                             requests.exceptions.ConnectionError,
                             JSONDecodeError,
-                            KeyError,
                         ):
                             continue
-                        # except KeyError:
-                        #     self.logger.warning("Key Error [%s]", db_entry["id"])
                     QualityUnmet = (
-                        db_entry["episodeFile"]["qualityCutoffNotMet"]
-                        if "episodeFile" in db_entry
+                        db_entry["movieFile"]["qualityCutoffNotMet"]
+                        if "movieFile" in db_entry
                         else False
                     )
                     if (
@@ -2598,41 +3006,35 @@ class Arr:
                         ).execute()
 
                     if self.use_temp_for_missing:
-                        try:
-                            if (
-                                searched
-                                and db_entry["qualityProfileId"]
-                                in self.temp_quality_profile_ids.values()
-                                and not self.keep_temp_profile
-                            ):
-                                db_entry["qualityProfileId"] = list(
-                                    self.temp_quality_profile_ids.keys()
-                                )[
-                                    list(self.temp_quality_profile_ids.values()).index(
-                                        db_entry["qualityProfileId"]
-                                    )
-                                ]
-                                self.logger.debug(
-                                    "Updating quality profile for %s to %s",
-                                    db_entry["title"],
-                                    db_entry["qualityProfileId"],
-                                )
-                            elif (
-                                not searched
-                                and db_entry["qualityProfileId"]
-                                in self.temp_quality_profile_ids.keys()
-                            ):
-                                db_entry["qualityProfileId"] = self.temp_quality_profile_ids[
-                                    db_entry["qualityProfileId"]
-                                ]
-                                self.logger.debug(
-                                    "Updating quality profile for %s to %s",
-                                    db_entry["title"],
-                                    self.temp_quality_profile_ids[db_entry["qualityProfileId"]],
+                        quality_profile_id = db_entry.get("qualityProfileId")
+                        if (
+                            searched
+                            and quality_profile_id in self.temp_quality_profile_ids.values()
+                            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
                                 )
-                        except KeyError:
-                            self.logger.warning(
-                                "Check quality profile settings for %s", db_entry["title"]
+                            ]
+                            self.logger.debug(
+                                "Updating quality profile for %s to %s",
+                                db_entry["title"],
+                                db_entry["qualityProfileId"],
+                            )
+                        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
+                            ]
+                            self.logger.debug(
+                                "Updating quality profile for %s to %s",
+                                db_entry["title"],
+                                db_entry["qualityProfileId"],
                             )
                         while True:
                             try:
@@ -2653,9 +3055,10 @@ class Arr:
                     entryId = db_entry["id"]
                     movieFileId = db_entry["movieFileId"]
                     qualityMet = not QualityUnmet if db_entry["hasFile"] else False
-                    customFormatMet = customFormat > minCustomFormat
+                    customFormatMet = customFormat >= minCustomFormat
 
                     if not db_entry["hasFile"]:
+                        # Movie is missing a file - always mark as Missing
                         reason = "Missing"
                     elif self.quality_unmet_search and QualityUnmet:
                         reason = "Quality"
@@ -2663,8 +3066,11 @@ class Arr:
                         reason = "CustomFormat"
                     elif self.do_upgrade_search:
                         reason = "Upgrade"
+                    elif searched:
+                        # Movie has file and search is complete
+                        reason = "Not being searched"
                     else:
-                        reason = None
+                        reason = "Not being searched"
 
                     to_update = {
                         self.model_file.MovieFileId: movieFileId,
@@ -2712,10 +3118,472 @@ class Arr:
                         self.model_file.EntryId == db_entry["id"]
                     )
                     db_commands.execute()
-
-        except requests.exceptions.ConnectionError as e:
-            self.logger.debug(
-                "Max retries exceeded for %s [%s][%s]",
+            elif self.type == "lidarr":
+                if not artist:
+                    # Album handling
+                    self.model_file: AlbumFilesModel
+                    searched = False
+                    albumData = self.model_file.get_or_none(
+                        self.model_file.EntryId == db_entry["id"]
+                    )
+                    if db_entry["monitored"] or self.search_unmonitored:
+                        while True:
+                            try:
+                                if albumData:
+                                    if not albumData.MinCustomFormatScore:
+                                        try:
+                                            profile_id = db_entry["profileId"]
+                                            # Check if this profile ID is known to be invalid
+                                            if profile_id in self._invalid_quality_profiles:
+                                                minCustomFormat = 0
+                                            # Check cache first
+                                            elif profile_id in self._quality_profile_cache:
+                                                minCustomFormat = self._quality_profile_cache[
+                                                    profile_id
+                                                ].get("minFormatScore", 0)
+                                            else:
+                                                # Fetch from API and cache
+                                                try:
+                                                    profile = self.client.get_quality_profile(
+                                                        profile_id
+                                                    )
+                                                    self._quality_profile_cache[profile_id] = (
+                                                        profile
+                                                    )
+                                                    minCustomFormat = profile.get(
+                                                        "minFormatScore", 0
+                                                    )
+                                                except PyarrResourceNotFound:
+                                                    # Mark as invalid to avoid repeated warnings
+                                                    self._invalid_quality_profiles.add(profile_id)
+                                                    self.logger.warning(
+                                                        "Quality profile %s not found for album %s, defaulting to 0",
+                                                        db_entry.get("profileId"),
+                                                        db_entry.get("title", "Unknown"),
+                                                    )
+                                                    minCustomFormat = 0
+                                        except Exception:
+                                            minCustomFormat = 0
+                                    else:
+                                        minCustomFormat = albumData.MinCustomFormatScore
+                                    if (
+                                        db_entry.get("statistics", {}).get("percentOfTracks", 0)
+                                        == 100
+                                    ):
+                                        # Album has files
+                                        albumFileId = db_entry.get("statistics", {}).get(
+                                            "sizeOnDisk", 0
+                                        )
+                                        if albumFileId != albumData.AlbumFileId:
+                                            # Get custom format score from album files
+                                            customFormat = (
+                                                0  # Lidarr may not have customFormatScore
+                                            )
+                                        else:
+                                            customFormat = albumData.CustomFormatScore
+                                    else:
+                                        customFormat = 0
+                                else:
+                                    try:
+                                        profile_id = db_entry["profileId"]
+                                        # Check if this profile ID is known to be invalid
+                                        if profile_id in self._invalid_quality_profiles:
+                                            minCustomFormat = 0
+                                        # Check cache first
+                                        elif profile_id in self._quality_profile_cache:
+                                            minCustomFormat = self._quality_profile_cache[
+                                                profile_id
+                                            ].get("minFormatScore", 0)
+                                        else:
+                                            # Fetch from API and cache
+                                            try:
+                                                profile = self.client.get_quality_profile(
+                                                    profile_id
+                                                )
+                                                self._quality_profile_cache[profile_id] = profile
+                                                minCustomFormat = profile.get("minFormatScore", 0)
+                                            except PyarrResourceNotFound:
+                                                # Mark as invalid to avoid repeated warnings
+                                                self._invalid_quality_profiles.add(profile_id)
+                                                self.logger.warning(
+                                                    "Quality profile %s not found for album %s, defaulting to 0",
+                                                    db_entry.get("profileId"),
+                                                    db_entry.get("title", "Unknown"),
+                                                )
+                                                minCustomFormat = 0
+                                    except Exception:
+                                        minCustomFormat = 0
+                                    if (
+                                        db_entry.get("statistics", {}).get("percentOfTracks", 0)
+                                        == 100
+                                    ):
+                                        customFormat = 0  # Lidarr may not have customFormatScore
+                                    else:
+                                        customFormat = 0
+                                break
+                            except (
+                                requests.exceptions.ChunkedEncodingError,
+                                requests.exceptions.ContentDecodingError,
+                                requests.exceptions.ConnectionError,
+                                JSONDecodeError,
+                            ):
+                                continue
+
+                        # Determine if album has all tracks
+                        hasAllTracks = (
+                            db_entry.get("statistics", {}).get("percentOfTracks", 0) == 100
+                        )
+
+                        # Check if quality cutoff is met for Lidarr
+                        # Unlike Sonarr/Radarr which have a qualityCutoffNotMet boolean field,
+                        # Lidarr requires us to check the track file quality against the profile cutoff
+                        QualityUnmet = False
+                        if hasAllTracks:
+                            try:
+                                # Get the artist's quality profile to find the cutoff
+                                artist_id = db_entry.get("artistId")
+                                artist_data = self.client.get_artist(artist_id)
+                                profile_id = artist_data.get("qualityProfileId")
+
+                                if profile_id:
+                                    # Get or use cached profile
+                                    if profile_id in self._quality_profile_cache:
+                                        profile = self._quality_profile_cache[profile_id]
+                                    else:
+                                        profile = self.client.get_quality_profile(profile_id)
+                                        self._quality_profile_cache[profile_id] = profile
+
+                                    cutoff_quality_id = profile.get("cutoff")
+                                    upgrade_allowed = profile.get("upgradeAllowed", False)
+
+                                    if cutoff_quality_id and upgrade_allowed:
+                                        # Get track files for this album to check their quality
+                                        album_id = db_entry.get("id")
+                                        track_files = self.client.get_track_file(
+                                            albumId=[album_id]
+                                        )
+
+                                        if track_files:
+                                            # Check if any track file's quality is below the cutoff
+                                            for track_file in track_files:
+                                                file_quality = track_file.get("quality", {}).get(
+                                                    "quality", {}
+                                                )
+                                                file_quality_id = file_quality.get("id", 0)
+
+                                                if file_quality_id < cutoff_quality_id:
+                                                    QualityUnmet = True
+                                                    self.logger.trace(
+                                                        "Album '%s' has quality below cutoff: %s (ID: %d) < cutoff (ID: %d)",
+                                                        db_entry.get("title", "Unknown"),
+                                                        file_quality.get("name", "Unknown"),
+                                                        file_quality_id,
+                                                        cutoff_quality_id,
+                                                    )
+                                                    break
+                            except Exception as e:
+                                self.logger.trace(
+                                    "Could not determine quality cutoff status for album '%s': %s",
+                                    db_entry.get("title", "Unknown"),
+                                    str(e),
+                                )
+                                # Default to False if we can't determine
+                                QualityUnmet = False
+
+                        if (
+                            hasAllTracks
+                            and not (self.quality_unmet_search and QualityUnmet)
+                            and not (
+                                self.custom_format_unmet_search and customFormat < minCustomFormat
+                            )
+                        ):
+                            searched = True
+                            self.model_queue.update(Completed=True).where(
+                                self.model_queue.EntryId == db_entry["id"]
+                            ).execute()
+
+                        if self.use_temp_for_missing:
+                            quality_profile_id = db_entry.get("qualityProfileId")
+                            if (
+                                searched
+                                and quality_profile_id in self.temp_quality_profile_ids.values()
+                                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
+                                    )
+                                ]
+                                self.logger.debug(
+                                    "Updating quality profile for %s to %s",
+                                    db_entry["title"],
+                                    db_entry["qualityProfileId"],
+                                )
+                            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
+                                ]
+                                self.logger.debug(
+                                    "Updating quality profile for %s to %s",
+                                    db_entry["title"],
+                                    db_entry["qualityProfileId"],
+                                )
+                            while True:
+                                try:
+                                    self.client.upd_album(db_entry)
+                                    break
+                                except (
+                                    requests.exceptions.ChunkedEncodingError,
+                                    requests.exceptions.ContentDecodingError,
+                                    requests.exceptions.ConnectionError,
+                                    JSONDecodeError,
+                                ):
+                                    continue
+
+                        title = db_entry.get("title", "Unknown Album")
+                        monitored = db_entry.get("monitored", False)
+                        # Handle artist field which can be an object or might not exist
+                        artist_obj = db_entry.get("artist", {})
+                        if isinstance(artist_obj, dict):
+                            # Try multiple possible field names for artist name
+                            artistName = (
+                                artist_obj.get("artistName")
+                                or artist_obj.get("name")
+                                or artist_obj.get("title")
+                                or "Unknown Artist"
+                            )
+                        else:
+                            artistName = "Unknown Artist"
+                        artistId = db_entry.get("artistId", 0)
+                        foreignAlbumId = db_entry.get("foreignAlbumId", "")
+                        releaseDate = db_entry.get("releaseDate")
+                        entryId = db_entry.get("id", 0)
+                        albumFileId = 1 if hasAllTracks else 0  # Use 1/0 to indicate presence
+                        qualityMet = not QualityUnmet if hasAllTracks else False
+                        customFormatMet = customFormat >= minCustomFormat
+
+                        if not hasAllTracks:
+                            # Album is missing tracks - always mark as Missing
+                            reason = "Missing"
+                        elif self.quality_unmet_search and QualityUnmet:
+                            reason = "Quality"
+                        elif self.custom_format_unmet_search and not customFormatMet:
+                            reason = "CustomFormat"
+                        elif self.do_upgrade_search:
+                            reason = "Upgrade"
+                        elif searched:
+                            # Album is complete and not being searched
+                            reason = "Not being searched"
+                        else:
+                            reason = "Not being searched"
+
+                        to_update = {
+                            self.model_file.AlbumFileId: albumFileId,
+                            self.model_file.Monitored: monitored,
+                            self.model_file.QualityMet: qualityMet,
+                            self.model_file.Searched: searched,
+                            self.model_file.Upgrade: False,
+                            self.model_file.MinCustomFormatScore: minCustomFormat,
+                            self.model_file.CustomFormatScore: customFormat,
+                            self.model_file.CustomFormatMet: customFormatMet,
+                            self.model_file.Reason: reason,
+                            self.model_file.ArtistTitle: artistName,
+                            self.model_file.ArtistId: artistId,
+                            self.model_file.ForeignAlbumId: foreignAlbumId,
+                            self.model_file.ReleaseDate: releaseDate,
+                        }
+
+                        if request:
+                            to_update[self.model_file.IsRequest] = request
+
+                        self.logger.debug(
+                            "Updating database entry | %s - %s [Searched:%s][Upgrade:%s][QualityMet:%s][CustomFormatMet:%s]",
+                            artistName.ljust(30, "."),
+                            title.ljust(30, "."),
+                            str(searched).ljust(5),
+                            str(False).ljust(5),
+                            str(qualityMet).ljust(5),
+                            str(customFormatMet).ljust(5),
+                        )
+
+                        db_commands = self.model_file.insert(
+                            Title=title,
+                            Monitored=monitored,
+                            ArtistTitle=artistName,
+                            ArtistId=artistId,
+                            ForeignAlbumId=foreignAlbumId,
+                            ReleaseDate=releaseDate,
+                            EntryId=entryId,
+                            Searched=searched,
+                            AlbumFileId=albumFileId,
+                            IsRequest=request,
+                            QualityMet=qualityMet,
+                            Upgrade=False,
+                            MinCustomFormatScore=minCustomFormat,
+                            CustomFormatScore=customFormat,
+                            CustomFormatMet=customFormatMet,
+                            Reason=reason,
+                        ).on_conflict(conflict_target=[self.model_file.EntryId], update=to_update)
+                        db_commands.execute()
+
+                        # Store tracks for this album (Lidarr only)
+                        if self.track_file_model:
+                            try:
+                                # Fetch tracks for this album via the track API
+                                # Tracks are NOT in the media field, they're a separate endpoint
+                                tracks = self.client.get_tracks(albumId=entryId)
+                                self.logger.debug(
+                                    f"Fetched {len(tracks) if isinstance(tracks, list) else 0} tracks for album {entryId}"
+                                )
+
+                                if tracks and isinstance(tracks, list):
+                                    # First, delete existing tracks for this album
+                                    self.track_file_model.delete().where(
+                                        self.track_file_model.AlbumId == entryId
+                                    ).execute()
+
+                                    # Insert new tracks
+                                    track_insert_count = 0
+                                    for track in tracks:
+                                        # Get monitored status from track or default to album's monitored status
+                                        track_monitored = track.get(
+                                            "monitored", db_entry.get("monitored", False)
+                                        )
+
+                                        self.track_file_model.insert(
+                                            EntryId=track.get("id"),
+                                            AlbumId=entryId,
+                                            TrackNumber=track.get("trackNumber", ""),
+                                            Title=track.get("title", ""),
+                                            Duration=track.get("duration", 0),
+                                            HasFile=track.get("hasFile", False),
+                                            TrackFileId=track.get("trackFileId", 0),
+                                            Monitored=track_monitored,
+                                        ).execute()
+                                        track_insert_count += 1
+
+                                    if track_insert_count > 0:
+                                        self.logger.info(
+                                            f"Stored {track_insert_count} tracks for album {entryId} ({title})"
+                                        )
+                                else:
+                                    self.logger.debug(
+                                        f"No tracks found for album {entryId} ({title})"
+                                    )
+                            except Exception as e:
+                                self.logger.warning(
+                                    f"Could not fetch tracks for album {entryId} ({title}): {e}"
+                                )
+                    else:
+                        db_commands = self.model_file.delete().where(
+                            self.model_file.EntryId == db_entry["id"]
+                        )
+                        db_commands.execute()
+                        # Also delete tracks for this album (Lidarr only)
+                        if self.track_file_model:
+                            self.track_file_model.delete().where(
+                                self.track_file_model.AlbumId == db_entry["id"]
+                            ).execute()
+                else:
+                    # Artist handling
+                    self.artists_file_model: ArtistFilesModel
+                    EntryId = db_entry["id"]
+                    artistData = self.artists_file_model.get_or_none(
+                        self.artists_file_model.EntryId == EntryId
+                    )
+                    if db_entry["monitored"] or self.search_unmonitored:
+                        while True:
+                            try:
+                                artistMetadata = self.client.get_artist(id_=EntryId) or {}
+                                quality_profile_id = None
+                                if isinstance(artistMetadata, dict):
+                                    quality_profile_id = artistMetadata.get("qualityProfileId")
+                                else:
+                                    quality_profile_id = getattr(
+                                        artistMetadata, "qualityProfileId", None
+                                    )
+                                if not artistData:
+                                    if quality_profile_id:
+                                        profile = (
+                                            self.client.get_quality_profile(quality_profile_id)
+                                            or {}
+                                        )
+                                        minCustomFormat = profile.get("minFormatScore") or 0
+                                    else:
+                                        self.logger.warning(
+                                            "Artist %s (%s) missing qualityProfileId; "
+                                            "defaulting custom format score to 0",
+                                            db_entry.get("artistName"),
+                                            EntryId,
+                                        )
+                                        minCustomFormat = 0
+                                else:
+                                    minCustomFormat = getattr(
+                                        artistData, "MinCustomFormatScore", 0
+                                    )
+                                break
+                            except (
+                                requests.exceptions.ChunkedEncodingError,
+                                requests.exceptions.ContentDecodingError,
+                                requests.exceptions.ConnectionError,
+                                JSONDecodeError,
+                            ):
+                                continue
+                        # Calculate if artist is fully searched based on album statistics
+                        statistics = artistMetadata.get("statistics", {})
+                        albumCount = statistics.get("albumCount", 0)
+                        statistics.get("totalAlbumCount", 0)
+                        # Check if there's any album with files (sizeOnDisk > 0)
+                        sizeOnDisk = statistics.get("sizeOnDisk", 0)
+                        # Artist is considered searched if it has albums and at least some have files
+                        searched = albumCount > 0 and sizeOnDisk > 0
+
+                        Title = artistMetadata.get("artistName")
+                        Monitored = db_entry["monitored"]
+
+                        to_update = {
+                            self.artists_file_model.Monitored: Monitored,
+                            self.artists_file_model.Title: Title,
+                            self.artists_file_model.Searched: searched,
+                            self.artists_file_model.Upgrade: False,
+                            self.artists_file_model.MinCustomFormatScore: minCustomFormat,
+                        }
+
+                        self.logger.debug(
+                            "Updating database entry | %s [Searched:%s][Upgrade:%s]",
+                            Title.ljust(60, "."),
+                            str(searched).ljust(5),
+                            str(False).ljust(5),
+                        )
+
+                        db_commands = self.artists_file_model.insert(
+                            EntryId=EntryId,
+                            Title=Title,
+                            Searched=searched,
+                            Monitored=Monitored,
+                            Upgrade=False,
+                            MinCustomFormatScore=minCustomFormat,
+                        ).on_conflict(
+                            conflict_target=[self.artists_file_model.EntryId], update=to_update
+                        )
+                        db_commands.execute()
+
+                        # Note: Albums are now handled separately in db_update()
+                        # No need to recursively process albums here to avoid duplication
+                    else:
+                        db_commands = self.artists_file_model.delete().where(
+                            self.artists_file_model.EntryId == EntryId
+                        )
+                        db_commands.execute()
+
+        except requests.exceptions.ConnectionError as e:
+            self.logger.debug(
+                "Max retries exceeded for %s [%s][%s]",
                 self._name,
                 db_entry["id"],
                 db_entry["title"],
@@ -2743,10 +3611,11 @@ class Arr:
         try:
             while True:
                 try:
-                    res = self.client._delete(
-                        f"queue/{id_}?removeFromClient={remove_from_client}&blocklist={blacklist}",
-                        self.client.ver_uri,
-                    )
+                    res = self.client.del_queue(id_, remove_from_client, blacklist)
+                    # res = self.client._delete(
+                    #     f"queue/{id_}?removeFromClient={remove_from_client}&blocklist={blacklist}",
+                    #     self.client.ver_uri,
+                    # )
                     break
                 except (
                     requests.exceptions.ChunkedEncodingError,
@@ -2755,8 +3624,8 @@ class Arr:
                     JSONDecodeError,
                 ):
                     continue
-        except PyarrResourceNotFound:
-            self.logger.error("Connection Error")
+        except PyarrResourceNotFound as e:
+            self.logger.error("Connection Error: " + e.message)
             raise DelayLoopException(length=300, type=self._name)
         return res
 
@@ -2770,6 +3639,9 @@ class Arr:
             if file.is_dir():
                 self.logger.trace("Not probeable: File is a directory: %s", file)
                 return False
+            if file.name.endswith(".!qB"):
+                self.logger.trace("Not probeable: File is still downloading: %s", file)
+                return False
             output = ffmpeg.probe(
                 str(file.absolute()), cmd=self.manager.qbit_manager.ffprobe_downloader.probe_path
             )
@@ -2901,16 +3773,26 @@ class Arr:
         request_tag = (
             "[OVERSEERR REQUEST]: "
             if request and self.overseerr_requests
-            else "[OMBI REQUEST]: "
-            if request and self.ombi_search_requests
-            else "[PRIORITY SEARCH - TODAY]: "
-            if todays
-            else ""
+            else (
+                "[OMBI REQUEST]: "
+                if request and self.ombi_search_requests
+                else "[PRIORITY SEARCH - TODAY]: " if todays else ""
+            )
         )
         self.refresh_download_queue()
         if request or todays:
             bypass_limit = True
-        if (not self.search_missing) or (file_model is None):
+        if file_model is None:
+            return None
+        features_enabled = (
+            self.search_missing
+            or self.do_upgrade_search
+            or self.quality_unmet_search
+            or self.custom_format_unmet_search
+            or self.ombi_search_requests
+            or self.overseerr_requests
+        )
+        if not features_enabled and not (request or todays):
             return None
         elif not self.is_alive:
             raise NoConnectionrException(f"Could not connect to {self.uri}", type="arr")
@@ -2984,7 +3866,8 @@ class Arr:
                 self.model_file.update(Searched=True, Upgrade=True).where(
                     file_model.EntryId == file_model.EntryId
                 ).execute()
-                if file_model.Reason:
+                reason_text = getattr(file_model, "Reason", None) or None
+                if reason_text:
                     self.logger.hnotice(
                         "%sSearching for: %s | S%02dE%03d | %s | [id=%s|AirDateUTC=%s][%s]",
                         request_tag,
@@ -2994,7 +3877,7 @@ class Arr:
                         file_model.Title,
                         file_model.EntryId,
                         file_model.AirDateUtc,
-                        file_model.Reason,
+                        reason_text,
                     )
                 else:
                     self.logger.hnotice(
@@ -3007,6 +3890,15 @@ class Arr:
                         file_model.EntryId,
                         file_model.AirDateUtc,
                     )
+                description = f"{file_model.SeriesTitle} S{file_model.SeasonNumber:02d}E{file_model.EpisodeNumber:02d}"
+                if getattr(file_model, "Title", None):
+                    description = f"{description} · {file_model.Title}"
+                context_label = self._humanize_request_tag(request_tag)
+                self._record_search_activity(
+                    description,
+                    context=context_label,
+                    detail=str(reason_text) if reason_text else None,
+                )
                 return True
             else:
                 file_model: SeriesFilesModel
@@ -3048,12 +3940,22 @@ class Arr:
                 self.logger.hnotice(
                     "%sSearching for: %s | %s | [id=%s]",
                     request_tag,
-                    "Missing episodes in"
-                    if "Missing" in self.search_api_command
-                    else "All episodes in",
+                    (
+                        "Missing episodes in"
+                        if "Missing" in self.search_api_command
+                        else "All episodes in"
+                    ),
                     file_model.Title,
                     file_model.EntryId,
                 )
+                context_label = self._humanize_request_tag(request_tag)
+                scope = (
+                    "Missing episodes in"
+                    if "Missing" in self.search_api_command
+                    else "All episodes in"
+                )
+                description = f"{scope} {file_model.Title}"
+                self._record_search_activity(description, context=context_label)
                 return True
         elif self.type == "radarr":
             file_model: MoviesFilesModel
@@ -3105,7 +4007,8 @@ class Arr:
             self.model_file.update(Searched=True, Upgrade=True).where(
                 file_model.EntryId == file_model.EntryId
             ).execute()
-            if file_model.Reason:
+            reason_text = getattr(file_model, "Reason", None)
+            if reason_text:
                 self.logger.hnotice(
                     "%sSearching for: %s (%s) [tmdbId=%s|id=%s][%s]",
                     request_tag,
@@ -3113,7 +4016,7 @@ class Arr:
                     file_model.Year,
                     file_model.TmdbId,
                     file_model.EntryId,
-                    file_model.Reason,
+                    reason_text,
                 )
             else:
                 self.logger.hnotice(
@@ -3124,6 +4027,97 @@ class Arr:
                     file_model.TmdbId,
                     file_model.EntryId,
                 )
+            context_label = self._humanize_request_tag(request_tag)
+            description = (
+                f"{file_model.Title} ({file_model.Year})"
+                if getattr(file_model, "Year", None)
+                else f"{file_model.Title}"
+            )
+            self._record_search_activity(
+                description,
+                context=context_label,
+                detail=str(reason_text) if reason_text else None,
+            )
+            return True
+        elif self.type == "lidarr":
+            file_model: AlbumFilesModel
+            if not (request or todays):
+                (
+                    self.model_queue.select(self.model_queue.Completed)
+                    .where(self.model_queue.EntryId == file_model.EntryId)
+                    .execute()
+                )
+            else:
+                pass
+            if file_model.EntryId in self.queue_file_ids:
+                self.logger.debug(
+                    "%sSkipping: Already Searched: %s - %s (%s)",
+                    request_tag,
+                    file_model.ArtistTitle,
+                    file_model.Title,
+                    file_model.EntryId,
+                )
+                self.model_file.update(Searched=True, Upgrade=True).where(
+                    file_model.EntryId == file_model.EntryId
+                ).execute()
+                return True
+            active_commands = self.arr_db_query_commands_count()
+            self.logger.info("%s active search commands, %s remaining", active_commands, commands)
+            if not bypass_limit and active_commands >= self.search_command_limit:
+                self.logger.trace(
+                    "Idle: Too many commands in queue: %s - %s | [id=%s]",
+                    file_model.ArtistTitle,
+                    file_model.Title,
+                    file_model.EntryId,
+                )
+                return False
+            self.persistent_queue.insert(EntryId=file_model.EntryId).on_conflict_ignore().execute()
+
+            self.model_queue.insert(
+                Completed=False, EntryId=file_model.EntryId
+            ).on_conflict_replace().execute()
+            if file_model.EntryId:
+                while True:
+                    try:
+                        self.client.post_command("AlbumSearch", albumIds=[file_model.EntryId])
+                        break
+                    except (
+                        requests.exceptions.ChunkedEncodingError,
+                        requests.exceptions.ContentDecodingError,
+                        requests.exceptions.ConnectionError,
+                        JSONDecodeError,
+                    ):
+                        continue
+            self.model_file.update(Searched=True, Upgrade=True).where(
+                file_model.EntryId == file_model.EntryId
+            ).execute()
+            reason_text = getattr(file_model, "Reason", None)
+            if reason_text:
+                self.logger.hnotice(
+                    "%sSearching for: %s - %s [foreignAlbumId=%s|id=%s][%s]",
+                    request_tag,
+                    file_model.ArtistTitle,
+                    file_model.Title,
+                    file_model.ForeignAlbumId,
+                    file_model.EntryId,
+                    reason_text,
+                )
+            else:
+                self.logger.hnotice(
+                    "%sSearching for: %s - %s [foreignAlbumId=%s|id=%s]",
+                    request_tag,
+                    file_model.ArtistTitle,
+                    file_model.Title,
+                    file_model.ForeignAlbumId,
+                    file_model.EntryId,
+                )
+            context_label = self._humanize_request_tag(request_tag)
+            description = f"{file_model.ArtistTitle} - {file_model.Title}"
+            self._record_search_activity(
+                description,
+                context=context_label,
+                detail=str(reason_text) if reason_text else None,
+            )
             return True
 
     def process(self):
@@ -3162,6 +4156,7 @@ class Arr:
                         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):
                     raise DelayLoopException(length=LOOP_SLEEP_TIMER, type="no_downloads")
                 if not has_internet(self.manager.qbit_manager.client):
@@ -3206,7 +4201,7 @@ class Arr:
             "[Last active: %s] "
             "| [%s] | %s (%s)",
             round(torrent.progress * 100, 2),
-            datetime.fromtimestamp(self.recently_queue.get(torrent.hash, torrent.added_on)),
+            datetime.fromtimestamp(torrent.added_on),
             round(torrent.availability * 100, 2),
             timedelta(seconds=torrent.eta),
             datetime.fromtimestamp(torrent.last_activity),
@@ -3224,7 +4219,7 @@ class Arr:
             "[Last active: %s] "
             "| [%s] | %s (%s)",
             round(torrent.progress * 100, 2),
-            datetime.fromtimestamp(self.recently_queue.get(torrent.hash, torrent.added_on)),
+            datetime.fromtimestamp(torrent.added_on),
             round(torrent.availability * 100, 2),
             timedelta(seconds=torrent.eta),
             datetime.fromtimestamp(torrent.last_activity),
@@ -3243,7 +4238,7 @@ class Arr:
             "[Last active: %s] "
             "| [%s] | %s (%s)",
             round(torrent.progress * 100, 2),
-            datetime.fromtimestamp(self.recently_queue.get(torrent.hash, torrent.added_on)),
+            datetime.fromtimestamp(torrent.added_on),
             round(torrent.availability * 100, 2),
             timedelta(seconds=torrent.eta),
             datetime.fromtimestamp(torrent.last_activity),
@@ -3251,8 +4246,6 @@ class Arr:
             torrent.name,
             torrent.hash,
         )
-        if torrent.state_enum == TorrentStates.QUEUED_DOWNLOAD:
-            self.recently_queue[torrent.hash] = time.time()
 
     def _process_single_torrent_added_to_ignore_cache(
         self, torrent: qbittorrentapi.TorrentDictionary
@@ -3264,7 +4257,7 @@ class Arr:
             "[Last active: %s] "
             "| [%s] | %s (%s)",
             round(torrent.progress * 100, 2),
-            datetime.fromtimestamp(self.recently_queue.get(torrent.hash, torrent.added_on)),
+            datetime.fromtimestamp(torrent.added_on),
             round(torrent.availability * 100, 2),
             timedelta(seconds=torrent.eta),
             datetime.fromtimestamp(torrent.last_activity),
@@ -3284,7 +4277,7 @@ class Arr:
                 "[Last active: %s] "
                 "| [%s] | %s (%s)",
                 round(torrent.progress * 100, 2),
-                datetime.fromtimestamp(self.recently_queue.get(torrent.hash, torrent.added_on)),
+                datetime.fromtimestamp(torrent.added_on),
                 round(torrent.availability * 100, 2),
                 timedelta(seconds=torrent.eta),
                 datetime.fromtimestamp(torrent.last_activity),
@@ -3301,7 +4294,7 @@ class Arr:
                 "[Last active: %s] "
                 "| [%s] | %s (%s)",
                 round(torrent.progress * 100, 2),
-                datetime.fromtimestamp(self.recently_queue.get(torrent.hash, torrent.added_on)),
+                datetime.fromtimestamp(torrent.added_on),
                 round(torrent.availability * 100, 2),
                 timedelta(seconds=torrent.eta),
                 datetime.fromtimestamp(torrent.last_activity),
@@ -3316,10 +4309,9 @@ class Arr:
         # Process torrents who have stalled at this point, only mark for
         # deletion if they have been added more than "IgnoreTorrentsYoungerThan"
         # seconds ago
-        if self.recently_queue.get(
-            torrent.hash, torrent.added_on
-        ) < time.time() - self.ignore_torrents_younger_than and torrent.last_activity < (
-            time.time() - self.ignore_torrents_younger_than
+        if (
+            torrent.added_on < time.time() - self.ignore_torrents_younger_than
+            and torrent.last_activity < (time.time() - self.ignore_torrents_younger_than)
         ):
             self.logger.info(
                 "Deleting Stale torrent: %s | "
@@ -3329,7 +4321,7 @@ class Arr:
                 "| [%s] | %s (%s)",
                 extra,
                 round(torrent.progress * 100, 2),
-                datetime.fromtimestamp(self.recently_queue.get(torrent.hash, torrent.added_on)),
+                datetime.fromtimestamp(torrent.added_on),
                 round(torrent.availability * 100, 2),
                 timedelta(seconds=torrent.eta),
                 datetime.fromtimestamp(torrent.last_activity),
@@ -3346,7 +4338,7 @@ class Arr:
                 "[Last active: %s] "
                 "| [%s] | %s (%s)",
                 round(torrent.progress * 100, 2),
-                datetime.fromtimestamp(self.recently_queue.get(torrent.hash, torrent.added_on)),
+                datetime.fromtimestamp(torrent.added_on),
                 round(torrent.availability * 100, 2),
                 timedelta(seconds=torrent.eta),
                 datetime.fromtimestamp(torrent.last_activity),
@@ -3376,7 +4368,7 @@ class Arr:
                 "[Last active: %s] "
                 "| [%s] | %s (%s)",
                 round(torrent.progress * 100, 2),
-                datetime.fromtimestamp(self.recently_queue.get(torrent.hash, torrent.added_on)),
+                datetime.fromtimestamp(torrent.added_on),
                 round(torrent.availability * 100, 2),
                 timedelta(seconds=torrent.eta),
                 datetime.fromtimestamp(torrent.last_activity),
@@ -3394,7 +4386,7 @@ class Arr:
                 "[Last active: %s] "
                 "| [%s] | %s (%s)",
                 round(torrent.progress * 100, 2),
-                datetime.fromtimestamp(self.recently_queue.get(torrent.hash, torrent.added_on)),
+                datetime.fromtimestamp(torrent.added_on),
                 round(torrent.availability * 100, 2),
                 timedelta(seconds=torrent.eta),
                 datetime.fromtimestamp(torrent.last_activity),
@@ -3413,7 +4405,7 @@ class Arr:
             "[Last active: %s] "
             "| [%s] | %s (%s)",
             round(torrent.progress * 100, 2),
-            datetime.fromtimestamp(self.recently_queue.get(torrent.hash, torrent.added_on)),
+            datetime.fromtimestamp(torrent.added_on),
             round(torrent.availability * 100, 2),
             timedelta(seconds=torrent.eta),
             datetime.fromtimestamp(torrent.last_activity),
@@ -3432,7 +4424,7 @@ class Arr:
             "[Last active: %s] "
             "| [%s] | %s (%s)",
             round(torrent.progress * 100, 2),
-            datetime.fromtimestamp(self.recently_queue.get(torrent.hash, torrent.added_on)),
+            datetime.fromtimestamp(torrent.added_on),
             round(torrent.availability * 100, 2),
             timedelta(seconds=torrent.eta),
             datetime.fromtimestamp(torrent.last_activity),
@@ -3449,7 +4441,7 @@ class Arr:
             "[Last active: %s] "
             "| [%s] | %s (%s)",
             round(torrent.progress * 100, 2),
-            datetime.fromtimestamp(self.recently_queue.get(torrent.hash, torrent.added_on)),
+            datetime.fromtimestamp(torrent.added_on),
             round(torrent.availability * 100, 2),
             timedelta(seconds=torrent.eta),
             datetime.fromtimestamp(torrent.last_activity),
@@ -3470,7 +4462,7 @@ class Arr:
                 "[Last active: %s] "
                 "| [%s] | %s (%s)",
                 round(torrent.progress * 100, 2),
-                datetime.fromtimestamp(self.recently_queue.get(torrent.hash, torrent.added_on)),
+                datetime.fromtimestamp(torrent.added_on),
                 round(torrent.availability * 100, 2),
                 timedelta(seconds=torrent.eta),
                 datetime.fromtimestamp(torrent.last_activity),
@@ -3486,7 +4478,7 @@ class Arr:
                 "[Last active: %s] "
                 "| [%s] | %s (%s)",
                 round(torrent.progress * 100, 2),
-                datetime.fromtimestamp(self.recently_queue.get(torrent.hash, torrent.added_on)),
+                datetime.fromtimestamp(torrent.added_on),
                 round(torrent.availability * 100, 2),
                 timedelta(seconds=torrent.eta),
                 datetime.fromtimestamp(torrent.last_activity),
@@ -3517,7 +4509,7 @@ class Arr:
             "[Last active: %s] "
             "| [%s] | %s (%s)",
             round(torrent.progress * 100, 2),
-            datetime.fromtimestamp(self.recently_queue.get(torrent.hash, torrent.added_on)),
+            datetime.fromtimestamp(torrent.added_on),
             round(torrent.availability * 100, 2),
             timedelta(seconds=torrent.eta),
             datetime.fromtimestamp(torrent.last_activity),
@@ -3539,7 +4531,7 @@ class Arr:
                 "[Last active: %s] "
                 "| [%s] | %s (%s)",
                 round(torrent.progress * 100, 2),
-                datetime.fromtimestamp(self.recently_queue.get(torrent.hash, torrent.added_on)),
+                datetime.fromtimestamp(torrent.added_on),
                 round(torrent.availability * 100, 2),
                 timedelta(seconds=torrent.eta),
                 datetime.fromtimestamp(torrent.last_activity),
@@ -3555,7 +4547,7 @@ class Arr:
                 "[Last active: %s] "
                 "| [%s] | %s (%s)",
                 round(torrent.progress * 100, 2),
-                datetime.fromtimestamp(self.recently_queue.get(torrent.hash, torrent.added_on)),
+                datetime.fromtimestamp(torrent.added_on),
                 round(torrent.availability * 100, 2),
                 timedelta(seconds=torrent.eta),
                 datetime.fromtimestamp(torrent.last_activity),
@@ -3575,7 +4567,7 @@ class Arr:
             "[Last active: %s] "
             "| [%s] | %s (%s)",
             round(torrent.progress * 100, 2),
-            datetime.fromtimestamp(self.recently_queue.get(torrent.hash, torrent.added_on)),
+            datetime.fromtimestamp(torrent.added_on),
             round(torrent.availability * 100, 2),
             timedelta(seconds=torrent.eta),
             datetime.fromtimestamp(torrent.last_activity),
@@ -3592,7 +4584,7 @@ class Arr:
             "[Last active: %s] "
             "| [%s] | %s (%s)",
             round(torrent.progress * 100, 2),
-            datetime.fromtimestamp(self.recently_queue.get(torrent.hash, torrent.added_on)),
+            datetime.fromtimestamp(torrent.added_on),
             round(torrent.availability * 100, 2),
             timedelta(seconds=torrent.eta),
             datetime.fromtimestamp(torrent.last_activity),
@@ -3610,7 +4602,7 @@ class Arr:
             "[Last active: %s] "
             "| [%s] | %s (%s)",
             round(torrent.progress * 100, 2),
-            datetime.fromtimestamp(self.recently_queue.get(torrent.hash, torrent.added_on)),
+            datetime.fromtimestamp(torrent.added_on),
             torrent.ratio,
             timedelta(seconds=torrent.seeding_time),
             datetime.fromtimestamp(torrent.last_activity),
@@ -3628,7 +4620,7 @@ class Arr:
             "[Last active: %s] "
             "| [%s] | %s (%s)",
             round(torrent.progress * 100, 2),
-            datetime.fromtimestamp(self.recently_queue.get(torrent.hash, torrent.added_on)),
+            datetime.fromtimestamp(torrent.added_on),
             torrent.ratio,
             timedelta(seconds=torrent.seeding_time),
             datetime.fromtimestamp(torrent.last_activity),
@@ -3709,9 +4701,7 @@ class Arr:
                     "[Last active: %s] "
                     "| [%s] | %s (%s)",
                     round(torrent.progress * 100, 2),
-                    datetime.fromtimestamp(
-                        self.recently_queue.get(torrent.hash, torrent.added_on)
-                    ),
+                    datetime.fromtimestamp(torrent.added_on),
                     round(torrent.availability * 100, 2),
                     timedelta(seconds=torrent.eta),
                     datetime.fromtimestamp(torrent.last_activity),
@@ -3740,7 +4730,7 @@ class Arr:
                 "[Last active: %s] "
                 "| [%s] | %s (%s)",
                 round(torrent.progress * 100, 2),
-                datetime.fromtimestamp(self.recently_queue.get(torrent.hash, torrent.added_on)),
+                datetime.fromtimestamp(torrent.added_on),
                 round(torrent.availability * 100, 2),
                 timedelta(seconds=torrent.eta),
                 datetime.fromtimestamp(torrent.last_activity),
@@ -3756,7 +4746,7 @@ class Arr:
                 "[Last active: %s] "
                 "| [%s] | %s (%s)",
                 round(torrent.progress * 100, 2),
-                datetime.fromtimestamp(self.recently_queue.get(torrent.hash, torrent.added_on)),
+                datetime.fromtimestamp(torrent.added_on),
                 round(torrent.availability * 100, 2),
                 timedelta(seconds=torrent.eta),
                 datetime.fromtimestamp(torrent.last_activity),
@@ -3773,7 +4763,7 @@ class Arr:
             "[Last active: %s] "
             "| [%s] | %s (%s)",
             round(torrent.progress * 100, 2),
-            datetime.fromtimestamp(self.recently_queue.get(torrent.hash, torrent.added_on)),
+            datetime.fromtimestamp(torrent.added_on),
             round(torrent.availability * 100, 2),
             timedelta(seconds=torrent.eta),
             datetime.fromtimestamp(torrent.last_activity),
@@ -3819,38 +4809,46 @@ class Arr:
         )
 
         data_settings = {
-            "ratio_limit": r
-            if (
-                r := most_important_tracker.get(
-                    "MaxUploadRatio", self.seeding_mode_global_max_upload_ratio
+            "ratio_limit": (
+                r
+                if (
+                    r := most_important_tracker.get(
+                        "MaxUploadRatio", self.seeding_mode_global_max_upload_ratio
+                    )
                 )
-            )
-            > 0
-            else -5,
-            "seeding_time_limit": r
-            if (
-                r := most_important_tracker.get(
-                    "MaxSeedingTime", self.seeding_mode_global_max_seeding_time
+                > 0
+                else -5
+            ),
+            "seeding_time_limit": (
+                r
+                if (
+                    r := most_important_tracker.get(
+                        "MaxSeedingTime", self.seeding_mode_global_max_seeding_time
+                    )
                 )
-            )
-            > 0
-            else -5,
-            "dl_limit": r
-            if (
-                r := most_important_tracker.get(
-                    "DownloadRateLimit", self.seeding_mode_global_download_limit
+                > 0
+                else -5
+            ),
+            "dl_limit": (
+                r
+                if (
+                    r := most_important_tracker.get(
+                        "DownloadRateLimit", self.seeding_mode_global_download_limit
+                    )
                 )
-            )
-            > 0
-            else -5,
-            "up_limit": r
-            if (
-                r := most_important_tracker.get(
-                    "UploadRateLimit", self.seeding_mode_global_upload_limit
+                > 0
+                else -5
+            ),
+            "up_limit": (
+                r
+                if (
+                    r := most_important_tracker.get(
+                        "UploadRateLimit", self.seeding_mode_global_upload_limit
+                    )
                 )
-            )
-            > 0
-            else -5,
+                > 0
+                else -5
+            ),
             "super_seeding": most_important_tracker.get("SuperSeedMode", torrent.super_seeding),
             "max_eta": most_important_tracker.get("MaximumETA", self.maximum_eta),
         }
@@ -3921,13 +4919,19 @@ class Arr:
             torrent.add_trackers(need_to_be_added)
         with contextlib.suppress(BaseException):
             for tracker in torrent.trackers:
-                if (
+                tracker_url = getattr(tracker, "url", None)
+                message_text = (getattr(tracker, "msg", "") or "").lower()
+                remove_for_message = (
                     self.remove_dead_trackers
-                    and (
-                        any(tracker.msg == m for m in self.seeding_mode_global_bad_tracker_msg)
-                    )  # TODO: Add more messages
-                ) or tracker.url in self._remove_trackers_if_exists:
-                    _remove_urls.add(tracker.url)
+                    and self._normalized_bad_tracker_msgs
+                    and any(
+                        keyword in message_text for keyword in self._normalized_bad_tracker_msgs
+                    )
+                )
+                if not tracker_url:
+                    continue
+                if remove_for_message or tracker_url in self._remove_trackers_if_exists:
+                    _remove_urls.add(tracker_url)
         if _remove_urls:
             self.logger.trace(
                 "Removing trackers from torrent: %s (%s) - %s",
@@ -3944,22 +4948,26 @@ class Arr:
             # Only use globals if there is not a configured equivalent value on the
             # highest priority tracker
             data = {
-                "ratio_limit": r
-                if (
-                    r := most_important_tracker.get(
-                        "MaxUploadRatio", self.seeding_mode_global_max_upload_ratio
+                "ratio_limit": (
+                    r
+                    if (
+                        r := most_important_tracker.get(
+                            "MaxUploadRatio", self.seeding_mode_global_max_upload_ratio
+                        )
                     )
-                )
-                > 0
-                else None,
-                "seeding_time_limit": r
-                if (
-                    r := most_important_tracker.get(
-                        "MaxSeedingTime", self.seeding_mode_global_max_seeding_time
+                    > 0
+                    else None
+                ),
+                "seeding_time_limit": (
+                    r
+                    if (
+                        r := most_important_tracker.get(
+                            "MaxSeedingTime", self.seeding_mode_global_max_seeding_time
+                        )
                     )
-                )
-                > 0
-                else None,
+                    > 0
+                    else None
+                ),
             }
             if any(r is not None for r in data):
                 if (
@@ -4016,9 +5024,9 @@ class Arr:
         else:
             data = {
                 "ratio_limit": r if (r := self.seeding_mode_global_max_upload_ratio) > 0 else None,
-                "seeding_time_limit": r
-                if (r := self.seeding_mode_global_max_seeding_time) > 0
-                else None,
+                "seeding_time_limit": (
+                    r if (r := self.seeding_mode_global_max_seeding_time) > 0 else None
+                ),
             }
             if any(r is not None for r in data):
                 if (
@@ -4065,12 +5073,9 @@ class Arr:
         if not self.allowed_stalled:
             self.logger.trace("Stalled check: Stalled delay disabled")
             return False
-        if (
-            self.recently_queue.get(torrent.hash, torrent.added_on)
-            < time_now - self.ignore_torrents_younger_than
-        ):
+        if time_now < torrent.added_on + self.ignore_torrents_younger_than:
             self.logger.trace(
-                "Stalled check: In recent queue %s [Current:%s][Added:%s][Limit:%s]",
+                "Stalled check: In recent queue %s [Current:%s][Added:%s][Starting:%s]",
                 torrent.name,
                 datetime.fromtimestamp(time_now),
                 datetime.fromtimestamp(torrent.added_on),
@@ -4081,19 +5086,19 @@ class Arr:
             return True
         if self.stalled_delay == 0:
             self.logger.trace(
-                "Stalled check: %s [Current:%s][Added:%s][Limit:No Limit]",
+                "Stalled check: %s [Current:%s][Last Activity:%s][Limit:No Limit]",
                 torrent.name,
                 datetime.fromtimestamp(time_now),
-                datetime.fromtimestamp(torrent.added_on),
+                datetime.fromtimestamp(torrent.last_activity),
             )
         else:
             self.logger.trace(
-                "Stalled check: %s [Current:%s][Added:%s][Limit:%s]",
+                "Stalled check: %s [Current:%s][Last Activity:%s][Limit:%s]",
                 torrent.name,
                 datetime.fromtimestamp(time_now),
-                datetime.fromtimestamp(torrent.added_on),
+                datetime.fromtimestamp(torrent.last_activity),
                 datetime.fromtimestamp(
-                    torrent.added_on + timedelta(minutes=self.stalled_delay).seconds
+                    torrent.last_activity + timedelta(minutes=self.stalled_delay).seconds
                 ),
             )
         if (
@@ -4104,11 +5109,7 @@ class Arr:
                 and not self.in_tags(torrent, "qBitrr-free_space_paused")
             )
             or (
-                (
-                    self.recently_queue.get(torrent.hash, torrent.added_on)
-                    < time_now - self.ignore_torrents_younger_than
-                    and torrent.availability < 1
-                )
+                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")
@@ -4117,7 +5118,8 @@ class Arr:
         ) and self.allowed_stalled:
             if (
                 self.stalled_delay > 0
-                and time_now >= torrent.added_on + timedelta(minutes=self.stalled_delay).seconds
+                and time_now
+                >= torrent.last_activity + timedelta(minutes=self.stalled_delay).seconds
             ):
                 stalled_ignore = False
                 self.logger.trace("Process stalled, delay expired: %s", torrent.name)
@@ -4140,7 +5142,15 @@ class Arr:
                 else:
                     self.logger.trace("Stalled, adding tag: %s", torrent.name)
             elif self.in_tags(torrent, "qBitrr-allowed_stalled"):
-                self.logger.trace("Stalled: %s", torrent.name)
+                self.logger.trace(
+                    "Stalled: %s [Current:%s][Last Activity:%s][Limit:%s]",
+                    torrent.name,
+                    datetime.fromtimestamp(time_now),
+                    datetime.fromtimestamp(torrent.last_activity),
+                    datetime.fromtimestamp(
+                        torrent.last_activity + timedelta(minutes=self.stalled_delay).seconds
+                    ),
+                )
 
         elif self.in_tags(torrent, "qBitrr-allowed_stalled"):
             self.remove_tags(torrent, ["qBitrr-allowed_stalled"])
@@ -4167,7 +5177,14 @@ class Arr:
         )
         maximum_eta = _tracker_max_eta
 
-        stalled_ignore = self._stalled_check(torrent, time_now)
+        if torrent.state_enum in (
+            TorrentStates.METADATA_DOWNLOAD,
+            TorrentStates.STALLED_DOWNLOAD,
+            TorrentStates.DOWNLOADING,
+        ):
+            stalled_ignore = self._stalled_check(torrent, time_now)
+        else:
+            stalled_ignore = False
 
         if self.in_tags(torrent, "qBitrr-ignored"):
             self.remove_tags(torrent, ["qBitrr-allowed_seeding", "qBitrr-free_space_paused"])
@@ -4209,6 +5226,14 @@ class Arr:
             self._process_single_torrent_added_to_ignore_cache(torrent)
         elif torrent.state_enum == TorrentStates.QUEUED_UPLOAD:
             self._process_single_torrent_queued_upload(torrent, leave_alone)
+        # Resume monitored downloads which have been paused.
+        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")
+        ):
+            self._process_single_torrent_paused(torrent)
         elif (
             torrent.progress <= self.maximum_deletable_percentage
             and not self.is_complete_state(torrent)
@@ -4217,13 +5242,6 @@ class Arr:
             and not stalled_ignore
         ) and torrent.hash in self.cleaned_torrents:
             self._process_single_torrent_percentage_threshold(torrent, maximum_eta)
-        # Resume monitored downloads which have been paused.
-        elif (
-            torrent.state_enum == TorrentStates.PAUSED_DOWNLOAD
-            and torrent.amount_left != 0
-            and not self.in_tags(torrent, "qBitrr-free_space_paused")
-        ):
-            self._process_single_torrent_paused(torrent)
         # Ignore torrents which have been submitted to their respective Arr
         # instance for import.
         elif (
@@ -4264,8 +5282,7 @@ class Arr:
         elif (
             torrent.state_enum != TorrentStates.PAUSED_DOWNLOAD
             and torrent.state_enum.is_downloading
-            and self.recently_queue.get(torrent.hash, torrent.added_on)
-            < time_now - self.ignore_torrents_younger_than
+            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")
@@ -4279,8 +5296,7 @@ class Arr:
             # "IgnoreTorrentsYoungerThan" variable, mark it for deletion.
             if (
                 (
-                    self.recently_queue.get(torrent.hash, torrent.added_on)
-                    < time_now - self.ignore_torrents_younger_than
+                    time_now > torrent.added_on + self.ignore_torrents_younger_than
                     and torrent.availability < 1
                 )
                 and torrent.hash in self.cleaned_torrents
@@ -4340,6 +5356,9 @@ class Arr:
             elif self.type == "radarr":
                 entry_id_field = "movieId"
                 file_id_field = "MovieFileId"
+            elif self.type == "lidarr":
+                entry_id_field = "albumId"
+                file_id_field = "AlbumFileId"
             else:
                 return False  # Unknown type
 
@@ -4400,7 +5419,9 @@ class Arr:
             return False
 
     def refresh_download_queue(self):
-        self.queue = self.get_queue()
+        self.queue = self.get_queue() or []
+        self.queue_active_count = len(self.queue)
+        self.category_torrent_count = 0
         self.requeue_cache = defaultdict(set)
         if self.queue:
             self.cache = {
@@ -4440,23 +5461,36 @@ class Arr:
                     self.model_queue.delete().where(
                         self.model_queue.EntryId.not_in(list(self.queue_file_ids))
                     ).execute()
+            elif self.type == "lidarr":
+                self.requeue_cache = {
+                    entry["id"]: entry["albumId"] for entry in self.queue if entry.get("albumId")
+                }
+                self.queue_file_ids = {
+                    entry["albumId"] for entry in self.queue if entry.get("albumId")
+                }
+                if self.model_queue:
+                    self.model_queue.delete().where(
+                        self.model_queue.EntryId.not_in(list(self.queue_file_ids))
+                    ).execute()
 
         self._update_bad_queue_items()
 
     def get_queue(self, page=1, page_size=1000, sort_direction="ascending", sort_key="timeLeft"):
-        while True:
-            try:
-                res = self.client.get_queue(
-                    page=page, page_size=page_size, sort_key=sort_key, sort_dir=sort_direction
-                )
-                break
-            except (
+        res = with_retry(
+            lambda: self.client.get_queue(
+                page=page, page_size=page_size, sort_key=sort_key, sort_dir=sort_direction
+            ),
+            retries=3,
+            backoff=0.5,
+            max_backoff=3,
+            exceptions=(
                 requests.exceptions.ChunkedEncodingError,
                 requests.exceptions.ContentDecodingError,
                 requests.exceptions.ConnectionError,
                 JSONDecodeError,
-            ):
-                continue
+                requests.exceptions.RequestException,
+            ),
+        )
         try:
             res = res.get("records", [])
         except AttributeError:
@@ -4493,7 +5527,7 @@ class Arr:
             self.files_to_explicitly_delete = iter(_path_filter.copy())
 
     def parse_quality_profiles(self) -> dict[int, int]:
-        temp_quality_profile_ids = {}
+        temp_quality_profile_ids: dict[int, int] = {}
 
         while True:
             try:
@@ -4505,7 +5539,23 @@ class Arr:
                 requests.exceptions.ConnectionError,
                 JSONDecodeError,
             ):
+                # transient network/encoding issues; retry
+                continue
+            except PyarrServerError as e:
+                # Server-side error (e.g., Radarr DB disk I/O). Log and wait 5 minutes before retrying.
+                self.logger.error(
+                    "Failed to get quality profiles (server error): %s -- retrying in 5 minutes", e
+                )
+                try:
+                    time.sleep(300)
+                except Exception:
+                    pass
                 continue
+            except Exception as e:
+                # Unexpected error; log and continue without profiles.
+                self.logger.error("Unexpected error getting quality profiles: %s", e)
+                profiles = []
+                break
 
         for n in self.main_quality_profiles:
             pair = [n, self.temp_quality_profiles[self.main_quality_profiles.index(n)]]
@@ -4524,24 +5574,55 @@ class Arr:
     def register_search_mode(self):
         if self.search_setup_completed:
             return
-        if not self.search_missing:
+
+        db1, db2, db3, db4, db5 = self._get_models()
+
+        if not (
+            self.search_missing
+            or self.do_upgrade_search
+            or self.quality_unmet_search
+            or self.custom_format_unmet_search
+            or self.ombi_search_requests
+            or self.overseerr_requests
+        ):
+            if db5 and getattr(self, "torrents", None) is None:
+                self.torrent_db = SqliteDatabase(None)
+                self.torrent_db.init(
+                    str(self._app_data_folder.joinpath("Torrents.db")),
+                    pragmas={
+                        "journal_mode": "wal",
+                        "cache_size": -64_000,
+                        "foreign_keys": 1,
+                        "ignore_check_constraints": 0,
+                        "synchronous": 0,
+                    },
+                    timeout=15,
+                )
+
+                class Torrents(db5):
+                    class Meta:
+                        database = self.torrent_db
+
+                self.torrent_db.connect()
+                self.torrent_db.create_tables([Torrents])
+                self.torrents = Torrents
             self.search_setup_completed = True
             return
 
+        self.search_db_file.parent.mkdir(parents=True, exist_ok=True)
         self.db = SqliteDatabase(None)
         self.db.init(
             str(self.search_db_file),
             pragmas={
                 "journal_mode": "wal",
-                "cache_size": -1 * 64000,  # 64MB
+                "cache_size": -64_000,
                 "foreign_keys": 1,
                 "ignore_check_constraints": 0,
                 "synchronous": 0,
             },
+            timeout=15,
         )
 
-        db1, db2, db3, db4 = self._get_models()
-
         class Files(db1):
             class Meta:
                 database = self.db
@@ -4555,7 +5636,18 @@ class Arr:
                 database = self.db
 
         self.db.connect()
-        if db3:
+
+        if db4:
+
+            class Tracks(db4):
+                class Meta:
+                    database = self.db
+
+            self.track_file_model = Tracks
+        else:
+            self.track_file_model = None
+
+        if db3 and self.type == "sonarr":
 
             class Series(db3):
                 class Meta:
@@ -4563,35 +5655,86 @@ class Arr:
 
             self.db.create_tables([Files, Queue, PersistingQueue, Series])
             self.series_file_model = Series
+            self.artists_file_model = None
+        elif db3 and self.type == "lidarr":
+
+            class Artists(db3):
+                class Meta:
+                    database = self.db
+
+            self.db.create_tables([Files, Queue, PersistingQueue, Artists, Tracks])
+            self.artists_file_model = Artists
+            self.series_file_model = None  # Lidarr uses artists, not series
         else:
+            # Radarr or any type without db3/db4 (series/artists/tracks models)
             self.db.create_tables([Files, Queue, PersistingQueue])
+            self.artists_file_model = None
+            self.series_file_model = None
 
-        if db4:
+        if db5:
             self.torrent_db = SqliteDatabase(None)
             self.torrent_db.init(
                 str(self._app_data_folder.joinpath("Torrents.db")),
                 pragmas={
                     "journal_mode": "wal",
-                    "cache_size": -1 * 64000,  # 64MB
+                    "cache_size": -64_000,
                     "foreign_keys": 1,
                     "ignore_check_constraints": 0,
                     "synchronous": 0,
                 },
+                timeout=15,
             )
 
-            class Torrents(db4):
+            class Torrents(db5):
                 class Meta:
                     database = self.torrent_db
 
             self.torrent_db.connect()
             self.torrent_db.create_tables([Torrents])
             self.torrents = Torrents
+        else:
+            self.torrents = None
 
         self.model_file = Files
         self.model_queue = Queue
         self.persistent_queue = PersistingQueue
         self.search_setup_completed = True
 
+    def _get_models(
+        self,
+    ) -> tuple[
+        type[EpisodeFilesModel] | type[MoviesFilesModel] | type[AlbumFilesModel],
+        type[EpisodeQueueModel] | type[MovieQueueModel] | type[AlbumQueueModel],
+        type[SeriesFilesModel] | type[ArtistFilesModel] | None,
+        type[TrackFilesModel] | None,
+        type[TorrentLibrary] | None,
+    ]:
+        if self.type == "sonarr":
+            return (
+                EpisodeFilesModel,
+                EpisodeQueueModel,
+                SeriesFilesModel,
+                None,
+                TorrentLibrary if TAGLESS else None,
+            )
+        if self.type == "radarr":
+            return (
+                MoviesFilesModel,
+                MovieQueueModel,
+                None,
+                None,
+                TorrentLibrary if TAGLESS else None,
+            )
+        if self.type == "lidarr":
+            return (
+                AlbumFilesModel,
+                AlbumQueueModel,
+                ArtistFilesModel,
+                TrackFilesModel,
+                TorrentLibrary if TAGLESS else None,
+            )
+        raise UnhandledError(f"Well you shouldn't have reached here, Arr.type={self.type}")
+
     def run_request_search(self):
         if (
             (
@@ -4602,13 +5745,13 @@ class Arr:
             or (self.request_search_timer > time.time() - self.search_requests_every_x_seconds)
         ):
             return None
-        self.register_search_mode()
         totcommands = -1
         if SEARCH_LOOP_DELAY == -1:
             loop_delay = 30
         else:
             loop_delay = SEARCH_LOOP_DELAY
         try:
+            event = self.manager.qbit_manager.shutdown_event
             self.db_request_update()
             try:
                 for entry, commands in self.db_get_request_files():
@@ -4621,15 +5764,17 @@ class Arr:
                         loop_delay = 30
                     else:
                         loop_delay = SEARCH_LOOP_DELAY
-                    while not self.maybe_do_search(
-                        entry,
-                        request=True,
-                        commands=totcommands,
+                    while (not event.is_set()) and (
+                        not self.maybe_do_search(
+                            entry,
+                            request=True,
+                            commands=totcommands,
+                        )
                     ):
                         self.logger.debug("Waiting for active request search commands")
-                        time.sleep(loop_delay)
+                        event.wait(loop_delay)
                     self.logger.info("Delaying request search loop by %s seconds", loop_delay)
-                    time.sleep(loop_delay)
+                    event.wait(loop_delay)
                     if totcommands == 0:
                         self.logger.info("All request searches completed")
                     else:
@@ -4669,23 +5814,26 @@ class Arr:
                 self.logger.debug(
                     "No downloads in category, sleeping for %s", timedelta(seconds=e.length)
                 )
-            time.sleep(e.length)
+            # Respect shutdown signal
+            self.manager.qbit_manager.shutdown_event.wait(e.length)
 
     def get_year_search(self) -> tuple[list[int], int]:
         years_list = set()
         years = []
         if self.type == "radarr":
-            while True:
-                try:
-                    movies = self.client.get_movie()
-                    break
-                except (
+            movies = with_retry(
+                lambda: self.client.get_movie(),
+                retries=3,
+                backoff=0.5,
+                max_backoff=3,
+                exceptions=(
                     requests.exceptions.ChunkedEncodingError,
                     requests.exceptions.ContentDecodingError,
                     requests.exceptions.ConnectionError,
                     JSONDecodeError,
-                ):
-                    continue
+                    requests.exceptions.RequestException,
+                ),
+            )
 
             for m in movies:
                 if not m["monitored"]:
@@ -4694,20 +5842,34 @@ class Arr:
                     years_list.add(m["year"])
 
         elif self.type == "sonarr":
-            while True:
-                try:
-                    series = self.client.get_series()
-                    break
-                except (
+            series = with_retry(
+                lambda: self.client.get_series(),
+                retries=3,
+                backoff=0.5,
+                max_backoff=3,
+                exceptions=(
                     requests.exceptions.ChunkedEncodingError,
                     requests.exceptions.ContentDecodingError,
                     requests.exceptions.ConnectionError,
                     JSONDecodeError,
-                ):
-                    continue
+                    requests.exceptions.RequestException,
+                ),
+            )
 
             for s in series:
-                episodes = self.client.get_episode(s["id"], True)
+                episodes = with_retry(
+                    lambda: self.client.get_episode(s["id"], True),
+                    retries=3,
+                    backoff=0.5,
+                    max_backoff=3,
+                    exceptions=(
+                        requests.exceptions.ChunkedEncodingError,
+                        requests.exceptions.ContentDecodingError,
+                        requests.exceptions.ConnectionError,
+                        JSONDecodeError,
+                        requests.exceptions.RequestException,
+                    ),
+                )
                 for e in episodes:
                     if "airDateUtc" in e:
                         if not self.search_specials and e["seasonNumber"] == 0:
@@ -4736,15 +5898,22 @@ class Arr:
     def run_search_loop(self) -> NoReturn:
         run_logs(self.logger)
         try:
-            self.register_search_mode()
-            if not self.search_missing:
+            if not (
+                self.search_missing
+                or self.do_upgrade_search
+                or self.quality_unmet_search
+                or self.custom_format_unmet_search
+                or self.ombi_search_requests
+                or self.overseerr_requests
+            ):
                 return None
             loop_timer = timedelta(minutes=15)
             timer = datetime.now()
             years_index = 0
             totcommands = -1
             self.db_update_processed = False
-            while True:
+            event = self.manager.qbit_manager.shutdown_event
+            while not event.is_set():
                 if self.loop_completed:
                     years_index = 0
                     totcommands = -1
@@ -4770,13 +5939,22 @@ class Arr:
                                 self.search_current_year = years[years_index]
                             elif datetime.now() >= (timer + loop_timer):
                                 self.refresh_download_queue()
-                                time.sleep(((timer + loop_timer) - datetime.now()).total_seconds())
+                                event.wait(((timer + loop_timer) - datetime.now()).total_seconds())
                                 self.logger.trace("Restarting loop testing")
+                                try:
+                                    self._record_search_activity(None, detail="loop-complete")
+                                except Exception:
+                                    pass
                                 raise RestartLoopException
                         elif datetime.now() >= (timer + loop_timer):
                             self.refresh_download_queue()
                             self.logger.trace("Restarting loop testing")
+                            try:
+                                self._record_search_activity(None, detail="loop-complete")
+                            except Exception:
+                                pass
                             raise RestartLoopException
+                        any_commands = False
                         for (
                             entry,
                             todays,
@@ -4784,6 +5962,7 @@ class Arr:
                             series_search,
                             commands,
                         ) in self.db_get_files():
+                            any_commands = True
                             if totcommands == -1:
                                 totcommands = commands
                                 self.logger.info("Starting search for %s items", totcommands)
@@ -4791,25 +5970,39 @@ class Arr:
                                 loop_delay = 30
                             else:
                                 loop_delay = SEARCH_LOOP_DELAY
-                            while not self.maybe_do_search(
-                                entry,
-                                todays=todays,
-                                bypass_limit=limit_bypass,
-                                series_search=series_search,
-                                commands=totcommands,
+                            while (not event.is_set()) and (
+                                not self.maybe_do_search(
+                                    entry,
+                                    todays=todays,
+                                    bypass_limit=limit_bypass,
+                                    series_search=series_search,
+                                    commands=totcommands,
+                                )
                             ):
                                 self.logger.debug("Waiting for active search commands")
-                                time.sleep(loop_delay)
+                                event.wait(loop_delay)
                             totcommands -= 1
                             self.logger.info("Delaying search loop by %s seconds", loop_delay)
-                            time.sleep(loop_delay)
+                            event.wait(loop_delay)
                             if totcommands == 0:
                                 self.logger.info("All searches completed")
+                                try:
+                                    self._record_search_activity(
+                                        None, detail="no-pending-searches"
+                                    )
+                                except Exception:
+                                    pass
                             elif datetime.now() >= (timer + loop_timer):
                                 timer = datetime.now()
                                 self.logger.info(
                                     "Searches not completed, %s remaining", totcommands
                                 )
+                        if not any_commands:
+                            self.logger.debug("No pending searches for %s", self._name)
+                            try:
+                                self._record_search_activity(None, detail="no-pending-searches")
+                            except Exception:
+                                pass
                     except RestartLoopException:
                         self.loop_completed = True
                         self.db_update_processed = False
@@ -4828,7 +6021,7 @@ class Arr:
                         raise DelayLoopException(length=300, type="qbit")
                     except Exception as e:
                         self.logger.exception(e, exc_info=sys.exc_info())
-                    time.sleep(LOOP_SLEEP_TIMER)
+                    event.wait(LOOP_SLEEP_TIMER)
                 except DelayLoopException as e:
                     if e.type == "qbit":
                         self.logger.critical(
@@ -4851,22 +6044,22 @@ class Arr:
                             "sleeping for %s",
                             timedelta(seconds=e.length),
                         )
-                    time.sleep(e.length)
+                    event.wait(e.length)
                     self.manager.qbit_manager.should_delay_torrent_scan = False
                 except KeyboardInterrupt:
                     self.logger.hnotice("Detected Ctrl+C - Terminating process")
                     sys.exit(0)
                 else:
-                    time.sleep(5)
+                    event.wait(5)
         except KeyboardInterrupt:
             self.logger.hnotice("Detected Ctrl+C - Terminating process")
             sys.exit(0)
 
     def run_torrent_loop(self) -> NoReturn:
         run_logs(self.logger)
-        self.register_search_mode()
         self.logger.hnotice("Starting torrent monitoring for %s", self._name)
-        while True:
+        event = self.manager.qbit_manager.shutdown_event
+        while not event.is_set():
             try:
                 try:
                     try:
@@ -4896,7 +6089,7 @@ class Arr:
                         sys.exit(0)
                     except Exception as e:
                         self.logger.error(e, exc_info=sys.exc_info())
-                    time.sleep(LOOP_SLEEP_TIMER)
+                    event.wait(LOOP_SLEEP_TIMER)
                 except DelayLoopException as e:
                     if e.type == "qbit":
                         self.logger.critical(
@@ -4924,7 +6117,7 @@ class Arr:
                             "No downloads in category, sleeping for %s",
                             timedelta(seconds=e.length),
                         )
-                    time.sleep(e.length)
+                    event.wait(e.length)
                     self.manager.qbit_manager.should_delay_torrent_scan = False
                 except KeyboardInterrupt:
                     self.logger.hnotice("Detected Ctrl+C - Terminating process")
@@ -4937,13 +6130,13 @@ class Arr:
         _temp = []
         if self.search_missing:
             self.process_search_loop = pathos.helpers.mp.Process(
-                target=self.run_search_loop, daemon=True
+                target=self.run_search_loop, daemon=False
             )
             self.manager.qbit_manager.child_processes.append(self.process_search_loop)
             _temp.append(self.process_search_loop)
-        if not any([QBIT_DISABLED, SEARCH_ONLY]):
+        if not (QBIT_DISABLED or SEARCH_ONLY):
             self.process_torrent_loop = pathos.helpers.mp.Process(
-                target=self.run_torrent_loop, daemon=True
+                target=self.run_torrent_loop, daemon=False
             )
             self.manager.qbit_manager.child_processes.append(self.process_torrent_loop)
             _temp.append(self.process_torrent_loop)
@@ -4961,7 +6154,6 @@ class PlaceHolderArr(Arr):
         self.queue = []
         self.cache = {}
         self.requeue_cache = {}
-        self.recently_queue = {}
         self.sent_to_scan = set()
         self.sent_to_scan_hashes = set()
         self.files_probed = set()
@@ -4982,22 +6174,15 @@ class PlaceHolderArr(Arr):
         self.tracker_delay = ExpiringSet(max_age_seconds=600)
         self._LOG_LEVEL = self.manager.qbit_manager.logger.level
         self.logger = logging.getLogger(f"qBitrr.{self._name}")
-        if ENABLE_LOGS:
-            logs_folder = HOME_PATH.joinpath("logs")
-            logs_folder.mkdir(parents=True, exist_ok=True)
-            logs_folder.chmod(mode=0o777)
-            logfile = logs_folder.joinpath(self._name + ".log")
-            if pathlib.Path(logfile).is_file():
-                logold = logs_folder.joinpath(self._name + ".log.old")
-                if pathlib.Path(logold).exists():
-                    logold.unlink()
-                logfile.rename(logold)
-            fh = logging.FileHandler(logfile)
-            self.logger.addHandler(fh)
-        run_logs(self.logger)
+        run_logs(self.logger, self._name)
         self.search_missing = False
         self.session = None
         self.search_setup_completed = False
+        self.last_search_description: str | None = None
+        self.last_search_timestamp: str | None = None
+        self.queue_active_count: int = 0
+        self.category_torrent_count: int = 0
+        self.free_space_tagged_count: int = 0
         self.logger.hnotice("Starting %s monitor", self._name)
 
     def _process_errored(self):
@@ -5010,9 +6195,31 @@ class PlaceHolderArr(Arr):
             updated_recheck.append(h)
             if c := self.manager.qbit_manager.cache.get(h):
                 temp[c].append(h)
-        self.manager.qbit.torrents_recheck(torrent_hashes=updated_recheck)
+        with contextlib.suppress(Exception):
+            with_retry(
+                lambda: self.manager.qbit.torrents_recheck(torrent_hashes=updated_recheck),
+                retries=3,
+                backoff=0.5,
+                max_backoff=3,
+                exceptions=(
+                    qbittorrentapi.exceptions.APIError,
+                    qbittorrentapi.exceptions.APIConnectionError,
+                    requests.exceptions.RequestException,
+                ),
+            )
         for k, v in temp.items():
-            self.manager.qbit.torrents_set_category(torrent_hashes=v, category=k)
+            with contextlib.suppress(Exception):
+                with_retry(
+                    lambda: self.manager.qbit.torrents_set_category(torrent_hashes=v, category=k),
+                    retries=3,
+                    backoff=0.5,
+                    max_backoff=3,
+                    exceptions=(
+                        qbittorrentapi.exceptions.APIError,
+                        qbittorrentapi.exceptions.APIConnectionError,
+                        requests.exceptions.RequestException,
+                    ),
+                )
 
         for k in updated_recheck:
             self.timed_ignore_cache.add(k)
@@ -5035,10 +6242,36 @@ class PlaceHolderArr(Arr):
             # Remove all bad torrents from the Client.
             temp_to_delete = set()
             if to_delete_all:
-                self.manager.qbit.torrents_delete(hashes=to_delete_all, delete_files=True)
+                with contextlib.suppress(Exception):
+                    with_retry(
+                        lambda: self.manager.qbit.torrents_delete(
+                            hashes=to_delete_all, delete_files=True
+                        ),
+                        retries=3,
+                        backoff=0.5,
+                        max_backoff=3,
+                        exceptions=(
+                            qbittorrentapi.exceptions.APIError,
+                            qbittorrentapi.exceptions.APIConnectionError,
+                            requests.exceptions.RequestException,
+                        ),
+                    )
             if self.remove_from_qbit or self.skip_blacklist:
                 temp_to_delete = self.remove_from_qbit.union(self.skip_blacklist)
-                self.manager.qbit.torrents_delete(hashes=temp_to_delete, delete_files=True)
+                with contextlib.suppress(Exception):
+                    with_retry(
+                        lambda: self.manager.qbit.torrents_delete(
+                            hashes=temp_to_delete, delete_files=True
+                        ),
+                        retries=3,
+                        backoff=0.5,
+                        max_backoff=3,
+                        exceptions=(
+                            qbittorrentapi.exceptions.APIError,
+                            qbittorrentapi.exceptions.APIConnectionError,
+                            requests.exceptions.RequestException,
+                        ),
+                    )
             to_delete_all = to_delete_all.union(temp_to_delete)
             for h in to_delete_all:
                 if h in self.manager.qbit_manager.name_cache:
@@ -5058,16 +6291,27 @@ class PlaceHolderArr(Arr):
             try:
                 while True:
                     try:
-                        torrents = self.manager.qbit_manager.client.torrents.info(
-                            status_filter="all",
-                            category=self.category,
-                            sort="added_on",
-                            reverse=False,
+                        torrents = with_retry(
+                            lambda: self.manager.qbit_manager.client.torrents.info(
+                                status_filter="all",
+                                category=self.category,
+                                sort="added_on",
+                                reverse=False,
+                            ),
+                            retries=3,
+                            backoff=0.5,
+                            max_backoff=3,
+                            exceptions=(
+                                qbittorrentapi.exceptions.APIError,
+                                qbittorrentapi.exceptions.APIConnectionError,
+                                requests.exceptions.RequestException,
+                            ),
                         )
                         break
                     except qbittorrentapi.exceptions.APIError:
                         continue
                 torrents = [t for t in torrents if hasattr(t, "category")]
+                self.category_torrent_count = len(torrents)
                 if not len(torrents):
                     raise DelayLoopException(length=LOOP_SLEEP_TIMER, type="no_downloads")
                 if not has_internet(self.manager.qbit_manager):
@@ -5108,29 +6352,15 @@ class PlaceHolderArr(Arr):
         except DelayLoopException:
             raise
 
-    def run_search_loop(self):
-        return
-
 
 class FreeSpaceManager(Arr):
     def __init__(self, categories: set[str], manager: ArrManager):
         self._name = "FreeSpaceManager"
+        self.type = "FreeSpaceManager"
         self.manager = manager
         self.logger = logging.getLogger(f"qBitrr.{self._name}")
         self._LOG_LEVEL = self.manager.qbit_manager.logger.level
-        if ENABLE_LOGS:
-            logs_folder = HOME_PATH.joinpath("logs")
-            logs_folder.mkdir(parents=True, exist_ok=True)
-            logs_folder.chmod(mode=0o777)
-            logfile = logs_folder.joinpath(self._name + ".log")
-            if pathlib.Path(logfile).is_file():
-                logold = logs_folder.joinpath(self._name + ".log.old")
-                if pathlib.Path(logold).exists():
-                    logold.unlink()
-                logfile.rename(logold)
-            fh = logging.FileHandler(logfile)
-            self.logger.addHandler(fh)
-        run_logs(self.logger)
+        run_logs(self.logger, self._name)
         self.categories = categories
         self.logger.trace("Categories: %s", self.categories)
         self.pause = set()
@@ -5141,6 +6371,9 @@ class FreeSpaceManager(Arr):
         )
         self.timed_ignore_cache = ExpiringSet(max_age_seconds=self.ignore_torrents_younger_than)
         self.needs_cleanup = False
+        self._app_data_folder = APPDATA_FOLDER
+        # Track search setup state to cooperate with Arr.register_search_mode
+        self.search_setup_completed = False
         if FREE_SPACE_FOLDER == "CHANGE_ME":
             self.completed_folder = pathlib.Path(COMPLETED_DOWNLOAD_FOLDER).joinpath(
                 next(iter(self.categories))
@@ -5148,53 +6381,68 @@ class FreeSpaceManager(Arr):
         else:
             self.completed_folder = pathlib.Path(FREE_SPACE_FOLDER)
         self.min_free_space = FREE_SPACE
-        self.current_free_space = shutil.disk_usage(self.completed_folder).free - parse_size(
-            self.min_free_space
+        # Parse once to avoid repeated conversions
+        self._min_free_space_bytes = (
+            parse_size(self.min_free_space) if self.min_free_space != "-1" else 0
+        )
+        self.current_free_space = (
+            shutil.disk_usage(self.completed_folder).free - self._min_free_space_bytes
+        )
+        self.logger.trace(
+            "Free space monitor initialized | Available: %s | Threshold: %s",
+            format_bytes(self.current_free_space + self._min_free_space_bytes),
+            format_bytes(self._min_free_space_bytes),
         )
-        self.logger.trace("Current free space: %s", self.current_free_space)
         self.manager.qbit_manager.client.torrents_create_tags(["qBitrr-free_space_paused"])
         self.search_missing = False
+        self.do_upgrade_search = False
+        self.quality_unmet_search = False
+        self.custom_format_unmet_search = False
+        self.ombi_search_requests = False
+        self.overseerr_requests = False
         self.session = None
-        self.register_torrent_database()
+        # Ensure torrent tag-emulation tables exist when needed.
+        self.torrents = None
+        self.torrent_db: SqliteDatabase | None = None
+        self.last_search_description: str | None = None
+        self.last_search_timestamp: str | None = None
+        self.queue_active_count: int = 0
+        self.category_torrent_count: int = 0
+        self.free_space_tagged_count: int = 0
+        self.register_search_mode()
         self.logger.hnotice("Starting %s monitor", self._name)
-        self.search_setup_completed = False
-
-    def register_torrent_database(self):
-        self.torrent_db = SqliteDatabase(None)
-        self.torrent_db.init(
-            str(APPDATA_FOLDER.joinpath("Torrents.db")),
-            pragmas={
-                "journal_mode": "wal",
-                "cache_size": -1 * 64000,  # 64MB
-                "foreign_keys": 1,
-                "ignore_check_constraints": 0,
-                "synchronous": 0,
-            },
+        atexit.register(
+            lambda: (
+                hasattr(self, "torrent_db")
+                and self.torrent_db
+                and not self.torrent_db.is_closed()
+                and self.torrent_db.close()
+            )
         )
 
-        class Torrents(TorrentLibrary):
-            class Meta:
-                database = self.torrent_db
-
-        self.torrent_db.connect()
-        self.torrent_db.create_tables([Torrents])
-        self.torrents = Torrents
+    def _get_models(
+        self,
+    ) -> tuple[
+        None,
+        None,
+        None,
+        None,
+        type[TorrentLibrary] | None,
+    ]:
+        return None, None, None, None, (TorrentLibrary if TAGLESS else None)
 
     def _process_single_torrent_pause_disk_space(self, torrent: qbittorrentapi.TorrentDictionary):
         self.logger.info(
-            "Pausing torrent for disk space: "
-            "[Progress: %s%%][Added On: %s]"
-            "[Availability: %s%%][Time Left: %s]"
-            "[Last active: %s] "
-            "| [%s] | %s (%s)",
+            "Pausing torrent due to insufficient disk space | "
+            "Name: %s | Progress: %s%% | Size remaining: %s | "
+            "Availability: %s%% | ETA: %s | State: %s | Hash: %s",
+            torrent.name,
             round(torrent.progress * 100, 2),
-            datetime.fromtimestamp(torrent.added_on),
+            format_bytes(torrent.amount_left),
             round(torrent.availability * 100, 2),
             timedelta(seconds=torrent.eta),
-            datetime.fromtimestamp(torrent.last_activity),
             torrent.state_enum,
-            torrent.name,
-            torrent.hash,
+            torrent.hash[:8],  # Shortened hash for readability
         )
         self.pause.add(torrent.hash)
 
@@ -5203,45 +6451,48 @@ class FreeSpaceManager(Arr):
             free_space_test = self.current_free_space
             free_space_test -= torrent["amount_left"]
             self.logger.trace(
-                "Result [%s]: Free space %s -> %s",
+                "Evaluating torrent: %s | Current space: %s | Space after download: %s | Remaining: %s",
                 torrent.name,
-                self.current_free_space,
-                free_space_test,
+                format_bytes(self.current_free_space + self._min_free_space_bytes),
+                format_bytes(free_space_test + self._min_free_space_bytes),
+                format_bytes(torrent.amount_left),
             )
             if torrent.state_enum != TorrentStates.PAUSED_DOWNLOAD and free_space_test < 0:
                 self.logger.info(
-                    "Pause download [%s]: Free space %s -> %s",
+                    "Pausing download (insufficient space) | Torrent: %s | Available: %s | Needed: %s | Deficit: %s",
                     torrent.name,
-                    self.current_free_space,
-                    free_space_test,
+                    format_bytes(self.current_free_space + self._min_free_space_bytes),
+                    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._process_single_torrent_pause_disk_space(torrent)
             elif torrent.state_enum == TorrentStates.PAUSED_DOWNLOAD and free_space_test < 0:
                 self.logger.info(
-                    "Leave paused [%s]: Free space %s -> %s",
+                    "Keeping paused (insufficient space) | Torrent: %s | Available: %s | Needed: %s | Deficit: %s",
                     torrent.name,
-                    self.current_free_space,
-                    free_space_test,
+                    format_bytes(self.current_free_space + self._min_free_space_bytes),
+                    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"])
             elif torrent.state_enum != TorrentStates.PAUSED_DOWNLOAD and free_space_test > 0:
                 self.logger.info(
-                    "Continue downloading [%s]: Free space %s -> %s",
+                    "Continuing download (sufficient space) | Torrent: %s | Available: %s | Space after: %s",
                     torrent.name,
-                    self.current_free_space,
-                    free_space_test,
+                    format_bytes(self.current_free_space + self._min_free_space_bytes),
+                    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"])
             elif torrent.state_enum == TorrentStates.PAUSED_DOWNLOAD and free_space_test > 0:
                 self.logger.info(
-                    "Unpause download [%s]: Free space %s -> %s",
+                    "Resuming download (space available) | Torrent: %s | Available: %s | Space after: %s",
                     torrent.name,
-                    self.current_free_space,
-                    free_space_test,
+                    format_bytes(self.current_free_space + self._min_free_space_bytes),
+                    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"])
@@ -5249,10 +6500,9 @@ class FreeSpaceManager(Arr):
             torrent, "qBitrr-free_space_paused"
         ):
             self.logger.info(
-                "Removing tag [%s] for completed torrent[%s]: Free space %s",
-                "qBitrr-free_space_paused",
+                "Torrent completed, removing free space tag | Torrent: %s | Available: %s",
                 torrent.name,
-                self.current_free_space,
+                format_bytes(self.current_free_space + self._min_free_space_bytes),
             )
             self.remove_tags(torrent, ["qBitrr-free_space_paused"])
 
@@ -5264,15 +6514,28 @@ class FreeSpaceManager(Arr):
             try:
                 while True:
                     try:
-                        torrents = self.manager.qbit_manager.client.torrents.info(
-                            status_filter="all", sort="added_on", reverse=False
-                        )
+                        # Fetch per category to reduce client-side filtering
+                        torrents = []
+                        for cat in self.categories:
+                            with contextlib.suppress(qbittorrentapi.exceptions.APIError):
+                                torrents.extend(
+                                    self.manager.qbit_manager.client.torrents.info(
+                                        status_filter="all",
+                                        category=cat,
+                                        sort="added_on",
+                                        reverse=False,
+                                    )
+                                )
                         break
                     except qbittorrentapi.exceptions.APIError:
                         continue
                 torrents = [t for t in torrents if hasattr(t, "category")]
                 torrents = [t for t in torrents if t.category in self.categories]
                 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")
+                )
                 if not len(torrents):
                     raise DelayLoopException(length=LOOP_SLEEP_TIMER, type="no_downloads")
                 if not has_internet(self.manager.qbit_manager):
@@ -5280,10 +6543,17 @@ class FreeSpaceManager(Arr):
                     raise DelayLoopException(length=NO_INTERNET_SLEEP_TIMER, type="internet")
                 if self.manager.qbit_manager.should_delay_torrent_scan:
                     raise DelayLoopException(length=NO_INTERNET_SLEEP_TIMER, type="delay")
-                self.current_free_space = shutil.disk_usage(
-                    self.completed_folder
-                ).free - parse_size(self.min_free_space)
-                self.logger.trace("Current free space: %s", self.current_free_space)
+                self.current_free_space = (
+                    shutil.disk_usage(self.completed_folder).free - self._min_free_space_bytes
+                )
+                self.logger.trace(
+                    "Processing torrents | Available: %s | Threshold: %s | Usable: %s | Torrents: %d | Paused for space: %d",
+                    format_bytes(self.current_free_space + self._min_free_space_bytes),
+                    format_bytes(self._min_free_space_bytes),
+                    format_bytes(self.current_free_space),
+                    self.category_torrent_count,
+                    self.free_space_tagged_count,
+                )
                 sorted_torrents = sorted(torrents, key=lambda t: t["priority"])
                 for torrent in sorted_torrents:
                     with contextlib.suppress(qbittorrentapi.NotFound404Error):
@@ -5331,7 +6601,7 @@ class ArrManager:
         self.ffprobe_available: bool = self.qbit_manager.ffprobe_downloader.probe_path.exists()
         self.logger = logging.getLogger("qBitrr.ArrManager")
         run_logs(self.logger)
-        if not self.ffprobe_available and not any([QBIT_DISABLED, SEARCH_ONLY]):
+        if not self.ffprobe_available and not (QBIT_DISABLED or SEARCH_ONLY):
             self.logger.error(
                 "'%s' was not found, disabling all functionality dependant on it",
                 self.qbit_manager.ffprobe_downloader.probe_path,
@@ -5339,7 +6609,7 @@ class ArrManager:
 
     def build_arr_instances(self):
         for key in CONFIG.sections():
-            if search := re.match("(rad|son|anim)arr.*", key, re.IGNORECASE):
+            if search := re.match("(rad|son|anim|lid)arr.*", key, re.IGNORECASE):
                 name = search.group(0)
                 match = search.group(1)
                 if match.lower() == "son":
@@ -5348,6 +6618,8 @@ class ArrManager:
                     call_cls = SonarrAPI
                 elif match.lower() == "rad":
                     call_cls = RadarrAPI
+                elif match.lower() == "lid":
+                    call_cls = LidarrAPI
                 else:
                     call_cls = None
                 try:
@@ -5362,7 +6634,12 @@ class ArrManager:
                     continue
                 except (OSError, TypeError) as e:
                     self.logger.exception(e)
-        if FREE_SPACE != "-1" and AUTO_PAUSE_RESUME:
+        if (
+            FREE_SPACE != "-1"
+            and AUTO_PAUSE_RESUME
+            and not QBIT_DISABLED
+            and len(self.arr_categories) > 0
+        ):
             managed_object = FreeSpaceManager(self.arr_categories, self)
             self.managed_objects["FreeSpaceManager"] = managed_object
         for cat in self.special_categories: