diff --git a/quasarr/providers/AGENTS.md b/quasarr/providers/AGENTS.md
index 4ede2647..91523298 100644
--- a/quasarr/providers/AGENTS.md
+++ b/quasarr/providers/AGENTS.md
@@ -20,7 +20,7 @@ The shared-services layer consumed by every other subsystem: cross-process state
 - `cloudflare.py` — challenge detection, `ensure_session_cf_bypassed`, FlareSolverr get/post/session helpers
 - `html_templates.py` / `html_images.py` — UI page shell, base64 image constants, and language-flag emoji/SVG fallback assets for setup UI
 - `hostname_issues.py` — DB-backed source health tracker (`mark_/clear_/get_hostname_issue`)
-- `utils.py` — grab-bag: payload generate/parse, category resolvers, title matching, online-status checks, `download_package` (the JD linkgrabber submission)
+- `utils.py` — grab-bag: payload generate/parse, category resolvers, title matching (including shared date-numbering parsing/query/match/canonicalization), online-status checks, `download_package` (the JD linkgrabber submission)
 - `sessions/` and `notifications/` — see Child DOX Index
 
 ## Local Contracts
diff --git a/quasarr/providers/utils.py b/quasarr/providers/utils.py
index dd36f428..0696d60a 100644
--- a/quasarr/providers/utils.py
+++ b/quasarr/providers/utils.py
@@ -1047,15 +1047,160 @@ def match_in_title(title: str, season: int = None, episode: int = None) -> bool:
     return False
 
 
+_DATE_NUMBERING_IGNORED_TITLE_WORDS = {
+    "a",
+    "an",
+    "and",
+    "das",
+    "der",
+    "die",
+    "friday",
+    "monday",
+    "night",
+    "saturday",
+    "sunday",
+    "the",
+    "thursday",
+    "tuesday",
+    "wednesday",
+}
+_DATE_NUMBERING_SCHEDULE_WORDS = {
+    "friday",
+    "monday",
+    "night",
+    "saturday",
+    "sunday",
+    "thursday",
+    "tuesday",
+    "wednesday",
+}
+
+
+def parse_episode_date(season, episode):
+    """Return a validated date for Sonarr's year + MM/DD numbering shape."""
+    parts = str(episode or "").split("/")
+    if len(parts) != 2:
+        return None
+
+    try:
+        return date(int(season), int(parts[0]), int(parts[1]))
+    except (TypeError, ValueError):
+        return None
+
+
+def date_numbering_title_tokens(value):
+    normalized = replace_umlauts(html.unescape(str(value or ""))).lower()
+    normalized = re.sub(r"[^a-z0-9]+", " ", normalized)
+    return {
+        token
+        for token in normalized.split()
+        if token not in _DATE_NUMBERING_IGNORED_TITLE_WORDS
+        and not re.fullmatch(r"\d+", token)
+    }
+
+
+def date_numbering_title_matches(title, search_string):
+    search_tokens = date_numbering_title_tokens(search_string)
+    if not search_tokens:
+        return False
+    return search_tokens.issubset(date_numbering_title_tokens(title))
+
+
+def date_numbering_release_matches(title, search_string, episode_date):
+    if episode_date is None:
+        return False
+
+    date_pattern = re.compile(
+        rf"(?<!\d){episode_date:%Y}[\s.-]+{episode_date:%m}[\s.-]+"
+        rf"{episode_date:%d}(?!\d)"
+    )
+    if not date_pattern.search(str(title or "")):
+        return False
+    return bool(
+        is_imdb_id(search_string) or date_numbering_title_matches(title, search_string)
+    )
+
+
+def _date_numbering_case_variant(value):
+    words = str(value or "").split()
+    normalized = []
+    changed = False
+    for word in words:
+        if any(char.islower() for char in word) and any(
+            char.isupper() for char in word[1:]
+        ):
+            word = word[:1] + word[1:].lower()
+            changed = True
+        normalized.append(word)
+    return " ".join(normalized) if changed else ""
+
+
+def date_numbering_search_strings(search_string, episode_date):
+    """Build generic title/date variants without series-specific aliases."""
+    search_string = " ".join(str(search_string or "").split())
+    if not search_string or episode_date is None:
+        return [search_string]
+
+    title_variants = [search_string]
+    words = search_string.split()
+    compact_words = [
+        word
+        for word in words
+        if re.sub(r"[^a-z0-9]+", "", word.lower()) not in _DATE_NUMBERING_SCHEDULE_WORDS
+    ]
+    if len(compact_words) >= 2 and compact_words != words:
+        title_variants.append(" ".join(compact_words))
+
+    for value in list(title_variants):
+        case_variant = _date_numbering_case_variant(value)
+        if case_variant and case_variant not in title_variants:
+            title_variants.append(case_variant)
+
+    search_strings = list(title_variants)
+    for candidate in (
+        episode_date,
+        episode_date - timedelta(days=1),
+        episode_date + timedelta(days=1),
+    ):
+        for title_variant in title_variants:
+            for date_variant in (
+                f"{candidate:%Y %m %d}",
+                f"{candidate:%Y-%m-%d}",
+                f"{candidate:%Y.%m.%d}",
+            ):
+                value = f"{title_variant} {date_variant}"
+                if value not in search_strings:
+                    search_strings.append(value)
+
+    return search_strings
+
+
+def canonicalize_date_numbered_title(title, search_string, episode_date):
+    if is_imdb_id(search_string) or not date_numbering_release_matches(
+        title, search_string, episode_date
+    ):
+        return title
+
+    date_match = re.search(
+        rf"(?<!\d){episode_date:%Y}[\s.-]+{episode_date:%m}[\s.-]+"
+        rf"{episode_date:%d}(?!\d)",
+        str(title or ""),
+    )
+    if not date_match:
+        return title
+
+    canonical_prefix = re.sub(r"[^\w]+", ".", str(search_string)).strip(".")
+    suffix = str(title)[date_match.start() :].lstrip(" .-_")
+    return f"{canonical_prefix}.{suffix}" if canonical_prefix and suffix else title
+
+
 def is_valid_release(
     title: str,
     search_category: int,
     search_string: str,
     season: int = None,
     episode: int = None,
-    episode_year: int = None,
-    episode_month: int = None,
-    episode_day: int = None,
+    episode_date: date = None,
 ) -> bool:
     """
     Return True if the given release title is valid for the given search parameters.
@@ -1064,6 +1209,7 @@ def is_valid_release(
     - search_string: the original search phrase (could be an IMDb id or plain text)
     - season: desired season number (or None)
     - episode: desired episode number (or None)
+    - episode_date: validated date for a date-numbered TV episode (or None)
     """
     try:
         is_movie_search = search_category // 1000 * 1000 == SEARCH_CAT_MOVIES
