fix(transcode): "Abbrechen" wirkt sofort statt erst beim naechsten Prozent

Fund des Commanders am laufenden Akira-Job (Nachtrag im vorigen Savepoint): Job stand auf 'canceling', HandBrake lief weiter. Gemessen 3,4 Minuten zwischen Anforderung (18:30:17) und Bestaetigung (18:33:38) - bei langsamerem Fortschritt entsprechend mehr. Ursache genau wie dort beschrieben: Der Abbruch wurde nur in datei_fortschritt geprueft, und diese Closure stieg oben sofort wieder aus, wenn sich die Prozentzahl nicht geaendert hatte ("if gesamt == letzter[0]: return"). Bei einem Prozent je halber Stunde hing der Abbruch also an einem Ereignis, das eine halbe Stunde lang nicht eintrat. run_handbrake bekommt jetzt einen eigenen abbruch_cb neben progress_cb - dasselbe Muster, das run_makemkv schon fuer log_cb benutzt, und aus demselben Grund: der Fortschritts-Kanal verwirft Aufrufe. Er wird bei JEDER Ausgabezeile aufgerufen und im Worker auf 5 s gedrosselt. Nebeneffekt, der genauso wichtig ist: Er greift auch waehrend des Scan-Durchlaufs, der ueberhaupt keine Encode-Prozente liefert. Dort war ein Abbruch vorher grundsaetzlich unmoeglich - und seit die Prozent-Regex den Scan korrekt ignoriert, waere das sonst sogar schlimmer geworden. Die Leseschleife ist als _handbrake_schleife() herausgezogen, damit die Reihenfolge (Abbruch VOR Fortschritt) ohne echtes HandBrake pruefbar ist. Der Test belegt: zwei Scan-Zeilen genuegen fuer den Abbruch, es muss NICHT auf eine Encode-Zeile gewartet werden. Savepoint nachgezogen: Der Encode laeuft nicht mehr, ein Deploy ist gefahrlos moeglich, und die alte "SOFORT ENTSCHEIDEN"-Passage (Platte laeuft voll, wenn der Job fertig wird) ist damit gegenstandslos. Neu darin: die drei Wege fuer UHD, und die Warnung, dass eine /proc-Suche nach "HandBrake" die eigene Shell mittrifft - zwei Fehlalarme in dieser Sitzung. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
docs(savepoint): v3.14 - Durchsicht, mit den zwei eigenen Fehlschluessen
2026-07-25 21:10:03 +02:00 · 2026-07-25 21:05:38 +02:00 · 2026-07-25 21:05:11 +02:00 · 2026-07-25 21:04:42 +02:00 · 2026-07-25 21:04:19 +02:00
21 changed files with 1516 additions and 161 deletions
@@ -66,4 +66,21 @@ Bibliotheks-APIs: `--help`/Doku prüfen und die Fundstelle im Commit nennen.
 - ✅ **Etappe 18 (v3.11):** 4K-UHD gelöst — `makemkvcon` holt Schlüssel
  unter Linux nie, unter Windows schon; Schlüsselspeicher übernehmbar.
  Akira-UHD geht auf der VM auf (`TCOUNT:5`, bewiesen)
 - ✅ **Etappe 19 (v3.14):** Durchsicht Frontend/Backend — vier Placebos weg
  (Fortschritt log, Auswurf tat nichts, „Alle Tracks" konnte nichts, Encoder
  wurden behauptet statt gemessen), Zombie-Erkennung gebaut, Pfad-Prüfung
  gehärtet, und der Platten-Schutz aus `c065967` als **unwirksam** entlarvt
 - 📝 **Details immer in SAVEPOINT.md** — diese Sektion nennt nur die Etappe
 ## Was diese Sitzungen wiederholt gekostet hat
 **Nicht aus einem Zustandswert auf einen Mechanismus schließen.** Vorgefallen:
 aus „kein Schlüssel da" → „Server abgeschaltet" (falsch), aus Status
 `transcoding` → „Celery hat neu zugestellt" (falsch), aus `progress=99` →
 „Altwert aus dem Absturz" (falsch — ein Bug), aus gleichem `st_dev` →
 „`os.rename` funktioniert" (falsch — der Kernel vergleicht den Mount).
 Jedes Mal hätte eine Messung von unter einer Minute gereicht.
 **Und die Umkehrung gilt genauso:** gleiches `st_dev` heißt NICHT gleicher
 Mount. Wo eine Eigenschaft ausprobierbar ist, probiere sie aus, statt sie
 vorherzusagen.
@@ -1,6 +1,199 @@
 # SAVEPOINT — Rippy
