dev: bump to 0.1.91.5-dev TMDb Helper Fix, Autoplay Fix, Gesperrte Hoster

CHANGELOG-DEV.md

@@ -1,3 +1,55 @@
+## 0.1.91.0-dev - 2026-04-10
+
+- dev: bump to 0.1.90.5 pre-commit Hook synchronisiert Changelog-Version mit ZIP-Version
+
+## 0.1.90.5-dev - 2026-04-10
+
+- dev: bump to 0.1.90.0 Changelog und Release-Prozess fix
+
+## 0.1.90.0-dev - 2026-04-10
+
+- dev: bump to 0.1.89.5 Changelog aktualisiert
+
+## 0.1.89.5-dev - 2026-04-10
+
+- dev: bump to 0.1.89.0 Changelog komplett
+
+## 0.1.89.0-dev - 2026-04-10
+
+- dev: bump to 0.1.88.5 Changelog fuer aktuelle Version
+
+## 0.1.88.5-dev - 2026-04-10
+
+- dev: bump to 0.1.88.0 Changelog ergaenzt
+
+## 0.1.88.0-dev - 2026-04-10
+
+- dev: bump to 0.1.87.5 TMDb Helper Player, Metadaten-Fix, Menü-Icons, Filmpalast veeve
+
+## 0.1.87.5-dev - 2026-04-04
+
+- dev: bump to 0.1.87.0-dev Changelog-Prozess verbessert
+
+## 0.1.87.0-dev - 2026-04-04
+
+- dev: bump to 0.1.86.5-dev Trakt-Untermenue, Weiterschauen-Fixes, Scrobbling zuverlässig
+
+## 0.1.86.5-dev - 2026-04-03
+
+- dev: bump to 0.1.86.0-dev Globale Suche konfigurierbar, Changelog-Dialog beim ersten Start
+
+## 0.1.86.0-dev - 2026-04-02
+
+- dev: bump to 0.1.85.5-dev Settings-Menü benutzerfreundlicher gestaltet
+
+## 0.1.85.5-dev - 2026-04-02
+
+- dev: bump to 0.1.85.0-dev settings.xml und default.py auf 0.1.84.5-Stand zurueckgesetzt, serienstream_plugin.py aktuell behalten
+
+## 0.1.85.0-dev - 2026-04-01
+
+- dev: bump to 0.1.84.5-dev settings.xml auf Kodi 19+ Format (version=1) migriert, Level-Filter fuer Expert/Advanced korrigiert
+
 ## 0.1.84.5-dev - 2026-03-31
 
 - dev: bump to 0.1.84.0-dev SerienStream Sammlungen mit Poster/Plot, Session-Cache für Sammlungs-URLs

addon/CHANGELOG-USER.md

@@ -0,0 +1,162 @@
+## 0.1.91.5
+
+**TMDb Helper Integration**
+- SerienStream-Player: Staffel- und Episodennummer werden jetzt korrekt an ViewIT übergeben
+- Direkte Episodenwiedergabe über TMDb Helper funktioniert jetzt zuverlässig
+
+**Autoplay / Hoster**
+- Bevorzugter Hoster wird jetzt korrekt ausgelesen und angewendet
+- Gesperrte Hoster: Einstellungen → Tools → „Gesperrte Hoster konfigurieren" – ausgewählte Hoster werden bei der Wiedergabe übersprungen
+
+**Allgemein**
+- Changelog und Release-Prozess fix.
+
+
+## 0.1.90.0
+
+**TMDb Helper Integration**
+- Einstellungen → Tools: Player-Dateien für TMDb Helper direkt aus ViewIT installierbar
+- Zwei Player mitgeliefert: SerienStream (direkte Episodenwiedergabe) und Globale Suche
+- Menüpunkt ist ausgegraut wenn TMDb Helper nicht installiert ist
+
+**Metadaten / Poster**
+- Poster und Infos werden jetzt korrekt geladen wenn kein eigener TMDb-API-Key eingetragen ist
+- „Neueste Episoden" (SerienStream, Aniworld) zeigt jetzt Poster und Serieninfos
+
+**Topstreamfilm**
+- „Neueste Titel" entfernt – das Feature existiert auf der aktuellen Domain nicht
+
+**Filmpalast**
+- Hoster „Veev HD" wird jetzt erkannt und in der Hoster-Liste angezeigt
+
+**Kosmetik**
+- Menü-Icons für Hauptmenü, Plugin-Menüs und Trakt-Untermenü
+
+## 0.1.89.5
+
+**TMDb Helper Integration**
+- Einstellungen → Tools: Player-Dateien für TMDb Helper direkt aus ViewIT installierbar
+- Zwei Player mitgeliefert: SerienStream (direkte Episodenwiedergabe) und Globale Suche
+- Menüpunkt ist ausgegraut wenn TMDb Helper nicht installiert ist
+
+**Metadaten / Poster**
+- Poster und Infos werden jetzt korrekt geladen wenn kein eigener TMDb-API-Key eingetragen ist
+- „Neueste Episoden" (SerienStream, Aniworld) zeigt jetzt Poster und Serieninfos
+
+**Topstreamfilm**
+- „Neueste Titel" entfernt – das Feature existiert auf der aktuellen Domain nicht
+
+**Filmpalast**
+- Hoster „Veev HD" wird jetzt erkannt und in der Hoster-Liste angezeigt
+
+**Kosmetik**
+- Menü-Icons für Hauptmenü, Plugin-Menüs und Trakt-Untermenü
+
+## 0.1.88.5
+
+**TMDb Helper Integration**
+- Einstellungen → Tools: Player-Dateien für TMDb Helper direkt aus ViewIT installierbar
+- Zwei Player mitgeliefert: SerienStream (direkte Episodenwiedergabe) und Globale Suche
+- Menüpunkt ist ausgegraut wenn TMDb Helper nicht installiert ist
+
+**Metadaten / Poster**
+- Poster und Infos werden jetzt korrekt geladen wenn kein eigener TMDb-API-Key eingetragen ist
+- „Neueste Episoden" (SerienStream, Aniworld) zeigt jetzt Poster und Serieninfos
+
+**Topstreamfilm**
+- „Neueste Titel" entfernt – das Feature existiert auf der aktuellen Domain nicht
+
+**Filmpalast**
+- Hoster „Veev HD" wird jetzt erkannt und in der Hoster-Liste angezeigt
+
+**Kosmetik**
+- Menü-Icons für Hauptmenü, Plugin-Menüs und Trakt-Untermenü
+
+## 0.1.88.0
+
+**TMDb Helper Integration**
+- Einstellungen → Tools: Player-Dateien für TMDb Helper direkt aus ViewIT installierbar
+- Zwei Player mitgeliefert: SerienStream (direkte Episodenwiedergabe) und Globale Suche
+- Menüpunkt ist ausgegraut wenn TMDb Helper nicht installiert ist
+
+**Metadaten / Poster**
+- Poster und Infos werden jetzt korrekt geladen wenn kein eigener TMDb-API-Key eingetragen ist
+- „Neueste Episoden" (SerienStream, Aniworld) zeigt jetzt Poster und Serieninfos
+
+**Topstreamfilm**
+- „Neueste Titel" entfernt – das Feature existiert auf der aktuellen Domain nicht
+
+**Filmpalast**
+- Hoster „Veev HD" wird jetzt erkannt und in der Hoster-Liste angezeigt
+
+**Kosmetik**
+- Menü-Icons für Hauptmenü, Plugin-Menüs und Trakt-Untermenü
+
+## 0.1.87.5
+
+**TMDb Helper Integration**
+- Einstellungen → Tools: Player-Dateien für TMDb Helper direkt aus ViewIT installierbar
+- Zwei Player mitgeliefert: SerienStream (direkte Episodenwiedergabe) und Globale Suche
+- Menüpunkt ist ausgegraut wenn TMDb Helper nicht installiert ist
+
+**Metadaten / Poster**
+- Poster und Infos werden jetzt korrekt geladen wenn kein eigener TMDb-API-Key eingetragen ist (Fallback auf installierten Kodi-Scraper oder Community-Key war nicht aktiv)
+- „Neueste Episoden" (SerienStream, Aniworld) zeigt jetzt Poster und Serieninfos
+
+**Topstreamfilm**
+- „Neueste Titel" entfernt – das Feature existiert auf der aktuellen Domain nicht
+
+**Filmpalast**
+- Hoster „Veev HD" wird jetzt erkannt und in der Hoster-Liste angezeigt
+
+**Kosmetik**
+- Menü-Icons für Hauptmenü, Plugin-Menüs und Trakt-Untermenü
+
+## 0.1.87.0
+
+**Trakt**
+- Alle Trakt-Funktionen sind jetzt unter einem eigenen Untermenüpunkt „Trakt" gebündelt
+- Weiterschauen erkennt Staffelwechsel korrekt (z.B. S02E12 → S03E01 statt S02E13)
+- Scrobbling zuverlässiger: Episoden werden nicht mehr fälschlicherweise als gesehen markiert wenn die Streamlänge unbekannt ist
+- Trakt-IDs werden jetzt auch gefunden wenn TMDB die Serie nicht kennt
+
+
+
+## 0.1.86.5
+
+**Globale Suche**
+- Jedes Such-Plugin in den Einstellungen unter „Globale Suche" einzeln aktivierbar
+- YouTube optional als Suchquelle wählbar
+- Suchergebnisse zeigen den Anbieter in eckigen Klammern an, z.B. „Breaking Bad [Serienstream]"
+
+**Neu beim Start**
+- Nach einem Update wird automatisch ein Changelog-Dialog mit den Neuigkeiten angezeigt
+
+**Einstellungsmenü**
+- Neue Kategorie „Globale Suche" mit Checkboxen für alle Anbieter
+- Trakt-Verbindungsstatus direkt in den Einstellungen sichtbar
+- Bevorzugter Hoster als Auswahlliste, nur aktiv wenn Autoplay eingeschaltet ist
+
+## 0.1.86.0
+
+**Globale Suche verbessert**
+- Jedes Such-Plugin kann in den Einstellungen unter „Globale Suche" einzeln aktiviert oder deaktiviert werden
+- YouTube ist nun ebenfalls als optionale Suchquelle wählbar
+- Suchergebnisse zeigen jetzt den Anbieter in eckigen Klammern an, z.B. „Breaking Bad [Serienstream]"
+
+**Einstellungsmenü übersichtlicher**
+- Neue Kategorie „Globale Suche" mit Checkboxen für alle Anbieter
+- Trakt-Verbindungsstatus direkt in den Einstellungen sichtbar
+- Bevorzugter Hoster als Auswahlliste, nur aktiv wenn Autoplay eingeschaltet ist
+
+## 0.1.84.0
+
+**Trakt Weiterschauen**
+- Serien, die du bereits angeschaut hast, werden über Trakt als „Weiterschauen"-Liste angezeigt
+- Specials (Staffel 0) werden dabei automatisch übersprungen
+
+## 0.1.82.0
+
+**SerienStream Sammlungen**
+- Sammlungen auf SerienStream sind jetzt durchsuchbar
+- Die Liste wird alphabetisch sortiert und Sonderzeichen in Titeln werden bereinigt