@@ -1072,9 +1218,14 @@ def is_valid_release(
         is_music_search = search_category // 1000 * 1000 == SEARCH_CAT_MUSIC
         is_xxx_search = search_category // 1000 * 1000 == SEARCH_CAT_XXX
 
-        # if search string is NOT an imdb id check search_string_in_sanitized_title - if not match, it is not valid
+        # if search string is NOT an imdb id, require a title match
         if not is_docs_search and not is_imdb_id(search_string):
-            if not search_string_in_sanitized_title(search_string, title):
+            title_matches = (
+                date_numbering_title_matches(title, search_string)
+                if is_tv_search and episode_date is not None
+                else search_string_in_sanitized_title(search_string, title)
+            )
+            if not title_matches:
                 trace(
                     "Skipping {title!r} as it doesn't match sanitized "
                     "search string: {search_string!r}",
@@ -1094,27 +1245,16 @@ def is_valid_release(
                 return False
             return True
 
-        date_pattern = None
-        if (
-            episode_year is not None
-            and episode_month is not None
-            and episode_day is not None
-        ):
-            date_pattern = re.compile(
-                rf"(?<!\d){int(episode_year):04d}[\s.-]+"
-                rf"{int(episode_month):02d}[\s.-]+"
-                rf"{int(episode_day):02d}(?!\d)"
-            )
-
         # if it's a TV show search, don't allow any movies (check for season or episode tags in the title)
         if is_tv_search:
-            if date_pattern is not None:
-                if not date_pattern.search(title):
+            if episode_date is not None:
+                if not date_numbering_release_matches(
+                    title, search_string, episode_date
+                ):
                     trace(
-                        "Skipping {title!r} as it doesn't match date regex: "
-                        "{pattern!r}",
+                        "Skipping {title!r} as it doesn't match date {episode_date}",
                         title=title,
-                        pattern=date_pattern.pattern,
+                        episode_date=episode_date,
                     )
                     return False
                 return True
diff --git a/quasarr/search/AGENTS.md b/quasarr/search/AGENTS.md
index e9e0acb0..16a55b94 100644
--- a/quasarr/search/AGENTS.md
+++ b/quasarr/search/AGENTS.md
@@ -11,7 +11,8 @@ The Newznab-facing search layer: `get_search_results()` fans a single *arr reque
 
 ## Local Contracts
 
-- Per-source gating before dispatch: hostname configured, category in `supported_categories`, category whitelist from `get_search_category_sources`, `supports_imdb` for the imdb branch, `supports_phrase` for the phrase branch, `supports_absolute_numbering` when an episode is given without a season. The feed branch checks only hostname/category/whitelist.
+- Per-source gating before dispatch: hostname configured, category in `supported_categories`, category whitelist from `get_search_category_sources`, `supports_imdb` for the imdb branch, `supports_phrase` for the phrase branch, `supports_absolute_numbering` when an episode is given without a season, and `supports_date_numbering` for Sonarr's year + `MM/DD` episode shape. The feed branch checks only hostname/category/whitelist.
+- Date-numbered requests are parsed once into a validated `datetime.date` and passed to sources as `episode_date`; invalid calendar dates stay on the normal numbering path.
 - The method names `search` and `feed` are load-bearing — dispatch is `getattr(source, action)`.
 - Cache TTL is 300s for search, 60s for feed; the key nulls `start_time` and uses the cache-owner category. Cached entries skip execution entirely, so source methods must be safe to skip.
 - Per-source results are merged, date-sorted descending, title-filtered by `release_matches_search_category`, then offset/limit-sliced; feed responses are never paginated.
diff --git a/quasarr/search/__init__.py b/quasarr/search/__init__.py
index e0707c25..acdd521f 100644
--- a/quasarr/search/__init__.py
+++ b/quasarr/search/__init__.py
@@ -44,6 +44,7 @@ def get_search_results(
         get_search_behavior_category,
         get_search_cache_owner_category,
         get_search_capability_category,
+        parse_episode_date,
         release_matches_search_category,
     )
 
@@ -55,15 +56,7 @@ def get_search_results(
     if imdb_id:
         get_imdb_metadata(imdb_id)
 
-    episode_year = None
-    episode_month = None
-    episode_day = None
-    if episode and "/" in str(episode):
-        episode_date_raw = str(episode).split("/")
-        if len(episode_date_raw) == 2:
-            episode_year = season
-            episode_month = episode_date_raw[0]
-            episode_day = episode_date_raw[1]
+    episode_date = parse_episode_date(season, episode)
 
     # Determine search category if not provided
     if not search_category:
@@ -116,10 +109,8 @@ def get_search_results(
             stype += f" <g>S{season}</g>"
         if episode:
             stype += f"{'' if season else ' '}<e>E{episode}</e>"
-        if episode_year:
-            stype += (
-                f" <g>{episode_year}</g>-<e>{episode_month}</e>-<y>{episode_day}</y>"
-            )
+        if episode_date:
+            stype += f" <g>{episode_date:%Y}</g>-<e>{episode_date:%m}</e>-<y>{episode_date:%d}</y>"
 
         if base_search_category in [SEARCH_CAT_MOVIES, SEARCH_CAT_SHOWS]:
             args = (shared_state, start_time, behavior_search_category)
@@ -156,18 +147,12 @@ def get_search_results(
                     "episode": episode,
                 }
 
-                if episode_year:
+                if episode_date:
                     if not source.supports_date_numbering:
                         source_logger.trace("Search with date unsupported")
                         continue
 
-                    kwargs.update(
-                        {
-                            "episode_year": episode_year,
-                            "episode_month": episode_month,
-                            "episode_day": episode_day,
-                        }
-                    )
+                    kwargs["episode_date"] = episode_date
 
                 search_executor.add(
                     source,
diff --git a/quasarr/search/sources/AGENTS.md b/quasarr/search/sources/AGENTS.md
index 3896cfa3..6a4d91fd 100644
--- a/quasarr/search/sources/AGENTS.md
+++ b/quasarr/search/sources/AGENTS.md
@@ -11,10 +11,10 @@ Two-letter lowercase source modules plus `helpers/`: `search_source.py` (`Abstra
 ## Local Contracts
 
 - Registration is by file existence alone: drop `<xy>.py` into this folder exposing `class Source(AbstractSearchSource)`. The module filename, `Source.initials`, and the `Config("Hostnames")` key all use the same two-letter key; a same-key download twin exists only when release links need source-specific extraction (FX has none). Adding/renaming a module file changes the Hostnames config key space automatically.
-- Signatures: `search(shared_state, start_time, search_category, search_string="", season=None, episode=None)` and `feed(shared_state, start_time, search_category)`, both returning `list[SearchRelease]` — empty list on failure, never raise to the caller.
+- Signatures: `search(shared_state, start_time, search_category, search_string="", season=None, episode=None, episode_date=None)` and `feed(shared_state, start_time, search_category)`, both returning `list[SearchRelease]` — empty list on failure, never raise to the caller. `episode_date` is a validated `datetime.date` for Sonarr's year + `MM/DD` numbering shape.
 - `SearchRelease`: `{"details": {"title", "hostname" (= initials), "imdb_id" (str or None), "link", "size" (bytes), "date" (RFC822 preferred), "source" (original page URL)}, "type": "protected"}` — every emit site uses type `"protected"`.
 - `details.link` must come from `quasarr.providers.utils.generate_download_link(...)`; the payload is pipe-delimited (`title|url|size_mb|password|imdb_id|source_key`), so field values must not contain `|`.
-- Capabilities are plain class attributes: `initials`, `language` (`"de"`, `"en"`, or `"fr"`), `supports_imdb`, `supports_phrase`, `supported_categories` (constants `SEARCH_CAT_*`), plus optional `supports_absolute_numbering` / `requires_login` / `requires_account` / `invite_only` / `requires_flaresolverr` / `requires_radarr` / `requires_sonarr`. `language`, category, account, invite, login, FlareSolverr, and *arr-client metadata is surfaced in the hostname editor through `helpers.get_source_metadata()`.
+- Capabilities are plain class attributes: `initials`, `language` (`"de"`, `"en"`, or `"fr"`), `supports_imdb`, `supports_phrase`, `supported_categories` (constants `SEARCH_CAT_*`), plus optional `supports_absolute_numbering` / `supports_date_numbering` / `requires_login` / `requires_account` / `invite_only` / `requires_flaresolverr` / `requires_radarr` / `requires_sonarr`. Date numbering defaults to supported; AL and AT opt out because their anime-specific numbering rewrites require numeric episodes, MX opts out because its API requires numeric season+episode, and movie-only FF is never dispatched for TV dates. `language`, category, account, invite, login, FlareSolverr, and *arr-client metadata is surfaced in the hostname editor through `helpers.get_source_metadata()`.
 - `is_valid_release(...)` is the default validation for each candidate title in `search()` (not `feed()`); AT and AL intentionally deviate with bespoke matching suited to absolute-numbered anime. IMDb convention: if the searched ID and a release-page ID both exist and differ → skip; if the release lacks one → inherit the searched ID.
 - Call `mark_hostname_issue(self.initials, "feed"|"search", msg)` on fetch/parse errors and `clear_hostname_issue(self.initials)` when releases were produced.
 - `Source.__init__` must be cheap and never fail — a failure is logged as an error and the source is dropped from the registry.
@@ -26,6 +26,7 @@ Two-letter lowercase source modules plus `helpers/`: `search_source.py` (`Abstra
 - Timeouts from `constants.FEED_/SEARCH_REQUEST_TIMEOUT_SECONDS`; User-Agent from shared state. Sources without native IMDb search resolve a localized title via `get_localized_title(shared_state, imdb_id, language)` — pass `"de"`, `"en"`, or `"fr"` matching the source site's content language.
 - Module-private parsing helpers are underscore-prefixed at the module bottom; `size` flows as MB int into `generate_download_link` and as bytes in `details.size`; size 0 is the accepted fallback.
 - Do not infer payloads or response shapes — the root `Third-Party Source Work` rules require real traffic captures or direct curl confirmation first.
+- Date-numbering parsing, title matching, query variants, and canonical title rewriting belong in `quasarr.providers.utils`; source modules only pass `episode_date` through existing verified request/result paths. Keep production logic series-agnostic and add series-specific compatibility cases only as synthetic tests.
 - A new source adds its entry to the Per-Source Notes below and, when it has a download module, to the notes in `quasarr/downloads/sources/AGENTS.md` — in the same change.
 
 ### Per-Source Notes (search side)
@@ -37,7 +38,7 @@ Capability flags (`supports_*`, `requires_*`) and categories are class attribute
 - **BY** — no login. Book/magazine titles run through Magazarr-compatible date/issue normalization; search drops releases without valid resolution/codec (feed keeps the original metadata); per-category fetches use category-ID constants inside the module.
 - **DD** — login (`providers/sessions/dd`, which applies a fixed quality-profile filter to API responses — new resolutions must be added there). IMDb mismatch between request and API response discards the result; a suspected fake release (the API's `fake` flag) invalidates the cached session.
 - **DJ** — login (shares the `JUNKIES` credentials section with SJ). IMDb-only; series discovered by HTML scrape to locate a media id, releases then fetched via JSON and aggregated per season block.
-- **DL** — login (`providers/sessions/dl`); umlauts normalized when building queries. Paginated search is sequential, bounded by a wall-clock budget, and stops on an empty page; yearly magazine threads ("Jahresthema") expand into per-issue entries (requires the current year in the thread); magazine titles use a token-normalized matcher to align month/issue variants.
+- **DL** — login (`providers/sessions/dl`); umlauts normalized when building queries. Paginated search is sequential, bounded by a wall-clock budget, and stops on an empty page; yearly magazine threads ("Jahresthema") expand into per-issue entries (requires the current year in the thread); magazine titles use a token-normalized matcher to align month/issue variants. Date-numbered thread discovery/pagination is DL-specific, while query variants, title/date matching, and canonicalization use shared generic helpers.
 - **DT** — no login. Article date parsing assumes a fixed timezone offset; IMDb id parsed from article HTML and propagated; search drops candidates not matching requested resolution/codec (feed keeps them).
 - **DW** — no login. German month names mapped in a local table (new variants go there); IMDb id read from article HTML validates the result still matches the request.
 - **FF** — no login, movie-only. Search uses the public title lookup, then opens each movie page to extract IMDb id and the movie-token release API; releases are emitted from API `div.entry` blocks and use the release page URL as the download payload source. Feed reads recent update rows, then cross-references each movie page/API to fill size and IMDb data for the release anchors; cross-reference stops when the source's global feed budget reaches `FEED_REQUEST_TIMEOUT_SECONDS`.
diff --git a/quasarr/search/sources/al.py b/quasarr/search/sources/al.py
index d6d6a7cc..e4ff3b30 100644
--- a/quasarr/search/sources/al.py
+++ b/quasarr/search/sources/al.py
@@ -45,6 +45,7 @@ class Source(AbstractSearchSource):
     requires_flaresolverr = True
     supports_imdb = True
     supports_phrase = False
+    supports_date_numbering = False
     supports_absolute_numbering = True
     supported_categories = [SEARCH_CAT_MOVIES, SEARCH_CAT_SHOWS, SEARCH_CAT_SHOWS_ANIME]
     requires_login = True
diff --git a/quasarr/search/sources/at.py b/quasarr/search/sources/at.py
index 01d3da51..38f38bc0 100644
--- a/quasarr/search/sources/at.py
+++ b/quasarr/search/sources/at.py
@@ -69,6 +69,7 @@ class Source(AbstractSearchSource):
     language = "en"
     supports_imdb = True
     supports_phrase = True
+    supports_date_numbering = False
     supports_absolute_numbering = True
     supported_categories = [SEARCH_CAT_MOVIES, SEARCH_CAT_SHOWS, SEARCH_CAT_SHOWS_ANIME]
 
diff --git a/quasarr/search/sources/by.py b/quasarr/search/sources/by.py
index 2bbe15b4..78a73509 100644
--- a/quasarr/search/sources/by.py
+++ b/quasarr/search/sources/by.py
@@ -103,6 +103,7 @@ def search(
         search_string: str = "",
         season: int = None,
         episode: int = None,
+        episode_date=None,
     ) -> list[SearchRelease]:
         by = shared_state.values["config"]("Hostnames").get(self.initials)
         password = by
@@ -140,6 +141,7 @@ def search(
                 search_string=search_string,
                 season=season,
                 episode=episode,
+                episode_date=episode_date,
             )
         except Exception as e:
             error(f"Error loading search: {e}")
@@ -164,6 +166,7 @@ def _parse_posts(
         search_string=None,
         season=None,
         episode=None,
+        episode_date=None,
     ):
         releases = []
 
@@ -281,7 +284,12 @@ def _parse_posts(
                             continue
 
                     if not is_valid_release(
-                        title, search_category, search_string, season, episode
+                        title,
+                        search_category,
+                        search_string,
+                        season,
+                        episode,
+                        episode_date,
                     ):
                         continue
                     if XXX_REGEX.search(title) and "xxx" not in search_string.lower():
diff --git a/quasarr/search/sources/dd.py b/quasarr/search/sources/dd.py
index 35827c13..1ca663e1 100644
--- a/quasarr/search/sources/dd.py
+++ b/quasarr/search/sources/dd.py
@@ -54,6 +54,7 @@ def search(
         search_string: str = "",
         season: int = None,
         episode: int = None,
+        episode_date=None,
     ) -> list[SearchRelease]:
         releases = []
         dd = shared_state.values["config"]("Hostnames").get(self.initials)
@@ -76,7 +77,7 @@ def search(
                 info(f"Could not extract title from IMDb-ID {imdb_id}")
                 return releases
             search_string = html.unescape(search_string)
-            if season:
+            if season and episode_date is None:
                 search_string += f" S{int(season):02d}"
                 if episode:
                     search_string += f"E{int(episode):02d}"
@@ -130,7 +131,12 @@ def search(
                         title = release.get("release")
 
                         if not is_valid_release(
-                            title, search_category, search_string, season, episode
+                            title,
+                            search_category,
+                            search_string,
+                            season,
+                            episode,
+                            episode_date,
                         ):
                             continue
 
diff --git a/quasarr/search/sources/dj.py b/quasarr/search/sources/dj.py
index feca6b66..3824c514 100644
--- a/quasarr/search/sources/dj.py
+++ b/quasarr/search/sources/dj.py
@@ -131,6 +131,7 @@ def search(
         search_string: str = "",
         season: int = None,
         episode: int = None,
+        episode_date=None,
     ) -> list[SearchRelease]:
         releases = []
 
@@ -220,7 +221,12 @@ def search(
                             continue
 
                         if not is_valid_release(
-                            title, search_category, search_string, season, episode
+                            title,
+                            search_category,
+                            search_string,
+                            season,
+                            episode,
+                            episode_date,
                         ):
                             continue
 
diff --git a/quasarr/search/sources/dl.py b/quasarr/search/sources/dl.py
index 44573116..3d935a02 100644
--- a/quasarr/search/sources/dl.py
+++ b/quasarr/search/sources/dl.py
@@ -4,7 +4,7 @@
 
 import re
 import time
-from datetime import datetime, timedelta
+from datetime import datetime
 from html import unescape
 from urllib.parse import urlsplit, urlunsplit
 
@@ -32,6 +32,10 @@
     retrieve_and_validate_session,
 )
 from quasarr.providers.utils import (
+    canonicalize_date_numbered_title,
+    date_numbering_release_matches,
+    date_numbering_search_strings,
+    date_numbering_title_matches,
     generate_download_link,
     get_base_search_category_id,
     is_imdb_id,
@@ -191,9 +195,7 @@ def _search_single_page(
         search_category,
         season,
         episode,
-        episode_year,
-        episode_month,
-        episode_day,
+        episode_date,
     ):
         """
         Search a single page. This method is called sequentially for each page.
@@ -263,11 +265,11 @@ def _search_single_page(
                     title = unescape(title)
                     title_normalized = _normalize_title_for_arr(title)
                     is_date_thread_candidate = (
-                        episode_year
+                        episode_date
                         and _should_check_thread_for_date_release(
                             title_normalized,
                             search_string,
-                            episode_year,
+                            episode_date,
                         )
                     )
 
@@ -298,9 +300,7 @@ def _search_single_page(
                         search_string,
                         season,
                         episode,
-                        episode_year,
-                        episode_month,
-                        episode_day,
+                        episode_date,
                     )
                     if not is_release_valid:
                         if is_date_thread_candidate:
@@ -308,17 +308,16 @@ def _search_single_page(
                                 shared_state,
                                 thread_url,
                                 search_string,
-                                episode_year,
-                                episode_month,
-                                episode_day,
+                                episode_date,
                             )
                         if not date_release:
                             continue
                         title_normalized = date_release["title"]
-                    elif episode_year:
-                        title_normalized = _date_release_title_for_arr(
+                    elif episode_date:
+                        title_normalized = canonicalize_date_numbered_title(
                             title_normalized,
                             search_string,
+                            episode_date,
                         )
 
                     # Extract date and convert to RFC 2822 format
@@ -390,9 +389,7 @@ def search(
         search_string: str = "",
         season: int = None,
         episode: int = None,
-        episode_year: int = None,
-        episode_month: int = None,
-        episode_day: int = None,
+        episode_date=None,
     ) -> list[SearchRelease]:
         """
         Search with sequential pagination to find best quality releases.
@@ -408,24 +405,20 @@ def search(
                 info(f"no title for IMDb {imdb_id}")
                 return releases
             search_string = title
-            if episode_year:
-                search_string = _date_search_alias(search_string)
             if not season:
                 if year := get_year(imdb_id):
                     search_string += f" {year}"
 
         search_string = unescape(search_string)
         search_strings = (
-            _date_search_strings(
+            date_numbering_search_strings(
                 search_string,
-                episode_year,
-                episode_month,
-                episode_day,
+                episode_date,
             )
-            if episode_year
+            if episode_date
             else [search_string]
         )
-        max_search_duration = 15 if episode_year else 7
+        max_search_duration = 15 if episode_date else 7
 
         trace(
             f"Starting sequential paginated search for '{search_string}' "
@@ -461,9 +454,7 @@ def search(
                         search_category,
                         season,
                         episode,
-                        episode_year,
-                        episode_month,
-                        episode_day,
+                        episode_date,
                     )
 
                     page_release_titles = tuple(
@@ -548,74 +539,18 @@ def _normalize_title_for_arr(title):
     return title
 
 
-def _date_search_alias(search_string):
-    normalized = replace_umlauts(unescape(str(search_string or ""))).lower()
-    normalized = re.sub(r"[^a-z0-9]+", " ", normalized)
-    normalized = re.sub(r"\s+", " ", normalized).strip()
-
-    aliases = {
-        "wwe monday night raw": "WWE RAW",
-        "wwe friday night smackdown": "WWE SmackDown",
-    }
-    alias = aliases.get(normalized, search_string)
-    return alias
-
-
-def _date_search_strings(search_string, episode_year, episode_month, episode_day):
-    try:
-        episode_date = datetime(
-            int(episode_year),
-            int(episode_month),
-            int(episode_day),
-        )
-    except (TypeError, ValueError):
-        return [search_string]
-
-    candidates = [
-        episode_date,
-        episode_date - timedelta(days=1),
-        episode_date + timedelta(days=1),
-    ]
-    search_strings = [search_string]
-    search_variants = [search_string]
-    if re.search(r"(?i)\bsmackdown\b", search_string):
-        smackdown_variant = re.sub(
-            r"(?i)\bsmackdown\b",
-            "Smackdown",
-            search_string,
-            count=1,
-        )
-        if smackdown_variant not in search_variants:
-            search_variants.append(smackdown_variant)
-
-    for candidate in candidates:
-        date_variants = (
-            f"{candidate:%Y %m %d}",
-            f"{candidate:%Y-%m-%d}",
-            f"{candidate:%Y.%m.%d}",
-        )
-        for search_variant in search_variants:
-            for date_variant in date_variants:
-                value = f"{search_variant} {date_variant}"
-                if value not in search_strings:
-                    search_strings.append(value)
-
-    return search_strings
-
-
-def _should_check_thread_for_date_release(title, search_string=None, episode_year=None):
+def _should_check_thread_for_date_release(title, search_string=None, episode_date=None):
     normalized = replace_umlauts(unescape(str(title or ""))).lower()
     normalized = re.sub(r"[^a-z0-9]+", " ", normalized)
     tokens = set(normalized.split())
 
-    if episode_year and str(episode_year) not in tokens:
+    if episode_date and str(episode_date.year) not in tokens:
         return False
 
-    search_tokens = _title_match_tokens(search_string or "")
-    if not search_tokens:
+    if not search_string:
         return bool(re.search(r"\b(?:19|20)\d{2}\b", normalized))
 
-    if not search_tokens.issubset(tokens):
+    if not date_numbering_title_matches(title, search_string):
         return False
 
     return bool(re.search(r"\b(?:19|20)\d{2}\b", normalized))
@@ -755,11 +690,9 @@ def _date_release_from_thread(
     shared_state,
     thread_url,
     search_string,
-    episode_year,
-    episode_month,
-    episode_day,
+    episode_date,
 ):
-    if not (episode_year and episode_month and episode_day):
+    if episode_date is None:
         return {}
 
     first_page = _fetch_thread_page(shared_state, thread_url)
@@ -796,14 +729,10 @@ def _date_release_from_thread(
             title = _date_release_title_from_post(post)
             if not title:
                 continue
-            if _date_release_title_matches_search(
-                title,
-                search_string,
-                episode_year,
-                episode_month,
-                episode_day,
-            ):
-                arr_title = _date_release_title_for_arr(title, search_string)
+            if date_numbering_release_matches(title, search_string, episode_date):
+                arr_title = canonicalize_date_numbered_title(
+                    title, search_string, episode_date
+                )
                 source = thread_url
                 if _post_contains_supported_download(post):
                     source = _post_url(page_url, post)
@@ -867,80 +796,6 @@ def _date_release_size_mb_from_post(post):
     return 0
 
 
-def _date_release_title_for_arr(title, search_string):
-    normalized_search = replace_umlauts(unescape(str(search_string or ""))).lower()
-    normalized_search = re.sub(r"[^a-z0-9]+", " ", normalized_search)
-    normalized_search = re.sub(r"\b\d+\b", " ", normalized_search)
-    normalized_search = re.sub(r"\s+", " ", normalized_search).strip()
-
-    canonical_prefixes = {
-        "wwe raw": "WWE.Monday.Night.RAW",
-        "wwe smackdown": "WWE.Friday.Night.SmackDown",
-    }
-    canonical_prefix = canonical_prefixes.get(normalized_search)
-    if not canonical_prefix:
-        return title
-
-    compact_prefix = canonical_prefix.replace(".", r"[\s.]+")
-    raw_prefix = re.sub(
-        r"^(wwe)[\s.]+(?:monday[\s.]+night[\s.]+)?raw",
-        "wwe raw",
-        normalized_search,
-    )
-    raw_prefix = re.escape(raw_prefix).replace(r"\ ", r"[\s.]+")
-    if re.match(rf"(?i)^{raw_prefix}[\s.]+", title):
-        return re.sub(rf"(?i)^{raw_prefix}", canonical_prefix, title, count=1)
-    if re.match(rf"(?i)^{compact_prefix}[\s.]+", title):
-        return re.sub(rf"(?i)^{compact_prefix}", canonical_prefix, title, count=1)
-
-    return title
-
-
-def _date_release_title_matches_search(
-    title,
-    search_string,
-    episode_year,
-    episode_month,
-    episode_day,
-):
-    date_pattern = re.compile(
-        rf"(?<!\d){int(episode_year):04d}[\s.-]+"
-        rf"{int(episode_month):02d}[\s.-]+"
-        rf"{int(episode_day):02d}(?!\d)"
-    )
-    if not date_pattern.search(title):
-        return False
-
-    normalized_title = _title_match_tokens(title)
-    search_tokens = _title_match_tokens(search_string)
-    if not search_tokens:
-        return False
-
-    return search_tokens.issubset(normalized_title)
-
-
-def _title_match_tokens(text):
-    normalized = replace_umlauts(unescape(str(text or ""))).lower()
-    normalized = re.sub(r"[^a-z0-9]+", " ", normalized)
-    ignored = {
-        "a",
-        "an",
-        "and",
-        "der",
-        "die",
-        "das",
-        "monday",
-        "night",
-        "the",
-    }
-    tokens = {
-        token
-        for token in normalized.split()
-        if token not in ignored and not re.fullmatch(r"\d+", token)
-    }
-    return tokens
-
-
 def _extract_last_thread_page(html):
     soup = BeautifulSoup(html, "html.parser")
     page_numbers = [1]
diff --git a/quasarr/search/sources/dt.py b/quasarr/search/sources/dt.py
index a546f6a0..81dd7727 100644
--- a/quasarr/search/sources/dt.py
+++ b/quasarr/search/sources/dt.py
@@ -174,6 +174,7 @@ def search(
         search_string: str = "",
         season: int = None,
         episode: int = None,
+        episode_date=None,
     ) -> list[SearchRelease]:
         releases = []
         dt = shared_state.values["config"]("Hostnames").get(self.initials)
@@ -250,7 +251,12 @@ def search(
                     )
 
                     if not is_valid_release(
-                        title, search_category, search_string, season, episode
+                        title,
+                        search_category,
+                        search_string,
+                        season,
+                        episode,
+                        episode_date,
                     ):
                         continue
 
diff --git a/quasarr/search/sources/dw.py b/quasarr/search/sources/dw.py
index 89ec40a8..1c2f3cde 100644
--- a/quasarr/search/sources/dw.py
+++ b/quasarr/search/sources/dw.py
@@ -139,6 +139,7 @@ def search(
         search_string: str = "",
         season: int = None,
         episode: int = None,
+        episode_date=None,
     ) -> list[SearchRelease]:
         releases = []
         dw = shared_state.values["config"]("Hostnames").get(self.initials)
@@ -184,7 +185,12 @@ def search(
                     title = result.a.text.strip()
 
                     if not is_valid_release(
-                        title, search_category, search_string, season, episode
+                        title,
+                        search_category,
+                        search_string,
+                        season,
+                        episode,
+                        episode_date,
                     ):
                         continue
 
diff --git a/quasarr/search/sources/ff.py b/quasarr/search/sources/ff.py
index d63a7965..d68fbab8 100644
--- a/quasarr/search/sources/ff.py
+++ b/quasarr/search/sources/ff.py
@@ -174,9 +174,7 @@ def search(
         search_string: str = "",
         season: int = None,
         episode: int = None,
-        episode_year: int = None,
-        episode_month: int = None,
-        episode_day: int = None,
+        episode_date=None,
     ) -> list[SearchRelease]:
         releases = []
         host = shared_state.values["config"]("Hostnames").get(self.initials)
diff --git a/quasarr/search/sources/fx.py b/quasarr/search/sources/fx.py
index 68f153ca..5ca028c5 100644
--- a/quasarr/search/sources/fx.py
+++ b/quasarr/search/sources/fx.py
@@ -159,6 +159,7 @@ def search(
         search_string: str = "",
         season: int = None,
         episode: int = None,
+        episode_date=None,
     ) -> list[SearchRelease]:
         releases = []
         fx = shared_state.values["config"]("Hostnames").get(self.initials)
@@ -228,7 +229,12 @@ def search(
                             title = sanitize_title(title.text)
 
                             if not is_valid_release(
-                                title, search_category, search_string, season, episode
+                                title,
+                                search_category,
+                                search_string,
+                                season,
+                                episode,
+                                episode_date,
                             ):
                                 continue
 
diff --git a/quasarr/search/sources/he.py b/quasarr/search/sources/he.py
index 23b1c4fc..6ab90a8f 100644
--- a/quasarr/search/sources/he.py
+++ b/quasarr/search/sources/he.py
@@ -52,6 +52,7 @@ def search(
         search_string: str = "",
         season: int = None,
         episode: int = None,
+        episode_date=None,
     ) -> list[SearchRelease]:
         releases = []
         host = shared_state.values["config"]("Hostnames").get(self.initials)
@@ -92,7 +93,7 @@ def search(
             search_type = "search"
             timeout = SEARCH_REQUEST_TIMEOUT_SECONDS
 
-        if season:
+        if season and episode_date is None:
             source_search += f" S{int(season):02d}"
 
             if episode:
@@ -142,7 +143,12 @@ def search(
                 title = head_split[0].strip()
 
                 if not is_valid_release(
-                    title, search_category, search_string, season, episode
+                    title,
+                    search_category,
+                    search_string,
+                    season,
+                    episode,
+                    episode_date,
                 ):
                     trace("invalid release {}", title)
                     continue
diff --git a/quasarr/search/sources/helpers/search_source.py b/quasarr/search/sources/helpers/search_source.py
index 36a88618..34df7c19 100644
--- a/quasarr/search/sources/helpers/search_source.py
+++ b/quasarr/search/sources/helpers/search_source.py
@@ -32,7 +32,7 @@ def supports_absolute_numbering(self) -> bool:
 
     @property
     def supports_date_numbering(self) -> bool:
-        return False
+        return True
 
     @property
     @abstractmethod
@@ -75,9 +75,7 @@ def search(
         search_string: str = "",
         season: int = None,
         episode: int = None,
-        episode_year: int = None,
-        episode_month: int = None,
-        episode_day: int = None,
+        episode_date=None,
     ) -> list[SearchRelease]:
         pass
 
diff --git a/quasarr/search/sources/hs.py b/quasarr/search/sources/hs.py
index f93c81cb..42f5949c 100644
--- a/quasarr/search/sources/hs.py
+++ b/quasarr/search/sources/hs.py
@@ -149,6 +149,7 @@ def search(
         search_string: str = "",
         season: int = None,
         episode: int = None,
+        episode_date=None,
     ) -> list[SearchRelease]:
         """Search HS for releases by IMDb ID"""
         releases = []
@@ -183,6 +184,7 @@ def search(
                 search_string,
                 season,
                 episode,
+                episode_date,
             )
 
         except Exception as e:
@@ -207,6 +209,7 @@ def _parse_search_results(
         search_string,
         season,
         episode,
+        episode_date,
     ):
         """Parse search results page and extract releases with filecrypt links.
 
@@ -290,7 +293,12 @@ def _parse_search_results(
                 for title in unique_episodes:
                     # Validate release against search criteria
                     if not is_valid_release(
-                        title, base_search_category, search_string, season, episode
+                        title,
+                        base_search_category,
+                        search_string,
+                        season,
+                        episode,
+                        episode_date,
                     ):
                         continue
 
@@ -328,7 +336,12 @@ def _parse_search_results(
                 # Also add the main title (season pack) with full size - if not duplicate
                 if main_title.lower() not in seen:
                     if is_valid_release(
-                        main_title, base_search_category, search_string, season, episode
+                        main_title,
+                        base_search_category,
+                        search_string,
+                        season,
+                        episode,
+                        episode_date,
                     ):
                         link = generate_download_link(
                             shared_state,
diff --git a/quasarr/search/sources/mb.py b/quasarr/search/sources/mb.py
index b8a99a1e..cc00c7b7 100644
--- a/quasarr/search/sources/mb.py
+++ b/quasarr/search/sources/mb.py
@@ -52,6 +52,7 @@ def _parse_posts(
         search_string=None,
         season=None,
         episode=None,
+        episode_date=None,
     ):
         releases = []
         one_hour_ago = (datetime.now() - timedelta(hours=1)).strftime(
@@ -85,7 +86,12 @@ def _parse_posts(
 
                 if is_search:
                     if not is_valid_release(
-                        title, search_category, search_string, season, episode
+                        title,
+                        search_category,
+                        search_string,
+                        season,
+                        episode,
+                        episode_date,
                     ):
                         continue
 
@@ -198,6 +204,7 @@ def search(
         search_string: str = "",
         season: int = None,
         episode: int = None,
+        episode_date=None,
     ) -> list[SearchRelease]:
         mb = shared_state.values["config"]("Hostnames").get(self.initials)
 
@@ -226,6 +233,7 @@ def search(
                 search_string=search_string,
                 season=season,
                 episode=episode,
+                episode_date=episode_date,
             )
         except Exception as e:
             warn(f"Error loading search: {e}")
diff --git a/quasarr/search/sources/mx.py b/quasarr/search/sources/mx.py
index 62bde7ba..e94faae7 100644
--- a/quasarr/search/sources/mx.py
+++ b/quasarr/search/sources/mx.py
@@ -51,6 +51,7 @@ class Source(AbstractSearchSource):
     language = "fr"
     supports_imdb = True
     supports_phrase = False
+    supports_date_numbering = False
     supported_categories = [SEARCH_CAT_MOVIES, SEARCH_CAT_SHOWS]
     # The movie feed reads Radarr and the show feed reads Sonarr (ID search
     # needs neither). Setup prompts remain source-wide, but feed() degrades
diff --git a/quasarr/search/sources/nk.py b/quasarr/search/sources/nk.py
index f03709cf..15b27664 100644
--- a/quasarr/search/sources/nk.py
+++ b/quasarr/search/sources/nk.py
@@ -51,6 +51,7 @@ def search(
         search_string: str = "",
         season: int = None,
         episode: int = None,
+        episode_date=None,
     ) -> list[SearchRelease]:
         releases = []
         host = shared_state.values["config"]("Hostnames").get(self.initials)
@@ -81,7 +82,7 @@ def search(
             search_type = "search"
             timeout = SEARCH_REQUEST_TIMEOUT_SECONDS
 
-        if season:
+        if season and episode_date is None:
             source_search += f" S{int(season):02d}"
 
             if episode:
@@ -137,7 +138,12 @@ def search(
                     release_imdb_id = imdb_id
 
                 if not is_valid_release(
-                    title, search_category, search_string, season, episode
+                    title,
+                    search_category,
+                    search_string,
+                    season,
+                    episode,
+                    episode_date,
                 ):
                     continue
 
diff --git a/quasarr/search/sources/nx.py b/quasarr/search/sources/nx.py
index 4615e478..7eb0678e 100644
--- a/quasarr/search/sources/nx.py
+++ b/quasarr/search/sources/nx.py
@@ -155,6 +155,7 @@ def search(
         search_string: str = "",
         season: int = None,
         episode: int = None,
+        episode_date=None,
     ) -> list[SearchRelease]:
         """
         Search using internal API.
@@ -212,7 +213,12 @@ def search(
                     title = item["name"]
                     if title:
                         if not is_valid_release(
-                            title, search_category, search_string, season, episode
+                            title,
+                            search_category,
+                            search_string,
+                            season,
+                            episode,
+                            episode_date,
                         ):
                             continue
 
diff --git a/quasarr/search/sources/rm.py b/quasarr/search/sources/rm.py
index 9d0568de..92b7af25 100644
--- a/quasarr/search/sources/rm.py
+++ b/quasarr/search/sources/rm.py
@@ -98,6 +98,7 @@ def search(
         search_string: str = "",
         season: int = None,
         episode: int = None,
+        episode_date=None,
     ) -> list[SearchRelease]:
         releases = []
         match_search_string = search_string
@@ -141,6 +142,7 @@ def search(
                 imdb_id=imdb_id,
                 season=season,
                 episode=episode,
+                episode_date=episode_date,
             )
         except Exception as e:
             warn(f"Error loading search: {e}")
@@ -296,8 +298,19 @@ def _matches_requested_release(
     search_string,
     season=None,
     episode=None,
+    episode_date=None,
 ):
     base_search_category = get_base_search_category_id(search_category)
+    if episode_date is not None:
+        return is_valid_release(
+            title,
+            search_category,
+            search_string,
+            season,
+            episode,
+            episode_date,
+        )
+
     if base_search_category != SEARCH_CAT_SHOWS:
         return is_valid_release(title, search_category, search_string, season, episode)
 
@@ -345,6 +358,7 @@ def _build_search_results(
     imdb_id,
     season=None,
     episode=None,
+    episode_date=None,
     is_feed=False,
 ):
     base_url = _get_base_url(shared_state)
@@ -370,6 +384,7 @@ def _build_search_results(
                 search_string,
                 season,
                 episode,
+                episode_date,
             ):
                 continue
 
diff --git a/quasarr/search/sources/sf.py b/quasarr/search/sources/sf.py
index d97a2c3b..3965afeb 100644
--- a/quasarr/search/sources/sf.py
+++ b/quasarr/search/sources/sf.py
@@ -147,6 +147,7 @@ def search(
         search_string: str = "",
         season: int = None,
         episode: int = None,
+        episode_date=None,
     ) -> list[SearchRelease]:
         releases = []
         sf = shared_state.values["config"]("Hostnames").get(self.initials)
@@ -310,7 +311,7 @@ def search(
                         debug(f"Error extracting size for {title}: {e}")
                         mb = 0
 
-                    if episode:
+                    if episode and episode_date is None:
                         try:
                             if not re.search(r"S\d{1,3}E\d{1,3}", title):
                                 episodes_in_release = len(mirrors["episodes"])
@@ -354,7 +355,12 @@ def search(
 
                     # check down here on purpose, because the title may be modified at episode stage
                     if not is_valid_release(
-                        title, search_category, search_string, season, episode
+                        title,
+                        search_category,
+                        search_string,
+                        season,
+                        episode,
+                        episode_date,
                     ):
                         continue
 
diff --git a/quasarr/search/sources/sj.py b/quasarr/search/sources/sj.py
index d8380da0..bb288730 100644
--- a/quasarr/search/sources/sj.py
+++ b/quasarr/search/sources/sj.py
@@ -132,6 +132,7 @@ def search(
         search_string: str = "",
         season: int = None,
         episode: int = None,
+        episode_date=None,
     ) -> list[SearchRelease]:
         releases = []
 
@@ -222,7 +223,12 @@ def search(
                             continue
 
                         if not is_valid_release(
-                            title, search_category, search_string, season, episode
+                            title,
+                            search_category,
+                            search_string,
+                            season,
+                            episode,
+                            episode_date,
                         ):
                             continue
 
diff --git a/quasarr/search/sources/sl.py b/quasarr/search/sources/sl.py
index 2958f24f..1f1df8ee 100644
--- a/quasarr/search/sources/sl.py
+++ b/quasarr/search/sources/sl.py
@@ -177,6 +177,7 @@ def search(
         search_string: str = "",
         season: int = None,
         episode: int = None,
+        episode_date=None,
     ) -> list[SearchRelease]:
         releases = []
 
@@ -271,7 +272,12 @@ def fetch(url):
                             title = a.get_text(strip=True)
 
                             if not is_valid_release(
-                                title, search_category, search_string, season, episode
+                                title,
+                                search_category,
+                                search_string,
+                                season,
+                                episode,
+                                episode_date,
                             ):
                                 continue
 
diff --git a/quasarr/search/sources/wd.py b/quasarr/search/sources/wd.py
index 00b977ca..012cfb5d 100644
--- a/quasarr/search/sources/wd.py
+++ b/quasarr/search/sources/wd.py
@@ -132,6 +132,7 @@ def search(
         search_string: str = "",
         season: int = None,
         episode: int = None,
+        episode_date=None,
     ) -> list[SearchRelease]:
         releases = []
         wd = shared_state.values["config"]("Hostnames").get(self.initials)
@@ -196,6 +197,7 @@ def search(
                 search_string=search_string,
                 season=season,
                 episode=episode,
+                episode_date=episode_date,
                 imdb_id=imdb_id,
             )
         except Exception as e:
@@ -220,6 +222,7 @@ def _parse_rows(
         search_string=None,
         season=None,
         episode=None,
+        episode_date=None,
         imdb_id=None,
     ):
         """
@@ -261,7 +264,12 @@ def _parse_rows(
                 # search context contains non-video releases (ebooks, games, etc.)
                 if is_search:
                     if not is_valid_release(
-                        title, search_category, search_string, season, episode
+                        title,
+                        search_category,
+                        search_string,
+                        season,
+                        episode,
+                        episode_date,
                     ):
                         continue
 
diff --git a/quasarr/search/sources/wx.py b/quasarr/search/sources/wx.py
index 007f2ad2..900faa10 100644
--- a/quasarr/search/sources/wx.py
+++ b/quasarr/search/sources/wx.py
@@ -168,6 +168,7 @@ def search(
         search_string: str = "",
         season: int = None,
         episode: int = None,
+        episode_date=None,
     ) -> list[SearchRelease]:
         """
         Search using internal API.
@@ -301,7 +302,12 @@ def search(
                         title = title.replace(" ", ".")
 
                         if is_valid_release(
-                            title, search_category, search_string, season, episode
+                            title,
+                            search_category,
+                            search_string,
+                            season,
+                            episode,
+                            episode_date,
                         ):
                             # Skip if we've already seen this exact title
                             if title in seen_titles:
@@ -364,6 +370,7 @@ def search(
                                     search_string,
                                     season,
                                     episode,
+                                    episode_date,
                                 ):
                                     continue
 
diff --git a/tests/AGENTS.md b/tests/AGENTS.md
index 35d70975..2ba5900b 100644
--- a/tests/AGENTS.md
+++ b/tests/AGENTS.md
@@ -14,6 +14,7 @@ Hermetic unit tests for Quasarr, built exclusively on the standard-library `unit
 - Full-suite command: `uv run python -X utf8 -m unittest discover -s tests` (the `-X utf8` flag avoids Windows console encoding noise in log output).
 - Tests must not perform network I/O or touch JDownloader. Patch in the consuming module's namespace (e.g. `quasarr.downloads.sources.<xx>.requests.Session`), not the `requests` library globally. Only `test_sqlite_database.py` touches disk, via `tempfile.TemporaryDirectory`.
 - Synthetic-data rule (security-critical): source hostnames in tests are fake domains on the reserved `.invalid` TLD; use synthetic release titles (never paste real ones). Real public hoster/crypter domains are permitted only where the production matching logic keys on those literal domains — they are hoster/crypter services, not protected sources.
+- Date-numbering regression tests may name a motivating real series to prove title-alias compatibility, but every complete release string, date, quality/group suffix, hostname, and URL remains synthetic.
 - `shared_state` is always faked (MagicMock with a `.values` dict, SimpleNamespace, or a small local class whose `values["config"]` is a callable returning dicts) — except `test_sqlite_database.py`, which mutates the real module in `setUp`.
 - There is no fixtures directory and no shared test-helpers module: each file defines its own `FakeResponse`/`FakeSession`/fake shared_state inline.
 - Run the full suite after touching shared providers, download flow, search behavior, or notification logic. Per root change discipline, tests change only when the intended behavior in the covered area changed or the existing test is incorrect.
diff --git a/tests/test_dl_jahresthema.py b/tests/test_dl_jahresthema.py
index 678555b6..09bf5737 100644
--- a/tests/test_dl_jahresthema.py
+++ b/tests/test_dl_jahresthema.py
@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 
 import unittest
-from datetime import datetime
+from datetime import date, datetime
 from unittest.mock import patch
 
 from bs4 import BeautifulSoup
@@ -52,7 +52,7 @@ def test_date_thread_candidate_uses_search_tokens_without_release_group_lock(sel
             _should_check_thread_for_date_release(
                 "Sample Show 2026 Collection",
                 "Sample Show",
-                2026,
+                date(2026, 6, 19),
             )
         )
 
@@ -61,7 +61,7 @@ def test_date_thread_candidate_rejects_unrelated_series(self):
             _should_check_thread_for_date_release(
                 "Other Show 2026 Collection",
                 "Sample Show",
-                2026,
+                date(2026, 6, 19),
             )
         )
 
@@ -89,9 +89,7 @@ def test_date_release_from_thread_uses_post_url_only_for_downloadable_post(self)
                 FakeSharedState(),
                 "https://www.source.invalid/thread.1/",
                 "Sample Show",
-                2026,
-                6,
-                19,
+                date(2026, 6, 19),
             )
 
         self.assertEqual(
@@ -117,9 +115,7 @@ def test_date_release_from_thread_pins_downloadable_post(self):
                 FakeSharedState(),
                 "https://www.source.invalid/thread.1/",
                 "Sample Show",
-                2026,
-                6,
-                19,
+                date(2026, 6, 19),
             )
 
         self.assertEqual(
@@ -162,9 +158,7 @@ def fake_fetch(_shared_state, page_url):
                 FakeSharedState(),
                 "https://www.source.invalid/thread.1/",
                 "Sample Show",
-                2026,
-                6,
-                19,
+                date(2026, 6, 19),
             )
 
         self.assertEqual(
@@ -179,6 +173,46 @@ def fake_fetch(_shared_state, page_url):
             release["source"],
         )
 
+    def test_date_release_from_thread_finds_wwe_scheduled_series_generically(self):
+        episode_date = date(2031, 2, 3)
+        cases = (
+            (
+                "WWE Monday Night RAW",
+                "WWE.RAW.2031.02.03.1080p.WEB.h264-GRP",
+                "WWE.Monday.Night.RAW.2031.02.03.1080p.WEB.h264-GRP",
+            ),
+            (
+                "WWE Friday Night SmackDown",
+                "WWE.SmackDown.2031.02.03.1080p.WEB.h264-GRP",
+                "WWE.Friday.Night.SmackDown.2031.02.03.1080p.WEB.h264-GRP",
+            ),
+        )
+
+        for search_string, posted_title, expected_title in cases:
+            with self.subTest(search_string=search_string):
+                html = f"""
+                <article class="message--post" id="post-2">
+                  <div class="bbWrapper">
+                    <p>Title: {posted_title}</p>
+                    <p>https://ddownload.com/example</p>
+                  </div>
+                </article>
+                """
+                with patch(
+                    "quasarr.search.sources.dl._fetch_thread_page",
+                    return_value=FakeResponse(
+                        html, "https://www.source.invalid/thread.1/"
+                    ),
+                ):
+                    release = _date_release_from_thread(
+                        FakeSharedState(),
+                        "https://www.source.invalid/thread.1/",
+                        search_string,
+                        episode_date,
+                    )
+
+                self.assertEqual(expected_title, release["title"])
+
     def test_matches_compact_ct_style_spelling(self):
         current_year = datetime.now().year
 
diff --git a/tests/test_hostname_capabilities.py b/tests/test_hostname_capabilities.py
index ec8c2186..4e7b24d0 100644
--- a/tests/test_hostname_capabilities.py
+++ b/tests/test_hostname_capabilities.py
@@ -1,5 +1,7 @@
+import inspect
 import unittest
 
+from quasarr.constants import SEARCH_CAT_SHOWS
 from quasarr.providers.html_images import FLAG_SVGS, LANGUAGE_FLAG_EMOJI
 from quasarr.search.sources import get_sources
 from quasarr.search.sources.helpers import get_source_metadata
@@ -30,6 +32,48 @@ def test_flag_assets_cover_every_used_language(self):
                 self.assertIn(language, LANGUAGE_FLAG_EMOJI)
                 self.assertIn(language, FLAG_SVGS)
 
+    def test_date_numbering_sources_accept_shared_date_context(self):
+        for key, source in get_sources().items():
+            if (
+                SEARCH_CAT_SHOWS not in source.supported_categories
+                or not source.supports_date_numbering
+            ):
+                continue
+            with self.subTest(source=key):
+                self.assertIn(
+                    "episode_date",
+                    inspect.signature(source.search).parameters,
+                )
+
+    def test_date_numbering_enabled_for_all_compatible_tv_sources(self):
+        expected = {
+            "by",
+            "dd",
+            "dj",
+            "dl",
+            "dt",
+            "dw",
+            "fx",
+            "he",
+            "hs",
+            "mb",
+            "nk",
+            "nx",
+            "rm",
+            "sf",
+            "sj",
+            "sl",
+            "wd",
+            "wx",
+        }
+        actual = {
+            key
+            for key, source in get_sources().items()
+            if SEARCH_CAT_SHOWS in source.supported_categories
+            and source.supports_date_numbering
+        }
+        self.assertEqual(expected, actual)
+
 
 class SourceMetadataTests(unittest.TestCase):
     def test_metadata_exposes_expected_keys_for_every_source(self):
diff --git a/tests/test_utils_release_matching.py b/tests/test_utils_release_matching.py
index fc358a71..f104d0ff 100644
--- a/tests/test_utils_release_matching.py
+++ b/tests/test_utils_release_matching.py
@@ -1,9 +1,16 @@
 # -*- coding: utf-8 -*-
 
 import unittest
+from datetime import date
 
 from quasarr.constants import SEARCH_CAT_SHOWS
-from quasarr.providers.utils import is_valid_release, normalize_optional_int
+from quasarr.providers.utils import (
+    canonicalize_date_numbered_title,
+    date_numbering_search_strings,
+    is_valid_release,
+    normalize_optional_int,
+    parse_episode_date,
+)
 
 
 class ReleaseMatchingUtilsTests(unittest.TestCase):
@@ -14,33 +21,93 @@ def test_normalize_optional_int_parses_numbers(self):
         self.assertEqual(4, normalize_optional_int("4"))
 
     def test_date_numbered_tv_release_matches_date_components(self):
+        episode_date = date(2031, 6, 19)
         self.assertTrue(
             is_valid_release(
-                "Sample.Show.2026.06.19.1080p.WEB.h264-GRP",
+                "Sample.Show.2031.06.19.1080p.WEB.h264-GRP",
                 SEARCH_CAT_SHOWS,
                 "Sample Show",
-                season=2026,
+                season=2031,
                 episode="06/19",
-                episode_year=2026,
-                episode_month=6,
-                episode_day=19,
+                episode_date=episode_date,
             )
         )
 
     def test_date_numbered_tv_release_rejects_wrong_date(self):
+        episode_date = date(2031, 6, 19)
         self.assertFalse(
             is_valid_release(
-                "Sample.Show.2026.06.18.1080p.WEB.h264-GRP",
+                "Sample.Show.2031.06.18.1080p.WEB.h264-GRP",
                 SEARCH_CAT_SHOWS,
                 "Sample Show",
-                season=2026,
+                season=2031,
                 episode="06/19",
-                episode_year=2026,
-                episode_month=6,
-                episode_day=19,
+                episode_date=episode_date,
             )
         )
 
+    def test_date_numbered_tv_release_accepts_verified_imdb_search(self):
+        episode_date = date(2031, 6, 19)
+        self.assertTrue(
+            is_valid_release(
+                "Sample.Show.2031.06.19.1080p.WEB.h264-GRP",
+                SEARCH_CAT_SHOWS,
+                "tt0000001",
+                season=2031,
+                episode="06/19",
+                episode_date=episode_date,
+            )
+        )
+
+    def test_parse_episode_date_validates_calendar_date(self):
+        self.assertEqual(date(2031, 2, 3), parse_episode_date(2031, "02/03"))
+        self.assertIsNone(parse_episode_date(2031, "02/30"))
+        self.assertIsNone(parse_episode_date(2031, "2"))
+
+    def test_date_numbering_canonicalizes_generic_scheduled_title(self):
+        episode_date = date(2031, 2, 3)
+        self.assertEqual(
+            "Sample.Monday.Night.Showcase.2031.02.03.1080p-GRP",
+            canonicalize_date_numbered_title(
+                "Sample.Showcase.2031.02.03.1080p-GRP",
+                "Sample Monday Night Showcase",
+                episode_date,
+            ),
+        )
+
+    def test_wwe_raw_uses_generic_schedule_alias_and_canonical_title(self):
+        episode_date = date(2031, 2, 3)
+        search_strings = date_numbering_search_strings(
+            "WWE Monday Night RAW", episode_date
+        )
+
+        self.assertIn("WWE RAW 2031.02.03", search_strings)
+        self.assertEqual(
+            "WWE.Monday.Night.RAW.2031.02.03.1080p-GRP",
+            canonicalize_date_numbered_title(
+                "WWE.RAW.2031.02.03.1080p-GRP",
+                "WWE Monday Night RAW",
+                episode_date,
+            ),
+        )
+
+    def test_wwe_smackdown_uses_generic_schedule_and_case_variants(self):
+        episode_date = date(2031, 2, 3)
+        search_strings = date_numbering_search_strings(
+            "WWE Friday Night SmackDown", episode_date
+        )
+
+        self.assertIn("WWE SmackDown 2031.02.03", search_strings)
+        self.assertIn("WWE Smackdown 2031.02.03", search_strings)
+        self.assertEqual(
+            "WWE.Friday.Night.SmackDown.2031.02.03.1080p-GRP",
+            canonicalize_date_numbered_title(
+                "WWE.SmackDown.2031.02.03.1080p-GRP",
+                "WWE Friday Night SmackDown",
+                episode_date,
+            ),
+        )
+
 
 if __name__ == "__main__":
     unittest.main()