-## Aktueller Stand: v3.13 — ÜBERGABE (25.07.2026, 18:05)
+## Aktueller Stand: v3.14 — Durchsicht: vier Placebos und ein unwirksamer Schutz (25.07.2026, 18:40)
 > Alles unten ist committet, die Ampel ist grün, **nichts ist deployt**.
 > Der Akira-Encode wurde parallel zu dieser Sitzung um 18:31 abgebrochen
 > (siehe Nachtrag im Block darunter) — **es läuft jetzt nichts mehr, ein
 > Deploy ist gefahrlos möglich.** Zuerst lesen: „SOFORT ENTSCHEIDEN" unten.
 ### DER WICHTIGSTE FUND: der Platten-Schutz aus `c065967` greift nicht
 `_original_aufheben()` entschied per `os.stat().st_dev`, ob umgehängt oder
 kopiert werden muss. Auf der VM gemessen — **beides gleichzeitig wahr**:
 ```
 st_dev /app/temp  = 2050
 st_dev /app/media = 2050        → identisch
 os.rename(...)    → EXDEV, "Invalid cross-device link"
 ```
 Der Kernel vergleicht bei `rename()` den **Mount**, nicht das Gerät.
 `/app/temp` (Docker-Volume) und `/app/media` (Bind-Mount) sind zwei Mounts
 DERSELBEN ext4-Partition. Die Prüfung sah deshalb „gleiches Dateisystem",
 **übersprang die Platzprüfung**, und `shutil.move` kopierte doch — 75 GB bei
 37 GB frei. Der Schutz hätte genau den Schaden zugelassen, gegen den er
 gebaut wurde.
 **Behoben:** `os.rename` wird jetzt VERSUCHT statt vorhergesagt. Klappt es,
 ist es umgehängt. Kommt EXDEV, steht die Kopie fest — und erst dann wird der
 Platz geprüft. Vier Tests dazu (`test_original_aufheben.py`), inklusive des
 Falls, der die Platte füllte.
 ### GEMESSEN, Stand 18:30 (alles per Befehl auf der VM geprüft)
 - **Container:** alle 5 `Up`, api/postgres/redis `healthy`. api/ui/worker seit
  18:00:39 (Deploy von `8bb075c`), postgres/redis älter.
 - **Platte:** 148 G, 105 G belegt, 37 G frei = 75 G Rohschnitt + 4,9 G Medien
  (Evangelion) + ~25 G System. **Keine Kopier-Reste**, kein `original`-Ordner.
 - **Akira-Job:** `failed`, „Abgebrochen durch Nutzer" (Abbruch 18:30:17
  angefordert, Worker bestätigt 18:33:38 → **3,4 Minuten Verzug**, siehe unten).
  Es läuft **kein** HandBrake mehr (per `/proc` geprüft, Stand 19:06).
 - **Der Encode war bei 1,44 %**, gemessen an der Leseposition im Quellstrom
  (`/proc/<pid>/fdinfo/3`: 1.145.940.149 von 79.604.951.639 Bytes) — exakter
  als jede Fortschrittsanzeige. Zwei Tempo-Fenster ergaben 395 und 784 KB/s
  → **28–55 h** für den Film, bei 3,84 von 4 gesättigten Kernen.
 - **Achtung bei Prozess-Suchen per `/proc`:** Ein `case "$c" in *HandBrake*)`
  trifft die eigene Shell mit, weil deren Kommandozeile das Wort enthält. Zwei
  Fehlalarme in dieser Sitzung. Immer die PID gegenprüfen.
 - **Die Ursache dafür ist neu und behebbar:** Die VM läuft auf dem generischen
  QEMU-CPU-Modell (`QEMU Virtual CPU version 2.5+`), `grep -c avx2
  /proc/cpuinfo` = **0**, nur bis `sse4_2`. x265 lebt von AVX2. Abhilfe:
  CPU-Typ von VM 106 in Proxmox auf `host` stellen (braucht VM-Neustart).
 - **HandBrake im Worker-Image kann:** `svt_av1`, `x264`, `x265` (je 10/12-bit),
  `mpeg4/2`, `VP8/9`, `theora` — und **keinen einzigen Hardware-Encoder**.
 - **Ampel grün** für `b526a0a` und `8bb075c` (Gitea-API abgefragt).
 ### GEBAUT — vier Placebos entfernt bzw. echt gemacht
 1. **Fortschritt log statt Wahrheit.** `get_progress_from_line` matchte jede
   Zahl vor einem `%` — also auch HandBrakes **Scan-Durchlauf**, der VOR dem
   Encodieren bis 100 % hochläuft. Dazu warf `if progress > 0` alle echten
   Werte unter 1,00 % weg. Ergebnis: Anzeige klebte stundenlang auf 99 %.
   Jetzt wird nur die `Encoding:`-Zeile gelesen, `task N of M` mitgerechnet,
   und **-1 heißt „keine Angabe"** (Muster von `get_progress_from_prgv`).
   Formatstrings aus dem Binary gelesen, nicht geraten.
   **⚠️ Richtigstellung zu v3.13:** Dort steht, `progress=99` sei ein „Altwert
   aus dem Absturz". Falsch — beide Startpfade setzen auf 0, der Wert war
   frisch vom Scan-Durchlauf geschrieben. Es war ein Bug, kein Überrest.
 2. **„Automatischer Auswurf" tat nichts.** Die Einstellung (Standard: ein)
   wurde von niemandem gelesen: DVD/Blu-ray warfen **nie** aus, Audio-CDs
   **immer**, weil abcde `-x` fest verdrahtet bekam. Jetzt entscheidet die
   Einstellung beides (`wirf_disc_aus()` per CDROMEJECT-ioctl, Linux-guarded).
 3. **„Alle Tracks rippen" konnte nichts bewirken** — abcde bekommt keine
   Track-Auswahl und es gibt keine Oberfläche dafür. Schalter entfernt, an
   seiner Stelle steht jetzt die Wahrheit („wird immer vollständig gerippt").
 4. **Encoder-Auslese behauptete statt zu messen.** `cpu-x264`/`cpu-x265`
   standen fest verdrahtet drin („immer dabei") — ein Rip-Worker **ohne**
   HandBrake behauptete damit, komprimieren zu können. Und `vaapi` wurde
   allein wegen `/dev/dri` gemeldet, ohne zu prüfen, ob HandBrake das kann
   (dieses Image kann es nicht). Jetzt aus `HandBrakeCLI --help` geparst, plus
   **CPU-Modell, Kernzahl und Vektorbefehlsstufe** je Worker — mit sichtbarer
   Warnung im UI, wenn AVX2 fehlt. Genau die Angabe, deren Fehlen den
   55-Stunden-Encode unsichtbar machte.
 ### GEBAUT — Zombie-Erkennung (v3.13 Punkt 2 abgearbeitet)
 `zombies.py`: Beim Worker-Start werden Jobs, die auf `ripping`/`transcoding`/
 `canceling` stehen, gegen Celerys `active`/`reserved`/`scheduled` gehalten und
 ehrlich auf `failed` gesetzt, wenn niemand daran arbeitet. Drei Sicherungen,
 weil ein falsch getöteter Job teurer ist als eine stehende Leiche:
 - **nur beim Start** (da ist „es lief nichts" eindeutig),
 - **120 s Gnadenfrist** (Celery stellt unbestätigte Aufgaben erneut zu),
 - **Vollzähligkeit**: antworten weniger Knoten als laut Herzschlag online
  sind, wird NICHTS gewertet — sonst wäre der laufende Job eines
  beschäftigten Remote-Workers eine falsche Leiche.
 13 Tests, unter anderem: „laufender Job wird nicht angetastet" und
 „schweigender Worker verhindert jedes Urteil".
 ### GEBAUT — Pfad-Prüfung gehärtet
 Elf Stellen prüften mit nacktem `startswith(MEDIA_ROOT)`. `/app/media-boese/x`
 beginnt mit `/app/media`, liegt aber außerhalb — betroffen waren auch `/browse`
 und `/browse/mkdir`, wo der Pfad vom Nutzer kommt. Neuer Zwillings-Helfer
 `unter_wurzel()` in `api/main.py` und `worker/tasks.py`, alle elf Stellen
 umgestellt, Tests in beiden.
 Nebenbefund dabei: `_zielbasis()` benutzte `os.path.normpath` — unter Windows
 werden daraus Backslashes und die Prüfung greift nicht mehr; das gewählte Ziel
 wäre still auf den Standard zurückgefallen. Genau die Falle, die
 `_arbeitsverzeichnis()` drei Zeilen weiter dokumentiert und mit `posixpath`
 vermeidet. Live war es nie (nur aus `rip_disc`, das auf Windows verriegelt
 ist), jetzt konsistent.
 ### GEFUNDEN, NICHT ANGETASTET — vier tote Endpunkte
 Nirgends im UI referenziert (mechanisch gegengeprüft: alle `api.*`-Aufrufe
 gegen alle Routen):
 | Endpunkt | Lage |
 |---|---|
 | `POST /jellyfin/format` | ersetzt durch `medien.py` im Worker; zieht `nfo_generator.py` + `image_downloader.py` in der API mit, die sonst niemand nutzt |
 | `POST /prescan` | ohne Aufrufer (die `PreScan`-Klasse selbst wird woanders sehr wohl gebraucht) |
 | `GET /stream/jobs` | niemand konsumiert ihn; der Kommentar behauptet einen „Fix 23.07.", der ihn funktionsfähig machte — gebraucht wird er trotzdem nicht |
 | `GET /worker-setup/windows-gui` | seit der `.exe` (v3.9) unreferenziert |
 Bewusst nicht entfernt: `test_api_smoke.py` prüft `/prescan` als verdrahtete
 Route, und Entfernen ist eine Entscheidung, keine Reparatur. **Der Commander
 entscheidet.**
 ### NOCH OFFEN / EHRLICH UNGEKLÄRT
 - **Was die Platte am 25.07. mittags füllte, ist nicht belegt.** Es gibt keine
  Kopier-Reste, kein `original`-Verzeichnis und **keinen einzigen Log-Eintrag
  von `_original_aufheben`** — das loggt in beiden Zweigen. Zwischen 10:21:50
  und 17:49 steht überhaupt nichts im Log. Der EXDEV-Mechanismus ist jetzt
  belegt (siehe oben), dass er DAMALS zuschlug, ist es nicht.
 - **`tracks:/dev/sr0` meldet `{"status":"done","tracks":[]}`** — null Titel für
  eine Disc, die MakeMKV mit `TCOUNT:5` öffnet. Nicht weiter verfolgt.
 - **Der Discord-Webhook und der MakeMKV-Key liegen im Klartext** in der
  settings-Tabelle. Für Heimnetz erwartbar, aber der Webhook ist eine echte
  Zugangsberechtigung.
 - **Zwei neue API-Tests laufen nur in der Ampel** — `test_api_smoke.py`
  überspringt sich unter Windows selbst (`main.py` braucht `fcntl`).
 ### GEBAUT — „Abbrechen" wirkt jetzt sofort
 Der Fund aus dem Nachtrag (Commander, am laufenden Job beobachtet) ist behoben.
 Ursache war genau wie dort beschrieben: Der Abbruch wurde nur in
 `datei_fortschritt` geprüft, und diese Closure stieg oben sofort wieder aus,
 wenn sich die Prozentzahl nicht geändert hatte. Bei einem Prozent je halber
 Stunde sah „Abbrechen" entsprechend lange wirkungslos aus.
 Jetzt gibt es in `run_handbrake` einen **eigenen Abbruch-Kanal** neben dem
 Fortschritts-Callback — dasselbe Muster, das `run_makemkv` schon für `log_cb`
 benutzt, und aus demselben Grund. Er wird bei JEDER Ausgabezeile aufgerufen
 und ist im Worker auf 5 Sekunden gedrosselt (`ABBRUCH_INTERVALL_SEKUNDEN`).
 Nebeneffekt: Er greift auch während des Scan-Durchlaufs, der überhaupt keine
 Encode-Prozente liefert — dort war ein Abbruch vorher grundsätzlich unmöglich.
 Die Leseschleife ist als `_handbrake_schleife()` herausgezogen, damit die
 Reihenfolge (Abbruch VOR Fortschritt) ohne echtes HandBrake testbar ist.
 ### SOFORT ENTSCHEIDEN
 **1. Deployen — es läuft nichts, der Weg ist frei.** Nichts blockiert mehr, und
 solange nicht deployt ist, gilt weiterhin der alte Code: unwirksamer
 Platten-Schutz, Anzeige auf 99 %, Auswurf ohne Wirkung, träges „Abbrechen".
 ```
 ssh arcane@192.168.178.162 'cd ~/projects/rippy && git pull --ff-only && docker compose up -d --build'
 ```
 **2. Die UHD-Strategie ist noch offen** (aus dem Nachtrag, unverändert gültig).
 Preset-je-Disc-Typ war richtig, reicht aber nicht: Software-HEVC in 4K ist auf
 dieser CPU keine Option. Drei Wege, keiner davon gebaut:
 - **UHD gar nicht komprimieren** — Roh-MKV behalten. Ehrlichste Variante,
  kostet Platz (75–100 GB je Film, gehört dann auf die NAS).
 - **Hardware-Encoder** — Remote-Worker mit GPU (`nvenc`/`vaapi`). Rippy kann
  das schon routen (bewiesen v3.7); es fehlt die Maschine. Achtung: Das
  Worker-Image kann selbst keinen Hardware-Encoder, ein GPU-Worker braucht ein
  HandBrake-Build mit `nvenc_*`/`qsv_*` — die neue Anzeige sagt das jetzt.
 - **CPU-Typ der VM auf `host`** — schaltet AVX2 frei, bringt bei x265 typisch
  Faktor 2–4. Aus 28–55 h werden damit aber immer noch Stunden bis Tage; das
  allein löst 4K nicht, hilft aber jedem 1080p-Encode.
 **3. Vier tote Endpunkte** — entfernen oder behalten (Tabelle oben).
 **4. Im Akira-Ordner liegt ein unbrauchbares 4K-Fragment** (die 1080p-Fassung
 wurde beim Start auf 0 Bytes gekürzt). Der 75-GB-Rohschnitt ist unversehrt,
 also ist nichts verloren — aber die Datei gehört weg, bevor jemand sie für ein
 Ergebnis hält.
 ---
 ## Vorheriger Stand: v3.13 — ÜBERGABE (25.07.2026, 18:05)
 > Dieser Block ist eine Übergabe an die nächste Sitzung. Er trennt bewusst
 > **gemessen** von **vermutet** — in dieser Sitzung wurden zwei Behauptungen
@@ -155,7 +155,7 @@ async def _auto_rip_wenn_aktiviert(pfad: str):
    else:
        unterordner = einstellungen.get("movieDir") or "movies"
    ziel = os.path.normpath(os.path.join(basis, unterordner))
-    if not ziel.startswith(MEDIA_ROOT):
+    if not unter_wurzel(ziel, MEDIA_ROOT):
        ziel = None
    job_id = str(uuid.uuid4())
@@ -308,7 +308,7 @@ def _kann_neu_komprimieren(job: dict, work_dir: str) -> bool:
        return False
    if os.path.isdir(os.path.join("/app/temp/raw", job["id"])):
        return True
-    return work_dir.startswith(MEDIA_ROOT) and os.path.isdir(os.path.join(work_dir, job["id"]))
+    return unter_wurzel(work_dir, MEDIA_ROOT) and os.path.isdir(os.path.join(work_dir, job["id"]))
@app.get("/jobs", response_model=List[Job])
@@ -373,7 +373,7 @@ def _validiere_ziel(target_dir: Optional[str]) -> Optional[str]:
    if not target_dir:
        return None
    normalisiert = os.path.normpath(target_dir)
-    if not normalisiert.startswith(MEDIA_ROOT):
+    if not unter_wurzel(normalisiert, MEDIA_ROOT):
        raise HTTPException(
            status_code=422,
            detail=f"Ziel muss unter {MEDIA_ROOT} liegen (Shares dort einhängen)",
@@ -462,10 +462,24 @@ def _sicherer_dateiname(name: str) -> bool:
    return bool(name) and "/" not in name and "\\" not in name and not name.startswith(".")
 def unter_wurzel(pfad: str, wurzel: str) -> bool:
    """Liegt `pfad` wirklich unterhalb von `wurzel` (oder IST es die Wurzel)?
    Pure Funktion, testbar. Ein nacktes `startswith()` genügt hier nicht:
    „/app/media-boese/x" beginnt mit „/app/media", liegt aber ausserhalb
    (Befund 25.07.2026 bei der Durchsicht). Deshalb Gleichheit ODER Wurzel
    samt Trennzeichen. Erwartet werden normalisierte Container-Pfade mit „/".
    """
    if not pfad or not wurzel:
        return False
    sauber = wurzel.rstrip("/") or "/"
    return pfad == sauber or pfad.startswith(sauber + "/")
 def _job_ausgabeordner(job: dict) -> str:
    """Validierter Ausgabeordner eines Jobs — strikt unter /app/media."""
    ausgabe = os.path.normpath(job.get("output_path") or "")
-    if not ausgabe.startswith(MEDIA_ROOT):
+    if not unter_wurzel(ausgabe, MEDIA_ROOT):
        raise HTTPException(status_code=404, detail="Job hat keinen Ausgabeordner unter /app/media")
    return ausgabe
@@ -522,7 +536,7 @@ async def download_job_file(job_id: str, dateiname: str):
    pfad = os.path.join(ausgabe, dateiname)
    def pruefe():
-        return os.path.isfile(pfad) and os.path.realpath(pfad).startswith(MEDIA_ROOT)
+        return os.path.isfile(pfad) and unter_wurzel(os.path.realpath(pfad), MEDIA_ROOT)
    if not await asyncio.to_thread(pruefe):
        raise HTTPException(status_code=404, detail="Datei nicht gefunden")
@@ -633,7 +647,7 @@ async def retry_transcode(job_id: str):
    # (Einstellungen → Verarbeitung), sonst Container-Default /app/temp/raw.
    einstellungen = await asyncio.to_thread(db.get_settings)
    work_dir = os.path.normpath((einstellungen.get("workDir") or "").strip() or "/")
-    raw_basis = work_dir if work_dir.startswith(MEDIA_ROOT) else "/app/temp/raw"
+    raw_basis = work_dir if unter_wurzel(work_dir, MEDIA_ROOT) else "/app/temp/raw"
    raw_dir = f"{raw_basis}/{job_id}"
    # Zielordner: der Worker schreibt das geplante Ziel beim Rip-Start nach
    # output_path (sprechender Name statt UUID) — alter Fallback bleibt.
@@ -988,7 +1002,7 @@ async def delete_storage_mount(name: str):
 async def browse(path: str = MEDIA_ROOT):
    """Server-seitiger Ordner-Browser für die Ziel-Auswahl (nur unter /app/media)."""
    normalisiert = os.path.normpath(path)
-    if not normalisiert.startswith(MEDIA_ROOT):
+    if not unter_wurzel(normalisiert, MEDIA_ROOT):
        raise HTTPException(status_code=422, detail=f"Nur Pfade unter {MEDIA_ROOT}")
    def liste():
@@ -1029,7 +1043,7 @@ class MkdirRequest(BaseModel):
 async def browse_mkdir(request: MkdirRequest):
    """Neuen Ordner unter /app/media anlegen (Speicherziele-Verwaltung)."""
    basis = os.path.normpath(request.path)
-    if not basis.startswith(MEDIA_ROOT):
+    if not unter_wurzel(basis, MEDIA_ROOT):
        raise HTTPException(status_code=422, detail=f"Nur Pfade unter {MEDIA_ROOT}")
    name = request.name.strip()
    if not name or "/" in name or "\\" in name or name.startswith("."):
@@ -1388,7 +1402,7 @@ async def download_aacs_dump(dateiname: str):
    pfad = os.path.join(MAKEMKV_DATA_ROOT, dateiname)
    def pruefe():
-        return os.path.isfile(pfad) and os.path.realpath(pfad).startswith(MAKEMKV_DATA_ROOT)
+        return os.path.isfile(pfad) and unter_wurzel(os.path.realpath(pfad), MAKEMKV_DATA_ROOT)
    if not await asyncio.to_thread(pruefe):
        raise HTTPException(
@@ -66,3 +66,31 @@ def test_remount_blockiert_den_api_start_nicht():
        "remount muss als Hintergrund-Task laufen (nicht blockierend)"
    assert "await asyncio.to_thread(remount)" not in quelle, \
        "remount darf nicht mehr direkt awaited werden (blockiert sonst den Start)"
 def test_unter_wurzel_faellt_nicht_auf_praefix_namen_herein():
    """Befund 25.07.2026: In main.py prueften neun Stellen mit nacktem
    startswith(MEDIA_ROOT) — darunter /browse und /browse/mkdir, wo der Pfad
    vom Nutzer kommt. „/app/media-boese/x" beginnt mit „/app/media", liegt
    aber ausserhalb. Zwilling von tasks.unter_wurzel im Worker."""
    from main import unter_wurzel
    assert unter_wurzel("/app/media", "/app/media") is True
    assert unter_wurzel("/app/media/movies", "/app/media") is True
    assert unter_wurzel("/app/media-boese/x", "/app/media") is False
    assert unter_wurzel("/app/mediaX", "/app/media") is False
    assert unter_wurzel("/etc/passwd", "/app/media") is False
    assert unter_wurzel("", "/app/media") is False
    assert unter_wurzel("/app/media", "") is False
    assert unter_wurzel("/app/media/movies", "/app/media/") is True
 def test_sicherer_dateiname_blockt_pfad_tricks():
    from main import _sicherer_dateiname
    assert _sicherer_dateiname("film.mkv") is True
    assert _sicherer_dateiname("../../etc/passwd") is False
    assert _sicherer_dateiname("a/b.mkv") is False
    assert _sicherer_dateiname("a\b.mkv") is False
    assert _sicherer_dateiname(".versteckt") is False
    assert _sicherer_dateiname("") is False
@@ -14,6 +14,7 @@ interface WorkerInfo {
 const ENCODER_LABELS: Record<string, string> = {
  'cpu-x264': 'CPU · H.264 (x264)',
  'cpu-x265': 'CPU · H.265 (x265)',
  'cpu-av1': 'CPU · AV1 (SVT-AV1)',
  'vaapi': 'Hardware · VAAPI (AMD/Intel)',
  'nvenc': 'Hardware · NVENC (NVIDIA)',
 }
@@ -38,7 +38,8 @@ interface WorkerWahl {
 }
 const ENCODER_KURZ: Record<string, string> = {
-  'cpu-x264': 'H.264', 'cpu-x265': 'H.265', 'vaapi': 'VAAPI⚡', 'nvenc': 'NVENC⚡',
+  'cpu-x264': 'H.264', 'cpu-x265': 'H.265', 'cpu-av1': 'AV1',
  'vaapi': 'VAAPI⚡', 'nvenc': 'NVENC⚡',
 }
 interface TitelInfo {
@@ -1,6 +1,7 @@
 import { useState, useEffect } from 'react'
 import { Server, RefreshCw, Copy, CheckCircle, Trash2, Download } from 'lucide-react'
 import { api } from '../lib/api'
 import { simdWarnung } from '../lib/encoder'
 import { useToast } from '../context/ToastContext'
 import { Card, CardHeader, CardTitle, CardContent } from './ui/Card'
 import { Button } from './ui/Button'
@@ -16,16 +17,22 @@ interface WorkerInfo {
    ip?: string
    makemkv?: string
    handbrake?: string
    cpu_modell?: string
    cpu_kerne?: string
    cpu_simd?: string
    handbrake_encoder?: string
  }
 }
 const ENCODER_LABELS: Record<string, string> = {
  'cpu-x264': 'CPU · H.264',
  'cpu-x265': 'CPU · H.265',
  'cpu-av1': 'CPU · AV1 (SVT)',
  'vaapi': 'GPU · VAAPI (AMD/Intel)',
  'nvenc': 'GPU · NVENC (NVIDIA)',
 }
 function relativeZeit(iso?: string): string {
  if (!iso) return 'nie'
  const sekunden = Math.floor((Date.now() - new Date(iso).getTime()) / 1000)
@@ -134,6 +141,18 @@ export default function WorkerVerwaltung() {
                        {w.info?.ip ? ` · IP ${w.info.ip}` : ''}
                        {w.info?.hostname && w.info.hostname !== w.name ? ` · ID ${w.info.hostname}` : ''}
                      </p>
                      {(w.info?.cpu_kerne || w.info?.cpu_simd) && (
                        <p className="text-xs text-slate-500 dark:text-slate-400" title={w.info?.cpu_modell || ''}>
                          {w.info?.cpu_kerne ? `${w.info.cpu_kerne} Kerne` : ''}
                          {w.info?.cpu_kerne && w.info?.cpu_simd ? ' · ' : ''}
                          {w.info?.cpu_simd ? `Vektorbefehle ${w.info.cpu_simd}` : ''}
                        </p>
                      )}
                      {simdWarnung(w.info?.cpu_simd) && (
                        <p className="mt-1 text-xs text-amber-600 dark:text-amber-400 max-w-xl">
                          {simdWarnung(w.info?.cpu_simd)}
                        </p>
                      )}
                    </div>
                  </div>
                  <div className="flex items-center gap-2">
@@ -80,6 +80,7 @@ export const LOG_LEVEL_STYLES = {
 export const ENCODER_BADGES: Record<string, { label: string; highlight: boolean }> = {
  'cpu-x264': { label: 'H.264 (CPU)', highlight: false },
  'cpu-x265': { label: 'H.265 (CPU)', highlight: false },
  'cpu-av1': { label: 'AV1 (CPU)', highlight: false },
  'vaapi': { label: 'VAAPI ⚡', highlight: true },
  'nvenc': { label: 'NVENC ⚡', highlight: true },
 }
@@ -0,0 +1,24 @@
 // Encoder-Fähigkeiten eines Workers in Klartext übersetzen.
 //
 // Befund 25.07.2026: Die Rippy-VM lief auf dem generischen QEMU-CPU-Modell
 // („QEMU Virtual CPU version 2.5+") und hatte deshalb kein AVX2, nur sse4_2.
 // x265 lebt von diesen Vektorbefehlen — ein 4K-Encode brauchte dort gemessene
 // 28-55 Stunden, und nirgends im UI war das zu sehen. Der Worker meldet die
 // Angaben seit dieser Runde selbst (worker/caps.py), hier werden sie gedeutet.
 // Stufen, mit denen Software-Encoding brauchbar schnell ist.
 export const SIMD_SCHNELL = ['avx512f', 'avx2']
 /**
 * Warnt, wenn die CPU dieses Workers zu schwach für Software-Encoding ist.
 * Gibt null zurück, wenn alles in Ordnung ist ODER die Stufe unbekannt ist —
 * lieber nichts sagen als etwas Falsches behaupten.
 */
 export function simdWarnung(simd?: string): string | null {
  if (!simd || simd === 'unbekannt') return null
  if (SIMD_SCHNELL.includes(simd)) return null
  return `Diese CPU kann nur ${simd} (kein AVX2) — Software-Encoding ist hier `
    + 'sehr langsam. Bei einer virtuellen Maschine hilft es meist, den '
    + 'CPU-Typ auf "host" zu stellen; sonst besser einen Worker mit '
    + 'Hardware-Encoder wählen.'
 }
@@ -10,6 +10,7 @@ import { Button } from '../components/ui/Button'
 import { Input, Select, Toggle } from '../components/ui/Input'
 import { MEDIA_SERVER_OPTIONEN } from '../lib/mediaServer'
 import { ENCODER_BADGES } from '../lib/design'
 import { simdWarnung } from '../lib/encoder'
 interface SettingsState {
  tmdbApiKey: string
@@ -19,7 +20,6 @@ interface SettingsState {
  movieDir: string
  seriesDir: string
  musicDir: string
  ripAllTracks: boolean
  mainFeatureOnly: boolean
  autoEject: boolean
  autoRipStart: boolean
@@ -48,7 +48,6 @@ const defaultSettings: SettingsState = {
  movieDir: 'movies',
  seriesDir: 'series',
  musicDir: 'music',
  ripAllTracks: true,
  mainFeatureOnly: false,
  autoEject: true,
  autoRipStart: false,
@@ -74,7 +73,15 @@ interface WorkerInfo {
  // keydb: "ja" | "nein" | "unbekannt" — sagt, ob DIESER Worker eine KEYDB.cfg
  // in seinem MakeMKV-Datenverzeichnis sieht. Nur der Worker, der wirklich
  // rippt, zaehlt, deshalb steht die Angabe pro Worker und nicht global.
-  info?: { makemkv?: string, handbrake?: string, makemkv_key?: string, keydb?: string }
+  // cpu_kerne/cpu_simd: Rechenleistung fuers Software-Encodieren. Ohne diese
  // Angaben war am 25.07.2026 nicht zu sehen, dass ein 4K-Encode auf der
  // Rippy-VM Tage statt Stunden braucht (kein AVX2, 4 Kerne).
  // handbrake_encoder: die ungefilterte Encoder-Auskunft von HandBrake selbst.
  info?: {
    makemkv?: string, handbrake?: string, makemkv_key?: string, keydb?: string,
    cpu_modell?: string, cpu_kerne?: string, cpu_simd?: string,
    handbrake_encoder?: string,
  }
 }
 // Antwort von GET/POST/DELETE /system/keydb (Feldnamen exakt wie die API sie liefert).
@@ -427,14 +434,16 @@ export default function SettingsPage() {
                  🎵 Audio-CD
                </p>
-                <div className="p-4 rounded-xl border border-slate-200/80 dark:border-slate-800 bg-slate-50/50 dark:bg-slate-950/80">
+                {/* Der Schalter „Alle Tracks rippen" ist am 25.07.2026 entfallen.
-                  <Toggle
+                    Er war ein Placebo: abcde bekommt keine Track-Auswahl (siehe
-                    label="Alle Tracks rippen"
+                    build_abcde_cmd) und es gibt auch keine Oberflaeche, um eine
-                    description="Rippe alle Tracks einer CD (FLAC + MusicBrainz-Tags)."
+                    Teilmenge zu waehlen — eine Audio-CD wurde also immer
-                    checked={settings.ripAllTracks}
+                    vollstaendig gerippt, egal wie der Schalter stand. Statt einer
-                    onChange={(v) => handleChange('ripAllTracks', v)}
+                    Wahl, die nichts bewirkt, steht hier jetzt die Wahrheit. */}
-                  />
+                <p className="text-xs text-slate-500 dark:text-slate-400 px-1">
-                </div>
+                  💿 Eine Audio-CD wird immer vollständig gerippt — alle Tracks als
                  FLAC, mit MusicBrainz-Tags.
                </p>
                <p className="text-xs font-bold uppercase tracking-wider pt-2 text-slate-400 dark:text-slate-500">
                  Allgemein
@@ -555,6 +564,24 @@ export default function SettingsPage() {
                          {ENCODER_BADGES[e]?.label || e}
                        </span>
                      ))}
                      {(w.info?.cpu_kerne || w.info?.cpu_simd) && (
                        <p className="mt-1 text-xs text-slate-500 dark:text-slate-400" title={w.info?.cpu_modell || ''}>
                          {w.info?.cpu_modell ? `${w.info.cpu_modell} · ` : ''}
                          {w.info?.cpu_kerne ? `${w.info.cpu_kerne} Kerne` : ''}
                          {w.info?.cpu_kerne && w.info?.cpu_simd ? ' · ' : ''}
                          {w.info?.cpu_simd ? `Vektorbefehle ${w.info.cpu_simd}` : ''}
                        </p>
                      )}
                      {simdWarnung(w.info?.cpu_simd) && (
                        <p className="mt-1 text-xs text-amber-600 dark:text-amber-400">
                          {simdWarnung(w.info?.cpu_simd)}
                        </p>
                      )}
                      {w.info?.handbrake_encoder && (
                        <p className="mt-1 text-xs text-slate-400 dark:text-slate-500 font-mono break-all">
                          HandBrake meldet: {w.info.handbrake_encoder}
                        </p>
                      )}
                    </div>
                  ))
                )}
@@ -6,26 +6,133 @@ Remote-GPU-Worker meldet sich hier genauso wie der eingebaute CPU-Worker.
 """
 import os
 import platform
 import re
 import shutil
 import subprocess
-def erkenne_encoder() -> list:
+HB_ENCODER_KOPF = re.compile(r"^-e,\s*--encoder\b")
    """Liste der verfügbaren Encoder-Backends auf dieser Maschine."""
    gefunden = ["cpu-x264", "cpu-x265"]  # HandBrake-Software-Encoder, immer dabei
-    # VAAPI: AMD (VCN) und Intel (QuickSync) melden sich über /dev/dri
+# Reihenfolge = Anzeige-Reihenfolge im UI.
-    if os.path.exists("/dev/dri/renderD128"):
+SIMD_STUFEN = ("avx512f", "avx2", "avx", "sse4_2")
 def parse_encoder_liste(hilfe_text: str) -> list:
    """Video-Encoder, die DIESES HandBrake wirklich anbietet.
    Quelle: `HandBrakeCLI --help`, Abschnitt `-e, --encoder <string>`
    (AGENTS Regel D — im Worker-Image am 25.07.2026 gemessen, nicht geraten):
        -e, --encoder <string>  Select video encoder:
                                    svt_av1
                                    x264
                                    x265
                                    ...
           --encoder-preset <string>
    Der Block endet an der nächsten Option — also an der ersten Zeile, deren
    erstes nicht-leeres Zeichen ein Bindestrich ist.
    """
    encoder = []
    im_block = False
    for zeile in (hilfe_text or "").splitlines():
        inhalt = zeile.strip()
        if not im_block:
            if HB_ENCODER_KOPF.match(inhalt):
                im_block = True
            continue
        if not inhalt:
            continue
        if inhalt.startswith("-"):
            break
        encoder.append(inhalt.split()[0])
    return encoder
 def leite_backends_ab(hb_encoder, dri_da: bool, nvidia_da: bool) -> list:
    """Übersetzt die HandBrake-Encoder-Namen in die Backends, die das UI zeigt.
    Zwei Ehrlichkeits-Regeln, die vorher fehlten (Befund 25.07.2026):
    * Ohne HandBrake gibt es KEINE Encoder. Vorher standen `cpu-x264` und
      `cpu-x265` fest verdrahtet in der Liste („immer dabei") — ein reiner
      Rip-Worker ohne HandBrake behauptete damit, komprimieren zu können.
    * Hardware zählt nur, wenn das Gerät da ist UND HandBrake den Encoder
      überhaupt kennt. Vorher genügte `/dev/dri` — das Worker-Image kann
      laut eigener Auskunft aber gar keinen Hardware-Encoder.
    """
    namen = {e.lower() for e in (hb_encoder or [])}
    gefunden = []
    if any(n.startswith("x264") for n in namen):
        gefunden.append("cpu-x264")
    if any(n.startswith("x265") for n in namen):
        gefunden.append("cpu-x265")
    if any(n.startswith("svt_av1") for n in namen):
        gefunden.append("cpu-av1")
    if dri_da and any(("qsv" in n) or ("vce" in n) or ("vaapi" in n) for n in namen):
        gefunden.append("vaapi")
-
+    if nvidia_da and any("nvenc" in n for n in namen):
    # NVENC: NVIDIA-Treiber im Container sichtbar
    if shutil.which("nvidia-smi") or os.path.exists("/usr/lib/x86_64-linux-gnu/libnvidia-encode.so.1"):
        gefunden.append("nvenc")
    return gefunden
 def beste_simd(flags_text: str) -> str:
    """Höchste Vektor-Befehlsstufe der CPU — entscheidend fürs Software-Encodieren.
    Befund 25.07.2026: Die Rippy-VM läuft auf dem generischen QEMU-CPU-Modell
    („QEMU Virtual CPU version 2.5+") und hat deshalb KEIN AVX2, nur sse4_2.
    x265 lebt von diesen Befehlen; ein 4K-Encode brauchte dort gemessene
    28-55 Stunden. Sichtbar war das nirgends — genau diese Lücke schließt die
    Anzeige. Abhilfe bei Proxmox/KVM: CPU-Typ der VM auf `host` stellen.
    """
    vorhanden = set((flags_text or "").split())
    for stufe in SIMD_STUFEN:
        if stufe in vorhanden:
            return stufe
    return "unbekannt"
 def _lies_cpuinfo() -> tuple:
    """(Modellname, Flags-Text, Kernzahl) aus /proc/cpuinfo — leer auf Windows."""
    modell, flags, kerne = "", "", 0
    try:
        with open("/proc/cpuinfo", encoding="utf-8", errors="replace") as f:
            for zeile in f:
                if zeile.startswith("processor"):
                    kerne += 1
                elif not modell and zeile.startswith("model name"):
                    modell = zeile.split(":", 1)[-1].strip()
                elif not flags and zeile.startswith("flags"):
                    flags = zeile.split(":", 1)[-1].strip()
    except OSError:
        pass
    return modell, flags, kerne
 def hole_handbrake_hilfe() -> str:
    """`HandBrakeCLI --help` einmal abrufen (leer, wenn nicht installiert)."""
    if not shutil.which("HandBrakeCLI"):
        return ""
    try:
        aus = subprocess.run(
            ["HandBrakeCLI", "--help"], capture_output=True, text=True, timeout=30
        )
        return (aus.stdout or "") + (aus.stderr or "")
    except (OSError, subprocess.TimeoutExpired):
        return ""
 def erkenne_encoder() -> list:
    """Encoder-Backends, die auf DIESER Maschine wirklich nutzbar sind."""
    hb_encoder = parse_encoder_liste(hole_handbrake_hilfe())
    dri_da = os.path.exists("/dev/dri/renderD128")
    nvidia_da = bool(
        shutil.which("nvidia-smi")
        or os.path.exists("/usr/lib/x86_64-linux-gnu/libnvidia-encode.so.1")
    )
    return leite_backends_ab(hb_encoder, dri_da, nvidia_da)
 def erkenne_ip() -> str:
    """Beste erratbare eigene IP (UDP-Route-Trick, KEIN echter Traffic).
@@ -56,11 +163,23 @@ def werkzeug_versionen() -> dict:
    """
    import socket
    modell, flags, kerne = _lies_cpuinfo()
    info = {
        # Zuordnung im UI: hostname (für den Celery-Online-Abgleich) + IP
        "hostname": socket.gethostname(),
        "ip": erkenne_ip(),
        # Rechenleistung fürs Software-Encodieren. Ohne diese drei Angaben war
        # am 25.07.2026 nicht zu sehen, dass ein 4K-Encode auf dieser Maschine
        # Tage statt Stunden braucht (kein AVX2, 4 Kerne).
        "cpu_modell": modell or (platform.processor() or "unbekannt"),
        "cpu_kerne": str(kerne or os.cpu_count() or 0),
        "cpu_simd": beste_simd(flags),
    }
    hb_encoder = parse_encoder_liste(hole_handbrake_hilfe())
    if hb_encoder:
        # Die ungefilterte Auskunft von HandBrake — damit im UI nachprüfbar ist,
        # woher die Backend-Liste kommt.
        info["handbrake_encoder"] = ",".join(hb_encoder)
    if shutil.which("makemkvcon"):
        info["makemkv"] = os.getenv("MAKEMKV_VERSION") or "installiert"
    if shutil.which("HandBrakeCLI"):
@@ -33,6 +33,30 @@ celery_app.conf.update(
 # zuverlässig im sys.path (ModuleNotFoundError 'caps', Deploy 23.07.).
 import caps  # noqa: E402
 import db  # noqa: E402
 import zombies  # noqa: E402
@worker_ready.connect
 def raeume_job_leichen_auf(**kwargs):
    """Nach der Gnadenfrist: Jobs, an denen niemand arbeitet, ehrlich auf
    'failed' setzen (Details und Sicherungen in zombies.py).
    Läuft im Hintergrund-Thread — der Worker soll sofort Aufgaben annehmen und
    nicht zwei Minuten auf die Aufräumung warten.
    """
    import threading
    import time
    def spaeter():
        time.sleep(zombies.GNADENFRIST_SEKUNDEN)
        try:
            db.init_db()
            bericht = zombies.raeume_zombies_auf(celery_app, db)
            print(f"Zombie-Erkennung: {bericht}")
        except Exception as e:  # darf den Worker nie mitnehmen
            print(f"Zombie-Erkennung fehlgeschlagen: {e}")
    threading.Thread(target=spaeter, daemon=True, name="zombie-erkennung").start()
@worker_ready.connect
@@ -181,6 +181,42 @@ def get_job_status(job_id: str) -> str:
    return zeile[0] if zeile else ""
 def list_jobs_mit_status(stati) -> list:
    """Alle Jobs in einem der genannten Zustände (id/status/title/created_at).
    Basis der Zombie-Erkennung: Jobs, die behaupten, es arbeite gerade jemand
    an ihnen. Bewusst NUR diese schmale Auswahl statt der ganzen Zeile — die
    Erkennung braucht nichts weiter.
    """
    from sqlalchemy import select
    with engine.connect() as conn:
        zeilen = conn.execute(
            select(jobs.c.id, jobs.c.status, jobs.c.title, jobs.c.created_at)
            .where(jobs.c.status.in_(list(stati)))
        ).mappings().all()
    return [dict(z) for z in zeilen]
 def zaehle_online_worker(sekunden: int = 120) -> int:
    """Wie viele Worker gelten laut Herzschlag gerade als online?
    Die Zombie-Erkennung vergleicht das mit der Zahl der Celery-Antworten:
    melden sich weniger Worker als bekannt sind, ist die Auskunft
    unvollstaendig — dann wird NICHTS als Leiche gewertet.
    """
    from datetime import timedelta
    from sqlalchemy import func, select
    grenze = utcnow() - timedelta(seconds=sekunden)
    with engine.connect() as conn:
        anzahl = conn.execute(
            select(func.count()).select_from(workers).where(workers.c.last_seen >= grenze)
        ).scalar()
    return int(anzahl or 0)
 def update_job(job_id: str, **fields) -> None:
    with engine.begin() as conn:
        conn.execute(jobs.update().where(jobs.c.id == job_id).values(**fields))
@@ -25,6 +25,36 @@ class RipAbbruch(Exception):
    Nutzer den Job abgebrochen hat (Status 'canceling' in der DB)."""
 # include/uapi/linux/cdrom.h — dasselbe ioctl wie in api/devices.py
 CDROMEJECT = 0x5309
 def wirf_disc_aus(device_path: str) -> bool:
    """Wirft die Disc aus; gibt zurück, ob es geklappt hat. Wirft NIE.
    Befund 25.07.2026: Die Einstellung „Automatischer Auswurf" (Standard: ein,
    Beschreibung „Disc nach erfolgreichem Ripping automatisch auswerfen") wurde
    von niemandem gelesen — bei DVD/Blu-ray warf Rippy nie aus.
    Bewusst hier und nicht in detection.py: das Modul ist ein byteweiser
    Zwilling der API-Kopie. `fcntl` gibt es nur unter Linux — der native
    Windows-Worker lädt ripping.py ebenfalls, rippt dort aber nie.
    """
    try:
        from fcntl import ioctl
    except ImportError:  # Windows
        return False
    try:
        fd = os.open(device_path, os.O_RDONLY | os.O_NONBLOCK)
        try:
            ioctl(fd, CDROMEJECT, 0)
        finally:
            os.close(fd)
        return True
    except OSError:
        return False
 def check_makemkv_installed() -> bool:
    """Prüft, ob makemkvcon installiert ist."""
    return shutil.which("makemkvcon") is not None
@@ -271,20 +301,57 @@ def build_handbrake_cmd(input_path: str, output_path: str, preset: str = DEFAULT
    ]
 HB_ENCODE_RE = re.compile(
    r'^Encoding:\s*task\s+(\d+)\s+of\s+(\d+),\s*(\d+(?:\.\d+)?)\s*%'
 )
 def get_progress_from_line(line: str) -> int:
-    """Extrahiert Fortschritt in Prozent aus HandBrake-Ausgabe.
+    """Extrahiert den ENCODE-Fortschritt in Prozent aus HandBrake-Ausgabe.
-    Testfund 22.07.: echtes HandBrake schreibt „45.50 %" MIT Leerzeichen vor
+    Gibt **-1** zurück, wenn die Zeile kein Encode-Fortschritt ist — genau wie
-    dem Prozentzeichen — eine Regex ohne \\s* parst NIE echte Ausgabe.
+    get_progress_from_prgv. Sonst wäre ein echtes „0 %" nicht von „keine
    Angabe" zu unterscheiden, und der Anfang des Encodes bliebe unsichtbar.
    Formatstrings aus dem HandBrakeCLI-Binary im Worker-Image gelesen
    (AGENTS Regel D — nicht aus dem Kopf):
      Scanning title %d of %d, preview %d, %.2f %%              → Scan, NICHT Encode
      Encoding: task %d of %d, %.2f %%       (%.2f fps, avg     → Encode
      Encoding: task %d of %d, Searching for start time, %.2f   → Vorlauf, NICHT Encode
    Befund 25.07.2026 (Akira-UHD, live gemessen): Die alte Regex nahm JEDE
    Zahl vor einem Prozentzeichen — also auch den Scan-Durchlauf, der VOR dem
    Encodieren einmal bis 100 % hochläuft. Die Anzeige stand deshalb auf 99 %,
    während der eigentliche Encode bei 1 % war. Zusammen mit dem alten Filter
    `progress > 0` im Aufrufer blieb sie dort stundenlang kleben, weil
    int(0.87) == 0 verworfen wurde.
    `task N of M` wird mitgerechnet: Presets mit zwei Durchläufen zählen die
    Prozente je Durchlauf neu, sonst sprang die Anzeige mitten in der Datei
    zurück auf 0.
    """
-    match = re.search(r'(\d+\.\d+)\s*%', line)
+    match = HB_ENCODE_RE.match(line.strip())
-    if match:
+    if not match:
-        return int(float(match.group(1)))
+        return -1
-    return 0
+    aktuell, gesamt, prozent = int(match.group(1)), int(match.group(2)), float(match.group(3))
    if gesamt < 1 or aktuell < 1:
        return -1
    return int(((aktuell - 1) * 100 + prozent) / gesamt)
-def run_handbrake(input_path: str, output_path: str, preset: str = DEFAULT_HB_PRESET, progress_cb=None) -> dict:
+def run_handbrake(input_path: str, output_path: str, preset: str = DEFAULT_HB_PRESET,
-    """Komprimiert eine MKV-Datei mit HandBrakeCLI; meldet Fortschritt."""
+                  progress_cb=None, abbruch_cb=None) -> dict:
    """Komprimiert eine MKV-Datei mit HandBrakeCLI; meldet Fortschritt.
    `abbruch_cb` wird bei JEDER Ausgabezeile aufgerufen und soll RipAbbruch
    werfen, wenn der Nutzer abgebrochen hat. Bewusst ein eigener Kanal neben
    `progress_cb` — aus demselben Grund wie `log_cb` bei run_makemkv: der
    Fortschritts-Callback verwirft Aufrufe mit unveränderter Prozentzahl, und
    genau daran hing der Abbruch früher. Bei einem 4K-Encode mit einem Prozent
    je halber Stunde sah „Abbrechen" deshalb minutenlang wirkungslos aus
    (Befund 25.07.2026). Zusätzlich greift es damit auch während des
    Scan-Durchlaufs, der gar keine Encode-Prozente ausgibt.
    """
    if not check_handbrake_installed():
        return {"status": "error", "error": "HandBrakeCLI ist nicht installiert"}
@@ -296,44 +363,64 @@ def run_handbrake(input_path: str, output_path: str, preset: str = DEFAULT_HB_PR
            text=True,
            bufsize=1
        )
-
+        return _handbrake_schleife(process, output_path, abbruch_cb, progress_cb)
        try:
            for line in process.stdout:
                progress = get_progress_from_line(line)
                if progress > 0 and progress_cb:
                    progress_cb(progress)
        except RipAbbruch:
            process.kill()
            process.wait()
            return {"status": "cancelled", "error": "Abgebrochen durch Nutzer"}
        process.wait()
        if process.returncode == 0 and os.path.exists(output_path):
            return {"status": "success", "output_path": output_path}
        return {
            "status": "error",
            "error": f"HandBrake endete mit Code {process.returncode}",
            "return_code": process.returncode,
        }
    except Exception as e:
        return {"status": "error", "error": str(e)}
-def build_abcde_cmd(device_path: str, config_path: str) -> list:
+def _handbrake_schleife(process, output_path: str, abbruch_cb=None, progress_cb=None) -> dict:
    """Liest HandBrakes Ausgabe und wertet sie aus. Eigene Funktion, damit die
    Reihenfolge (Abbruch VOR Fortschritt) ohne echtes HandBrake testbar ist."""
    try:
        for line in process.stdout:
            # Zuerst der Abbruch — unabhängig davon, ob die Zeile überhaupt
            # einen Fortschritt enthält. Sonst haengt „Abbrechen" daran, dass
            # sich die Prozentzahl bewegt (Befund 25.07.2026).
            if abbruch_cb:
                abbruch_cb()
            progress = get_progress_from_line(line)
            # >= 0: ein echtes 0 % ist eine Angabe und muss durch. Der alte
            # Filter `> 0` verwarf den gesamten ersten Prozentpunkt — bei
            # einem 4K-Encode sind das Stunden ohne sichtbare Bewegung.
            if progress >= 0 and progress_cb:
                progress_cb(progress)
    except RipAbbruch:
        process.kill()
        process.wait()
        return {"status": "cancelled", "error": "Abgebrochen durch Nutzer"}
    process.wait()
    if process.returncode == 0 and os.path.exists(output_path):
        return {"status": "success", "output_path": output_path}
    return {
        "status": "error",
        "error": f"HandBrake endete mit Code {process.returncode}",
        "return_code": process.returncode,
    }
 def build_abcde_cmd(device_path: str, config_path: str, auswerfen: bool = True) -> list:
    """Baut das abcde-Kommando (pure Funktion, testbar).
    -o = Ausgabeformat (flac), -N = nicht-interaktiv, -x = Eject am Ende,
    -c = Config-Datei (enthält OUTPUTDIR). NIE ein Verzeichnis an -o geben.
    Befund 25.07.2026: `-x` stand fest verdrahtet drin. Damit warf eine
    Audio-CD IMMER aus, während eine DVD/Blu-ray NIE auswarf — und die
    Einstellung „Automatischer Auswurf" regelte keines von beidem, weil sie
    nirgends gelesen wurde. Jetzt entscheidet sie hier mit.
    """
-    return [
+    cmd = [
        "abcde",
        "-d", device_path,
        "-o", "flac",
        "-N",
        "-x",
        "-c", config_path
    ]
    if auswerfen:
        cmd.append("-x")
    cmd += ["-c", config_path]
    return cmd
 def write_abcde_config(output_dir: str) -> str:
@@ -467,8 +554,10 @@ def rip_video(device_path: str, disc_id: str, disc_type: str = "dvd", progress_c
                       log_cb=log_cb)
-def rip_cd(device_path: str, disc_id: str, progress_cb=None, output_dir: str = None) -> dict:
+def rip_cd(device_path: str, disc_id: str, progress_cb=None, output_dir: str = None,
-    """Rippt eine CD mit abcde (FLAC)."""
+           auswerfen: bool = True) -> dict:
    """Rippt eine CD mit abcde (FLAC). `auswerfen` = Einstellung „Automatischer
    Auswurf" (abcde macht das selbst per -x)."""
    if not check_abcde_installed():
        return {
            "status": "error",
@@ -492,7 +581,7 @@ def rip_cd(device_path: str, disc_id: str, progress_cb=None, output_dir: str = N
    try:
        process = subprocess.Popen(
-            build_abcde_cmd(device_path, config_path),
+            build_abcde_cmd(device_path, config_path, auswerfen=auswerfen),
            stdout=subprocess.PIPE,
            stderr=subprocess.STDOUT,
            text=True,
@@ -12,11 +12,13 @@ komprimiert danach auf Arbeitsgröße. Die Rohdatei liegt nur temporär in
 /app/temp und wird nach Erfolg gelöscht (Setting keepOriginal behält sie).
 """
 import errno
 import glob
 import json
 import os
 import posixpath
 import shutil
 import time
 import requests
@@ -44,6 +46,7 @@ from ripping import (
    rip_cd,
    rip_video,
    run_handbrake,
    wirf_disc_aus,
 )
 API_URL = os.getenv("API_URL", "http://api:8000")
@@ -90,14 +93,44 @@ def pfad_lokal(pfad: str, mapping: str = None) -> str:
 RAW_DIR = os.getenv("RAW_DIR", "/app/temp/raw")
 MEDIA_ROOT = "/app/media"
 # Wie oft während einer Kompression nachgesehen wird, ob der Nutzer abgebrochen
 # hat. Eine DB-Abfrage alle paar Sekunden ist nichts gegen einen Encode, der
 # Stunden läuft — und „Abbrechen" fühlt sich damit sofort an.
 ABBRUCH_INTERVALL_SEKUNDEN = 5
 def unter_wurzel(pfad: str, wurzel: str) -> bool:
    """Liegt `pfad` wirklich unterhalb von `wurzel` (oder IST es die Wurzel)?
    Pure Funktion, testbar. Ein nacktes `startswith()` genügt nicht:
    „/app/media-boese/x" beginnt mit „/app/media", liegt aber ausserhalb
    (Befund 25.07.2026 bei der Durchsicht). Immer „/" als Trenner — das sind
    Container-Pfade, auch wenn ein nativer Windows-Worker das Modul lädt.
    Gleichlautend in docker/api/main.py; es gibt kein geteiltes Paket zwischen
    den Containern.
    """
    if not pfad or not wurzel:
        return False
    sauber = wurzel.rstrip("/") or "/"
    return pfad == sauber or pfad.startswith(sauber + "/")
 def _zielbasis(target_dir, disc_type: str) -> str:
-    """Ablagebasis: vom Nutzer gewähltes Ziel (validiert) oder Standard."""
+    """Ablagebasis: vom Nutzer gewähltes Ziel (validiert) oder Standard.
    posixpath statt os.path — aus demselben Grund wie in _arbeitsverzeichnis:
    das sind IMMER Container-Pfade. os.path.normpath macht unter Windows
    Backslashes daraus, und dann greift die MEDIA_ROOT-Prüfung nicht mehr, das
    gewählte Ziel fiele still auf den Standard zurück. Aufgefallen 25.07.2026,
    als der Test dafür erstmals unter Windows lief. Live war es nie: aufgerufen
    wird nur aus rip_disc, und das ist auf Windows-Workern verriegelt.
    """
    if target_dir:
-        normalisiert = os.path.normpath(target_dir)
+        normalisiert = posixpath.normpath(target_dir)
-        if normalisiert.startswith(MEDIA_ROOT):
+        if unter_wurzel(normalisiert, MEDIA_ROOT):
            return normalisiert
-    return os.path.join(RIP_OUTPUT_DIR, disc_type)
+    return posixpath.join(RIP_OUTPUT_DIR, disc_type)
 def _arbeitsverzeichnis(einstellungen: dict, job_wahl: str = "") -> str:
@@ -121,7 +154,7 @@ def _arbeitsverzeichnis(einstellungen: dict, job_wahl: str = "") -> str:
        wert = (kandidat or "").strip()
        if wert:
            normalisiert = posixpath.normpath(wert)
-            if normalisiert.startswith(MEDIA_ROOT):
+            if unter_wurzel(normalisiert, MEDIA_ROOT):
                return normalisiert
    return RAW_DIR
@@ -199,36 +232,65 @@ def _original_aufheben(job_id: str, raw_dir: str, final_dir: str) -> None:
    """Roh-Rip zusätzlich aufheben — darf den Job NIEMALS scheitern lassen.
    Befund 25.07.2026 (Akira-UHD, echter Schaden): Hier stand ein nacktes
-    shutil.move(). Arbeitsverzeichnis (/app/temp, Docker-Volume) und Ziel
+    shutil.move(). Zwischen Arbeitsverzeichnis (/app/temp) und Ziel
-    (/app/media, Bind-Mount) sind VERSCHIEDENE Dateisysteme — os.rename
+    (/app/media) scheitert os.rename mit EXDEV, shutil.move fällt auf Kopieren
-    scheitert dort mit EXDEV, und shutil.move fällt auf Kopieren zurück. Damit
+    zurück — eine 74-GB-Vollkopie auf dieselbe Platte, bis sie mit ENOSPC voll
-    lief eine 74-GB-Vollkopie auf dieselbe Platte an, bis sie mit ENOSPC voll
+    war. Ergebnis: Platte 100 % voll, Worker-Container startete nicht mehr, und
-    war. Ergebnis: Platte 100 % voll, Worker-Container startete nicht mehr —
+    der Job galt als FEHLGESCHLAGEN, obwohl die komprimierte Datei längst
-    und der Job wurde als FEHLGESCHLAGEN markiert, obwohl die komprimierte
+    fertig war. Der Nutzer sah nur „nichts da".
    Datei längst fertig und in Ordnung war. Der Nutzer sah nur „nichts da".
-    Deshalb dreifach abgesichert: Platz vorher prüfen, Fehler abfangen, und im
+    ## Warum hier NICHT vorhergesagt, sondern versucht wird
-    Zweifel die Rohdatei einfach liegen lassen, wo sie ist.
+
    Die erste Fassung dieses Schutzes verglich `os.stat(...).st_dev` und
    schloss aus gleichen Werten auf „reines Umhängen, kein Platz nötig". Am
    25.07.2026 im Worker-Container nachgemessen — beides zugleich wahr:
        st_dev /app/temp  = 2050
        st_dev /app/media = 2050      → also identisch
        os.rename(...)    → EXDEV, „Invalid cross-device link"
    Der Kernel vergleicht bei rename() den **Mount**, nicht das Gerät. /app/temp
    (Docker-Volume) und /app/media (Bind-Mount) sind zwei Mounts DERSELBEN
    ext4-Partition. Die st_dev-Prüfung war deshalb wirkungslos: sie sah
    „gleiches Dateisystem", übersprang die Platzprüfung, und shutil.move kopierte
    doch. Der Schutz hätte genau den Schaden zugelassen, gegen den er gebaut war.
    Also: erst rename VERSUCHEN. Klappt es, ist es umgehängt und fertig.
    Kommt EXDEV, steht fest, dass kopiert werden müsste — und erst dann wird
    der Platz geprüft. Das ist keine Vermutung mehr, sondern die Antwort des
    Kernels.
    """
    ziel_original = os.path.join(final_dir, "original")
    try:
-        # Liegt beides auf demselben Dateisystem, ist es ein reines Umhängen —
+        # Der billige Weg zuerst — und er ist gleichzeitig der einzige
-        # sofort fertig, kein zusätzlicher Platz nötig.
+        # verlässliche Test, ob überhaupt umgehängt werden kann.
-        gleiches_dateisystem = os.stat(raw_dir).st_dev == os.stat(final_dir).st_dev
+        try:
-        if not gleiches_dateisystem:
+            os.rename(raw_dir, ziel_original)
-            benoetigt = _ordner_groesse(raw_dir)
+            db.add_log(
-            frei = _frei_bytes(final_dir)
+                "info", "worker",
-            if frei < benoetigt * 1.05:
+                f"Job {job_id}: Original behalten unter {ziel_original} (umgehängt, "
-                db.add_log(
+                "kein zusätzlicher Platz nötig)",
-                    "warning", "worker",
+            )
-                    f"Job {job_id}: Original NICHT aufgehoben — dafür wären "
+            return
-                    f"{benoetigt / 1024**3:.1f} GB nötig, frei sind nur "
+        except OSError as e:
-                    f"{frei / 1024**3:.1f} GB. Die Roh-Datei bleibt unter "
+            if e.errno != errno.EXDEV:
-                    f"{raw_dir} liegen. Abhilfe: Arbeitsverzeichnis "
+                raise  # etwas anderes ist schiefgelaufen → unten ehrlich melden
-                    "(Einstellungen → Verarbeitung) auf dieselbe Freigabe legen "
+
-                    "wie das Ziel — dann wird nur umgehängt statt kopiert."
+        # Ab hier ist eine echte Kopie unvermeidlich. Jetzt lohnt die Platzfrage.
-                )
+        benoetigt = _ordner_groesse(raw_dir)
-                return
+        frei = _frei_bytes(final_dir)
        if frei < benoetigt * 1.05:
            db.add_log(
                "warning", "worker",
                f"Job {job_id}: Original NICHT aufgehoben — Ziel liegt auf einem "
                f"anderen Mount, es müsste kopiert werden. Dafür wären "
                f"{benoetigt / 1024**3:.1f} GB nötig, frei sind nur "
                f"{frei / 1024**3:.1f} GB. Die Roh-Datei bleibt unter "
                f"{raw_dir} liegen. Abhilfe: Arbeitsverzeichnis "
                "(Einstellungen → Verarbeitung) auf dieselbe Freigabe legen "
                "wie das Ziel — dann wird nur umgehängt statt kopiert."
            )
            return
        shutil.move(raw_dir, ziel_original)
        db.add_log("info", "worker", f"Job {job_id}: Original behalten unter {ziel_original}")
    except OSError as e:
@@ -500,7 +562,10 @@ def rip_disc(self, device_path: str, job_id: str, target_dir: str = None):
            return ergebnis
    if disc_type == "cd":
-        ergebnis = rip_cd(device_path, job_id, progress_cb=fortschritt, output_dir=final_dir)
+        ergebnis = rip_cd(
            device_path, job_id, progress_cb=fortschritt, output_dir=final_dir,
            auswerfen=bool(einstellungen.get("autoEject", True)),
        )
    elif transcode_an:
        # Roh-Rip ins Arbeitsverzeichnis (wird nach erfolgreicher Kompression gelöscht)
        ergebnis = rip_video(
@@ -562,6 +627,23 @@ def rip_disc(self, device_path: str, job_id: str, target_dir: str = None):
                "Normale BD/DVD gehen weiterhin."
            )
    # Automatischer Auswurf. Die Disc ist nach dem Rip nicht mehr nötig — die
    # Kompression arbeitet auf der Datei, nicht am Laufwerk.
    #
    # Befund 25.07.2026: Die Einstellung („Disc nach erfolgreichem Ripping
    # automatisch auswerfen", Standard ein) wurde von NIEMANDEM gelesen. Bei
    # DVD/Blu-ray warf Rippy deshalb nie aus, bei Audio-CD dagegen immer, weil
    # abcde `-x` fest verdrahtet bekam. Jetzt entscheidet die Einstellung beides.
    if ergebnis.get("status") == "success" and ist_video and einstellungen.get("autoEject", True):
        if wirf_disc_aus(device_path):
            db.add_log("info", "worker", f"Job {job_id}: Disc ausgeworfen")
        else:
            db.add_log(
                "warning", "worker",
                f"Job {job_id}: Disc konnte nicht ausgeworfen werden ({device_path}) — "
                "der Rip ist davon unberührt.",
            )
    if ergebnis.get("status") == "success" and transcode_an:
        # Kompression als eigener Task — an den im Rip-Dialog GEWÄHLTEN Worker
        # (worker_direct), sonst an die geteilte transcode-Queue (irgendein
@@ -652,6 +734,30 @@ def transcode_files(self, job_id: str, raw_dir: str, final_dir: str):
    anzahl = len(quellen)
    letzter = [-1]
    letzte_abbruchpruefung = [0.0]
    def abbruch_pruefen():
        """Zeitgesteuert prüfen, ob der Nutzer abgebrochen hat. Wirft RipAbbruch.
        Befund 25.07.2026 (Commander, am laufenden Akira-Job beobachtet): Der
        Abbruch wurde NUR in `datei_fortschritt` geprüft — und diese Closure
        stieg oben sofort wieder aus, wenn sich die Prozentzahl nicht geändert
        hatte. Bei einem 4K-Encode, der pro Prozent eine halbe Stunde braucht,
        sah „Abbrechen" entsprechend lange wirkungslos aus (gemessen: 3,4 min
        zwischen Anforderung 18:30:17 und Bestätigung 18:33:38 — bei noch
        langsamerem Fortschritt entsprechend mehr).
        Deshalb hängt die Prüfung jetzt an der Zeit statt am Fortschritt und
        läuft bei JEDER Ausgabezeile von HandBrake — auch während des
        Scan-Durchlaufs, der überhaupt keine Encode-Prozente liefert.
        """
        jetzt = time.monotonic()
        if jetzt - letzte_abbruchpruefung[0] < ABBRUCH_INTERVALL_SEKUNDEN:
            return
        letzte_abbruchpruefung[0] = jetzt
        if _abbruch_angefordert(job_id):
            raise RipAbbruch()
    for index, quelle in enumerate(quellen):
        ziel = os.path.join(final_dir, os.path.basename(quelle))
@@ -660,11 +766,13 @@ def transcode_files(self, job_id: str, raw_dir: str, final_dir: str):
            if gesamt == letzter[0]:
                return
            letzter[0] = gesamt
            if _abbruch_angefordert(job_id):
                raise RipAbbruch()
            db.update_job(job_id, progress=min(99, gesamt))
-        hb = run_handbrake(quelle, ziel, preset=preset, progress_cb=datei_fortschritt)
+        hb = run_handbrake(
            quelle, ziel, preset=preset,
            progress_cb=datei_fortschritt,
            abbruch_cb=abbruch_pruefen,
        )
        if hb.get("status") == "cancelled":
            _job_abschliessen(job_id, hb)
            return hb
@@ -0,0 +1,115 @@
 """Tests der Fähigkeiten-Erkennung — reine Funktionen, keine Infrastruktur.
 Die Testdaten sind ECHTE Ausgaben, am 25.07.2026 im Worker-Image der Rippy-VM
 abgenommen (AGENTS Regel D). Erfundene Formate hätten hier keinen Wert: genau
 daran ist die Erkennung vorher gescheitert.
 """
 import caps
 # Wörtlich aus `docker exec rippy-worker-1 HandBrakeCLI --help` (HandBrake im
 # Worker-Image, 25.07.2026). Bemerkenswert: KEIN Hardware-Encoder dabei.
 HB_HILFE_ECHT = """
   -Z, --preset <string>   Select preset by name
   -e, --encoder <string>  Select video encoder:
                               svt_av1
                               svt_av1_10bit
                               x264
                               x264_10bit
                               x265
                               x265_10bit
                               x265_12bit
                               mpeg4
                               mpeg2
                               VP8
                               VP9
                               VP9_10bit
                               theora
       --encoder-preset <string>
                           Adjust video encoding settings
 """
 # Wie dieselbe Stelle auf einer Maschine MIT Hardware-Encodern aussieht
 # (HandBrake-Windows-Build; Struktur identisch, nur mehr Namen).
 HB_HILFE_MIT_HARDWARE = """
   -e, --encoder <string>  Select video encoder:
                               x264
                               x265
                               nvenc_h264
                               nvenc_h265
                               qsv_h264
                               qsv_h265
       --encoder-preset <string>
 """
 def test_encoder_liste_wird_aus_echter_hilfe_gelesen():
    encoder = caps.parse_encoder_liste(HB_HILFE_ECHT)
    assert encoder == [
        "svt_av1", "svt_av1_10bit",
        "x264", "x264_10bit",
        "x265", "x265_10bit", "x265_12bit",
        "mpeg4", "mpeg2", "VP8", "VP9", "VP9_10bit", "theora",
    ]
    # Der Block endet an der nächsten Option — sie darf nicht mitgelesen werden
    assert not any("encoder-preset" in e for e in encoder)
    assert not any(e.startswith("-") for e in encoder)
 def test_encoder_liste_ohne_handbrake_ist_leer():
    assert caps.parse_encoder_liste("") == []
    assert caps.parse_encoder_liste(None) == []
    assert caps.parse_encoder_liste("irgendein Text ohne Encoder-Abschnitt") == []
 def test_ohne_handbrake_keine_encoder():
    """Der wichtigste Fall: vorher standen cpu-x264/cpu-x265 fest verdrahtet in
    der Liste. Ein Rip-Worker ohne HandBrake behauptete damit, komprimieren zu
    können — und jeder Transcode dort endete sofort mit 'nicht installiert'."""
    assert caps.leite_backends_ab([], dri_da=True, nvidia_da=True) == []
 def test_backends_aus_echter_liste():
    encoder = caps.parse_encoder_liste(HB_HILFE_ECHT)
    # Kein /dev/dri, kein NVIDIA — und HandBrake kann hier ohnehin keine Hardware
    assert caps.leite_backends_ab(encoder, dri_da=False, nvidia_da=False) == [
        "cpu-x264", "cpu-x265", "cpu-av1",
    ]
 def test_hardware_nur_wenn_geraet_UND_handbrake_es_kann():
    """Befund 25.07.2026: Vorher genügte /dev/dri, um 'vaapi' zu melden. Das
    Worker-Image kann laut eigener Auskunft aber gar keinen Hardware-Encoder —
    Rippy hätte VAAPI versprochen und wäre beim Encodieren gescheitert."""
    ohne_hw = caps.parse_encoder_liste(HB_HILFE_ECHT)
    assert "vaapi" not in caps.leite_backends_ab(ohne_hw, dri_da=True, nvidia_da=True)
    assert "nvenc" not in caps.leite_backends_ab(ohne_hw, dri_da=True, nvidia_da=True)
    mit_hw = caps.parse_encoder_liste(HB_HILFE_MIT_HARDWARE)
    # Gerät fehlt → trotz Können kein Hardware-Backend
    assert caps.leite_backends_ab(mit_hw, dri_da=False, nvidia_da=False) == [
        "cpu-x264", "cpu-x265",
    ]
    # Beides da → beides gemeldet
    beides = caps.leite_backends_ab(mit_hw, dri_da=True, nvidia_da=True)
    assert "vaapi" in beides   # qsv_* vorhanden
    assert "nvenc" in beides
 def test_simd_stufe_erkennt_die_hoechste():
    assert caps.beste_simd("fpu vme de sse4_2 avx avx2") == "avx2"
    assert caps.beste_simd("sse4_2 avx avx2 avx512f") == "avx512f"
    assert caps.beste_simd("fpu vme de pse tsc sse4_2") == "sse4_2"
    assert caps.beste_simd("") == "unbekannt"
    assert caps.beste_simd(None) == "unbekannt"
 def test_simd_stufe_der_rippy_vm_ist_sse4_2():
    """Echt gemessen auf der Rippy-VM (25.07.2026): generisches QEMU-CPU-Modell,
    `grep -c avx2 /proc/cpuinfo` = 0. Genau das macht Software-4K dort so lahm."""
    flags_vm = (
        "fpu de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 "
        "clflush mmx fxsr sse sse2 syscall nx lm rep_good nopl cpuid "
        "pni cx16 sse4_1 sse4_2 x2apic popcnt aes hypervisor lahf_lm"
    )
    assert caps.beste_simd(flags_vm) == "sse4_2"
@@ -114,63 +114,11 @@ def test_pfad_lokal_uebersetzt_fuer_windows_worker():
    assert pfad_lokal("/app/temp/raw/abc", "") == "/app/temp/raw/abc"
-def test_original_aufheben_laesst_job_nie_scheitern(tmp_path, monkeypatch):
+# Die beiden frueheren Tests zu _original_aufheben sind nach
-    """Der Schritt "Original behalten" darf einen fertigen Job NICHT killen.
+# test_original_aufheben.py gewandert und dort erweitert. Sie pruefen jetzt das
-
+# richtige Kriterium: Vorher taeuschten sie per gefaelschtem os.stat
-    Schaden vom 25.07.2026 (Akira-UHD): shutil.move() ueber Dateisystemgrenzen
+# „verschiedene Dateisysteme" vor — genau die Annahme, an der der Schutz in der
-    kopierte 74 GB, lief in ENOSPC, und der Job galt als fehlgeschlagen —
+# Praxis scheiterte (st_dev war identisch, os.rename trotzdem EXDEV).
    obwohl die komprimierte Datei laengst fertig war. Der Nutzer sah nur eine
    leere Queue.
    """
    import tasks
    meldungen = []
    monkeypatch.setattr(tasks.db, "add_log", lambda *a: meldungen.append(a))
    raw = tmp_path / "raw"
    raw.mkdir()
    (raw / "title_t00.mkv").write_bytes(b"x" * 1024)
    final = tmp_path / "final"
    final.mkdir()
    def platzt(*_a, **_k):
        raise OSError(28, "No space left on device")
    monkeypatch.setattr(tasks.shutil, "move", platzt)
    # Darf NICHT werfen
    tasks._original_aufheben("job-1", str(raw), str(final))
    assert meldungen and meldungen[-1][0] == "warning"
    assert "Roh-Datei bleibt" in meldungen[-1][2]
 def test_original_aufheben_warnt_statt_platte_vollzuschreiben(tmp_path, monkeypatch):
    """Zu wenig Platz auf einem ANDEREN Dateisystem -> gar nicht erst anfangen."""
    import tasks
    meldungen = []
    monkeypatch.setattr(tasks.db, "add_log", lambda *a: meldungen.append(a))
    bewegt = []
    monkeypatch.setattr(tasks.shutil, "move", lambda *a: bewegt.append(a))
    raw = tmp_path / "raw"
    raw.mkdir()
    (raw / "gross.mkv").write_bytes(b"x" * 4096)
    final = tmp_path / "final"
    final.mkdir()
    # Verschiedene Dateisysteme vortaeuschen und den freien Platz kleinrechnen.
    # _ordner_groesse wird mitgefaelscht, weil ein selbstgebautes os.stat sonst
    # os.path.getsize mitreisst (das liest st_size an derselben Stelle).
    class Stat:
        def __init__(self, dev): self.st_dev = dev
    monkeypatch.setattr(tasks.os, "stat", lambda p: Stat(1 if "raw" in str(p) else 2))
    monkeypatch.setattr(tasks, "_ordner_groesse", lambda _p: 4096)
    monkeypatch.setattr(tasks, "_frei_bytes", lambda _p: 100)
    tasks._original_aufheben("job-2", str(raw), str(final))
    assert bewegt == [], "es darf NICHT kopiert werden, wenn der Platz nicht reicht"
    assert meldungen[-1][0] == "warning"
    assert "NICHT aufgehoben" in meldungen[-1][2]
 def test_arbeitsverzeichnis_wahl_des_rips_schlaegt_die_einstellung():
@@ -191,3 +139,37 @@ def test_arbeitsverzeichnis_wahl_des_rips_schlaegt_die_einstellung():
    assert tasks._arbeitsverzeichnis({}, "/app/media/../etc") == tasks.RAW_DIR
    # Leere Wahl faellt sauber auf die Einstellung zurueck
    assert tasks._arbeitsverzeichnis(einst, "   ") == "/app/media/movies"
 def test_unter_wurzel_faellt_nicht_auf_praefix_namen_herein():
    """Befund 25.07.2026: Elf Stellen prueften mit nacktem startswith().
    „/app/media-boese/x" beginnt mit „/app/media", liegt aber ausserhalb."""
    import tasks
    assert tasks.unter_wurzel("/app/media", "/app/media") is True
    assert tasks.unter_wurzel("/app/media/movies", "/app/media") is True
    assert tasks.unter_wurzel("/app/media/movies/Film (2020)", "/app/media") is True
    # Der Fall, den startswith() durchgelassen haette
    assert tasks.unter_wurzel("/app/media-boese/x", "/app/media") is False
    assert tasks.unter_wurzel("/app/mediaX", "/app/media") is False
    assert tasks.unter_wurzel("/etc/passwd", "/app/media") is False
    assert tasks.unter_wurzel("", "/app/media") is False
    assert tasks.unter_wurzel("/app/media", "") is False
    # Wurzel mit Schrägstrich am Ende darf nichts aendern
    assert tasks.unter_wurzel("/app/media/movies", "/app/media/") is True
 def test_zielbasis_lehnt_praefix_ausbruch_ab():
    import tasks
    assert tasks._zielbasis("/app/media/movies", "bluray") == "/app/media/movies"
    # Ausbruch per Praefix-Namen faellt auf den Standard zurueck
    assert tasks._zielbasis("/app/media-boese", "bluray") != "/app/media-boese"
    assert tasks._zielbasis("/etc", "bluray") != "/etc"
 def test_arbeitsverzeichnis_lehnt_praefix_ausbruch_ab():
    import tasks
    assert tasks._arbeitsverzeichnis({}, "/app/media-boese") == tasks.RAW_DIR
    assert tasks._arbeitsverzeichnis({"workDir": "/app/mediaX"}) == tasks.RAW_DIR
@@ -0,0 +1,124 @@
 """Tests fuer _original_aufheben — der Pfad, der am 25.07.2026 die Platte fuellte.
 Der Kern: Es wird NICHT vorhergesagt, ob umgehaengt werden kann, sondern
 os.rename versucht. Die alte Fassung verglich st_dev und lag damit falsch —
 auf der Rippy-VM sind st_dev von /app/temp und /app/media identisch (2050),
 os.rename scheitert zwischen ihnen trotzdem mit EXDEV, weil der Kernel den
 Mount vergleicht und nicht das Geraet. Die Platzpruefung wurde deshalb
 uebersprungen und shutil.move kopierte 75 GB bei 37 GB frei.
 """
 import errno
 import os
 import pytest
 import tasks
 class FakeDb:
    """Faengt nur die Log-Zeilen ab — mehr braucht _original_aufheben nicht."""
    def __init__(self):
        self.logs = []
    def add_log(self, level, source, message):
        self.logs.append((level, message))
    def meldungen(self):
        return " ".join(m for _, m in self.logs)
@pytest.fixture
 def fake_db(monkeypatch):
    ersatz = FakeDb()
    monkeypatch.setattr(tasks, "db", ersatz)
    return ersatz
 def _lege_rohdaten_an(tmp_path, groesse=2048):
    raw = tmp_path / "raw" / "job-1"
    raw.mkdir(parents=True)
    (raw / "title_t00.mkv").write_bytes(b"x" * groesse)
    final = tmp_path / "media" / "Film (2020)"
    final.mkdir(parents=True)
    return str(raw), str(final)
 def test_umhaengen_wenn_derselbe_mount(tmp_path, fake_db):
    """Der gute Fall: rename klappt, nichts wird kopiert, kein Platz noetig."""
    raw, final = _lege_rohdaten_an(tmp_path)
    tasks._original_aufheben("job-1", raw, final)
    assert os.path.isdir(os.path.join(final, "original"))
    assert os.path.isfile(os.path.join(final, "original", "title_t00.mkv"))
    assert not os.path.exists(raw)
    assert "umgehängt" in fake_db.meldungen()
 def test_bei_exdev_und_zu_wenig_platz_wird_nur_gewarnt(tmp_path, fake_db, monkeypatch):
    """Der Fall, der die Platte fuellte: rename geht nicht, Platz reicht nicht.
    Vorher lief hier eine Vollkopie an, weil die st_dev-Pruefung „gleiches
    Dateisystem" meldete und die Platzpruefung deshalb ausblieb.
    """
    raw, final = _lege_rohdaten_an(tmp_path)
    def kein_rename(*_a, **_k):
        raise OSError(errno.EXDEV, "Invalid cross-device link")
    monkeypatch.setattr(tasks.os, "rename", kein_rename)
    monkeypatch.setattr(tasks, "_frei_bytes", lambda _p: 1024)  # weniger als die Rohdaten
    tasks._original_aufheben("job-1", raw, final)
    # Rohdaten bleiben unangetastet liegen, es wurde NICHTS kopiert
    assert os.path.isfile(os.path.join(raw, "title_t00.mkv"))
    assert not os.path.exists(os.path.join(final, "original"))
    meldungen = fake_db.meldungen()
    assert "NICHT aufgehoben" in meldungen
    assert "anderen Mount" in meldungen
    assert "Arbeitsverzeichnis" in meldungen  # nennt die Abhilfe
 def test_bei_exdev_und_genug_platz_wird_kopiert(tmp_path, fake_db, monkeypatch):
    raw, final = _lege_rohdaten_an(tmp_path)
    echtes_rename = os.rename
    aufrufe = {"n": 0}
    def rename_erst_exdev(*args, **kwargs):
        # Nur der Versuch von _original_aufheben scheitert; shutil.move darf
        # intern weiter umbenennen (es kopiert selbst und benennt Teile um).
        aufrufe["n"] += 1
        if aufrufe["n"] == 1:
            raise OSError(errno.EXDEV, "Invalid cross-device link")
        return echtes_rename(*args, **kwargs)
    monkeypatch.setattr(tasks.os, "rename", rename_erst_exdev)
    monkeypatch.setattr(tasks, "_frei_bytes", lambda _p: 10 * 1024**3)
    tasks._original_aufheben("job-1", raw, final)
    assert os.path.isfile(os.path.join(final, "original", "title_t00.mkv"))
    assert "Original behalten" in fake_db.meldungen()
 def test_anderer_fehler_wird_ehrlich_gemeldet_und_reisst_job_nicht_mit(
    tmp_path, fake_db, monkeypatch
 ):
    """Ein Fehler beim Aufheben darf den Job NIE scheitern lassen — die
    komprimierte Datei ist zu diesem Zeitpunkt fertig und in Ordnung."""
    raw, final = _lege_rohdaten_an(tmp_path)
    def zugriff_verweigert(*_a, **_k):
        raise OSError(errno.EACCES, "Permission denied")
    monkeypatch.setattr(tasks.os, "rename", zugriff_verweigert)
    tasks._original_aufheben("job-1", raw, final)  # darf nicht werfen
    meldungen = fake_db.meldungen()
    assert "konnte nicht aufgehoben werden" in meldungen
    assert raw in meldungen  # sagt, WO die Rohdatei liegt
@@ -43,10 +43,43 @@ def test_handbrake_cmd_arbeitet_auf_datei_nicht_geraet():
 def test_handbrake_progress_parsing():
-    # Testfund 22.07.: echtes HandBrake schreibt „45.50 %" MIT Leerzeichen
+    # Testfund 22.07.: echtes HandBrake schreibt 45.50 % MIT Leerzeichen
    assert get_progress_from_line("Encoding: task 1 of 1, 45.50 %") == 45
    assert get_progress_from_line("Encoding: task 1 of 1, 100.00 %") == 100
-    assert get_progress_from_line("kein Fortschritt hier") == 0
+    # Echte Zeile mit fps-Anhang, wie sie im Binary steht
    assert get_progress_from_line(
        "Encoding: task 1 of 1, 12.34 % (5.67 fps, avg 4.32 fps, ETA 00h12m34s)"
    ) == 12
    # Ein echtes 0 % ist eine ANGABE, keine Leermeldung
    assert get_progress_from_line("Encoding: task 1 of 1, 0.00 %") == 0
 def test_handbrake_progress_ignoriert_scan_durchlauf():
    """Befund 25.07.2026 (Akira-UHD, live gemessen): HandBrake läuft VOR dem
    Encodieren einen Scan-Durchlauf, der ebenfalls Prozente ausgibt und dabei
    bis 100 % steigt. Die alte Regex nahm jede Zahl vor einem Prozentzeichen
    und meldete deshalb 99 %, während der Encode bei 1 % stand.
    -1 heißt „keine Encode-Fortschrittszeile" — dasselbe Muster wie bei
    get_progress_from_prgv. Fremde Zeilen dürfen NIE als 0 % gelten.
    """
    assert get_progress_from_line("Scanning title 1 of 1, preview 3, 30.00 %") == -1
    assert get_progress_from_line("Scanning title 1 of 1, preview 10, 100.00 %") == -1
    # Vorlauf-Phase: Prozente beziehen sich auf die Suche, nicht auf den Encode
    assert get_progress_from_line(
        "Encoding: task 1 of 1, Searching for start time, 42.00 %"
    ) == -1
    assert get_progress_from_line("kein Fortschritt hier") == -1
    assert get_progress_from_line("Muxing: this may take awhile...") == -1
    assert get_progress_from_line("") == -1
 def test_handbrake_progress_rechnet_zwei_durchlaeufe_zusammen():
    """Presets mit zwei Durchläufen zählen die Prozente je Durchlauf neu.
    Ohne Verrechnung sprang die Anzeige mitten in der Datei zurück auf 0."""
    assert get_progress_from_line("Encoding: task 1 of 2, 50.00 %") == 25
    assert get_progress_from_line("Encoding: task 2 of 2, 0.00 %") == 50
    assert get_progress_from_line("Encoding: task 2 of 2, 100.00 %") == 100
 def test_prgv_parsing():
@@ -129,6 +162,20 @@ def test_abcde_cmd_hat_genau_ein_ausgabeformat():
    assert "-N" in cmd  # nicht-interaktiv, sonst hängt der Worker
 def test_abcde_auswurf_folgt_der_einstellung():
    """Befund 25.07.2026: `-x` (Auswurf) stand fest verdrahtet drin. Eine
    Audio-CD warf damit IMMER aus, eine DVD/Blu-ray NIE — und die Einstellung
    „Automatischer Auswurf" regelte keines von beidem, weil sie nirgends
    gelesen wurde."""
    assert "-x" in build_abcde_cmd("/dev/sr0", "/tmp/c.conf", auswerfen=True)
    assert "-x" not in build_abcde_cmd("/dev/sr0", "/tmp/c.conf", auswerfen=False)
    # Standard bleibt „auswerfen" — so war das Verhalten bisher
    assert "-x" in build_abcde_cmd("/dev/sr0", "/tmp/c.conf")
    # Die Config darf durch das weggefallene -x nicht verrutschen
    ohne = build_abcde_cmd("/dev/sr0", "/tmp/c.conf", auswerfen=False)
    assert ohne[ohne.index("-c") + 1] == "/tmp/c.conf"
 def test_abcde_config_enthaelt_zielverzeichnis():
    pfad = write_abcde_config("/app/media/cd/test123")
    try:
@@ -178,3 +225,50 @@ def test_preset_fuer_ohne_einstellungen_nimmt_den_eingebauten_standard():
    assert preset_fuer("", None) == DEFAULT_HB_PRESET
    assert preset_fuer(None, {}) == DEFAULT_HB_PRESET
    assert preset_fuer("cd", {"transcodePresetUhd": "egal"}) == DEFAULT_HB_PRESET
 def test_handbrake_prueft_abbruch_bei_jeder_zeile_nicht_nur_bei_fortschritt():
    """Befund 25.07.2026 (am laufenden Akira-Job beobachtet): Der Abbruch hing
    am Fortschritts-Callback, und der stieg bei unveraenderter Prozentzahl
    sofort aus. Bei einem 4K-Encode mit einem Prozent je halber Stunde sah
    „Abbrechen" minutenlang wirkungslos aus (gemessen: 3,4 min).
    Der Abbruch-Kanal muss deshalb JEDE Ausgabezeile sehen — auch die des
    Scan-Durchlaufs, der gar keine Encode-Prozente liefert.
    """
    import ripping
    zeilen = [
        "Scanning title 1 of 1, preview 1, 10.00 %\n",
        "Scanning title 1 of 1, preview 2, 20.00 %\n",
        "Encoding: task 1 of 1, 0.00 %\n",
        "Encoding: task 1 of 1, 0.00 %\n",
    ]
    gesehen = []
    class FakeProcess:
        def __init__(self):
            self.stdout = iter(zeilen)
            self.returncode = 0
            self.getoetet = False
        def kill(self):
            self.getoetet = True
        def wait(self):
            return 0
    prozess = FakeProcess()
    def abbruch_cb():
        gesehen.append(1)
        if len(gesehen) == 2:  # beim zweiten Mal abbrechen
            raise ripping.RipAbbruch()
    ergebnis = ripping._handbrake_schleife(prozess, "/x.mkv", abbruch_cb, None)
    assert ergebnis["status"] == "cancelled"
    assert prozess.getoetet is True
    # Zwei Scan-Zeilen genuegten — es musste NICHT auf eine Encode-Zeile gewartet
    # werden. Genau das war der Fehler.
    assert len(gesehen) == 2
@@ -0,0 +1,190 @@
 """Tests der Zombie-Erkennung — ohne Postgres und ohne Redis.
 Der Schwerpunkt liegt bewusst auf dem, was WEHTUT: ein laufender Job darf
 niemals als Leiche gelten. Genau das wäre am 25.07.2026 passiert, wenn die
 Erkennung nach dem Alter des Jobs geurteilt hätte — der Akira-Job war seit
 neun Stunden offen und lief trotzdem.
 """
 import zombies
 # --- reine Funktionen -------------------------------------------------------
 def test_belegte_job_ids_findet_id_an_beliebiger_stelle():
    """job_id steht bei rip_disc an zweiter, bei transcode_files an erster
    Stelle — die Erkennung darf sich auf keine Position verlassen."""
    aktiv = {
        "celery@node1": [
            {"name": "worker.tasks.transcode_files", "args": ["job-eins", "/raw", "/final"]},
            {"name": "worker.tasks.rip_disc", "args": ["/dev/sr0", "job-zwei"]},
        ]
    }
    belegt = zombies.belegte_job_ids([aktiv], ["job-eins", "job-zwei", "job-drei"])
    assert belegt == {"job-eins", "job-zwei"}
 def test_belegte_job_ids_versteht_args_als_text():
    """Celery liefert args je nach Version als Liste ODER als Text-Repräsentation."""
    aktiv = {"celery@node1": [{"name": "x", "args": "('job-eins', '/raw', '/final')"}]}
    assert zombies.belegte_job_ids([aktiv], ["job-eins", "job-zwei"]) == {"job-eins"}
 def test_belegte_job_ids_ohne_auskunft_ist_leer():
    assert zombies.belegte_job_ids(None, ["a"]) == set()
    assert zombies.belegte_job_ids([None, None, None], ["a"]) == set()
    assert zombies.belegte_job_ids([{}, None], ["a"]) == set()
 def test_antwortende_knoten_sammelt_ueber_alle_abfragen():
    aktiv = {"celery@a": []}
    vorgemerkt = {"celery@b": []}
    assert zombies.antwortende_knoten([aktiv, None, vorgemerkt]) == {"celery@a", "celery@b"}
    assert zombies.antwortende_knoten([None, None]) == set()
 def test_auskunft_nur_vollstaendig_wenn_alle_bekannten_antworten():
    assert zombies.auskunft_vollstaendig(1, 1) is True
    assert zombies.auskunft_vollstaendig(2, 1) is True
    # Ein bekannter Worker schweigt → NICHT urteilen
    assert zombies.auskunft_vollstaendig(1, 2) is False
    # Niemand antwortet → wir wissen nichts
    assert zombies.auskunft_vollstaendig(0, 0) is False
 def test_finde_zombies_verschont_belegte_jobs():
    offene = [{"id": "a", "status": "transcoding"}, {"id": "b", "status": "ripping"}]
    assert zombies.finde_zombies(offene, {"a"}) == [{"id": "b", "status": "ripping"}]
    assert zombies.finde_zombies(offene, {"a", "b"}) == []
 def test_fehlertext_nennt_zustand_und_den_weg_zurueck():
    text = zombies.fehlertext({"status": "transcoding"})
    assert "transcoding" in text
    assert "Neu komprimieren" in text
    assert "NICHT gelöscht" in text
 # --- Attrappen für den Gesamtdurchlauf --------------------------------------
 class FakeInspektor:
    def __init__(self, aktiv=None, vorgemerkt=None, geplant=None):
        self._aktiv, self._vorgemerkt, self._geplant = aktiv, vorgemerkt, geplant
    def active(self):
        return self._aktiv
    def reserved(self):
        return self._vorgemerkt
    def scheduled(self):
        return self._geplant
 class FakeCelery:
    def __init__(self, inspektor):
        self.control = self
        self._inspektor = inspektor
    def inspect(self, timeout=None):
        return self._inspektor
 class FakeDb:
    def __init__(self, offene, online=1):
        self._offene, self._online = offene, online
        self.aktualisierungen = []
        self.logs = []
    def list_jobs_mit_status(self, stati):
        return [j for j in self._offene if j["status"] in stati]
    def zaehle_online_worker(self, sekunden=120):
        return self._online
    def update_job(self, job_id, **felder):
        self.aktualisierungen.append((job_id, felder))
    def add_log(self, level, source, message):
        self.logs.append((level, message))
    def utcnow(self):
        return "jetzt"
 # --- Gesamtdurchlauf --------------------------------------------------------
 def test_laufender_job_wird_nicht_angetastet():
    """Der Fall, der wehtut: Job läuft seit Stunden und IST aktiv."""
    db = FakeDb([{"id": "lebt", "status": "transcoding", "title": "Akira"}])
    aktiv = {"celery@a": [{"name": "worker.tasks.transcode_files", "args": ["lebt"]}]}
    celery = FakeCelery(FakeInspektor(aktiv=aktiv, vorgemerkt={}, geplant={}))
    bericht = zombies.raeume_zombies_auf(celery, db)
    assert bericht["aufgeraeumt"] == []
    assert db.aktualisierungen == []
 def test_echte_leiche_wird_auf_failed_gesetzt():
    db = FakeDb([{"id": "leiche", "status": "transcoding", "title": "Akira"}])
    # Der Knoten antwortet — er arbeitet nur an nichts.
    celery = FakeCelery(FakeInspektor(aktiv={"celery@a": []}, vorgemerkt={}, geplant={}))
    bericht = zombies.raeume_zombies_auf(celery, db)
    assert bericht["aufgeraeumt"] == ["leiche"]
    job_id, felder = db.aktualisierungen[0]
    assert job_id == "leiche"
    assert felder["status"] == "failed"
    assert "Neu komprimieren" in felder["error"]
    assert felder["finished_at"] == "jetzt"
 def test_schweigender_worker_verhindert_jedes_urteil():
    """Zwei Worker gelten als online, nur einer antwortet — der andere könnte
    genau diesen Job bearbeiten. Also: Finger weg."""
    db = FakeDb([{"id": "unklar", "status": "transcoding", "title": "X"}], online=2)
    celery = FakeCelery(FakeInspektor(aktiv={"celery@a": []}, vorgemerkt={}, geplant={}))
    bericht = zombies.raeume_zombies_auf(celery, db)
    assert bericht["aufgeraeumt"] == []
    assert db.aktualisierungen == []
    assert "unvollständige Auskunft" in bericht["uebersprungen"]
 def test_gar_keine_antwort_fuehrt_zu_keinem_urteil():
    db = FakeDb([{"id": "unklar", "status": "ripping", "title": "X"}], online=0)
    celery = FakeCelery(FakeInspektor(aktiv=None, vorgemerkt=None, geplant=None))
    bericht = zombies.raeume_zombies_auf(celery, db)
    assert bericht["aufgeraeumt"] == []
    assert db.aktualisierungen == []
 def test_fertige_jobs_werden_gar_nicht_betrachtet():
    db = FakeDb([
        {"id": "fertig", "status": "completed", "title": "A"},
        {"id": "kaputt", "status": "failed", "title": "B"},
        {"id": "wartet", "status": "pending", "title": "C"},
    ])
    celery = FakeCelery(FakeInspektor(aktiv={"celery@a": []}, vorgemerkt={}, geplant={}))
    bericht = zombies.raeume_zombies_auf(celery, db)
    # pending bleibt bewusst unberührt: die Aufgabe kann noch in der
    # Warteschlange liegen und wird von selbst abgeholt.
    assert bericht["geprueft"] == 0
    assert db.aktualisierungen == []
 def test_fehler_reisst_den_worker_start_nicht_mit():
    class KaputteDb(FakeDb):
        def list_jobs_mit_status(self, stati):
            raise RuntimeError("Postgres weg")
    db = KaputteDb([])
    bericht = zombies.raeume_zombies_auf(FakeCelery(FakeInspektor()), db)
    assert "Postgres weg" in bericht["uebersprungen"]
@@ -0,0 +1,149 @@
 """Erkennt Job-Leichen: Jobs, die behaupten zu laufen, an denen aber niemand arbeitet.
 Befund 25.07.2026 (Akira-UHD): Nach einem Absturz stand ein Job auf
 `transcoding` bei 96 %, obwohl weder ein Prozess lief noch etwas in den
 Celery-Queues stand. Folge für den Nutzer: kein Fortschritt, kein Download —
 und der Knopf „Neu komprimieren" fehlte, weil `_kann_neu_komprimieren`
 (api/main.py) `status == "failed"` verlangt. Der Job war damit unerreichbar,
 obwohl die Rohdateien vollständig dalagen.
 ## Die Leitregel: ohne vollständige Auskunft wird NICHTS angetastet
 Ein falsch als Leiche markierter Job ist teurer als eine stehengebliebene
 Leiche. Deshalb drei Sicherungen:
 1. **Nur beim Worker-Start.** Da ist die Aussage eindeutig: „als ich hochkam,
   lief nichts". Ein periodischer Lauf könnte einen Job erwischen, der legitim
   in der Warteschlange wartet, weil alle Arbeitsplätze belegt sind — der ist
   für `active()`/`reserved()` unsichtbar. Bewusst nicht gebaut.
 2. **Gnadenfrist.** Nach einem Neustart stellt Celery unbestätigte Aufgaben
   erneut zu. Erst abwarten, dann urteilen.
 3. **Vollzähligkeit.** Es wird nur geurteilt, wenn mindestens so viele
   Celery-Knoten antworten, wie laut Herzschlag online sind. Antwortet ein
   beschäftigter Remote-Worker nicht rechtzeitig, wäre sein laufender Job
   sonst eine falsche Leiche.
 Die Kernfunktionen sind bewusst rein (kein Postgres, kein Redis), damit die
 Ampel sie ohne Infrastruktur prüfen kann.
 """
 # Zustände, die behaupten: hier arbeitet gerade jemand.
 ARBEITS_STATI = ("ripping", "transcoding", "canceling")
 # Wartezeit nach dem Worker-Start, bevor geurteilt wird. Deckt die
 # Wiederzustellung unbestätigter Aufgaben durch Celery ab.
 GNADENFRIST_SEKUNDEN = 120
 # Wie lange auf Antworten der Celery-Knoten gewartet wird. Großzügig, weil ein
 # Worker mitten in einem 4K-Encode träge antwortet.
 INSPEKT_TIMEOUT_SEKUNDEN = 10
 def belegte_job_ids(inspektionen, kandidaten) -> set:
    """Welche der `kandidaten`-IDs kommen in irgendeiner Celery-Aufgabe vor?
    Bewusst als Textsuche über die ganze Inspektions-Antwort: `job_id` steht
    bei `rip_disc` an ZWEITER, bei `transcode_files` an ERSTER Stelle, und
    Celery liefert `args` je nach Version als Liste oder als Text. Eine
    Positions-Auswertung wäre an beidem zerbrechlich. Eine Job-ID ist eine
    36-stellige UUID — Fehltreffer sind praktisch ausgeschlossen.
    `inspektionen` ist die Liste der Antworten (active/reserved/scheduled);
    `None`-Einträge werden übersprungen.
    """
    vorhandene = [i for i in (inspektionen or []) if i]
    if not vorhandene:
        return set()
    text = repr(vorhandene)
    return {jid for jid in kandidaten if jid and jid in text}
 def antwortende_knoten(inspektionen) -> set:
    """Namen aller Celery-Knoten, die auf die Inspektion geantwortet haben."""
    knoten = set()
    for antwort in (inspektionen or []):
        if antwort:
            knoten.update(antwort.keys())
    return knoten
 def auskunft_vollstaendig(anzahl_antworten: int, anzahl_bekannt: int) -> bool:
    """Darf aus dieser Auskunft überhaupt ein Urteil folgen?
    Nein, wenn niemand geantwortet hat (dann wissen wir nichts), und nein, wenn
    weniger Knoten antworten als laut Herzschlag online sind (dann fehlt uns
    genau der Knoten, der den Job vielleicht gerade bearbeitet).
    """
    if anzahl_antworten < 1:
        return False
    return anzahl_antworten >= anzahl_bekannt
 def finde_zombies(offene_jobs, belegte) -> list:
    """Jobs aus `offene_jobs`, zu denen keine Celery-Aufgabe existiert."""
    return [job for job in offene_jobs if job.get("id") not in belegte]
 def fehlertext(job) -> str:
    """Ehrlicher Klartext für die Job-Karte — was war, und was jetzt hilft."""
    zuletzt = job.get("status") or "unbekannt"
    return (
        f"Abgebrochen: Der Vorgang lief nicht mehr (zuletzt gemeldet: {zuletzt}). "
        "Beim Start des Workers war dazu weder ein Prozess noch eine Aufgabe in "
        "der Warteschlange zu finden — meistens ein Absturz oder ein Neustart "
        "mitten im Lauf. Die Rohdateien wurden NICHT gelöscht: mit "
        "'Neu komprimieren' läuft die Kompression erneut, ohne die Disc noch "
        "einmal zu rippen."
    )
 def raeume_zombies_auf(celery_app, db) -> dict:
    """Sucht Leichen und setzt sie ehrlich auf `failed`. Wirft nie.
    Rückgabe (auch für den Log): was geprüft und was getan wurde.
    """
    bericht = {"geprueft": 0, "aufgeraeumt": [], "uebersprungen": ""}
    try:
        offene = db.list_jobs_mit_status(ARBEITS_STATI)
        bericht["geprueft"] = len(offene)
        if not offene:
            return bericht
        inspektor = celery_app.control.inspect(timeout=INSPEKT_TIMEOUT_SEKUNDEN)
        inspektionen = [inspektor.active(), inspektor.reserved(), inspektor.scheduled()]
        knoten = antwortende_knoten(inspektionen)
        bekannt = db.zaehle_online_worker()
        if not auskunft_vollstaendig(len(knoten), bekannt):
            bericht["uebersprungen"] = (
                f"unvollständige Auskunft ({len(knoten)} von {bekannt} Worker "
                "haben geantwortet) — es wird nichts als Leiche gewertet"
            )
            db.add_log(
                "info", "worker",
                f"Zombie-Erkennung übersprungen: {bericht['uebersprungen']}",
            )
            return bericht
        belegte = belegte_job_ids(inspektionen, [j.get("id") for j in offene])
        for job in finde_zombies(offene, belegte):
            db.update_job(
                job["id"],
                status="failed",
                error=fehlertext(job),
                finished_at=db.utcnow(),
            )
            db.add_log(
                "warning", "worker",
                f"Job {job['id']} ({job.get('title') or 'ohne Titel'}) stand auf "
                f"'{job.get('status')}', es arbeitet aber niemand daran — "
                "ehrlich auf 'failed' gesetzt. Rohdateien bleiben liegen.",
            )
            bericht["aufgeraeumt"].append(job["id"])
    except Exception as e:  # Erkennung darf den Worker-Start NIEMALS verhindern
        bericht["uebersprungen"] = f"Fehler: {e}"
        try:
            db.add_log("warning", "worker", f"Zombie-Erkennung fehlgeschlagen: {e}")
        except Exception:
            pass
    return bericht
Author	SHA1	Message	Date
Hitonabi	8394de6926	fix(transcode): "Abbrechen" wirkt sofort statt erst beim naechsten Prozent Ampel / ampel (push) Failing after 28s Details Fund des Commanders am laufenden Akira-Job (Nachtrag im vorigen Savepoint): Job stand auf 'canceling', HandBrake lief weiter. Gemessen 3,4 Minuten zwischen Anforderung (18:30:17) und Bestaetigung (18:33:38) - bei langsamerem Fortschritt entsprechend mehr. Ursache genau wie dort beschrieben: Der Abbruch wurde nur in datei_fortschritt geprueft, und diese Closure stieg oben sofort wieder aus, wenn sich die Prozentzahl nicht geaendert hatte ("if gesamt == letzter[0]: return"). Bei einem Prozent je halber Stunde hing der Abbruch also an einem Ereignis, das eine halbe Stunde lang nicht eintrat. run_handbrake bekommt jetzt einen eigenen abbruch_cb neben progress_cb - dasselbe Muster, das run_makemkv schon fuer log_cb benutzt, und aus demselben Grund: der Fortschritts-Kanal verwirft Aufrufe. Er wird bei JEDER Ausgabezeile aufgerufen und im Worker auf 5 s gedrosselt. Nebeneffekt, der genauso wichtig ist: Er greift auch waehrend des Scan-Durchlaufs, der ueberhaupt keine Encode-Prozente liefert. Dort war ein Abbruch vorher grundsaetzlich unmoeglich - und seit die Prozent-Regex den Scan korrekt ignoriert, waere das sonst sogar schlimmer geworden. Die Leseschleife ist als _handbrake_schleife() herausgezogen, damit die Reihenfolge (Abbruch VOR Fortschritt) ohne echtes HandBrake pruefbar ist. Der Test belegt: zwei Scan-Zeilen genuegen fuer den Abbruch, es muss NICHT auf eine Encode-Zeile gewartet werden. Savepoint nachgezogen: Der Encode laeuft nicht mehr, ein Deploy ist gefahrlos moeglich, und die alte "SOFORT ENTSCHEIDEN"-Passage (Platte laeuft voll, wenn der Job fertig wird) ist damit gegenstandslos. Neu darin: die drei Wege fuer UHD, und die Warnung, dass eine /proc-Suche nach "HandBrake" die eigene Shell mittrifft - zwei Fehlalarme in dieser Sitzung. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>	2026-07-25 21:10:03 +02:00
Hitonabi	574354131c	docs(savepoint): v3.14 - Durchsicht, mit den zwei eigenen Fehlschluessen SAVEPOINT bekommt den Stand v3.14: der unwirksame Platten-Schutz zuerst (wichtigster Fund), dann die gemessenen Werte, das Gebaute, die vier toten Endpunkte als Entscheidungsvorlage - und ein Abschnitt "SOFORT ENTSCHEIDEN". Der laufende Akira-Encode wird beim Fertigwerden mit dem DEPLOYTEN, alten Code versuchen, 75 GB in 37 GB zu kopieren. keepOriginal steht auf true, und den Wert hat die Aufgabe beim Start gelesen - jetzt umstellen aendert daran nichts mehr. Der Savepoint nennt die drei Optionen mit Empfehlung. Zwei Richtigstellungen an v3.13, beide durch Messung: - "progress=99 ist ein Altwert aus dem Absturz" war falsch. Beide Startpfade setzen auf 0; der Wert kam frisch vom Scan-Durchlauf. Ein Bug, kein Ueberrest. - Die Erwartung, _original_aufheben werde nur warnen, war falsch - siehe EXDEV-Fund im vorigen Commit. Ehrlich als OFFEN markiert: Was die Platte am 25.07. mittags fuellte, ist NICHT belegt. Es gibt keine Kopier-Reste, kein original-Verzeichnis und keinen einzigen Log-Eintrag von _original_aufheben, das in beiden Zweigen loggt. Der Mechanismus ist jetzt bewiesen, sein Zuschlagen an jenem Tag nicht. Lieber offen lassen als eine dritte Vermutung aufstellen. AGENTS bekommt Etappe 19 und einen neuen Abschnitt, der das wiederkehrende Muster benennt: nicht aus einem Zustandswert auf einen Mechanismus schliessen - vier belegte Faelle. Plus die Umkehrung, die diese Sitzung gekostet hat: gleiches st_dev heisst NICHT gleicher Mount. Was ausprobierbar ist, wird ausprobiert statt vorhergesagt. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>	2026-07-25 21:05:38 +02:00
Hitonabi	ef0a574a70	fix(worker,api): Platten-Schutz griff nicht, Fortschritt log, Auswurf tat nichts Vier Funde aus der Durchsicht, alle auf der VM gemessen. 1. DER PLATTEN-SCHUTZ AUS `c065967` WAR WIRKUNGSLOS _original_aufheben() entschied per os.stat().st_dev, ob umgehaengt oder kopiert werden muss. Im Worker-Container gemessen - beides gleichzeitig wahr: st_dev /app/temp = 2050 st_dev /app/media = 2050 → identisch os.rename(...) → EXDEV, "Invalid cross-device link" Der Kernel vergleicht bei rename() den MOUNT, nicht das Geraet. /app/temp (Docker-Volume) und /app/media (Bind-Mount) sind zwei Mounts DERSELBEN ext4-Partition. Die Pruefung sah "gleiches Dateisystem", uebersprang die Platzpruefung, und shutil.move kopierte doch - 75 GB bei 37 GB frei. Der Schutz haette genau den Schaden zugelassen, gegen den er gebaut wurde. Jetzt wird os.rename VERSUCHT statt vorhergesagt: klappt es, ist es umgehaengt und fertig; kommt EXDEV, steht die Kopie fest und ERST DANN wird der Platz geprueft. Das ist keine Vermutung mehr, sondern die Antwort des Kernels. Vier Tests in test_original_aufheben.py, darunter genau der Fall, der die Platte fuellte. Die zwei alten Tests in test_medien.py sind dorthin gewandert - sie taeuschten per gefaelschtem os.stat "verschiedene Dateisysteme" vor, also genau die Annahme, an der der Schutz scheiterte. 2. DIE FORTSCHRITTSANZEIGE ZEIGTE DEN SCAN, NICHT DEN ENCODE get_progress_from_line matchte jede Zahl vor einem Prozentzeichen. HandBrake gibt Prozente aber in drei Phasen aus (Formatstrings aus dem Binary gelesen): Scanning title %d of %d, preview %d, %.2f %% → laeuft VOR dem Encode bis 100 % Encoding: task %d of %d, %.2f %% (%.2f fps, avg → der echte Wert Encoding: task %d of %d, Searching for start time, ... → Vorlauf Dazu warf `if progress > 0` im Aufrufer jeden Wert unter 1,00 % weg. Live beobachtet: Anzeige stand auf 99 %, der Encode bei 1,06 %; sie fiel erst auf 1, als der Encode die 1-%-Marke ueberschritt. Jetzt wird nur die Encoding-Zeile gelesen, `task N of M` mitgerechnet (sonst springt die Anzeige bei Zwei-Pass-Presets mitten in der Datei zurueck), und -1 heisst "keine Angabe" - dasselbe Muster wie bei get_progress_from_prgv. 3. "AUTOMATISCHER AUSWURF" WURDE VON NIEMANDEM GELESEN Die Einstellung (Standard: ein, "Disc nach erfolgreichem Ripping automatisch auswerfen") kam in keiner Zeile Backend-Code vor. DVD/Blu-ray warfen deshalb NIE aus, Audio-CDs IMMER, weil abcde `-x` fest verdrahtet bekam. Jetzt entscheidet die Einstellung beides: wirf_disc_aus() per CDROMEJECT-ioctl (fcntl-guarded, der native Windows-Worker laedt das Modul auch) und `-x` nur noch, wenn gewuenscht. 4. PFAD-PRUEFUNG FIEL AUF PRAEFIX-NAMEN HEREIN Elf Stellen prueften mit nacktem startswith(MEDIA_ROOT). "/app/media-boese/x" beginnt mit "/app/media", liegt aber ausserhalb - betroffen waren auch /browse und /browse/mkdir, wo der Pfad vom Nutzer kommt. Neuer Zwillings-Helfer unter_wurzel() in api/main.py und worker/tasks.py, alle elf Stellen umgestellt, Tests in beiden. Nebenbefund: _zielbasis() benutzte os.path.normpath - unter Windows werden daraus Backslashes, die MEDIA_ROOT-Pruefung greift nicht mehr, und das gewaehlte Ziel faellt still auf den Standard zurueck. Genau die Falle, die _arbeitsverzeichnis() drei Zeilen weiter dokumentiert und mit posixpath vermeidet. Live war es nie (nur aus rip_disc, das auf Windows verriegelt ist), jetzt konsistent. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>	2026-07-25 21:05:11 +02:00
Hitonabi	883c1c290b	fix(caps,ui): Encoder werden gemessen statt behauptet Der Modulkopf von caps.py verspricht "ehrlich erkannt, nicht behauptet" - erkenne_encoder() tat aber drei Mal das Gegenteil: 1. cpu-x264 und cpu-x265 standen fest verdrahtet in der Liste ("immer dabei"). Ein Rip-Worker OHNE HandBrake behauptete damit, komprimieren zu koennen; jeder Transcode dort endete sofort mit "nicht installiert". 2. 'vaapi' wurde allein wegen /dev/dri gemeldet, ohne zu pruefen, ob HandBrake das ueberhaupt kann. Auf der VM gemessen: das Worker-Image kennt svt_av1/x264/x265/mpeg4/mpeg2/VP8/VP9/theora und KEINEN einzigen Hardware-Encoder. Rippy haette VAAPI versprochen und dann versagt. 3. Ueber die Rechenleistung sagte es gar nichts. Genau deshalb war nicht zu sehen, dass ein 4K-Encode auf dieser Maschine Tage braucht: CPU-Modell ist das generische "QEMU Virtual CPU version 2.5+", grep -c avx2 /proc/cpuinfo = 0, nur bis sse4_2. x265 lebt von AVX2. Gemessen an der Leseposition des Quellstroms: 28-55 h fuer einen Film, 3,84 von 4 Kernen gesaettigt. Abhilfe waere der CPU-Typ 'host' in Proxmox. Jetzt wird die Encoder-Liste aus `HandBrakeCLI --help` geparst (Abschnitt -e/--encoder, Formatstrings im Worker-Image gemessen - AGENTS Regel D), und Hardware zaehlt nur, wenn Geraet UND HandBrake-Unterstuetzung da sind. Neu gemeldet: cpu-av1 (svt_av1 ist wirklich verfuegbar) sowie CPU-Modell, Kernzahl und Vektorbefehlsstufe je Worker. UI: Kerne/Vektorbefehle stehen bei jedem Worker (Worker-Tab und Einstellungen -> System), dazu die ungefilterte HandBrake-Auskunft und eine sichtbare Warnung, wenn AVX2 fehlt - inklusive des Hinweises auf den VM-CPU-Typ. Der Warntext liegt in lib/encoder.ts, damit er nicht doppelt im Code steht. Mit im gleichen Zug (dieselbe Datei): der Schalter "Alle Tracks rippen" ist entfallen. Er war ein Placebo - abcde bekommt keine Track-Auswahl und es gab auch keine Oberflaeche, um eine Teilmenge zu waehlen. Eine Audio-CD wurde also immer vollstaendig gerippt, egal wie der Schalter stand. An seiner Stelle steht jetzt die Wahrheit. 7 Tests, Testdaten sind echte HandBrake-Ausgaben von der VM. Der Parser ist zusaetzlich gegen die vollen 697 Zeilen der echten --help gegengeprueft. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>	2026-07-25 21:04:42 +02:00
Hitonabi	e0cb7b3ddc	feat(worker): Zombie-Erkennung - Jobs, an denen niemand arbeitet Nach einem Absturz oder Rebuild blieb ein Job auf 'transcoding' stehen, obwohl weder ein Prozess lief noch etwas in den Queues stand. Folge: keine Anzeige, kein Download - und der Knopf "Neu komprimieren" fehlte, weil _kann_neu_komprimieren (api/main.py) status=='failed' verlangt. Der Job war unerreichbar, obwohl die Rohdateien vollstaendig dalagen. zombies.py haelt beim Worker-Start die Jobs in 'ripping'/'transcoding'/ 'canceling' gegen Celerys active/reserved/scheduled und setzt sie ehrlich auf 'failed', wenn niemand daran arbeitet. Drei Sicherungen, weil ein falsch getoeteter Job teurer ist als eine stehengebliebene Leiche: - nur beim Start (da ist "es lief nichts" eindeutig; ein periodischer Lauf koennte einen Job erwischen, der legitim in der Warteschlange wartet) - 120 s Gnadenfrist (Celery stellt unbestaetigte Aufgaben erneut zu) - Vollzaehligkeit: antworten weniger Knoten als laut Herzschlag online sind, wird NICHTS gewertet - sonst waere der laufende Job eines beschaeftigten Remote-Workers eine falsche Leiche Die Job-ID wird per Textsuche ueber die Inspektions-Antwort gefunden, nicht per Position: sie steht bei rip_disc an zweiter, bei transcode_files an erster Stelle, und Celery liefert args je nach Version als Liste oder Text. 13 Tests ohne Postgres/Redis, darunter "laufender Job wird nicht angetastet" und "schweigender Worker verhindert jedes Urteil". Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>	2026-07-25 21:04:19 +02:00