addon/addon.xml

@@ -1,5 +1,5 @@
 <?xml version='1.0' encoding='utf-8'?>
-<addon id="plugin.video.viewit" name="ViewIt" version="0.1.85.0-dev" provider-name="ViewIt">
+<addon id="plugin.video.viewit" name="ViewIt" version="0.1.91.5-dev" provider-name="ViewIt">
   <requires>
     <import addon="xbmc.python" version="3.0.0" />
     <import addon="script.module.requests" />

addon/core/trakt.py

@@ -65,6 +65,8 @@ class TraktItem:
     episode_thumb: str = ""     # Screenshot-URL (extended=images)
     show_poster: str = ""       # Serien-Poster-URL (extended=images)
     show_fanart: str = ""       # Serien-Fanart-URL (extended=images)
+    # Staffel → höchste gesehene Episodennummer (für Staffelwechsel-Erkennung)
+    seasons_watched: dict = field(default_factory=dict)
 
 
 @dataclass(frozen=True)
@@ -387,19 +389,26 @@ class TraktClient:
             seasons = entry.get("seasons") or []
             last_season = 0
             last_episode = 0
+            seasons_watched: dict[int, int] = {}
             for s in seasons:
                 snum = int((s.get("number") or 0))
                 if snum == 0:  # Specials überspringen
                     continue
+                max_ep = 0
                 for ep in (s.get("episodes") or []):
                     enum = int((ep.get("number") or 0))
+                    if enum > max_ep:
+                        max_ep = enum
                     if snum > last_season or (snum == last_season and enum > last_episode):
                         last_season = snum
                         last_episode = enum
+                if max_ep > 0:
+                    seasons_watched[snum] = max_ep
             if title:
                 result.append(TraktItem(
                     title=title, year=year, media_type="episode",
                     ids=ids, season=last_season, episode=last_episode,
+                    seasons_watched=seasons_watched,
                 ))
         self._do_log(f"get_watched_shows: {len(result)} Serien")
         return result
@@ -461,6 +470,21 @@ class TraktClient:
         ids = show.get("ids") or {}
         return str(ids.get("slug") or ids.get("trakt") or "")
 
