updated

backend/analyze.go

@@ -613,13 +613,11 @@ func mergeAnalyzeHits(in []analyzeHit) []analyzeHit {
 	for i := 1; i < len(cp); i++ {
 		n := cp[i]
 
-		// Nur direkt aufeinanderfolgende Treffer mit gleichem Label zusammenfassen
+		// Direkt aufeinanderfolgende Treffer mit gleichem Label immer zusammenfassen.
-		const mergeGapSeconds = 1.0
+		// Sobald ein anderes Label dazwischen liegt, wird automatisch nicht gemergt.
-
 		sameLabel := strings.EqualFold(cur.Label, n.Label)
-		touchesOrNear := n.Start <= cur.End+mergeGapSeconds
 
-		if sameLabel && touchesOrNear {
+		if sameLabel {
 			if n.Start < cur.Start {
 				cur.Start = n.Start
 			}

backend/assets_generate.go

@@ -932,7 +932,6 @@ func ensureAssetsForVideoDetailed(ctx context.Context, videoPath string, sourceU
 			}); err != nil {
 				if isFFmpegInputInvalidError(err) {
 					sourceInputInvalid = true
-					fmt.Printf("⚠️ preview clips skipped (invalid/incomplete input): %s\n", videoPath)
 					return
 				}
 				return

backend/tasks_regenerate_assets.go

@@ -14,10 +14,35 @@ import (
 	"time"
 )
 
+const regenerateAssetsMaxParallel = 3
+
 type regenerateAssetsRequest struct {
 	File string `json:"file"`
 }
 
+type regenerateAssetsJob struct {
+	File      string
+	VideoPath string
+	AssetID   string
+
+	Ctx    context.Context
+	Cancel context.CancelFunc
+
+	State string // queued | running | done | error | cancelled
+	Error string
+
+	EnqueuedAt time.Time
+	StartedAt  time.Time
+	EndedAt    time.Time
+}
+
+var (
+	regenerateAssetsMu             sync.Mutex
+	regenerateAssetsJobs           = map[string]*regenerateAssetsJob{} // key = file
+	regenerateAssetsQueue          []string                            // file names
+	regenerateAssetsWorkersStarted bool
+)
+
 func publishFinishedPostworkPhase(
 	file string,
 	assetID string,
@@ -41,131 +66,140 @@ func publishFinishedPostworkPhase(
 	}
 }
 
-var (
+func ensureRegenerateAssetsWorkersStarted() {
-	regenerateAssetsRunMu  sync.Mutex
+	regenerateAssetsMu.Lock()
-	regenerateAssetsCancel context.CancelFunc
+	defer regenerateAssetsMu.Unlock()
-	regenerateAssetsFile   string
-)
 
-func handleRegenerateAssets(w http.ResponseWriter, r *http.Request) {
+	if regenerateAssetsWorkersStarted {
-	if r.Method != http.MethodPost && r.Method != http.MethodDelete {
-		http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
 		return
 	}
 
-	if r.Method == http.MethodDelete {
+	regenerateAssetsWorkersStarted = true
-		regenerateAssetsRunMu.Lock()
-		cancel := regenerateAssetsCancel
-		file := regenerateAssetsFile
-		regenerateAssetsCancel = nil
-		regenerateAssetsFile = ""
-		regenerateAssetsRunMu.Unlock()
 
-		if cancel != nil {
+	for i := 0; i < regenerateAssetsMaxParallel; i++ {
-			cancel()
+		go regenerateAssetsWorker()
+	}
+}
+
+func enqueueRegenerateAssetsJob(job *regenerateAssetsJob) {
+	regenerateAssetsMu.Lock()
+	defer regenerateAssetsMu.Unlock()
+
+	regenerateAssetsJobs[job.File] = job
+	regenerateAssetsQueue = append(regenerateAssetsQueue, job.File)
+}
+
+func nextQueuedRegenerateAssetsJob() *regenerateAssetsJob {
+	regenerateAssetsMu.Lock()
+	defer regenerateAssetsMu.Unlock()
+
+	for len(regenerateAssetsQueue) > 0 {
+		file := regenerateAssetsQueue[0]
+		regenerateAssetsQueue = regenerateAssetsQueue[1:]
+
+		job := regenerateAssetsJobs[file]
+		if job == nil {
+			continue
+		}
+		if job.State != "queued" {
+			continue
 		}
 
-		if strings.TrimSpace(file) != "" {
+		job.State = "running"
+		job.StartedAt = time.Now()
+		return job
+	}
+
+	return nil
+}
+
+func finishRegenerateAssetsJob(file string, state string, errMsg string) {
+	regenerateAssetsMu.Lock()
+	defer regenerateAssetsMu.Unlock()
+
+	job := regenerateAssetsJobs[file]
+	if job == nil {
+		return
+	}
+
+	job.State = state
+	job.Error = strings.TrimSpace(errMsg)
+	job.EndedAt = time.Now()
+}
+
+func removeRegenerateAssetsJobLater(file string, after time.Duration) {
+	time.AfterFunc(after, func() {
+		regenerateAssetsMu.Lock()
+		defer regenerateAssetsMu.Unlock()
+
+		delete(regenerateAssetsJobs, file)
+	})
+}
+
+func getRegenerateAssetsJobsSnapshot() []map[string]any {
+	regenerateAssetsMu.Lock()
+	defer regenerateAssetsMu.Unlock()
+
+	out := make([]map[string]any, 0, len(regenerateAssetsJobs))
+	for _, job := range regenerateAssetsJobs {
+		out = append(out, map[string]any{
+			"file":       job.File,
+			"assetId":    job.AssetID,
+			"state":      job.State,
+			"error":      job.Error,
+			"enqueuedAt": job.EnqueuedAt.UnixMilli(),
+			"startedAt": func() int64 {
+				if job.StartedAt.IsZero() {
+					return 0
+				}
+				return job.StartedAt.UnixMilli()
+			}(),
+			"endedAt": func() int64 {
+				if job.EndedAt.IsZero() {
+					return 0
+				}
+				return job.EndedAt.UnixMilli()
+			}(),
+		})
+	}
+
+	return out
+}
+
+func regenerateAssetsWorker() {
+	for {
+		job := nextQueuedRegenerateAssetsJob()
+		if job == nil {
+			time.Sleep(250 * time.Millisecond)
+			continue
+		}
+
+		runRegenerateAssetsJob(job)
+	}
+}
+
+func runRegenerateAssetsJob(job *regenerateAssetsJob) {
+	file := job.File
+	videoPath := job.VideoPath
+	id := job.AssetID
+	ctx := job.Ctx
+
+	setRegenerateAssetsTaskRunning(file, file)
+
+	cancelDeferredEnrichForFile(file)
+
+	select {
+	case <-ctx.Done():
+		finishRegenerateAssetsJob(file, "cancelled", "Abgebrochen")
 		setRegenerateAssetsTaskError(file, "Abgebrochen")
 
-			id := strings.TrimSpace(assetIDFromVideoPath(file))
-			if id == "" {
-				id = stripHotPrefix(strings.TrimSuffix(filepath.Base(file), filepath.Ext(file)))
-			}
-
 		publishFinishedPostworkPhase(file, id, "postwork", "meta", "missing", "")
 		publishFinishedPostworkPhase(file, id, "postwork", "teaser", "missing", "")
 		publishFinishedPostworkPhase(file, id, "postwork", "thumb", "missing", "")
 		publishFinishedPostworkPhase(file, id, "postwork", "sprites", "missing", "")
 		publishFinishedPostworkPhase(file, id, "enrich", "analyze", "missing", "")
 
-			time.AfterFunc(2*time.Second, func() {
+		removeRegenerateAssetsJobLater(file, 2*time.Second)
-				clearRegenerateAssetsTaskState()
-			})
-		} else {
-			clearRegenerateAssetsTaskState()
-		}
-
-		w.Header().Set("Content-Type", "application/json")
-		_ = json.NewEncoder(w).Encode(map[string]any{
-			"ok":        true,
-			"cancelled": true,
-		})
-		return
-	}
-
-	var req regenerateAssetsRequest
-	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
-		http.Error(w, "invalid json body", http.StatusBadRequest)
-		return
-	}
-
-	file := strings.TrimSpace(req.File)
-	if file == "" {
-		http.Error(w, "missing file", http.StatusBadRequest)
-		return
-	}
-	if !isAllowedVideoExt(file) {
-		http.Error(w, "nicht erlaubt", http.StatusForbidden)
-		return
-	}
-
-	s := getSettings()
-	doneAbs, err := resolvePathRelativeToApp(s.DoneDir)
-	if err != nil {
-		http.Error(w, "doneDir auflösung fehlgeschlagen: "+err.Error(), http.StatusInternalServerError)
-		return
-	}
-	if strings.TrimSpace(doneAbs) == "" {
-		http.Error(w, "doneDir ist leer", http.StatusBadRequest)
-		return
-	}
-
-	videoPath, _, fi, err := resolveDoneFileByName(doneAbs, file)
-	if err != nil {
-		http.Error(w, "datei nicht gefunden", http.StatusNotFound)
-		return
-	}
-	if fi == nil || fi.IsDir() || fi.Size() <= 0 {
-		http.Error(w, "invalid output path", http.StatusBadRequest)
-		return
-	}
-
-	runCtx, runCancel := context.WithCancel(context.Background())
-
-	regenerateAssetsRunMu.Lock()
-	if regenerateAssetsCancel != nil {
-		regenerateAssetsCancel()
-	}
-	regenerateAssetsCancel = runCancel
-	regenerateAssetsFile = file
-	regenerateAssetsRunMu.Unlock()
-
-	setRegenerateAssetsTaskRunning(file, file)
-
-	go func(ctx context.Context, videoPath string, file string) {
-		defer func() {
-			regenerateAssetsRunMu.Lock()
-			if regenerateAssetsFile == file {
-				regenerateAssetsCancel = nil
-				regenerateAssetsFile = ""
-			}
-			regenerateAssetsRunMu.Unlock()
-		}()
-
-		id := assetIDFromVideoPath(videoPath)
-		if strings.TrimSpace(id) == "" {
-			id = stripHotPrefix(strings.TrimSuffix(filepath.Base(file), filepath.Ext(file)))
-		}
-
-		cancelDeferredEnrichForFile(file)
-
-		select {
-		case <-ctx.Done():
-			setRegenerateAssetsTaskError(file, "Abgebrochen")
-			time.AfterFunc(2*time.Second, func() {
-				clearRegenerateAssetsTaskState()
-			})
 		return
 	default:
 	}
@@ -235,6 +269,7 @@ func handleRegenerateAssets(w http.ResponseWriter, r *http.Request) {
 	close(assetWatchDone)
 
 	if errors.Is(errAssets, context.Canceled) || ctx.Err() == context.Canceled {
+		finishRegenerateAssetsJob(file, "cancelled", "Abgebrochen")
 		setRegenerateAssetsTaskError(file, "Abgebrochen")
 
 		publishFinishedPostworkPhase(file, id, "postwork", "meta", "missing", "")
@@ -243,9 +278,7 @@ func handleRegenerateAssets(w http.ResponseWriter, r *http.Request) {
 		publishFinishedPostworkPhase(file, id, "postwork", "sprites", "missing", "")
 		publishFinishedPostworkPhase(file, id, "enrich", "analyze", "missing", "")
 
-			time.AfterFunc(2*time.Second, func() {
+		removeRegenerateAssetsJobLater(file, 2*time.Second)
-				clearRegenerateAssetsTaskState()
-			})
 		return
 	}
 
@@ -256,12 +289,11 @@ func handleRegenerateAssets(w http.ResponseWriter, r *http.Request) {
 	errAI := ensureDeferredAssetsAndAI(ctx, videoPath, "")
 
 	if errors.Is(errAI, context.Canceled) || ctx.Err() == context.Canceled {
+		finishRegenerateAssetsJob(file, "cancelled", "Abgebrochen")
 		setRegenerateAssetsTaskError(file, "Abgebrochen")
 		publishFinishedPostworkPhase(file, id, "enrich", "analyze", "missing", "")
 
-			time.AfterFunc(2*time.Second, func() {
+		removeRegenerateAssetsJobLater(file, 2*time.Second)
-				clearRegenerateAssetsTaskState()
-			})
 		return
 	}
 
@@ -277,6 +309,7 @@ func handleRegenerateAssets(w http.ResponseWriter, r *http.Request) {
 			errMsg = errAI.Error()
 		}
 
+		finishRegenerateAssetsJob(file, "error", errMsg)
 		setRegenerateAssetsTaskError(file, errMsg)
 
 		errEv := finishedPostworkEvent{
@@ -293,22 +326,130 @@ func handleRegenerateAssets(w http.ResponseWriter, r *http.Request) {
 			publishSSE("finishedPostwork", b)
 		}
 
-			time.AfterFunc(5*time.Second, func() {
+		removeRegenerateAssetsJobLater(file, 5*time.Second)
-				clearRegenerateAssetsTaskState()
+		return
+	}
+
+	finishRegenerateAssetsJob(file, "done", "")
+	setRegenerateAssetsTaskDone(file, "Fertig")
+	removeRegenerateAssetsJobLater(file, 3*time.Second)
+}
+
+func handleRegenerateAssets(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodPost && r.Method != http.MethodDelete {
+		http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
+		return
+	}
+
+	if r.Method == http.MethodDelete {
+		var req regenerateAssetsRequest
+		_ = json.NewDecoder(r.Body).Decode(&req)
+
+		file := strings.TrimSpace(req.File)
+		if file == "" {
+			http.Error(w, "missing file", http.StatusBadRequest)
+			return
+		}
+
+		regenerateAssetsMu.Lock()
+		job := regenerateAssetsJobs[file]
+		regenerateAssetsMu.Unlock()
+
+		if job != nil && job.Cancel != nil {
+			job.Cancel()
+		}
+
+		w.Header().Set("Content-Type", "application/json")
+		_ = json.NewEncoder(w).Encode(map[string]any{
+			"ok":        true,
+			"cancelled": true,
+			"file":      file,
 		})
 		return
 	}
 
-		setRegenerateAssetsTaskDone(file, "Fertig")
+	var req regenerateAssetsRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		http.Error(w, "invalid json body", http.StatusBadRequest)
+		return
+	}
 
-		time.AfterFunc(3*time.Second, func() {
+	file := strings.TrimSpace(req.File)
-			clearRegenerateAssetsTaskState()
+	if file == "" {
-		})
+		http.Error(w, "missing file", http.StatusBadRequest)
-	}(runCtx, videoPath, file)
+		return
+	}
+	if !isAllowedVideoExt(file) {
+		http.Error(w, "nicht erlaubt", http.StatusForbidden)
+		return
+	}
+
+	s := getSettings()
+	doneAbs, err := resolvePathRelativeToApp(s.DoneDir)
+	if err != nil {
+		http.Error(w, "doneDir auflösung fehlgeschlagen: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+	if strings.TrimSpace(doneAbs) == "" {
+		http.Error(w, "doneDir ist leer", http.StatusBadRequest)
+		return
+	}
+
+	videoPath, _, fi, err := resolveDoneFileByName(doneAbs, file)
+	if err != nil {
+		http.Error(w, "datei nicht gefunden", http.StatusNotFound)
+		return
+	}
+	if fi == nil || fi.IsDir() || fi.Size() <= 0 {
+		http.Error(w, "invalid output path", http.StatusBadRequest)
+		return
+	}
+
+	ensureRegenerateAssetsWorkersStarted()
+
+	regenerateAssetsMu.Lock()
+	if existing := regenerateAssetsJobs[file]; existing != nil {
+		regenerateAssetsMu.Unlock()
 
 		w.Header().Set("Content-Type", "application/json")
 		_ = json.NewEncoder(w).Encode(map[string]any{
 			"ok":    true,
 			"file":  file,
+			"state": existing.State,
+		})
+		return
+	}
+	regenerateAssetsMu.Unlock()
+
+	runCtx, runCancel := context.WithCancel(context.Background())
+
+	id := assetIDFromVideoPath(videoPath)
+	if strings.TrimSpace(id) == "" {
+		id = stripHotPrefix(strings.TrimSuffix(filepath.Base(file), filepath.Ext(file)))
+	}
+
+	job := &regenerateAssetsJob{
+		File:       file,
+		VideoPath:  videoPath,
+		AssetID:    id,
+		Ctx:        runCtx,
+		Cancel:     runCancel,
+		State:      "queued",
+		EnqueuedAt: time.Now(),
+	}
+
+	enqueueRegenerateAssetsJob(job)
+
+	publishFinishedPostworkPhase(file, id, "postwork", "meta", "queued", "Meta")
+	publishFinishedPostworkPhase(file, id, "postwork", "teaser", "queued", "Teaser")
+	publishFinishedPostworkPhase(file, id, "postwork", "thumb", "queued", "Vorschaubild")
+	publishFinishedPostworkPhase(file, id, "postwork", "sprites", "queued", "Sprites")
+	publishFinishedPostworkPhase(file, id, "enrich", "analyze", "queued", "KI-Analyse")
+
+	w.Header().Set("Content-Type", "application/json")
+	_ = json.NewEncoder(w).Encode(map[string]any{
+		"ok":    true,
+		"file":  file,
+		"state": "queued",
 	})
 }

backend/tasks_status.go

@@ -30,6 +30,7 @@ type RegenerateAssetsTaskState struct {
 type TasksStatusResponse struct {
 	GenerateAssets       AssetsTaskState           `json:"generateAssets"`
 	RegenerateAssets     RegenerateAssetsTaskState `json:"regenerateAssets"`
+	RegenerateAssetsJobs []map[string]any          `json:"regenerateAssetsJobs"`
 	Cleanup              CleanupTaskState          `json:"cleanup"`
 	AnyRunning           bool                      `json:"anyRunning"`
 }
@@ -47,6 +48,17 @@ func cleanupNowISO() *string {
 	return &s
 }
 
+func anyToString(v any) string {
+	switch x := v.(type) {
+	case string:
+		return x
+	case []byte:
+		return string(x)
+	default:
+		return ""
+	}
+}
+
 func snapshotRegenerateAssetsTaskState() RegenerateAssetsTaskState {
 	regenerateAssetsTaskMu.Lock()
 	st := regenerateAssetsTaskState
@@ -175,13 +187,26 @@ func tasksStatusHandler(w http.ResponseWriter, r *http.Request) {
 
 	assets := getGenerateAssetsTaskStatus()
 	regenerate := snapshotRegenerateAssetsTaskState()
+	regenerateJobs := getRegenerateAssetsJobsSnapshot()
 	cleanup := snapshotCleanupTaskState()
 
+	anyRegenerateRunning := regenerate.Running
+	if !anyRegenerateRunning {
+		for _, job := range regenerateJobs {
+			state := strings.TrimSpace(strings.ToLower(anyToString(job["state"])))
+			if state == "queued" || state == "running" {
+				anyRegenerateRunning = true
+				break
+			}
+		}
+	}
+
 	resp := TasksStatusResponse{
 		GenerateAssets:       assets,
 		RegenerateAssets:     regenerate,
+		RegenerateAssetsJobs: regenerateJobs,
 		Cleanup:              cleanup,
-		AnyRunning:       assets.Running || regenerate.Running || cleanup.Running,
+		AnyRunning:           assets.Running || anyRegenerateRunning || cleanup.Running,
 	}
 
 	w.Header().Set("Content-Type", "application/json")

frontend/src/components/ui/FinishedDownloads.tsx

@@ -1477,89 +1477,90 @@ export default function FinishedDownloads({
         const data = await res.json().catch(() => null)
         if (!alive || !data) return
 
-        const regen = data?.regenerateAssets
+        const jobs = Array.isArray(data?.regenerateAssetsJobs)
-        const file = String(regen?.file ?? '').trim()
+          ? data.regenerateAssetsJobs
+          : []
 
-        if (!file) return
+        if (jobs.length > 0) {
+          setPostworkByFile((prev) => {
+            const next = { ...prev }
 
-        if (regen?.running) {
+            for (const item of jobs) {
-          setPostworkByFile((prev) => ({
+              const file = String(item?.file ?? '').trim()
-            ...prev,
+              if (!file) continue
-            [file]: [
+
+              const rawState = String(item?.state ?? '').trim().toLowerCase()
+              const assetId =
+                String(item?.assetId ?? '').trim() || fileStemFromOutput(file)
+
+              const state: FinishedPostworkState =
+                rawState === 'queued' ||
+                rawState === 'running' ||
+                rawState === 'done' ||
+                rawState === 'error' ||
+                rawState === 'missing'
+                  ? rawState
+                  : rawState === 'cancelled'
+                    ? 'missing'
+                    : 'missing'
+
+              // Nur aktive / noch relevante Jobs beim Initial-Load wiederherstellen.
+              // "done" kommt danach ohnehin sauber über Meta/SSE rein.
+              if (state !== 'queued' && state !== 'running' && state !== 'error') {
+                continue
+              }
+
+              next[file] = [
                 {
                   file,
-                assetId: fileStemFromOutput(file),
+                  assetId,
-                queue: 'enrich',
+                  queue: 'postwork',
-                state: 'running',
+                  state,
-                phase: 'assets',
+                  phase: 'meta',
+                  label: 'Meta',
+                  ts: Date.now(),
+                },
+                {
+                  file,
+                  assetId,
+                  queue: 'postwork',
+                  state,
+                  phase: 'teaser',
+                  label: 'Teaser',
+                  ts: Date.now(),
+                },
+                {
+                  file,
+                  assetId,
+                  queue: 'postwork',
+                  state,
+                  phase: 'thumb',
                   label: 'Vorschaubild',
                   ts: Date.now(),
                 },
-            ],
-          }))
-          return
-        }
-
-        if (regen?.error) {
-          setPostworkByFile((prev) => ({
-            ...prev,
-            [file]: [
                 {
                   file,
-                assetId: fileStemFromOutput(file),
+                  assetId,
-                queue: 'enrich',
+                  queue: 'postwork',
-                state: 'error',
+                  state,
-                phase: 'assets',
+                  phase: 'sprites',
-                label: 'Fehler',
+                  label: 'Sprites',
                   ts: Date.now(),
                 },
-            ],
-          }))
-          return
-        }
-
-        const bulk = data?.generateAssets
-        const bulkFile = String(bulk?.currentFile ?? '').trim()
-        const bulkQueue =
-          String(bulk?.currentQueue ?? '').trim().toLowerCase() === 'enrich'
-            ? 'enrich'
-            : 'postwork'
-        const bulkPhase = String(bulk?.currentPhase ?? '').trim().toLowerCase()
-        const bulkLabel = String(bulk?.currentLabel ?? '').trim()
-
-        if (bulk?.running && bulkFile && bulkPhase) {
-          setPostworkByFile((prev) => ({
-            ...prev,
-            [bulkFile]: [
-              {
-                file: bulkFile,
-                assetId: fileStemFromOutput(bulkFile),
-                queue: bulkQueue,
-                state: 'running',
-                phase: bulkPhase,
-                label: bulkLabel || undefined,
-                ts: Date.now(),
-              },
-            ],
-          }))
-        }
-
-        // optional: wenn du "done" kurz nach Reload noch sichtbar haben willst
-        if (regen?.text) {
-          setPostworkByFile((prev) => ({
-            ...prev,
-            [file]: [
                 {
                   file,
-                assetId: fileStemFromOutput(file),
+                  assetId,
                   queue: 'enrich',
-                state: 'done',
+                  state,
-                phase: 'assets',
+                  phase: 'analyze',
-                label: 'Fertig',
+                  label: 'KI-Analyse',
                   ts: Date.now(),
                 },
-            ],
+              ]
-          }))
+            }
+
+            return next
+          })
         }
       } catch {
         // ignore
@@ -2820,13 +2821,49 @@ export default function FinishedDownloads({
     setPostworkByFile((prev) => ({
       ...prev,
       [cleanFile]: [
+        {
+          file: cleanFile,
+          assetId: fileStemFromOutput(cleanFile),
+          queue: 'postwork',
+          state: 'queued',
+          phase: 'meta',
+          label: 'Meta',
+          ts: Date.now(),
+        },
+        {
+          file: cleanFile,
+          assetId: fileStemFromOutput(cleanFile),
+          queue: 'postwork',
+          state: 'queued',
+          phase: 'teaser',
+          label: 'Teaser',
+          ts: Date.now(),
+        },
+        {
+          file: cleanFile,
+          assetId: fileStemFromOutput(cleanFile),
+          queue: 'postwork',
+          state: 'queued',
+          phase: 'thumb',
+          label: 'Vorschaubild',
+          ts: Date.now(),
+        },
+        {
+          file: cleanFile,
+          assetId: fileStemFromOutput(cleanFile),
+          queue: 'postwork',
+          state: 'queued',
+          phase: 'sprites',
+          label: 'Sprites',
+          ts: Date.now(),
+        },
         {
           file: cleanFile,
           assetId: fileStemFromOutput(cleanFile),
           queue: 'enrich',
-          state: 'running',
+          state: 'queued',
-          phase: 'assets',
+          phase: 'analyze',
-          label: 'Wird verarbeitet…',
+          label: 'KI-Analyse',
           ts: Date.now(),
         },
       ],

frontend/src/components/ui/FinishedVideoPreview.tsx

@@ -151,46 +151,9 @@ export default function FinishedVideoPreview({
     return m
   }, [job])
 
-  // ✅ falls job.meta keine previewClips enthält: meta.json nachladen
-  const [fetchedMeta, setFetchedMeta] = useState<any | null>(null)
-
-  // ✅ verhindert mehrfachen fallback-fetch pro Datei in derselben Komponenteninstanz
-  const fetchedMetaFilesRef = useRef<Set<string>>(new Set())  
-
   // ✅ merge statt "meta ?? fetchedMeta"
   // job.meta bleibt Basis, fetchedMeta ergänzt fehlende Felder (z.B. previewClips)
-  const metaForPreview = useMemo(() => {
+  const metaForPreview = meta
-    if (!meta && !fetchedMeta) return null
-    if (!meta) return fetchedMeta
-    if (!fetchedMeta) return meta
-    return { ...meta, ...fetchedMeta }
-  }, [meta, fetchedMeta])
-
-  // ✅ stabiler Guard für den fallback-fetch (berücksichtigt auch bereits geholtes fetchedMeta)
-  const hasPreviewClipsInAnyMeta = useMemo(() => {
-    let pcs: any = (metaForPreview as any)?.previewClips
-
-    if (typeof pcs === 'string') {
-      const s = pcs.trim()
-      if (s.length > 0) {
-        try {
-          const parsed = JSON.parse(s)
-          if (Array.isArray(parsed) && parsed.length > 0) return true
-          // falls string vorhanden aber nicht parsebar, behandeln wir ihn trotzdem als "vorhanden"
-          return true
-        } catch {
-          return true
-        }
-      }
-    }
-
-    if (Array.isArray(pcs) && pcs.length > 0) return true
-
-    const nested = (metaForPreview as any)?.preview?.clips
-    if (Array.isArray(nested) && nested.length > 0) return true
-
-    return false
-  }, [metaForPreview])
   
   const [progressMountTick, setProgressMountTick] = useState(0)
 
@@ -587,7 +550,6 @@ export default function FinishedVideoPreview({
   useEffect(() => {
     setTeaserReady(false)
     setTeaserOk(true)
-    setFetchedMeta(null) // ✅ neue Datei/Asset -> alten fallback-meta cache in state verwerfen
 
     // ✅ neue Datei/Asset -> Callback-Dedupe zurücksetzen
     emittedDurationRef.current = ''
@@ -783,63 +745,6 @@ export default function FinishedVideoPreview({
     if (did) setMetaLoaded(true)
   }, [file, job, onDuration, onResolution, hasDuration, hasResolution, effectiveDurationSec, effectiveW, effectiveH])
 
-  
-  // ✅ meta fallback fetch: nur wenn previewClips fehlen (für teaser-sprünge)
-  //    und pro Datei in dieser Komponenteninstanz nur 1x
-  useEffect(() => {
-    if (!previewId) return
-    if (!file) return
-    if (!animated || animatedMode !== 'teaser') return
-    if (!shouldPreloadAnimatedAssets) return
-
-    // ✅ wenn wir schon previewClips aus job.meta ODER fetchedMeta haben -> kein Request
-    if (hasPreviewClipsInAnyMeta) return
-
-    // ✅ gleicher file-Request in dieser Instanz schon gemacht -> nicht nochmal feuern
-    if (fetchedMetaFilesRef.current.has(file)) return
-
-    let aborted = false
-    const ctrl = new AbortController()
-
-    const tryFetch = async (url: string) => {
-      try {
-        const res = await fetch(url, {
-          signal: ctrl.signal,
-          cache: 'no-store',
-          credentials: 'include',
-        })
-        if (!res.ok) return null
-        return await res.json()
-      } catch {
-        return null
-      }
-    }
-
-    ;(async () => {
-      const byFile = await tryFetch(`/api/record/done/meta?file=${encodeURIComponent(file)}`)
-      if (aborted) return
-
-      // ✅ als "versucht" markieren (auch wenn null), damit nearView/inView/hover nicht spammt
-      fetchedMetaFilesRef.current.add(file)
-
-      if (byFile) {
-        setFetchedMeta(byFile)
-      }
-    })()
-
-    return () => {
-      aborted = true
-      ctrl.abort()
-    }
-  }, [
-    previewId,
-    file,
-    animated,
-    animatedMode,
-    shouldPreloadAnimatedAssets,
-    hasPreviewClipsInAnyMeta,
-  ])
-
   // ✅ Fallback: nur wenn wir wirklich noch nichts haben, über loadedmetadata nachladen
   const handleLoadedMetadata = (e: SyntheticEvent<HTMLVideoElement>) => {
     setMetaLoaded(true)

frontend/src/components/ui/VideoSplitModal.tsx

@@ -942,10 +942,7 @@ export default function VideoSplitModal({
         const clipMap = extractPreviewClipMap(data)
 
         const metaDuration = extractMetaDuration(data)
-        const resolvedDuration =
+        const resolvedDuration = metaDuration > 0 ? metaDuration : 0
-          metaDuration > 0
-            ? metaDuration
-            : duration
 
         const shouldMapPreviewAi =
           Boolean(shouldMapAiPreviewTimes(ai, clipMap, resolvedDuration) && clipMap)
@@ -997,7 +994,7 @@ export default function VideoSplitModal({
     return () => {
       cancelled = true
     }
-  }, [open, job?.id, job?.output, duration])
+  }, [open, job?.id, job?.output])
 
   const effectiveDuration = mediaDuration > 0 ? mediaDuration : duration