diff --git a/.gitignore b/.gitignore
index 00b8528..e57570e 100644
--- a/.gitignore
+++ b/.gitignore
@@ -3,3 +3,4 @@ backend/generated
 backend/nsfwapp.exe
 backend/web/dist
 backend/recorder_settings.json
+backend/data/pending-autostart/__global__.json
diff --git a/backend/analyze.go b/backend/analyze.go
index 43c25b4..440c7ba 100644
--- a/backend/analyze.go
+++ b/backend/analyze.go
@@ -44,27 +44,15 @@ type analyzeVideoResp struct {
 	Error    string          `json:"error,omitempty"`
 }
 
-type aiRatingMeta struct {
-	Score                  float64 `json:"score"`
-	Stars                  int     `json:"stars"`
-	Segments               int     `json:"segments"`
-	SegmentsPerMinute      float64 `json:"segmentsPerMinute"`
-	FlaggedSeconds         float64 `json:"flaggedSeconds"`
-	WeightedFlaggedSeconds float64 `json:"weightedFlaggedSeconds"`
-	CoverageRatio          float64 `json:"coverageRatio"`
-	WeightedCoverageRatio  float64 `json:"weightedCoverageRatio"`
-	LongestSegmentSeconds  float64 `json:"longestSegmentSeconds"`
-	AvgConfidence          float64 `json:"avgConfidence"`
-}
-
 type spriteFrameCandidate struct {
 	Index int
 	Time  float64
 }
 
 const (
-	nsfwThresholdModerate = 0.35
-	nsfwThresholdStrong   = 0.60
+	analyzeSegmentMergeGapSeconds = 8.0
+	nsfwThresholdModerate         = 0.35
+	nsfwThresholdStrong           = 0.60
 )
 
 var autoSelectedAILabels = map[string]struct{}{
@@ -633,8 +621,9 @@ func mergeAnalyzeHits(in []analyzeHit) []analyzeHit {
 		// Direkt aufeinanderfolgende Treffer mit gleichem Label immer zusammenfassen.
 		// Sobald ein anderes Label dazwischen liegt, wird automatisch nicht gemergt.
 		sameLabel := strings.EqualFold(cur.Label, n.Label)
+		gap := n.Start - cur.End
 
-		if sameLabel {
+		if sameLabel && gap <= analyzeSegmentMergeGapSeconds {
 			if n.Start < cur.Start {
 				cur.Start = n.Start
 			}
@@ -656,119 +645,116 @@ func mergeAnalyzeHits(in []analyzeHit) []analyzeHit {
 	return out
 }
 
-func nsfwSegmentSeverityWeight(label string) float64 {
-	switch strings.ToLower(strings.TrimSpace(label)) {
-	case "female_genitalia_exposed":
-		return 1.00
-	case "anus_exposed":
-		return 0.95
-	case "female_breast_exposed":
-		return 0.85
-	case "male_genitalia_exposed":
-		return 0.80
-	case "buttocks_exposed":
-		return 0.65
-	default:
-		return 0.50
-	}
-}
+func inferAnalyzePointSpanSeconds(hits []analyzeHit, duration float64) float64 {
+	const fallback = 3.0
 
-func starsFromNSFWScore(score float64) int {
-	switch {
-	case score < 5:
-		return 1
-	case score < 15:
-		return 2
-	case score < 35:
-		return 3
-	case score < 60:
-		return 4
-	default:
-		return 5
-	}
-}
-
-func computeNSFWRating(segments []aiSegmentMeta, durationSec float64) *aiRatingMeta {
-	r := &aiRatingMeta{
-		Score: 0,
-		Stars: 1,
+	if len(hits) < 2 {
+		return fallback
 	}
 
-	if durationSec <= 0 || len(segments) == 0 {
-		return r
-	}
+	times := make([]float64, 0, len(hits))
 
-	videoMinutes := math.Max(durationSec/60.0, 0.25)
+	for _, h := range hits {
+		t := h.Time
 
-	var totalFlagged float64
-	var totalWeighted float64
-	var longest float64
-	var confSum float64
-	var n int
-
-	for _, s := range segments {
-		segDur := s.DurationSeconds
-		if segDur <= 0 {
-			segDur = s.EndSeconds - s.StartSeconds
+		if t < 0 {
+			if h.Start >= 0 {
+				t = h.Start
+			} else if h.End >= 0 {
+				t = h.End
+			}
 		}
-		if segDur <= 0 {
+
+		if t < 0 {
 			continue
 		}
 
-		sev := nsfwSegmentSeverityWeight(s.Label)
-		conf := clamp01(s.Score)
+		if duration > 0 {
+			t = math.Max(0, math.Min(t, duration))
+		}
 
-		// Confidence beeinflusst, dominiert aber nicht.
-		weight := sev * (0.65 + 0.35*conf)
+		times = append(times, t)
+	}
 
-		totalFlagged += segDur
-		totalWeighted += segDur * weight
-		confSum += conf
-		n++
+	if len(times) < 2 {
+		return fallback
+	}
 
-		if segDur > longest {
-			longest = segDur
+	sort.Float64s(times)
+
+	gaps := make([]float64, 0, len(times)-1)
+	prev := times[0]
+
+	for _, t := range times[1:] {
+		gap := t - prev
+		if gap > 0.05 {
+			gaps = append(gaps, gap)
+			prev = t
 		}
 	}
 
-	if n == 0 {
-		return r
+	if len(gaps) == 0 {
+		return fallback
 	}
 
-	coverageRatio := clamp01(totalFlagged / durationSec)
-	weightedCoverageRatio := clamp01(totalWeighted / durationSec)
-	segmentsPerMinute := float64(n) / videoMinutes
-	avgConfidence := confSum / float64(n)
+	sort.Float64s(gaps)
 
-	// Normalisierung / Sättigung:
-	// - 20% gewichtete Abdeckung => voll
-	// - 4 Segmente pro Minute => voll
-	// - 20s längstes Segment => voll
-	coverageNorm := clamp01(weightedCoverageRatio / 0.20)
-	frequencyNorm := clamp01(segmentsPerMinute / 4.0)
-	longestNorm := clamp01(longest / 20.0)
-	confNorm := clamp01((avgConfidence - 0.35) / 0.45)
+	median := gaps[len(gaps)/2]
+	if len(gaps)%2 == 0 {
+		median = (gaps[len(gaps)/2-1] + gaps[len(gaps)/2]) / 2
+	}
 
-	raw := 0.55*coverageNorm +
-		0.20*frequencyNorm +
-		0.15*longestNorm +
-		0.10*confNorm
+	// Ein einzelner Frame repräsentiert ungefähr seinen Sample-Abstand,
+	// aber wir deckeln, damit Sparse-Hits nicht riesig werden.
+	span := median * 0.90
 
-	score := math.Round(clamp01(raw)*1000) / 10 // 0..100 mit 1 Nachkommastelle
-	stars := starsFromNSFWScore(score)
+	if span < 2 {
+		span = 2
+	}
+	if span > 12 {
+		span = 12
+	}
 
-	r.Score = score
-	r.Stars = stars
-	r.Segments = n
-	r.SegmentsPerMinute = math.Round(segmentsPerMinute*100) / 100
-	r.FlaggedSeconds = math.Round(totalFlagged*100) / 100
-	r.WeightedFlaggedSeconds = math.Round(totalWeighted*100) / 100
-	r.CoverageRatio = math.Round(coverageRatio*10000) / 10000
-	r.WeightedCoverageRatio = math.Round(weightedCoverageRatio*10000) / 10000
-	r.LongestSegmentSeconds = math.Round(longest*100) / 100
-	r.AvgConfidence = math.Round(avgConfidence*1000) / 1000
+	return span
+}
 
-	return r
+func expandAnalyzePointToSpan(t, span, duration float64) (float64, float64) {
+	if span <= 0 {
+		span = 3
+	}
+
+	if t < 0 {
+		t = 0
+	}
+
+	if duration > 0 {
+		t = math.Max(0, math.Min(t, duration))
+	}
+
+	half := span / 2
+
+	start := t - half
+	end := t + half
+
+	if start < 0 {
+		start = 0
+	}
+	if duration > 0 && end > duration {
+		end = duration
+	}
+
+	if end <= start {
+		if duration > 0 {
+			end = math.Min(duration, start+math.Max(1, span))
+			if end <= start {
+				start = math.Max(0, end-math.Max(1, span))
+			}
+		} else {
+			end = start + math.Max(1, span)
+		}
+	}
+
+	return start, end
 }
 
 func buildSegmentsFromAnalyzeHits(hits []analyzeHit, duration float64) []aiSegmentMeta {
@@ -776,6 +762,8 @@ func buildSegmentsFromAnalyzeHits(hits []analyzeHit, duration float64) []aiSegme
 		return []aiSegmentMeta{}
 	}
 
+	pointSpan := inferAnalyzePointSpanSeconds(hits, duration)
+
 	out := make([]aiSegmentMeta, 0, len(hits))
 
 	for _, hit := range hits {
@@ -797,6 +785,7 @@ func buildSegmentsFromAnalyzeHits(hits []analyzeHit, duration float64) []aiSegme
 				end = hit.Time
 			}
 		}
+
 		if start > end {
 			start, end = end, start
 		}
@@ -804,6 +793,18 @@ func buildSegmentsFromAnalyzeHits(hits []analyzeHit, duration float64) []aiSegme
 		start = math.Max(0, math.Min(start, duration))
 		end = math.Max(0, math.Min(end, duration))
 
+		// Wichtig:
+		// Einzelne AI-Treffer sind oft Punkt-Treffer: Start == End.
+		// Für Segmente und Rating brauchen sie aber eine kleine Dauer.
+		if end <= start {
+			marker := hit.Time
+			if marker < 0 {
+				marker = start
+			}
+
+			start, end = expandAnalyzePointToSpan(marker, pointSpan, duration)
+		}
+
 		if end <= start {
 			continue
 		}
@@ -838,10 +839,12 @@ func buildSegmentsFromAnalyzeHits(hits []analyzeHit, duration float64) []aiSegme
 	for i := 1; i < len(out); i++ {
 		n := out[i]
 
-		// Direkt aufeinanderfolgende Segmente mit gleichem Label immer mergen,
-		// unabhängig von der Lücke. Sobald ein anderes Label dazwischen liegt,
-		// wird automatisch nicht gemergt, weil wir nur mit dem direkten Nachfolger arbeiten.
-		if strings.EqualFold(cur.Label, n.Label) {
+		gap := n.StartSeconds - cur.EndSeconds
+		if gap < 0 {
+			gap = 0
+		}
+
+		if strings.EqualFold(cur.Label, n.Label) && gap <= analyzeSegmentMergeGapSeconds {
 			if n.StartSeconds < cur.StartSeconds {
 				cur.StartSeconds = n.StartSeconds
 			}
diff --git a/backend/main.go b/backend/main.go
index 4377994..ee26bbc 100644
--- a/backend/main.go
+++ b/backend/main.go
@@ -389,8 +389,6 @@ var startedAtFromFilenameRe = regexp.MustCompile(
 )
 
 func shouldAutoDeleteSmallDownload(filePath string) (bool, int64, int64) {
-	// returns: (shouldDelete, sizeBytes, thresholdBytes)
-
 	s := getSettings()
 	if !s.AutoDeleteSmallDownloads {
 		return false, 0, 0
@@ -406,7 +404,6 @@ func shouldAutoDeleteSmallDownload(filePath string) (bool, int64, int64) {
 		return false, 0, 0
 	}
 
-	// relativ -> absolut versuchen (best effort)
 	if !filepath.IsAbs(p) {
 		if abs, err := resolvePathRelativeToApp(p); err == nil && strings.TrimSpace(abs) != "" {
 			p = abs
@@ -420,9 +417,15 @@ func shouldAutoDeleteSmallDownload(filePath string) (bool, int64, int64) {
 
 	size := fi.Size()
 	thr := int64(mb) * 1024 * 1024
+
 	if size > 0 && size < thr {
+		if isFavoriteProtectedDownload(p, "") {
+			return false, size, thr
+		}
+
 		return true, size, thr
 	}
+
 	return false, size, thr
 }
 
diff --git a/backend/models_store.go b/backend/models_store.go
index e47e249..558beb9 100644
--- a/backend/models_store.go
+++ b/backend/models_store.go
@@ -293,6 +293,46 @@ LIMIT 1;
 	return &m, true
 }
 
+func (s *ModelStore) IsFavoriteModel(host string, modelKey string) bool {
+	if s == nil {
+		return false
+	}
+	if err := s.ensureInit(); err != nil {
+		return false
+	}
+
+	host = canonicalHost(host)
+	modelKey = strings.TrimSpace(modelKey)
+	if modelKey == "" {
+		return false
+	}
+
+	var ok bool
+
+	// host ist optional:
+	// - Wenn host gesetzt ist: exakter Host oder alte Legacy-Einträge ohne Host schützen.
+	// - Wenn host leer ist: alle Hosts nach diesem model_key prüfen.
+	err := s.db.QueryRow(`
+SELECT EXISTS (
+  SELECT 1
+  FROM models
+  WHERE lower(trim(model_key)) = lower(trim($1))
+    AND COALESCE(favorite, false) = true
+    AND (
+      trim($2) = ''
+      OR lower(trim(COALESCE(host, ''))) = lower(trim($2))
+      OR trim(COALESCE(host, '')) = ''
+    )
+);
+`, modelKey, host).Scan(&ok)
+
+	if err != nil {
+		return false
+	}
+
+	return ok
+}
+
 func canonicalHost(host string) string {
 	h := strings.ToLower(strings.TrimSpace(host))
 	h = strings.TrimPrefix(h, "www.")
diff --git a/backend/rating.go b/backend/rating.go
new file mode 100644
index 0000000..9e7100e
--- /dev/null
+++ b/backend/rating.go
@@ -0,0 +1,186 @@
+// backend\rating.go
+
+package main
+
+import (
+	"math"
+	"strings"
+)
+
+type aiRatingMeta struct {
+	Score                  float64 `json:"score"`
+	Stars                  int     `json:"stars"`
+	Segments               int     `json:"segments"`
+	SegmentsPerMinute      float64 `json:"segmentsPerMinute"`
+	FlaggedSeconds         float64 `json:"flaggedSeconds"`
+	WeightedFlaggedSeconds float64 `json:"weightedFlaggedSeconds"`
+	CoverageRatio          float64 `json:"coverageRatio"`
+	WeightedCoverageRatio  float64 `json:"weightedCoverageRatio"`
+	LongestSegmentSeconds  float64 `json:"longestSegmentSeconds"`
+	AvgConfidence          float64 `json:"avgConfidence"`
+}
+
+func ratingClamp01(v float64) float64 {
+	if v < 0 {
+		return 0
+	}
+	if v > 1 {
+		return 1
+	}
+	return v
+}
+
+func ratingRound(v float64, places int) float64 {
+	p := math.Pow(10, float64(places))
+	return math.Round(v*p) / p
+}
+
+func ratingSmoothStep(v float64) float64 {
+	v = ratingClamp01(v)
+	return v * v * (3 - 2*v)
+}
+
+func ratingSoftCap(value, knee float64) float64 {
+	if value <= 0 || knee <= 0 {
+		return 0
+	}
+	return value / (value + knee)
+}
+
+func ratingEffectiveDurationSeconds(seconds float64) float64 {
+	if seconds <= 0 {
+		return 0
+	}
+
+	// Lange Segmente zählen weiter, aber mit abnehmendem Zusatznutzen.
+	// Dadurch kippen falsche oder zu breite Merges nicht sofort auf 5 Sterne.
+	const kneeSeconds = 24.0
+	return kneeSeconds * math.Log1p(seconds/kneeSeconds)
+}
+
+func nsfwSegmentSeverityWeight(label string) float64 {
+	switch strings.ToLower(strings.TrimSpace(label)) {
+	case "female_genitalia_exposed":
+		return 1.00
+	case "anus_exposed":
+		return 0.95
+	case "female_breast_exposed":
+		return 0.85
+	case "male_genitalia_exposed":
+		return 0.80
+	case "buttocks_exposed":
+		return 0.65
+	default:
+		return 0.50
+	}
+}
+
+func ratingConfidenceWeight(conf float64) float64 {
+	conf = ratingClamp01(conf)
+
+	// Unterhalb ~0.30 soll Confidence kaum boosten.
+	// Oberhalb ~0.95 ist praktisch gesättigt.
+	n := ratingSmoothStep((conf - 0.30) / 0.65)
+
+	return 0.60 + 0.40*n
+}
+
+func starsFromNSFWScore(score float64) int {
+	switch {
+	case score < 15:
+		return 1
+	case score < 35:
+		return 2
+	case score < 58:
+		return 3
+	case score < 78:
+		return 4
+	default:
+		return 5
+	}
+}
+
+func computeNSFWRating(segments []aiSegmentMeta, durationSec float64) *aiRatingMeta {
+	r := &aiRatingMeta{
+		Score: 0,
+		Stars: 1,
+	}
+
+	if durationSec <= 0 || len(segments) == 0 {
+		return r
+	}
+
+	videoMinutes := math.Max(durationSec/60.0, 0.25)
+
+	var totalFlagged float64
+	var totalWeighted float64
+	var totalEffectiveWeighted float64
+	var longest float64
+	var confSum float64
+	var n int
+
+	for _, s := range segments {
+		segDur := s.DurationSeconds
+		if segDur <= 0 {
+			segDur = s.EndSeconds - s.StartSeconds
+		}
+		if segDur <= 0 {
+			continue
+		}
+
+		sev := nsfwSegmentSeverityWeight(s.Label)
+		conf := ratingClamp01(s.Score)
+		weight := sev * ratingConfidenceWeight(conf)
+
+		totalFlagged += segDur
+		totalWeighted += segDur * weight
+		totalEffectiveWeighted += ratingEffectiveDurationSeconds(segDur) * weight
+
+		confSum += conf
+		n++
+
+		if segDur > longest {
+			longest = segDur
+		}
+	}
+
+	if n == 0 {
+		return r
+	}
+
+	coverageRatio := ratingClamp01(totalFlagged / durationSec)
+	weightedCoverageRatio := ratingClamp01(totalWeighted / durationSec)
+	segmentsPerMinute := float64(n) / videoMinutes
+	avgConfidence := confSum / float64(n)
+	effectiveWeightedSecondsPerMinute := totalEffectiveWeighted / videoMinutes
+
+	// Weichere Normalisierung statt harter Sättigung.
+	// Das reduziert 1/5-Ausreißer und verteilt mehr Fälle auf 2–4 Sterne.
+	densityNorm := ratingSoftCap(effectiveWeightedSecondsPerMinute, 8.0)
+	coverageNorm := ratingSoftCap(weightedCoverageRatio, 0.22)
+	frequencyNorm := ratingSoftCap(segmentsPerMinute, 1.25)
+	longestNorm := ratingSoftCap(longest, 25.0)
+	confNorm := ratingSmoothStep((avgConfidence - 0.35) / 0.60)
+
+	raw :=
+		0.38*densityNorm +
+			0.30*coverageNorm +
+			0.12*frequencyNorm +
+			0.10*longestNorm +
+			0.10*confNorm
+
+	score := ratingRound(ratingClamp01(raw)*100, 1)
+
+	r.Score = score
+	r.Stars = starsFromNSFWScore(score)
+	r.Segments = n
+	r.SegmentsPerMinute = ratingRound(segmentsPerMinute, 2)
+	r.FlaggedSeconds = ratingRound(totalFlagged, 2)
+	r.WeightedFlaggedSeconds = ratingRound(totalWeighted, 2)
+	r.CoverageRatio = ratingRound(coverageRatio, 4)
+	r.WeightedCoverageRatio = ratingRound(weightedCoverageRatio, 4)
+	r.LongestSegmentSeconds = ratingRound(longest, 2)
+	r.AvgConfidence = ratingRound(avgConfidence, 3)
+
+	return r
+}
diff --git a/backend/recorder.go b/backend/recorder.go
index 8184ddd..ccfca57 100644
--- a/backend/recorder.go
+++ b/backend/recorder.go
@@ -985,6 +985,48 @@ func ensureUsableRecordedOutput(job *RecordJob, target JobStatus, out string) bo
 	return false
 }
 
+func favoriteProtectionModelKeyForDownload(out string, sourceURL string) (host string, modelKey string) {
+	sourceURL = strings.TrimSpace(sourceURL)
+
+	if sourceURL != "" {
+		switch detectProvider(sourceURL) {
+		case "chaturbate":
+			host = "chaturbate.com"
+			modelKey = strings.TrimSpace(extractUsername(sourceURL))
+		case "mfc":
+			host = "myfreecams.com"
+			modelKey = strings.TrimSpace(extractMFCUsername(sourceURL))
+		}
+	}
+
+	if strings.TrimSpace(modelKey) == "" {
+		stem := strings.TrimSuffix(filepath.Base(strings.TrimSpace(out)), filepath.Ext(out))
+		stem = stripHotPrefix(stem)
+		modelKey = sanitizeModelKey(strings.TrimSpace(modelNameFromFilename(stem)))
+	}
+
+	return strings.TrimSpace(host), strings.ToLower(strings.TrimSpace(modelKey))
+}
+
+func isFavoriteProtectedDownload(out string, sourceURL string) bool {
+	s := getSettings()
+	if !s.AutoDeleteSmallDownloadsKeepFavorites {
+		return false
+	}
+
+	host, modelKey := favoriteProtectionModelKeyForDownload(out, sourceURL)
+	if modelKey == "" {
+		return false
+	}
+
+	store := getModelStore()
+	if store == nil {
+		return false
+	}
+
+	return store.IsFavoriteModel(host, modelKey)
+}
+
 func maybeDeleteSmallRecordedOutput(job *RecordJob, out string) bool {
 	fi, err := os.Stat(out)
 	if err != nil || fi == nil || fi.IsDir() {
@@ -1006,6 +1048,11 @@ func maybeDeleteSmallRecordedOutput(job *RecordJob, out string) bool {
 		return false
 	}
 
+	if isFavoriteProtectedDownload(out, job.SourceURL) {
+		fmt.Println("⭐ auto-delete skipped for favorite:", filepath.Base(out))
+		return false
+	}
+
 	base := filepath.Base(out)
 	id := stripHotPrefix(strings.TrimSuffix(base, filepath.Ext(base)))
 
diff --git a/backend/settings.go b/backend/settings.go
index 2f9d089..20f4cc2 100644
--- a/backend/settings.go
+++ b/backend/settings.go
@@ -29,9 +29,10 @@ type RecorderSettings struct {
 	UseChaturbateAPI     bool `json:"useChaturbateApi"`
 	UseMyFreeCamsWatcher bool `json:"useMyFreeCamsWatcher"`
 	// Wenn aktiv, werden fertige Downloads automatisch gelöscht, wenn sie kleiner als der Grenzwert sind.
-	AutoDeleteSmallDownloads        bool `json:"autoDeleteSmallDownloads"`
-	AutoDeleteSmallDownloadsBelowMB int  `json:"autoDeleteSmallDownloadsBelowMB"`
-	LowDiskPauseBelowGB             int  `json:"lowDiskPauseBelowGB"`
+	AutoDeleteSmallDownloads              bool `json:"autoDeleteSmallDownloads"`
+	AutoDeleteSmallDownloadsBelowMB       int  `json:"autoDeleteSmallDownloadsBelowMB"`
+	AutoDeleteSmallDownloadsKeepFavorites bool `json:"autoDeleteSmallDownloadsKeepFavorites"`
+	LowDiskPauseBelowGB                   int  `json:"lowDiskPauseBelowGB"`
 
 	BlurPreviews   bool   `json:"blurPreviews"`
 	TeaserPlayback string `json:"teaserPlayback"` // still | hover | all
@@ -63,11 +64,12 @@ var (
 		EnableConcurrentDownloadsLimit: false,
 		MaxConcurrentDownloads:         20,
 
-		UseChaturbateAPI:                false,
-		UseMyFreeCamsWatcher:            false,
-		AutoDeleteSmallDownloads:        false,
-		AutoDeleteSmallDownloadsBelowMB: 50,
-		LowDiskPauseBelowGB:             5,
+		UseChaturbateAPI:                      false,
+		UseMyFreeCamsWatcher:                  false,
+		AutoDeleteSmallDownloads:              false,
+		AutoDeleteSmallDownloadsBelowMB:       50,
+		AutoDeleteSmallDownloadsKeepFavorites: true,
+		LowDiskPauseBelowGB:                   5,
 
 		BlurPreviews:   false,
 		TeaserPlayback: "hover",
@@ -226,9 +228,10 @@ type RecorderSettingsPublic struct {
 	UseChaturbateAPI     bool `json:"useChaturbateApi"`
 	UseMyFreeCamsWatcher bool `json:"useMyFreeCamsWatcher"`
 
-	AutoDeleteSmallDownloads        bool `json:"autoDeleteSmallDownloads"`
-	AutoDeleteSmallDownloadsBelowMB int  `json:"autoDeleteSmallDownloadsBelowMB"`
-	LowDiskPauseBelowGB             int  `json:"lowDiskPauseBelowGB"`
+	AutoDeleteSmallDownloads              bool `json:"autoDeleteSmallDownloads"`
+	AutoDeleteSmallDownloadsBelowMB       int  `json:"autoDeleteSmallDownloadsBelowMB"`
+	AutoDeleteSmallDownloadsKeepFavorites bool `json:"autoDeleteSmallDownloadsKeepFavorites"`
+	LowDiskPauseBelowGB                   int  `json:"lowDiskPauseBelowGB"`
 
 	BlurPreviews   bool   `json:"blurPreviews"`
 	TeaserPlayback string `json:"teaserPlayback"`
@@ -259,9 +262,10 @@ func toPublicSettings(s RecorderSettings) RecorderSettingsPublic {
 		UseChaturbateAPI:     s.UseChaturbateAPI,
 		UseMyFreeCamsWatcher: s.UseMyFreeCamsWatcher,
 
-		AutoDeleteSmallDownloads:        s.AutoDeleteSmallDownloads,
-		AutoDeleteSmallDownloadsBelowMB: s.AutoDeleteSmallDownloadsBelowMB,
-		LowDiskPauseBelowGB:             s.LowDiskPauseBelowGB,
+		AutoDeleteSmallDownloads:              s.AutoDeleteSmallDownloads,
+		AutoDeleteSmallDownloadsBelowMB:       s.AutoDeleteSmallDownloadsBelowMB,
+		AutoDeleteSmallDownloadsKeepFavorites: s.AutoDeleteSmallDownloadsKeepFavorites,
+		LowDiskPauseBelowGB:                   s.LowDiskPauseBelowGB,
 
 		BlurPreviews:   s.BlurPreviews,
 		TeaserPlayback: s.TeaserPlayback,
@@ -417,6 +421,7 @@ func recordSettingsHandler(w http.ResponseWriter, r *http.Request) {
 
 		next.AutoDeleteSmallDownloads = in.AutoDeleteSmallDownloads
 		next.AutoDeleteSmallDownloadsBelowMB = in.AutoDeleteSmallDownloadsBelowMB
+		next.AutoDeleteSmallDownloadsKeepFavorites = in.AutoDeleteSmallDownloadsKeepFavorites
 		next.LowDiskPauseBelowGB = in.LowDiskPauseBelowGB
 
 		next.BlurPreviews = in.BlurPreviews
diff --git a/backend/tasks_cleanup.go b/backend/tasks_cleanup.go
index da5f405..94bc8d8 100644
--- a/backend/tasks_cleanup.go
+++ b/backend/tasks_cleanup.go
@@ -461,6 +461,34 @@ func dirSizeBytes(root string) int64 {
 	return total
 }
 
+func removeDirIfEmpty(dir string) (bool, error) {
+	dir = strings.TrimSpace(dir)
+	if dir == "" {
+		return false, nil
+	}
+
+	entries, err := os.ReadDir(dir)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return false, nil
+		}
+		return false, err
+	}
+
+	if len(entries) > 0 {
+		return false, nil
+	}
+
+	if err := os.Remove(dir); err != nil {
+		if os.IsNotExist(err) {
+			return false, nil
+		}
+		return false, err
+	}
+
+	return true, nil
+}
+
 // Läuft synchron und liefert Zahlen zurück (für /api/settings/cleanup Response).
 func triggerGeneratedGarbageCollectorSync() generatedGCStats {
 	// nur 1 GC gleichzeitig
@@ -603,7 +631,9 @@ func runGeneratedGarbageCollector() generatedGCStats {
 	collectLiveIDsFromTrash(filepath.Join(doneAbs, ".trash"), live)
 
 	// 1b) Auch aktuell laufende / nachbearbeitete Jobs als "live" behandeln.
-	// Sonst räumt der GC generated/meta/<id> weg, obwohl RecordStream dort noch schreibt.
+	// Zusätzlich separat merken, damit leere Ordner aktiver Jobs nicht gelöscht werden.
+	activeJobIDs := make(map[string]struct{}, 128)
+
 	jobsMu.RLock()
 	for _, j := range jobs {
 		if j == nil {
@@ -616,6 +646,7 @@ func runGeneratedGarbageCollector() generatedGCStats {
 		}
 
 		live[id] = struct{}{}
+		activeJobIDs[id] = struct{}{}
 	}
 	jobsMu.RUnlock()
 
@@ -637,21 +668,38 @@ func runGeneratedGarbageCollector() generatedGCStats {
 			if !e.IsDir() {
 				continue
 			}
+
 			id := strings.TrimSpace(e.Name())
 			if id == "" || strings.HasPrefix(id, ".") {
 				continue
 			}
 
 			checkedMeta++
+
+			orphanDir := filepath.Join(metaRoot, id)
+
+			// Leere generated/meta/<id>-Ordner immer entfernen,
+			// außer ein aktiver Job könnte gerade hinein schreiben.
+			if _, active := activeJobIDs[id]; !active {
+				if removedEmpty, err := removeDirIfEmpty(orphanDir); err == nil && removedEmpty {
+					removedMeta++
+					continue
+				}
+			}
+
 			if _, ok := live[id]; ok {
 				continue
 			}
 
-			orphanDir := filepath.Join(metaRoot, id)
 			orphanBytes := dirSizeBytes(orphanDir)
 
 			removeGeneratedForID(id)
 
+			// Falls removeGeneratedForID nur Dateien gelöscht hat, den nun leeren Ordner entfernen.
+			if removedEmpty, err := removeDirIfEmpty(orphanDir); err == nil && removedEmpty {
+				// ok
+			}
+
 			if _, err := os.Stat(orphanDir); os.IsNotExist(err) {
 				removedMeta++
 				removedBytes += orphanBytes
diff --git a/frontend/src/App.tsx b/frontend/src/App.tsx
index dd5a114..33ce2b7 100644
--- a/frontend/src/App.tsx
+++ b/frontend/src/App.tsx
@@ -3949,7 +3949,7 @@ export default function App() {
               blurPreviews={Boolean(recSettings.blurPreviews)}
               teaserPlayback={recSettings.teaserPlayback ?? 'hover'}
               teaserAudio={Boolean(recSettings.teaserAudio)}
-              pauseTeasers={Boolean(detailsModelKey) || splitModalOpen}
+              pauseTeasers={Boolean(detailsModelKey) || splitModalOpen || Boolean(playerJob)}
               assetNonce={assetNonce}
               sortMode={doneSort}
               onSortModeChange={(m) => {
diff --git a/frontend/src/components/ui/FinishedDownloadRating.tsx b/frontend/src/components/ui/FinishedDownloadRating.tsx
deleted file mode 100644
index 7512844..0000000
--- a/frontend/src/components/ui/FinishedDownloadRating.tsx
+++ /dev/null
@@ -1,279 +0,0 @@
-// frontend\src\components\ui\FinishedDownloadRating.tsx
-
-'use client'
-
-import HoverPopover from './HoverPopover'
-import type { RecordJobMeta } from '../../types'
-
-type FinishedDownloadRatingProps = {
-  metaRaw: unknown
-  variant?: 'overlay' | 'badge'
-  reserveSpace?: boolean
-}
-
-function parseMetaObject(metaRaw: unknown): RecordJobMeta | null {
-  if (!metaRaw) return null
-
-  if (typeof metaRaw === 'string') {
-    try {
-      return JSON.parse(metaRaw) as RecordJobMeta
-    } catch {
-      return null
-    }
-  }
-
-  return typeof metaRaw === 'object' ? (metaRaw as RecordJobMeta) : null
-}
-
-function readRatingNode(metaRaw: unknown): Record<string, unknown> | null {
-  const meta = parseMetaObject(metaRaw) as any
-
-  const rating =
-    meta?.analysis?.ai?.rating ??
-    meta?.ai?.rating ??
-    null
-
-  if (!rating || typeof rating !== 'object' || Array.isArray(rating)) {
-    return null
-  }
-
-  return rating as Record<string, unknown>
-}
-
-function readNSFWStars(metaRaw: unknown): number | undefined {
-  const rating = readRatingNode(metaRaw)
-
-  const raw = rating?.stars
-  const n = Number(raw)
-  if (!Number.isFinite(n)) return undefined
-
-  return Math.max(1, Math.min(5, Math.floor(n)))
-}
-
-function humanizeKey(key: string): string {
-  return key
-    .replace(/\./g, ' ')
-    .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
-    .replace(/[_-]+/g, ' ')
-    .replace(/\b\w/g, (m) => m.toUpperCase())
-}
-
-function formatScalar(value: unknown): string | null {
-  if (value == null) return null
-
-  if (typeof value === 'string') {
-    const s = value.trim()
-    return s || null
-  }
-
-  if (typeof value === 'number') {
-    if (!Number.isFinite(value)) return null
-    if (Number.isInteger(value)) return String(value)
-    return value.toFixed(4).replace(/\.?0+$/, '')
-  }
-
-  if (typeof value === 'boolean') {
-    return value ? 'Ja' : 'Nein'
-  }
-
-  if (Array.isArray(value)) {
-    const parts = value.map(formatScalar).filter(Boolean) as string[]
-    return parts.length > 0 ? parts.join(', ') : null
-  }
-
-  return null
-}
-
-function readRatingEntries(metaRaw: unknown): Array<{ key: string; label: string; value: string }> {
-  const rating = readRatingNode(metaRaw)
-  if (!rating) return []
-
-  const out: Array<{ key: string; label: string; value: string }> = []
-
-  for (const [key, raw] of Object.entries(rating)) {
-    if (raw && typeof raw === 'object' && !Array.isArray(raw)) {
-      for (const [subKey, subRaw] of Object.entries(raw as Record<string, unknown>)) {
-        if (subRaw && typeof subRaw === 'object') continue
-
-        const formatted = formatScalar(subRaw)
-        if (!formatted) continue
-
-        out.push({
-          key: `${key}.${subKey}`,
-          label: humanizeKey(`${key} ${subKey}`),
-          value: formatted,
-        })
-      }
-      continue
-    }
-
-    const formatted = formatScalar(raw)
-    if (!formatted) continue
-
-    out.push({
-      key,
-      label: humanizeKey(key),
-      value: formatted,
-    })
-  }
-
-  out.sort((a, b) => {
-    if (a.key === 'stars') return -1
-    if (b.key === 'stars') return 1
-    return a.label.localeCompare(b.label, 'de')
-  })
-
-  return out
-}
-
-function nsfwRatingTone(stars: number) {
-  switch (stars) {
-    case 1:
-      return { star: 'text-yellow-400 opacity-40' }
-    case 2:
-      return { star: 'text-yellow-400 opacity-55' }
-    case 3:
-      return { star: 'text-yellow-400 opacity-70' }
-    case 4:
-      return { star: 'text-yellow-400 opacity-85' }
-    default:
-      return { star: 'text-yellow-400 opacity-100' }
-  }
-}
-
-function RatingStar({
-  stars,
-  className,
-}: {
-  stars: number
-  className: string
-}) {
-  const tone = nsfwRatingTone(stars)
-
-  return (
-    <span className={`relative inline-grid shrink-0 place-items-center leading-none ${className}`}>
-      <svg
-        viewBox="0 0 20 20"
-        aria-hidden="true"
-        className={`shrink-0 fill-current ${tone.star}`}
-        style={{
-          filter: 'drop-shadow(0 1px 2px rgba(0,0,0,0.75)) drop-shadow(0 0 3px rgba(0,0,0,0.35))',
-        }}
-      >
-        <path
-          d="M9.049 2.927c.3-.921 1.603-.921 1.902 0l1.07 3.292a1 1 0 00.95.69h3.462c.969 0 1.371 1.24.588 1.81l-2.8 2.034a1 1 0 00-.364 1.118l1.07 3.292c.3.921-.755 1.688-1.54 1.118l-2.8-2.034a1 1 0 00-1.176 0l-2.8 2.034c-.784.57-1.838-.197-1.539-1.118l1.07-3.292a1 1 0 00-.364-1.118L2.98 9.72c-.783-.57-.38-1.81.588-1.81H7.03a1 1 0 00.951-.69l1.07-3.292z"
-          stroke="rgba(0,0,0,0.75)"
-          strokeWidth="1.1"
-          paintOrder="stroke fill"
-        />
-      </svg>
-
-      <span
-        className="absolute inset-0 grid place-items-center text-[10px] font-black leading-none text-white"
-        style={{
-          textShadow: '0 1px 2px rgba(0,0,0,0.95), 0 0 2px rgba(0,0,0,0.85)',
-        }}
-      >
-        {stars}
-      </span>
-    </span>
-  )
-}
-
-function RatingWithPopover({
-  stars,
-  metaRaw,
-  className,
-}: {
-  stars: number
-  metaRaw: unknown
-  className: string
-}) {
-  const entries = readRatingEntries(metaRaw)
-
-  const starNode = (
-    <span
-      className="inline-flex items-center justify-center"
-      aria-label={`Rating ${stars} von 5`}
-    >
-      <RatingStar stars={stars} className={className} />
-    </span>
-  )
-
-  if (entries.length === 0) {
-    return starNode
-  }
-
-  return (
-    <HoverPopover
-      content={(open) =>
-        open && (
-          <div className="w-[240px] rounded-lg">
-            <div className="border-b border-gray-200 px-3 py-2 dark:border-white/10">
-              <div className="text-xs font-semibold text-gray-900 dark:text-white">
-                AI Rating
-              </div>
-              <div className="mt-0.5 text-[11px] text-gray-500 dark:text-gray-400">
-                Bewertungswerte aus der Analyse
-              </div>
-            </div>
-
-            <div className="px-3 py-2">
-              <div className="space-y-1.5">
-                {entries.map((entry) => (
-                  <div key={entry.key} className="flex items-start justify-between gap-3 text-[12px]">
-                    <span className="min-w-0 text-gray-500 dark:text-gray-400">
-                      {entry.label}
-                    </span>
-                    <span className="shrink-0 font-medium text-gray-900 dark:text-white">
-                      {entry.value}
-                    </span>
-                  </div>
-                ))}
-              </div>
-            </div>
-          </div>
-        )
-      }
-    >
-      {starNode}
-    </HoverPopover>
-  )
-}
-
-export default function FinishedDownloadRating({
-  metaRaw,
-  variant = 'overlay',
-  reserveSpace = false,
-}: FinishedDownloadRatingProps) {
-  const stars = readNSFWStars(metaRaw)
-
-  if (typeof stars !== 'number') {
-    if (reserveSpace && variant === 'badge') {
-      return <span aria-hidden="true" className="inline-block h-6 w-6 shrink-0 opacity-0" />
-    }
-    return null
-  }
-
-  if (variant === 'badge') {
-    return (
-      <span className="inline-flex h-6 w-6 shrink-0 items-center justify-center align-middle">
-        <RatingWithPopover
-          stars={stars}
-          metaRaw={metaRaw}
-          className="h-6 w-6"
-        />
-      </span>
-    )
-  }
-
-  return (
-    <span className="inline-flex h-6 min-w-[24px] shrink-0 items-center justify-center">
-      <RatingWithPopover
-        stars={stars}
-        metaRaw={metaRaw}
-        className="h-6 w-6"
-      />
-    </span>
-  )
-}
\ No newline at end of file
diff --git a/frontend/src/components/ui/FinishedDownloads.tsx b/frontend/src/components/ui/FinishedDownloads.tsx
index d443933..20f723e 100644
--- a/frontend/src/components/ui/FinishedDownloads.tsx
+++ b/frontend/src/components/ui/FinishedDownloads.tsx
@@ -59,7 +59,7 @@ import {
   type FinishedSelectionStore,
 } from './finishedSelectionStore'
 import { formatResolution, formatDuration, formatBytes } from './formatters'
-import FinishedDownloadRating from './FinishedDownloadRating'
+import RatingOverlay from './RatingOverlay'
 
 type Props = {
   jobs: RecordJob[]
@@ -1614,8 +1614,7 @@ export default function FinishedDownloads({
   const LAST_UNDO_KEY = 'finishedDownloads_lastUndo_v1'
 
   const requestedTeaserPlaybackMode: TeaserPlaybackMode = teaserPlayback ?? 'hover'
-  const teaserPlaybackMode: TeaserPlaybackMode =
-    pauseTeasers ? 'still' : requestedTeaserPlaybackMode
+  const teaserPlaybackMode: TeaserPlaybackMode = requestedTeaserPlaybackMode
 
   const notify = useNotify()
 
@@ -1631,7 +1630,6 @@ export default function FinishedDownloads({
     !canHover && teaserPlaybackMode === 'hover' ? 'still' : teaserPlaybackMode
 
   const mobileNeedsTapForAudio = isCoarsePointer || isTabletOrSmaller
-  const previewMuted = !Boolean(teaserAudio)
 
   const cardsMobileOffsetTopClass = 'mt-10'
   const cardsMobileOffsetBottomClass = 'mb-2'
@@ -1805,22 +1803,39 @@ export default function FinishedDownloads({
     return renderDownloadIntegrityBadge((job as any)?.meta)
   }, [])
 
+  const openPlayerAndPauseTeasers = useCallback((job: RecordJob, startAtSec?: number) => {
+    onOpenPlayer(job, startAtSec)
+  }, [onOpenPlayer])
+
   const renderRatingOverlay = useCallback((job: RecordJob) => {
     return (
-      <FinishedDownloadRating
+      <RatingOverlay
         metaRaw={(job as any)?.meta}
         variant="overlay"
+        onOpenAt={(seconds) => {
+          openPlayerAndPauseTeasers(job, seconds)
+        }}
       />
     )
-  }, [])
+  }, [openPlayerAndPauseTeasers])
 
   // -----------------------------------------------------------------------------
   // memoized derived data
   // -----------------------------------------------------------------------------
   const forcePreviewMuted =
-    mobileNeedsTapForAudio && teaserAudio
+    Boolean(pauseTeasers) ||
+    (mobileNeedsTapForAudio && teaserAudio
       ? !mobileTeaserAudioUnlocked
-      : false
+      : false)
+
+  const previewMuted = !Boolean(teaserAudio) || forcePreviewMuted
+
+  const audibleTeaserKey =
+    previewMuted
+      ? null
+      : canHover
+        ? hoverTeaserKey
+        : inlinePlay?.key ?? teaserKey
 
   const deferredSearchQuery = useDeferredValue(searchQuery)
 
@@ -1848,9 +1863,9 @@ export default function FinishedDownloads({
       mode: effectiveTeaserPlaybackMode,
       activeKey: teaserKey,
       hoverKey: hoverTeaserKey,
-      audioEnabled: Boolean(teaserAudio),
+      audioEnabled: Boolean(teaserAudio) && !forcePreviewMuted && Boolean(audibleTeaserKey),
     }),
-    [effectiveTeaserPlaybackMode, teaserKey, hoverTeaserKey, teaserAudio]
+    [effectiveTeaserPlaybackMode, teaserKey, hoverTeaserKey, teaserAudio, forcePreviewMuted, audibleTeaserKey]
   )
 
   const modelTags = useMemo(() => {
@@ -2347,16 +2362,26 @@ export default function FinishedDownloads({
   const tryAutoplayInline = useCallback((domId: string) => {
     const host = document.getElementById(domId)
     const v = host?.querySelector('video') as HTMLVideoElement | null
-    if (!v) return false
+    if (!host || !v) return false
 
-    applyInlineVideoPolicy(v, { muted: previewMuted })
+    const teaserHost =
+      host.closest<HTMLElement>('[data-finished-hover-key]') ??
+      host.querySelector<HTMLElement>('[data-finished-hover-key]')
+
+    const key = teaserHost?.dataset.finishedHoverKey ?? null
+    const muted = !audibleTeaserKey || key !== audibleTeaserKey
+
+    applyInlineVideoPolicy(v, { muted })
+    v.defaultMuted = muted
+    v.muted = muted
 
     const p = v.play?.()
     if (p && typeof (p as any).catch === 'function') {
-      (p as Promise<void>).catch(() => {})
+      ;(p as Promise<void>).catch(() => {})
     }
+
     return true
-  }, [previewMuted])
+  }, [audibleTeaserKey])
 
   const startInline = useCallback((key: string) => {
     setInlinePlay((prev) => (
@@ -2382,7 +2407,11 @@ export default function FinishedDownloads({
         return
       }
 
-      applyInlineVideoPolicy(v, { muted: previewMuted })
+      const muted = !audibleTeaserKey || key !== audibleTeaserKey
+
+      applyInlineVideoPolicy(v, { muted })
+      v.defaultMuted = muted
+      v.muted = muted
 
       const applySeek = () => {
         try {
@@ -2420,18 +2449,16 @@ export default function FinishedDownloads({
     }
 
     requestAnimationFrame(() => trySeekAndPlay(8))
-  }, [previewMuted])
+  }, [audibleTeaserKey])
 
   const openPlayer = useCallback((job: RecordJob) => {
-    setInlinePlay(null)
-    onOpenPlayer(job)
-  }, [onOpenPlayer])
+    openPlayerAndPauseTeasers(job)
+  }, [openPlayerAndPauseTeasers])
 
   const openPlayerAt = useCallback((job: RecordJob, seconds: number) => {
     const s = Number.isFinite(seconds) && seconds >= 0 ? seconds : 0
-    setInlinePlay(null)
-    onOpenPlayer(job, s)
-  }, [onOpenPlayer])
+    openPlayerAndPauseTeasers(job, s)
+  }, [openPlayerAndPauseTeasers])
 
   const handleScrubberClickIndex = useCallback(
     (job: RecordJob, segmentIndex: number, segmentCount: number) => {
@@ -3548,12 +3575,17 @@ export default function FinishedDownloads({
   }, [])
 
   useEffect(() => {
-    if (!pauseTeasers) return
+    for (const [key, host] of teaserHostsRef.current.entries()) {
+      const muted = !audibleTeaserKey || key !== audibleTeaserKey
+      const videos = host.querySelectorAll('video')
 
-    setTeaserKey(null)
-    setHoverTeaserKey(null)
-    setInlinePlay(null)
-  }, [pauseTeasers])
+      videos.forEach((video) => {
+        applyInlineVideoPolicy(video, { muted })
+        video.defaultMuted = muted
+        video.muted = muted
+      })
+    }
+  }, [audibleTeaserKey, view, pageRows])
   
   const refreshPostworkState = useCallback(async () => {
     try {
@@ -3774,13 +3806,73 @@ export default function FinishedDownloads({
   }, [refreshPostworkState])
 
   useEffect(() => {
+    if (!canHover) {
+      pointerPosRef.current = null
+      setHoverTeaserKey(null)
+      return
+    }
+
+    let raf: number | null = null
+
+    const syncHoverFromPointer = () => {
+      raf = null
+
+      const pos = pointerPosRef.current
+      if (!pos) {
+        setHoverTeaserKey((prev) => (prev === null ? prev : null))
+        return
+      }
+
+      const el = document.elementFromPoint(pos.x, pos.y) as HTMLElement | null
+      const hoverHost = el?.closest<HTMLElement>('[data-finished-hover-key]') ?? null
+      const nextKey = hoverHost?.dataset.finishedHoverKey ?? null
+
+      setHoverTeaserKey((prev) => (prev === nextKey ? prev : nextKey))
+    }
+
+    const scheduleSync = () => {
+      if (raf != null) return
+      raf = requestAnimationFrame(syncHoverFromPointer)
+    }
+
+    const clearHover = () => {
+      pointerPosRef.current = null
+      setHoverTeaserKey((prev) => (prev === null ? prev : null))
+    }
+
     const onPointerMove = (e: PointerEvent) => {
       pointerPosRef.current = { x: e.clientX, y: e.clientY }
+      scheduleSync()
+    }
+
+    const onPointerOut = (e: PointerEvent) => {
+      if (!e.relatedTarget) {
+        clearHover()
+      }
+    }
+
+    const onVisibilityChange = () => {
+      if (document.visibilityState !== 'visible') {
+        clearHover()
+      }
     }
 
     window.addEventListener('pointermove', onPointerMove, { passive: true })
-    return () => window.removeEventListener('pointermove', onPointerMove)
-  }, [])
+    window.addEventListener('pointerout', onPointerOut, { passive: true })
+    window.addEventListener('blur', clearHover)
+    window.addEventListener('scroll', scheduleSync, true)
+    document.addEventListener('visibilitychange', onVisibilityChange)
+
+    return () => {
+      if (raf != null) cancelAnimationFrame(raf)
+
+      window.removeEventListener('pointermove', onPointerMove)
+      window.removeEventListener('pointerout', onPointerOut)
+      window.removeEventListener('blur', clearHover)
+      window.removeEventListener('scroll', scheduleSync, true)
+      document.removeEventListener('visibilitychange', onVisibilityChange)
+    }
+  }, [canHover])
 
   useEffect(() => {
     try {
@@ -4849,7 +4941,7 @@ export default function FinishedDownloads({
                 sizeBytesOf={sizeBytesOf}
                 formatBytes={formatBytes}
                 lower={lowerTag}
-                onOpenPlayer={onOpenPlayer}
+                onOpenPlayer={openPlayerAndPauseTeasers}
                 openPlayer={openPlayer}
                 onOpenPlayerAt={openPlayerAt}
                 handleScrubberClickIndex={handleScrubberClickIndex}
@@ -4921,7 +5013,7 @@ export default function FinishedDownloads({
               modelsByKey={modelsByKey}
               activeTagSet={activeTagSet}
               onToggleTagFilter={toggleTagFilter}
-              onOpenPlayer={onOpenPlayer}
+              onOpenPlayer={openPlayerAndPauseTeasers}
               handleScrubberClickIndex={handleScrubberClickIndex}
               onSortModeChange={onSortModeChange}
               page={page}
@@ -4968,7 +5060,7 @@ export default function FinishedDownloads({
               keepingKeys={keepingKeys}
               removingKeys={removingKeys}
               registerTeaserHost={registerTeaserHost}
-              onOpenPlayer={onOpenPlayer}
+              onOpenPlayer={openPlayerAndPauseTeasers}
               handleScrubberClickIndex={handleScrubberClickIndex}
               deleteVideo={deleteVideo}
               keepVideo={keepVideo}
diff --git a/frontend/src/components/ui/FinishedDownloadsCardsView.tsx b/frontend/src/components/ui/FinishedDownloadsCardsView.tsx
index 9e50611..e8b0d6b 100644
--- a/frontend/src/components/ui/FinishedDownloadsCardsView.tsx
+++ b/frontend/src/components/ui/FinishedDownloadsCardsView.tsx
@@ -683,10 +683,7 @@ function FinishedDownloadsCardsView({
             >
               {/* media */}
               <div className="absolute inset-0 overflow-hidden rounded-t-lg">
-                <PreviewRatingOverlay
-                  hidden={inlineActive}
-                  raised={!inlineActive && scrubberCount > 1 && hoveredThumbKey === k}
-                >
+                <PreviewRatingOverlay hidden={inlineActive}>
                   {renderRatingOverlay ? renderRatingOverlay(j) : null}
                 </PreviewRatingOverlay>
 
diff --git a/frontend/src/components/ui/FinishedDownloadsGalleryCard.tsx b/frontend/src/components/ui/FinishedDownloadsGalleryCard.tsx
index e964f65..ff6ad18 100644
--- a/frontend/src/components/ui/FinishedDownloadsGalleryCard.tsx
+++ b/frontend/src/components/ui/FinishedDownloadsGalleryCard.tsx
@@ -385,9 +385,7 @@ function FinishedDownloadsGalleryCardInner({
                 />
               </div>
 
-              <PreviewRatingOverlay
-                raised={hasScrubber && hoveredThumbKey === k}
-              >
+              <PreviewRatingOverlay>
                 {renderRatingOverlay ? renderRatingOverlay(j) : null}
               </PreviewRatingOverlay>
 
diff --git a/frontend/src/components/ui/LoadingSpinner.tsx b/frontend/src/components/ui/LoadingSpinner.tsx
index ae4f6ab..8bc51c5 100644
--- a/frontend/src/components/ui/LoadingSpinner.tsx
+++ b/frontend/src/components/ui/LoadingSpinner.tsx
@@ -1,5 +1,7 @@
 // frontend\src\components\ui\LoadingSpinner.tsx
 
+// frontend/src/components/ui/LoadingSpinner.tsx
+
 'use client'
 
 import { type ReactNode } from 'react'
@@ -44,36 +46,45 @@ export default function LoadingSpinner({
     <span
       className={cn(
         'inline-flex items-center gap-2',
-        center && 'justify-center w-full',
+        center && 'w-full justify-center',
       )}
       role="status"
       aria-live="polite"
+      aria-label={label ? undefined : srLabel}
     >
       <svg
         width={px}
         height={px}
         viewBox="0 0 24 24"
-        className={cn('animate-spin text-gray-500', className)}
+        className={cn(
+          'block shrink-0 text-gray-500 motion-safe:animate-spin',
+          className,
+        )}
         aria-hidden="true"
       >
-        {/* Hintergrund-Ring (leicht transparent) */}
+        {/* Hintergrund-Ring */}
         <circle
           cx="12"
           cy="12"
-          r="9"
+          r="8.5"
           fill="none"
           stroke="currentColor"
           strokeWidth="3"
-          opacity="0.25"
+          opacity="0.22"
         />
-        {/* “Arc” vorne */}
-        <path
+
+        {/* Vorderes Segment mit runden Enden */}
+        <circle
+          cx="12"
+          cy="12"
+          r="8.5"
           fill="none"
           stroke="currentColor"
           strokeWidth="3"
           strokeLinecap="round"
-          d="M21 12a9 9 0 0 0-9-9"
-          opacity="0.95"
+          strokeDasharray="22 54"
+          strokeDashoffset="0"
+          opacity="0.98"
         />
       </svg>
 
@@ -84,4 +95,4 @@ export default function LoadingSpinner({
       )}
     </span>
   )
-}
+}
\ No newline at end of file
diff --git a/frontend/src/components/ui/PreviewRatingOverlay.tsx b/frontend/src/components/ui/PreviewRatingOverlay.tsx
index 2b0dc7a..06fb9d0 100644
--- a/frontend/src/components/ui/PreviewRatingOverlay.tsx
+++ b/frontend/src/components/ui/PreviewRatingOverlay.tsx
@@ -3,33 +3,21 @@
 'use client'
 
 import type { ReactNode } from 'react'
-import { PREVIEW_SCRUBBER_HEIGHT_PX } from './PreviewScrubber'
-
-const PREVIEW_RATING_BASE_BOTTOM_PX = 7
 
 type PreviewRatingOverlayProps = {
   hidden?: boolean
   children?: ReactNode
-  raised?: boolean
 }
 
 export default function PreviewRatingOverlay({
   hidden = false,
   children,
-  raised = false,
 }: PreviewRatingOverlayProps) {
   if (hidden || !children) return null
 
-  const bottomPx = raised
-    ? PREVIEW_RATING_BASE_BOTTOM_PX + PREVIEW_SCRUBBER_HEIGHT_PX
-    : PREVIEW_RATING_BASE_BOTTOM_PX
-
   return (
-    <div
-      className="absolute left-1.5 z-40 transition-[bottom] duration-150"
-      style={{ bottom: `${bottomPx}px` }}
-    >
-      <div className="pointer-events-auto flex items-end">
+    <div className="absolute right-1.5 top-1.5 z-40">
+      <div className="pointer-events-auto flex items-start justify-end">
         {children}
       </div>
     </div>
diff --git a/frontend/src/components/ui/RatingOverlay.tsx b/frontend/src/components/ui/RatingOverlay.tsx
new file mode 100644
index 0000000..db0deaf
--- /dev/null
+++ b/frontend/src/components/ui/RatingOverlay.tsx
@@ -0,0 +1,1180 @@
+// frontend/src/components/ui/RatingOverlay.tsx
+
+'use client'
+
+import { type CSSProperties } from 'react'
+import HoverPopover from './HoverPopover'
+import type { RecordJobMeta } from '../../types'
+import { getSegmentLabelText } from './Icons'
+
+type RatingOverlayProps = {
+  metaRaw: unknown
+  variant?: 'overlay' | 'badge'
+  reserveSpace?: boolean
+  onOpenAt?: (seconds: number) => void
+}
+
+type RatingEntry = {
+  key: string
+  label: string
+  value: string
+  tone?: 'normal' | 'strong' | 'muted'
+}
+
+type SegmentSpritePreview = {
+  src: string
+  frameStyle: CSSProperties
+  imageStyle: CSSProperties
+}
+
+type RatingSegment = {
+  key: string
+  title: string
+  timeLabel?: string
+  valueLabel?: string
+  detail?: string
+  tags: string[]
+  preview?: SegmentSpritePreview
+  openAtSec?: number
+}
+
+const VALUE_LABELS: Record<string, string> = {
+  stars: 'Sterne',
+  score: 'Score',
+  confidence: 'Konfidenz',
+  probability: 'Wahrscheinlichkeit',
+  nsfw: 'NSFW',
+  adult: 'Adult',
+  explicit: 'Explizit',
+  explicitness: 'Explizitheit',
+  nudity: 'Nacktheit',
+  sexual: 'Sexuell',
+  sexualActivity: 'Sexuelle Aktivität',
+  visibility: 'Sichtbarkeit',
+  quality: 'Qualität',
+  reason: 'Begründung',
+  summary: 'Zusammenfassung',
+  label: 'Label',
+  category: 'Kategorie',
+  model: 'Modell',
+  version: 'Version',
+}
+
+const AI_LABEL_FALLBACKS: Record<string, string> = {
+  // entspricht SEGMENT_LABEL_META in Icons.tsx
+  anus_exposed: 'Anus',
+  anus: 'Anus',
+
+  female_genitalia_exposed: 'Vagina',
+  vulva_exposed: 'Vagina',
+  labia_exposed: 'Vagina',
+
+  male_genitalia_exposed: 'Penis',
+  penis_exposed: 'Penis',
+
+  female_breast_exposed: 'Brüste',
+  breast_exposed: 'Brüste',
+
+  male_breast_exposed: 'Männliche Brust',
+
+  buttocks_exposed: 'Hintern',
+  buttocks: 'Hintern',
+
+  belly_exposed: 'Bauch',
+  stomach_exposed: 'Bauch',
+  abdomen_exposed: 'Bauch',
+  navel_exposed: 'Bauch',
+
+  feet_exposed: 'Füße',
+  foot_exposed: 'Füße',
+
+  face_female: 'Gesicht',
+  face_male: 'Gesicht',
+  face: 'Gesicht',
+  female_face: 'Gesicht',
+  male_face: 'Gesicht',
+
+  // covered-Varianten passend zur Logik in Icons.tsx
+  anus_covered: 'Anus bedeckt',
+  buttocks_covered: 'Hintern bedeckt',
+  female_breast_covered: 'Brüste bedeckt',
+  breast_covered: 'Brüste bedeckt',
+  male_breast_covered: 'Männliche Brust bedeckt',
+  female_genitalia_covered: 'Vagina bedeckt',
+  vulva_covered: 'Vagina bedeckt',
+  labia_covered: 'Vagina bedeckt',
+  male_genitalia_covered: 'Penis bedeckt',
+  penis_covered: 'Penis bedeckt',
+  belly_covered: 'Bauch bedeckt',
+  stomach_covered: 'Bauch bedeckt',
+  abdomen_covered: 'Bauch bedeckt',
+  navel_covered: 'Bauch bedeckt',
+  feet_covered: 'Füße bedeckt',
+  foot_covered: 'Füße bedeckt',
+  face_covered: 'Gesicht bedeckt',
+
+  // allgemeine AI-/Safety-Labels
+  explicit_nudity: 'Explizite Nacktheit',
+  non_explicit_nudity: 'Nicht-explizite Nacktheit',
+  suggestive: 'Suggestiv',
+  sexual_activity: 'Sexuelle Aktivität',
+  sexual_display: 'Sexuelle Darstellung',
+  sex_toy: 'Sexspielzeug',
+  underwear: 'Unterwäsche',
+  lingerie: 'Lingerie',
+  swimwear: 'Bademode',
+}
+
+function isAiLikeLabel(value: string): boolean {
+  const s = value.trim()
+  if (!s) return false
+
+  return (
+    s in AI_LABEL_FALLBACKS ||
+    /^[a-z0-9]+(?:_[a-z0-9]+)+$/i.test(s) ||
+    /^[a-z0-9]+(?:-[a-z0-9]+)+$/i.test(s)
+  )
+}
+
+function titleCaseLabel(value: string): string {
+  return value
+    .replace(/[_-]+/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim()
+    .replace(/\b\w/g, (m) => m.toUpperCase())
+}
+
+function prettyAiLabel(value: unknown): string {
+  const raw = String(value ?? '').trim()
+  if (!raw) return ''
+
+  const key = raw.toLowerCase()
+
+  try {
+    const fromIcons = getSegmentLabelText(raw).trim()
+
+    if (
+      fromIcons &&
+      fromIcons !== raw &&
+      fromIcons.toLowerCase() !== key
+    ) {
+      return fromIcons
+    }
+  } catch {
+    // fallback below
+  }
+
+  const direct = AI_LABEL_FALLBACKS[key]
+  if (direct) return direct
+
+  return isAiLikeLabel(raw) ? titleCaseLabel(raw) : raw
+}
+
+function prettyMaybeAiValue(key: string, value: string): string {
+  const k = key.toLowerCase()
+
+  if (
+    k === 'label' ||
+    k.endsWith('.label') ||
+    k === 'category' ||
+    k.endsWith('.category') ||
+    k === 'type' ||
+    k.endsWith('.type') ||
+    k === 'kind' ||
+    k.endsWith('.kind') ||
+    k === 'name' ||
+    k.endsWith('.name') ||
+    k.includes('class') ||
+    k.includes('tag') ||
+    k.includes('flag')
+  ) {
+    return prettyAiLabel(value)
+  }
+
+  return isAiLikeLabel(value) ? prettyAiLabel(value) : value
+}
+
+function parseMetaObject(metaRaw: unknown): RecordJobMeta | null {
+  if (!metaRaw) return null
+
+  if (typeof metaRaw === 'string') {
+    try {
+      return JSON.parse(metaRaw) as RecordJobMeta
+    } catch {
+      return null
+    }
+  }
+
+  return typeof metaRaw === 'object' ? (metaRaw as RecordJobMeta) : null
+}
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return !!value && typeof value === 'object' && !Array.isArray(value)
+}
+
+function readAiNode(metaRaw: unknown): Record<string, unknown> | null {
+  const meta = parseMetaObject(metaRaw) as any
+
+  const ai =
+    meta?.analysis?.ai ??
+    meta?.ai ??
+    null
+
+  return isPlainObject(ai) ? ai : null
+}
+
+function readRatingNode(metaRaw: unknown): Record<string, unknown> | null {
+  const ai = readAiNode(metaRaw) as any
+
+  const rating =
+    ai?.rating ??
+    null
+
+  return isPlainObject(rating) ? rating : null
+}
+
+function readRatingStars(metaRaw: unknown): number | undefined {
+  const rating = readRatingNode(metaRaw)
+  const ai = readAiNode(metaRaw)
+
+  const raw =
+    rating?.stars ??
+    ai?.stars ??
+    rating?.scoreStars ??
+    rating?.rating
+
+  const n = Number(raw)
+  if (!Number.isFinite(n)) return undefined
+
+  return Math.max(1, Math.min(5, Math.round(n)))
+}
+
+function humanizeKey(key: string): string {
+  const last = key.split('.').at(-1) || ''
+  const direct = VALUE_LABELS[key] ?? VALUE_LABELS[last]
+  if (direct) return direct
+
+  if (isAiLikeLabel(last)) return prettyAiLabel(last)
+
+  return key
+    .replace(/\./g, ' ')
+    .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+    .replace(/[_-]+/g, ' ')
+    .replace(/\b\w/g, (m) => m.toUpperCase())
+}
+
+function formatSeconds(secondsRaw: number): string {
+  const seconds = Math.max(0, Math.floor(secondsRaw))
+  const h = Math.floor(seconds / 3600)
+  const m = Math.floor((seconds % 3600) / 60)
+  const s = seconds % 60
+
+  if (h > 0) {
+    return `${h}:${String(m).padStart(2, '0')}:${String(s).padStart(2, '0')}`
+  }
+
+  return `${m}:${String(s).padStart(2, '0')}`
+}
+
+function formatNumberByKey(key: string, value: number): string | null {
+  if (!Number.isFinite(value)) return null
+
+  const k = key.toLowerCase()
+
+  if (k.endsWith('stars') || k === 'stars' || k.includes('rating')) {
+    if (value >= 1 && value <= 5) return `${Math.round(value)}/5`
+  }
+
+  if (
+    value >= 0 &&
+    value <= 1 &&
+    (
+      k.includes('score') ||
+      k.includes('confidence') ||
+      k.includes('probability') ||
+      k.includes('ratio') ||
+      k.includes('nsfw') ||
+      k.includes('adult') ||
+      k.includes('explicit') ||
+      k.includes('nudity') ||
+      k.includes('sexual') ||
+      k.includes('visibility')
+    )
+  ) {
+    return `${Math.round(value * 100)}%`
+  }
+
+  if (k.includes('seconds') || k.endsWith('sec') || k === 'start' || k === 'end' || k === 'duration') {
+    return formatSeconds(value)
+  }
+
+  if (Number.isInteger(value)) return String(value)
+
+  return value.toFixed(2).replace(/\.?0+$/, '')
+}
+
+function formatScalar(key: string, value: unknown): string | null {
+  if (value == null) return null
+
+  if (typeof value === 'string') {
+    const s = value.trim()
+    return s ? prettyMaybeAiValue(key, s) : null
+  }
+
+  if (typeof value === 'number') {
+    return formatNumberByKey(key, value)
+  }
+
+  if (typeof value === 'boolean') {
+    return value ? 'Ja' : 'Nein'
+  }
+
+  if (Array.isArray(value)) {
+    const parts = value
+      .map((v, i) => formatScalar(`${key}.${i}`, v))
+      .filter(Boolean) as string[]
+
+    return parts.length > 0 ? parts.join(', ') : null
+  }
+
+  return null
+}
+
+function shouldSkipRatingKey(key: string): boolean {
+  const k = key.toLowerCase()
+
+  return (
+    k === 'segments' ||
+    k === 'hits' ||
+    k === 'matches' ||
+    k === 'frames' ||
+    k === 'clips' ||
+    k.endsWith('.segments') ||
+    k.endsWith('.hits') ||
+    k.endsWith('.matches')
+  )
+}
+
+function ratingEntryPriority(key: string): number {
+  const k = key.toLowerCase()
+
+  if (k === 'stars') return 0
+  if (k.includes('score')) return 1
+  if (k.includes('confidence')) return 2
+  if (k.includes('probability')) return 3
+  if (k.includes('explicit') || k.includes('nsfw') || k.includes('adult')) return 4
+  if (k.includes('nudity') || k.includes('sexual')) return 5
+  if (k.includes('reason') || k.includes('summary')) return 20
+
+  return 10
+}
+
+function readRatingEntries(metaRaw: unknown): RatingEntry[] {
+  const rating = readRatingNode(metaRaw)
+  const ai = readAiNode(metaRaw)
+
+  const source = rating ?? ai
+  if (!source) return []
+
+  const out: RatingEntry[] = []
+
+  const walk = (
+    obj: Record<string, unknown>,
+    prefix = '',
+    depth = 0
+  ) => {
+    for (const [key, raw] of Object.entries(obj)) {
+      const fullKey = prefix ? `${prefix}.${key}` : key
+      if (shouldSkipRatingKey(fullKey)) continue
+
+      if (isPlainObject(raw) && depth < 2) {
+        walk(raw, fullKey, depth + 1)
+        continue
+      }
+
+      const formatted = formatScalar(fullKey, raw)
+      if (!formatted) continue
+
+      out.push({
+        key: fullKey,
+        label: humanizeKey(fullKey),
+        value: formatted,
+        tone:
+          fullKey === 'stars' || fullKey.toLowerCase().includes('score')
+            ? 'strong'
+            : undefined,
+      })
+    }
+  }
+
+  walk(source)
+
+  out.sort((a, b) => {
+    const pa = ratingEntryPriority(a.key)
+    const pb = ratingEntryPriority(b.key)
+    if (pa !== pb) return pa - pb
+    return a.label.localeCompare(b.label, 'de')
+  })
+
+  return out.slice(0, 18)
+}
+
+function firstString(obj: Record<string, unknown>, keys: string[]): string | undefined {
+  for (const key of keys) {
+    const v = obj[key]
+    if (typeof v === 'string' && v.trim()) return v.trim()
+  }
+
+  return undefined
+}
+
+function firstNumber(obj: Record<string, unknown>, keys: string[]): number | undefined {
+  for (const key of keys) {
+    const raw = obj[key]
+    const n = Number(raw)
+
+    if (!Number.isFinite(n)) continue
+
+    if (key.toLowerCase().endsWith('ms')) {
+      return n / 1000
+    }
+
+    return n
+  }
+
+  return undefined
+}
+
+type PreviewSpriteMeta = {
+  path: string
+  count: number
+  cols: number
+  rows: number
+  stepSeconds: number
+  aspectRatio: number
+}
+
+function readMetaVideoAspectRatio(metaRaw: unknown): number {
+  const meta = parseMetaObject(metaRaw) as any
+
+  const w = Number(
+    meta?.media?.video?.width ??
+    meta?.media?.video?.w ??
+    meta?.media?.width ??
+    meta?.file?.video?.width ??
+    meta?.file?.video?.w ??
+    meta?.file?.width ??
+    meta?.video?.width ??
+    meta?.video?.w ??
+    meta?.width
+  )
+
+  const h = Number(
+    meta?.media?.video?.height ??
+    meta?.media?.video?.h ??
+    meta?.media?.height ??
+    meta?.file?.video?.height ??
+    meta?.file?.video?.h ??
+    meta?.file?.height ??
+    meta?.video?.height ??
+    meta?.video?.h ??
+    meta?.height
+  )
+
+  if (
+    Number.isFinite(w) &&
+    Number.isFinite(h) &&
+    w > 0 &&
+    h > 0
+  ) {
+    return w / h
+  }
+
+  return 16 / 9
+}
+
+function readPreviewSpriteMeta(metaRaw: unknown): PreviewSpriteMeta | null {
+  const meta = parseMetaObject(metaRaw) as any
+
+  let sprite =
+    meta?.preview?.sprite ??
+    meta?.previewSprite ??
+    meta?.preview_sprite ??
+    null
+
+  if (typeof sprite === 'string') {
+    try {
+      sprite = JSON.parse(sprite)
+    } catch {
+      sprite = null
+    }
+  }
+
+  if (!isPlainObject(sprite)) return null
+
+  const path = String(
+    sprite.path ??
+    sprite.url ??
+    sprite.src ??
+    ''
+  ).trim()
+
+  const count = Number(sprite.count)
+  const cols = Number(sprite.cols)
+  const rows = Number(sprite.rows)
+  const stepSeconds = Number(sprite.stepSeconds ?? sprite.step_seconds ?? 0)
+
+  if (!path || !Number.isFinite(count) || count <= 0) return null
+
+  const frameWidth = Number(
+    sprite.frameWidth ??
+    sprite.frame_width ??
+    sprite.tileWidth ??
+    sprite.tile_width ??
+    0
+  )
+
+  const frameHeight = Number(
+    sprite.frameHeight ??
+    sprite.frame_height ??
+    sprite.tileHeight ??
+    sprite.tile_height ??
+    0
+  )
+
+  const aspectRatio =
+    Number.isFinite(frameWidth) &&
+    Number.isFinite(frameHeight) &&
+    frameWidth > 0 &&
+    frameHeight > 0
+      ? frameWidth / frameHeight
+      : readMetaVideoAspectRatio(metaRaw)
+
+  return {
+    path,
+    count: Math.max(1, Math.floor(count)),
+    cols: Number.isFinite(cols) && cols > 0 ? Math.floor(cols) : 1,
+    rows: Number.isFinite(rows) && rows > 0 ? Math.floor(rows) : 1,
+    stepSeconds: Number.isFinite(stepSeconds) && stepSeconds > 0 ? stepSeconds : 0,
+    aspectRatio,
+  }
+}
+
+function readMetaDurationSeconds(metaRaw: unknown): number {
+  const meta = parseMetaObject(metaRaw) as any
+
+  const raw =
+    meta?.media?.durationSeconds ??
+    meta?.media?.durationSec ??
+    meta?.media?.duration ??
+    meta?.file?.durationSeconds ??
+    meta?.file?.durationSec ??
+    meta?.file?.duration ??
+    meta?.durationSeconds ??
+    meta?.durationSec ??
+    meta?.duration
+
+  const n = Number(raw)
+  return Number.isFinite(n) && n > 0 ? n : 0
+}
+
+function segmentPreviewTime(obj: Record<string, unknown>): number | undefined {
+  const start = firstNumber(obj, [
+    'startSec',
+    'startSeconds',
+    'start_s',
+    'start',
+    'from',
+    'startMs',
+  ])
+
+  const end = firstNumber(obj, [
+    'endSec',
+    'endSeconds',
+    'end_s',
+    'end',
+    'to',
+    'endMs',
+  ])
+
+  const marker = firstNumber(obj, [
+    'markerTime',
+    'markerSec',
+    'markerSeconds',
+    'time',
+    't',
+    'timestamp',
+    'at',
+    'timeMs',
+    'timestampMs',
+  ])
+
+  if (typeof start === 'number' && typeof end === 'number' && end > start) {
+    return start + (end - start) / 2
+  }
+
+  if (typeof marker === 'number') return marker
+  if (typeof start === 'number') return start
+
+  return undefined
+}
+
+function segmentOpenTime(obj: Record<string, unknown>): number | undefined {
+  const start = firstNumber(obj, [
+    'startSec',
+    'startSeconds',
+    'start_s',
+    'start',
+    'from',
+    'startMs',
+  ])
+
+  const marker = firstNumber(obj, [
+    'markerTime',
+    'markerSec',
+    'markerSeconds',
+    'time',
+    't',
+    'timestamp',
+    'at',
+    'timeMs',
+    'timestampMs',
+  ])
+
+  if (typeof start === 'number') return start
+  if (typeof marker === 'number') return marker
+
+  return segmentPreviewTime(obj)
+}
+
+function spriteFrameIndexFromTime(
+  timeSec: number,
+  durationSec: number,
+  sprite: PreviewSpriteMeta
+): number {
+  const count = Math.max(1, sprite.count)
+
+  if (count <= 1) return 0
+
+  if (sprite.stepSeconds > 0) {
+    return Math.max(
+      0,
+      Math.min(count - 1, Math.round(timeSec / sprite.stepSeconds))
+    )
+  }
+
+  if (durationSec > 0) {
+    const ratio = Math.max(0, Math.min(1, timeSec / durationSec))
+    return Math.max(0, Math.min(count - 1, Math.round(ratio * (count - 1))))
+  }
+
+  return 0
+}
+
+function buildSpritePreview(
+  sprite: PreviewSpriteMeta,
+  timeSec: number,
+  durationSec: number
+): SegmentSpritePreview {
+  const count = Math.max(1, sprite.count)
+  const cols = Math.max(1, sprite.cols)
+  const rows = Math.max(1, sprite.rows)
+
+  const index = spriteFrameIndexFromTime(timeSec, durationSec, sprite)
+  const safeIndex = Math.max(0, Math.min(count - 1, index))
+
+  const col = safeIndex % cols
+  const row = Math.floor(safeIndex / cols)
+
+  return {
+    src: sprite.path,
+
+    // Dieser Container hält die echte Frame-Proportion.
+    // Er darf größer als die Karte sein, damit das Bild wie object-cover wirkt.
+    frameStyle: {
+      position: 'absolute',
+      left: '50%',
+      top: '50%',
+      width: '100%',
+      minHeight: '100%',
+      aspectRatio: `${sprite.aspectRatio}`,
+      transform: 'translate(-50%, -50%)',
+      overflow: 'hidden',
+    },
+
+    // Das Sprite-Sheet wird nur innerhalb des korrekt proportionierten Frames verschoben.
+    imageStyle: {
+      position: 'absolute',
+      left: `${-col * 100}%`,
+      top: `${-row * 100}%`,
+      width: `${cols * 100}%`,
+      height: `${rows * 100}%`,
+      maxWidth: 'none',
+      pointerEvents: 'none',
+      userSelect: 'none',
+    },
+  }
+}
+
+function readTags(obj: Record<string, unknown>): string[] {
+  const raw =
+    obj.tags ??
+    obj.labels ??
+    obj.classes ??
+    obj.flags ??
+    []
+
+  if (typeof raw === 'string') {
+    return raw
+      .split(/[\n,;|]+/g)
+      .map((s) => prettyAiLabel(s))
+      .filter(Boolean)
+      .slice(0, 6)
+  }
+
+  if (Array.isArray(raw)) {
+    return raw
+      .map((v) => prettyAiLabel(v))
+      .filter(Boolean)
+      .slice(0, 6)
+  }
+
+  return []
+}
+
+function segmentValueLabel(obj: Record<string, unknown>): string | undefined {
+  const stars = firstNumber(obj, ['stars', 'ratingStars'])
+  if (typeof stars === 'number' && stars > 0) {
+    return `${Math.max(1, Math.min(5, Math.round(stars)))}/5`
+  }
+
+  const score = firstNumber(obj, ['score', 'confidence', 'probability', 'nsfw', 'explicitness'])
+  if (typeof score !== 'number') return undefined
+
+  if (score >= 0 && score <= 1) return `${Math.round(score * 100)}%`
+  return score.toFixed(2).replace(/\.?0+$/, '')
+}
+
+function segmentTimeLabel(obj: Record<string, unknown>): string | undefined {
+  const start = firstNumber(obj, [
+    'startSec',
+    'startSeconds',
+    'start_s',
+    'start',
+    'from',
+    't',
+    'time',
+    'timestamp',
+    'startMs',
+  ])
+
+  const end = firstNumber(obj, [
+    'endSec',
+    'endSeconds',
+    'end_s',
+    'end',
+    'to',
+    'endMs',
+  ])
+
+  const duration = firstNumber(obj, [
+    'durationSec',
+    'durationSeconds',
+    'duration_s',
+    'duration',
+    'durationMs',
+  ])
+
+  if (typeof start === 'number' && typeof end === 'number' && end > start) {
+    return `${formatSeconds(start)}–${formatSeconds(end)}`
+  }
+
+  if (typeof start === 'number') {
+    return `ab ${formatSeconds(start)}`
+  }
+
+  if (typeof duration === 'number') {
+    return `Dauer ${formatSeconds(duration)}`
+  }
+
+  return undefined
+}
+
+function readSegmentArray(metaRaw: unknown): unknown[] {
+  const meta = parseMetaObject(metaRaw) as any
+  const ai = readAiNode(metaRaw) as any
+  const rating = readRatingNode(metaRaw) as any
+
+  const candidates = [
+    ai?.segments,
+    ai?.ratingSegments,
+    ai?.hits,
+    ai?.matches,
+    rating?.segments,
+    rating?.hits,
+    meta?.analysis?.segments,
+    meta?.analysis?.hits,
+  ]
+
+  for (const candidate of candidates) {
+    if (Array.isArray(candidate) && candidate.length > 0) {
+      return candidate
+    }
+  }
+
+  return []
+}
+
+function readRatingSegments(metaRaw: unknown): RatingSegment[] {
+  const rawSegments = readSegmentArray(metaRaw)
+  const spriteMeta = readPreviewSpriteMeta(metaRaw)
+  const durationSeconds = readMetaDurationSeconds(metaRaw)
+
+  return rawSegments
+    .map((raw, index): RatingSegment | null => {
+      if (!isPlainObject(raw)) return null
+
+      const rawTitle =
+        firstString(raw, ['title', 'label', 'category', 'type', 'kind', 'name']) ??
+        `Segment ${index + 1}`
+
+      const title = prettyAiLabel(rawTitle)
+
+      const rawDetail =
+        firstString(raw, ['summary', 'reason', 'description', 'text', 'caption', 'note']) ??
+        undefined
+
+      const detail = rawDetail
+        ? rawDetail
+            .split(/,\s*/g)
+            .map((part) => isAiLikeLabel(part) ? prettyAiLabel(part) : part)
+            .join(', ')
+        : undefined
+
+      const previewTime = segmentPreviewTime(raw)
+      const openAtSec = segmentOpenTime(raw)
+
+      const preview =
+        spriteMeta && typeof previewTime === 'number'
+          ? buildSpritePreview(spriteMeta, previewTime, durationSeconds)
+          : undefined
+
+      return {
+        key: String(raw.id ?? raw.key ?? `${index}`),
+        title,
+        timeLabel: segmentTimeLabel(raw),
+        valueLabel: segmentValueLabel(raw),
+        detail,
+        tags: readTags(raw),
+        preview,
+        openAtSec,
+      }
+    })
+    .filter(Boolean)
+    .slice(0, 10) as RatingSegment[]
+}
+
+function ratingTone(stars: number) {
+  switch (stars) {
+    case 1:
+      return { star: 'text-yellow-400 opacity-40', label: 'Sehr niedrig' }
+    case 2:
+      return { star: 'text-yellow-400 opacity-55', label: 'Niedrig' }
+    case 3:
+      return { star: 'text-yellow-400 opacity-70', label: 'Mittel' }
+    case 4:
+      return { star: 'text-yellow-400 opacity-85', label: 'Hoch' }
+    default:
+      return { star: 'text-yellow-400 opacity-100', label: 'Sehr hoch' }
+  }
+}
+
+function RatingStar({
+  stars,
+  className,
+}: {
+  stars: number
+  className: string
+}) {
+  const tone = ratingTone(stars)
+
+  return (
+    <span className={`relative inline-grid shrink-0 place-items-center leading-none ${className}`}>
+      <svg
+        viewBox="0 0 20 20"
+        aria-hidden="true"
+        className={`shrink-0 fill-current ${tone.star}`}
+        style={{
+          filter: 'drop-shadow(0 1px 2px rgba(0,0,0,0.75)) drop-shadow(0 0 3px rgba(0,0,0,0.35))',
+        }}
+      >
+        <path
+          d="M9.049 2.927c.3-.921 1.603-.921 1.902 0l1.07 3.292a1 1 0 00.95.69h3.462c.969 0 1.371 1.24.588 1.81l-2.8 2.034a1 1 0 00-.364 1.118l1.07 3.292c.3.921-.755 1.688-1.54 1.118l-2.8-2.034a1 1 0 00-1.176 0l-2.8 2.034c-.784.57-1.838-.197-1.539-1.118l1.07-3.292a1 1 0 00-.364-1.118L2.98 9.72c-.783-.57-.38-1.81.588-1.81H7.03a1 1 0 00.951-.69l1.07-3.292z"
+          stroke="rgba(0,0,0,0.75)"
+          strokeWidth="1.1"
+          paintOrder="stroke fill"
+        />
+      </svg>
+
+      <span
+        className="absolute inset-0 grid place-items-center text-[10px] font-black leading-none text-white"
+        style={{
+          textShadow: '0 1px 2px rgba(0,0,0,0.95), 0 0 2px rgba(0,0,0,0.85)',
+        }}
+      >
+        {stars}
+      </span>
+    </span>
+  )
+}
+
+function RatingWithPopover({
+  stars,
+  metaRaw,
+  className,
+  onOpenAt,
+}: {
+  stars: number
+  metaRaw: unknown
+  className: string
+  onOpenAt?: (seconds: number) => void
+}) {
+  const entries = readRatingEntries(metaRaw)
+  const segments = readRatingSegments(metaRaw)
+  const tone = ratingTone(stars)
+
+  const starNode = (
+    <span
+      className="inline-flex items-center justify-center"
+      aria-label={`Rating ${stars} von 5`}
+      title={`Rating ${stars}/5`}
+    >
+      <RatingStar stars={stars} className={className} />
+    </span>
+  )
+
+  if (entries.length === 0 && segments.length === 0) {
+    return starNode
+  }
+
+  return (
+    <HoverPopover
+      content={(open) =>
+        open && (
+          <div className="w-[340px] overflow-hidden rounded-lg">
+            <div className="border-b border-gray-200 px-3 py-2 dark:border-white/10">
+              <div className="flex items-center justify-between gap-3">
+                <div>
+                  <div className="text-xs font-semibold text-gray-900 dark:text-white">
+                    AI Rating
+                  </div>
+                  <div className="mt-0.5 text-[11px] text-gray-500 dark:text-gray-400">
+                    {tone.label} · {stars}/5 Sterne
+                  </div>
+                </div>
+
+                <RatingStar stars={stars} className="h-7 w-7" />
+              </div>
+            </div>
+
+            <div className="max-h-[420px] overflow-y-auto px-3 py-2">
+              {entries.length > 0 ? (
+                <div className="space-y-1.5">
+                  {entries.map((entry) => (
+                    <div key={entry.key} className="flex items-start justify-between gap-3 text-[12px]">
+                      <span className="min-w-0 text-gray-500 dark:text-gray-400">
+                        {entry.label}
+                      </span>
+                      <span
+                        className={[
+                          'shrink-0 text-right font-medium',
+                          entry.tone === 'strong'
+                            ? 'text-gray-950 dark:text-white'
+                            : 'text-gray-800 dark:text-gray-100',
+                        ].join(' ')}
+                        title={entry.value}
+                      >
+                        {entry.value}
+                      </span>
+                    </div>
+                  ))}
+                </div>
+              ) : null}
+
+              {segments.length > 0 ? (
+                <div className={entries.length > 0 ? 'mt-3 border-t border-gray-200 pt-2 dark:border-white/10' : ''}>
+                  <div className="mb-2 flex items-center justify-between gap-2">
+                    <div className="text-[11px] font-semibold uppercase tracking-wide text-gray-500 dark:text-gray-400">
+                      Segmente
+                    </div>
+                    <div className="text-[11px] text-gray-400 dark:text-gray-500">
+                      {segments.length}
+                    </div>
+                  </div>
+
+                  <div className="space-y-2">
+                    {segments.map((segment, index) => (
+                      <button
+                        key={`${segment.key}-${index}`}
+                        type="button"
+                        disabled={!onOpenAt || typeof segment.openAtSec !== 'number'}
+                        title={
+                          onOpenAt && typeof segment.openAtSec === 'number'
+                            ? `Video bei ${formatSeconds(segment.openAtSec)} öffnen`
+                            : undefined
+                        }
+                        onClick={(e) => {
+                          e.preventDefault()
+                          e.stopPropagation()
+
+                          if (!onOpenAt || typeof segment.openAtSec !== 'number') return
+                          onOpenAt(segment.openAtSec)
+                        }}
+                        className={[
+                          'relative block w-full overflow-hidden rounded-md text-left ring-1 transition',
+                          onOpenAt && typeof segment.openAtSec === 'number'
+                            ? 'cursor-pointer hover:scale-[1.01] hover:ring-indigo-400/60 focus:outline-none focus:ring-2 focus:ring-indigo-500'
+                            : 'cursor-default',
+                          segment.preview
+                            ? 'bg-black ring-white/10'
+                            : 'bg-gray-50 ring-gray-200 dark:bg-white/5 dark:ring-white/10',
+                        ].join(' ')}
+                      >
+                        {segment.preview ? (
+                          <div className="absolute inset-0 bg-black" aria-hidden="true">
+                            <div style={segment.preview.frameStyle}>
+                              <img
+                                src={segment.preview.src}
+                                alt=""
+                                draggable={false}
+                                style={segment.preview.imageStyle}
+                              />
+                            </div>
+
+                            <div className="absolute inset-0 bg-gradient-to-r from-black/75 via-black/45 to-black/70" />
+                            <div className="absolute inset-0 bg-black/20" />
+                          </div>
+                        ) : null}
+
+                        <div className="relative z-10 px-2.5 py-2">
+                          <div className="flex items-start justify-between gap-2">
+                            <div className="min-w-0">
+                              <div
+                                className={[
+                                  'truncate text-[12px] font-semibold',
+                                  segment.preview ? 'text-white' : 'text-gray-900 dark:text-white',
+                                ].join(' ')}
+                              >
+                                {segment.title}
+                              </div>
+
+                              {segment.timeLabel ? (
+                                <div
+                                  className={[
+                                    'mt-0.5 text-[11px] tabular-nums',
+                                    segment.preview ? 'text-white/75' : 'text-gray-500 dark:text-gray-400',
+                                  ].join(' ')}
+                                >
+                                  {segment.timeLabel}
+                                </div>
+                              ) : null}
+                            </div>
+
+                            {segment.valueLabel ? (
+                              <div
+                                className={[
+                                  'shrink-0 rounded-full px-2 py-0.5 text-[11px] font-semibold ring-1',
+                                  segment.preview
+                                    ? 'bg-black/45 text-white ring-white/20 backdrop-blur-sm'
+                                    : 'bg-white text-gray-800 ring-gray-200 dark:bg-black/20 dark:text-gray-100 dark:ring-white/10',
+                                ].join(' ')}
+                              >
+                                {segment.valueLabel}
+                              </div>
+                            ) : null}
+                          </div>
+
+                          {segment.detail ? (
+                            <div
+                              className={[
+                                'mt-1.5 text-[11px] leading-snug',
+                                segment.preview ? 'text-white/85' : 'text-gray-600 dark:text-gray-300',
+                              ].join(' ')}
+                            >
+                              {segment.detail}
+                            </div>
+                          ) : null}
+
+                          {segment.tags.length > 0 ? (
+                            <div className="mt-1.5 flex flex-wrap gap-1">
+                              {segment.tags.map((tag) => (
+                                <span
+                                  key={tag}
+                                  className={[
+                                    'rounded-full px-1.5 py-0.5 text-[10px] font-medium ring-1',
+                                    segment.preview
+                                      ? 'bg-black/45 text-white/90 ring-white/20 backdrop-blur-sm'
+                                      : 'bg-white text-gray-600 ring-gray-200 dark:bg-black/20 dark:text-gray-300 dark:ring-white/10',
+                                  ].join(' ')}
+                                >
+                                  {tag}
+                                </span>
+                              ))}
+                            </div>
+                          ) : null}
+                        </div>
+                      </button>
+                    ))}
+                  </div>
+                </div>
+              ) : null}
+            </div>
+          </div>
+        )
+      }
+    >
+      {starNode}
+    </HoverPopover>
+  )
+}
+
+export default function RatingOverlay({
+  metaRaw,
+  variant = 'overlay',
+  reserveSpace = false,
+  onOpenAt,
+}: RatingOverlayProps) {
+  const stars = readRatingStars(metaRaw)
+
+  if (typeof stars !== 'number') {
+    if (reserveSpace && variant === 'badge') {
+      return <span aria-hidden="true" className="inline-block h-6 w-6 shrink-0 opacity-0" />
+    }
+
+    return null
+  }
+
+  if (variant === 'badge') {
+    return (
+      <span className="inline-flex h-6 w-6 shrink-0 items-center justify-center align-middle">
+        <RatingWithPopover
+          stars={stars}
+          metaRaw={metaRaw}
+          className="h-6 w-6"
+          onOpenAt={onOpenAt}
+        />
+      </span>
+    )
+  }
+
+  return (
+    <span className="inline-flex h-6 min-w-[24px] shrink-0 items-center justify-center">
+      <RatingWithPopover
+        stars={stars}
+        metaRaw={metaRaw}
+        className="h-6 w-6"
+        onOpenAt={onOpenAt}
+      />
+    </span>
+  )
+}
\ No newline at end of file
diff --git a/frontend/src/components/ui/RecorderSettings.tsx b/frontend/src/components/ui/RecorderSettings.tsx
index 09038ec..56d0acb 100644
--- a/frontend/src/components/ui/RecorderSettings.tsx
+++ b/frontend/src/components/ui/RecorderSettings.tsx
@@ -24,6 +24,7 @@ type RecorderSettings = {
   useMyFreeCamsWatcher?: boolean
   autoDeleteSmallDownloads?: boolean
   autoDeleteSmallDownloadsBelowMB?: number
+  autoDeleteSmallDownloadsKeepFavorites?: boolean
   blurPreviews?: boolean
   teaserPlayback?: 'still' | 'hover' | 'all'
   teaserAudio?: boolean
@@ -60,6 +61,7 @@ const DEFAULTS: RecorderSettings = {
   useMyFreeCamsWatcher: false,
   autoDeleteSmallDownloads: true,
   autoDeleteSmallDownloadsBelowMB: 200,
+  autoDeleteSmallDownloadsKeepFavorites: true,
   blurPreviews: false,
   teaserPlayback: 'hover',
   teaserAudio: false,
@@ -397,6 +399,8 @@ export default function RecorderSettings({ onAssetsGenerated }: Props) {
           useMyFreeCamsWatcher: data.useMyFreeCamsWatcher ?? DEFAULTS.useMyFreeCamsWatcher,
           autoDeleteSmallDownloads: data.autoDeleteSmallDownloads ?? DEFAULTS.autoDeleteSmallDownloads,
           autoDeleteSmallDownloadsBelowMB: data.autoDeleteSmallDownloadsBelowMB ?? DEFAULTS.autoDeleteSmallDownloadsBelowMB,
+          autoDeleteSmallDownloadsKeepFavorites:
+            (data as any).autoDeleteSmallDownloadsKeepFavorites ?? DEFAULTS.autoDeleteSmallDownloadsKeepFavorites,
           blurPreviews: data.blurPreviews ?? DEFAULTS.blurPreviews,
           teaserPlayback: (data as any).teaserPlayback ?? DEFAULTS.teaserPlayback,
           teaserAudio: (data as any).teaserAudio ?? DEFAULTS.teaserAudio,
@@ -688,6 +692,7 @@ export default function RecorderSettings({ onAssetsGenerated }: Props) {
       0,
       Math.min(100_000, Math.floor(Number(value.autoDeleteSmallDownloadsBelowMB ?? DEFAULTS.autoDeleteSmallDownloadsBelowMB)))
     )
+    const autoDeleteSmallDownloadsKeepFavorites = !!value.autoDeleteSmallDownloadsKeepFavorites
     const blurPreviews = !!value.blurPreviews
     const teaserPlayback =
       value.teaserPlayback === 'still' || value.teaserPlayback === 'all' || value.teaserPlayback === 'hover'
@@ -720,6 +725,7 @@ export default function RecorderSettings({ onAssetsGenerated }: Props) {
           useMyFreeCamsWatcher,
           autoDeleteSmallDownloads,
           autoDeleteSmallDownloadsBelowMB,
+          autoDeleteSmallDownloadsKeepFavorites,
           blurPreviews,
           teaserPlayback,
           teaserAudio,
@@ -1321,6 +1327,25 @@ export default function RecorderSettings({ onAssetsGenerated }: Props) {
                   </div>
                 </div>
               </div>
+
+              <div
+                className={
+                  'mt-3 border-t border-gray-200 pt-3 dark:border-white/10 ' +
+                  (!value.autoDeleteSmallDownloads ? 'opacity-50 pointer-events-none' : '')
+                }
+              >
+                <LabeledSwitch
+                  checked={!!value.autoDeleteSmallDownloadsKeepFavorites}
+                  onChange={(checked) =>
+                    setValue((v) => ({
+                      ...v,
+                      autoDeleteSmallDownloadsKeepFavorites: checked,
+                    }))
+                  }
+                  label="Favoriten nicht automatisch löschen"
+                  description="Schützt Downloads von favorisierten Models vor dem automatischen Löschen, auch wenn die Datei kleiner als die Mindestgröße ist."
+                />
+              </div>
             </div>
 
             <LabeledSwitch