+    def search_show_ids(self, query: str) -> "tuple[int, str]":
+        """GET /search/show?query=... – gibt (tmdb_id, imdb_id) des ersten Treffers zurück.
+        Fallback wenn TMDB keine IDs liefert.
+        """
+        from urllib.parse import urlencode
+        path = f"/search/show?{urlencode({'query': query, 'limit': 1})}"
+        status, payload = self._get(path)
+        if status != 200 or not isinstance(payload, list) or not payload:
+            return 0, ""
+        show = (payload[0] or {}).get("show") or {}
+        ids = show.get("ids") or {}
+        tmdb_id = int(ids.get("tmdb") or 0)
+        imdb_id = str(ids.get("imdb") or "")
+        return tmdb_id, imdb_id
+
     def lookup_tv_season(
         self,
         show_id_or_slug: "str | int",

addon/default.py

@@ -117,11 +117,26 @@ from metadata_utils import (
     needs_tmdb as _needs_tmdb,
 )
 from tmdb import TmdbCastMember, TmdbExternalIds, fetch_external_ids, fetch_tv_episode_credits, lookup_movie, lookup_tv_season, lookup_tv_season_summary, lookup_tv_show
+from core.metadata import _resolve_tmdb_api_key
 from core.router import Router
+from hosters import ALL_HOSTERS, normalize_hoster_name
 
 _router = Router()
 
 PLUGIN_DIR = Path(__file__).with_name("plugins")
+_PICTURES_DIR = Path(__file__).parent / "pictures"
+_MENU_ICONS: dict[str, str] = {
+    "search":         str(_PICTURES_DIR / "suche.png"),
+    "plugin_search":  str(_PICTURES_DIR / "suche.png"),
+    "genres":         str(_PICTURES_DIR / "generes.png"),
+    "alpha_index":    str(_PICTURES_DIR / "a_z.png"),
+    "series_catalog": str(_PICTURES_DIR / "serien.png"),
+    "settings":       str(_PICTURES_DIR / "einstellung.png"),
+    "trakt_menu":     str(_PICTURES_DIR / "seriensammlung.png"),
+    "trakt_continue": str(_PICTURES_DIR / "hgesehn.png"),
+    "latest_titles":  str(_PICTURES_DIR / "neuste.png"),
+}
+
 _PLUGIN_CACHE: dict[str, BasisPlugin] | None = None
 _TMDB_CACHE: dict[str, tuple[dict[str, str], dict[str, str]]] = {}
 _TMDB_CAST_CACHE: dict[str, list[TmdbCastMember]] = {}
@@ -132,6 +147,8 @@ _TMDB_SEASON_CACHE: dict[tuple[int, int, str, str], dict[int, tuple[dict[str, st
 _TMDB_SEASON_SUMMARY_CACHE: dict[tuple[int, int, str, str], tuple[dict[str, str], dict[str, str]]] = {}
 _TMDB_EPISODE_CAST_CACHE: dict[tuple[int, int, int, str], list[TmdbCastMember]] = {}
 _TRAKT_SEASON_META_CACHE: dict = {}
+_TRAKT_SEASON_META_CACHE_TS: float = 0.0
+_TRAKT_SEASON_META_CACHE_TTL: int = 1800  # 30 Minuten
 _TMDB_LOG_PATH: str | None = None
 _GENRE_TITLES_CACHE: dict[tuple[str, str], list[str]] = {}
 _ADDON_INSTANCE = None
@@ -177,7 +194,7 @@ def _fetch_and_cache_imdb_id(title_key: str, tmdb_id: int, kind: str) -> str:
     cached = _tmdb_cache_get(_IMDB_ID_CACHE, title_key)
     if cached is not None:
         return cached
-    api_key = _get_setting_string("tmdb_api_key").strip()
+    api_key = _resolve_tmdb_api_key(_get_setting_string("tmdb_api_key").strip())
     if not api_key or api_key == "None" or not tmdb_id:
         return ""
     ext = fetch_external_ids(kind=kind, tmdb_id=tmdb_id, api_key=api_key)
@@ -205,19 +222,6 @@ def _set_trakt_ids_property(title: str, tmdb_id: int, imdb_id: str = "") -> None
 # Trakt-Helfer
 # ---------------------------------------------------------------------------
 
-_PREFERRED_HOSTERS_LIST = ["voe", "streamtape", "doodstream", "vidoza", "mixdrop", "supervideo", "dropload"]
-
-
-def _get_preferred_hoster() -> str:
-    """Liest preferred_hoster (enum-Index) und gibt den Hosternamen zurück."""
-    raw = _get_setting_string("preferred_hoster").strip()
-    try:
-        idx = int(raw)
-        return _PREFERRED_HOSTERS_LIST[idx]
-    except (ValueError, IndexError):
-        return raw  # Fallback: alten Textwert direkt verwenden
-
-
 def _trakt_load_token():
     """Laedt den gespeicherten Trakt-Token aus den Addon-Settings."""
     access = _get_setting_string("trakt_access_token").strip()
@@ -238,7 +242,6 @@ def _trakt_save_token(token) -> None:
     addon.setSetting("trakt_access_token", token.access_token)
     addon.setSetting("trakt_refresh_token", token.refresh_token)
     addon.setSetting("trakt_token_expires", str(token.expires_at))
-    addon.setSetting("trakt_status", "Verbunden" if token.access_token else "Nicht verbunden")
 
 
 TRAKT_CLIENT_ID = "5f1a46be11faa2ef286d6a5d4fbdcdfe3b19c87d3799c11af8cf25dae5b802e9"
@@ -616,6 +619,71 @@ def _get_setting_int(setting_id: str, *, default: int = 0) -> int:
     return default
 
 
+_PREFERRED_HOSTERS_LIST = [h["id"] for h in ALL_HOSTERS]
+
+
+def _get_preferred_hoster() -> str:
+    """Liest preferred_hoster (enum-Index) und gibt den Hosternamen zurueck."""
+    raw = _get_setting_string("preferred_hoster").strip()
+    raw_int = _get_setting_int("preferred_hoster", default=-1)
+    _log(f"preferred_hoster raw_string='{raw}' raw_int={raw_int}", xbmc.LOGINFO)
+    # getSettingString liefert bei enum den Display-Wert (z.B. "voe"), nicht den Index.
+    # Prüfe ob raw bereits ein bekannter Hoster-Name ist.
+    if raw.casefold() in [h.casefold() for h in _PREFERRED_HOSTERS_LIST]:
+        return raw
+    # Fallback: Index-basiert über getSettingInt
+    if raw_int >= 0:
+        try:
+            return _PREFERRED_HOSTERS_LIST[raw_int]
+        except IndexError:
+            pass
+    # Fallback: Index aus String
+    try:
+        return _PREFERRED_HOSTERS_LIST[int(raw)]
+    except (ValueError, IndexError):
+        return raw
+
+
+def _get_blocked_hosters() -> set[str]:
+    """Gibt die Menge der gesperrten Hoster-IDs zurück."""
+    raw = _get_setting_string("blocked_hosters").strip()
+    if not raw:
+        return set()
+    return {h.strip().casefold() for h in raw.split(",") if h.strip()}
+
+
+def _filter_hosters(hosters: list[str], blocked: set[str]) -> list[str]:
+    """Entfernt gesperrte Hoster aus der Liste. Unbekannte Hoster bleiben erhalten."""
+    if not blocked:
+        return hosters
+    result = []
+    for h in hosters:
+        hid = normalize_hoster_name(h)
+        if hid and hid.casefold() in blocked:
+            _log(f"Hoster '{h}' ist gesperrt und wird entfernt.", xbmc.LOGDEBUG)
+            continue
+        result.append(h)
+    return result
+
+
+def _configure_blocked_hosters_dialog() -> None:
+    """Multi-Select-Dialog zum Sperren/Entsperren von Hostern."""
+    blocked = _get_blocked_hosters()
+    labels = [h["display"] for h in ALL_HOSTERS]
+    preselected = [i for i, h in enumerate(ALL_HOSTERS) if h["id"].casefold() in blocked]
+
+    result = xbmcgui.Dialog().multiselect("Gesperrte Hoster auswaehlen", labels, preselect=preselected)
+    if result is None:
+        return  # Abgebrochen
+
+    blocked_ids = sorted(ALL_HOSTERS[i]["id"] for i in result)
+    _set_setting_string("blocked_hosters", ",".join(blocked_ids))
+    count = len(blocked_ids)
+    msg = f"{count} Hoster gesperrt" if count else "Keine Hoster gesperrt"
+    xbmcgui.Dialog().notification("Hoster-Sperrung", msg, xbmcgui.NOTIFICATION_INFO, 3000)
+    _log(f"Gesperrte Hoster gespeichert: {blocked_ids}", xbmc.LOGINFO)
+
+
 def _metadata_policy(
     plugin_name: str,
     plugin: BasisPlugin,
@@ -868,7 +936,7 @@ def _tmdb_labels_and_art(title: str) -> tuple[dict[str, str], dict[str, str], li
     art: dict[str, str] = {}
     cast: list[TmdbCastMember] = []
     query = (title or "").strip()
-    api_key = _get_setting_string("tmdb_api_key").strip()
+    api_key = _resolve_tmdb_api_key(_get_setting_string("tmdb_api_key").strip())
     log_requests = _get_setting_bool("tmdb_log_requests", default=False)
     log_responses = _get_setting_bool("tmdb_log_responses", default=False)
     if api_key and api_key != "None":
@@ -1018,7 +1086,7 @@ def _tmdb_episode_labels_and_art(*, title: str, season_label: str, episode_label
     season_key = (tmdb_id, season_number, language, flags)
     cached_season = _tmdb_cache_get(_TMDB_SEASON_CACHE, season_key)
     if cached_season is None:
-        api_key = _get_setting_string("tmdb_api_key").strip()
+        api_key = _resolve_tmdb_api_key(_get_setting_string("tmdb_api_key").strip())
         if not api_key or api_key == "None":
             return _trakt_episode_labels_and_art(
                 title=title, season_label=season_label, episode_label=episode_label
@@ -1064,6 +1132,12 @@ def _trakt_episode_labels_and_art(
     Lädt Staffel-Episodendaten per Batch (extended=full,images) und optionale
     deutsche Übersetzung per Episode (Translations-Endpunkt).
     """
+    global _TRAKT_SEASON_META_CACHE_TS
+    now = time.time()
+    if now - _TRAKT_SEASON_META_CACHE_TS > _TRAKT_SEASON_META_CACHE_TTL:
+        _TRAKT_SEASON_META_CACHE.clear()
+        _TRAKT_SEASON_META_CACHE_TS = now
+
     client = _trakt_get_client()
     if not client:
         return {"title": episode_label}, {}
@@ -1143,7 +1217,7 @@ def _tmdb_episode_cast(*, title: str, season_label: str, episode_label: str) ->
     if cached is not None:
         return list(cached)
 
-    api_key = _get_setting_string("tmdb_api_key").strip()
+    api_key = _resolve_tmdb_api_key(_get_setting_string("tmdb_api_key").strip())
     if not api_key or api_key == "None":
         _tmdb_cache_set(_TMDB_EPISODE_CAST_CACHE, cache_key, [])
         return []
@@ -1171,6 +1245,11 @@ def _tmdb_episode_cast(*, title: str, season_label: str, episode_label: str) ->
     return list(cast)
 
 
+def _icon_for(action: str) -> dict[str, str] | None:
+    path = _MENU_ICONS.get(action)
+    return {"icon": path, "thumb": path} if path else None
+
+
 def _add_directory_item(
     handle: int,
     label: str,
@@ -1230,6 +1309,29 @@ UPDATE_ADDON_ID = "plugin.video.viewit"
 RESOLVEURL_ADDON_ID = "script.module.resolveurl"
 RESOLVEURL_AUTO_INSTALL_INTERVAL_SEC = 6 * 60 * 60
 YTDLP_ADDON_ID = "script.module.yt-dlp"
+TMDB_HELPER_ADDON_ID = "plugin.video.themoviedb.helper"
+
+
+def _kodi_userdata_dir() -> Path:
+    """Ermittelt das Kodi-Userdata-Verzeichnis plattformübergreifend."""
+    import platform
+    system = platform.system()
+    if system == "Windows":
+        appdata = os.environ.get("APPDATA") or os.environ.get("LOCALAPPDATA") or ""
+        if appdata:
+            return Path(appdata) / "Kodi" / "userdata"
+    if system == "Darwin":
+        return Path.home() / "Library" / "Application Support" / "Kodi" / "userdata"
+    # Linux, LibreELEC, OSMC, Flatpak-Fallback → ~/.kodi/userdata
+    flatpak = Path.home() / ".var" / "app" / "tv.kodi.Kodi" / "data" / "userdata"
+    if flatpak.exists():
+        return flatpak
+    return Path.home() / ".kodi" / "userdata"
+
+
+def _tmdb_helper_players_dir() -> Path:
+    """Gibt das players/-Verzeichnis im TMDb-Helper-Addon-Data-Ordner zurück."""
+    return _kodi_userdata_dir() / "addon_data" / TMDB_HELPER_ADDON_ID / "players"
 
 
 def _selected_update_channel() -> int:
@@ -1549,6 +1651,11 @@ def _install_addon_version(info_url: str, version: str) -> bool:
     return _install_addon_version_manual(info_url, version)
 
 
+def _sync_trakt_status_setting() -> None:
+    connected = bool(_trakt_load_token())
+    _get_addon().setSetting("trakt_status", "Verbunden" if connected else "Nicht verbunden")
+
+
 def _sync_update_channel_status_settings() -> None:
     channel = _selected_update_channel()
     selected_info_url = _resolve_update_info_url()
@@ -1556,13 +1663,6 @@ def _sync_update_channel_status_settings() -> None:
     _set_setting_string("update_active_channel", _channel_label(channel))
     _set_setting_string("update_active_repo_url", selected_info_url)
     _set_setting_string("update_available_selected", available_selected)
-    installed = _get_setting_string("update_installed_version").strip()
-    has_update = (
-        bool(available_selected) and available_selected not in ("-", "", "0.0.0")
-        and bool(installed) and installed not in ("-", "", "0.0.0")
-        and _version_sort_key(available_selected) > _version_sort_key(installed)
-    )
-    _get_addon().setSettingBool("update_available_flag", has_update)
 
 
 def _repo_addon_xml_path() -> str:
@@ -1710,7 +1810,6 @@ def _maybe_auto_install_resolveurl(action: str | None) -> None:
 
 
 def _sync_tmdb_active_key_setting() -> None:
-    from core.metadata import _resolve_tmdb_api_key
     raw_key = _get_setting_string("tmdb_api_key").strip()
     active_key = _resolve_tmdb_api_key(raw_key)
     if active_key:
@@ -1725,6 +1824,35 @@ def _sync_ytdlp_status_setting() -> None:
     _set_setting_string("ytdlp_status", status)
 
 
+def _sync_tmdb_helper_status_setting() -> None:
+    status = "Installiert" if _is_addon_installed(TMDB_HELPER_ADDON_ID) else "Nicht installiert"
+    _set_setting_string("tmdb_helper_status", status)
+
+
+_TMDB_HELPER_PLAYERS_SOURCE = Path(__file__).parent / "resources" / "players"
+
+
+def _install_tmdb_helper_players() -> None:
+    if not _is_addon_installed(TMDB_HELPER_ADDON_ID):
+        xbmcgui.Dialog().notification("TMDb Helper", "TMDb Helper ist nicht installiert.", xbmcgui.NOTIFICATION_WARNING, 4000)
+        return
+    try:
+        source_files = list(_TMDB_HELPER_PLAYERS_SOURCE.glob("*.json"))
+        if not source_files:
+            xbmcgui.Dialog().notification("TMDb Helper", "Keine Player-Dateien gefunden.", xbmcgui.NOTIFICATION_WARNING, 4000)
+            return
+        dest_dir = _tmdb_helper_players_dir()
+        dest_dir.mkdir(parents=True, exist_ok=True)
+        import shutil
+        for src in source_files:
+            shutil.copy2(src, dest_dir / src.name)
+        _log(f"TMDb Helper Player installiert: {[f.name for f in source_files]}")
+        xbmcgui.Dialog().notification("TMDb Helper", f"{len(source_files)} Player installiert.", xbmcgui.NOTIFICATION_INFO, 3000)
+    except Exception as exc:
+        _log(f"TMDb Helper Player Installation fehlgeschlagen: {exc}", xbmc.LOGWARNING)
+        xbmcgui.Dialog().notification("TMDb Helper", f"Fehler: {exc}", xbmcgui.NOTIFICATION_ERROR, 5000)
+
+
 def _fetch_ytdlp_zip_url() -> str:
     """Ermittelt die aktuellste ZIP-URL fuer script.module.yt-dlp von GitHub."""
     api_url = "https://api.github.com/repos/lekma/script.module.yt-dlp/releases/latest"
@@ -1821,6 +1949,7 @@ def _sync_update_version_settings() -> None:
     _set_setting_string("update_installed_version", addon_version)
     _sync_resolveurl_status_setting()
     _sync_ytdlp_status_setting()
+    _sync_tmdb_helper_status_setting()
     _sync_update_channel_status_settings()
     _sync_tmdb_active_key_setting()
 
@@ -1839,7 +1968,7 @@ def _show_root_menu() -> None:
             "select_update_version",
         )
 
-    _add_directory_item(handle, "Suche in allen Quellen", "search")
+    _add_directory_item(handle, "Suche in allen Quellen", "search", art=_icon_for("search"))
 
     plugins = _discover_plugins()
     for plugin_name in sorted(plugins.keys(), key=lambda value: value.casefold()):
@@ -1847,15 +1976,22 @@ def _show_root_menu() -> None:
 
     # Trakt-Menue (nur wenn aktiviert)
     if _get_setting_bool("trakt_enabled", default=False):
-        if _trakt_load_token():
+        _add_directory_item(handle, "Trakt", "trakt_menu", is_folder=True, art=_icon_for("trakt_menu"))
-            _add_directory_item(handle, "Weiterschauen", "trakt_continue", is_folder=True)
-            _add_directory_item(handle, "Trakt Upcoming", "trakt_upcoming", is_folder=True)
-            _add_directory_item(handle, "Trakt Watchlist", "trakt_watchlist", is_folder=True)
-            _add_directory_item(handle, "Trakt History", "trakt_history", {"page": "1"}, is_folder=True)
-        else:
-            _add_directory_item(handle, "Trakt autorisieren", "trakt_auth", is_folder=True)
 
-    _add_directory_item(handle, "Einstellungen", "settings")
+    _add_directory_item(handle, "Einstellungen", "settings", art=_icon_for("settings"))
+    xbmcplugin.endOfDirectory(handle)
+
+
+def _show_trakt_menu() -> None:
+    handle = _get_handle()
+    xbmcplugin.setPluginCategory(handle, "Trakt")
+    if _trakt_load_token():
+        _add_directory_item(handle, "Weiterschauen", "trakt_continue", is_folder=True, art=_icon_for("trakt_continue"))
+        _add_directory_item(handle, "Trakt Upcoming", "trakt_upcoming", is_folder=True)
+        _add_directory_item(handle, "Trakt Watchlist", "trakt_watchlist", is_folder=True)
+        _add_directory_item(handle, "Trakt History", "trakt_history", {"page": "1"}, is_folder=True)
+    else:
+        _add_directory_item(handle, "Trakt autorisieren", "trakt_auth", is_folder=True)
     xbmcplugin.endOfDirectory(handle)
 
 
@@ -1871,19 +2007,19 @@ def _show_plugin_menu(plugin_name: str) -> None:
     xbmcplugin.setPluginCategory(handle, plugin_name)
 
     if callable(getattr(plugin, "search_titles", None)):
-        _add_directory_item(handle, "Suche", "plugin_search", {"plugin": plugin_name}, is_folder=True)
+        _add_directory_item(handle, "Suche", "plugin_search", {"plugin": plugin_name}, is_folder=True, art=_icon_for("plugin_search"))
 
     if _plugin_has_capability(plugin, "new_titles") or _plugin_has_capability(plugin, "latest_episodes"):
-        _add_directory_item(handle, LATEST_MENU_LABEL, "latest_titles", {"plugin": plugin_name, "page": "1"}, is_folder=True)
+        _add_directory_item(handle, LATEST_MENU_LABEL, "latest_titles", {"plugin": plugin_name, "page": "1"}, is_folder=True, art=_icon_for("latest_titles"))
 
     if _plugin_has_capability(plugin, "genres"):
-        _add_directory_item(handle, "Genres", "genres", {"plugin": plugin_name}, is_folder=True)
+        _add_directory_item(handle, "Genres", "genres", {"plugin": plugin_name}, is_folder=True, art=_icon_for("genres"))
 
     if _plugin_has_capability(plugin, "alpha"):
-        _add_directory_item(handle, "A-Z", "alpha_index", {"plugin": plugin_name}, is_folder=True)
+        _add_directory_item(handle, "A-Z", "alpha_index", {"plugin": plugin_name}, is_folder=True, art=_icon_for("alpha_index"))
 
     if _plugin_has_capability(plugin, "series_catalog"):
-        _add_directory_item(handle, "Serien", "series_catalog", {"plugin": plugin_name, "page": "1"}, is_folder=True)
+        _add_directory_item(handle, "Serien", "series_catalog", {"plugin": plugin_name, "page": "1"}, is_folder=True, art=_icon_for("series_catalog"))
 
     if _plugin_has_capability(plugin, "popular_series"):
         _add_directory_item(handle, POPULAR_MENU_LABEL, "popular", {"plugin": plugin_name, "page": "1"}, is_folder=True)
@@ -1906,7 +2042,7 @@ def _show_plugin_menu(plugin_name: str) -> None:
     xbmcplugin.endOfDirectory(handle)
 
 
-def _show_plugin_search(plugin_name: str) -> None:
+def _show_plugin_search(plugin_name: str, query: str = "") -> None:
     plugin_name = (plugin_name or "").strip()
     plugin = _discover_plugins().get(plugin_name)
     if not plugin:
@@ -1914,13 +2050,15 @@ def _show_plugin_search(plugin_name: str) -> None:
         _show_root_menu()
         return
 
-    _log(f"Plugin-Suche gestartet: {plugin_name}")
+    query = (query or "").strip()
-    dialog = xbmcgui.Dialog()
-    query = dialog.input(f"{plugin_name}: Titel eingeben", type=xbmcgui.INPUT_ALPHANUM).strip()
     if not query:
-        _log("Plugin-Suche abgebrochen (leere Eingabe).", xbmc.LOGDEBUG)
+        _log(f"Plugin-Suche gestartet: {plugin_name}")
-        _show_plugin_menu(plugin_name)
+        dialog = xbmcgui.Dialog()
-        return
+        query = dialog.input(f"{plugin_name}: Titel eingeben", type=xbmcgui.INPUT_ALPHANUM).strip()
+        if not query:
+            _log("Plugin-Suche abgebrochen (leere Eingabe).", xbmc.LOGDEBUG)
+            _show_plugin_menu(plugin_name)
+            return
     _log(f"Plugin-Suchbegriff ({plugin_name}): {query}", xbmc.LOGDEBUG)
     _show_plugin_search_results(plugin_name, query)
 
@@ -2191,6 +2329,29 @@ def _clean_search_titles(values: list[str]) -> list[str]:
     return cleaned
 
 
+_SEARCH_PLUGIN_SETTING_IDS: dict[str, str] = {
+    "Serienstream":  "search_plugin_serienstream",
+    "Aniworld":      "search_plugin_aniworld",
+    "Topstreamfilm": "search_plugin_topstreamfilm",
+    "Filmpalast":    "search_plugin_filmpalast",
+    "Moflix":        "search_plugin_moflix",
+    "KKiste":        "search_plugin_kkiste",
+    "HDFilme":       "search_plugin_hdfilme",
+    "Einschalten":   "search_plugin_einschalten",
+    "Doku-Streams":  "search_plugin_doku_streams",
+    "NetzkKino":     "search_plugin_netzkino",
+    "YouTube":       "search_plugin_youtube",
+}
+
+
+def _plugin_search_enabled(plugin_name: str) -> bool:
+    """Gibt True zurück wenn das Plugin in der globalen Suche aktiv ist."""
+    setting_id = _SEARCH_PLUGIN_SETTING_IDS.get(plugin_name)
+    if setting_id is None:
+        return True  # unbekannte Plugins standardmäßig einschließen
+    return _get_setting_bool(setting_id, default=True)
+
+
 def _show_search() -> None:
     _log("Suche gestartet.")
     dialog = xbmcgui.Dialog()
@@ -2215,7 +2376,7 @@ def _show_search_results(query: str) -> None:
     # grouped: casefold-key → Liste der Plugin-Einträge für diesen Titel
     grouped: dict[str, list[dict[str, object]]] = {}
     canceled = False
-    plugin_entries = list(plugins.items())
+    plugin_entries = [(n, p) for n, p in plugins.items() if _plugin_search_enabled(n)]
     total_plugins = max(1, len(plugin_entries))
     with _progress_dialog("Suche laeuft", "Suche startet...") as progress:
         for plugin_index, (plugin_name, plugin) in enumerate(plugin_entries, start=1):
@@ -2320,7 +2481,7 @@ def _show_search_results(query: str) -> None:
             # Nur ein Plugin → direkt zur Staffel-Ansicht
             direct_play = bool(first["direct_play"])
             list_items.append({
-                "label": first["label_base"],
+                "label": f"{first['label_base']} [{first['plugin_name']}]",
                 "action": "play_movie" if direct_play else "seasons",
                 "params": {"plugin": first["plugin_name"], "title": canonical_title, **dict(first["extra_params"])},
                 "is_folder": not direct_play,
@@ -2331,8 +2492,9 @@ def _show_search_results(query: str) -> None:
         else:
             # Mehrere Plugins → Zwischenstufe "Quelle wählen"
             plugin_list = ",".join(str(e["plugin_name"]) for e in entries)
+            provider_label = ", ".join(str(e["plugin_name"]) for e in entries)
             list_items.append({
-                "label": first["label_base"],
+                "label": f"{first['label_base']} [{provider_label}]",
                 "action": "choose_source",
                 "params": {"title": canonical_title, "plugins": plugin_list},
                 "is_folder": True,
@@ -2519,7 +2681,7 @@ def _show_seasons(plugin_name: str, title: str, series_url: str = "") -> None:
     # Staffel-Metadaten (Plot/Poster) optional via TMDB.
     if show_tmdb:
         _tmdb_labels_and_art(title)
-    api_key = _get_setting_string("tmdb_api_key").strip() if show_tmdb else ""
+    api_key = _resolve_tmdb_api_key(_get_setting_string("tmdb_api_key").strip()) if show_tmdb else ""
     language = _get_setting_string("tmdb_language").strip() or "de-DE"
     show_plot = _get_setting_bool("tmdb_show_plot", default=True)
     show_art = _get_setting_bool("tmdb_show_art", default=True)
@@ -3507,6 +3669,8 @@ def _show_latest_episodes(plugin_name: str, page: int = 1) -> None:
         xbmcplugin.endOfDirectory(handle)
         return
 
+    # Unique Serientitel für Metadaten-Prefetch sammeln
+    valid_entries = []
     for entry in entries:
         try:
             title = str(getattr(entry, "series_title", "") or "").strip()
@@ -3518,7 +3682,28 @@ def _show_latest_episodes(plugin_name: str, page: int = 1) -> None:
             continue
         if not title or not url or season_number < 0 or episode_number <= 0:
             continue
+        valid_entries.append((title, season_number, episode_number, url, airdate))
 
+    unique_titles = list(dict.fromkeys(t for t, *_ in valid_entries))
+    use_source, show_tmdb, prefer_source = _metadata_policy(
+        plugin_name, plugin, allow_tmdb=_tmdb_enabled()
+    )
+    plugin_meta = _collect_plugin_metadata(plugin, unique_titles) if use_source else {}
+    show_plot = _get_setting_bool("tmdb_show_plot", default=True)
+    show_art = _get_setting_bool("tmdb_show_art", default=True)
+    tmdb_prefetched: dict[str, tuple[dict[str, str], dict[str, str], list[TmdbCastMember]]] = {}
+    tmdb_titles = list(unique_titles) if show_tmdb else []
+    if show_tmdb and prefer_source and use_source:
+        tmdb_titles = [t for t in unique_titles if _needs_tmdb(
+            (plugin_meta.get(t) or ({}, {}))[0],
+            (plugin_meta.get(t) or ({}, {}))[1],
+            want_plot=show_plot, want_art=show_art,
+        )]
+    if show_tmdb and tmdb_titles:
+        with _busy_dialog(f"{LATEST_MENU_LABEL} wird geladen..."):
+            tmdb_prefetched = _tmdb_labels_and_art_bulk(tmdb_titles)
+
+    for title, season_number, episode_number, url, airdate in valid_entries:
         season_label = f"Staffel {season_number}"
         episode_label = f"Episode {episode_number}"
         key = _playstate_key(plugin_name=plugin_name, title=title, season=season_label, episode=episode_label)
@@ -3527,13 +3712,20 @@ def _show_latest_episodes(plugin_name: str, page: int = 1) -> None:
         label = f"{title} - S{season_number:02d}E{episode_number:02d}"
         label = _label_with_playstate(label, playstate)
 
-        info_labels: dict[str, object] = {
+        tmdb_info, tmdb_art, tmdb_cast = tmdb_prefetched.get(title, ({}, {}, [])) if show_tmdb else ({}, {}, [])
+        meta = plugin_meta.get(title)
+        merged_labels, art, cast = _merge_metadata(title, tmdb_info, tmdb_art, tmdb_cast, meta)
+
+        info_labels: dict[str, object] = dict(merged_labels or {})
+        info_labels.update({
             "title": f"{title} - S{season_number:02d}E{episode_number:02d}",
             "tvshowtitle": title,
             "season": season_number,
             "episode": episode_number,
             "mediatype": "episode",
-        }
+        })
+        if airdate:
+            info_labels.setdefault("aired", airdate)
         info_labels = _apply_playstate_to_info(info_labels, playstate)
 
         _add_directory_item(
@@ -3549,6 +3741,8 @@ def _show_latest_episodes(plugin_name: str, page: int = 1) -> None:
             },
             is_folder=False,
             info_labels=info_labels,
+            art=art,
+            cast=cast,
         )
 
     has_more_fn = getattr(plugin, "latest_episodes_has_more", None)
@@ -4282,8 +4476,10 @@ def _trakt_scrobble_start_async(media: dict[str, object]) -> None:
     threading.Thread(target=_do, daemon=True).start()
 
 
-def _trakt_scrobble_stop_async(media: dict[str, object], progress: float = 100.0) -> None:
+def _trakt_scrobble_stop_async(media: dict[str, object], progress: float = 100.0) -> threading.Thread:
-    """Sendet scrobble/stop an die Trakt-API in einem Hintergrund-Thread."""
+    """Sendet scrobble/stop an die Trakt-API in einem Hintergrund-Thread.
+    Gibt den Thread zurück damit der Aufrufer bei Bedarf darauf warten kann.
+    """
     def _do() -> None:
         try:
             from core.trakt import TraktClient
@@ -4304,7 +4500,9 @@ def _trakt_scrobble_stop_async(media: dict[str, object], progress: float = 100.0
             progress=progress,
         )
         _log(f"Trakt scrobble/stop: {media.get('title')} progress={progress:.0f}%", xbmc.LOGDEBUG)
-    threading.Thread(target=_do, daemon=True).start()
+    t = threading.Thread(target=_do, daemon=True)
+    t.start()
+    return t
 
 
 def _trakt_monitor_playback(media: dict[str, object]) -> None:
@@ -4346,9 +4544,18 @@ def _trakt_monitor_playback(media: dict[str, object]) -> None:
     if monitor.abortRequested():
         return
 
-    progress = min(100.0, (last_pos / total_time * 100.0)) if total_time > 0 else 100.0
+    if total_time > 0:
+        progress = min(100.0, last_pos / total_time * 100.0)
+    elif last_pos > 0:
+        # Keine Gesamtlaufzeit bekannt – kein Scrobble um falsche 100%-Markierung zu vermeiden
+        _log("Trakt monitor: total_time unbekannt, kein Scrobble.", xbmc.LOGDEBUG)
+        return
+    else:
+        _log("Trakt monitor: keine Positionsdaten, kein Scrobble.", xbmc.LOGDEBUG)
+        return
     _log(f"Trakt monitor: Wiedergabe beendet, progress={progress:.0f}%", xbmc.LOGDEBUG)
-    _trakt_scrobble_stop_async(media, progress=progress)
+    stop_thread = _trakt_scrobble_stop_async(media, progress=progress)
+    stop_thread.join(timeout=10)
 
 
 def _track_playback_and_update_state_async(key: str) -> None:
@@ -4410,6 +4617,9 @@ def _play_episode(
     forced_hoster = (forced_hoster or "").strip()
     autoplay = _get_setting_bool("autoplay_enabled", default=False)
     preferred = _get_preferred_hoster()
+    blocked = _get_blocked_hosters()
+    available_hosters = _filter_hosters(available_hosters, blocked)
+    _log(f"Autoplay={autoplay}, preferred='{preferred}', blocked={blocked}, hosters={available_hosters}", xbmc.LOGINFO)
     if available_hosters:
         if forced_hoster:
             for hoster in available_hosters:
@@ -4477,6 +4687,15 @@ def _play_episode(
     if _tmdb_id:
         _imdb_id = _fetch_and_cache_imdb_id(title_key, _tmdb_id, _kind)
         _set_trakt_ids_property(title, _tmdb_id, _imdb_id)
+    if not _tmdb_id and not _imdb_id and _get_setting_bool("trakt_enabled", default=False):
+        # Fallback: Trakt-Titelsuche wenn TMDB keine IDs liefert
+        try:
+            _trakt_client = _trakt_get_client()
+            if _trakt_client:
+                _tmdb_id, _imdb_id = _trakt_client.search_show_ids(title)
+                _log(f"Trakt ID-Fallback fuer '{title}': tmdb={_tmdb_id} imdb={_imdb_id}", xbmc.LOGDEBUG)
+        except Exception:
+            pass
     trakt_media: dict[str, object] = {
         "title": title, "tmdb_id": _tmdb_id, "imdb_id": _imdb_id, "kind": _kind,
         "season": season_number or 0, "episode": episode_number or 0,
@@ -4529,6 +4748,9 @@ def _play_episode_url(
     selected_hoster: str | None = None
     autoplay = _get_setting_bool("autoplay_enabled", default=False)
     preferred = _get_preferred_hoster()
+    blocked = _get_blocked_hosters()
+    available_hosters = _filter_hosters(available_hosters, blocked)
+    _log(f"Autoplay={autoplay}, preferred='{preferred}', blocked={blocked}, hosters={available_hosters}", xbmc.LOGINFO)
     if available_hosters:
         if autoplay and preferred:
             pref_lower = preferred.casefold()
@@ -4737,34 +4959,28 @@ def _show_country_titles_page(plugin_name: str, country: str, page: int = 1) ->
     xbmcplugin.endOfDirectory(handle)
 
 
-def _show_collections_menu(plugin_name: str, page: int = 1) -> None:
+def _show_collections_menu(plugin_name: str) -> None:
-    """Zeigt Sammlungen/Filmreihen eines Plugins (Capability: collections) - paginiert."""
+    """Zeigt Sammlungen/Filmreihen eines Plugins (Capability: collections)."""
     handle = _get_handle()
     plugin = _discover_plugins().get(plugin_name)
     if plugin is None:
         xbmcgui.Dialog().notification("Sammlungen", "Quelle nicht gefunden.", xbmcgui.NOTIFICATION_INFO, 3000)
         xbmcplugin.endOfDirectory(handle)
         return
-    page_getter = getattr(plugin, "_collections_page", None)
+    getter = getattr(plugin, "collections", None)
-    if not callable(page_getter):
+    if not callable(getter):
         xbmcplugin.endOfDirectory(handle)
         return
-    xbmcplugin.setPluginCategory(handle, f"{plugin_name}: Sammlungen (Seite {page})")
+    xbmcplugin.setPluginCategory(handle, f"{plugin_name}: Sammlungen")
     try:
-        cols = list(page_getter(page) or [])
+        cols = list(getter() or [])
     except Exception as exc:
-        _log(f"Sammlungen (Seite {page}) konnten nicht geladen werden ({plugin_name}): {exc}", xbmc.LOGWARNING)
+        _log(f"Sammlungen konnten nicht geladen werden ({plugin_name}): {exc}", xbmc.LOGWARNING)
         xbmcplugin.endOfDirectory(handle)
         return
-    if page > 1:
-        _add_directory_item(handle, "Vorherige Seite", "collections_menu",
-                            {"plugin": plugin_name, "page": str(page - 1)}, is_folder=True)
     for col in cols:
         _add_directory_item(handle, str(col), "collection_titles_page",
                             {"plugin": plugin_name, "collection": str(col), "page": "1"}, is_folder=True)
-    if cols:
-        _add_directory_item(handle, "Naechste Seite", "collections_menu",
-                            {"plugin": plugin_name, "page": str(page + 1)}, is_folder=True)
     xbmcplugin.endOfDirectory(handle)
 
 
@@ -4819,9 +5035,8 @@ def _show_collection_titles_page(plugin_name: str, collection: str, page: int =
             _add_directory_item(handle, title, "seasons",
                                 {"plugin": plugin_name, "title": title, **_series_url_params(plugin, title)},
                                 is_folder=True, info_labels=info_labels, art=art, cast=cast)
-        if getattr(plugin, "_collection_has_more", False):
+        _add_directory_item(handle, "Naechste Seite", "collection_titles_page",
-            _add_directory_item(handle, "Naechste Seite", "collection_titles_page",
+                            {"plugin": plugin_name, "collection": collection, "page": str(page + 1)}, is_folder=True)
-                                {"plugin": plugin_name, "collection": collection, "page": str(page + 1)}, is_folder=True)
     xbmcplugin.endOfDirectory(handle)
 
 
@@ -5226,8 +5441,17 @@ def _show_trakt_continue_watching() -> None:
     tmdb_prefetched = _tmdb_labels_and_art_bulk(list(seen.keys())) if _tmdb_enabled() else {}
 
     for last in seen.values():
-        next_season = last.season
+        # Staffelwechsel erkennen: wenn last.episode die höchste gesehene Episode
-        next_ep = last.episode + 1
+        # der aktuellen Staffel ist und eine höhere Staffel existiert → S+1 E01
+        seasons_watched: dict[int, int] = getattr(last, "seasons_watched", {})
+        max_ep_in_season = seasons_watched.get(last.season, 0)
+        next_seasons = sorted(s for s in seasons_watched if s > last.season)
+        if max_ep_in_season > 0 and last.episode >= max_ep_in_season and next_seasons:
+            next_season = next_seasons[0]
+            next_ep = 1
+        else:
+            next_season = last.season
+            next_ep = last.episode + 1
 
         label = f"{last.title} \u2013 S{next_season:02d}E{next_ep:02d}"
         sub = f"(zuletzt: S{last.season:02d}E{last.episode:02d})"
@@ -5271,7 +5495,7 @@ def _route_plugin_menu(params: dict[str, str]) -> None:
 
 @_router.route("plugin_search")
 def _route_plugin_search(params: dict[str, str]) -> None:
-    _show_plugin_search(params.get("plugin", ""))
+    _show_plugin_search(params.get("plugin", ""), params.get("query", ""))
 
 
 @_router.route("genres")
@@ -5369,6 +5593,16 @@ def _route_install_ytdlp(params: dict[str, str]) -> None:
     _ensure_ytdlp_installed(force=True, silent=False)
 
 
+@_router.route("install_tmdb_helper_players")
+def _route_install_tmdb_helper_players(params: dict[str, str]) -> None:
+    _install_tmdb_helper_players()
+
+
+@_router.route("configure_blocked_hosters")
+def _route_configure_blocked_hosters(params: dict[str, str]) -> None:
+    _configure_blocked_hosters_dialog()
+
+
 @_router.route("choose_source")
 def _route_choose_source(params: dict[str, str]) -> None:
     _show_choose_source(params.get("title", ""), params.get("plugins", ""))
@@ -5419,6 +5653,63 @@ def _route_play_movie(params: dict[str, str]) -> None:
         _play_episode(plugin_name, title, "Film", "Stream", resolve_handle=_get_handle())
 
 
+@_router.route("play_direct")
+def _route_play_direct(params: dict[str, str]) -> None:
+    """Direkte Wiedergabe ohne Ordner-Navigation: sucht Titel im Plugin, nimmt besten Match."""
+    plugin_name = (params.get("plugin", "") or "").strip()
+    query = (params.get("query", "") or "").strip()
+    season_num = _parse_positive_int(params.get("season", "1"), default=1)
+    episode_num = _parse_positive_int(params.get("episode", "1"), default=1)
+    is_movie = params.get("type", "").lower() == "movie"
+
+    plugin = _discover_plugins().get(plugin_name)
+    if not plugin:
+        xbmcgui.Dialog().notification("ViewIT", f"Plugin nicht gefunden: {plugin_name}", xbmcgui.NOTIFICATION_ERROR, 4000)
+        return
+    if not query:
+        xbmcgui.Dialog().notification("ViewIT", "Kein Suchtitel angegeben.", xbmcgui.NOTIFICATION_ERROR, 4000)
+        return
+
+    # Suche im Plugin
+    try:
+        search_coro = _call_plugin_search(plugin, query)
+        results = _run_async(search_coro)
+        results = _clean_search_titles([str(t).strip() for t in (results or []) if t and str(t).strip()])
+    except Exception as exc:
+        xbmcgui.Dialog().notification("ViewIT", f"Suche fehlgeschlagen: {exc}", xbmcgui.NOTIFICATION_ERROR, 4000)
+        return
+
+    if not results:
+        xbmcgui.Dialog().notification("ViewIT", f"Kein Ergebnis für: {query}", xbmcgui.NOTIFICATION_WARNING, 4000)
+        return
+
+    # Besten Match wählen: bevorzuge Titel die den Query enthalten
+    from search_utils import matches_query as _mq
+    matched = [r for r in results if _mq(query, title=r)]
+    title = matched[0] if matched else results[0]
+
+    if is_movie:
+        _play_episode(plugin_name, title, "Film", "Stream", resolve_handle=_get_handle())
+    else:
+        season_label = f"Staffel {season_num}"
+        # Episodenlabel exakt aus dem Plugin holen (z.B. "Episode 3: Titel (Original)")
+        episode_label = f"Episode {episode_num}"
+        episodes = getattr(plugin, "episodes_for", None)
+        if callable(episodes):
+            try:
+                ep_list = episodes(title, season_label)
+                # Suche das Label das mit "Episode {episode_num}:" oder "Episode {episode_num} " beginnt
+                prefix = f"Episode {episode_num}:"
+                prefix2 = f"Episode {episode_num} "
+                for ep in (ep_list or []):
+                    if ep.startswith(prefix) or ep.startswith(prefix2) or ep == f"Episode {episode_num}":
+                        episode_label = ep
+                        break
+            except Exception:
+                pass
+        _play_episode(plugin_name, title, season_label, episode_label, resolve_handle=_get_handle())
+
+
 @_router.route("play_episode_url")
 def _route_play_episode_url(params: dict[str, str]) -> None:
     _play_episode_url(
@@ -5466,10 +5757,7 @@ def _route_country_titles_page(params: dict[str, str]) -> None:
 
 @_router.route("collections_menu")
 def _route_collections_menu(params: dict[str, str]) -> None:
-    _show_collections_menu(
+    _show_collections_menu(params.get("plugin", ""))
-        params.get("plugin", ""),
-        _parse_positive_int(params.get("page", "1"), default=1),
-    )
 
 
 @_router.route("collection_titles_page")
@@ -5498,6 +5786,11 @@ def _route_random_title(params: dict[str, str]) -> None:
     _play_random_title(params.get("plugin", ""))
 
 
+@_router.route("trakt_menu")
+def _route_trakt_menu(params: dict[str, str]) -> None:
+    _show_trakt_menu()
+
+
 @_router.route("trakt_auth")
 def _route_trakt_auth(params: dict[str, str]) -> None:
     _trakt_authorize()
@@ -5571,10 +5864,36 @@ def _route_fallback(params: dict[str, str]) -> None:
     _show_root_menu()
 
 
-def _sync_trakt_status_setting() -> None:
+def _maybe_show_changelog() -> None:
-    """Setzt trakt_status anhand des gespeicherten Tokens."""
+    """Zeigt beim ersten Start nach einem Update das Benutzer-Changelog an."""
-    connected = bool(_trakt_load_token())
+    try:
-    _get_addon().setSetting("trakt_status", "Verbunden" if connected else "Nicht verbunden")
+        current_version = str(_get_addon().getAddonInfo("version") or "").strip()
+        last_shown = _get_setting_string("changelog_last_shown_version").strip()
+        if not current_version or current_version == last_shown:
+            return
+        changelog_path = Path(__file__).parent / "CHANGELOG-USER.md"
+        if not changelog_path.exists():
+            return
+        text = changelog_path.read_text(encoding="utf-8")
+        # Ersten Abschnitt (neueste Version) extrahieren
+        lines = text.splitlines()
+        section: list[str] = []
+        for line in lines:
+            if line.startswith("## ") and section:
+                break
+            section.append(line)
+        content = "\n".join(section).strip()
+        if not content:
+            return
+        viewer = getattr(xbmcgui.Dialog(), "textviewer", None)
+        if callable(viewer):
+            try:
+                viewer("Was ist neu?", content)
+            except Exception:
+                pass
+        _get_addon().setSetting("changelog_last_shown_version", current_version)
+    except Exception as exc:
+        _log(f"Changelog-Anzeige fehlgeschlagen: {exc}", xbmc.LOGWARNING)
 
 
 def run() -> None:
@@ -5584,6 +5903,8 @@ def run() -> None:
     _maybe_run_auto_update_check(action)
     _maybe_auto_install_resolveurl(action)
     _sync_trakt_status_setting()
+    if not action:
+        _maybe_show_changelog()
     _router.dispatch(action=action, params=params)
 
 

addon/hosters.py

@@ -0,0 +1,33 @@
+"""Zentrale Hoster-Definitionen für ViewIT."""
+
+ALL_HOSTERS: list[dict] = [
+    {"id": "voe",         "display": "VOE",         "aliases": ["voe", "voe.sx"]},
+    {"id": "streamtape",  "display": "Streamtape",  "aliases": ["streamtape", "streamtape.com"]},
+    {"id": "doodstream",  "display": "Doodstream",  "aliases": ["doodstream", "dood", "ds2play", "playmogo"]},
+    {"id": "vidoza",      "display": "Vidoza",      "aliases": ["vidoza", "vidoza.net"]},
+    {"id": "mixdrop",     "display": "Mixdrop",     "aliases": ["mixdrop", "mixdrop.co"]},
+    {"id": "supervideo",  "display": "Supervideo",  "aliases": ["supervideo", "supervideo.tv"]},
+    {"id": "dropload",    "display": "Dropload",    "aliases": ["dropload", "dropload.io"]},
+]
+
+
+def get_hoster_ids() -> list[str]:
+    return [h["id"] for h in ALL_HOSTERS]
+
+
+def get_display_names() -> list[str]:
+    return [h["display"] for h in ALL_HOSTERS]
+
+
+def normalize_hoster_name(name: str) -> str | None:
+    """Wandelt Display-Name oder Alias in Hoster-ID um. Gibt None zurück wenn unbekannt."""
+    key = (name or "").casefold().strip()
+    for h in ALL_HOSTERS:
+        if key == h["id"].casefold():
+            return h["id"]
+        if any(key == a.casefold() for a in h["aliases"]):
+            return h["id"]
+        # Substring-Fallback: "Voe Stream" → "voe"
+        if key and h["id"].casefold() in key:
+            return h["id"]
+    return None

addon/plugins/filmpalast_plugin.py

@@ -893,8 +893,8 @@ class FilmpalastPlugin(BasisPlugin):
         for block in soup.select("ul.currentStreamLinks"):
             host_name_node = block.select_one("li.hostBg .hostName")
             host_name = self._normalize_hoster_name(host_name_node.get_text(" ", strip=True) if host_name_node else "")
-            play_anchor = block.select_one("li.streamPlayBtn a[href], a.button.iconPlay[href]")
+            play_anchor = block.select_one("li.streamPlayBtn a[href], li.streamPlayBtn a[data-player-url], a.button.iconPlay[href]")
-            href = (play_anchor.get("href") if play_anchor else "") or ""
+            href = (play_anchor.get("href") or play_anchor.get("data-player-url") if play_anchor else "") or ""
             play_url = _absolute_url(href).strip()
             if not play_url:
                 continue

addon/plugins/topstreamfilm_plugin.py

@@ -1167,7 +1167,7 @@ class TopstreamfilmPlugin(BasisPlugin):
         return resolve_via_resolveurl(link, fallback_to_link=True)
 
     def capabilities(self) -> set[str]:
-        return {"genres", "popular_series", "year_filter", "new_titles"}
+        return {"genres", "popular_series", "year_filter"}
 
     def years_available(self) -> List[str]:
         """Liefert verfügbare Erscheinungsjahre (aktuelles Jahr bis 1980)."""

addon/resources/players/viewit_global.json

@@ -0,0 +1,11 @@
+{
+    "name"              : "ViewIT (Globale Suche)",
+    "plugin"            : "plugin.video.viewit",
+    "priority"          : 900,
+    "assert"            : {
+                            "search_movie":     ["title"],
+                            "search_episode":   ["showname"]
+                          },
+    "search_movie"      : "plugin://plugin.video.viewit/?action=search&query={title_url}",
+    "search_episode"    : "plugin://plugin.video.viewit/?action=search&query={showname_url}"
+}

addon/resources/players/viewit_serienstream.json

@@ -0,0 +1,15 @@
+{
+    "name"              : "ViewIT (SerienStream)",
+    "plugin"            : "plugin.video.viewit",
+    "priority"          : 1000,
+    "provider"          : "SerienStream",
+    "is_resolvable"     : "true",
+    "assert"            : {
+                            "play_movie":       ["title"],
+                            "play_episode":     ["showname", "season", "episode"],
+                            "search_movie":     ["title"]
+                          },
+    "play_movie"        : "plugin://plugin.video.viewit/?action=play_direct&plugin=Serienstream&type=movie&query={title}",
+    "play_episode"      : "plugin://plugin.video.viewit/?action=play_direct&plugin=Serienstream&type=episode&query={showname}&season={season}&episode={episode}",
+    "search_movie"      : "plugin://plugin.video.viewit/?action=plugin_search&plugin=Serienstream&query={title}"
+}

docs/ARCHITECTURE.md

@@ -58,6 +58,26 @@ Es ergänzt die Detaildokumente `DEFAULT_ROUTER.md` und `PLUGIN_SYSTEM.md`.
   - Zentrale Sammlung wiederverwendeter Regulärer Ausdrücke (Staffel/Episoden‑Tags, Ziffern etc.).
   - Ziel: Konsistenz und Vermeidung von fehleranfälligem Copy/Paste in Plugins.
 
+- **yt-dlp Helper (`addon/ytdlp_helper.py`)**
+  - Kapselt Zugriffe auf `yt-dlp` zum Auflösen von Stream-URLs.
+  - Wird als optionales Backend für Hoster genutzt, die weder ResolveURL noch direkte Links liefern.
+
+- **Genre-Helfer (`addon/genre_utils.py`)**
+  - Hilfsfunktionen für Genre-Normalisierung und -Mapping (plugin-übergreifend wiederverwendbar).
+
+- **Such-Helfer (`addon/search_utils.py`)**
+  - Gemeinsame Logik für titelbasierte Volltextsuche (Wortmatch, Normalisierung).
+  - Wird vom Router genutzt, um Plugin-Suchtreffer konsistent zu filtern.
+
+- **Kern-Module (`addon/core/`)**
+  - `trakt.py` – Trakt.tv-Integration (OAuth, Scrobbling, Watchlist, Upcoming, History).
+  - `metadata.py` – Metadaten-Aggregation aus Plugins und TMDB.
+  - `gui.py` – Dialog-Helfer und UI-Utilities (z.B. Changelog-Dialog).
+  - `playstate.py` – Playstate-Hilfsfunktionen (Schlüssel­berechnung, Zustandsabfrage). Eigenes Resume/Watched ist deaktiviert; Kodi verwaltet das selbst.
+  - `plugin_manager.py` – Plugin-Discovery und -Instanziierung.
+  - `router.py` – Routing-Helfer und Aktions-Dispatch.
+  - `updater.py` – Versionsprüfung und Addon-Update-Flow.
+
 - **Plugins (`addon/plugins/*.py`)**
   - Konkrete Integrationen zu einzelnen Providern (z.B. Serien-/Filmportale).
   - Implementieren `BasisPlugin` und optional zusätzliche Capabilities.

docs/DEFAULT_ROUTER.md

@@ -27,9 +27,10 @@ Typische Aktionen:
 - `play_episode_url`
 
 ## Playstate
-- Speicherort: Addon Profilordner, Datei `playstate.json`
+Eigenes Resume/Watched-Tracking ist deaktiviert (`addon/core/playstate.py`).
-- Key: Plugin + Titel + Staffel + Episode
+Kodi verwaltet den Playstate vollständig selbst (Watched-Status, Resume-Position).
-- Werte: watched, playcount, resume_position, resume_total
+Die Helfer-Funktionen in `playstate.py` (Schlüsselberechnung, Zustandsabfrage) sind
+noch vorhanden, aber `track_playback_and_update_state_async()` ist ein No-op.
 
 ## Wichtige Helper
 - Plugin Loader und Discovery

docs/PLUGIN_DEVELOPMENT.md

@@ -19,9 +19,15 @@ Jedes Plugin implementiert:
 - `genres()`
 - `popular_series()`
 - `latest_episodes(page: int = 1)`
+- `latest_titles(page: int = 1)`
 - `titles_for_genre(genre: str)`
 - `titles_for_genre_page(genre: str, page: int)`
 - `titles_for_genre_group_page(...)` / `genre_has_more(...)` (Paging / Alphabet-Gruppen)
+- `years_available()` / `titles_for_year(year, page)`
+- `countries_available()` / `titles_for_country(country, page)`
+- `collections()` / `titles_for_collection(collection, page)`
+- `tags()` / `titles_for_tag(tag, page)`
+- `random_title()`
 - `stream_link_for(...)`
 - `stream_link_for_url(...)`
 - `available_hosters_for(...)`
@@ -39,12 +45,17 @@ Wenn keine echten Staffeln existieren:
 ## Capabilities
 Ein Plugin kann Features melden ueber `capabilities()`.
 Bekannte Werte:
-- `popular_series`
+- `popular_series`   – beliebte Serien/Filme verfügbar
-- `genres`
+- `genres`           – Genre-Navigation
-- `latest_episodes`
+- `latest_episodes`  – neu erschienene Episoden (`latest_episodes(page)`)
-- `new_titles`
+- `new_titles`       – neu hinzugefügte Titel (`latest_titles(page)`)
-- `alpha`
+- `alpha`            – alphabetische Navigation
-- `series_catalog`
+- `series_catalog`   – vollständiger Serienindex
+- `year_filter`      – Filter nach Erscheinungsjahr (`years_available()`, `titles_for_year()`)
+- `country_filter`   – Filter nach Produktionsland (`countries_available()`, `titles_for_country()`)
+- `collections`      – Sammlungen/Filmreihen (`collections()`, `titles_for_collection()`)
+- `tags`             – Schlagwort-Suche (`tags()`, `titles_for_tag()`)
+- `random`           – zufälliger Titel (`random_title()`)
 
 ## Suche
 Aktuelle Regeln fuer Suchtreffer:
@@ -58,6 +69,11 @@ Siehe als Referenz:
 - `addon/plugins/serienstream_plugin.py`
 - `addon/plugins/aniworld_plugin.py`
 - `addon/plugins/topstreamfilm_plugin.py`
+- `addon/plugins/hdfilme_plugin.py`
+- `addon/plugins/kkiste_plugin.py`
+- `addon/plugins/moflix_plugin.py`
+- `addon/plugins/netzkino_plugin.py`
+- `addon/plugins/youtube_plugin.py`
 
 ## Settings
 Pro Plugin meist `*_base_url`.
@@ -68,6 +84,10 @@ Beispiele:
 - `topstream_base_url`
 - `filmpalast_base_url`
 - `doku_streams_base_url`
+- `hdfilme_base_url`
+- `kkiste_base_url`
+- `moflix_base_url`
+- `netzkino_base_url`
 
 ## Playback Flow
 1. Episode oder Film auswaehlen.

docs/PLUGIN_SYSTEM.md

@@ -19,6 +19,11 @@ Relevante Dateien:
 - `aniworld_plugin.py`
 - `filmpalast_plugin.py`
 - `dokustreams_plugin.py`
+- `hdfilme_plugin.py`
+- `kkiste_plugin.py`
+- `moflix_plugin.py`
+- `netzkino_plugin.py`
+- `youtube_plugin.py`
 - `_template_plugin.py` (Vorlage)
 
 ## Discovery Ablauf
@@ -41,12 +46,17 @@ Weitere Methoden sind optional und werden nur genutzt, wenn vorhanden.
 ## Capabilities
 Plugins koennen Features aktiv melden.
 Typische Werte:
-- `popular_series`
+- `popular_series`   – beliebte Serien/Filme
-- `genres`
+- `genres`           – Genre-Navigation
-- `latest_episodes`
+- `latest_episodes`  – neu erschienene Episoden
-- `new_titles`
+- `new_titles`       – neu hinzugefügte Titel (einfache Stringliste)
-- `alpha`
+- `alpha`            – alphabetische Navigation
-- `series_catalog`
+- `series_catalog`   – vollständiger Serienindex
+- `year_filter`      – Filter nach Erscheinungsjahr
+- `country_filter`   – Filter nach Produktionsland
+- `collections`      – Sammlungen/Filmreihen
+- `tags`             – Schlagwort-Suche
+- `random`           – zufälliger Titel
 
 Das UI zeigt nur Menues fuer aktiv gemeldete Features.
 

docs/TRAKT.md

@@ -44,7 +44,9 @@ Einstellungen
 
 Menues im Hauptmenue
 
-Wenn Trakt aktiviert und autorisiert ist, erscheinen im ViewIT-Hauptmenue folgende Eintraege:
+Wenn Trakt aktiviert ist, erscheint im ViewIT-Hauptmenue ein Untermenüpunkt "Trakt" (nach allen Quellen-Plugins).
+
+Ein Klick darauf oeffnet das Trakt-Untermenue mit folgenden Eintraegen (nur wenn bereits autorisiert):
 
 
 Weiterschauen

scripts/build_kodi_zip.sh

@@ -34,6 +34,10 @@ PY
 ZIP_NAME="${ADDON_ID}-${ADDON_VERSION}.zip"
 ZIP_PATH="${INSTALL_DIR}/${ZIP_NAME}"
 
+CHANGELOG_USER="${SRC_ADDON_DIR}/CHANGELOG-USER.md"
+python3 "${ROOT_DIR}/scripts/update_user_changelog.py" --fill  "${ADDON_XML}" "${CHANGELOG_USER}" >&2
+python3 "${ROOT_DIR}/scripts/update_user_changelog.py" --check "${ADDON_XML}" "${CHANGELOG_USER}" >&2 || exit 1
+
 ADDON_DIR="$("${ROOT_DIR}/scripts/build_install_addon.sh" >/dev/null; echo "${INSTALL_DIR}/${ADDON_ID}")"
 
 rm -f "${ZIP_PATH}"

scripts/hooks/pre-commit

@@ -51,4 +51,13 @@ fi
 sed -i "s/version=\"${current}\"/version=\"${new_version}\"/" addon/addon.xml
 git add addon/addon.xml
 
+# Changelog-Abschnitt von alter auf neue Version umbenennen (nur erstes Vorkommen)
+old_clean=$(echo "$version_only")
+new_clean=$(echo "$new_version" | sed 's/-[a-zA-Z].*$//')
+CHANGELOG="addon/CHANGELOG-USER.md"
+if [[ -f "$CHANGELOG" ]]; then
+    sed -i "0,/^## ${old_clean}$/s//## ${new_clean}/" "$CHANGELOG"
+    git add "$CHANGELOG"
+fi
+
 echo "[hook] Version: $current → $new_version"

scripts/update_user_changelog.py

@@ -0,0 +1,238 @@
+#!/usr/bin/env python3
+"""
+Pflegt CHANGELOG-USER.md vor dem ZIP-Build.
+
+Modi:
+  --fill    Liest Commits seit letztem Tag, generiert lesbaren Text und ersetzt
+            den Platzhalter im Abschnitt der aktuellen Version.
+            Legt den Abschnitt an falls noch nicht vorhanden.
+  --check   Prüft ob ein gefüllter Abschnitt für VERSION existiert.
+            Exit 0 = OK, Exit 1 = fehlt oder ist Platzhalter.
+
+Aufruf durch build_kodi_zip.sh:
+  python3 scripts/update_user_changelog.py --fill  addon/addon.xml addon/CHANGELOG-USER.md
+  python3 scripts/update_user_changelog.py --check addon/addon.xml addon/CHANGELOG-USER.md
+"""
+
+import re
+import subprocess
+import sys
+import xml.etree.ElementTree as ET
+from pathlib import Path
+
+PLACEHOLDER_LINE = "(Bitte Changelog-Einträge hier einfügen)"
+
+# Schlüsselwörter aus Commit-Messages → lesbarer Kategorie-Text
+# Reihenfolge bestimmt Priorität (erster Treffer gewinnt).
+CATEGORY_RULES: list[tuple[re.Pattern, str]] = [
+    (re.compile(r"trakt", re.I),             "Trakt"),
+    (re.compile(r"serienstream|serien.?stream", re.I), "SerienStream"),
+    (re.compile(r"aniworld", re.I),          "AniWorld"),
+    (re.compile(r"youtube|yt.?dlp", re.I),  "YouTube"),
+    (re.compile(r"tmdb|metadat", re.I),     "Metadaten"),
+    (re.compile(r"suche|search", re.I),     "Suche"),
+    (re.compile(r"setting|einstellung", re.I), "Einstellungen"),
+    (re.compile(r"update|version", re.I),   "Updates"),
+    (re.compile(r"moflix", re.I),           "Moflix"),
+    (re.compile(r"filmpalast", re.I),       "Filmpalast"),
+    (re.compile(r"kkiste", re.I),           "KKiste"),
+    (re.compile(r"doku.?stream", re.I),     "Doku-Streams"),
+    (re.compile(r"topstream", re.I),        "Topstreamfilm"),
+    (re.compile(r"einschalten", re.I),      "Einschalten"),
+    (re.compile(r"hdfilme", re.I),          "HDFilme"),
+    (re.compile(r"netzkino", re.I),         "NetzkKino"),
+]
+
+
+def get_version(addon_xml: Path) -> str:
+    root = ET.parse(addon_xml).getroot()
+    return root.attrib.get("version", "").strip()
+
+
+def strip_suffix(version: str) -> str:
+    return re.sub(r"-(dev|nightly|beta|alpha).*$", "", version)
+
+
+def get_prev_tag(current_tag: str) -> str | None:
+    try:
+        result = subprocess.run(
+            ["git", "tag", "--sort=-version:refname"],
+            capture_output=True, text=True, check=True,
+        )
+        tags = [t.strip() for t in result.stdout.splitlines() if t.strip()]
+        if current_tag in tags:
+            idx = tags.index(current_tag)
+            return tags[idx + 1] if idx + 1 < len(tags) else None
+        return tags[0] if tags else None
+    except Exception:
+        return None
+
+
+def get_commits_since(prev_tag: str | None) -> list[str]:
+    """Gibt Commit-Subjects seit prev_tag zurück (ohne den Tag-Commit selbst)."""
+    try:
+        ref = f"{prev_tag}..HEAD" if prev_tag else "HEAD"
+        result = subprocess.run(
+            ["git", "log", ref, "--pretty=format:%s"],
+            capture_output=True, text=True, check=True,
+        )
+        return [l.strip() for l in result.stdout.splitlines() if l.strip()]
+    except Exception:
+        return []
+
+
+def extract_description(subject: str) -> str:
+    """Extrahiert den lesbaren Teil aus einer Commit-Message."""
+    # "dev: bump to 0.1.86.0-dev Beschreibung hier" → "Beschreibung hier"
+    m = re.match(r"^(?:dev|nightly|main):\s*bump\s+to\s+[\d.]+(?:-\w+)?\s*(.+)$", subject, re.I)
+    if m:
+        return m.group(1).strip()
+    # "dev: Beschreibung" → "Beschreibung"
+    m = re.match(r"^(?:dev|nightly|main):\s*(.+)$", subject, re.I)
+    if m:
+        return m.group(1).strip()
+    return subject
+
+
+def split_description(desc: str) -> list[str]:
+    """Zerlegt kommagetrennte Beschreibungen in Einzelpunkte."""
+    parts = [p.strip() for p in re.split(r",\s*(?=[A-ZÄÖÜ\w])", desc) if p.strip()]
+    return parts if parts else [desc]
+
+
+def categorize(items: list[str]) -> dict[str, list[str]]:
+    """Gruppiert Beschreibungs-Punkte nach Kategorie."""
+    categories: dict[str, list[str]] = {}
+    for item in items:
+        cat = "Allgemein"
+        for pattern, label in CATEGORY_RULES:
+            if pattern.search(item):
+                cat = label
+                break
+        categories.setdefault(cat, []).append(item)
+    return categories
+
+
+def build_changelog_text(commits: list[str]) -> str:
+    """Erzeugt lesbaren Changelog-Text aus Commit-Subjects."""
+    all_items: list[str] = []
+    for subject in commits:
+        desc = extract_description(subject)
+        if desc:
+            all_items.extend(split_description(desc))
+
+    if not all_items:
+        return "- Verschiedene Verbesserungen und Fehlerbehebungen"
+
+    categories = categorize(all_items)
+    lines: list[str] = []
+    for cat, items in categories.items():
+        lines.append(f"**{cat}**")
+        for item in items:
+            # Ersten Buchstaben groß, Punkt am Ende
+            item = item[0].upper() + item[1:] if item else item
+            if not item.endswith((".","!","?")):
+                item += "."
+            lines.append(f"- {item}")
+        lines.append("")
+    return "\n".join(lines).rstrip()
+
+
+def section_exists(lines: list[str], header: str) -> bool:
+    return any(line.strip() == header for line in lines)
+
+
+def section_is_placeholder(lines: list[str], header: str) -> bool:
+    in_section = False
+    content_lines = []
+    for line in lines:
+        if line.strip() == header:
+            in_section = True
+            continue
+        if in_section:
+            if line.startswith("## "):
+                break
+            stripped = line.strip()
+            if stripped:
+                content_lines.append(stripped)
+    return not content_lines or all(l == PLACEHOLDER_LINE for l in content_lines)
+
+
+def replace_section_content(lines: list[str], header: str, new_content: str) -> list[str]:
+    """Ersetzt den Inhalt eines bestehenden Abschnitts."""
+    result: list[str] = []
+    in_section = False
+    content_written = False
+    for line in lines:
+        if line.strip() == header:
+            result.append(line)
+            result.append("")
+            result.extend(new_content.splitlines())
+            result.append("")
+            in_section = True
+            content_written = True
+            continue
+        if in_section:
+            if line.startswith("## "):
+                in_section = False
+                result.append(line)
+            # Alte Zeilen des Abschnitts überspringen
+            continue
+        result.append(line)
+    return result
+
+
+def insert_section(lines: list[str], header: str, content: str) -> list[str]:
+    new_section = [header, "", *content.splitlines(), ""]
+    return new_section + ([""] if lines and lines[0].strip() else []) + lines
+
+
+def main() -> None:
+    if len(sys.argv) < 4 or sys.argv[1] not in ("--fill", "--check"):
+        print(f"Usage: {sys.argv[0]} --fill|--check <addon.xml> <CHANGELOG-USER.md>", file=sys.stderr)
+        sys.exit(2)
+
+    mode = sys.argv[1]
+    addon_xml = Path(sys.argv[2])
+    changelog = Path(sys.argv[3])
+
+    version = get_version(addon_xml)
+    if not version:
+        print("Fehler: Version konnte nicht aus addon.xml gelesen werden.", file=sys.stderr)
+        sys.exit(2)
+
+    clean_version = strip_suffix(version)
+    header = f"## {clean_version}"
+    lines = changelog.read_text(encoding="utf-8").splitlines() if changelog.exists() else []
+
+    if mode == "--check":
+        if not section_exists(lines, header):
+            print(f"FEHLER: Kein Changelog-Abschnitt für {clean_version} in {changelog}", file=sys.stderr)
+            sys.exit(1)
+        if section_is_placeholder(lines, header):
+            print(f"FEHLER: Changelog-Abschnitt für {clean_version} ist noch ein Platzhalter.", file=sys.stderr)
+            sys.exit(1)
+        print(f"OK: Changelog-Abschnitt für {clean_version} vorhanden.")
+        sys.exit(0)
+
+    # --fill
+    current_tag = f"v{version}"
+    prev_tag = get_prev_tag(current_tag)
+    commits = get_commits_since(prev_tag)
+    content = build_changelog_text(commits)
+
+    if section_exists(lines, header):
+        if not section_is_placeholder(lines, header):
+            print(f"Abschnitt {header} bereits gefüllt – keine Änderung.")
+            sys.exit(0)
+        new_lines = replace_section_content(lines, header, content)
+    else:
+        new_lines = insert_section(lines, header, content)
+
+    changelog.write_text("\n".join(new_lines) + "\n", encoding="utf-8")
+    print(f"Changelog für {header} geschrieben.")
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()