fix(tests): Vorgabe-Test ohne den entfernten USERPROFILE-Zweig

Der Test verlangte den Windows-Sonderzweig von ablage_vorgabe, der mit
Entscheid 7 gegangen ist — lokal (Windows) blieb er zufaellig gruen,
weil expanduser('~') dort auf USERPROFILE zeigt; die Linux-Ampel hat es
gemerkt. Er prueft jetzt die neue Wirklichkeit: nativ = Benutzerordner
DIESER Maschine.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

AGENTS.md

@@ -29,6 +29,29 @@ rot heißt: nicht deployen). Nie freihändig per SSH auf der VM bauen.
 Bibliotheks-APIs: `--help`/Doku prüfen und die Fundstelle im Commit nennen.
 (Vorgefallen: erfundene Celery-Methode `self.send_task`, erfundene abcde-Flags.)
 
+### Zwei Schreibfallen, die am 28.08.2026 mehrfach gekostet haben
+
+**1. Deutsche Anführungszeichen in doppelt gequoteten Zeichenketten.**
+Das öffnende `„` ist U+201E und harmlos. Das schließende ist das **gerade
+ASCII-Zeichen** `"` — es beendet die Python-Zeichenkette. Der Fehler erscheint
+dann am Gedankenstrich dahinter, also an einer Stelle, an der nichts falsch
+ist. An einem Tag vier Mal passiert.
+
+    falsch:   "einen Ordner unter „Benutzer" wählen"
+    richtig:  'einen Ordner unter „Benutzer" wählen'
+
+**Regel: Steht ein `„` in der Zeichenkette, gehört sie in EINFACHE
+Anführungszeichen.**
+
+**2. Bash-Heredocs mit Windows-Pfaden.** `<<'EOF'` sollte literal sein,
+halbiert in dieser Umgebung aber Backslashes — aus `C:\\Users` wird `C:\Users`,
+und das ist eine ungültige Escape-Sequenz. An einem Tag fünf Mal passiert,
+zuletzt beim Schreiben genau dieses Absatzes.
+
+**Regel: Dateien mit Windows-Pfaden oder Umlauten mit dem Write-Werkzeug
+schreiben, nicht per Heredoc.** Wo es doch sein muss: Backslashes über
+`chr(92)` zusammensetzen.
+
 ## Workflow
 
 1. **Read:** KONZEPT.md + ROADMAP.md lesen. Verstehen, welche Etappe dran ist.

KONZEPT-V2.md

@@ -1267,8 +1267,207 @@ Eingabemaske — nur der Knopf „Verbinden" wird zu „Zeile kopieren".
 `apparmor:unconfined`, `propagation: rshared` und die Mount-Wache fallen in
 V2-5 ersatzlos weg.
 
+### Entscheid 4 — Echtes Fenster statt Browser-Tab, aber ohne Electron
+
+Nachgefragt vom Commander am 28.08.2026:
+
+> „Warum nutzen wir für Windows weiterhin einen Browser? Warum nutzen wir kein
+> Electron oder sowas und machen daraus einen echten Client?"
+
+Die erste Hälfte trifft zu und wird umgesetzt: Ein Browser-Tab ist kein Client.
+Er hat eine Adresszeile, die niemand braucht, liegt zwischen fremden Tabs, hat
+kein eigenes Symbol in der Taskleiste, und wer den Browser schließt, glaubt, er
+habe Rippy beendet.
+
+Die zweite Hälfte wird **abgelehnt**, und zwar gemessen statt geschätzt:
+
+| Weg | Zusatz zum Paket | Was mitkommt |
+|-----|------------------|--------------|
+| **pywebview + WebView2** | **8,0 MB** | nur die Anbindung; der Renderer liegt schon auf dem System |
+| Electron | ~150–210 MB | ein komplettes zweites Chromium **und** eine zweite Laufzeitumgebung neben Python |
+
+Windows 11 liefert die WebView2-Laufzeit mit. Auf dem Rechner des Commanders am
+28.08.2026 nachgesehen: **151.0.4129.107**. Und nachgemessen, was sie wirklich
+rendert — nicht angenommen:
+
+```
+navigator.userAgent   …Chrome/151.0.0.0 Safari/537.36 Edg/151.0.0.0
+fetch  ja      EventSource  ja      CSS Grid  ja      Pfeilfunktionen  ja
+```
+
+Das ist dasselbe Chromium, das auch in Electron steckt. Rippy bekommt also
+denselben Renderer, nur ohne ihn ein zweites Mal mitzuschleppen. Damit bleibt
+auch § 4.1 unverändert gültig — dort stand WebView2 von Anfang an.
+
+**Drei Dinge gehören zum Entscheid, nicht als Beiwerk:**
+
+1. **Kein stiller Rückfall auf MSHTML.** `pywebview` kann unter Windows auch den
+   alten IE-Renderer nehmen; der stellt die React-Oberfläche nicht dar. Fehlt
+   die WebView2-Laufzeit, öffnet Rippy **den Browser** und sagt warum — ein
+   leeres Fenster wäre schlimmer als ein Tab.
+2. **Fenster und Tray sind getrennte Prozesse.** `pystray` belegt unter Windows
+   den Haupt-Thread, das WebView2-Fenster braucht ihn genauso; zwei
+   Nachrichtenschleifen passen nicht in einen Thread. `--dienst` hält Server und
+   Tray, `--oeffnen` ist der Client davor. Beide heißen im Taskmanager
+   `Rippy.exe`, und das Fenster lässt sich schließen, ohne den Dienst
+   mitzureißen.
+3. **Die eigene Konsole wird versteckt, eine geerbte nie.** `Rippy.exe` ist ein
+   Konsolenprogramm, weil der Installer seine Meldungen zeigen muss. Beim
+   Doppelklick auf das Desktop-Symbol blitzte damit erst eine schwarze Box auf.
+   `GetConsoleProcessList` unterscheidet beides: genau ein Prozess an der
+   Konsole heißt, sie gehört uns.
+
+**Folge für den Plan:** Kein neuer Etappen-Punkt — das ist Teil von V2-4 und
+dort erledigt. `src/rippy/fenster.py` trägt die vollständige Begründung.
+
+### Entscheid 5 — Die Werkzeuge gehören ins Setup, nicht in eine Fehlermeldung
+
+Der Commander am 28.08.2026:
+
+> „handbrake und makemkv MÜSSEN mitgeliefert werden oder während des Setups
+> separat installiert werden! Ohne das ist das tool NICHT einsatzfähig"
+
+Er hat recht, und die Lücke war real: `katalog.py` konnte die Werkzeuge
+finden, `beschaffen.py` konnte sie holen — **das Setup rief beides nie auf.**
+Wer Rippy auf einem frischen Rechner installierte, bekam eine Oberfläche, die
+ihm mitteilte, was fehlt, und keinen Weg, es zu ändern.
+
+Die beiden gehen unterschiedliche Wege, und der Grund ist die **Lizenz**,
+nicht die Bequemlichkeit:
+
+| | Weg | Warum |
+|---|---|---|
+| **HandBrakeCLI** | **mitgeliefert** (+35 MB) | GPL-2 erlaubt die Weitergabe ausdrücklich, solange Lizenztext und Quellverweis dabei sind. `LIZENZ-HandBrake.txt` liegt daneben. Damit komprimiert Rippy auch ohne Internet. |
+| **MakeMKV** | **beim Einrichten geholt** | Proprietär — die Lizenz erlaubt Dritten keine Weitergabe. Rippy lädt die offizielle Datei vom Hersteller und startet dessen Installer. Der Nutzer bezieht sie also weiterhin von MakeMKV; Rippy nimmt ihm nur die Handgriffe ab. |
+
+Das deckt sich mit § 4.1 („MakeMKV wird NICHT mitgeliefert") und mit der
+Black-Box-Trennung aus `KONZEPT.md` § 6. Beides bleibt gültig.
+
+**Drei Regeln, die zum Entscheid gehören:**
+
+1. **Ein Setup meldet nie Erfolg, während ein Pflichtwerkzeug fehlt.**
+   `einrichten.sicherstellen()` liest den Bestand VOR und NACH dem Versuch
+   und gibt zurück, was danach wirklich da ist — nicht, dass es versucht
+   wurde.
+2. **Ein nicht erreichbarer Download bricht die Installation nicht ab.** Am
+   28.08.2026 antwortete makemkv.com mit HTTP 525. Rippy ist dann trotzdem
+   installiert und sagt im Klartext, was fehlt und wie man es beschafft.
+3. **Ohne HandBrake ist Rippy einsatzbereit, ohne MakeMKV nicht.** Ein Rip
+   läuft ohne Kompression durch — das ist ein vorgesehener Betriebsfall.
+   Ohne MakeMKV ist Rippy ein Anzeigeprogramm. Nur `pflicht`-Werkzeuge
+   entscheiden über „einsatzbereit".
+
+**Nicht im Repo:** Die 70,9 MB HandBrakeCLI holt der **Bau** nach
+`dist/windows/vendor/` (nicht versioniert) — dasselbe Muster wie der
+`vendor/`-Ordner für MakeMKV auf der VM. Ein Binärblob in git wäre bei jedem
+Klon dabei und bei jedem Update ein zweites Mal.
+
+
+### Entscheid 6 — Die Oberfläche kennt ihren Betrieb, und das Setup fragt
+
+Zwei Befunde des Commanders am 28.08.2026, beide am selben Punkt:
+
+> „Du hast ja quasi nur rippy genommen und die docker installation für Windows
+> gebaut. […] Das gilt für die ganze standalone version für Windows, auch für
+> die settings und die Anleitung usw."
+
+> „Dann hätte ich beim ‚Setup' auch erwartet das nen echtes setup passiert —
+> wo will ich das hinspeichern, nen pre requirement check usw. Da kommt
+> garnichts Rippy geht einfach auf."
+
+#### 6a — Fähigkeiten statt Modus-Name
+
+Im Windows-Fenster stand `Worker erreichbar: 0 von 1`, `Container-Platte:
+unbekannt` und `Prüfen: docker compose ps`. Kein Satz davon ergibt dort einen
+Sinn.
+
+Die naheliegende Reparatur wäre ein `if (windows)` an dreißig Stellen gewesen
+— dieselbe Falle noch einmal, nur mit einer zweiten Sorte Vermutung. Es
+fehlte etwas anderes: **Das UI hat nie erfahren, worauf es läuft.**
+
+`GET /betrieb` meldet deshalb **Fähigkeiten**, keinen Namen:
+
+    externe_worker        Gibt es andere Maschinen, die Jobs übernehmen?
+    freigaben_einhaengen  Kann Rippy Netzwerk-Freigaben selbst einhängen?
+    container_pfade       Sind Pfade wie /app/media überhaupt gemeint?
+    werkzeuge_verwalten   Kann Rippy MakeMKV/HandBrake selbst beschaffen?
+
+Ein Modus-Name würde das UI zwingen, aus einem Namen auf Verhalten zu
+schließen — und das bricht beim nächsten Betriebsfall: Ein Docker-All-in-One
+hat Container-Pfade, aber keinen zweiten Worker.
+
+#### 6b — Ein Setup, das prüft und fragt
+
+Acht Voraussetzungs-Prüfungen, zwei Ordner-Wahlen (Programm **und** Ablage),
+Port, drei Schalter. Drei Regeln:
+
+1. **Nur ein Fehler blockiert.** Eine Warnung, die den Knopf sperrt, ist eine
+   Bevormundung; ein Fehler, der nur warnt, ist eine Falle. Kein optisches
+   Laufwerk ist eine Warnung — eine reine Komprimier-Maschine ist ein
+   vorgesehener Betriebsfall.
+2. **Jeder Befund sagt, was zu tun ist.** Ein Test hält das für jede Prüfung
+   fest.
+3. **Die Prüfungen kennen kein Fenster.** Sie stehen in `einrichtung.py` und
+   sind vollständig ohne WebView2 prüfbar; im Fenstermodul steht nur Aufbau
+   und Brücke.
+
+WebView2 statt Win32-Dialog: Es ist wegen Entscheid 4 ohnehin da — der
+Assistent kostet **null zusätzliche Bytes**. Die Seite lädt nichts aus dem
+Netz; sie muss auf einem Rechner ohne Internet aufgehen.
+
+
+#### 5a — Ausweichquellen für MakeMKV (28.08.2026, nachgetragen)
+
+Der Commander: *„bitte baue für MakeMKV fallback seiten ein."* Anlass war ein
+echter Ausfall. Gemessen:
+
+    https://www.makemkv.com/download/   HTTP 525   (dauerhaft)
+    https://forum.makemkv.com/          Zeitablauf / 522 / OK  (wechselnd)
+    web.archive.org/web/2025id_/…exe    HTTP 200, 16.432.607 Bytes
+
+525/522 heißen: Cloudflare erreicht den Ursprungsserver nicht. Eine Störung
+beim Hersteller, nichts, was Rippy reparieren könnte.
+
+**Die Kette, in dieser Reihenfolge:**
+
+| | Version | Datei |
+|---|---|---|
+| eigene Quelle (`basis`) | — | zuerst, wer sie einträgt hat sich etwas dabei gedacht |
+| Hersteller-Seite | **maßgeblich** — wer sie erreicht, sucht nicht weiter | ja |
+| Hersteller-Forum | ja (Ankündigungs-Bereich) | — |
+| Internet Archive | ja (Rückfall) | ja |
+
+Zwei Feinheiten, beide aus Messungen:
+
+* **Die höchste Nummer gewinnt, nicht die erste.** Antwortet das Forum nicht,
+  meldet das Archiv einen älteren Stand (1.18.2 statt 1.18.4) — „neueste
+  Fassung" wäre dann eine falsche Aussage.
+* **Ein zweiter Anlauf, mit knapper Zeitgrenze.** Drei Abrufe am Forum:
+  Zeitablauf, HTTP 522, dann Erfolg. Ohne Wiederholung fiel die Quelle in
+  zwei von drei Fällen aus; mit 20-Sekunden-Grenzen dauerte der schlimmste
+  Fall 46 Sekunden, in denen das Setup eingefroren aussah. Jetzt: acht
+  Sekunden je Versuch, schlimmstenfalls gut zwanzig insgesamt.
+
+**Und warum das trotzdem sicher ist.** Der naheliegende Schutz geht nicht:
+MakeMKV **signiert seinen Installer nicht** (`Get-AuthenticodeSignature` →
+`NotSigned`, an der echten Datei gemessen). Eine Signaturprüfung wäre eine,
+die immer fehlschlägt. Geprüft wird stattdessen die Versions-Ressource:
+
+    CompanyName      GuinpinSoft inc
+    FileDescription  MakeMKV installer
+    FileVersion      v1.18.4
+
+Das ersetzt keine Signatur — wer die Datei fälscht, fälscht auch die
+Ressource. Es fängt aber zuverlässig ab, was hier wirklich droht: eine
+Fehlerseite mit `.exe`-Namen, ein abgebrochener Download, eine falsche
+Fassung. Und Rippy nennt hinterher die Quelle, aus der die Datei kam.
+
+**Die Grenze aus `KONZEPT.md` § 6 bleibt unangetastet:** Rippy liefert
+MakeMKV weiterhin NICHT mit. Es holt die Datei des Herstellers — im
+Rückfall aus einem Archiv, das genau diese Datei aufbewahrt.
 ---
 
+
 ### Was jetzt noch fehlt, bevor gebaut wird
 
 - **`KONZEPT.md` § 10 fortschreiben** — Entscheid 2 widerspricht dem Eintrag vom

ROADMAP.md

@@ -619,15 +619,58 @@ Medien.
       plus Worker) UND ein Verbindungsabriss keine Liste leert.
 
 ### V2-4: Windows nativ
-- [ ] `drives/windows.py` — Win32 statt ioctl (`IOCTL_STORAGE_CHECK_VERIFY2`,
+- [x] `drives/windows.py` — Win32 statt ioctl (`IOCTL_STORAGE_CHECK_VERIFY2`,
       `IOCTL_STORAGE_MEDIA_REMOVAL`, `IOCTL_STORAGE_EJECT_MEDIA`,
       MMC `GET CONFIGURATION` für den Disc-Typ)
-- [ ] Disc-Einwurf per `WM_DEVICECHANGE` statt Polling
-- [ ] Dienst (WinSW) + Tray als GETRENNTE Prozesse; WebView2-Fenster
-- [ ] Nuitka `--standalone` (one-dir, nicht one-file) + Inno Setup
+- [ ] Disc-Einwurf per `WM_DEVICECHANGE` statt Polling — **offen**, läuft
+      vorerst über den Poll aus `drives/detection.py`
+- [x] Dienst + Fenster als GETRENNTE Prozesse; **WebView2-Fenster**
+      (`fenster.py`, Entscheid 4 in `KONZEPT-V2.md` § 10)
+- [x] Eintrag in „Programme und Features" und im Taskmanager als `Rippy.exe`
+      (ausdrücklicher Wunsch des Commanders)
+- [x] Desktop-Symbol und Startmenü-Eintrag, im Setup abschaltbar
+- [x] Werkzeug-Erkennung und -Beschaffung (`tools/katalog.py`,
+      `tools/beschaffen.py`) — Rippy findet, holt und aktualisiert
+      HandBrake/MakeMKV selbst
+- [x] **Das Setup richtet die Werkzeuge wirklich ein** (`tools/einrichten.py`,
+      Entscheid 5) — HandBrakeCLI liegt im Paket (GPL-2), MakeMKV wird beim
+      Einrichten vom Hersteller geholt. Ein Setup, dem ein Pflichtwerkzeug
+      fehlt, meldet das im Klartext statt Erfolg.
+- [x] Symbol mit allen Größen, die Windows holt (16/32/48/256) — vorher steckte
+      nur 256×256 in der `.ico`, und Desktop, Startmenü und Taskleiste zeigten
+      ein leeres Blatt
+- [x] **Ein echtes Setup** (`einrichtung.py`, `setup_fenster.py`): acht
+      Voraussetzungs-Prüfungen, Zielordner UND Ablage zur Wahl, Port,
+      Autostart/Verknüpfungen/Werkzeuge als Schalter. Vorher installierte der
+      Doppelklick stillschweigend und öffnete das Fenster.
+- [x] **Die Oberfläche kennt ihren Betrieb** (`betrieb.py`, `GET /betrieb`,
+      `useBetrieb.tsx`): keine Worker-Zähler, keine Container-Platte, kein
+      `docker compose ps` mehr im Windows-Client — und der Docker-Betrieb
+      behält alles.
 - [ ] Standby blocken via `SetThreadExecutionState`, ohne `ES_DISPLAY_REQUIRED`
+      — **offen**
 - **Fertig, wenn:** auf einem frischen Win-11-Rechner gilt: Installer →
       Disc rein → MKV raus. Und der UHD-Schlüssel kommt automatisch.
+      **Noch offen:** ein echter Rip auf Windows ist ungeprüft — das Laufwerk
+      hängt an der VM.
+
+> **Abweichung vom Plan, bewusst und mit Folgen.** Statt Nuitka `--standalone`
+> (one-dir) + Inno Setup wurde **PyInstaller onefile** genommen: ein Programm,
+> drei Betriebsarten (`RippySetup.exe`, `--dienst`, `--deinstallieren`), kein
+> zweites Werkzeug in der Kette.
+>
+> Der Preis stand oben schon im Plan — *„ein Onefile-Paket entpackt sich bei
+> jedem Start neu nach `%TEMP%`"* — und er ist am 28.08.2026 fällig geworden:
+> Ein Dienst lief eine Stunde, `/api/health` gab 200, `/` gab **404**. Vom
+> Entpack-Verzeichnis des laufenden Prozesses waren 31 statt 44 Einträge übrig,
+> `ui` und `api` fehlten. Die API meldete sich gesund, während die Oberfläche
+> weg war.
+>
+> **Gegenmaßnahme:** Der Installer legt die Oberfläche als Kopie NEBEN das
+> Programm (`windows_app.ui_auspacken`), und `daemon._ui_pfad()` nimmt diese
+> Kopie vor dem Entpack-Verzeichnis. Zwei Tests halten das fest. Sollte sich
+> derselbe Ausfall an den API-Modulen zeigen, ist one-dir die richtige Antwort
+> — dann ist diese Abweichung zurückzunehmen.
 
 ### V2-5: Docker neu
 - [ ] EIN Image, drei Profile (`standalone`, `api`, `node`)

docker/api/cache/cache.py

@@ -1,42 +1,122 @@
-"""Cache module."""
+"""Zwischenspeicher für API-Antworten — mit Redis, wenn es eins gibt.
+
+## Warum das nicht mehr scheitern darf (Befund 28.08.2026)
+
+Hier stand ein nacktes `redis_client.get(key)`. Der Vorgabe-Host ist `redis`
+— der Dienstname aus `docker-compose.yml`. Im Container stimmt das; auf einem
+Windows-PC gibt es kein Redis, und jeder Aufruf endete mit:
+
+    redis.exceptions.ConnectionError: Error 11001 connecting to redis:6379
+
+Das riss den Pre-Scan mit. Der Commander sah die Folge, nicht die Ursache:
+Eine eingelegte Blu-ray blieb namenlos, und die Metadaten-Suche lief nie an.
+
+**Ein Zwischenspeicher ist eine Beschleunigung, keine Voraussetzung.** Ist
+keiner da, wird eben jedes Mal neu gefragt — TMDB und OMDb halten das aus.
+Deshalb fängt jeder Zugriff hier den Verbindungsfehler ab und tut so, als
+wäre der Eintrag nicht vorhanden. Das ist genau die Wahrheit: Er ist es
+nicht.
+
+## Warum trotzdem einmal gemeldet wird
+
+Ein Zwischenspeicher, der still nie greift, ist eine unsichtbare
+Verlangsamung — und auf der VM wäre ein weggefallenes Redis ein echter
+Befund. Deshalb sagt `zustand()`, woran man ist, und die erste fehlgeschlagene
+Verbindung schreibt eine Zeile. Danach Ruhe: Eine Meldung je Anfrage wäre
+Lärm.
+"""
 
-from redis import Redis
-from typing import Any, Optional
 import json
 import os
+from typing import Any, Optional
+
+from redis import Redis
+from redis.exceptions import RedisError
 
 redis_host = os.getenv("REDIS_HOST", "redis")
 redis_port = int(os.getenv("REDIS_PORT", "6379"))
 
-redis_client = Redis(host=redis_host, port=redis_port, decode_responses=True)
+# Kurze Zeitgrenzen: Ein Zwischenspeicher, auf den man wartet, ist keiner.
+# Ohne sie hing jeder Aufruf am Standard-Timeout der Bibliothek.
+redis_client = Redis(host=redis_host, port=redis_port, decode_responses=True,
+                     socket_connect_timeout=1.5, socket_timeout=1.5)
+
+# Erst beim ersten Zugriff bekannt. None = noch nichts versucht.
+_erreichbar: Optional[bool] = None
+
+
+def _melde_einmal(fehler: Exception) -> None:
+    """Beim ERSTEN Fehlschlag eine Zeile, danach Ruhe."""
+    global _erreichbar
+    if _erreichbar is False:
+        return
+    _erreichbar = False
+    print("Zwischenspeicher (%s:%s) nicht erreichbar — es wird ohne "
+          "gearbeitet: %s" % (redis_host, redis_port, fehler))
+
+
+def zustand() -> dict:
+    """Woran man ist. Für Diagnose und Selbstauskunft."""
+    return {"host": redis_host, "port": redis_port, "erreichbar": _erreichbar}
 
 
 def init_cache() -> None:
-    """Initialize cache connection."""
-    pass
+    """Einmal anklopfen, damit der Zustand bekannt ist. Wirft nie."""
+    global _erreichbar
+    try:
+        redis_client.ping()
+        _erreichbar = True
+    except (RedisError, OSError) as e:
+        _melde_einmal(e)
 
 
 def get(key: str) -> Optional[Any]:
-    """Get value from cache."""
-    value = redis_client.get(key)
+    """Wert aus dem Zwischenspeicher. None = nicht da ODER kein Speicher."""
+    global _erreichbar
+    try:
+        value = redis_client.get(key)
+    except (RedisError, OSError) as e:
+        _melde_einmal(e)
+        return None
+    _erreichbar = True
     if value:
-        return json.loads(value)
+        try:
+            return json.loads(value)
+        except (TypeError, ValueError):
+            # Ein kaputter Eintrag ist kein Grund, den Aufrufer scheitern zu
+            # lassen — er holt sich die Antwort dann eben frisch.
+            return None
     return None
 
 
 def set(key: str, value: Any, expire: Optional[int] = None) -> bool:
-    """Set value in cache."""
-    serialized = json.dumps(value)
-    if expire:
-        return redis_client.setex(key, expire, serialized)
-    return redis_client.set(key, serialized)
+    """Wert ablegen. False heißt: ging nicht — und das ist in Ordnung."""
+    global _erreichbar
+    try:
+        serialized = json.dumps(value)
+        if expire:
+            return bool(redis_client.setex(key, expire, serialized))
+        return bool(redis_client.set(key, serialized))
+    except (RedisError, OSError) as e:
+        _melde_einmal(e)
+        return False
+    except (TypeError, ValueError):
+        # Nicht serialisierbar. Das ist ein Fehler des Aufrufers, aber keiner,
+        # der eine Metadaten-Abfrage umwerfen darf.
+        return False
 
 
 def delete(key: str) -> bool:
-    """Delete value from cache."""
-    return redis_client.delete(key)
+    try:
+        return bool(redis_client.delete(key))
+    except (RedisError, OSError) as e:
+        _melde_einmal(e)
+        return False
 
 
 def clear() -> bool:
-    """Clear all cache."""
-    return redis_client.flushdb()
+    try:
+        return bool(redis_client.flushdb())
+    except (RedisError, OSError) as e:
+        _melde_einmal(e)
+        return False

docker/api/clients/omdb.py

@@ -33,8 +33,13 @@ def parse_year(year: str) -> Optional[int]:
 class OMDbClient:
     def __init__(self):
         # DB-Einstellung (Settings-UI/Wizard) gewinnt gegen die Env-Variable
-        from db import get_settings
-        self.api_key = get_settings().get("omdbApiKey") or settings.omdb_api_key
+        # ⚠️ rippy.store, NICHT db (Befund 28.08.2026). docker/api/db.py
+        # gibt es seit V2-1 (dd1d0b7) nicht mehr — main.py schreibt seitdem
+        # "from rippy import store as db", dieses Modul hat es nie
+        # mitbekommen. Jede Abfrage starb beim Erzeugen des Clients, und
+        # _auto_prescan verschluckte es. Siehe clients/tmdb.py.
+        from rippy.store import get_settings
+        self.api_key = get_settings(bei_fehler_leer=True).get("omdbApiKey") or settings.omdb_api_key
         self.session = requests.Session()
 
     def suche(self, title: str) -> list:

docker/api/clients/thetvdb.py

@@ -13,8 +13,13 @@ THETVDB_BASE_URL = "https://api.thetvdb.com"
 class TheTVDBClient:
     def __init__(self):
         # DB-Einstellung (Settings-UI/Wizard) gewinnt gegen die Env-Variable
-        from db import get_settings
-        self.api_key = get_settings().get("tvdbApiKey") or settings.thetvdb_api_key
+        # ⚠️ rippy.store, NICHT db (Befund 28.08.2026). docker/api/db.py
+        # gibt es seit V2-1 (dd1d0b7) nicht mehr — main.py schreibt seitdem
+        # "from rippy import store as db", dieses Modul hat es nie
+        # mitbekommen. Jede Abfrage starb beim Erzeugen des Clients, und
+        # _auto_prescan verschluckte es. Siehe clients/tmdb.py.
+        from rippy.store import get_settings
+        self.api_key = get_settings(bei_fehler_leer=True).get("tvdbApiKey") or settings.thetvdb_api_key
         self.base_url = THETVDB_BASE_URL
         self.session = requests.Session()
         self.session.headers.update({

docker/api/clients/tmdb.py

@@ -24,8 +24,20 @@ class TMDBClient:
     def __init__(self):
         # DB-Einstellung (Settings-UI/Wizard) gewinnt gegen die Env-Variable —
         # vorher war das Settings-Feld reine Dekoration (Fix 23.07.).
-        from db import get_settings
-        self.api_key = get_settings().get("tmdbApiKey") or settings.tmdb_api_key
+        # ⚠️ rippy.store, NICHT db (Befund 28.08.2026).
+        #
+        # Hier stand "from db import get_settings". docker/api/db.py gibt es
+        # seit der Zusammenlegung in V2-1 (dd1d0b7) nicht mehr — main.py
+        # schreibt seitdem "from rippy import store as db", aber dieses Modul
+        # hat das nie mitbekommen. Die Folge: JEDE Metadaten-Abfrage starb
+        # schon beim Erzeugen des Clients mit ModuleNotFoundError, und
+        # _auto_prescan verschluckte das in seinem "except Exception". Discs
+        # blieben namenlos — auf Windows UND auf der VM.
+        #
+        # bei_fehler_leer=True: Ohne Datenbank gilt der Schlüssel aus der
+        # Umgebung. Ein Metadaten-Client ist kein Grund, warum nichts geht.
+        from rippy.store import get_settings
+        self.api_key = get_settings(bei_fehler_leer=True).get("tmdbApiKey") or settings.tmdb_api_key
         self.session = requests.Session()
         self.session.headers.update({"Content-Type": "application/json"})
         # Beide Key-Arten unterstützen (developer.themoviedb.org: v3 als

docker/api/eta.py

@@ -111,13 +111,44 @@ def schluessel(job_id: str) -> str:
     return f"eta:{job_id}"
 
 
+#: Messreihen im eigenen Prozess — der Rückfall, wenn es kein Redis gibt.
+#:
+#: ## Der Befund des Commanders (29.08.2026)
+#:
+#: > „Über den kompletten vorgang steht dort ‚Restzeit wird gemessen' aber
+#: > messung wird nicht abgeschlossen. Das heißt man hat kein ETA"
+#:
+#: Die Messreihe lag ausschließlich im Cache, und der Modul-Kopf sagte dazu:
+#: „Der Cache (Redis) ist schon da". Im Container stimmt das. Auf einem
+#: Windows-PC gibt es kein Redis — `cache_get` gab bei JEDEM Aufruf `None`
+#: zurück, `beobachtung_hinzufuegen` legte also jedes Mal eine frische Reihe
+#: mit EINEM Punkt an, und `restzeit_sekunden` braucht `MINDEST_PUNKTE = 2`.
+#: Ergebnis: über den ganzen Rip hinweg „noch keine Aussage".
+#:
+#: Ein Wörterbuch im Prozess reicht hier vollkommen: Die Reihe ist ein paar
+#: Zahlen, sie gilt nur für die Dauer eines Jobs, und im eigenständigen
+#: Betrieb gibt es ohnehin nur diesen einen Prozess. Redis bleibt der bessere
+#: Ort, wo es eins gibt — es überlebt einen API-Neustart.
+_REIHEN: dict = {}
+
+#: Wie lange eine Reihe im Prozess aufgehoben wird (wie `expire` im Cache).
+REIHE_HALTBAR_SEKUNDEN = 86400
+
+
+def _aufraeumen(jetzt: float) -> None:
+    """Alte Reihen wegwerfen — sonst waechst das Woerterbuch unbegrenzt."""
+    for k, (stand, _) in list(_REIHEN.items()):
+        if jetzt - stand > REIHE_HALTBAR_SEKUNDEN:
+            _REIHEN.pop(k, None)
+
+
 def aktualisiere_und_schaetze(job_id: str, status: str, progress: int,
                              jetzt: float, cache_get, cache_set) -> dict:
-    """Messreihe im Cache fortschreiben und die Restzeit zurückgeben.
+    """Messreihe fortschreiben und die Restzeit zurückgeben.
 
-    Der Cache (Redis) ist schon da und überlebt einen Neustart des UI. Fällt er
-    aus, kommt bei jedem Aufruf eine leere Reihe zurück — dann gibt es eben
-    keine ETA, aber nichts scheitert.
+    Gespeichert wird in BEIDEN Ablagen: im Cache, wo es einen gibt (er
+    überlebt einen API-Neustart), und im Prozess, damit die Schätzung auch
+    ohne Redis zustande kommt. Siehe `_REIHEN`.
     """
     if status not in LAUFENDE_STATUS or progress <= 0:
         return {"sekunden": -1, "text": ""}
@@ -126,11 +157,17 @@ def aktualisiere_und_schaetze(job_id: str, status: str, progress: int,
         reihe = cache_get(k)
     except Exception:
         reihe = None
+    if not reihe:
+        # Kein Cache (oder leer) — dann der eigene Vorrat.
+        eintrag = _REIHEN.get(k)
+        reihe = eintrag[1] if eintrag else None
     reihe = beobachtung_hinzufuegen(reihe, status, progress, jetzt)
     try:
         # Eine Reihe ohne Fortschritt ist nach einem Tag wertlos.
-        cache_set(k, reihe, expire=86400)
+        cache_set(k, reihe, expire=REIHE_HALTBAR_SEKUNDEN)
     except Exception:
         pass
+    _REIHEN[k] = (jetzt, reihe)
+    _aufraeumen(jetzt)
     sekunden = restzeit_sekunden(reihe, jetzt)
     return {"sekunden": sekunden, "text": formatiere_restzeit(sekunden)}

docker/api/mounts.py

@@ -12,6 +12,8 @@ sondern über eine temporäre credentials-Datei).
 
 import os
 import posixpath
+
+from rippy.platform.winlauf import OHNE_FENSTER
 import re
 import subprocess
 import tempfile
@@ -60,7 +62,8 @@ def ist_erreichbar(name: str) -> bool:
     ziel = _mountpoint(name)
     try:
         ergebnis = subprocess.run(
-            ["timeout", "3", "ls", ziel], capture_output=True, timeout=5
+            ["timeout", "3", "ls", ziel], capture_output=True,
+            creationflags=OHNE_FENSTER, timeout=5
         )
         return ergebnis.returncode == 0
     except (OSError, subprocess.TimeoutExpired):
@@ -89,7 +92,8 @@ def pfad_lage(ziel: str) -> str:
     """
     try:
         ergebnis = subprocess.run(
-            ["timeout", "4", "ls", "-d", ziel], capture_output=True, timeout=6
+            ["timeout", "4", "ls", "-d", ziel], capture_output=True,
+            creationflags=OHNE_FENSTER, timeout=6
         )
     except (OSError, subprocess.TimeoutExpired):
         return "unklar"

docker/api/phasen.py

@@ -44,8 +44,12 @@ UNKLAR = "unklar"
 NICHTS = ""
 
 
-def _meta(meta_json) -> dict:
-    """Metadaten lesen, ohne an kaputtem JSON zu scheitern."""
+def meta_von(meta_json) -> dict:
+    """Metadaten lesen, ohne an kaputtem JSON zu scheitern.
+
+    Oeffentlich, seit auch `main.py` sie braucht: Dort muss die Wahl des
+    Rip-Dialogs (`work_dir`) aus denselben Metadaten gelesen werden.
+    """
     if isinstance(meta_json, dict):
         return meta_json
     if not meta_json:
@@ -68,7 +72,7 @@ def retry_art(job) -> str:
     """
     if (job.get("status") or "") != "failed":
         return NICHTS
-    marke = _meta(job.get("meta")).get(RIP_FERTIG)
+    marke = meta_von(job.get("meta")).get(RIP_FERTIG)
     if marke is True:
         return NEU_KOMPRIMIEREN
     if marke is False:

docker/api/prescan/prescan.py

@@ -6,11 +6,11 @@ lieferte seitdem immer „Unknown Disc". Dies ist die echte Logik, bereinigt.
 """
 
 import os
-import shutil
 import subprocess
 from typing import Dict, List, Optional
 
 from rippy import drives as _laufwerks_schicht
+from rippy.platform.winlauf import OHNE_FENSTER
 from clients.tmdb import TMDBClient
 from clients.jikan import JikanClient
 from clients.musicbrainz import MusicBrainzClient
@@ -25,6 +25,13 @@ from cache.keys import generate_prescan_key
 # test_treiberwahl.py.
 detection = _laufwerks_schicht.treiber()
 
+# Wie viele Treffer eine Suche hoechstens liefern darf, damit sie als
+# SPEZIFISCH gilt. Gemessen am 28.08.2026: Der volle Disc-Titel
+# „Evangelion 2.22" ergab bei TMDB 1 Treffer (den richtigen), die gekuerzte
+# Variante „Evangelion" ergab 20 (beliebige). Drei ist grosszuegig genug fuer
+# Neuauflagen und Regie-Fassungen desselben Films.
+WENIGE_TREFFER = 3
+
 def normalize_disc_label(label: str) -> str:
     """Disc-Labels wie 'PULP_FICTION_DE' → 'Pulp Fiction De' (pure Funktion).
 
@@ -80,50 +87,95 @@ def parse_udf_dstring(data: bytes) -> str:
     return ""
 
 
+def disc_wurzel(device_path: str):
+    r"""Ein lesbarer Einstieg in die Disc — Windows braucht dafuer kein Mounten.
+
+    Gibt `(wurzel, aufraeumen)` zurueck. `aufraeumen` ist eine Funktion, die
+    nach dem Lesen aufgerufen wird; unter Windows tut sie nichts.
+
+    ## Warum das getrennt ist (28.08.2026)
+
+    Der Weg hier war fest `mount -t udf` — also Linux. Unter Windows haengt
+    Windows die Disc selbst ein: `\.\G:` entspricht `G:\`, und dort liegen
+    die Dateien einfach da. Ohne diese Unterscheidung fand Rippy unter
+    Windows NIE den Klartext-Titel und blieb beim Volume-Label haengen
+    (gemessen an einer echten Disc: `BD_EVG_D2` statt `Evangelion 2.22`) --
+    und mit so einem Label findet keine Metadaten-API etwas.
+    """
+    if os.name == "nt":
+        # \.\G: -> G:\   (der Buchstabe ist alles, was wir brauchen)
+        buchstabe = device_path.rstrip(":").rsplit("\\", 1)[-1].rstrip(":")
+        wurzel = buchstabe + ":" + "\\"
+        return (wurzel, lambda: None) if os.path.isdir(wurzel) else (None, lambda: None)
+
+    mountpoint = "/mnt/rippy-disc"
+    os.makedirs(mountpoint, exist_ok=True)
+    ergebnis = subprocess.run(
+        ["mount", "-t", "udf", "-o", "ro", device_path, mountpoint],
+        capture_output=True, text=True, timeout=30,
+        creationflags=OHNE_FENSTER,
+    )
+    if ergebnis.returncode != 0:
+        return None, lambda: None
+
+    def abhaengen():
+        subprocess.run(["umount", mountpoint], capture_output=True, timeout=15,
+                       creationflags=OHNE_FENSTER)
+
+    return mountpoint, abhaengen
+
+
+def titel_aus_bdmt(wurzel: str) -> Optional[str]:
+    """Der Klartext-Titel aus BDMV/META/DL/bdmt_*.xml. (ohne Mounten)
+
+    Getrennt von der Beschaffung der Wurzel, damit er ohne Disc pruefbar ist:
+    ein Ordner mit einer bdmt-Datei reicht.
+    """
+    import re as _re
+
+    meta_dir = os.path.join(wurzel, "BDMV", "META", "DL")
+    if not os.path.isdir(meta_dir):
+        return None
+    try:
+        kandidaten = sorted(os.listdir(meta_dir))
+    except OSError:
+        return None
+    # bdmt_eng.xml bevorzugen, sonst die erste bdmt-Datei (bdmt_deu.xml, ...)
+    bdmt = next((k for k in kandidaten if k == "bdmt_eng.xml"), None) or next(
+        (k for k in kandidaten if k.startswith("bdmt_") and k.endswith(".xml")), None
+    )
+    if not bdmt:
+        return None
+    try:
+        with open(os.path.join(meta_dir, bdmt), "rb") as f:
+            inhalt = f.read(65536).decode("utf-8", errors="replace")
+    except OSError:
+        return None
+    # <di:name>Titel</di:name> - bewusst per Regex statt XML-Parser
+    # (Namespaces variieren je Authoring-Werkzeug)
+    treffer = _re.search(r"<di:name>([^<]{2,120})</di:name>", inhalt)
+    return treffer.group(1).strip() if treffer else None
+
+
 def read_disc_title_via_mount(device_path: str) -> Optional[str]:
     """Liest den KLARTEXT-Titel einer Blu-ray aus BDMV/META/DL/bdmt_*.xml.
 
-    Das Volume-Label ist oft kryptisch (BD_EVG_D2) — der echte Titel
-    („Evangelion: 2.22 …") steht in den Disc-Metadaten. Die API darf
-    read-only mounten (CAP_SYS_ADMIN ist für die Speicherziele ohnehin da).
-    Gibt None zurück, wenn kein BD-Metadatensatz existiert (z. B. DVD).
+    Das Volume-Label ist oft kryptisch (`BD_EVG_D2`) - der echte Titel
+    („Evangelion 2.22") steht in den Disc-Metadaten. Unter Linux wird dafuer
+    read-only gemountet, unter Windows haengt Windows die Disc selbst ein.
+    Gibt None zurueck, wenn kein BD-Metadatensatz existiert (z. B. DVD).
     """
-    import re as _re
-    mountpoint = "/mnt/rippy-disc"
-    os.makedirs(mountpoint, exist_ok=True)
-    gemountet = False
+    wurzel, aufraeumen = None, lambda: None
     try:
-        ergebnis = subprocess.run(
-            ["mount", "-t", "udf", "-o", "ro", device_path, mountpoint],
-            capture_output=True, text=True, timeout=30,
-        )
-        if ergebnis.returncode != 0:
-            return None
-        gemountet = True
-
-        meta_dir = os.path.join(mountpoint, "BDMV", "META", "DL")
-        if not os.path.isdir(meta_dir):
-            return None
-        kandidaten = sorted(os.listdir(meta_dir))
-        # bdmt_eng.xml bevorzugen, sonst erste bdmt-Datei (bdmt_ger.xml, …)
-        bdmt = next((k for k in kandidaten if k == "bdmt_eng.xml"), None) or next(
-            (k for k in kandidaten if k.startswith("bdmt_") and k.endswith(".xml")), None
-        )
-        if not bdmt:
-            return None
-        with open(os.path.join(meta_dir, bdmt), "rb") as f:
-            inhalt = f.read(65536).decode("utf-8", errors="replace")
-        # <di:name>Titel</di:name> — bewusst per Regex statt XML-Parser
-        # (Namespaces variieren je Authoring-Werkzeug)
-        treffer = _re.search(r"<di:name>([^<]{2,120})</di:name>", inhalt)
-        if treffer:
-            return treffer.group(1).strip()
-        return None
+        wurzel, aufraeumen = disc_wurzel(device_path)
+        return titel_aus_bdmt(wurzel) if wurzel else None
     except Exception:
         return None
     finally:
-        if gemountet:
-            subprocess.run(["umount", mountpoint], capture_output=True, timeout=15)
+        try:
+            aufraeumen()
+        except Exception:
+            pass
 
 
 def titel_kandidaten(titel: str) -> List[str]:
@@ -279,7 +331,8 @@ class PreScan:
                     ["cdparanoia", "-Q", device_path],
                     capture_output=True,
                     text=True,
-                    timeout=10
+                    timeout=10,
+                    creationflags=OHNE_FENSTER,
                 )
                 for line in result.stdout.split('\n'):
                     if 'track' in line.lower():
@@ -303,22 +356,37 @@ class PreScan:
                     if label:
                         toc["title"] = normalize_disc_label(label)
 
-                # Titel-Quelle 2 (optional, falls makemkvcon doch da ist):
-                if shutil.which("makemkvcon"):
-                    result = subprocess.run(
-                        ["makemkvcon", "-r", "--noscan", "--minlength=300", "info", f"dev:{device_path}"],
-                        capture_output=True,
-                        text=True,
-                        timeout=120
-                    )
-                    for line in result.stdout.split('\n'):
-                        if line.startswith('TINFO:'):
-                            parts = line.split(',')
-                            if len(parts) >= 5:
-                                toc["tracks"].append({
-                                    "title": parts[4].strip().strip('"') if len(parts) > 4 else "Title",
-                                    "duration": int(parts[2]) if len(parts) > 2 else 0
-                                })
+                # Titel-Quelle 3 (makemkvcon) gibt es hier NICHT mehr.
+                #
+                # ## Warum sie weg ist (Befund 30.08.2026)
+                #
+                # Der Commander: „das erkennen der disk dauert sehr sehr
+                # lange. Das ging mal viel schneller."
+                #
+                # Hier stand ein `makemkvcon -r --noscan --minlength=300
+                # info` mit 120 s Zeitgrenze — bei jeder eingelegten Disc,
+                # vor jeder Anzeige. Auf einer Blu-ray dauert dieser Aufruf
+                # 20 bis 120 Sekunden; solange steht „Disc wird gelesen".
+                #
+                # Dass es frueher schnell war, hat einen unschoenen Grund:
+                # Der Zweig lief unter Windows NIE. Er suchte makemkvcon mit
+                # `shutil.which`, und das findet unter Windows nichts
+                # (Programme liegen nicht im PATH). `be3fac5` hat das am
+                # 28.08.2026 richtig repariert — und damit erst die Kosten
+                # sichtbar gemacht, die hier immer schon standen.
+                #
+                # Der Aufwand war umsonst: Das Ergebnis landete allein in
+                # `toc["tracks"]`, und **die liest niemand**. Der Rip-Dialog
+                # holt seine Titelliste ueber `POST /devices/{id}/scan-tracks`
+                # und `GET /devices/{id}/tracks` — also dann, wenn sie
+                # gebraucht wird, statt bei jedem Einlegen auf Verdacht.
+                # Der Weg fuer eine Disc, die man gar nicht rippen will,
+                # sind so zwei Minuten Warten fuer nichts.
+                #
+                # Der Titel kommt aus Quelle 1 und 2 darueber; die sind
+                # billig. Wer den Aufruf je wieder braucht, braucht dazu
+                # `makemkv_aufruf.quelle`, `makemkv_aufruf.text_von` und
+                # `tools.katalog` — die Importe sind mit ihm gegangen.
         except Exception as e:
             print(f"Pre-Scan TOC Error: {e}")
         return toc
@@ -395,11 +463,13 @@ class PreScan:
         # probieren — Disc-Titel sind selten API-freundlich formatiert.
         kandidaten = titel_kandidaten(title) or [title]
         movies = []
+        movies_kandidat = ""      # WELCHE Variante hat sie geliefert?
 
         for kandidat in kandidaten:
             treffer = self.tmdb.search_movie(kandidat)
             if treffer and not movies:
                 movies = treffer  # bester Rohtreffer für den Vorschlags-Fallback
+                movies_kandidat = kandidat
             for movie in treffer:
                 if movie.get("title", "").lower() == kandidat.lower():
                     confidence = 0.95
@@ -446,6 +516,55 @@ class PreScan:
                 if matched:
                     break
 
+        # ── Ein spezifischer Treffer zählt, auch ohne exakten Titel ─────────
+        #
+        # ## Der Befund des Commanders (28.08.2026)
+        #
+        # > „Was ist mit dem Cover auf Windows Rippy? In der Web Version haben
+        # > wir ein cover."
+        #
+        # Es gab keins, weil es gar keinen Treffer gab — und der Grund war
+        # nicht Windows, sondern die Bedingung oben: `movie["title"].lower()
+        # == kandidat.lower()`. An seiner Disc gemessen:
+        #
+        #     'Evangelion 2.22'    1 Treffer   Evangelion: 2.0 You Can (Not) Advance
+        #     'Evangelion'        20 Treffer   irgendein Evangelion
+        #
+        # Der EINZIGE Treffer auf den vollen Disc-Titel war der richtige Film,
+        # mit Poster — und wurde verworfen, weil der Titel nicht wörtlich
+        # gleich war. Danach gewann eine schlechtere Quelle oder gar keine.
+        #
+        # ## Warum die Trefferzahl das bessere Kriterium ist als Ähnlichkeit
+        #
+        # Die Ähnlichkeit hilft hier nicht: „Evangelion 2.22" gegen
+        # „Evangelion: 2.0 You Can (Not) Advance" ergibt 0,51 — das steht als
+        # Messung schon im Jikan-Absatz unten und fällt durch jedes sinnvolle
+        # Gatter. Die SPEZIFITÄT der Anfrage sagt mehr: Wer auf den vollen,
+        # ungekürzten Disc-Titel eine Handvoll Treffer bekommt, hat gefragt
+        # wie jemand, der weiß, was er sucht. Wer 20 bekommt, hat geraten.
+        #
+        # Deshalb: nur der UNGEKÜRZTE Titel (kandidaten[0]) und nur wenige
+        # Treffer. Confidence 0,8 — sicherer als ein Vorschlag (0,6), aber
+        # ehrlich unter einem wörtlichen Treffer (0,95).
+        if not matched and movies and movies_kandidat == kandidaten[0] \
+                and len(movies) <= WENIGE_TREFFER:
+            details = self.tmdb.get_movie_details(movies[0]["id"])
+            if details:
+                confidence = 0.8
+                metadata = {
+                    "type": "movie",
+                    "id": movies[0]["id"],
+                    "title": details.get("title", title),
+                    "year": int(details.get("release_date", "0")[:4]) if details.get("release_date") else None,
+                    "overview": details.get("overview", ""),
+                    "poster_path": details.get("poster_path", ""),
+                    "backdrop_path": details.get("backdrop_path", ""),
+                    "runtime": details.get("runtime", 0),
+                    "genres": [g["name"] for g in details.get("genres", [])],
+                    "source": "tmdb",
+                }
+                matched = True
+
         # Fallback 1: Jikan/MyAnimeList (kostenlos, KEIN Key) — für Anime die
         # präziseste Quelle; wählt per Titel-Ähnlichkeit, nicht Treffer #1.
         #

docker/api/rohdaten.py

@@ -38,18 +38,71 @@ Verwechslungsgefahr gibt es dabei nicht: Roh-Verzeichnisse heißen exakt wie die
 Job-ID (vollständige UUID), fertige Ablagen heißen `Titel (Jahr) [kurz-id]`.
 """
 
-import posixpath
+import os
 import subprocess
 
-# Container-Standard für Roh-Rips (RAW_DIR im Worker).
+from rippy import pfade as _pfade
+
+# Container-Standard für Roh-Rips (RAW_DIR im Worker). Bleibt als Rueckfall
+# stehen — die WURZELN dieses Betriebs liefert `wurzeln()`.
 RAW_STANDARD = "/app/temp/raw"
 MEDIA_ROOT = "/app/media"
 
+
+def _ui_einstellungen() -> dict:
+    """Was in der Oberflaeche eingestellt ist — leer, wenn die Datenbank
+    gerade nicht antwortet.
+
+    Bewusst gekapselt und abgesichert: `wurzeln()` wird auch aus der
+    Jobliste heraus aufgerufen, die alle vier Sekunden laeuft. Sie darf an
+    einer klemmenden Datenbank nicht scheitern — dann gilt eben die
+    Vorgabe, wie bisher.
+    """
+    try:
+        from rippy import store as db
+
+        return db.get_settings(bei_fehler_leer=True) or {}
+    except Exception:                                # noqa: BLE001
+        return {}
+
+
+def wurzeln(werte=None) -> tuple:
+    """`(roh_standard, medien_wurzel, frei)` fuer DIESEN Betrieb.
+
+    ## Warum das nicht fest sein darf (Befund 29.08.2026)
+
+    Dieses Modul findet die Rohdaten eines Jobs wieder — fuer den
+    Wiederholen-Dialog („auf der Platte liegen X GB Rohdaten") und fuer
+    „Rohdaten mitloeschen". Es suchte fest unter `/app/temp/raw` und
+    `/app/media`.
+
+    Auf einem Windows-PC gibt es beides nicht. Also fand es NIE etwas: Der
+    Dialog meldete „keine Rohdaten", das Aufraeumen loeschte nichts, und die
+    Bruchstuecke eines abgebrochenen Rips blieben unbemerkt liegen — bei einer
+    4K-UHD bis zu 100 GB.
+    """
+    from rippy import betrieb, config
+
+    if werte is None:
+        try:
+            werte = config.laden()
+        except Exception:                            # noqa: BLE001
+            werte = {}
+        # Dieselbe Bruecke wie in /system/info: Die Oberflaeche legt
+        # ihre Orte in der Datenbank ab, nicht in der Datei. Ohne sie
+        # suchte die Rohdaten-Suche unter der Vorgabe statt unter dem,
+        # was eingestellt ist (Befund 30.08.2026).
+        werte = betrieb.mit_einstellungen(werte, _ui_einstellungen())
+    return (betrieb.arbeits_vorgabe(werte) or RAW_STANDARD,
+            betrieb.medien_wurzel(werte) or MEDIA_ROOT,
+            betrieb.frei_blaettern(werte))
+
 # Harte Obergrenze für EINE Verzeichnis-Prüfung. Siehe verzeichnis_da().
 PRUEF_TIMEOUT_SEKUNDEN = 4
 
 
-def kandidaten(job_id: str, work_dir: str, media_unterordner) -> list:
+def kandidaten(job_id: str, work_dir: str, media_unterordner,
+               orte_wurzeln=None) -> list:
     """Alle Orte, an denen die Roh-MKVs dieses Jobs liegen KÖNNTEN (pure).
 
     `media_unterordner` sind die Namen der obersten Ebene unter /app/media
@@ -65,13 +118,37 @@ def kandidaten(job_id: str, work_dir: str, media_unterordner) -> list:
     """
     if not job_id:
         return []
-    orte = [posixpath.join(RAW_STANDARD, job_id)]
-    wahl = (work_dir or "").strip().rstrip("/")
-    if wahl and (wahl == MEDIA_ROOT or wahl.startswith(MEDIA_ROOT + "/")):
-        orte.append(posixpath.join(wahl, job_id))
+    roh, medien, frei = orte_wurzeln or (RAW_STANDARD, MEDIA_ROOT, False)
+    from rippy import pfade
+
+    orte = [pfade.verbinden(roh, job_id)]
+    # Zum VERGLEICHEN ohne Schluss-Trenner, zum VERBINDEN mit.
+    #
+    # ⚠️ Befund 30.08.2026, am Rechner des Commanders nachgerechnet:
+    # Hier stand `wahl = (work_dir or "").strip().rstrip("/\\")`, und mit
+    # dieser einen abgestreiften Zeichenkette wurde dann auch VERBUNDEN.
+    # Sein Arbeitsordner ist `F:\` — ein Laufwerks-Stammverzeichnis:
+    #
+    #     "F:\\".rstrip("/\\")          -> "F:"
+    #     verbinden("F:", job_id)      -> "F:1aa41fef-…"   isdir: False
+    #     verbinden("F:\\", job_id)     -> "F:\1aa41fef-…"  isdir: True
+    #
+    # `F:` ohne Trenner heisst unter Windows „der aktuelle Ordner auf
+    # Laufwerk F", nicht die Wurzel — die Falle steht woertlich im Kopf von
+    # `pfade.verbinden`, und diese Zeile ist hineingetreten. Folge: 16,5 GB
+    # Rohschnitt unsichtbar, und der Wiederholen-Dialog bot nur „Neu
+    # rippen" an — Stunden am beschaedigten Datentraeger fuer nichts.
+    wahl = (work_dir or "").strip()
+    vergleich = wahl.rstrip("/\\")
+    grenze = (medien or "").rstrip("/\\")
+    # Nativ zaehlt jede Wahl — dort liegt der Arbeitsordner oft auf einem
+    # ganz anderen Laufwerk und damit unter gar keiner Wurzel.
+    if vergleich and (frei or vergleich == grenze
+                      or vergleich.startswith(grenze + "/")):
+        orte.append(pfade.verbinden(wahl, job_id))
     for name in media_unterordner or []:
         if name:
-            orte.append(posixpath.join(MEDIA_ROOT, name, job_id))
+            orte.append(pfade.verbinden(pfade.verbinden(medien, name), job_id))
     gesehen, eindeutig = set(), []
     for ort in orte:
         if ort not in gesehen:
@@ -80,6 +157,16 @@ def kandidaten(job_id: str, work_dir: str, media_unterordner) -> list:
     return eindeutig
 
 
+def nativ_nachsehen() -> bool:
+    """Darf direkt nachgesehen werden, statt einen Prozess dafuer zu starten?
+
+    Eigene Funktion, damit beide Zweige ueberall pruefbar sind — dieselbe
+    Regel wie bei `betrieb.im_container`. Die Begruendung steht in
+    `pruefen`.
+    """
+    return os.name == "nt"
+
+
 def pruefen(pfad: str, laufen=None) -> str:
     """Gibt es dieses Verzeichnis? „da" | „weg" | „unklar" — mit HARTER Zeitgrenze.
 
@@ -96,6 +183,33 @@ def pruefen(pfad: str, laufen=None) -> str:
     """
     if not pfad:
         return "weg"
+    if laufen is None and nativ_nachsehen():
+        # ## Warum Windows hier NICHT den Umweg ueber einen Prozess geht
+        #
+        # ⚠️ Befund 30.08.2026, an der laufenden Instanz beobachtet:
+        #
+        #     14:54:40  timeout.exe  timeout 4 ls -d C:\\...\\d7ee6c06-...
+        #     14:54:40  WindowsTerminal.exe
+        #
+        # Der Commander: „nun oeffnen sich diverse fenster im hintergrund,
+        # gehen ganz kurz auf und dann wieder zu."
+        #
+        # `timeout` und `ls` sind Linux-Befehle. Unter Windows GIBT es eine
+        # `timeout.exe` — sie wartet nur Sekunden ab und kennt weder `ls`
+        # noch `-d`. Sie braucht aber eine Konsole, und die reisst Windows
+        # dann auf. Dreifach falsch also: ein Fenster bei jedem Durchlauf,
+        # ein Prozess fuer nichts, und ein Rueckgabewert ungleich 0 — also
+        # die Antwort „weg" fuer JEDES Verzeichnis. Rohdaten waren damit
+        # unter Windows grundsaetzlich unsichtbar.
+        #
+        # Der Grund fuer den Umweg gilt hier nicht: Der Kernel-Hang im
+        # Zustand D (siehe `verzeichnis_da`) ist eine Linux-Eigenheit. Ein
+        # totes Netzlaufwerk laesst `os.path.isdir` unter Windows mit einem
+        # Fehler zurueckkommen, nicht unabbrechbar haengen.
+        try:
+            return "da" if os.path.isdir(pfad) else "weg"
+        except OSError:
+            return "unklar"
     starten = laufen or subprocess.run
     try:
         ergebnis = starten(
@@ -145,7 +259,8 @@ def verzeichnis_da(pfad: str, laufen=None) -> bool:
     return pruefen(pfad, laufen) == "da"
 
 
-def suche(job_id: str, work_dir: str, listdir, isdir) -> list:
+def suche(job_id: str, work_dir: str, listdir, isdir,
+          orte_wurzeln=None) -> list:
     """Die Orte, an denen wirklich etwas liegt.
 
     `listdir` und `isdir` werden übergeben statt importiert — so ist die Suche
@@ -156,12 +271,13 @@ def suche(job_id: str, work_dir: str, listdir, isdir) -> list:
     `listdir` darf os.listdir bleiben: Gelistet wird nur /app/media selbst, und
     das ist ein lokales Verzeichnis — die Freigaben sind Unterordner davon.
     """
+    orte_wurzeln = orte_wurzeln or wurzeln()
     try:
-        unterordner = sorted(listdir(MEDIA_ROOT))
+        unterordner = sorted(listdir(orte_wurzeln[1]))
     except OSError:
         unterordner = []
     gefunden = []
-    for ort in kandidaten(job_id, work_dir, unterordner):
+    for ort in kandidaten(job_id, work_dir, unterordner, orte_wurzeln):
         try:
             if isdir(ort):
                 gefunden.append(ort)
@@ -172,7 +288,8 @@ def suche(job_id: str, work_dir: str, listdir, isdir) -> list:
     return gefunden
 
 
-def suche_mit_status(job_id: str, work_dir: str, listdir, pruefer=None) -> dict:
+def suche_mit_status(job_id: str, work_dir: str, listdir, pruefer=None,
+                     orte_wurzeln=None) -> dict:
     """Wie suche(), aber sagt auch, ob etwas UNGEPRÜFT geblieben ist.
 
     Rückgabe: {"pfade": [...], "unklar": bool}. `unklar` heißt: Mindestens ein
@@ -181,12 +298,13 @@ def suche_mit_status(job_id: str, work_dir: str, listdir, pruefer=None) -> dict:
     behalten, statt Abwesenheit zu behaupten (siehe pruefen()).
     """
     pruefe = pruefer or pruefen
+    orte_wurzeln = orte_wurzeln or wurzeln()
     try:
-        unterordner = sorted(listdir(MEDIA_ROOT))
+        unterordner = sorted(listdir(orte_wurzeln[1]))
     except OSError:
         unterordner = []
     gefunden, unklar = [], False
-    for ort in kandidaten(job_id, work_dir, unterordner):
+    for ort in kandidaten(job_id, work_dir, unterordner, orte_wurzeln):
         antwort = pruefe(ort)
         if antwort == "da":
             gefunden.append(ort)
@@ -208,7 +326,11 @@ def groesse(pfade: list, listdir, isfile, getsize) -> tuple:
         except OSError:
             continue
         for name in namen:
-            voll = posixpath.join(pfad, name)
+            # `pfade.verbinden` statt posixpath: Auf Windows ist `pfad`
+            # ein echter Windows-Pfad, und `posixpath.join` baute daraus
+            # `C:\Roh/datei.mkv` — gemischte Trenner, die im UI falsch
+            # aussehen und jeden Vergleich brechen (Befund 29.08.2026).
+            voll = _pfade.verbinden(pfad, name)
             try:
                 if isfile(voll):
                     bytes_gesamt += getsize(voll)

docker/api/test_api_smoke.py

@@ -2,16 +2,20 @@
 
 Warum: Kein anderer Test importiert main.py — ein Tippfehler dort fiele sonst
 erst beim Container-Start auf (und die Ampel bliebe fälschlich grün).
-Läuft nur unter Linux (detection.py nutzt fcntl/ioctl), also genau dort,
-wo auch die Ampel läuft.
+## Warum das hier nicht mehr uebersprungen wird (28.08.2026)
+
+Bis V2-4 stand hier ein `pytest.skip` fuer Windows: `main.py` importierte
+`rippy.drives.linux` direkt, und das braucht `fcntl`. Seit die Treiberwahl
+ueber den Port `rippy.ports.Drives` laeuft, laedt `main.py` auf BEIDEN
+Plattformen — nachgemessen: 57 Routen, sauberer Import.
+
+Das Ueberspringen war damit nicht mehr Vorsicht, sondern eine Luecke: Diese
+siebzehn Tests liefen nur auf der Ampel. Und ein Test, der nur auf einer
+Plattform greift, ist eine halbe Zusage — genau daran ist die Ampel am
+28.08.2026 fuenf Laeufe lang unbemerkt rot gewesen.
 """
 
-import sys
-
-import pytest
-
-if sys.platform == "win32":  # pragma: no cover
-    pytest.skip("detection.py braucht fcntl (Linux)", allow_module_level=True)
+import pytest  # noqa: F401  (einzelne Tests brauchen ihn fuer skipif)
 
 
 def test_main_importierbar_und_routen_verdrahtet():
@@ -27,6 +31,9 @@ def test_main_importierbar_und_routen_verdrahtet():
         # Der Hauptweg für 4K-UHD (25.07.2026): makemkvcon holt Disc-Schluessel
         # unter Linux nie selbst, sie kommen von Hand über diesen Endpunkt.
         "/system/keystore",
+        # Ohne die weiss das UI nicht, worauf es laeuft — und zeigt dann auf
+        # einem Windows-PC "Pruefen: docker compose ps" (Befund 28.08.2026).
+        "/betrieb",
     ):
         assert pfad in routen, f"Route {pfad} fehlt"
 
@@ -317,9 +324,18 @@ def test_snapshot_meldet_unlesbare_laufwerke_als_none(monkeypatch):
     assert zustand["jobs"] == []
 
 
-def test_snapshot_liefert_alle_vier_bereiche(monkeypatch):
+def test_snapshot_liefert_das_ganze_bild(monkeypatch):
     """Ein Client, der sich verbindet, bekommt das GANZE Bild — sonst muesste
-    er den Rest raten und faellt auf Polling zurueck."""
+    er den Rest raten und faellt auf Polling zurueck.
+
+    ## Warum der Server-Zustand dazugehoert (Befund 28.08.2026)
+
+    Er fehlte im Schnappschuss, und der Waechter schickt ihn nur alle 15
+    Sekunden. Ein frisch geladenes Dashboard stand deshalb bis zu einer
+    Viertelminute auf „Platz fuer Rippy: unbekannt" — und das sieht aus wie
+    eine Auskunft, obwohl es keine ist. Genau das hat der Commander im
+    Windows-Fenster gesehen.
+    """
     import asyncio
 
     import main
@@ -328,9 +344,591 @@ def test_snapshot_liefert_alle_vier_bereiche(monkeypatch):
     monkeypatch.setattr(main.db, "list_workers", lambda: [{"name": "pc"}])
     monkeypatch.setattr(main.db, "list_logs", lambda limit=50: [])
     monkeypatch.setattr(main.device_discovery, "list_optical_devices", lambda: [])
+    # Ohne DB liefe system_info() in eine Ausnahme, und die Ampel hat keine
+    # Datenbank (Lauf 170). Geprueft wird hier die FORM des Schnappschusses.
+    #
+    # `*a, **k`, nicht `lambda: {}` (Befund 30.08.2026): Die echte
+    # Funktion heisst `get_settings(key="ui", bei_fehler_leer=False)`.
+    # Der zu enge Doppelgaenger warf `TypeError`, sobald ein Aufrufer
+    # einen der Parameter benutzte — `system_info` fiel damit aus dem
+    # Schnappschuss, und dieser Test zeigte auf den Code statt auf sich
+    # selbst. Ein Doppelgaenger muss die Schnittstelle abbilden, die er
+    # ersetzt, nicht nur den einen Aufruf, den es gerade gibt.
+    monkeypatch.setattr(main.db, "get_settings", lambda *a, **k: {})
 
     zustand = asyncio.run(main._snapshot())
 
-    assert set(zustand) == {"jobs", "workers", "logs", "devices"}
+    assert {"jobs", "workers", "logs", "devices"} <= set(zustand)
+    assert "info" in zustand, (
+        "Ohne den Server-Zustand steht das Dashboard nach jedem Neuladen "
+        "bis zu 15 Sekunden auf 'unbekannt'."
+    )
     assert zustand["devices"] == []          # wirklich leer, nicht „unbekannt"
     assert zustand["workers"] == [{"name": "pc"}]
+
+
+def test_ein_kaputter_server_zustand_kippt_den_schnappschuss_nicht(monkeypatch):
+    """Der Schnappschuss ist die Grundlage fuer ALLES im UI. Lieber ohne
+    Platzangabe (das UI behaelt seinen Stand) als gar kein Schnappschuss."""
+    import asyncio
+
+    import main
+
+    monkeypatch.setattr(main.db, "list_jobs", lambda limit=50: [])
+    monkeypatch.setattr(main.db, "list_workers", lambda: [])
+    monkeypatch.setattr(main.db, "list_logs", lambda limit=50: [])
+    monkeypatch.setattr(main.device_discovery, "list_optical_devices", lambda: [])
+
+    async def platzt():
+        raise RuntimeError("Platte weg")
+
+    monkeypatch.setattr(main, "system_stand_fuer_snapshot", platzt)
+    zustand = asyncio.run(main._snapshot())
+    assert {"jobs", "workers", "logs", "devices"} <= set(zustand)
+
+
+def test_betrieb_meldet_faehigkeiten_statt_nur_einen_namen():
+    """Der Befund vom 28.08.2026: Das Windows-Fenster zeigte "Worker
+    erreichbar: 0 von 1", "Container-Platte" und "Pruefen: docker compose ps"
+    — auf einem PC ohne Container und ohne zweiten Worker.
+
+    Das UI muss FAEHIGKEITEN bekommen, keinen Modus-Namen: Aus einem Namen
+    auf Verhalten zu schliessen bricht beim naechsten Betriebsfall (ein
+    Docker-All-in-One hat Container-Pfade, aber keine externen Worker).
+    """
+    from fastapi.testclient import TestClient
+
+    from main import app
+
+    # OHNE `with`: Der Kontextmanager loest den Lebenszyklus aus, und der legt
+    # Tabellen an — auf der Ampel gibt es keine Datenbank. Genau daran ist
+    # Lauf 170 rot geworden. /betrieb braucht keine.
+    antwort = TestClient(app).get("/betrieb")
+    assert antwort.status_code == 200
+    daten = antwort.json()
+    assert daten["modus"] in ("standalone", "verteilt")
+    assert daten["plattform"] in ("windows", "linux", "macos")
+    assert set(daten["kann"]) == {"externe_worker", "freigaben_einhaengen",
+                                  "container_pfade", "werkzeuge_verwalten",
+                                  "frei_blaettern"}
+    # Beide Orte muessen dabei sein. Fehlte einer, muesste die Oberflaeche
+    # wieder raten — und genau daraus wurde „Container-Platte" auf einem PC,
+    # der keinen Container hat (Befund 28.08.2026).
+    assert daten["ablage_vorgabe"] and daten["arbeits_vorgabe"]
+    assert all(isinstance(w, bool) for w in daten["kann"].values())
+    # Ein Hinweis auf docker compose darf NUR im Container erscheinen.
+    if not daten["im_container"]:
+        assert daten["hilfe_befehl"] == ""
+
+
+# ── Die Grenze DB → Oberflaeche (Befund 29.08.2026) ─────────────────────
+#
+# Commander mit Bildschirmfoto: „schau mal hier, das Datum ist falsch."
+#
+#     TYP „DISC"   STARTZEIT „1.1.1970, 01:00:00"   STATUS „running"
+#
+# Der Waechter schickte die ROHE Datenbankzeile ueber den Ereignisstrom. Dort
+# heissen die Spalten `disc_type` und `created_at`, im UI aber `type` und
+# `startTime` — die Uebersetzung macht `_job_row_to_model`, und sie bildet
+# auch `running` auf `processing` ab.
+#
+# Der Test, den ich beim ersten Anlauf geschrieben habe, hat das NICHT
+# gefunden: Ich hatte seine Beispielzeile selbst erfunden, mit meinen
+# falschen Feldnamen. Ein Test, der dieselbe Annahme macht wie der Code,
+# prueft nichts. Dieser hier geht von der ECHTEN Zeile aus.
+
+
+def _echte_db_zeile():
+    """Eine Zeile mit den Spaltennamen, die wirklich in der Datenbank stehen."""
+    from datetime import datetime
+
+    return {
+        "id": "j1",
+        "disc_type": "bluray",              # NICHT "type"
+        "created_at": datetime(2026, 8, 29, 12, 7, 2),   # NICHT "startTime"
+        "finished_at": None,
+        "status": "running",                # wird zu "processing"
+        "device": r"\.\G:",
+        "progress": 12,
+        "title": "Evangelion 2.22",
+        "error": None,
+        "meta": None,
+    }
+
+
+def test_die_umwandlung_liefert_die_namen_die_das_ui_kennt():
+    import main
+
+    ui = main._job_row_to_model(_echte_db_zeile()).model_dump()
+    assert ui["type"] == "bluray"
+    assert ui["startTime"].startswith("2026-08-29")
+    assert ui["status"] == "processing", "der Worker-Status heisst im UI anders"
+
+
+def test_das_live_ereignis_traegt_dieselben_namen_wie_die_jobliste():
+    """DER Waechter gegen „1.1.1970". Ohne die Umwandlung sind alle
+    Pflichtfelder leer — und leer sieht im Browser aus wie eine Auskunft."""
+    import main
+    from rippy.bus.waechter import UI_PFLICHTFELDER, _job_kurz
+
+    ui = main._job_row_to_model(_echte_db_zeile()).model_dump()
+    kurz = _job_kurz(ui)
+    for feld in UI_PFLICHTFELDER:
+        assert kurz.get(feld) is not None, "%s waere im Browser leer" % feld
+    assert kurz["type"] == "bluray"
+    assert kurz["status"] == "processing"
+
+
+def test_der_waechter_ist_mit_der_umwandlung_verdrahtet():
+    """Sonst waere die Reparatur wieder nur eine Moeglichkeit, keine Tatsache."""
+    import inspect
+
+    import main
+
+    quelle = inspect.getsource(main.startup_event)
+    assert "job_form=" in quelle, "Waechter bekommt die Umwandlung nicht"
+    assert "_job_row_to_model" in quelle
+
+
+def test_die_laufwerksliste_kommt_aus_EINER_quelle():
+    """Waechter gegen die vierte Kopie (Befund 29.08.2026).
+
+    Commander: „Es ist eine Disk im laufwerk, aber er erkennt sie dort nicht."
+
+    Die Laufwerksliste wurde an DREI Stellen gebaut: im `/devices`-Endpunkt
+    (mit angehaengter Disc), im Ereignis-Waechter und im SSE-Schnappschuss
+    (beide ohne). Das Dashboard liest den Schnappschuss — und schloss aus der
+    fehlenden Disc auf ein leeres Laufwerk, waehrend ihr Titel eine Zeile
+    weiter oben stand.
+
+    Eine Auskunft in drei Fassungen ist zwei Fassungen zu viel.
+    """
+    import inspect
+
+    import main
+
+    quelle = inspect.getsource(main)
+    # Die eine erlaubte Fundstelle ist die Funktion selbst.
+    stellen = quelle.count("device_discovery.device_info(")
+    assert stellen == 1, (
+        "device_info wird an %d Stellen aufgerufen — die Liste gehoert in "
+        "laufwerke_mit_disc(), sonst fehlt irgendwo die Disc" % stellen)
+    for name in ("_snapshot", "startup_event", "get_devices"):
+        text = inspect.getsource(getattr(main, name))
+        assert "device_info(" not in text, \
+            "%s baut die Laufwerksliste selbst" % name
+
+
+def test_laufwerke_mit_disc_haengt_die_erkannte_disc_an(monkeypatch):
+    import main
+
+    monkeypatch.setattr(main.device_discovery, "list_optical_devices",
+                        lambda: [r"\.\G:"])
+    monkeypatch.setattr(main.device_discovery, "device_info",
+                        lambda p: {"id": "G", "name": "Laufwerk G:", "path": p,
+                                   "type": "bluray", "status": "ready"})
+    monkeypatch.setitem(main.DISC_CACHE, r"\.\G:", {"title": "Evangelion 2.22"})
+
+    geraete = main.laufwerke_mit_disc()
+    assert geraete[0]["disc"]["title"] == "Evangelion 2.22"
+
+
+def test_eine_noch_laufende_erkennung_wird_NICHT_als_disc_gemeldet(monkeypatch):
+    """`_laeuft` heisst „wird gerade erkannt" — das ist noch keine Auskunft."""
+    import main
+
+    monkeypatch.setattr(main.device_discovery, "list_optical_devices",
+                        lambda: [r"\.\G:"])
+    monkeypatch.setattr(main.device_discovery, "device_info",
+                        lambda p: {"id": "G", "name": "Laufwerk G:", "path": p,
+                                   "type": "bluray", "status": "ready"})
+    monkeypatch.setitem(main.DISC_CACHE, r"\.\G:",
+                        {"_laeuft": True, "title": "Wird erkannt…"})
+
+    assert "disc" not in main.laufwerke_mit_disc()[0]
+
+
+def test_eine_laufende_erkennung_ist_SICHTBAR(monkeypatch):
+    """Commander 29.08.2026: „das die disc erkennung noch läuft muss sichtbar
+    sein."
+
+    Vorher liess `laufwerke_mit_disc` einen laufenden Eintrag KOMPLETT weg —
+    damit keine halbfertige Disc-Karte mit „Wird erkannt…" als Titel und
+    einem „Rippen starten"-Knopf erscheint. Richtig gedacht, falsch geloest:
+    Fuer die Oberflaeche sah es aus wie ein leeres Laufwerk. Und das dauert:
+    `makemkvcon info` laeuft an einer Blu-ray in seine 120-Sekunden-Grenze
+    (gemessen: Disc nach 119 s erkannt).
+    """
+    import main
+
+    monkeypatch.setattr(main.device_discovery, "list_optical_devices",
+                        lambda: [r"\.\G:"])
+    monkeypatch.setattr(main.device_discovery, "device_info",
+                        lambda p: {"id": "G", "name": "Laufwerk G:", "path": p,
+                                   "type": "bluray", "status": "ready"})
+    monkeypatch.setitem(main.DISC_CACHE, r"\.\G:",
+                        {"_laeuft": True, "title": "Wird erkannt…"})
+
+    geraet = main.laufwerke_mit_disc()[0]
+    assert geraet["disc_wird_erkannt"] is True
+    # UND weiterhin keinen Titel behaupten, den es noch nicht gibt.
+    assert "disc" not in geraet
+
+
+def test_nach_der_erkennung_ist_die_marke_wieder_weg(monkeypatch):
+    import main
+
+    monkeypatch.setattr(main.device_discovery, "list_optical_devices",
+                        lambda: [r"\.\G:"])
+    monkeypatch.setattr(main.device_discovery, "device_info",
+                        lambda p: {"id": "G", "name": "Laufwerk G:", "path": p,
+                                   "type": "bluray", "status": "ready"})
+    monkeypatch.setitem(main.DISC_CACHE, r"\.\G:", {"title": "Evangelion 2.22"})
+
+    geraet = main.laufwerke_mit_disc()[0]
+    assert not geraet.get("disc_wird_erkannt")
+    assert geraet["disc"]["title"] == "Evangelion 2.22"
+
+
+def test_das_geraetemodell_gibt_die_marke_auch_heraus():
+    """Ohne Feld im Modell schneidet FastAPI sie weg — und das UI saehe
+    wieder nichts (derselbe Fehler wie 25.07. bei `meta`)."""
+    import main
+
+    assert "disc_wird_erkannt" in main.Device.model_fields
+
+
+# ── Die Notdurft-Auskunft (Befund 29.08.2026) ──────────────────────────
+#
+# Waehrend der Disc-Erkennung haelt makemkvcon das Laufwerk. Gemessen:
+# /devices braucht dann 14,0 s, die Zeitgrenze des Schnappschusses ist 5,0 s.
+# Der lieferte deshalb `devices = None` („konnte nicht nachsehen") — und nach
+# einem frischen Laden hatte das UI keinen alten Stand, den es haette behalten
+# koennen. Der Bildschirm blieb leer, ausgerechnet in der Phase, die sichtbar
+# sein soll.
+
+
+def test_notdurft_meldet_den_letzten_stand_plus_die_erkennung(monkeypatch):
+    import main
+
+    monkeypatch.setattr(main, "LETZTE_LAUFWERKE",
+                        [{"id": "G", "name": "Laufwerk G:", "path": r"\.\G:",
+                          "type": "bluray", "status": "ready"}])
+    monkeypatch.setitem(main.DISC_CACHE, r"\.\G:", {"_laeuft": True})
+
+    geraete = main.laufwerke_notdurft()
+    assert geraete[0]["disc_wird_erkannt"] is True
+    assert geraete[0]["type"] == "bluray", "der letzte bekannte Typ bleibt"
+
+
+def test_notdurft_ohne_jeden_stand_erfindet_nichts(monkeypatch):
+    """Wer nie erfolgreich gelesen hat, soll schweigen — `None` heisst
+    „behalte deinen Stand", und das ist die ehrliche Antwort."""
+    import main
+
+    monkeypatch.setattr(main, "LETZTE_LAUFWERKE", [])
+    monkeypatch.setattr(main.device_discovery, "list_optical_devices", lambda: [])
+    assert main.laufwerke_notdurft() is None
+
+
+def test_notdurft_beim_kaltstart_nennt_wenigstens_das_laufwerk(monkeypatch):
+    """Kaltstart mitten in der Erkennung: Die LISTE der Laufwerke ist billig,
+    nur das Abfragen des Laufwerks ist teuer."""
+    import main
+
+    monkeypatch.setattr(main, "LETZTE_LAUFWERKE", [])
+    monkeypatch.setattr(main.device_discovery, "list_optical_devices",
+                        lambda: [r"\.\G:"])
+    monkeypatch.setitem(main.DISC_CACHE, r"\.\G:", {"_laeuft": True})
+
+    geraete = main.laufwerke_notdurft()
+    assert geraete[0]["disc_wird_erkannt"] is True
+    assert geraete[0]["type"] == "unknown", "kein Typ wird erfunden"
+
+
+def test_ein_fertiges_ergebnis_ueberschreibt_die_alte_marke(monkeypatch):
+    """Sonst bliebe „wird erkannt" stehen, nachdem die Disc laengst da ist."""
+    import main
+
+    monkeypatch.setattr(main, "LETZTE_LAUFWERKE",
+                        [{"id": "G", "name": "Laufwerk G:", "path": r"\.\G:",
+                          "type": "bluray", "status": "ready",
+                          "disc_wird_erkannt": True}])
+    monkeypatch.setitem(main.DISC_CACHE, r"\.\G:", {"title": "Evangelion 2.22"})
+
+    geraet = main.laufwerke_notdurft()[0]
+    assert "disc_wird_erkannt" not in geraet
+    assert geraet["disc"]["title"] == "Evangelion 2.22"
+
+
+# ── Die Disc-Wache: kein Dauerscan (Befund 29.08.2026) ─────────────────
+#
+# Commander: „liest er die disc NOCHMAL ein das macht aber keinen sinn, wenn
+# er sie bereits erkannt hat. Außerdem öffnen sich nun immer irgendwelche
+# fenster ganz kurz im hintergrund."
+#
+# Beides war dieselbe Schleife: `except OSError: continue` liess
+# `bekannt[pfad]` ungesetzt, der naechste Durchlauf hielt das Laufwerk fuer
+# neu und stiess einen weiteren Vor-Scan an. Der haelt das Laufwerk, die
+# naechste Statusabfrage scheitert — und so weiter.
+
+
+def _CDS():
+    import main
+    return main.CDS_DISC_OK, main.CDS_NO_DISC, main.CDS_TRAY_OPEN
+
+
+def test_erster_blick_auf_eine_liegende_disc_erkennt_sie():
+    import main
+    ok, _, _ = _CDS()
+    assert main.disc_entscheidung(False, None, ok) == "erststart"
+
+
+def test_ein_leeres_laufwerk_beim_start_loest_nichts_aus():
+    import main
+    _, leer, _ = _CDS()
+    assert main.disc_entscheidung(False, None, leer) == ""
+
+
+def test_dieselbe_disc_wird_NICHT_nochmal_gelesen():
+    """Der Kern des Befundes."""
+    import main
+    ok, _, _ = _CDS()
+    assert main.disc_entscheidung(True, ok, ok) == ""
+
+
+def test_ein_fehlgeschlagener_lesevorgang_startet_KEINEN_neuen_scan():
+    """DER Fehler: Nach einem Fehlschlag blieb `vorher` leer. Wer das mit
+    „noch nie gesehen" verwechselt, scannt endlos.
+
+    Ablauf wie in echt: erst erfolgreich gelesen, dann scheitert der Lesevor-
+    gang (makemkvcon haelt das Laufwerk), dann klappt er wieder.
+    """
+    import main
+    ok, _, _ = _CDS()
+    # Der Fehlschlag setzt `bekannt` nicht — `vorher` ist danach None.
+    # `schon_gesehen` bleibt aber True, und genau daran haengt alles.
+    assert main.disc_entscheidung(True, None, ok) == "eingelegt", \
+        "eine Statusaenderung nach unbekannt->Disc ist ein Einlegen …"
+    # … aber NICHT ein Erststart, der ohne jede Aenderung scannt:
+    assert main.disc_entscheidung(True, ok, ok) == ""
+
+
+def test_auswurf_wird_erkannt():
+    import main
+    ok, leer, offen = _CDS()
+    assert main.disc_entscheidung(True, ok, leer) == "entfernt"
+    assert main.disc_entscheidung(True, ok, offen) == "entfernt"
+
+
+def test_ein_wackliger_zwischenstatus_wirft_die_disc_nicht_weg():
+    """3 = „nicht bereit" heisst nicht „ausgeworfen". Sonst faellt der Vorrat
+    weg, sobald das Laufwerk kurz beschaeftigt ist."""
+    import main
+    ok, _, _ = _CDS()
+    assert main.disc_entscheidung(True, ok, 3) == ""
+
+
+def test_die_wache_setzt_gesehen_auch_nach_einem_fehlschlag_nicht_zurueck():
+    """Waechter gegen die Rueckkehr des `continue`-Fehlers."""
+    import inspect
+
+    import main
+
+    quelle = inspect.getsource(main.disc_watcher)
+    assert "gesehen" in quelle, "die Wache muss sich merken, was sie je las"
+    assert "disc_entscheidung(" in quelle, "die Entscheidung gehoert in die pure Funktion"
+
+
+def test_schnappschuss_und_jobs_liefern_DIESELBE_jobliste():
+    """Waechter gegen die zweite Fassung (Befund 29.08.2026).
+
+    Commander: „Über den kompletten vorgang steht dort ‚Restzeit wird
+    gemessen' aber messung wird nicht abgeschlossen."
+
+    Die Restzeit wurde nur in `/jobs` berechnet. Der SSE-Schnappschuss baute
+    seine Jobs mit dem nackten `_job_row_to_model` — also ohne. Seit V2-3
+    liest die Oberflaeche aber genau diesen Schnappschuss. Die Restzeit wurde
+    also brav berechnet und niemandem gezeigt.
+    """
+    import inspect
+
+    import main
+
+    quelle = inspect.getsource(main._snapshot)
+    assert "jobs_fuer_ui(" in quelle, "der Schnappschuss baut die Jobs selbst"
+    assert "_job_row_to_model(z).model_dump() for z in db.list_jobs" not in quelle
+
+
+def test_die_jobliste_traegt_die_restzeit_felder():
+    """Ohne die Felder im Modell schneidet FastAPI sie weg."""
+    import main
+
+    for feld in ("eta_sekunden", "eta_text", "can_retry", "retry_art"):
+        assert feld in main.Job.model_fields, feld
+
+
+# ── Kein Vor-Scan waehrend eines Rips (Befund 29.08.2026) ───────────────
+#
+# Commander: „der ‚Disk wird gelesen' panel braucht eeeeewig. Der Rip ist
+# bereits bei 30% und er liest immernoch."
+#
+# Waehrend eines Rips haelt makemkvcon das Laufwerk. Ein zweites
+# `makemkvcon info` daneben wartet bis zu seiner Zeitgrenze — und die Marke
+# `_laeuft` blieb solange stehen, also stand auch das Panel. Es gibt keinen
+# Grund, dann zu scannen: Das Laufwerk ist belegt, und WELCHE Disc drin ist,
+# wissen wir — der Job laeuft ja auf ihr.
+
+
+def test_kein_vorscan_solange_ein_job_auf_dem_laufwerk_laeuft(monkeypatch):
+    import asyncio
+
+    import main
+
+    gescannt = []
+
+    class NieBenutzt:
+        def scan(self, pfad):
+            gescannt.append(pfad)
+            raise AssertionError("waehrend eines Rips darf nicht gescannt werden")
+
+    monkeypatch.setattr(main, "PreScan", NieBenutzt)
+    monkeypatch.setattr(main.db, "has_active_job", lambda p: True)
+    main.DISC_CACHE.pop(r"\.\G:", None)
+
+    asyncio.run(main._auto_prescan(r"\.\G:"))
+    assert gescannt == []
+    assert r"\.\G:" not in main.DISC_CACHE, "auch keine Marke setzen"
+
+
+def test_ohne_laufenden_job_wird_normal_gescannt(monkeypatch):
+    import asyncio
+
+    import main
+
+    class Ergebnis:
+        title, year, disc_type, confidence, fingerprint = "Akira", 1988, "Blu-ray", 0.9, "x"
+
+        def to_dict(self):
+            return {"title": "Akira"}
+
+    class Scanner:
+        def scan(self, pfad):
+            return Ergebnis()
+
+    monkeypatch.setattr(main, "PreScan", Scanner)
+    monkeypatch.setattr(main.db, "has_active_job", lambda p: False)
+    monkeypatch.setattr(main.db, "add_log", lambda *a, **k: None)
+    monkeypatch.setattr(main, "_duplikat_suchen", lambda f: None)
+    monkeypatch.setattr(main, "_auto_rip_wenn_aktiviert",
+                        lambda p: asyncio.sleep(0))
+    main.DISC_CACHE.pop(r"\.\G:", None)
+
+    asyncio.run(main._auto_prescan(r"\.\G:"))
+    assert main.DISC_CACHE[r"\.\G:"]["title"] == "Akira"
+    main.DISC_CACHE.pop(r"\.\G:", None)
+
+
+def test_der_job_start_raeumt_eine_haengende_erkennung_weg():
+    """Eine Marke, die KURZ VOR dem Rip gesetzt wurde, bliebe sonst bis zum
+    Ende stehen — der Scan davor haelt sie ja fest."""
+    import inspect
+
+    import main
+
+    quelle = inspect.getsource(main.create_job) if hasattr(main, "create_job") else ""
+    if not quelle:
+        # Der Endpunkt heisst anders — dann ueber das Modul suchen.
+        quelle = inspect.getsource(main)
+    assert 'DISC_CACHE.pop(device_path, None)' in quelle, \
+        "beim Job-Start muss eine haengende Erkennungs-Marke weg"
+
+
+# ── Kein zweiter Rip waehrend der Kompression (Befund 29.08.2026) ───────
+#
+# Der Commander: „Der Rip an sich war bereits fertig, bei der komprimierung
+# passiert das" — Fehlertext: „Das Öffnen der Disk schlug fehl".
+#
+# Ablauf dahinter: Rip fertig → Disc ausgeworfen → Status `transcoding`.
+# `has_active_job` kennt nur pending/running und meldete „Laufwerk frei".
+# Die Disc-Wache sah den Auswurf als Statuswechsel, die Vollautomatik startete
+# einen ZWEITEN Rip — in eine Schublade, die gerade herausfuhr.
+
+
+def test_automatik_startet_nicht_waehrend_der_kompression(monkeypatch):
+    import asyncio
+
+    import main
+
+    gestartet = []
+    monkeypatch.setattr(main.db, "get_settings", lambda: {"autoRipStart": True})
+    monkeypatch.setattr(main.db, "job_offen", lambda p: True)   # Job komprimiert
+    monkeypatch.setattr(main.db, "has_active_job", lambda p: False)  # Laufwerk frei
+    monkeypatch.setattr(main, "start_rip", lambda *a, **k: gestartet.append(a))
+    main.DISC_CACHE[r"\.\G:"] = {"title": "Akira"}
+
+    asyncio.run(main._auto_rip_wenn_aktiviert(r"\.\G:"))
+    assert gestartet == [], "waehrend der Kompression faengt die Automatik nichts Neues an"
+
+
+def test_job_offen_zaehlt_die_kompression_mit():
+    from rippy.store import JOB_OFFEN
+
+    assert "transcoding" in JOB_OFFEN, "die Kompression gehoert zum Vorgang"
+    assert "canceling" in JOB_OFFEN, "ein Abbruch ist auch noch nicht durch"
+    assert "completed" not in JOB_OFFEN and "failed" not in JOB_OFFEN
+
+
+def test_auswurf_bleibt_waehrend_der_kompression_erlaubt():
+    """Waechter gegen einen zu breiten Riegel: `has_active_job` fragt „haelt
+    jemand das Laufwerk?" — waehrend der Kompression tut das niemand, die Disc
+    darf raus. Nur die AUTOMATIK haelt sich zurueck."""
+    import inspect
+
+    from rippy import store
+
+    assert "transcoding" not in inspect.getsource(store.has_active_job)
+
+
+def test_laufwerk_bleibt_waehrend_eines_rips_unberuehrt(monkeypatch):
+    """Befund 30.08.2026, aus dem Protokoll des Commanders:
+
+        12:49:52  bluray-Rip gestartet
+        12:50:09  [watcher] Laufwerk G: beantwortet keine Medien-Abfragen
+        12:50:12  MSG 2003 SCSI-Fehler ILLEGAL REQUEST:INVALID FIELD IN CDB
+        12:50:12  makemkvcon endete mit Code 11
+
+    Der Waechter fragt alle drei Sekunden ab — drei CreateFileW plus IOCTLs
+    auf ein Geraet, das makemkvcon gerade liest. Sein Befund: das Laufwerk
+    hoert einfach auf zu lesen. `_auto_prescan` haelt sich seit dem
+    29.08.2026 an dieselbe Regel; die Laufwerksabfrage tat es nicht.
+    """
+    import main
+
+    gefragt = []
+    monkeypatch.setattr(main.device_discovery, "list_optical_devices",
+                        lambda: ["/dev/sr0"])
+    monkeypatch.setattr(main.device_discovery, "device_info",
+                        lambda p: gefragt.append(p) or dict({"id": "sr0", "name": "Laufwerk", "type": "bluray", "path": "/dev/sr0", "status": "ready", "model": "X", "serial": "Y", "grund": ""}))
+    monkeypatch.setattr(main, "LETZTE_LAUFWERKE", [dict({"id": "sr0", "name": "Laufwerk", "type": "bluray", "path": "/dev/sr0", "status": "ready", "model": "X", "serial": "Y", "grund": ""})])
+    monkeypatch.setattr(main.db, "has_active_job", lambda p: True)
+
+    stand = main.laufwerke_mit_disc()
+    assert gefragt == [], "waehrend eines Rips darf niemand das Laufwerk anfassen"
+    assert stand[0]["type"] == "bluray"      # letzter bekannter Stand gilt
+
+
+def test_ohne_rip_wird_das_laufwerk_normal_abgefragt(monkeypatch):
+    """Die Ausnahme darf nur fuer den laufenden Rip gelten."""
+    import main
+
+    gefragt = []
+    monkeypatch.setattr(main.device_discovery, "list_optical_devices",
+                        lambda: ["/dev/sr0"])
+    monkeypatch.setattr(main.device_discovery, "device_info",
+                        lambda p: gefragt.append(p) or dict({"id": "sr0", "name": "Laufwerk", "type": "bluray", "path": "/dev/sr0", "status": "ready", "model": "X", "serial": "Y", "grund": ""}))
+    monkeypatch.setattr(main, "LETZTE_LAUFWERKE", [dict({"id": "sr0", "name": "Laufwerk", "type": "bluray", "path": "/dev/sr0", "status": "ready", "model": "X", "serial": "Y", "grund": ""})])
+    monkeypatch.setattr(main.db, "has_active_job", lambda p: False)
+
+    main.laufwerke_mit_disc()
+    assert gefragt == ["/dev/sr0"]

docker/api/test_clients.py

@@ -0,0 +1,157 @@
+"""Die Metadaten-Clients muessen sich OHNE Datenbank und OHNE Redis bauen lassen.
+
+## Warum es diese Tests gibt (Befund 28.08.2026)
+
+Der Commander meldete, dass eine eingelegte Blu-ray namenlos blieb und keine
+Metadaten-Abfrage lief. Zwei Ursachen, beide unsichtbar:
+
+**1. Ein Phantom-Modul.** `clients/tmdb.py`, `clients/omdb.py` und
+`clients/thetvdb.py` machten im Konstruktor `from db import get_settings`.
+`docker/api/db.py` gibt es seit der Zusammenlegung in V2-1 (dd1d0b7) nicht
+mehr — main.py schreibt seitdem `from rippy import store as db`, diese drei
+Module haben es nie mitbekommen. Damit starb JEDE Metadaten-Abfrage schon
+beim Erzeugen des Clients mit `ModuleNotFoundError`, auf Windows UND auf der
+VM. `_auto_prescan` verschluckte es in seinem `except Exception`.
+
+**2. Ein harter Redis-Zwang.** `cache/cache.py` sprach `redis:6379` an — den
+Dienstnamen aus `docker-compose.yml`. Auf einem Windows-PC gibt es kein
+Redis, und jeder Zugriff endete mit `ConnectionError`. Das riss den Pre-Scan
+mit.
+
+Beide Male war der SYMPTOM sichtbar (keine Metadaten) und die URSACHE nicht.
+Diese Tests machen die Ursache sichtbar: Sie bauen die Clients und benutzen
+den Zwischenspeicher, ohne dass irgendetwas davon erreichbar sein muss.
+"""
+
+import pytest
+
+
+def test_tmdb_client_baut_sich_ohne_datenbank():
+    """Der Test, der den Phantom-Import gefangen haette."""
+    from clients.tmdb import TMDBClient
+
+    klient = TMDBClient()
+    assert hasattr(klient, "api_key")
+
+
+def test_omdb_client_baut_sich_ohne_datenbank():
+    from clients.omdb import OMDbClient
+
+    assert OMDbClient() is not None
+
+
+def test_thetvdb_client_baut_sich_ohne_datenbank():
+    from clients.thetvdb import TheTVDBClient
+
+    assert TheTVDBClient() is not None
+
+
+def test_kein_client_importiert_das_verschwundene_db_modul():
+    """Der Waechter gegen genau diesen Fehler, mechanisch.
+
+    Ein `from db import ...` faellt sonst erst auf, wenn jemand eine Disc
+    einlegt — und dann als „keine Metadaten", nicht als Import-Fehler.
+    """
+    import os
+
+    hier = os.path.dirname(os.path.abspath(__file__))
+    fundstellen = []
+    for wurzel, ordner, dateien in os.walk(os.path.join(hier, "clients")):
+        ordner[:] = [o for o in ordner if o != "__pycache__"]
+        for name in dateien:
+            if not name.endswith(".py"):
+                continue
+            pfad = os.path.join(wurzel, name)
+            with open(pfad, encoding="utf-8") as f:
+                for nr, zeile in enumerate(f, 1):
+                    if zeile.strip().startswith(("from db import", "import db")):
+                        fundstellen.append("%s:%d" % (name, nr))
+    assert not fundstellen, (
+        "docker/api/db.py gibt es seit V2-1 nicht mehr — benutzt "
+        "rippy.store. Fundstellen: " + ", ".join(fundstellen))
+
+
+# ── Der Zwischenspeicher ────────────────────────────────────────────────
+def test_cache_ohne_redis_liefert_None_statt_zu_werfen():
+    """Ein Zwischenspeicher ist eine Beschleunigung, keine Voraussetzung.
+
+    Auf einem Windows-PC gibt es kein Redis. Vorher riss jeder Zugriff den
+    Pre-Scan mit — und die Disc blieb namenlos.
+    """
+    from cache import cache
+
+    class ToterRedis:
+        def get(self, *a, **k):
+            raise cache.RedisError("nicht erreichbar")
+
+        def set(self, *a, **k):
+            raise cache.RedisError("nicht erreichbar")
+
+        def setex(self, *a, **k):
+            raise cache.RedisError("nicht erreichbar")
+
+        def delete(self, *a, **k):
+            raise cache.RedisError("nicht erreichbar")
+
+        def flushdb(self, *a, **k):
+            raise cache.RedisError("nicht erreichbar")
+
+        def ping(self, *a, **k):
+            raise cache.RedisError("nicht erreichbar")
+
+    echt = cache.redis_client
+    cache.redis_client = ToterRedis()
+    try:
+        assert cache.get("egal") is None
+        assert cache.set("egal", {"a": 1}) is False
+        assert cache.delete("egal") is False
+        assert cache.clear() is False
+        cache.init_cache()               # darf ebenfalls nicht werfen
+        assert cache.zustand()["erreichbar"] is False
+    finally:
+        cache.redis_client = echt
+
+
+def test_cache_meldet_den_ausfall_nur_EINMAL(capsys):
+    """Eine Meldung je Anfrage waere Laerm — und bei jedem Titel-Suchlauf
+    kaeme sie mehrfach."""
+    from cache import cache
+
+    class ToterRedis:
+        def get(self, *a, **k):
+            raise cache.RedisError("weg")
+
+    echt, zustand = cache.redis_client, cache._erreichbar
+    cache.redis_client = ToterRedis()
+    cache._erreichbar = None
+    try:
+        for _ in range(5):
+            cache.get("x")
+        ausgabe = capsys.readouterr().out
+        assert ausgabe.count("nicht erreichbar") == 1, ausgabe
+    finally:
+        cache.redis_client, cache._erreichbar = echt, zustand
+
+
+def test_ein_kaputter_eintrag_wirft_nicht():
+    """Ein unlesbarer Eintrag ist kein Grund zu scheitern — dann wird die
+    Antwort eben frisch geholt."""
+    from cache import cache
+
+    class KaputterRedis:
+        def get(self, *a, **k):
+            return "{kein json"
+
+    echt = cache.redis_client
+    cache.redis_client = KaputterRedis()
+    try:
+        assert cache.get("x") is None
+    finally:
+        cache.redis_client = echt
+
+
+@pytest.mark.parametrize("name", ["tmdb", "omdb", "jikan", "musicbrainz"])
+def test_jeder_client_ist_importierbar(name):
+    """Ein Tippfehler in einem Modulpfad faellt sonst erst auf, wenn jemand
+    eine Disc einlegt."""
+    __import__("clients." + name)

docker/api/test_eta.py

@@ -157,3 +157,73 @@ def test_fertige_und_wartende_jobs_bekommen_keine_eta():
             speicher.get, lambda k, v, expire=None: speicher.__setitem__(k, v))
         assert ergebnis == {"sekunden": -1, "text": ""}
     assert speicher == {}  # nichts geschrieben
+
+
+# ── Ohne Redis muss die Schaetzung trotzdem zustande kommen ─────────────
+#
+# Commander 29.08.2026: „Über den kompletten vorgang steht dort ‚Restzeit wird
+# gemessen' aber messung wird nicht abgeschlossen. Das heißt man hat kein ETA"
+#
+# Die Messreihe lag nur im Cache, und der Modul-Kopf sagte „Der Cache (Redis)
+# ist schon da". Im Container stimmt das. Auf einem Windows-PC gab `cache_get`
+# bei JEDEM Aufruf None zurueck — also jedes Mal eine frische Reihe mit EINEM
+# Punkt, und `restzeit_sekunden` braucht zwei.
+
+
+def _ohne_cache():
+    """Ein Cache, der nichts behaelt — genau wie Redis, das es nicht gibt."""
+    return (lambda k: None), (lambda k, v, expire=None: False)
+
+
+def test_ohne_cache_kommt_trotzdem_eine_schaetzung():
+    """DER Fall des Commanders."""
+    import eta
+
+    eta._REIHEN.clear()
+    lesen, schreiben = _ohne_cache()
+    # Zwei Messpunkte, 120 s auseinander, 10 % Fortschritt.
+    eta.aktualisiere_und_schaetze("j1", "running", 10, 1000.0, lesen, schreiben)
+    ergebnis = eta.aktualisiere_und_schaetze("j1", "running", 20, 1120.0, lesen, schreiben)
+
+    assert ergebnis["sekunden"] > 0, "ohne Redis kam nie eine Zahl heraus"
+    assert ergebnis["text"], "und damit stand dauerhaft „wird gemessen"
+
+
+def test_der_cache_hat_weiterhin_vorrang():
+    """Wo es Redis gibt, bleibt Redis die Quelle — es ueberlebt einen
+    API-Neustart, das Woerterbuch im Prozess nicht."""
+    import eta
+
+    eta._REIHEN.clear()
+    aus_dem_cache = {"status": "running", "punkte": [[500.0, 5], [560.0, 15]]}
+    ergebnis = eta.aktualisiere_und_schaetze(
+        "j2", "running", 25, 620.0,
+        lambda k: aus_dem_cache, lambda k, v, expire=None: True)
+    # Drei Punkte, 120 s fuer 20 % -> die Reihe aus dem Cache wurde benutzt.
+    assert ergebnis["sekunden"] > 0
+
+
+def test_ein_statuswechsel_beginnt_auch_ohne_cache_neu():
+    """Rip und Kompression haben nichts miteinander zu tun."""
+    import eta
+
+    eta._REIHEN.clear()
+    lesen, schreiben = _ohne_cache()
+    eta.aktualisiere_und_schaetze("j3", "running", 50, 1000.0, lesen, schreiben)
+    eta.aktualisiere_und_schaetze("j3", "running", 90, 1100.0, lesen, schreiben)
+    neu = eta.aktualisiere_und_schaetze("j3", "transcoding", 5, 1110.0, lesen, schreiben)
+    assert neu["sekunden"] == -1, "nach dem Wechsel gibt es noch keine Aussage"
+
+
+def test_alte_reihen_wachsen_nicht_unbegrenzt():
+    """Wer einen Vorrat anlegt, raeumt ihn auch weg (AGENTS.md)."""
+    import eta
+
+    eta._REIHEN.clear()
+    lesen, schreiben = _ohne_cache()
+    eta.aktualisiere_und_schaetze("alt", "running", 10, 0.0, lesen, schreiben)
+    # Einen Tag spaeter ein anderer Job -> der alte fliegt raus.
+    eta.aktualisiere_und_schaetze("neu", "running", 10,
+                                  eta.REIHE_HALTBAR_SEKUNDEN + 10.0, lesen, schreiben)
+    assert eta.schluessel("alt") not in eta._REIHEN
+    assert eta.schluessel("neu") in eta._REIHEN

docker/api/test_makemkv_key.py

@@ -1,4 +1,6 @@
 """Tests für den MakeMKV-Beta-Key-Parser (dependency-frei, nur extract_key)."""
+import pytest
+
 from makemkv_key import extract_key
 
 # Beispiel-Key im echten Format (T- + 64 Zeichen [A-Za-z0-9_]).
@@ -26,3 +28,71 @@ def test_extract_key_liefert_ganzen_key():
     treffer = extract_key(f"Vorher-Text {_KEY} Nachher-Text")
     assert treffer == _KEY
     assert treffer.startswith("T-")
+
+
+# ── Der Knopf „Jetzt aus dem Forum holen" (Commander 28.08.2026) ─────────
+#
+# > „Bezüglich des MKV Beta Keys - der könnte theoretisch auch automatisch
+# > ausgelesen werden, ich glaube das web rippy kann das"
+#
+# Er hatte recht: `refresh_loop()` laeuft seit jeher taeglich mit (main.py,
+# Startereignis). Gemessen am 28.08.2026: Forum antwortet in 3,3 s, Key mit 62
+# Zeichen. Nur war davon NICHTS zu sehen — kein Knopf, keine Meldung. Eine
+# Automatik, die man nicht sehen kann, ist fuer den Benutzer keine.
+
+@pytest.fixture
+def klient():
+    from fastapi.testclient import TestClient
+
+    from main import app
+    return TestClient(app)
+
+
+def test_der_knopf_holt_und_meldet_was_passiert_ist(klient, monkeypatch):
+    import main as api
+
+    monkeypatch.setattr("makemkv_key.fetch_current_key", lambda *a, **k: _KEY)
+    monkeypatch.setattr("makemkv_key._apply_key", lambda key: True)
+    monkeypatch.setattr(api.db, "add_log", lambda *a, **k: None)
+
+    antwort = klient.post("/system/makemkv-key/holen")
+    assert antwort.status_code == 200
+    daten = antwort.json()
+    assert daten["geholt"] is True
+    assert daten["geaendert"] is True
+    assert daten["endet_auf"] == _KEY[-6:]
+
+
+def test_der_key_selbst_wandert_NICHT_ueber_die_leitung(klient, monkeypatch):
+    """Er steht in den Einstellungen. Ein zweiter Weg zu demselben Wert ist
+    ein zweiter Weg, ihn zu verlieren."""
+    import main as api
+
+    monkeypatch.setattr("makemkv_key.fetch_current_key", lambda *a, **k: _KEY)
+    monkeypatch.setattr("makemkv_key._apply_key", lambda key: False)
+    monkeypatch.setattr(api.db, "add_log", lambda *a, **k: None)
+
+    text = klient.post("/system/makemkv-key/holen").text
+    assert _KEY not in text
+    assert _KEY[:20] not in text
+
+
+def test_ein_stummes_forum_ist_ein_klarer_fehler_kein_leerer_erfolg(klient,
+                                                                   monkeypatch):
+    """Sonst hiesse „geholt: true" mit leerem Key, es sei alles in Ordnung."""
+    def wirft(*a, **k):
+        raise OSError("Verbindung abgelehnt")
+
+    monkeypatch.setattr("makemkv_key.fetch_current_key", wirft)
+    antwort = klient.post("/system/makemkv-key/holen")
+    assert antwort.status_code == 502
+    assert "Forum" in antwort.json()["detail"]
+
+
+def test_geaendertes_seitenformat_wird_benannt(klient, monkeypatch):
+    """Kein Treffer heisst NICHT „kein Key noetig" — es heisst, die Seite hat
+    sich geaendert. Das muss dastehen, sonst sucht niemand danach."""
+    monkeypatch.setattr("makemkv_key.fetch_current_key", lambda *a, **k: None)
+    antwort = klient.post("/system/makemkv-key/holen")
+    assert antwort.status_code == 502
+    assert "geändert" in antwort.json()["detail"]

docker/api/test_pfadgrenze.py

@@ -0,0 +1,79 @@
+"""Welche Pfade darf die API anfassen — und wo ist „oben"?
+
+## Warum diese Grenze verschiebbar sein muss (Befund 28.08.2026)
+
+`MEDIA_ROOT = "/app/media"` war zugleich Vorgabe UND Pfadgrenze. Im Container
+ist beides richtig. Auf dem Windows-PC des Commanders war beides falsch, und
+die Folge war eine Oberflaeche, die stillschweigend nichts konnte:
+
+* `/storage-targets` lieferte `[]` (der Ordner existiert dort nicht),
+* `/browse` antwortete auf JEDEN Pfad mit 422,
+* im Auswahlfeld fuer das Arbeitsverzeichnis stand genau ein Eintrag.
+
+Sein Befund dazu: „Wäre es möglich das Arbeitsverzeichnis zu ändern?
+momentan geht das nicht."
+
+Die Grenze faellt aber NICHT einfach weg. Im Container haengt die API im
+Netz — eine Weboberflaeche, die jeden Pfad des Wirts ausliefern kann, ist ein
+Loch. Sie gilt nur dort nicht, wo Rippy den Menschen bedient, der vor dem
+Rechner sitzt. Diese Tests halten beide Haelften fest.
+"""
+
+import main
+
+
+# ── Die Grenze gilt, wo zugehoert wird ──────────────────────────────────
+def test_im_container_gilt_die_wurzel_weiter():
+    """Der Docker-Weg darf sich durch die Reparatur NICHT lockern."""
+    assert main.pfad_erlaubt("/app/media/movies", "/app/media", frei=False)
+    assert not main.pfad_erlaubt("/etc/passwd", "/app/media", frei=False)
+    # Der Klassiker: beginnt mit der Wurzel, liegt aber ausserhalb.
+    assert not main.pfad_erlaubt("/app/media-boese/x", "/app/media", frei=False)
+
+
+def test_nativ_ist_auch_eine_freigabe_erlaubt():
+    """Sein Ziel ist `\\\\192.168.179.62\\rippy\\movies` — das liegt unter gar
+    keiner lokalen Wurzel. Mit der alten Regel war es unerreichbar."""
+    assert main.pfad_erlaubt(r"\\192.168.179.62\rippy\movies", "/app/media", frei=True)
+    assert main.pfad_erlaubt(r"D:\Rippy-Arbeit", "/app/media", frei=True)
+
+
+def test_ein_leerer_pfad_ist_nie_erlaubt():
+    """Sonst wuerde aus einem vergessenen Feld ein Zugriff auf `/`."""
+    assert not main.pfad_erlaubt("", "/app/media", frei=True)
+    assert not main.pfad_erlaubt("", "/app/media", frei=False)
+
+
+# ── Wo ist oben ─────────────────────────────────────────────────────────
+def test_an_der_wurzel_ist_schluss():
+    """Im Container. `None` heisst: kein Knopf „nach oben"."""
+    assert main.eltern_von("/app/media", "/app/media", frei=False) is None
+    assert main.eltern_von("/app/media/movies", "/app/media", frei=False) == "/app/media"
+
+
+def test_ueber_der_laufwerkswurzel_steht_die_laufwerksliste():
+    """Zwei Fallen auf einmal.
+
+    `os.path.dirname("C:\\\\")` ist wieder `"C:\\\\"` — ein Knopf „nach oben",
+    der auf denselben Ordner zeigt, sieht aus wie ein Fehler. Und ueber der
+    Laufwerkswurzel steht nicht *nichts*, sondern die Liste der Laufwerke:
+    Sonst kaeme man von `D:\\` nie zu `C:\\`, und genau dort ist Platz fuer
+    100 GB Rohdaten.
+    """
+    import ntpath
+    import os
+
+    echt = os.path.dirname
+    os.path.dirname = ntpath.dirname          # Windows-Pfade auch auf Linux
+    try:
+        assert main.eltern_von("C:\\", "D:\\Rippy", frei=True) == ""
+        assert main.eltern_von("C:\\Users\\Tobi", "D:\\Rippy", frei=True) == "C:\\Users"
+    finally:
+        os.path.dirname = echt
+
+
+def test_die_wurzel_kommt_aus_dem_betrieb_und_ist_nie_leer():
+    """Eine leere Wurzel wuerde jede Pruefung durchwinken."""
+    assert main.medien_wurzel()
+
+

docker/api/test_prescan_helpers.py

@@ -144,3 +144,80 @@ def test_ohne_jede_quelle_bleibt_es_unbekannt(monkeypatch):
     assert ergebnis.confidence == 0.3
     assert ergebnis.metadata["type"] == "unknown"
     assert ergebnis.title == "Nix Da"
+
+
+# ── Was auf FREMDEN Rechnern gilt (Befund 28.08.2026) ───────────────────
+#
+# Der Commander: "du hast jetzt nur mein laufwerk analysiert oder? wenn ich
+# rippy weitergebe wie laeuft es dort?"
+#
+# Berechtigt. Gemessen wurde an EINEM Laufwerk (LG BU40N) und EINER Disc
+# (BD-50 mit BDMV/META). Diese Tests halten fest, was bei ANDEREN Discs
+# passieren muss -- ohne dass eine davon vorhanden sein muss.
+def test_bluray_ohne_metadaten_gibt_ehrlich_nichts_zurueck(tmp_path):
+    """Sehr viele Blu-rays haben kein BDMV/META. Dann greift der Rueckfall
+    auf das Volume-Label -- aber diese Funktion darf nichts erfinden."""
+    from prescan.prescan import titel_aus_bdmt
+
+    (tmp_path / "BDMV" / "STREAM").mkdir(parents=True)
+    assert titel_aus_bdmt(str(tmp_path)) is None
+
+
+def test_dvd_hat_kein_bdmv(tmp_path):
+    from prescan.prescan import titel_aus_bdmt
+
+    (tmp_path / "VIDEO_TS").mkdir()
+    assert titel_aus_bdmt(str(tmp_path)) is None
+
+
+def test_bdmt_wird_gelesen_wenn_da(tmp_path):
+    """Der Weg, der bei der Disc des Commanders 'Evangelion 2.22' lieferte —
+    hier ohne Disc nachgestellt."""
+    from prescan.prescan import titel_aus_bdmt
+
+    meta = tmp_path / "BDMV" / "META" / "DL"
+    meta.mkdir(parents=True)
+    (meta / "bdmt_deu.xml").write_text(
+        '<?xml version="1.0"?><disclib><di:discinfo>'
+        '<di:title><di:name>Evangelion 2.22</di:name></di:title>'
+        '</di:discinfo></disclib>', encoding="utf-8")
+    assert titel_aus_bdmt(str(tmp_path)) == "Evangelion 2.22"
+
+
+def test_englisch_wird_bevorzugt(tmp_path):
+    """Die APIs suchen mit englischen Titeln besser."""
+    from prescan.prescan import titel_aus_bdmt
+
+    meta = tmp_path / "BDMV" / "META" / "DL"
+    meta.mkdir(parents=True)
+    for datei, name in (("bdmt_deu.xml", "Deutscher Titel"),
+                        ("bdmt_eng.xml", "English Title")):
+        (meta / datei).write_text(
+            "<x><di:name>%s</di:name></x>" % name, encoding="utf-8")
+    assert titel_aus_bdmt(str(tmp_path)) == "English Title"
+
+
+def test_prescan_ruft_makemkvcon_nicht_mehr_auf():
+    """Der makemkvcon-Zweig (Titel-Quelle 3) wurde mit d3e86d2 bewusst
+    ENTFERNT — er lief unter Windows nie (`shutil.which` findet dort nichts,
+    Programme liegen in „Programme", nicht im PATH) und war unter Docker
+    doppelt zum eigentlichen Rip-Weg. Dieser Waechter passt auf, dass weder
+    der Aufruf noch die shutil.which-Suche zurueckkommen.
+
+    (Bis 30.08.2026 verlangte er stattdessen `werkzeug_katalog.finden` —
+    das war die Welt VOR d3e86d2. Er laeuft nur in der CI (fcntl) und hat
+    die Entfernung deshalb erst dort gemeldet.)"""
+    import os
+
+    hier = os.path.dirname(os.path.abspath(__file__))
+    with open(os.path.join(hier, "prescan", "prescan.py"), encoding="utf-8") as f:
+        # NUR Code, keine Kommentare: Der erste Anlauf dieses Tests fiel ueber
+        # den eigenen Erklaertext, in dem der alte Aufruf zitiert wird. Ein
+        # Waechter, der an einer Erklaerung scheitert, prueft das Falsche.
+        code = [z for z in f if not z.strip().startswith("#")]
+    quelle = "".join(code)
+    assert "shutil.which(" not in quelle, (
+        "shutil.which findet unter Windows keine Programme aus 'Programme'")
+    assert "makemkvcon" not in quelle, (
+        "Der makemkvcon-Zweig im Prescan wurde mit d3e86d2 entfernt und "
+        "soll nicht zurueckkommen — Titel kommen aus Label/BDMV/IFO.")

docker/api/test_prescan_treffer.py

@@ -0,0 +1,156 @@
+"""Wann gilt ein TMDB-Treffer als sicher genug? — ohne Netz geprueft.
+
+## Der Befund des Commanders (28.08.2026)
+
+> „Was ist mit dem Cover auf Windows Rippy? In der Web Version haben wir ein
+> cover."
+
+Es gab keins, weil es gar keinen Treffer gab. Der Grund war nicht Windows,
+sondern eine Bedingung im Pre-Scan:
+
+    if movie.get("title", "").lower() == kandidat.lower():
+
+An seiner Disc gemessen:
+
+    'Evangelion 2.22'    1 Treffer   Evangelion: 2.0 You Can (Not) Advance
+    'Evangelion'        20 Treffer   irgendein Evangelion
+
+Der EINZIGE Treffer auf den vollen Disc-Titel war der richtige Film, mit
+Poster — und wurde verworfen, weil der Titel nicht woertlich gleich war.
+
+## Warum die Trefferzahl und nicht die Aehnlichkeit
+
+„Evangelion 2.22" gegen „Evangelion: 2.0 You Can (Not) Advance" ergibt 0,51
+Aehnlichkeit — das steht als Messung schon laenger im Code und faellt durch
+jedes sinnvolle Gatter. Die SPEZIFITAET der Anfrage sagt mehr: Wer auf den
+vollen Disc-Titel eine Handvoll Treffer bekommt, hat gefragt wie jemand, der
+weiss was er sucht. Wer 20 bekommt, hat geraten.
+
+Diese Tests spritzen die Clients ein — kein Netz, keine Schluessel, keine
+Disc.
+"""
+
+import pytest
+
+
+class FakeTMDB:
+    """Ein TMDB, das genau die gemessenen Antworten liefert."""
+
+    def __init__(self, treffer_je_suche, details=None):
+        self.treffer = treffer_je_suche
+        self.details = details or {}
+        self.gefragt = []
+
+    def search_movie(self, begriff):
+        self.gefragt.append(begriff)
+        return self.treffer.get(begriff, [])
+
+    def search_tv(self, begriff):
+        return []
+
+    def get_movie_details(self, kennung):
+        return self.details.get(kennung)
+
+    def get_tv_details(self, kennung):
+        return None
+
+    def find_by_imdb(self, kennung):
+        return None
+
+
+class StummerClient:
+    def lookup(self, *a, **k):
+        return None
+
+
+DETAILS_2_0 = {
+    22843: {
+        "title": "Evangelion: 2.0 You Can (Not) Advance",
+        "release_date": "2009-06-27",
+        "overview": "Der Pilotin Mari gelingt es …",
+        "poster_path": "/hpChtHPoXGTfhphnHGXj2kGXZeH.jpg",
+        "backdrop_path": "/pzsVGcufDdBLmvagKyLFKaeA4O5.jpg",
+        "runtime": 112,
+        "genres": [{"name": "Animation"}],
+    }
+}
+
+
+def _prescan(tmdb):
+    from prescan.prescan import PreScan
+
+    p = PreScan()
+    p.tmdb = tmdb
+    p.jikan = StummerClient()
+    p.omdb = StummerClient()
+    return p
+
+
+def _toc(titel):
+    return {"title": titel, "year": None, "tracks": [], "duration": 0,
+            "disc_type": "Blu-ray", "fingerprint": "TEST|1"}
+
+
+def test_der_einzige_treffer_auf_den_vollen_titel_gilt():
+    """DER Fall des Commanders. Vorher: kein Treffer, kein Cover, 30 %."""
+    tmdb = FakeTMDB(
+        {"Evangelion 2.22": [{"id": 22843,
+                              "title": "Evangelion: 2.0 You Can (Not) Advance"}]},
+        DETAILS_2_0)
+    ergebnis = _prescan(tmdb)._scan_video("/dev/x", _toc("Evangelion 2.22"))
+
+    assert ergebnis.confidence == 0.8
+    assert ergebnis.title == "Evangelion: 2.0 You Can (Not) Advance"
+    assert ergebnis.year == 2009
+    assert ergebnis.metadata["poster_path"], "ohne poster_path gibt es kein Cover"
+    assert ergebnis.metadata["source"] == "tmdb"
+
+
+def test_woertlich_gleicher_titel_bleibt_sicherer():
+    """Ein exakter Treffer muss weiterhin hoeher stehen als ein spezifischer."""
+    tmdb = FakeTMDB(
+        {"Logan": [{"id": 22843, "title": "Logan"}]},
+        {22843: dict(DETAILS_2_0[22843], title="Logan")})
+    ergebnis = _prescan(tmdb)._scan_video("/dev/x", _toc("Logan"))
+    assert ergebnis.confidence == 0.95
+
+
+def test_zwanzig_treffer_gelten_NICHT_als_sicher():
+    """Wer 20 Treffer bekommt, hat geraten — das darf kein 80-Prozent-Fund
+    werden. Es bleibt beim ehrlichen Vorschlag."""
+    viele = [{"id": 1000 + i, "title": "Evangelion %d" % i} for i in range(20)]
+    tmdb = FakeTMDB({"Evangelion": viele},
+                    {1000: dict(DETAILS_2_0[22843], title="Irgendein Evangelion")})
+    ergebnis = _prescan(tmdb)._scan_video("/dev/x", _toc("Evangelion"))
+    assert ergebnis.confidence == 0.6, "20 Treffer sind kein sicherer Fund"
+
+
+def test_treffer_auf_eine_GEKUERZTE_variante_gilt_nicht_als_sicher():
+    """Die Spezifitaet zaehlt nur, wenn der VOLLE Disc-Titel gefragt wurde.
+
+    Sonst wuerde „Der Herr der Ringe: Die zwei Tuerme" ueber die Kuerzung
+    „Der Herr" zu einem 80-Prozent-Fund fuer irgendetwas.
+    """
+    tmdb = FakeTMDB(
+        {"Evangelion": [{"id": 22843, "title": "Neon Genesis Evangelion"}]},
+        {22843: dict(DETAILS_2_0[22843], title="Neon Genesis Evangelion")})
+    ergebnis = _prescan(tmdb)._scan_video("/dev/x", _toc("Evangelion 2.22"))
+    # Der volle Titel lieferte nichts, die Kuerzung schon -> nur Vorschlag.
+    assert ergebnis.confidence == 0.6
+
+
+def test_ohne_jeden_treffer_bleibt_es_ehrlich_bei_dreissig_prozent():
+    ergebnis = _prescan(FakeTMDB({}))._scan_video("/dev/x", _toc("Gibt Es Nicht"))
+    assert ergebnis.confidence == 0.3
+    assert ergebnis.metadata["type"] == "unknown"
+
+
+@pytest.mark.parametrize("anzahl,erwartet", [(1, 0.8), (3, 0.8), (4, 0.6)])
+def test_die_schwelle_liegt_bei_drei(anzahl, erwartet):
+    """Drei ist grosszuegig genug fuer Neuauflagen und Regie-Fassungen
+    desselben Films, aber eng genug, um Raten auszuschliessen."""
+    treffer = [{"id": 22843 + i, "title": "Film %d" % i} for i in range(anzahl)]
+    details = {22843: dict(DETAILS_2_0[22843], title="Film 0")}
+    tmdb = FakeTMDB({"Ein Sehr Genauer Titel": treffer}, details)
+    ergebnis = _prescan(tmdb)._scan_video("/dev/x", _toc("Ein Sehr Genauer Titel"))
+    assert ergebnis.confidence == erwartet

docker/api/test_rohdaten.py

@@ -19,13 +19,20 @@ def test_der_echte_fall_wird_gefunden():
     assert orte[0] == f"/app/temp/raw/{JOB}"
 
 
+# Die Wurzeln des CONTAINER-Betriebs, eingespritzt. Ohne sie hingen diese
+# Tests am laufenden Rechner: Unter Windows liefert `wurzeln()` echte
+# Windows-Pfade, und die Erwartungen hier gelten dort nicht (am 29.08.2026
+# prompt sieben Tests rot geworden).
+CONTAINER = ("/app/temp/raw", "/app/media", False)
+
+
 def test_suche_liefert_nur_was_existiert():
     vorhanden = {f"/app/media/rippy/{JOB}"}
     gefunden = rohdaten.suche(
         JOB, "",
         listdir=lambda p: ["movies", "rippy"],
         isdir=lambda p: p in vorhanden,
-    )
+     orte_wurzeln=CONTAINER)
     assert gefunden == [f"/app/media/rippy/{JOB}"]
 
 
@@ -51,6 +58,36 @@ def test_media_root_selbst_ist_erlaubt():
     assert f"/app/media/{JOB}" in orte
 
 
+#: Die Wurzeln eines NATIVEN Betriebs (Windows, freies Blättern) —
+#: Gegenstück zu CONTAINER weiter oben.
+NATIV = ("C:\\Rippy\\_arbeit", "C:\\Rippy", True)
+
+
+def test_laufwerks_wurzel_bleibt_absolut():
+    """Der Fall des Commanders (30.08.2026): Arbeitsordner F: — die Wurzel.
+
+    Hier wurde der Schluss-Trenner abgestreift und mit dem Rest dann auch
+    VERBUNDEN. Ein blosses "F:" ist unter Windows aber der AKTUELLE Ordner
+    auf Laufwerk F, nicht dessen Wurzel — die Suche sah damit an einer
+    ganz anderen Stelle nach. Ergebnis: 16,5 GB Rohschnitt unsichtbar, und
+    der Wiederholen-Dialog bot nur "Neu rippen" an: Stunden am
+    beschädigten Datenträger für etwas, das schon dalag.
+    """
+    orte = rohdaten.kandidaten(JOB, "F:\\", [], NATIV)
+    assert "F:" + chr(92) + JOB in orte
+    assert "F:" + JOB not in orte
+    # Ohne Schluss-Trenner muss dasselbe herauskommen
+    assert rohdaten.kandidaten(JOB, "F:\\Roh\\", [], NATIV)[-1] == (
+        "F:" + chr(92) + "Roh" + chr(92) + JOB)
+
+
+def test_media_root_mit_schluss_trenner_zaehlt_auch():
+    """/app/media/ und /app/media sind derselbe Ort — der Vergleich darf
+    nicht am Trenner scheitern."""
+    orte = rohdaten.kandidaten(JOB, "/app/media/", [], CONTAINER)
+    assert f"/app/media/{JOB}" in orte
+
+
 def test_ohne_job_id_nichts():
     assert rohdaten.kandidaten("", "/app/media", ["x"]) == []
 
@@ -64,7 +101,7 @@ def test_kaputter_mount_reisst_die_suche_nicht_mit():
         return p == f"/app/temp/raw/{JOB}"
 
     gefunden = rohdaten.suche(
-        JOB, "", listdir=lambda p: ["totes-nas", "movies"], isdir=isdir_kaputt)
+        JOB, "", listdir=lambda p: ["totes-nas", "movies"], isdir=isdir_kaputt, orte_wurzeln=CONTAINER)
     assert gefunden == [f"/app/temp/raw/{JOB}"]
 
 
@@ -73,7 +110,7 @@ def test_listdir_kaputt_faellt_auf_den_standard_zurueck():
         raise OSError("kein /app/media")
 
     gefunden = rohdaten.suche(
-        JOB, "", listdir=listdir_kaputt, isdir=lambda p: True)
+        JOB, "", listdir=listdir_kaputt, isdir=lambda p: True, orte_wurzeln=CONTAINER)
     assert gefunden == [f"/app/temp/raw/{JOB}"]
 
 
@@ -177,7 +214,7 @@ def test_suche_mit_der_zeitgrenze_findet_den_echten_fall():
         JOB, "",
         listdir=lambda p: ["bluray", "movies", "rippy"],
         isdir=lambda p: rohdaten.verzeichnis_da(p, laufen),
-    )
+     orte_wurzeln=CONTAINER)
     assert gefunden == [f"/app/media/rippy/{JOB}"]
 
 
@@ -206,7 +243,7 @@ def test_suche_mit_status_meldet_ungepruefte_orte():
         return "unklar" if pfad.startswith("/app/media/rippy/") else "weg"
 
     e = rohdaten.suche_mit_status(
-        JOB, "", listdir=lambda p: ["rippy"], pruefer=pruefe)
+        JOB, "", listdir=lambda p: ["rippy"], pruefer=pruefe, orte_wurzeln=CONTAINER)
     assert e == {"pfade": [], "unklar": True}
 
 
@@ -215,7 +252,7 @@ def test_suche_mit_status_ohne_zweifel():
         return "da" if pfad == f"/app/media/rippy/{JOB}" else "weg"
 
     e = rohdaten.suche_mit_status(
-        JOB, "", listdir=lambda p: ["movies", "rippy"], pruefer=pruefe)
+        JOB, "", listdir=lambda p: ["movies", "rippy"], pruefer=pruefe, orte_wurzeln=CONTAINER)
     assert e == {"pfade": [f"/app/media/rippy/{JOB}"], "unklar": False}
 
 
@@ -227,6 +264,43 @@ def test_suche_mit_status_findet_trotz_unklarem_anderen_ort():
         return "unklar" if "totes-nas" in pfad else "weg"
 
     e = rohdaten.suche_mit_status(
-        JOB, "", listdir=lambda p: ["rippy", "totes-nas"], pruefer=pruefe)
+        JOB, "", listdir=lambda p: ["rippy", "totes-nas"], pruefer=pruefe, orte_wurzeln=CONTAINER)
     assert e["pfade"] == [f"/app/media/rippy/{JOB}"]
     assert e["unklar"] is True
+
+
+def test_nativ_wird_kein_prozess_gestartet(monkeypatch, tmp_path):
+    """Befund 30.08.2026, an der laufenden Instanz beobachtet:
+
+        14:54:40  timeout.exe  timeout 4 ls -d C:...d7ee6c06-...
+        14:54:40  WindowsTerminal.exe
+
+    Der Commander sah Fenster aufblitzen. `timeout` und `ls` sind
+    Linux-Befehle; die Windows-eigene timeout.exe kennt weder `ls` noch
+    `-d`, braucht aber eine Konsole. Dreifach falsch: ein Fenster je
+    Durchlauf, ein Prozess fuer nichts, und Rueckgabewert ungleich 0 — also
+    die Antwort weg fuer JEDES Verzeichnis.
+    """
+    gestartet = []
+    monkeypatch.setattr(rohdaten, "nativ_nachsehen", lambda: True)
+    monkeypatch.setattr(rohdaten.subprocess, "run",
+                        lambda *a, **k: gestartet.append(a))
+    assert rohdaten.pruefen(str(tmp_path)) == "da"
+    assert rohdaten.pruefen(str(tmp_path / "gibt-es-nicht")) == "weg"
+    assert gestartet == [], "es darf kein Prozess gestartet werden"
+
+
+def test_im_container_bleibt_der_kindprozess(monkeypatch):
+    """Dort ist der Umweg richtig: os.path.isdir kann an einem toten
+    CIFS-Mount im Kernel haengen (Begruendung in verzeichnis_da)."""
+    monkeypatch.setattr(rohdaten, "nativ_nachsehen", lambda: False)
+    aufrufe = []
+
+    class Antwort:
+        returncode = 0
+
+    monkeypatch.setattr(rohdaten.subprocess, "run",
+                        lambda *a, **k: aufrufe.append(a[0]) or Antwort())
+    assert rohdaten.pruefen("/app/media/x") == "da"
+    assert aufrufe[0][0] == "timeout"
+    assert aufrufe[0][-1] == "/app/media/x"

docker/ui/src/App.tsx

@@ -7,6 +7,8 @@ import AnleitungPage from './pages/Anleitung'
 import FirstRunWizard from './components/FirstRunWizard'
 import { api } from './lib/api'
 import { EventStreamProvider, useStrom } from './lib/useEventStream'
+import { BetriebProvider } from './lib/useBetrieb'
+import { Fehlergrenze } from './components/Fehlergrenze'
 
 type Page = 'dashboard' | 'anleitung' | 'logs' | 'settings'
 
@@ -50,10 +52,45 @@ function AppInhalt() {
   // ihn statt des Dashboards. null = /setup noch nicht geprüft (kein Aufblitzen).
   const [setupDone, setSetupDone] = useState<boolean | null>(null)
 
+  /*
+   * ⚠️ Ein fehlgeschlagener Abruf ist KEINE Aussage über die Einrichtung.
+   *
+   * Hier stand `.catch(() => setSetupDone(true))` mit der Begründung
+   * „API/Setup nicht erreichbar → nicht blockieren". Die Folge hat der
+   * Commander am 28.08.2026 gemeldet: **Nach einer frischen Installation
+   * fehlte der Ersteinrichtungs-Assistent.**
+   *
+   * Und zwar zwangsläufig: Das Fenster geht unmittelbar nach dem Setup auf,
+   * der Dienst braucht ein bis zwei Sekunden bis zur ersten Antwort — der
+   * erste Abruf scheitert also fast immer. Aus „ich konnte nicht nachsehen"
+   * wurde „ist schon erledigt", und der Assistent war für immer weg.
+   *
+   * Dasselbe Prinzip steht nebenan in `useEventStream.tsx`: Wer nichts Neues
+   * weiß, behält, was er wusste — und behauptet nichts.
+   *
+   * Deshalb: nachfragen, bis der Server ANTWORTET. Erst eine Antwort
+   * entscheidet.
+   */
   useEffect(() => {
-    api.get('/setup')
-      .then((r) => setSetupDone(Boolean(r.data?.done)))
-      .catch(() => setSetupDone(true)) // API/Setup nicht erreichbar → nicht blockieren
+    let abgemeldet = false
+    let versuche = 0
+
+    const fragen = () => {
+      api.get('/setup')
+        .then((r) => { if (!abgemeldet) setSetupDone(Boolean(r.data?.done)) })
+        .catch(() => {
+          if (abgemeldet) return
+          versuche += 1
+          // Zwei Minuten lang alle zwei Sekunden. Antwortet der Server bis
+          // dahin nicht, hat der Nutzer ein anderes Problem als den
+          // Assistenten — dann zeigen wir die Oberfläche, damit er die Logs
+          // sehen kann.
+          if (versuche < 60) setTimeout(fragen, 2000)
+          else setSetupDone(true)
+        })
+    }
+    fragen()
+    return () => { abgemeldet = true }
   }, [])
 
   const navItems: { id: Page; label: string; icon: any }[] = [
@@ -63,7 +100,22 @@ function AppInhalt() {
     { id: 'settings', label: 'Einstellungen', icon: SettingsIcon },
   ]
 
-  if (setupDone === null) return null // kurzer Moment, bis /setup geantwortet hat
+  // Solange /setup noch nicht geantwortet hat: sagen, dass gewartet wird.
+  // Ein leeres Fenster sieht aus wie ein Absturz — und nach einer frischen
+  // Installation ist genau das der erste Eindruck.
+  if (setupDone === null) {
+    return (
+      <div className="min-h-screen flex items-center justify-center bg-[#0b0f19]">
+        <div className="text-center">
+          <div className="text-amber-400 text-3xl mb-3">◉</div>
+          <p className="text-slate-300 text-sm">Rippy startet …</p>
+          <p className="text-slate-500 text-xs mt-1 font-mono">
+            warte auf den Dienst
+          </p>
+        </div>
+      </div>
+    )
+  }
   if (!setupDone) return <FirstRunWizard onDone={() => setSetupDone(true)} />
 
   return (
@@ -110,10 +162,19 @@ function AppInhalt() {
 
       {/* Main Content Viewport */}
       <main className="max-w-[1400px] mx-auto px-4 sm:px-6 lg:px-8 py-8">
-        {currentPage === 'dashboard' && <Dashboard />}
-        {currentPage === 'anleitung' && <AnleitungPage />}
-        {currentPage === 'logs' && <LogsPage />}
-        {currentPage === 'settings' && <SettingsPage />}
+        {/* Je Seite eine eigene Grenze: Faellt eine aus, bleibt die
+            Navigation stehen und man kommt woanders hin. Ohne das war am
+            29.08.2026 nach einem Klick auf „Rippen starten" der ganze
+            Bildschirm leer — samt Kopfzeile. */}
+        <Fehlergrenze bereich={
+          currentPage === 'dashboard' ? 'Das Dashboard'
+            : currentPage === 'anleitung' ? 'Die Anleitung'
+            : currentPage === 'logs' ? 'Die Protokolle' : 'Die Einstellungen'}>
+          {currentPage === 'dashboard' && <Dashboard />}
+          {currentPage === 'anleitung' && <AnleitungPage />}
+          {currentPage === 'logs' && <LogsPage />}
+          {currentPage === 'settings' && <SettingsPage />}
+        </Fehlergrenze>
       </main>
     </div>
   )
@@ -123,9 +184,16 @@ export default function App() {
   // Der Provider haelt GENAU EINE SSE-Verbindung fuer die ganze Anwendung.
   // Ein Hook je Komponente waere eine Verbindung je Komponente — also das
   // alte Problem in neuer Form.
+  // BetriebProvider ganz aussen: Was Rippy anzeigen DARF, entscheidet sich
+  // vor allem anderen. Ohne ihn zeigte das Windows-Fenster "Pruefen: docker
+  // compose ps" — einen Rat, den dort niemand befolgen kann.
   return (
-    <EventStreamProvider>
-      <AppInhalt />
-    </EventStreamProvider>
+    <Fehlergrenze>
+      <BetriebProvider>
+        <EventStreamProvider>
+          <AppInhalt />
+        </EventStreamProvider>
+      </BetriebProvider>
+    </Fehlergrenze>
   )
 }

docker/ui/src/components/DeviceDiscovery.tsx

@@ -36,6 +36,8 @@ interface Device {
   serial?: string
   model?: string
   disc?: DiscInfo
+  /** Erkennung laeuft — noch kein Titel, aber auch kein leeres Laufwerk. */
+  disc_wird_erkannt?: boolean
 }
 
 function posterUrl(disc?: DiscInfo): string | null {
@@ -179,6 +181,34 @@ export default function DeviceDiscovery() {
       </CardHeader>
 
       <CardContent>
+        {/*
+          Die Erkennung LÄUFT NOCH — das muss man sehen.
+
+          Commander 29.08.2026: „das die disc erkennung noch läuft muss
+          sichtbar sein". An einer Blu-ray dauert sie rund zwei Minuten
+          (`makemkvcon info` läuft in seine 120-Sekunden-Grenze; gemessen:
+          Disc nach 119 s erkannt). Vorher war in dieser Zeit NICHTS zu
+          sehen — weder die Disc noch ein Hinweis. Das sah aus wie ein
+          leeres Laufwerk, also wie ein Fehler.
+        */}
+        {devices.filter(d => d.disc_wird_erkannt).map(device => (
+          <div
+            key={`erkennung-${device.id}`}
+            className="mb-6 rounded-2xl border border-slate-700 bg-slate-900/60 px-5 py-4 flex items-center gap-3"
+          >
+            <RefreshCw size={18} className="animate-spin text-amber-400 flex-shrink-0" />
+            <div>
+              <p className="font-semibold text-slate-200">
+                Disc wird gelesen — {device.name}
+              </p>
+              <p className="text-xs text-slate-400 mt-0.5">
+                Rippy liest Titel und Laufzeiten von der Disc. Das dauert bis
+                zu zwei Minuten; danach steht hier, was drin ist.
+              </p>
+            </div>
+          </div>
+        ))}
+
         {/* Disc-Karte: WAS liegt gerade im Laufwerk (Auto-Pre-Scan) */}
         {devices.filter(d => d.status === 'ready' && d.disc).map(device => (
           <div

docker/ui/src/components/Fehlergrenze.tsx

@@ -0,0 +1,100 @@
+/*
+ * Eine Fehlergrenze — damit ein Fehler nicht die ganze Oberfläche verschluckt.
+ *
+ * ## Der Befund des Commanders (29.08.2026)
+ *
+ * > „wenn man auf rippen starten klickt passiert irgendwas, was das Programm
+ * > nicht mag. Der Hintergrund ist einfach leer und er startet nix. Es gibt
+ * > auch keine fehlermeldung."
+ *
+ * Nachgestellt und in der Browser-Konsole gemessen:
+ *
+ *     TypeError: Cannot read properties of undefined (reading 'toUpperCase')
+ *
+ * Der Job war in Wirklichkeit angelegt und lief (gemessen: `processing`,
+ * 12 %). Nur zeigte die Oberfläche das nie — sie war weg. Grund: React baut
+ * bei einem Fehler im Zeichnen den GESAMTEN Baum ab, wenn ihn niemand
+ * auffängt. Und aufgefangen hat ihn niemand: Es gab in diesem Projekt keine
+ * einzige Fehlergrenze.
+ *
+ * ## Warum die eigentliche Reparatur woanders sitzt
+ *
+ * Die Ursache war ein Ereignis, das den halben Job schickte
+ * (`rippy/bus/waechter.py`), und zwei Stellen, die einen vollständigen
+ * annahmen. Das ist behoben. Diese Datei behebt etwas anderes: die WIRKUNG.
+ *
+ * Ein Programmierfehler in einer Karte darf den Rest des Bildschirms nicht
+ * mitnehmen — und schon gar nicht schweigend. Der nächste Fehler dieser Art
+ * kommt bestimmt; dann steht wenigstens da, was los ist, und der Rest der
+ * Oberfläche bleibt bedienbar.
+ *
+ * Deshalb wird sie ZWEIMAL eingesetzt: einmal um die ganze Anwendung, und
+ * einmal um den Job-Bereich allein. Fällt eine Karte aus, bleibt der Rest.
+ */
+
+import { Component, ErrorInfo, ReactNode } from 'react'
+
+interface Props {
+  children: ReactNode
+  /** Was hier kaputtgehen kann — steht in der Meldung. */
+  bereich?: string
+}
+
+interface State {
+  fehler: Error | null
+}
+
+export class Fehlergrenze extends Component<Props, State> {
+  state: State = { fehler: null }
+
+  static getDerivedStateFromError(fehler: Error): State {
+    return { fehler }
+  }
+
+  componentDidCatch(fehler: Error, info: ErrorInfo) {
+    // In die Konsole, damit die Ursache auffindbar bleibt. Ein stiller
+    // Fehler ist genau das, was diesen Befund so schwer gemacht hat.
+    console.error('Rippy: Fehler im Bereich', this.props.bereich || 'Oberfläche',
+      fehler, info.componentStack)
+  }
+
+  neuLaden = () => {
+    this.setState({ fehler: null })
+  }
+
+  render() {
+    if (!this.state.fehler) return this.props.children
+
+    return (
+      <div className="m-4 p-5 rounded-xl border border-amber-500/40 bg-amber-500/10">
+        <h2 className="font-semibold text-amber-700 dark:text-amber-300">
+          {this.props.bereich
+            ? `${this.props.bereich} lässt sich gerade nicht anzeigen`
+            : 'Diese Ansicht lässt sich gerade nicht anzeigen'}
+        </h2>
+        <p className="text-sm mt-2 text-slate-600 dark:text-slate-300">
+          Der Fehler betrifft nur die Anzeige.{' '}
+          <strong>Laufende Rips gehen weiter</strong> — Rippy arbeitet im
+          Hintergrund, auch wenn dieser Bereich leer bleibt.
+        </p>
+        <p className="text-xs mt-3 font-mono text-slate-500 dark:text-slate-400 break-all">
+          {this.state.fehler.message || String(this.state.fehler)}
+        </p>
+        <div className="flex gap-2 mt-4">
+          <button
+            onClick={this.neuLaden}
+            className="px-3 py-1.5 text-sm rounded-lg bg-amber-500 text-white hover:bg-amber-600"
+          >
+            Nochmal versuchen
+          </button>
+          <button
+            onClick={() => window.location.reload()}
+            className="px-3 py-1.5 text-sm rounded-lg border border-slate-300 dark:border-slate-700 text-slate-600 dark:text-slate-300"
+          >
+            Seite neu laden
+          </button>
+        </div>
+      </div>
+    )
+  }
+}

docker/ui/src/components/FirstRunWizard.tsx

@@ -1,6 +1,7 @@
 import { useState, useEffect } from 'react'
 import { Disc, Cpu, Globe, Tv, CheckCircle, ArrowRight, HardDrive, AlertTriangle, KeyRound } from 'lucide-react'
 import { api } from '../lib/api'
+import { useBetrieb } from '../lib/useBetrieb'
 import { MEDIA_SERVER_OPTIONEN } from '../lib/mediaServer'
 import { PRESET_KEINE, schwacheEncoderCpu } from '../lib/encoder'
 import { Button } from './ui/Button'
@@ -74,6 +75,7 @@ export default function FirstRunWizard({ onDone }: { onDone: () => void }) {
   const [makemkvKey, setMakemkvKey] = useState('')
   const [mediaServer, setMediaServer] = useState('jellyfin')
   const [transcodeEnabled, setTranscodeEnabled] = useState(true)
+  const betrieb = useBetrieb()
   const [workers, setWorkers] = useState<WorkerInfo[]>([])
   const [geraete, setGeraete] = useState<GeraetInfo[]>([])
   const [plaetze, setPlaetze] = useState<PlatzInfo[]>([])
@@ -197,7 +199,11 @@ export default function FirstRunWizard({ onDone }: { onDone: () => void }) {
                 schlechtText="Kein optisches Laufwerk gefunden. Rippy kann dann nur komprimieren, nicht rippen. Prüfe, ob das Laufwerk angeschlossen und (bei einer VM) durchgereicht ist."
               />
               <Zeile
-                titel="Encoding-Worker"
+                /* Auf einem Windows-PC gibt es keinen "Encoding-Worker" und
+                   keinen Worker-Container -- Rippy komprimiert selbst. Der
+                   Commander am 28.08.2026: "Das gilt fuer die ganze
+                   standalone version fuer Windows." */
+                titel={betrieb.kann.externe_worker ? 'Encoding-Worker' : 'Kompression'}
                 geladen={geladen}
                 gut={encoderWorker.length > 0}
                 gutText={encoderWorker.map(w => {
@@ -207,7 +213,9 @@ export default function FirstRunWizard({ onDone }: { onDone: () => void }) {
                     .filter(Boolean).join(', ')
                   return zusatz ? `${w.name} (${zusatz})` : w.name
                 }).join(' · ')}
-                schlechtText="Noch kein Worker gemeldet. Beim ersten Start dauert das bis zu einer Minute — diese Anzeige aktualisiert sich selbst. Bleibt es dabei, läuft der Worker-Container nicht."
+                schlechtText={betrieb.kann.externe_worker
+                  ? 'Noch kein Worker gemeldet. Beim ersten Start dauert das bis zu einer Minute — diese Anzeige aktualisiert sich selbst. Bleibt es dabei, läuft der Worker-Container nicht.'
+                  : 'Rippy meldet noch keine Encoder. Beim ersten Start dauert das bis zu einer Minute — diese Anzeige aktualisiert sich selbst.'}
               />
               <Zeile
                 titel="Freier Platz"
@@ -351,7 +359,7 @@ export default function FirstRunWizard({ onDone }: { onDone: () => void }) {
                       <span>Rippy hat deine Rechenleistung gemessen und passt die Wahl an.</span>
                     </p>
                     <p className="text-xs mt-2 text-amber-700/90 dark:text-amber-300/90">
-                      Keiner deiner Worker kann AVX2 — die Vektorbefehle, von denen H.265
+                      {betrieb.kann.externe_worker ? 'Keiner deiner Worker' : 'Dieser Rechner'} kann kein AVX2 — die Vektorbefehle, von denen H.265
                       lebt. 4K in H.265 würde hier <strong>ein bis zwei Tage pro Film</strong>
                       {' '}dauern. Deshalb wird eingestellt:
                     </p>

docker/ui/src/components/LiveLogSection.tsx

@@ -45,7 +45,10 @@ export default function LiveLogSection() {
           <CardTitle>Live-Log</CardTitle>
           <p className="text-sm text-slate-500 dark:text-slate-400">
             {currentJob 
-              ? `Aktiver Job: ${currentJob.type.toUpperCase()} (${currentJob.progress}%)`
+              // `type?.` ist hier kein Beiwerk: Ein frisch angelegter Job kann
+              // noch ohne Typ ankommen, und ohne das Fragezeichen riss diese
+              // eine Zeile am 29.08.2026 die GANZE Oberflaeche mit.
+              ? `Aktiver Job: ${currentJob.type?.toUpperCase() || 'Disc'} (${currentJob.progress ?? 0}%)`
               : 'Kein aktiver Job'}
           </p>
         </div>

docker/ui/src/components/OrdnerWaehler.tsx

@@ -0,0 +1,162 @@
+/*
+ * Ein Pfadfeld mit „Durchsuchen …" — wie im Installer.
+ *
+ * ## Der Wunsch des Commanders (29.08.2026)
+ *
+ * > „Wenn man im Nachhinein noch die Verzeichnisse ändern will, geht das
+ * > heute nur manuell über die einstellungen. Der Durchsuchen button fehlt.
+ * > Wie es der Installer auch macht"
+ *
+ * Er hat recht, und der Unterschied ist größer als ein Knopf: Im Setup wählt
+ * man den Ordner, danach musste man ihn abtippen. Einen Pfad wie
+ * `\\192.168.179.62\rippy\movies` tippt niemand zweimal richtig.
+ *
+ * ## Warum eine eigene Datei
+ *
+ * Weil es der DRITTE Ordner-Browser in diesem Projekt gewesen wäre:
+ * `RipTargetModal` hat einen, `StorageMounts` hat einen. Beide sind fest in
+ * ihre Karte eingebaut. Diesen hier kann jedes Feld benutzen.
+ *
+ * Der Browser selbst ist die API — `/browse` weiß seit dem 28.08.2026, in
+ * welchem Betrieb es läuft: im Container die Medien-Wurzel, nativ die Liste
+ * der Laufwerke. Diese Komponente muss darüber nichts wissen.
+ */
+
+import { useEffect, useState } from 'react'
+import { ArrowUp, Folder, FolderOpen } from 'lucide-react'
+
+import { api } from '../lib/api'
+import { Modal } from './ui/Modal'
+import { Button } from './ui/Button'
+import { Input } from './ui/Input'
+
+interface Eintrag {
+  name: string
+  path: string
+}
+
+interface Props {
+  label: string
+  value: string
+  placeholder?: string
+  onChange: (pfad: string) => void
+}
+
+export function OrdnerWaehler({ label, value, placeholder, onChange }: Props) {
+  const [offen, setOffen] = useState(false)
+  const [pfad, setPfad] = useState('')
+  const [eltern, setEltern] = useState<string | null>(null)
+  const [ordner, setOrdner] = useState<Eintrag[]>([])
+  const [fehler, setFehler] = useState('')
+  const [laedt, setLaedt] = useState(false)
+
+  const laden = async (ziel: string) => {
+    setLaedt(true)
+    setFehler('')
+    try {
+      const r = await api.get('/browse', { params: { path: ziel } })
+      setPfad(r.data.path || '')
+      setEltern(r.data.parent)
+      setOrdner(Array.isArray(r.data.dirs) ? r.data.dirs : [])
+    } catch (e: any) {
+      // Ein nicht lesbarer Ordner ist kein Grund, den Dialog zu schließen —
+      // man kommt mit „nach oben" wieder heraus.
+      setFehler(e?.response?.data?.detail || 'Ordner nicht lesbar')
+      setOrdner([])
+    } finally {
+      setLaedt(false)
+    }
+  }
+
+  useEffect(() => {
+    if (!offen) return
+    // Beim eingetragenen Wert einsteigen, sonst ganz oben. Leerer Pfad heißt
+    // für /browse „oberste Ebene" — nativ also die Laufwerksliste.
+    laden(value || '')
+  }, [offen])
+
+  return (
+    <div className="space-y-2">
+      <div className="flex items-end gap-2">
+        <div className="flex-1">
+          <Input
+            label={label}
+            value={value}
+            placeholder={placeholder}
+            onChange={(e) => onChange(e.target.value)}
+          />
+        </div>
+        <Button variant="secondary" onClick={() => setOffen(true)}>
+          Durchsuchen …
+        </Button>
+      </div>
+
+      <Modal
+        isOpen={offen}
+        onClose={() => setOffen(false)}
+        title={label}
+        maxWidth="lg"
+      >
+        <div className="space-y-3">
+          <div className="flex items-center gap-2 px-3 py-2 rounded-xl border border-slate-200 dark:border-slate-800 bg-slate-100/50 dark:bg-slate-900/50">
+            <button
+              onClick={() => eltern !== null && laden(eltern)}
+              disabled={eltern === null}
+              className="p-1 rounded-lg disabled:opacity-30 hover:bg-slate-200 dark:hover:bg-slate-800 text-slate-500 dark:text-slate-400"
+              title="Eine Ebene höher"
+            >
+              <ArrowUp size={16} />
+            </button>
+            <span className="text-xs font-mono truncate flex-1 text-slate-600 dark:text-slate-300">
+              {pfad || 'Laufwerke'}
+            </span>
+          </div>
+
+          <div className="max-h-72 overflow-y-auto rounded-xl border border-slate-200 dark:border-slate-800 p-1">
+            {laedt && (
+              <p className="px-3 py-2 text-xs text-slate-400">wird gelesen …</p>
+            )}
+            {!laedt && fehler && (
+              <p className="px-3 py-2 text-xs text-amber-600 dark:text-amber-400">{fehler}</p>
+            )}
+            {!laedt && !fehler && ordner.length === 0 && (
+              <p className="px-3 py-2 text-xs text-slate-400">Keine Unterordner.</p>
+            )}
+            {ordner.map((o) => (
+              <button
+                key={o.path}
+                onClick={() => laden(o.path)}
+                className="w-full flex items-center gap-2 px-3 py-1.5 text-xs text-left rounded-lg transition-colors text-slate-700 dark:text-slate-300 hover:bg-slate-100 dark:hover:bg-slate-800"
+              >
+                <Folder size={14} className="text-slate-400" />
+                {o.name}
+              </button>
+            ))}
+          </div>
+
+          <div className="flex items-center justify-between gap-2">
+            <p className="text-xs text-slate-500 dark:text-slate-400 flex items-center gap-1.5">
+              <FolderOpen size={13} />
+              Ein Netzwerkpfad lässt sich auch direkt ins Feld schreiben.
+            </p>
+            <div className="flex gap-2">
+              <Button variant="secondary" onClick={() => setOffen(false)}>
+                Abbrechen
+              </Button>
+              <Button
+                variant="amber"
+                disabled={!pfad}
+                onClick={() => {
+                  onChange(pfad)
+                  setOffen(false)
+                }}
+              >
+                Diesen Ordner nutzen
+              </Button>
+            </div>
+          </div>
+        </div>
+      </Modal>
+    </div>
+  )
+}

docker/ui/src/components/RipTargetModal.tsx

@@ -5,6 +5,7 @@ import { Modal } from './ui/Modal'
 import { Button } from './ui/Button'
 import { Input, Select } from './ui/Input'
 import { automatikWarnung, externWarnung, freigabenAusMapping, sprachName } from '../lib/encoder'
+import { useBetrieb } from '../lib/useBetrieb'
 
 interface TargetConfig {
   id: string
@@ -157,12 +158,20 @@ export default function RipTargetModal({ isOpen, initialType, discTitle, deviceI
     return () => clearInterval(interval)
   }, [scanStatus, deviceId])
 
-  const [targets, setTargets] = useState<TargetConfig[]>([
-    { id: '1', name: 'Filme', path: '/app/media/movies', type: 'movies', isActive: true },
-    { id: '2', name: 'Serien', path: '/app/media/series', type: 'series', isActive: true },
-    { id: '3', name: 'Musik', path: '/app/media/music', type: 'music', isActive: true },
-  ])
-  const [browsePath, setBrowsePath] = useState<string>('/app/media')
+  // Welcher Betrieb? Ohne diese Auskunft stand hier „Container-Platte" —
+  // auf einem Windows-PC eine Ortsangabe fuer einen Ort, den es nicht gibt.
+  const betrieb = useBetrieb()
+
+  /*
+   * Leer starten statt mit Container-Pfaden (Befund 29.08.2026).
+   *
+   * Hier standen `/app/media/movies` & Co. als Anfangswert. Auf einem
+   * Windows-PC gibt es die nicht — und fuer den Augenblick zwischen Oeffnen
+   * des Dialogs und der Antwort von /settings stand dort ein Pfad, den es
+   * nirgends gibt. Ein leerer Wert ist ehrlicher: Er behauptet nichts.
+   */
+  const [targets, setTargets] = useState<TargetConfig[]>([])
+  const [browsePath, setBrowsePath] = useState<string>('')
   const [browseParent, setBrowseParent] = useState<string | null>(null)
   const [browseDirs, setBrowseDirs] = useState<BrowseDir[]>([])
   const [customPath, setCustomPath] = useState('')
@@ -181,6 +190,10 @@ export default function RipTargetModal({ isOpen, initialType, discTitle, deviceI
   const [arbeitsZiele, setArbeitsZiele] = useState<StorageZiel[]>([])
   const [arbeitsDir, setArbeitsDir] = useState('')
   const [standardArbeitsDir, setStandardArbeitsDir] = useState('')
+  // Ein frei erblätterter Arbeitsordner. Er braucht einen eigenen Platz in
+  // der Liste, sonst zeigt das Auswahlfeld einen Wert an, den es nicht kennt
+  // — und stünde leer da, obwohl etwas gewählt ist.
+  const [eigenesArbeitsZiel, setEigenesArbeitsZiel] = useState('')
 
   useEffect(() => {
     if (!isOpen) return
@@ -194,6 +207,7 @@ export default function RipTargetModal({ isOpen, initialType, discTitle, deviceI
     setGewaehlt(new Set())
     setEncoderNode('')
     setArbeitsDir('')
+    setEigenesArbeitsZiel('')
     setBrowserOffen(false)
     setDiscSprachen(null)
     setAudioWahl(new Set())
@@ -213,7 +227,7 @@ export default function RipTargetModal({ isOpen, initialType, discTitle, deviceI
         .split(',').map((t: string) => t.trim().toLowerCase()).filter(Boolean)
       setStandardAudio(codes(s.audioSprachen))
       setStandardUntertitel(codes(s.untertitelSprachen))
-      const basis = s.outputDir || '/app/media'
+      const basis = s.outputDir || betrieb.ablage_vorgabe
       setTargets([
         { id: '1', name: 'Filme', path: `${basis}/${s.movieDir || 'movies'}`, type: 'movies', isActive: true },
         { id: '2', name: 'Serien', path: `${basis}/${s.seriesDir || 'series'}`, type: 'series', isActive: true },
@@ -240,6 +254,17 @@ export default function RipTargetModal({ isOpen, initialType, discTitle, deviceI
   // Das effektive Arbeitsverzeichnis: Wahl für diesen Rip → Einstellung →
   // leer (= Container-Platte /app/temp, für externe Worker unerreichbar).
   const arbeitsPfadEffektiv = arbeitsDir || standardArbeitsDir
+  /*
+   * Was WIRKLICH benutzt wird, wenn niemand etwas wählt.
+   *
+   * Commander am 28.08.2026: „Warum heißt das hier noch container platte? Er
+   * holt sich das Arbeitsverzeichnis ja von der Installation."
+   *
+   * Genau so ist es — nur stand hier fest verdrahtet „(Container-Platte)",
+   * sobald die Einstellung leer war. Auf seinem PC war das die Beschreibung
+   * eines Ortes, den es nicht gibt. Jetzt sagt der Betrieb, wohin es geht.
+   */
+  const arbeitsVorgabe = standardArbeitsDir || betrieb.arbeits_vorgabe
   // Warnung VOR dem Start, wenn der gewählte externe Encoder die Pfade nicht
   // erreicht (Punkt 6 des Savepoints v3.16). Am 26.07.2026 fiel genau das erst
   // NACH dem Rip auf, weil nur der Worker selbst prüfte.
@@ -378,8 +403,7 @@ export default function RipTargetModal({ isOpen, initialType, discTitle, deviceI
               onChange={e => setArbeitsDir(e.target.value)}
             >
               <option value="">
-                Standard aus den Einstellungen
-                {standardArbeitsDir ? ` (${standardArbeitsDir})` : ' (Container-Platte)'}
+                Standard{arbeitsVorgabe ? ` — ${arbeitsVorgabe}` : ''}
               </option>
               {arbeitsZiele.map(z => (
                 <option key={z.path} value={z.path}>
@@ -387,10 +411,13 @@ export default function RipTargetModal({ isOpen, initialType, discTitle, deviceI
                   {z.free_gb != null ? ` — ${z.free_gb} GB frei` : ''}
                 </option>
               ))}
+              {eigenesArbeitsZiel && (
+                <option value={eigenesArbeitsZiel}>{eigenesArbeitsZiel}</option>
+              )}
             </Select>
             <p className="text-xs mt-1.5 text-slate-500 dark:text-slate-400 flex items-center gap-1.5">
               <HardDrive size={13} />
-              Bei 4K-UHD bis zu 100 GB — nimm eine Freigabe mit Platz, am besten dieselbe wie das Ziel oben.
+              Bei 4K-UHD bis zu 100 GB — nimm ein Laufwerk mit Platz, am besten dasselbe wie das Ziel oben.
               Dann muss Rippy am Ende nur umhängen statt zu kopieren.
             </p>
           </div>
@@ -588,12 +615,14 @@ export default function RipTargetModal({ isOpen, initialType, discTitle, deviceI
             onClick={() => {
               const auf = !browserOffen
               setBrowserOffen(auf)
-              if (auf && browseDirs.length === 0) laden('/app/media')
+              if (auf && browseDirs.length === 0) laden('')
             }}
             className="flex items-center gap-1.5 text-xs text-slate-500 dark:text-slate-400 hover:text-slate-700 dark:hover:text-slate-200"
           >
             {browserOffen ? <ChevronDown size={14} /> : <ChevronRight size={14} />}
-            Anderen Zielordner wählen (nur für diesen Rip)
+            {selectedType === 'music'
+              ? 'Anderen Zielordner wählen (nur für diesen Rip)'
+              : 'Ordner durchsuchen — Ziel oder Arbeitsordner (nur für diesen Rip)'}
           </button>
 
           {browserOffen && (
@@ -607,14 +636,36 @@ export default function RipTargetModal({ isOpen, initialType, discTitle, deviceI
                 >
                   <ArrowUp size={16} />
                 </button>
-                <span className="text-xs font-mono truncate flex-1 text-slate-500 dark:text-slate-400">{browsePath}</span>
+                <span className="text-xs font-mono truncate flex-1 text-slate-500 dark:text-slate-400">
+                  {browsePath || 'Laufwerke'}
+                </span>
                 <Button
                   variant={customPath === browsePath ? 'amber' : 'secondary'}
                   size="sm"
+                  disabled={!browsePath}
                   onClick={() => setCustomPath(customPath === browsePath ? '' : browsePath)}
                 >
-                  {customPath === browsePath ? '✓ gewählt' : 'Diesen Ordner nutzen'}
+                  {customPath === browsePath ? '✓ Ziel' : 'Als Ziel'}
                 </Button>
+                {/* Der zweite Knopf ist der Grund, warum es diesen Browser für
+                    das Arbeitsverzeichnis überhaupt braucht: Die Schnellwahl
+                    darüber kennt nur Laufwerke und Unterordner der Ablage. Ein
+                    beliebiger Ordner — etwa D:\Rippy-Arbeit — ging bisher gar
+                    nicht („momentan geht das nicht", 28.08.2026). */}
+                {selectedType !== 'music' && (
+                  <Button
+                    variant={arbeitsDir === browsePath ? 'amber' : 'secondary'}
+                    size="sm"
+                    disabled={!browsePath}
+                    onClick={() => {
+                      if (arbeitsDir === browsePath) { setArbeitsDir(''); return }
+                      setEigenesArbeitsZiel(browsePath)
+                      setArbeitsDir(browsePath)
+                    }}
+                  >
+                    {arbeitsDir === browsePath ? '✓ Arbeitsordner' : 'Als Arbeitsordner'}
+                  </Button>
+                )}
               </div>
               <div className="max-h-36 overflow-y-auto p-1">
                 {browseDirs.map(d => (

docker/ui/src/components/ui/Badge.tsx

@@ -25,9 +25,12 @@ interface TypeBadgeProps {
 }
 
 export function TypeBadge({ type, className = '' }: TypeBadgeProps) {
+  // Ein fehlender Typ darf kein Absturz sein. Am 29.08.2026 hat genau diese
+  // Annahme (an anderer Stelle) die ganze Oberflaeche geleert: Ein frisch
+  // angelegter Job kommt ueber den Ereignisstrom ohne `type` an.
   const config = DISC_TYPE_STYLES[type as keyof typeof DISC_TYPE_STYLES] || {
     badge: 'bg-slate-500/15 text-slate-400 border-slate-500/30',
-    label: type.toUpperCase(),
+    label: type ? type.toUpperCase() : 'DISC',
   }
 
   return (

docker/ui/src/lib/useBetrieb.tsx

@@ -0,0 +1,144 @@
+/*
+ * Worauf läuft Rippy — und was kann dieser Betrieb überhaupt?
+ *
+ * ## Der Befund des Commanders (28.08.2026)
+ *
+ * Im Windows-Fenster stand auf der Server-Status-Kachel:
+ *
+ *     Worker erreichbar:   0 von 1
+ *     Kein Worker antwortet — ohne ihn läuft kein Rip. Prüfen: docker compose ps
+ *     Container-Platte:    unbekannt
+ *     Freigaben:           keine eingehängt
+ *
+ * Kein Satz davon ergibt auf einem Windows-PC einen Sinn. Es gibt keinen
+ * Container, kein `docker compose`, keinen zweiten Worker — Rippy rippt dort
+ * selbst. Sein Urteil: „Du hast ja quasi nur rippy genommen und die docker
+ * installation für Windows gebaut."
+ *
+ * ## Warum ein Provider und kein Abruf je Seite
+ *
+ * Dieselbe Begründung wie beim Ereignis-Strom nebenan: Vier Seiten, die
+ * dasselbe abfragen, sind vier Abrufe — und vier Gelegenheiten, dass eine
+ * davon einen anderen Stand hat als die anderen. Der Betrieb ändert sich zur
+ * Laufzeit nicht; er wird EINMAL geholt.
+ *
+ * ## Warum die Vorgabe „Docker" ist
+ *
+ * Solange die Antwort noch unterwegs ist, muss irgendetwas gelten. Die
+ * Docker-Annahme ist hier die richtige Vorgabe — sie zeigt MEHR, und ein kurz
+ * zu viel angezeigter Bereich ist harmloser als ein Bedienelement, das für
+ * einen Augenblick verschwindet und wieder auftaucht.
+ *
+ * Ein FEHLGESCHLAGENER Abruf ist etwas anderes als „noch unterwegs":
+ * `geladen` bleibt dann false, und wer das wissen will, kann es abfragen. Ein
+ * Verbindungsabriss ist keine Aussage über die Welt (siehe useEventStream).
+ */
+import { createContext, useContext, useEffect, useState, type ReactNode } from 'react'
+import { api } from './api'
+
+export interface BetriebsFaehigkeiten {
+  /** Gibt es andere Maschinen, die Jobs übernehmen? */
+  externe_worker: boolean
+  /** Kann Rippy Netzwerk-Freigaben selbst einhängen? */
+  freigaben_einhaengen: boolean
+  /** Sind Pfade wie /app/media überhaupt gemeint? */
+  container_pfade: boolean
+  /** Kann Rippy MakeMKV/HandBrake selbst beschaffen? */
+  werkzeuge_verwalten: boolean
+  /** Darf die Oberflaeche ausserhalb der Medien-Wurzel blaettern? */
+  frei_blaettern: boolean
+}
+
+export interface Betrieb {
+  modus: 'standalone' | 'verteilt'
+  plattform: 'windows' | 'linux' | 'macos'
+  im_container: boolean
+  kann: BetriebsFaehigkeiten
+  /** Womit ein Ablage-Feld vorbelegt wird — je Betrieb ein anderer Ort. */
+  ablage_vorgabe: string
+  /** Wohin die Rohdaten wandern, wenn niemand etwas anderes waehlt. */
+  arbeits_vorgabe: string
+  /** Der Befehl zum Nachsehen. LEER heißt: es gibt keinen, den der Nutzer
+   *  ausführen könnte — dann darf auch keiner dastehen. */
+  hilfe_befehl: string
+  /** Ist die Auskunft schon da? False heißt „noch unterwegs ODER nicht
+   *  erreichbar" — nicht „es gibt keinen Betrieb". */
+  geladen: boolean
+}
+
+const VORGABE: Betrieb = {
+  modus: 'verteilt',
+  plattform: 'linux',
+  im_container: true,
+  kann: {
+    externe_worker: true,
+    freigaben_einhaengen: true,
+    container_pfade: true,
+    werkzeuge_verwalten: false,
+    frei_blaettern: false,
+  },
+  // Leer statt Container-Pfade: Bis /betrieb geantwortet hat, WISSEN wir den
+  // Ort nicht. Ein leeres Feld sagt das; „/app/media" behauptet etwas, das
+  // auf einem Windows-PC falsch ist (Befund 29.08.2026).
+  ablage_vorgabe: '',
+  arbeits_vorgabe: '',
+  hilfe_befehl: 'docker compose -p rippy ps',
+  geladen: false,
+}
+
+const BetriebContext = createContext<Betrieb>(VORGABE)
+
+export function BetriebProvider({ children }: { children: ReactNode }) {
+  const [betrieb, setBetrieb] = useState<Betrieb>(VORGABE)
+
+  useEffect(() => {
+    let abgemeldet = false
+    api.get('/betrieb')
+      .then(antwort => {
+        const d = antwort.data
+        // Nur übernehmen, was WIRKLICH ankommt. Ein halb gefülltes Objekt
+        // hieße in JavaScript `undefined` — und `undefined` ist falsch, also
+        // verschwände ein Bereich stillschweigend.
+        if (abgemeldet || !d || !d.kann) return
+        setBetrieb({
+          modus: d.modus === 'verteilt' ? 'verteilt' : 'standalone',
+          plattform: d.plattform || 'linux',
+          im_container: !!d.im_container,
+          kann: {
+            externe_worker: !!d.kann.externe_worker,
+            freigaben_einhaengen: !!d.kann.freigaben_einhaengen,
+            container_pfade: !!d.kann.container_pfade,
+            werkzeuge_verwalten: !!d.kann.werkzeuge_verwalten,
+            frei_blaettern: !!d.kann.frei_blaettern,
+          },
+          ablage_vorgabe: d.ablage_vorgabe || '',
+          arbeits_vorgabe: d.arbeits_vorgabe || '',
+          hilfe_befehl: d.hilfe_befehl || '',
+          geladen: true,
+        })
+      })
+      .catch(() => {
+        // Nichts tun. Ein misslungener Abruf ist keine Aussage über den
+        // Betrieb — die Vorgabe bleibt stehen, `geladen` bleibt false.
+      })
+    return () => { abgemeldet = true }
+  }, [])
+
+  return <BetriebContext.Provider value={betrieb}>{children}</BetriebContext.Provider>
+}
+
+export function useBetrieb(): Betrieb {
+  return useContext(BetriebContext)
+}
+
+/**
+ * Kurzform für den häufigsten Fall: Läuft Rippy als eigenständige App
+ * (Windows-Client oder Docker-All-in-One)?
+ *
+ * Bewusst NICHT „ist Windows": Ein Docker-All-in-One hat auch keinen zweiten
+ * Worker. Wer nach der Plattform fragt, obwohl er die Fähigkeit meint, baut
+ * die nächste falsche Annahme ein.
+ */
+export function useAlleinbetrieb(): boolean {
+  return !useBetrieb().kann.externe_worker
+}

docker/ui/src/lib/useEventStream.tsx

@@ -123,6 +123,17 @@ export function EventStreamProvider({ children }: { children: ReactNode }) {
         devices: d.devices === undefined ? null : d.devices,
         workers: d.workers ?? [],
         logs: d.logs ?? [],
+        // ⚠️ Server-Zustand MIT übernehmen (Befund 28.08.2026).
+        //
+        // Er stand hier nicht, obwohl der Schnappschuss ihn liefert — und
+        // `system.status` kommt erst nach bis zu 15 Sekunden. Nach jedem
+        // Neuladen stand deshalb „Platz für Rippy: unbekannt" auf dem
+        // Bildschirm. Das sieht aus wie eine Auskunft und ist keine.
+        //
+        // `undefined` heißt weiterhin „nicht mitgeschickt": dann bleibt der
+        // alte Stand, statt auf leer zu fallen.
+        systemInfo: d.info !== undefined ? d.info : null,
+        ablagen: d.ablagen !== undefined ? d.ablagen : null,
         verbunden: true,
       })
     })

docker/ui/src/pages/Anleitung.tsx

@@ -2,6 +2,7 @@ import { ReactNode } from 'react'
 import { Disc, Tv, HardDrive, Bell, Wrench, Cpu, Download, HelpCircle } from 'lucide-react'
 import { PageHeader } from '../components/ui/PageHeader'
 import { Card, CardHeader, CardTitle, CardContent } from '../components/ui/Card'
+import { useBetrieb } from '../lib/useBetrieb'
 
 function Abschnitt({ icon: Icon, titel, children }: { icon: any, titel: string, children: ReactNode }) {
   return (
@@ -21,6 +22,18 @@ function Abschnitt({ icon: Icon, titel, children }: { icon: any, titel: string,
 
 export default function AnleitungPage() {
   const fett = "font-semibold text-slate-100"
+  /*
+   * Auch die Anleitung haengt am Betrieb.
+   *
+   * Commander-Befund 28.08.2026: „Das gilt fuer die ganze standalone version
+   * fuer Windows, auch fuer die settings und die Anleitung usw."
+   *
+   * Eine Anleitung, die einem Windows-Nutzer erklaert, wie er Freigaben
+   * einhaengt und weitere Encoding-Worker aufsetzt, beschreibt ein Programm,
+   * das er nicht hat. Das ist schlimmer als gar keine Anleitung: Sie laesst
+   * ihn glauben, er habe etwas falsch gemacht.
+   */
+  const betrieb = useBetrieb()
 
   return (
     <div className="space-y-6 max-w-6xl mx-auto">
@@ -67,18 +80,28 @@ export default function AnleitungPage() {
         </p>
       </Abschnitt>
 
-      <Abschnitt icon={HardDrive} titel="NAS &amp; Speicherziele">
+      <Abschnitt icon={HardDrive} titel="Wohin die Filme kommen">
+        {betrieb.kann.freigaben_einhaengen ? (
+          <p>
+            Einstellungen → Speicherziele: Rechner/NAS eintragen, <span className={fett}>Benutzer +
+            Passwort</span> angeben (Windows und die meisten NAS lehnen Gast-Zugriffe ab!), „Freigaben
+            auflisten", Freigabe wählen, „Einhängen &amp; speichern". Danach taucht das Ziel im
+            „Rippen starten"-Dialog auf und wird beim Start automatisch wieder verbunden.
+          </p>
+        ) : (
+          <p>
+            Einstellungen → Speicherziele: Bei <span className={fett}>Ablage</span> steht der Ordner,
+            in dem die fertigen Filme landen. Das darf ein normaler Ordner sein
+            {betrieb.ablage_vorgabe ? <> (Vorgabe: <code>{betrieb.ablage_vorgabe}</code>)</> : null} oder
+            ein Netzwerkpfad wie <code>\NAS\Filme</code> — Rippy schreibt einfach dorthin.
+            Ein Einhängen wie unter Linux gibt es hier nicht und ist auch nicht nötig.
+          </p>
+        )}
         <p>
-          Einstellungen → Speicherziele: Rechner/NAS eintragen, <span className={fett}>Benutzer +
-          Passwort</span> angeben (Windows und die meisten NAS lehnen Gast-Zugriffe ab!), „Freigaben
-          auflisten", Freigabe wählen, „Einhängen &amp; speichern". Danach taucht das Ziel im
-          „Rippen starten"-Dialog auf und wird beim Start automatisch wieder verbunden.
-        </p>
-        <p>
-          <span className={fett}>4K-UHD-Tipp:</span> Rohdaten sind bis 100 GB groß. Wenn die
-          Rippy-Platte knapp ist (Dashboard zeigt den freien Platz), das Arbeitsverzeichnis unter
-          Einstellungen → Verarbeitung auf eine große Freigabe legen. Rippy prüft den Platz vor
-          jedem Rip und bricht sonst mit Klartext ab.
+          <span className={fett}>4K-UHD-Tipp:</span> Rohdaten sind bis 100 GB groß. Wenn der Platz
+          knapp wird (das Dashboard zeigt ihn), das Arbeitsverzeichnis unter Einstellungen →
+          Verarbeitung auf {betrieb.kann.freigaben_einhaengen ? 'eine große Freigabe' : 'ein großes Laufwerk'} legen.
+          Rippy prüft den Platz vor jedem Rip und bricht sonst mit Klartext ab.
         </p>
       </Abschnitt>
 
@@ -104,6 +127,11 @@ export default function AnleitungPage() {
         </p>
       </Abschnitt>
 
+      {/* Nur im verteilten Betrieb. Einem Windows-Nutzer zu erklaeren,
+          wie er weitere Encoding-Worker aufsetzt, beschreibt ein Programm,
+          das er nicht hat — und laesst ihn glauben, er habe etwas falsch
+          gemacht (Commander-Befund 28.08.2026). */}
+      {betrieb.kann.externe_worker && (
       <Abschnitt icon={Cpu} titel="Weitere Maschinen als Encoding-Worker">
         <p>
           Die Kompression kann jede Maschine im Netz übernehmen — Einstellungen → Worker.
@@ -126,6 +154,7 @@ export default function AnleitungPage() {
           nie eine externe Domain (die läuft über den Reverse-Proxy und blockt).
         </p>
       </Abschnitt>
+      )}
 
       <Abschnitt icon={Wrench} titel="MakeMKV-Beta-Key &amp; System">
         <p>

docker/ui/src/pages/Dashboard.tsx

@@ -11,6 +11,7 @@ import JobDetailModal from '../components/JobDetailModal'
 import LiveLogSection from '../components/LiveLogSection'
 import RetryDialog from '../components/RetryDialog'
 import { useStrom } from '../lib/useEventStream'
+import { useBetrieb } from '../lib/useBetrieb'
 
 interface JobMeta {
   year?: number
@@ -43,7 +44,8 @@ interface Job {
 
 interface SystemInfo {
   api_version: string
-  plaetze: { name: string; frei_gb: number; gesamt_gb: number }[]
+  plaetze: { name: string; pfad?: string; gleiches_laufwerk?: boolean;
+             frei_gb: number; gesamt_gb: number }[]
   workers: { name: string; encoders: string[] }[]
 }
 
@@ -64,6 +66,9 @@ interface LaufwerkLive {
   id: string
   status: string
   disc?: { title?: string, year?: number | null, disc_type?: string }
+  /** Die Erkennung laeuft noch — es gibt noch keinen Titel, aber auch kein
+   *  leeres Laufwerk. Dauert an einer Blu-ray rund zwei Minuten. */
+  disc_wird_erkannt?: boolean
 }
 
 // Ein Ablageziel aus GET /storage-targets — Verzeichnisse unter /app/media
@@ -128,6 +133,9 @@ export default function Dashboard() {
   const [laufwerke, setLaufwerke] = useState<LaufwerkLive[]>([])
   const [ablagen, setAblagen] = useState<AblageZiel[]>([])
   const strom = useStrom()
+  // Was hier ueberhaupt angezeigt werden DARF, haengt am Betrieb.
+  // Ohne das stand im Windows-Fenster "Pruefen: docker compose ps".
+  const betrieb = useBetrieb()
   const { toast } = useToast()
 
   /*
@@ -324,7 +332,13 @@ export default function Dashboard() {
         : 'Rip läuft (MakeMKV, verlustfrei)')
     : discImLaufwerk
       ? 'Disc erkannt — wartet auf „Rippen starten"'
-      : 'Bereit — kein Datenträger im Laufwerk'
+      // Zwischen „Disc eingelegt" und „erkannt" liegen rund zwei Minuten
+      // (makemkvcon info laeuft in seine 120-Sekunden-Grenze). Ohne diese
+      // Zeile stand dort „kein Datentraeger", und das sah aus wie ein
+      // Fehler (Commander 29.08.2026).
+      : laufwerke.some(l => l.disc_wird_erkannt)
+        ? 'Disc wird gelesen — das dauert bis zu zwei Minuten'
+        : 'Bereit — kein Datenträger im Laufwerk'
 
   const filteredJobs = jobs.filter(j => {
     if (activeTab === 'active') return j.status === 'processing' || j.status === 'transcoding'
@@ -580,6 +594,38 @@ export default function Dashboard() {
                               Details
                             </Button>
 
+                            {/*
+                              Abbrechen DIREKT in der Zeile (Commander
+                              29.08.2026: „man kann einen rip garnicht
+                              abbrechen").
+
+                              Es gab genau einen Abbrechen-Knopf, und der
+                              steckte in der Kachel „laufender Job". Die
+                              erschien nur bei Status `processing` — der
+                              Ereignisstrom lieferte aber den rohen
+                              DB-Status `running`. Also keine Kachel, also
+                              kein Knopf, also kein Weg zurueck.
+                              Die Ursache ist behoben; ein zweiter Weg zum
+                              Abbrechen ist trotzdem richtig, denn genau
+                              hier sucht man ihn.
+                            */}
+                            {['processing', 'transcoding', 'pending'].includes(job.status) && (
+                              <Button
+                                variant="danger"
+                                size="sm"
+                                onClick={() => api.post(`/jobs/${job.id}/cancel`)
+                                  .then(() => toast('info', 'Abbruch angefordert — der Rip haelt beim naechsten Zwischenschritt an.'))
+                                  .catch((e: any) => toast('error',
+                                    e?.response?.data?.detail || 'Abbrechen ging nicht'))}
+                              >
+                                Abbrechen
+                              </Button>
+                            )}
+
+                            {job.status === 'canceling' && (
+                              <span className="text-xs font-mono text-slate-400">bricht ab …</span>
+                            )}
+
                             {job.status === 'completed' && (
                               <Button variant="amber" size="sm" onClick={() => setDetailJobId(job.id)}>
                                 <Download size={13} /> Download
@@ -678,7 +724,30 @@ export default function Dashboard() {
                   )}
                 </div>
 
-                {/* 2. Worker — die ECHTE Erreichbarkeit, plus was sie können */}
+                {/* 2. Wer arbeitet hier — und das hängt am BETRIEB.
+                       ⚠️ Commander-Befund 28.08.2026: Im Windows-Fenster stand
+                       „Worker erreichbar: 0 von 1 — Kein Worker antwortet.
+                       Prüfen: docker compose ps". Auf einem Windows-PC gibt es
+                       keinen zweiten Worker, auf den man warten könnte, und
+                       kein docker compose, das man prüfen könnte. Die Meldung
+                       war nicht nur unpassend, sie war falsch. */}
+                {!betrieb.kann.externe_worker ? (
+                  <div>
+                    <div className="flex items-center justify-between text-xs font-mono mb-1">
+                      <span className="text-slate-400 flex items-center gap-1.5">
+                        <Cpu size={14} className="text-amber-400" /> Rippy arbeitet:
+                      </span>
+                      <span className="text-slate-200">
+                        auf diesem Rechner
+                      </span>
+                    </div>
+                    <p className="text-[11px] font-mono text-slate-500">
+                      {aktiverJob
+                        ? 'Rippen und Komprimieren laufen hier — kein zweiter Rechner nötig.'
+                        : 'Rippen und Komprimieren erledigt Rippy selbst.'}
+                    </p>
+                  </div>
+                ) : (
                 <div>
                   <div className="flex items-center justify-between text-xs font-mono mb-1">
                     <span className="text-slate-400 flex items-center gap-1.5">
@@ -692,7 +761,9 @@ export default function Dashboard() {
                   {workerOnline.length === 0 ? (
                     <p className="text-[11px] font-mono text-rose-400">
                       Kein Worker antwortet — ohne ihn läuft kein Rip.
-                      Prüfen: <span className="text-slate-300">docker compose ps</span>
+                      {betrieb.hilfe_befehl && (
+                        <> Prüfen: <span className="text-slate-300">{betrieb.hilfe_befehl}</span></>
+                      )}
                     </p>
                   ) : (
                     <div className="space-y-0.5">
@@ -713,15 +784,52 @@ export default function Dashboard() {
                     </div>
                   )}
                 </div>
+                )}
 
                 {/* 3. Platz — Container-Platte UND die eingehängten Freigaben.
                        Vorher stand hier nur die Container-Platte; wer wissen
                        wollte, ob die NAS noch Platz für eine Disc hat, sah die
                        falsche Zahl (Commander-Befund 26.07.2026). */}
                 <div>
-                  <div className="flex items-center justify-between text-xs font-mono mb-1">
+                  {/*
+                    Jeder Ort mit seinem PFAD (Commander 29.08.2026): „bei
+                    ‚Platz für rippy' sollte eher das arbeitsverzeichnis und
+                    der Ablagepfad sein." Vorher stand hier eine nackte Zahl
+                    für den ERSTEN Ort — welcher Ordner das war, sah man nicht.
+                  */}
+                  {!betrieb.kann.container_pfade && (systemInfo?.plaetze || []).map(ort => (
+                    <div key={ort.name + ort.pfad} className="mb-1.5">
+                      <div className="flex items-center justify-between text-xs font-mono">
+                        <span className="text-slate-400 flex items-center gap-1.5">
+                          <HardDrive size={14} className="text-amber-400" />
+                          {ort.name}:
+                        </span>
+                        <span className={ort.frei_gb > 0 && ort.frei_gb < 60
+                          ? 'text-amber-400 font-bold' : 'text-slate-200'}>
+                          {ort.frei_gb > 0 ? `${ort.frei_gb} von ${ort.gesamt_gb} GB frei` : 'unbekannt'}
+                        </span>
+                      </div>
+                      {ort.pfad && (
+                        <p className="text-[11px] font-mono text-slate-500 truncate" title={ort.pfad}>
+                          {ort.pfad}
+                        </p>
+                      )}
+                    </div>
+                  ))}
+                  {!betrieb.kann.container_pfade
+                    && (systemInfo?.plaetze || []).length > 1
+                    && systemInfo?.plaetze?.every(o => o.gleiches_laufwerk) && (
+                    /* Ehrlich sagen, dass die Zahl zweimal dieselbe ist —
+                       statt die zweite Zeile wegzulassen. */
+                    <p className="text-[11px] font-mono text-slate-500 mb-1">
+                      Beide auf demselben Laufwerk — der Platz wird geteilt.
+                    </p>
+                  )}
+                  <div className={`flex items-center justify-between text-xs font-mono mb-1 ${
+                    betrieb.kann.container_pfade ? '' : 'hidden'}`}>
                     <span className="text-slate-400 flex items-center gap-1.5">
-                      <HardDrive size={14} className="text-amber-400" /> Container-Platte:
+                      <HardDrive size={14} className="text-amber-400" />
+                      Container-Platte:
                     </span>
                     <span className={freiGb > 0 && freiGb < 60 ? 'text-amber-400 font-bold' : 'text-slate-200'}>
                       {freiGb > 0 ? `${freiGb} von ${gesamtGb} GB frei` : 'unbekannt'}
@@ -744,7 +852,16 @@ export default function Dashboard() {
                 </div>
 
                 {/* Die eingehängten Freigaben. Sie sind der Ort, an dem die
-                    Rohdaten liegen und — bei externem Encoden — liegen MÜSSEN. */}
+                    Rohdaten liegen und — bei externem Encoden — liegen MÜSSEN.
+
+                    ⚠️ NUR im Container. Unter Windows hängt Rippy nichts ein:
+                    Dort gibt man einen Ordner oder einen UNC-Pfad an, fertig.
+                    Der Satz „Ohne Freigabe kann ein externer Encoder nichts
+                    tun — er sieht die Container-Platte nicht" stand am
+                    28.08.2026 im Windows-Fenster und ergab dort keinen Sinn:
+                    Es gibt weder einen externen Encoder noch eine
+                    Container-Platte. */}
+                {betrieb.kann.freigaben_einhaengen && (
                 <div>
                   <div className="flex items-center justify-between text-xs font-mono mb-1">
                     <span className="text-slate-400 flex items-center gap-1.5">
@@ -778,6 +895,7 @@ export default function Dashboard() {
                     </div>
                   )}
                 </div>
+                )}
               </div>
             </CardContent>
           </Card>

docker/ui/src/pages/Settings.tsx

@@ -4,10 +4,12 @@ import { api } from '../lib/api'
 import { useToast } from '../context/ToastContext'
 import StorageMounts from '../components/StorageMounts'
 import WorkerVerwaltung from '../components/WorkerVerwaltung'
+import { useBetrieb } from '../lib/useBetrieb'
 import { PageHeader } from '../components/ui/PageHeader'
 import { Card, CardHeader, CardTitle, CardContent } from '../components/ui/Card'
 import { Button } from '../components/ui/Button'
 import { Input, Select, Toggle } from '../components/ui/Input'
+import { OrdnerWaehler } from '../components/OrdnerWaehler'
 import { MEDIA_SERVER_OPTIONEN } from '../lib/mediaServer'
 import { ENCODER_BADGES } from '../lib/design'
 import { PRESET_KEINE, schwacheEncoderCpu, simdWarnung } from '../lib/encoder'
@@ -48,7 +50,10 @@ const defaultSettings: SettingsState = {
   tmdbApiKey: '',
   tvdbApiKey: '',
   omdbApiKey: '',
-  outputDir: '/app/media',
+  // Kein fester Container-Pfad: Auf Windows gibt es kein /app/media. Der
+  // echte Vorgabewert kommt aus GET /betrieb (ablage_vorgabe) und wird
+  // beim Laden gesetzt.
+  outputDir: '',
   movieDir: 'movies',
   seriesDir: 'series',
   musicDir: 'music',
@@ -187,6 +192,7 @@ function zeitLesbar(iso: string): string {
 
 export default function SettingsPage() {
   const [settings, setSettings] = useState<SettingsState>(defaultSettings)
+  const betrieb = useBetrieb()
   const [activeTab, setActiveTab] = useState<SettingsTab>('ripping')
   const [workers, setWorkers] = useState<WorkerInfo[]>([])
   const [systemInfo, setSystemInfo] = useState<SystemInfo | null>(null)
@@ -208,6 +214,9 @@ export default function SettingsPage() {
   // Ablageziele unter /app/media inkl. eingehängter Freigaben — speist die
   // Auswahl des Arbeitsverzeichnisses (vorher musste man den Pfad tippen).
   const [ziele, setZiele] = useState<StorageZiel[]>([])
+  // Beta-Key: läuft gerade ein Abruf, und was kam zuletzt dabei heraus?
+  const [keyHolt, setKeyHolt] = useState(false)
+  const [keyMeldung, setKeyMeldung] = useState('')
   const [keystore, setKeystore] = useState<KeystoreStatus | null>(null)
   const [keystoreBusy, setKeystoreBusy] = useState(false)
   const keystoreInput = useRef<HTMLInputElement>(null)
@@ -248,6 +257,43 @@ export default function SettingsPage() {
     api.get('/capabilities').then(r => setWorkers(r.data.workers || [])).catch(() => setWorkers([]))
   }
 
+  /*
+   * Den Beta-Key JETZT holen, statt auf die tägliche Schleife zu warten.
+   *
+   * Der geholte Key wird nicht angezeigt — er wandert in die Einstellungen,
+   * und die werden hier ohnehin neu geladen. Zwei Wege zu demselben Wert sind
+   * zwei Wege, ihn zu verlieren.
+   */
+  const keyJetztHolen = async () => {
+    setKeyHolt(true)
+    setKeyMeldung('')
+    try {
+      const r = await api.post('/system/makemkv-key/holen')
+      const antwort = await api.get('/settings')
+      setSettings({ ...defaultSettings, ...antwort.data })
+      if (r.data?.angenommen === false) {
+        // Geholt ist nicht angenommen. Am 29.08.2026 lehnte MakeMKV 1.18.4
+        // den aktuellen Key ab („Programmversion zu alt") — ohne diesen
+        // Hinweis stünde hier ein Erfolg, und der nächste Rip scheiterte
+        // trotzdem.
+        setKeyMeldung('Fehlgeschlagen: ' + (r.data.grund || 'MakeMKV nimmt den Key nicht an.'))
+        toast('error', r.data.grund || 'MakeMKV nimmt den Key nicht an.')
+      } else {
+        setKeyMeldung(r.data?.geaendert
+          ? `Neuer Key geholt und angenommen (endet auf …${r.data.endet_auf}).`
+          : `Schon aktuell (endet auf …${r.data?.endet_auf || '?'}).`)
+        toast('success', 'MakeMKV-Beta-Key aus dem Forum geholt.')
+      }
+    } catch (e: any) {
+      const grund = e?.response?.data?.detail
+        || 'Das Forum ist nicht erreichbar.'
+      setKeyMeldung('Fehlgeschlagen: ' + grund)
+      toast('error', grund)
+    } finally {
+      setKeyHolt(false)
+    }
+  }
+
   const keydbHochladen = async (datei: File) => {
     setKeydbBusy(true)
     try {
@@ -485,7 +531,12 @@ export default function SettingsPage() {
   const istFreigabe = (pfad: string) =>
     ziele.some(z => z.path === pfad && z.is_mount)
   const ablageWarnung = (() => {
-    const ablage = settings.outputDir || '/app/media'
+    // ⚠️ Die ganze Warnung dreht sich um einen Encoder auf einem ANDEREN
+    // Rechner, der die Container-Platte nicht sieht. Ohne externe Worker gibt
+    // es weder den einen noch die andere — der Satz stand am 28.08.2026
+    // trotzdem im Windows-Fenster und riet dort zu etwas, das es nicht gibt.
+    if (!betrieb.kann.externe_worker) return ''
+    const ablage = settings.outputDir || betrieb.ablage_vorgabe
     const arbeit = settings.workDir
     if (!arbeit) {
       return 'Das Arbeitsverzeichnis steht auf der Container-Platte. Ein Encoder auf '
@@ -505,16 +556,45 @@ export default function SettingsPage() {
     return ''
   })()
 
+  /*
+   * Die Reiter haengen am BETRIEB.
+   *
+   * Commander-Befund 28.08.2026: „Das gilt fuer die ganze standalone version
+   * fuer Windows, auch fuer die settings und die Anleitung usw."
+   *
+   * Ein Reiter „Worker" fuehrt in einer Standalone-Installation zu einer
+   * Maske, die Rechner in einem Netz verwaltet, das es nicht gibt. Ein Reiter
+   * „Speicherziele" bietet dort das Einhaengen von Freigaben an — etwas, das
+   * unter Windows niemand braucht (dort gibt man einen Ordner oder UNC-Pfad
+   * an). Beides ist keine kosmetische Frage: Wer darauf klickt, bekommt
+   * Bedienelemente, die ins Leere fuehren.
+   */
   const tabs: { id: SettingsTab; label: string; icon: any }[] = [
     { id: 'ripping', label: 'Ripping', icon: Disc },
     { id: 'verarbeitung', label: 'Verarbeitung', icon: Cpu },
-    { id: 'worker', label: 'Worker', icon: Cpu },
+    ...(betrieb.kann.externe_worker
+      ? [{ id: 'worker' as SettingsTab, label: 'Worker', icon: Cpu }]
+      : []),
+    // Speicherziele bleibt IMMER. Hier steht die Ablage — „wo will ich das
+    // hinspeichern" war die ausdrueckliche Frage des Commanders. Nur das
+    // EINHAENGEN von Freigaben faellt weg, wenn der Betrieb es nicht kann;
+    // das steckt weiter unten in einer eigenen Bedingung.
     { id: 'speicherziele', label: 'Speicherziele', icon: HardDrive },
     { id: 'apis', label: 'APIs', icon: Globe },
     { id: 'benachrichtigungen', label: 'Benachrichtigungen', icon: AlertCircle },
     { id: 'system', label: 'System', icon: Wrench },
   ]
 
+  /*
+   * Ein Reiter, den es nicht mehr gibt, darf nicht ausgewaehlt bleiben.
+   *
+   * Der Betrieb kommt ERST NACH dem ersten Rendern an (ein Abruf). Wer in der
+   * Zwischenzeit auf „Worker" steht — oder wer den Reiter beim Neuladen aus
+   * dem Zustand mitbringt — saehe sonst eine leere Seite ohne jeden Hinweis.
+   */
+  const sichtbareReiter = tabs.map(t => t.id)
+  const aktiverReiter = sichtbareReiter.includes(activeTab) ? activeTab : 'ripping'
+
   return (
     <div className="max-w-6xl mx-auto space-y-6">
       <PageHeader
@@ -533,7 +613,7 @@ export default function SettingsPage() {
         {/* Navigation Tabs */}
         <div className="flex border-b border-slate-800 overflow-x-auto [scrollbar-width:none] [-ms-overflow-style:none] [&::-webkit-scrollbar]:hidden bg-[#0c101d]">
           {tabs.map((tab) => {
-            const isActive = activeTab === tab.id
+            const isActive = aktiverReiter === tab.id
             return (
               <button
                 key={tab.id}
@@ -554,7 +634,7 @@ export default function SettingsPage() {
         {/* Tab Content */}
         <CardContent className="p-6 space-y-8">
           {/* Ripping Settings */}
-          {activeTab === 'ripping' && (
+          {aktiverReiter === 'ripping' && (
             <section className="space-y-6">
               <div>
                 <h2 className="text-lg font-semibold flex items-center gap-2 text-slate-900 dark:text-slate-100">
@@ -697,7 +777,7 @@ export default function SettingsPage() {
           )}
 
           {/* Verarbeitung */}
-          {activeTab === 'verarbeitung' && (
+          {aktiverReiter === 'verarbeitung' && (
             <section className="space-y-6">
               <h2 className="text-lg font-semibold flex items-center gap-2 text-slate-900 dark:text-slate-100">
                 <Cpu size={20} className="text-amber-500" />
@@ -901,12 +981,41 @@ export default function SettingsPage() {
                   /storage-targets — dieselbe Liste wie bei den Speicherzielen,
                   inklusive freiem Platz.
                 */}
+                {!betrieb.kann.container_pfade ? (
+                  /*
+                   * Ein echtes Pfadfeld statt einer Auswahl — dieselbe
+                   * Entscheidung wie bei der Ablage darüber, und aus demselben
+                   * Grund.
+                   *
+                   * Commander am 28.08.2026: „Wäre es möglich das
+                   * Arbeitsverzeichnis zu ändern? momentan geht das nicht."
+                   *
+                   * Es ging nicht, weil `ziele` auf Windows LEER war: Die Liste
+                   * kommt aus /storage-targets, und das las `/app/media` — ein
+                   * Ordner, den es dort nicht gibt. Übrig blieb eine Auswahl mit
+                   * genau einem Eintrag, und der hieß „Container-Platte".
+                   *
+                   * Die Liste ist inzwischen repariert (sie bringt jetzt die
+                   * Laufwerke mit freiem Platz). Aber die richtige Antwort auf
+                   * „wohin mit 100 GB" ist auf Windows oft ein Ort, den keine
+                   * Liste kennt — D:\Rippy-Arbeit oder eine UNC-Freigabe.
+                   * Deshalb hier ein Feld, in das man ihn schreiben kann.
+                   */
+                  <OrdnerWaehler
+                    label="Arbeitsverzeichnis für Roh-Rips (Standard)"
+                    value={settings.workDir}
+                    placeholder={betrieb.arbeits_vorgabe}
+                    onChange={(pfad) => handleChange('workDir', pfad)}
+                  />
+                ) : (
                 <Select
                   label="Arbeitsverzeichnis für Roh-Rips (Standard)"
                   value={settings.workDir}
                   onChange={(e) => handleChange('workDir', e.target.value)}
                 >
-                  <option value="">Container-Platte (Standard) — klein, nur für DVD/Blu-ray</option>
+                  <option value="">
+                    Container-Platte (Standard) — klein, nur für DVD/Blu-ray
+                  </option>
                   {ziele.map(z => (
                     <option key={z.path} value={z.path}>
                       {z.name}{z.is_mount ? ' (Netzwerk-Freigabe)' : ''}
@@ -914,13 +1023,35 @@ export default function SettingsPage() {
                     </option>
                   ))}
                 </Select>
+                )}
+                {!betrieb.kann.container_pfade && !!ziele.length && (
+                  /* Die Laufwerke als Ein-Klick-Wahl. Wer den Platz sieht,
+                     wählt anders — genau daran ist am 25.07. eine Platte
+                     vollgelaufen. */
+                  <div className="flex flex-wrap gap-1.5">
+                    {ziele.map(z => (
+                      <button
+                        key={z.path}
+                        onClick={() => handleChange('workDir', z.path)}
+                        className={`px-2.5 py-1 text-xs rounded-lg border transition-colors ${
+                          settings.workDir === z.path
+                            ? 'border-amber-500 bg-amber-500/10 text-amber-700 dark:text-amber-300'
+                            : 'border-slate-200 dark:border-slate-700 text-slate-500 dark:text-slate-400 hover:border-slate-400'
+                        }`}
+                      >
+                        {z.name}{z.free_gb != null ? ` — ${z.free_gb} GB frei` : ''}
+                      </button>
+                    ))}
+                  </div>
+                )}
                 <p className="text-xs text-slate-500 dark:text-slate-400">
                   <strong className="text-slate-700 dark:text-slate-300">Der Standard</strong> — beim
                   „Rippen starten" kannst du für jede Disc etwas anderes wählen. <strong className="text-slate-700 dark:text-slate-300">
                   Läuft die Vollautomatik</strong>, fragt dich niemand: dann gilt genau dieser Wert.
-                  Wichtig für 4K-UHD: Rohdaten sind bis 100 GB groß und passen selten auf die
-                  Container-Platte. Am besten dieselbe Freigabe wie das Ziel — dann muss Rippy die
-                  Rohdatei am Ende nur umhängen statt sie zu kopieren.
+                  Wichtig für 4K-UHD: Rohdaten sind bis 100 GB groß.
+                  {betrieb.kann.container_pfade
+                    ? ' Auf die Container-Platte passen die selten. Am besten dieselbe Freigabe wie das Ziel — dann muss Rippy die Rohdatei am Ende nur umhängen statt sie zu kopieren.'
+                    : ' Am besten dasselbe Laufwerk wie die Ablage — dann muss Rippy die Rohdatei am Ende nur umhängen statt sie über die Platte zu kopieren.'}
                   {systemInfo?.plaetze?.length ? (
                     <> Aktuell frei: {systemInfo.plaetze.map(p => `${p.name}: ${p.frei_gb} GB`).join(' · ')}</>
                   ) : null}
@@ -930,7 +1061,7 @@ export default function SettingsPage() {
           )}
 
           {/* Worker */}
-          {activeTab === 'worker' && (
+          {aktiverReiter === 'worker' && (
             <section className="space-y-6">
               <h2 className="text-lg font-semibold flex items-center gap-2 text-slate-900 dark:text-slate-100">
                 <Cpu size={20} className="text-amber-500" />
@@ -941,7 +1072,7 @@ export default function SettingsPage() {
           )}
 
           {/* Speicherziele */}
-          {activeTab === 'speicherziele' && (
+          {aktiverReiter === 'speicherziele' && (
             <section className="space-y-6">
               <h2 className="text-lg font-semibold flex items-center gap-2 text-slate-900 dark:text-slate-100">
                 <HardDrive size={20} className="text-amber-500" />
@@ -961,6 +1092,19 @@ export default function SettingsPage() {
                 <h3 className="font-semibold flex items-center gap-2 text-slate-900 dark:text-slate-100">
                   <HardDrive size={16} className="text-amber-500" /> Ablage — wohin die fertigen Filme kommen
                 </h3>
+                {!betrieb.kann.container_pfade ? (
+                  /* Kein Auswahlfeld, sondern ein echtes Pfadfeld: Auf einem
+                     Windows-PC gibt es keine Liste von Container-Zielen, aus
+                     der man waehlen koennte — es gibt Laufwerke, Ordner und
+                     UNC-Pfade. Eine Auswahl mit einem Eintrag waere eine
+                     Bedienung, die nichts bedient. */
+                  <OrdnerWaehler
+                    label="Ordner"
+                    value={settings.outputDir}
+                    placeholder={betrieb.ablage_vorgabe}
+                    onChange={(pfad) => handleChange('outputDir', pfad)}
+                  />
+                ) : (
                 <Select
                   label="Ablage"
                   value={settings.outputDir}
@@ -974,6 +1118,7 @@ export default function SettingsPage() {
                     </option>
                   ))}
                 </Select>
+                )}
                 <p className="text-xs text-slate-500 dark:text-slate-400">
                   Gilt für die Schnellwahl im Rip-Dialog <strong className="text-slate-700 dark:text-slate-300">und
                   für die Vollautomatik</strong> — dort fragt niemand nach, also entscheidet dieser Wert.
@@ -1005,12 +1150,15 @@ export default function SettingsPage() {
                 </div>
               </div>
 
-              <StorageMounts />
+              {/* Freigaben EINHAENGEN kann nur der Container-Betrieb.
+                  Unter Windows gibt man einen Ordner oder einen UNC-Pfad an —
+                  eine Maske zum Einhaengen fuehrte dort ins Leere. */}
+              {betrieb.kann.freigaben_einhaengen && <StorageMounts />}
             </section>
           )}
 
           {/* APIs */}
-          {activeTab === 'apis' && (
+          {aktiverReiter === 'apis' && (
             <section className="space-y-6">
               <h2 className="text-lg font-semibold flex items-center gap-2 text-slate-900 dark:text-slate-100">
                 <Globe size={20} className="text-amber-500" />
@@ -1070,7 +1218,7 @@ export default function SettingsPage() {
           )}
 
           {/* Benachrichtigungen */}
-          {activeTab === 'benachrichtigungen' && (
+          {aktiverReiter === 'benachrichtigungen' && (
             <section className="space-y-6">
               <h2 className="text-lg font-semibold flex items-center gap-2 text-slate-900 dark:text-slate-100">
                 <AlertCircle size={20} className="text-amber-500" />
@@ -1120,7 +1268,7 @@ export default function SettingsPage() {
           )}
 
           {/* System */}
-          {activeTab === 'system' && (
+          {aktiverReiter === 'system' && (
             <section className="space-y-6">
               <h2 className="text-lg font-semibold flex items-center gap-2 text-slate-900 dark:text-slate-100">
                 <Wrench size={20} className="text-amber-500" />
@@ -1188,13 +1336,44 @@ export default function SettingsPage() {
                 </p>
               </div>
 
-              <Input
-                type="password"
-                label="MakeMKV Beta-Key"
-                value={settings.makemkvAppKey}
-                onChange={(e) => handleChange('makemkvAppKey', e.target.value)}
-                placeholder="T-… (Forum-Thread „MakeMKV is free while in beta”)"
-              />
+              {/*
+                Der Beta-Key holt sich selbst — man sah es nur nirgends.
+
+                Commander am 28.08.2026: „Bezüglich des MKV Beta Keys — der
+                könnte theoretisch auch automatisch ausgelesen werden, ich
+                glaube das web rippy kann das." Er hatte recht:
+                `makemkv_key.refresh_loop()` läuft täglich mit, seit es die
+                Datei gibt (gemessen: Forum antwortet in 3,3 s, Key mit 62
+                Zeichen). Hier stand aber nur ein Passwortfeld — ob der Wert
+                darin von Hand kam oder von selbst, war nicht zu erkennen.
+                Eine Automatik, die man nicht sehen kann, ist für den
+                Benutzer keine.
+              */}
+              <div className="space-y-2">
+                <Input
+                  type="password"
+                  label="MakeMKV Beta-Key"
+                  value={settings.makemkvAppKey}
+                  onChange={(e) => handleChange('makemkvAppKey', e.target.value)}
+                  placeholder="T-… (Forum-Thread „MakeMKV is free while in beta”)"
+                />
+                <div className="flex items-center gap-2 flex-wrap">
+                  <Button
+                    variant="secondary"
+                    size="sm"
+                    disabled={keyHolt}
+                    onClick={keyJetztHolen}
+                  >
+                    {keyHolt ? 'wird geholt …' : 'Jetzt aus dem Forum holen'}
+                  </Button>
+                  <span className={`text-xs ${keyMeldung.startsWith('Fehlgeschlagen')
+                    ? 'text-red-600 dark:text-red-400'
+                    : 'text-slate-500 dark:text-slate-400'}`}>
+                    {keyMeldung || 'Rippy holt ihn ohnehin täglich selbst — '
+                      + 'der Key wechselt etwa monatlich.'}
+                  </span>
+                </div>
+              </div>
 
               {/*
                 Schlüsselspeicher — der Hauptweg für 4K-UHD (Befund 25.07.2026,

docker/worker/ablauf.py

@@ -47,7 +47,7 @@ import time
 import requests
 
 from rippy import store as db
-from rippy.rip import makemkv_daten
+from rippy.rip import makemkv_aufruf, makemkv_daten
 import medien
 from rippy.core import notify
 
@@ -157,7 +157,7 @@ def unter_wurzel(pfad: str, wurzel: str) -> bool:
     return pfad == sauber or pfad.startswith(sauber + "/")
 
 
-def _zielbasis(target_dir, disc_type: str) -> str:
+def _zielbasis(target_dir, disc_type: str, wurzeln=None) -> str:
     """Ablagebasis: vom Nutzer gewähltes Ziel (validiert) oder Standard.
 
     posixpath statt os.path — aus demselben Grund wie in _arbeitsverzeichnis:
@@ -167,16 +167,70 @@ def _zielbasis(target_dir, disc_type: str) -> str:
     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.
     """
+    wurzel, _vorgabe, frei = wurzeln or _betriebs_wurzeln()
     if target_dir:
-        normalisiert = posixpath.normpath(target_dir)
-        if unter_wurzel(normalisiert, MEDIA_ROOT):
+        normalisiert = _normalisiert(target_dir)
+        if frei or unter_wurzel(normalisiert, wurzel):
             return normalisiert
-    return posixpath.join(RIP_OUTPUT_DIR, disc_type)
+    # Ohne Wahl: die Wurzel dieses Betriebs, nicht die des Containers. Sonst
+    # landete die fertige Datei unter Windows in `X:\app\media\bluray` —
+    # einem Ordner, den niemand gesucht hat (gemessen 29.08.2026).
+    from rippy import pfade
+
+    return pfade.verbinden(wurzel if frei else RIP_OUTPUT_DIR, disc_type)
 
 
-def _arbeitsverzeichnis(einstellungen: dict, job_wahl: str = "") -> str:
+def _betriebs_wurzeln() -> tuple:
+    """`(medien_wurzel, arbeits_vorgabe, frei)` für DIESEN Betrieb.
+
+    ## Warum das hier gebraucht wird (Befund 29.08.2026)
+
+    Beim Nachstellen des leeren Bildschirms lief ein echter Test-Rip durch —
+    und die Rohdaten landeten in **`F:\\app\\temp\\raw`**. Also in einem
+    Ordner namens `app` auf dem Laufwerk, von dem Rippy gerade lief.
+
+    `RAW_DIR` ist `/app/temp/raw` und `MEDIA_ROOT` ist `/app/media`; unter
+    Windows sind das keine Pfade, sondern Unfälle. Schlimmer noch: Die
+    Prüfung `unter_wurzel(wahl, MEDIA_ROOT)` verwarf **auch eine ausdrückliche
+    Wahl** — ein Arbeitsordner wie `D:\\Roh` liegt nicht unter `/app/media`,
+    also fiel er still auf den Container-Standard zurück.
+
+    Damit kam der Arbeitsordner, den der Commander am 28.08.2026 ausdrücklich
+    bestellt hat („kannst du noch einbauen das man den arbeitsordner … setzen
+    kann"), unter Windows nie an. Der Dialog zeigte ihn, das Setzen ging, und
+    der Worker ignorierte ihn — ohne ein Wort.
+
+    Im Container ändert sich nichts: Dort ist `/app/media` die Wurzel, und
+    `frei` ist falsch.
+    """
+    from rippy import betrieb, config
+
+    try:
+        werte = config.laden()
+    except Exception:                                # noqa: BLE001
+        werte = {}
+    return (betrieb.medien_wurzel(werte) or MEDIA_ROOT,
+            betrieb.arbeits_vorgabe(werte) or RAW_DIR,
+            betrieb.frei_blaettern(werte))
+
+
+def _normalisiert(wert: str) -> str:
+    """Pfad säubern — nach seiner FORM, nicht nach dem laufenden Rechner.
+
+    `posixpath` für Container-Pfade (sonst macht Windows Backslashes daraus
+    und die Wurzelprüfung greift nicht mehr), `os.path` für echte
+    Windows-Pfade. Dieselbe Regel wie in `rippy.pfade`.
+    """
+    from rippy import pfade
+
+    return os.path.normpath(wert) if pfade.ist_windows_pfad(wert) \
+        else posixpath.normpath(wert)
+
+
+def _arbeitsverzeichnis(einstellungen: dict, job_wahl: str = "",
+                        wurzeln=None) -> str:
     """Basis für Roh-Rips. Reihenfolge: Wahl DIESES Rips → UI-Setting
-    `workDir` → Container-Default /app/temp/raw.
+    `workDir` → Vorgabe dieses Betriebs (Container: /app/temp/raw).
 
     Hintergrund (Commander 24.07.): Die VM-Platte (150 GB) reicht für BD-50,
     aber eine 4K-UHD (bis 100 GB roh + Kompression daneben) sprengt sie —
@@ -187,26 +241,48 @@ def _arbeitsverzeichnis(einstellungen: dict, job_wahl: str = "") -> str:
     Standard — und ist damit der Wert, der bei Vollautomatik-Rips greift, bei
     denen niemand gefragt wird.
     """
-    # posixpath statt os.path: Das sind IMMER Container-Pfade (/app/media/...),
-    # auch wenn ein nativer Windows-Worker dieses Modul lädt — der übersetzt
-    # sie erst später mit pfad_lokal(). os.path.normpath macht unter Windows
-    # Backslashes daraus, und dann greift die MEDIA_ROOT-Prüfung nicht mehr.
+    wurzel, vorgabe, frei = wurzeln or _betriebs_wurzeln()
     for kandidat in (job_wahl, einstellungen.get("workDir")):
         wert = (kandidat or "").strip()
-        if wert:
-            normalisiert = posixpath.normpath(wert)
-            if unter_wurzel(normalisiert, MEDIA_ROOT):
-                return normalisiert
-    return RAW_DIR
+        if not wert:
+            continue
+        normalisiert = _normalisiert(wert)
+        # Nativ zählt die Wahl des Nutzers — dort IST sein Laufwerk die
+        # Grenze. Im Container bleibt die Wurzelprüfung: Ein Pfad ausserhalb
+        # von /app/media wäre dort ein Pfad ins Nichts.
+        if frei or unter_wurzel(normalisiert, wurzel):
+            return normalisiert
+    return vorgabe
 
 
 def _frei_bytes(pfad: str) -> int:
-    """Freier Platz am Pfad (nächster existierender Elternordner zählt)."""
-    kandidat = pfad
-    while kandidat and not os.path.exists(kandidat):
-        kandidat = os.path.dirname(kandidat)
+    """Freier Platz am Pfad (nächster existierender Elternordner zählt).
+
+    ## Warum die Suche nach oben NICHT hier steht (Befund 30.08.2026)
+
+    An dieser Stelle stand sie als eigene Schleife:
+
+        while kandidat and not os.path.exists(kandidat):
+            kandidat = os.path.dirname(kandidat)
+
+    Unter Windows gibt `os.path.dirname("Q:\\")` **sich selbst** zurueck — an
+    einem freien Laufwerksbuchstaben nachgemessen. Zeigt das
+    Arbeitsverzeichnis oder ein Ablageziel auf ein Laufwerk, das gerade
+    nicht da ist (abgezogene USB-Platte, getrennte Netzlaufwerks-
+    Zuordnung), dreht diese Schleife **fuer immer**. Und zwar in
+    `_platz_pruefen`, also VOR dem Rip: Der Job bliebe ohne eine einzige
+    Meldung stehen, und im Protokoll stuende nichts, womit man das
+    aufklären koennte.
+
+    `pfade.naechster_vorhandener` macht dasselbe seit V2-1 richtig — mit
+    Abbruch bei `eltern == pfad` und einer `gesehen`-Menge gegen Zyklen.
+    Es war die ganze Zeit da. Dieselbe Entscheidung an zwei Orten, einer
+    davon veraltet: genau das Muster aus dem Kopf von `makemkv_aufruf.py`.
+    """
+    from rippy import pfade
+
     try:
-        return shutil.disk_usage(kandidat or "/").free
+        return shutil.disk_usage(pfade.naechster_vorhandener(pfad) or "/").free
     except OSError:
         return -1
 
@@ -243,17 +319,27 @@ def _makemkv_key_anwenden(einstellungen: dict) -> None:
     key = (einstellungen.get("makemkvAppKey") or "").strip()
     if not key:
         return
-    pfad = os.path.join(makemkv_daten.DATEN_DIR, "settings.conf")
     try:
-        os.makedirs(makemkv_daten.DATEN_DIR, exist_ok=True)
-        try:
-            with open(pfad, encoding="utf-8", errors="replace") as f:
-                alt = f.read()
-        except OSError:
-            alt = ""
-        with open(pfad, "w", encoding="utf-8", newline="\n") as f:
-            f.write(makemkv_daten.settings_conf_zusammenfuehren(alt, key))
-    except OSError as e:
+        # WOHIN, entscheidet der Rechner — unter Windows die Registry, sonst
+        # die settings.conf. Begruendung und Messung in
+        # `rippy.rip.makemkv_aufruf.key_ablegen`.
+        #
+        # UND nachsehen, ob MakeMKV ihn annimmt: Ein abgelehnter Schluessel
+        # ist schlimmer als gar keiner — ohne las MakeMKV die Disc noch, mit
+        # einem abgelehnten verweigerte es alles (gemessen 29.08.2026). Die
+        # paar Sekunden Rueckfrage sind nichts gegen einen Rip, der Stunden
+        # laeuft und sonst am ersten Titel scheitert.
+        from ripping import werkzeug
+
+        # Dasselbe, was `docker/worker/entrypoint.sh` vor jedem Worker-Start
+        # tut — nur in der Windows-Form.
+        makemkv_aufruf.einstellungen_sicherstellen()
+        urteil = makemkv_aufruf.key_setzen_und_pruefen(key, werkzeug("makemkv"))
+        if not urteil["ok"]:
+            db.add_log("warning", "worker",
+                       "MakeMKV nimmt den hinterlegten Beta-Key nicht an: %s"
+                       % urteil["grund"])
+    except (OSError, ImportError) as e:
         db.add_log("warning", "worker", f"MakeMKV-Key konnte nicht gesetzt werden: {e}")
 
 
@@ -547,7 +633,14 @@ def rippen(device_path: str, job_id: str, target_dir: str = None,
         if code == 1003 or len(gesehen) >= MAX_MELDUNGEN or text in gesehen:
             return
         gesehen.add(text)
-        db.add_log("info", "makemkv", f"Job {job_id}: {text[:300]}")
+        # Die MSG-NUMMER gehoert dazu (Befund 30.08.2026). MakeMKVs Texte
+        # sind uebersetzt, die Nummern nicht — sie sind die einzige
+        # verlaessliche Kennung (so arbeitet KRITISCHE_CODES). Ohne sie
+        # war an einem Lesefehler-Protokoll nicht abzulesen, WELCHE
+        # Meldung MakeMKV geschickt hatte; die Erkennung musste sich
+        # ersatzweise an einer URL im Text festhalten.
+        db.add_log("info", "makemkv",
+                   f"Job {job_id}: MSG {code} — {text[:300]}")
 
     einstellungen = db.get_settings(bei_fehler_leer=True)
     ist_video = disc_type in ("dvd", "bluray", "uhd")
@@ -675,6 +768,21 @@ def rippen(device_path: str, job_id: str, target_dir: str = None,
                 "Normale BD/DVD gehen weiterhin."
             )
 
+    # Lesefehler laut sagen — auch (und gerade) wenn der Rip als Erfolg
+    # endet. Befund 30.08.2026: MakeMKV sicherte 1 von 2 Titeln, meldete
+    # sich mit Code 0, und Rippy schrieb „Rip fertig". Dass ein Titel
+    # fehlt, stand nur in den MakeMKV-Zeilen. Wer die nicht liest, haelt
+    # eine halbe Disc für eine ganze.
+    if ergebnis.get("lesefehler"):
+        db.add_log(
+            "warning", "worker",
+            f"Job {job_id}: Die Disc hat Lesefehler — MakeMKV kam an "
+            "mehreren Stellen nicht durch. Es kann sein, dass ein Titel "
+            "fehlt oder unvollständig ist. Abhilfe: Disc reinigen (radial "
+            "von innen nach außen, nicht kreisend) oder ein anderes "
+            "Laufwerk probieren — Laufwerke unterscheiden sich hier stark.",
+        )
+
     # Automatischer Auswurf. Die Disc ist nach dem Rip nicht mehr nötig — die
     # Kompression arbeitet auf der Datei, nicht am Laufwerk.
     #
@@ -802,7 +910,8 @@ def erster_vorhandener_ordner(pfad: str, isdir=None, dirname=None) -> str:
 
 
 def _erreichbarkeit_pruefen(raw_container: str, raw_lokal: str,
-                            final_container: str, final_lokal: str) -> str:
+                            final_container: str, final_lokal: str,
+                            fremd=None) -> str:
     """Kann DIESER Worker Quelle und Ziel überhaupt sehen? Klartext oder "".
 
     Befund 25.07.2026 am Job 95afdc89, live: Das gezielte Routing an den
@@ -824,7 +933,20 @@ def _erreichbarkeit_pruefen(raw_container: str, raw_lokal: str,
     Quelle — sonst scheitert es erst beim Schreiben, nach Stunden Rechenzeit.
     """
     mapping = os.getenv("RIPPY_PATH_MAP", "")
-    fremder_worker = not os.path.isdir("/app")
+    # ⚠️ Hier stand `not os.path.isdir("/app")` (Befund 29.08.2026) — dasselbe
+    # Muster wie in `caps.py`. Im Image stimmt es; auf einem Windows-PC gibt
+    # es `/app` nicht, und der eigenstaendige Rippy hielt sich fuer einen
+    # FREMDEN Worker. Er haette sich dann selbst vorgeworfen, die
+    # Container-Pfade nicht zu erreichen — auf einer Maschine ohne Container.
+    #
+    # `fremd` ist einspritzbar, damit BEIDE Faelle ueberall pruefbar sind:
+    # Vorher haing der Test daran, ob es einen Ordner `/app` gibt, und war
+    # damit an den laufenden Rechner gebunden.
+    if fremd is None:
+        from caps import _extern
+
+        fremd = _extern() == "ja"
+    fremder_worker = fremd
 
     for zweck, container, lokal in (
         ("die Quelle (Rohdaten)", raw_container, raw_lokal),
@@ -1002,7 +1124,11 @@ def komprimieren(job_id: str, raw_dir: str, final_dir: str):
                 "status": "error",
                 "error": (
                     f"Kompression fehlgeschlagen bei {os.path.basename(quelle)}: "
-                    f"{hb.get('error')} — Roh-Datei bleibt in /app/temp erhalten"
+                    # Den ECHTEN Ordner nennen, nicht „/app/temp" (Befund
+                    # 29.08.2026). Auf Windows gibt es den nicht, und wer die
+                    # Roh-Datei retten will, sucht sonst am falschen Ort.
+                    f"{hb.get('error')} — Roh-Datei bleibt unter "
+                    f"{os.path.dirname(quelle)} erhalten"
                 ),
             }
             _job_abschliessen(job_id, ergebnis)

docker/worker/caps.py

@@ -8,13 +8,39 @@ Remote-GPU-Worker meldet sich hier genauso wie der eingebaute CPU-Worker.
 import os
 import platform
 import re
-import shutil
 import subprocess
 
 from rippy.platform.winlauf import OHNE_FENSTER
+from rippy.rip.handbrake_aufruf import HB_LESEN
 from rippy.tools import katalog as werkzeuge
 
 
+def _extern(werte=None, container=None) -> str:
+    """Läuft Rippy woanders als dieser Worker? „ja"/„nein" (einspritzbar).
+
+    Drei Fälle, und nur einer davon ist „ja":
+
+    * **Im Container** — der Worker ist Teil von Rippy. Nein.
+    * **Nativ und eigenständig** (Windows-App) — dieser Prozess IST Rippy.
+      Nein. Es gibt hier weder Container-Pfade noch eine Freigabe, über die
+      etwas zu übersetzen wäre.
+    * **Nativ und verteilt** — ein Worker auf einem anderen Rechner, der sich
+      bei einem Docker-Rippy meldet. Ja; er braucht RIPPY_PATH_MAP.
+    """
+    from rippy import betrieb, config
+
+    if container is None:
+        container = betrieb.im_container()
+    if container:
+        return "nein"
+    if werte is None:
+        try:
+            werte = config.laden()
+        except Exception:                            # noqa: BLE001
+            werte = {}
+    return "ja" if betrieb.modus(werte) == "verteilt" else "nein"
+
+
 def _hb() -> str:
     """Pfad zu HandBrakeCLI — "" wenn es nicht da ist.
 
@@ -166,7 +192,7 @@ def hole_handbrake_presets() -> list:
     try:
         aus = subprocess.run(
             [_hb(), "--preset-list"],
-            capture_output=True, text=True, timeout=30,
+            capture_output=True, timeout=30, **HB_LESEN,
             creationflags=OHNE_FENSTER,
         )
         return parse_preset_liste((aus.stdout or "") + (aus.stderr or ""))
@@ -279,8 +305,8 @@ def hole_handbrake_hilfe() -> str:
         return ""
     try:
         aus = subprocess.run(
-            [_hb(), "--help"], capture_output=True, text=True, timeout=30,
-            creationflags=OHNE_FENSTER
+            [_hb(), "--help"], capture_output=True, timeout=30,
+            creationflags=OHNE_FENSTER, **HB_LESEN
         )
         return (aus.stdout or "") + (aus.stderr or "")
     except (OSError, subprocess.TimeoutExpired):
@@ -343,8 +369,18 @@ def werkzeug_versionen() -> dict:
         # Container-Pfade (/app/media, /app/temp) nur über eine Freigabe plus
         # RIPPY_PATH_MAP erreicht. Das UI kann damit VOR dem Rip warnen, statt
         # den Nutzer eine Stunde rippen zu lassen (Vorfall 25.07.2026).
-        # /app ist im Rippy-Image immer vorhanden — kein Ratespiel.
-        "extern": "nein" if os.path.isdir("/app") else "ja",
+        #
+        # ⚠️ Hier stand `os.path.isdir("/app")` (Befund 29.08.2026). Im Image
+        # stimmt das. Auf einem Windows-PC gibt es `/app` nicht — und damit
+        # hielt sich der eigenständige Windows-Rippy für einen FREMDEN Worker.
+        # Folge: Das UI warnte vor fehlender Pfad-Übersetzung auf einer
+        # Maschine, auf der es weder Container noch Freigabe gibt.
+        #
+        # „Extern" heißt: Rippy läuft woanders als dieser Worker. In der
+        # eigenständigen Installation IST dieser Worker Rippy — dort ist die
+        # Frage gegenstandslos. Deshalb entscheidet der Betrieb, nicht ein
+        # Ordnername.
+        "extern": _extern(),
         # Ist die Pfad-Übersetzung gesetzt? Ohne sie kann ein externer Worker
         # grundsätzlich nicht komprimieren.
         "pfad_map": os.getenv("RIPPY_PATH_MAP", ""),
@@ -368,7 +404,7 @@ def werkzeug_versionen() -> dict:
         try:
             aus = subprocess.run(
                 [_hb(), "--version"],
-                capture_output=True, text=True, timeout=15,
+                capture_output=True, timeout=15, **HB_LESEN,
                 creationflags=OHNE_FENSTER,
             )
             treffer = re.search(r"HandBrake\s+([\w.]+)", (aus.stdout or "") + (aus.stderr or ""))
@@ -402,7 +438,21 @@ def werkzeug_versionen() -> dict:
         daten_dir = makemkv_daten.DATEN_DIR
     except Exception:
         daten_dir = ""
-    if shutil.which("makemkvcon") and daten_dir and os.path.ismount(daten_dir):
+    # ⚠️ `shutil.which` und `os.path.ismount` sind hier BEIDE Linux-Annahmen
+    # (Befund 29.08.2026): Unter Windows liegt makemkvcon in „Programme" und
+    # nicht im PATH, und ein normaler Ordner ist kein Mount. Beide Prüfungen
+    # waren dort also immer falsch — die Schlüssel-Auskunft blieb dauerhaft
+    # „unbekannt", obwohl MakeMKV samt Datenverzeichnis da war.
+    #
+    # Der Mount-Test bleibt für den Container: Dort teilen sich Rippy und ein
+    # reiner Encoder-Worker dasselbe Image, aber nur einer bekommt den Mount.
+    # Nativ zählt stattdessen, ob der Ordner überhaupt existiert.
+    from rippy import betrieb
+
+    _im_container = betrieb.im_container()
+    daten_da = bool(daten_dir) and (os.path.ismount(daten_dir) if _im_container
+                                    else os.path.isdir(daten_dir))
+    if werkzeuge.finden("makemkv") and daten_da:
         try:
             info["keydb"] = "ja" if makemkv_daten.keydb_status().get("vorhanden") else "nein"
         except Exception:

docker/worker/ripping.py

@@ -37,6 +37,9 @@ from rippy.drives.linux import (  # noqa: F401
 )
 from rippy.drives.linux import auswerfen_versuchen as wirf_disc_aus  # noqa: F401
 from rippy.platform.winlauf import OHNE_FENSTER
+from rippy.rip.handbrake_aufruf import HB_LESEN
+from rippy.rip.makemkv_aufruf import KRITISCHE_CODES, text_von
+from rippy.rip.makemkv_aufruf import quelle as makemkv_quelle
 from rippy.tools import katalog as werkzeuge
 
 _NACKTER_NAME = {"makemkv": "makemkvcon", "handbrake": "HandBrakeCLI"}
@@ -86,6 +89,24 @@ def check_cdparanoia_installed() -> bool:
     return shutil.which("cdparanoia") is not None
 
 
+#: Sprachunabhaengige Marke fuer „die Disc liess sich stellenweise nicht lesen".
+#:
+#: Am 30.08.2026 im Protokoll des Commanders abgelesen (Spartacus Disc 2,
+#: deutschsprachiges MakeMKV):
+#:
+#:   Encountered 29 errors of type 'Read Error' - see
+#:   http://www.makemkv.com/errors/read/
+#:   Das Kopieren wurde abgeschlossen. 1 Titel wurden gesichert, 1 schlugen fehl.
+#:
+#: Die URL steht auch in der deutschen Fassung englisch da — sie ist damit die
+#: einzige Stelle dieser Meldung, auf die Verlass ist. Die MSG-NUMMER waere
+#: besser (so macht es KRITISCHE_CODES), aber sie war im Protokoll nicht zu
+#: sehen: `melde_makemkv` schrieb sie bis heute nicht mit. Das ist behoben —
+#: beim naechsten Lesefehler steht die Nummer im Log, und dann gehoert sie
+#: hierher statt dieser Textsuche.
+LESEFEHLER_MARKE = "makemkv.com/errors/read"
+
+
 def build_makemkv_cmd(device_path: str, output_dir: str, titel: str = "all") -> list:
     """Baut das MakeMKV-Kommando (pure Funktion, testbar).
 
@@ -102,7 +123,7 @@ def build_makemkv_cmd(device_path: str, output_dir: str, titel: str = "all") ->
         "--noscan",
         "--progress=-same",
         "mkv",
-        f"dev:{device_path}",
+        makemkv_quelle(device_path),
         str(titel),
         output_dir,
     ]
@@ -257,11 +278,11 @@ def lies_titel_info(device_path: str, timeout: int = 300) -> tuple:
     wäre eine Minute Wartezeit für nichts.
     """
     ergebnis = subprocess.run(
-        [werkzeug("makemkv"), "-r", "--noscan", "info", f"dev:{device_path}"],
-        capture_output=True, text=True, timeout=timeout,
+        [werkzeug("makemkv"), "-r", "--noscan", "info", makemkv_quelle(device_path)],
+        capture_output=True, timeout=timeout,      # binaer: siehe text_von
         creationflags=OHNE_FENSTER,
     )
-    ausgabe = ergebnis.stdout or ""
+    ausgabe = text_von(ergebnis.stdout)
     return parse_titel_info(ausgabe), parse_stream_info(ausgabe)
 
 
@@ -271,6 +292,9 @@ def rip_titel_auswahl(device_path: str, output_dir: str, titel_liste: list,
     Titel oder 'all' — also ein Aufruf je Titel, Fortschritt anteilig)."""
     gesamt = len(titel_liste)
     alle_dateien = []
+    # Ein Lesefehler in Titel 1 darf nicht verschwinden, nur weil Titel 2
+    # sauber durchlief — je Titel laeuft ein eigener makemkvcon.
+    lesefehler = False
     for index, nr in enumerate(titel_liste):
         def anteilig(p, _i=index):
             if progress_cb:
@@ -278,13 +302,16 @@ def rip_titel_auswahl(device_path: str, output_dir: str, titel_liste: list,
 
         ergebnis = run_makemkv(device_path, output_dir, progress_cb=anteilig, titel=str(nr),
                                log_cb=log_cb)
+        lesefehler = lesefehler or bool(ergebnis.get("lesefehler"))
         if ergebnis.get("status") == "cancelled":
             return ergebnis
         if ergebnis.get("status") != "success":
             ergebnis["error"] = f"Titel {nr}: {ergebnis.get('error')}"
+            ergebnis["lesefehler"] = lesefehler
             return ergebnis
         alle_dateien = ergebnis.get("files", [])  # kumulativ: run_makemkv listet den Ordner
-    return {"status": "success", "output_dir": output_dir, "files": alle_dateien}
+    return {"status": "success", "output_dir": output_dir, "files": alle_dateien,
+            "lesefehler": lesefehler}
 
 
 def laengster_titel(dauern: dict, meta: dict = None):
@@ -330,13 +357,13 @@ def lies_titel_dauern(device_path: str, timeout: int = 300) -> dict:
     """Fragt die Titel-Laufzeiten der Disc ab (makemkvcon info, Robot-Mode)."""
     try:
         ergebnis = subprocess.run(
-            [werkzeug("makemkv"), "-r", "--noscan", "info", f"dev:{device_path}"],
-            capture_output=True, text=True, timeout=timeout,
+            [werkzeug("makemkv"), "-r", "--noscan", "info", makemkv_quelle(device_path)],
+            capture_output=True, timeout=timeout,  # binaer: siehe text_von
             creationflags=OHNE_FENSTER,
         )
     except (OSError, subprocess.TimeoutExpired):
         return {}
-    return parse_tinfo_dauern(ergebnis.stdout or "")
+    return parse_tinfo_dauern(text_von(ergebnis.stdout))
 
 
 def parse_scan_dauer(ausgabe: str) -> int:
@@ -360,7 +387,7 @@ def lies_datei_dauer(pfad: str, timeout: int = 120) -> int:
     try:
         ergebnis = subprocess.run(
             [werkzeug("handbrake"), "--scan", "-i", pfad],
-            capture_output=True, text=True, timeout=timeout,
+            capture_output=True, timeout=timeout, **HB_LESEN,
             creationflags=OHNE_FENSTER,
         )
     except (OSError, subprocess.TimeoutExpired):
@@ -474,6 +501,12 @@ def preset_fuer(disc_type: str, einstellungen: dict) -> str:
     return (einstellungen.get("transcodePreset") or "").strip() or DEFAULT_HB_PRESET
 
 
+#: Endung -> HandBrake-Container. Am mitgelieferten HandBrake 1.11.2
+#: gegengeprueft (`--help`, Abschnitt `-f, --format`).
+FORMATE = {".mkv": "av_mkv", ".mp4": "av_mp4", ".m4v": "av_mp4",
+           ".mov": "av_mov", ".webm": "av_webm"}
+
+
 def build_handbrake_cmd(input_path: str, output_path: str,
                         preset: str = DEFAULT_HB_PRESET,
                         audio_sprachen=None, untertitel_sprachen=None) -> list:
@@ -499,7 +532,7 @@ def build_handbrake_cmd(input_path: str, output_path: str,
        Sprachen drin — und das ist bei einer verlustfreien Ablage richtig.
 
     `--audio-lang-list` zusammen mit `--first-audio` heißt: HandBrake pickt pro
-    Sprache genau die erste (beste) Tonspur heraus. `--audio-codec copy` reicht
+    Sprache genau die erste (beste) Tonspur heraus. `--aencoder copy` reicht
     diese dann verlustfrei durch, statt sie auf Stereo herunterzurechnen.
     """
     befehl = [
@@ -508,11 +541,46 @@ def build_handbrake_cmd(input_path: str, output_path: str,
         "--output", output_path,
         "--preset", preset,
     ]
+    # Den Container zur Endung erzwingen (Befund 29.08.2026).
+    #
+    # Commander: „Kompression fehlgeschlagen bei title_t00.mkv: HandBrake
+    # endete mit Code 0"
+    #
+    # Code 0 heisst bei HandBrake ERFOLG — und trotzdem lag am erwarteten Ort
+    # keine Datei. Der Grund: **HandBrake bestimmt den Container aus dem
+    # Preset, nicht aus der Endung.** Steht ein MP4-Preset ein, schreibt es
+    # `title_t00.mp4` neben das verlangte `title_t00.mkv`, meldet „Output
+    # format changed" — und beendet sich mit 0. Rippy sah an seiner Stelle
+    # nichts und nannte das „fehlgeschlagen".
+    #
+    # `-f/--format` ist der dokumentierte Schalter dafuer (an dem
+    # mitgelieferten HandBrake 1.11.2 gegengeprueft: av_mp4, av_mov, av_mkv,
+    # av_webm). Damit sind Endung und Container EINE Entscheidung statt zwei,
+    # die auseinanderlaufen koennen.
+    format_name = FORMATE.get(os.path.splitext(output_path)[1].lower())
+    if format_name:
+        befehl += ["--format", format_name]
     audio = [s for s in (audio_sprachen or []) if s]
     if audio:
         befehl += ["--audio-lang-list", ",".join(audio)]
     befehl.append("--first-audio")
-    befehl += ["--audio-codec", "copy", "--audio-fallback", "av_aac"]
+    # `--aencoder`, NICHT `--audio-codec` (Befund 30.08.2026).
+    #
+    # Den Schalter `--audio-codec` gibt es bei HandBrakeCLI nicht und hat es
+    # nie gegeben — er heisst `-E` / `--aencoder`. Am mitgelieferten
+    # HandBrakeCLI 1.11.2 nachgestellt, mit Rippys eigener Befehlszeile:
+    #
+    #     unknown option (--audio-codec)
+    #     HandBrake has exited.        $? = 0
+    #
+    # Ein ganzer Blu-ray-Rip (16,5 GB) lief damit ins Leere: HandBrake war
+    # in derselben Sekunde wieder weg, in der es startete, und meldete das
+    # als ERFOLG. Der Test darunter forderte den falschen Namen sogar ein
+    # (`assert "--audio-codec" in cmd`) — ein Test, der einen Fehler
+    # festschreibt, statt ihn zu finden.
+    #
+    # `copy` ist als Wert gueltig (in `--help` gelistet, ebenda geprueft).
+    befehl += ["--aencoder", "copy", "--audio-fallback", "av_aac"]
     untertitel = [s for s in (untertitel_sprachen or []) if s]
     if untertitel:
         befehl += ["--subtitle-lang-list", ",".join(untertitel)]
@@ -577,6 +645,23 @@ def sprachliste(wert) -> list:
     return sauber
 
 
+def _datei_daneben(erwartet: str) -> str:
+    """Dieselbe Datei mit anderer Endung im selben Ordner — oder "".
+
+    HandBrake waehlt den Container nach dem Preset. Passt er nicht zur
+    verlangten Endung, liegt das Ergebnis unter demselben Namen mit anderer
+    Endung daneben (Befund 29.08.2026). Gesucht wird nur in den Endungen, die
+    HandBrake ueberhaupt schreiben kann.
+    """
+    ordner = os.path.dirname(erwartet)
+    stamm = os.path.splitext(os.path.basename(erwartet))[0]
+    for endung in FORMATE:
+        kandidat = os.path.join(ordner, stamm + endung)
+        if kandidat != erwartet and os.path.isfile(kandidat):
+            return kandidat
+    return ""
+
+
 def run_handbrake(input_path: str, output_path: str, preset: str = DEFAULT_HB_PRESET,
                   progress_cb=None, abbruch_cb=None,
                   audio_sprachen=None, untertitel_sprachen=None) -> dict:
@@ -600,9 +685,9 @@ def run_handbrake(input_path: str, output_path: str, preset: str = DEFAULT_HB_PR
                                 audio_sprachen, untertitel_sprachen),
             stdout=subprocess.PIPE,
             stderr=subprocess.STDOUT,
-            text=True,
             bufsize=1,
             creationflags=OHNE_FENSTER,
+            **HB_LESEN,
         )
         return _handbrake_schleife(process, output_path, abbruch_cb, progress_cb)
     except Exception as e:
@@ -629,10 +714,67 @@ def unbekanntes_preset(zeile: str) -> str:
     return text[len(kopf):].strip() if text.startswith(kopf) else ""
 
 
+#: Wie viele Ausgabezeilen von HandBrake fuer den Fehlerfall aufgehoben werden.
+HB_ZEILEN_PUFFER = 12
+#: ... und wie viele davon in die Fehlermeldung wandern. Sie steht in der
+#: Jobzeile und im UI; zwoelf Zeilen Muxer-Statistik waeren dort unlesbar.
+HB_ZEILEN_MELDUNG = 4
+
+_UNBEKANNTER_SCHALTER = re.compile(r"unknown option \(([^)]*)\)")
+
+
+def unbekannter_schalter(zeile: str) -> str:
+    """Meldet diese Zeile einen Schalter, den DIESES HandBrake nicht kennt?
+
+    ## Der Befund des Commanders (30.08.2026)
+
+    > „Kompression fehlgeschlagen bei Spartacus … _t01.mkv: HandBrake endete
+    > mit Code 0 — Roh-Datei bleibt erhalten"
+
+    16,5 GB Rohschnitt, und die Kompression war in derselben Sekunde vorbei,
+    in der sie begann — fuer einen Scan-Durchlauf haette das nicht gereicht.
+    Am mitgelieferten HandBrakeCLI 1.11.2 nachgestellt, mit genau der
+    Befehlszeile, die Rippy baute:
+
+        unknown option (--audio-codec)
+        HandBrake has exited.
+        $? = 0
+
+    **Der Rueckgabewert ist 0.** HandBrake meldet einen Tippfehler in seiner
+    eigenen Befehlszeile als ERFOLG. Rippy sah nur „Code 0" und keine Datei —
+    und riet daraufhin auf „Zielordner nicht beschreibbar". Das war falsch,
+    und es schickte die Suche in die vollkommen falsche Richtung.
+
+    Der Schalter ist repariert (siehe `build_handbrake_cmd`). Diese Pruefung
+    bleibt trotzdem: Der naechste falsche Schalter soll sich SELBST melden,
+    statt wieder einen ganzen Rip zu kosten.
+    """
+    treffer = _UNBEKANNTER_SCHALTER.search(zeile or "")
+    return treffer.group(1).strip() if treffer else ""
+
+
+def hb_schluss(zeilen) -> str:
+    """HandBrakes letzte Worte als Anhang fuer eine Fehlermeldung (pure).
+
+    Bis zum 30.08.2026 warf `_handbrake_schleife` jede Zeile weg, die kein
+    Fortschritt war. Im Fehlerfall blieb damit nur der Rueckgabewert uebrig —
+    und wenn der 0 ist, sagt er nichts. Der Grund stand die ganze Zeit in der
+    Ausgabe, nur hoerte niemand zu.
+    """
+    sauber = [z.strip() for z in (zeilen or []) if z and z.strip()]
+    if not sauber:
+        return ""
+    return " — HandBrake sagte zuletzt: " + " | ".join(sauber[-HB_ZEILEN_MELDUNG:])
+
+
 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."""
     falsches_preset = ""
+    falscher_schalter = ""
+    # Die letzten Zeilen aufheben — im Fehlerfall sind sie die einzige
+    # Auskunft, die es ueberhaupt gibt (siehe `hb_schluss`).
+    letzte_zeilen = []
     try:
         for line in process.stdout:
             # Zuerst der Abbruch — unabhängig davon, ob die Zeile überhaupt
@@ -640,8 +782,14 @@ def _handbrake_schleife(process, output_path: str, abbruch_cb=None, progress_cb=
             # sich die Prozentzahl bewegt (Befund 25.07.2026).
             if abbruch_cb:
                 abbruch_cb()
+            if line.strip():
+                letzte_zeilen.append(line)
+                if len(letzte_zeilen) > HB_ZEILEN_PUFFER:
+                    del letzte_zeilen[0]
             if not falsches_preset:
                 falsches_preset = unbekanntes_preset(line)
+            if not falscher_schalter:
+                falscher_schalter = unbekannter_schalter(line)
             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
@@ -657,6 +805,57 @@ def _handbrake_schleife(process, output_path: str, abbruch_cb=None, progress_cb=
 
     if process.returncode == 0 and os.path.exists(output_path):
         return {"status": "success", "output_path": output_path}
+
+    # Ein Schalter, den DIESES HandBrake nicht kennt, ist ein Fehler in
+    # RIPPY — und er kommt mit Rueckgabewert 0 daher (siehe
+    # `unbekannter_schalter`). Deshalb steht die Pruefung VOR allen
+    # anderen: sonst landet der Fall unten bei „HandBrake endete mit Code
+    # 0", und dort ist er nicht zu erraten. Genau das kostete am
+    # 30.08.2026 einen fertigen 16,5-GB-Rip.
+    if falscher_schalter:
+        return {
+            "status": "error",
+            "error": (
+                'Rippy hat HandBrake den Schalter „%s" übergeben, den '
+                'diese HandBrake-Fassung nicht kennt. Das ist ein Fehler '
+                'in Rippy, keine Einstellung — bitte melden.' % falscher_schalter
+                + hb_schluss(letzte_zeilen)
+            ),
+            "return_code": process.returncode,
+        }
+
+    # Code 0, aber die Datei fehlt: HandBrake hat sie woanders hingeschrieben.
+    #
+    # Commander 29.08.2026: „Kompression fehlgeschlagen bei title_t00.mkv:
+    # HandBrake endete mit Code 0". Code 0 heisst ERFOLG — HandBrake meldet
+    # Fehler notorisch nicht ueber den Rueckgabewert. Der haeufigste Fall ist
+    # der Container: Er kommt aus dem PRESET, nicht aus der Endung. Ein
+    # MP4-Preset schreibt `title_t00.mp4` neben das verlangte `.mkv`.
+    #
+    # Verhindert wird das jetzt mit `--format` (siehe build_handbrake_cmd).
+    # Dieser Zweig bleibt trotzdem: Er FINDET die Datei, statt einen
+    # erfolgreichen Lauf wegzuwerfen — und sagt, was passiert ist.
+    if process.returncode == 0:
+        daneben = _datei_daneben(output_path)
+        if daneben:
+            return {"status": "success", "output_path": daneben,
+                    "hinweis": "HandBrake hat %s geschrieben statt %s "
+                               "(der Container kommt aus dem Preset)."
+                               % (os.path.basename(daneben),
+                                  os.path.basename(output_path))}
+        # Frueher stand hier geraten „Meist ist der Zielordner nicht
+        # beschreibbar". Am 30.08.2026 war das falsch (der Ordner war da
+        # und leer, der Grund ein falscher Schalter) — und die Vermutung
+        # schickte die Suche in die falsche Richtung. Jetzt wird der
+        # Ordner GENANNT und HandBrake selbst zitiert.
+        return {
+            "status": "error",
+            "error": ("HandBrake meldet Erfolg, aber es ist keine Datei "
+                      "entstanden (Zielordner: %s)."
+                      % os.path.dirname(output_path)
+                      + hb_schluss(letzte_zeilen)),
+            "return_code": 0,
+        }
     if falsches_preset:
         return {
             "status": "error",
@@ -671,7 +870,8 @@ def _handbrake_schleife(process, output_path: str, abbruch_cb=None, progress_cb=
         }
     return {
         "status": "error",
-        "error": f"HandBrake endete mit Code {process.returncode}",
+        "error": (f"HandBrake endete mit Code {process.returncode}"
+                  + hb_schluss(letzte_zeilen)),
         "return_code": process.returncode,
     }
 
@@ -709,6 +909,48 @@ def write_abcde_config(output_dir: str) -> str:
     return tmp.name
 
 
+def disc_fehlt(device_path: str, zustand=None) -> str:
+    """Liegt ueberhaupt eine Disc drin? Klartext-Grund oder "" (alles gut).
+
+    ## Warum vorher nachgesehen wird (Befund 29.08.2026)
+
+    Der Commander bekam:
+
+        makemkvcon endete mit Code 11 — letzte Meldung:
+        Das Öffnen der Disk schlug fehl  — keine MKV-Datei entstanden
+
+    Auffaellig war, was FEHLTE: kein „Ursache:". Waere der Geraetepfad schuld
+    gewesen, stuende dort MSG 2024. Bleibt: kein Datentraeger im Laufwerk.
+    Nach einem fertigen Rip wirft Rippy die Disc aus — ein zweiter Versuch
+    trifft dann ein leeres Laufwerk, laeuft zwei Minuten in makemkvcon hinein
+    und meldet einen Satz, aus dem niemand das schliessen kann.
+
+    Nachsehen kostet Millisekunden und erspart genau diesen Satz.
+
+    ⚠️ Ein FEHLGESCHLAGENER Blick ist kein Grund, den Rip zu verweigern. Wer
+    das Laufwerk gerade nicht lesen kann, weiss nicht, dass es leer ist — und
+    „ich weiss es nicht" darf nie zu „es geht nicht" werden.
+    """
+    if zustand is None:
+        try:
+            from rippy import drives as _schicht
+
+            zustand = _schicht.treiber().drive_status
+        except Exception:                            # noqa: BLE001
+            return ""
+    try:
+        stand = zustand(device_path)
+    except Exception:                                # noqa: BLE001
+        return ""
+    if stand == CDS_NO_DISC:
+        return ("Kein Datentraeger im Laufwerk %s. Nach einem fertigen Rip "
+                "wirft Rippy die Disc aus — fuer einen neuen Rip muss sie "
+                "wieder hinein." % device_path)
+    if stand == CDS_TRAY_OPEN:
+        return "Die Schublade von %s ist offen." % device_path
+    return ""
+
+
 def run_makemkv(device_path: str, output_dir: str, progress_cb=None, titel: str = "all",
                 log_cb=None) -> dict:
     """Rippt eine DVD/Blu-ray verlustfrei mit makemkvcon; meldet Fortschritt.
@@ -723,6 +965,10 @@ def run_makemkv(device_path: str, output_dir: str, progress_cb=None, titel: str
     if not check_makemkv_installed():
         return {"status": "error", "error": "makemkvcon ist nicht installiert"}
 
+    fehlt = disc_fehlt(device_path)
+    if fehlt:
+        return {"status": "error", "error": fehlt}
+
     os.makedirs(output_dir, exist_ok=True)
 
     try:
@@ -730,17 +976,39 @@ def run_makemkv(device_path: str, output_dir: str, progress_cb=None, titel: str
             build_makemkv_cmd(device_path, output_dir, titel),
             stdout=subprocess.PIPE,
             stderr=subprocess.STDOUT,
-            text=True,
-            bufsize=1,
+            # BINAER lesen und selbst dekodieren (siehe `text_von`):
+            # `text=True` nahm die Gebietsschema-Kodierung, makemkvcon
+            # schrieb aber UTF-8 — daraus wurde beim Commander
+            # „Das Öffnen der Disk schlug fehl".
+            #
+            # bufsize=0 statt 1: Zeilenpufferung gibt es im Binaermodus
+            # nicht (Python warnt und puffert doch). Ungepuffert kommt
+            # jede Fortschrittszeile sofort an — bei einem Rip, der
+            # Stunden laeuft, ist das der Unterschied zwischen einem
+            # Balken und einem eingefrorenen Fenster.
+            bufsize=0,
             creationflags=OHNE_FENSTER,
         )
 
         letzte_meldung = ""
+        # Lesefehler sind KEIN Abbruchgrund — MakeMKV ueberspringt den
+        # kaputten Titel und macht mit dem naechsten weiter. Genau deshalb
+        # muessen sie gesagt werden: Am 30.08.2026 endete ein Rip als
+        # „erfolgreich", obwohl von zwei Titeln nur einer ankam. Im
+        # Jobprotokoll stand „Rip fertig" — dass ein Titel fehlt, war nur
+        # den MakeMKV-Zeilen zu entnehmen, die niemand liest.
+        lesefehler = False
         # Kritische Meldungen einsammeln: die LETZTE Zeile ist fast immer nur
         # "Failed to open disc" — die URSACHE ("volume key is unknown", Key
         # abgelaufen) steht Zeilen davor und ging im Fehlertext verloren
         # (Befund 24.07., Summer-Wars-UHD).
         kritische_meldungen = []
+        # Die Textmuster bleiben als Rueckfall fuer englische Installationen —
+        # die MELDUNGSNUMMERN sind aber die verlaessliche Quelle. Beim
+        # Commander meldet MakeMKV deutsch, also traf hier am 29.08.2026 kein
+        # einziges Muster: Im Fehler stand nur „Das Öffnen der Disk schlug
+        # fehl", waehrend die Ursache eine Zeile darueber („Der Testzeitraum
+        # ist abgelaufen", MSG 5051) unter den Tisch fiel.
         KRITISCH = (
             "volume key is unknown",
             "evaluation period has expired",
@@ -748,7 +1016,8 @@ def run_makemkv(device_path: str, output_dir: str, progress_cb=None, titel: str
             "Too old version",
         )
         try:
-            for line in process.stdout:
+            for rohzeile in process.stdout:
+                line = text_von(rohzeile)
                 progress = get_progress_from_prgv(line)
                 if progress >= 0:
                     if progress_cb:
@@ -758,7 +1027,12 @@ def run_makemkv(device_path: str, output_dir: str, progress_cb=None, titel: str
                 if meldung is None:
                     continue
                 code, letzte_meldung = meldung
-                if any(muster in letzte_meldung for muster in KRITISCH):
+                if LESEFEHLER_MARKE in letzte_meldung:
+                    lesefehler = True
+                if code in KRITISCHE_CODES:
+                    kritische_meldungen.append(
+                        "%s (%s)" % (KRITISCHE_CODES[code], letzte_meldung.strip()))
+                elif any(muster in letzte_meldung for muster in KRITISCH):
                     kritische_meldungen.append(letzte_meldung)
                 if log_cb:
                     try:
@@ -786,9 +1060,11 @@ def run_makemkv(device_path: str, output_dir: str, progress_cb=None, titel: str
                 "output_dir": output_dir,
                 "files": mkv_dateien,
                 "return_code": process.returncode,
+                "lesefehler": lesefehler,
             }
         return {
             "status": "error",
+            "lesefehler": lesefehler,
             "error": (
                 f"makemkvcon endete mit Code {process.returncode}"
                 + (f" — Ursache: {'; '.join(kritische_meldungen)}" if kritische_meldungen else "")
@@ -841,7 +1117,11 @@ def rip_video(device_path: str, disc_id: str, disc_type: str = "dvd", progress_c
 def rip_cd(device_path: str, disc_id: str, progress_cb=None, output_dir: str = None,
            auswerfen: bool = True) -> dict:
     """Rippt eine CD mit abcde (FLAC). `auswerfen` = Einstellung „Automatischer
-    Auswurf" (abcde macht das selbst per -x)."""
+    Auswurf" (abcde macht das selbst per -x).
+
+    Der Windows-Weg (Roh-Sektoren + FLAC) ist mit der Standalone-App nach
+    Rippy v5 gewandert (KONZEPT-WINDOWS.md Entscheid 7, dort § 6.3) —
+    diese Fassung rippt CDs nur noch im Container, mit abcde."""
     if not check_abcde_installed():
         return {
             "status": "error",

docker/worker/schluessel.py

@@ -101,7 +101,14 @@ def makemkvcon_pfad() -> str:
     for pfad in fest:
         if os.path.isfile(pfad):
             return pfad
-    return shutil.which("makemkvcon64") or shutil.which("makemkvcon") or ""
+    # ⚠️ `shutil.which` sucht NUR im PATH (Befund 29.08.2026). Unter Windows
+    # liegt MakeMKV in „Programme" und steht dort nie — ausgerechnet in dem
+    # Modul, das es NUR unter Windows gibt. Die Schluessel-Automatik lief
+    # damit nie an. Der Werkzeug-Katalog kennt die echten Orte.
+    from rippy.tools import katalog
+
+    return (katalog.finden("makemkv")
+            or shutil.which("makemkvcon64") or shutil.which("makemkvcon") or "")
 
 
 def parse_laufwerke(ausgabe: str) -> list:

docker/worker/test_caps.py

@@ -214,3 +214,33 @@ def test_hardware_presets_stehen_auch_ohne_hardware_in_der_liste():
     assert caps.leite_backends_ab(caps.parse_encoder_liste(HB_HILFE_ECHT)) == [
         "cpu-x264", "cpu-x265", "cpu-av1",
     ]
+
+
+# ── „Extern" heisst: Rippy laeuft woanders (Befund 29.08.2026) ──────────
+#
+# Hier stand `os.path.isdir("/app")`. Im Image stimmt das. Auf einem
+# Windows-PC gibt es `/app` nicht — und damit hielt sich der eigenstaendige
+# Windows-Rippy fuer einen FREMDEN Worker. Folge: Das UI warnte vor fehlender
+# Pfad-Uebersetzung auf einer Maschine, auf der es weder Container noch
+# Freigabe gibt.
+
+
+def test_im_container_ist_nichts_extern():
+    from caps import _extern
+
+    assert _extern({}, container=True) == "nein"
+
+
+def test_die_eigenstaendige_windows_app_ist_NICHT_extern():
+    """Dieser Prozess IST Rippy — die Frage ist dort gegenstandslos."""
+    from caps import _extern
+
+    assert _extern({"profil": "standalone"}, container=False) == "nein"
+
+
+def test_ein_worker_bei_einem_docker_rippy_ist_extern():
+    """Der Fall, fuer den die Auskunft gemacht ist: Er braucht RIPPY_PATH_MAP."""
+    from caps import _extern
+
+    assert _extern({"profil": "node", "queue": {"treiber": "celery"}},
+                   container=False) == "ja"

docker/worker/test_erreichbarkeit.py

@@ -84,6 +84,11 @@ def _pruefen(monkeypatch, vorhandene, mapping, im_container=False):
     return tasks._erreichbarkeit_pruefen(
         "/app/media/rippy/job1", "\\\\NAS\\rippy\\job1",
         "/app/media/rippy/movies/Akira (1988)", "\\\\NAS\\rippy\\movies\\Akira (1988)",
+        # „Fremd" heisst: Rippy laeuft woanders als dieser Worker. Bis zum
+        # 29.08.2026 wurde das an der Existenz von `/app` festgemacht — damit
+        # hing dieser Test am laufenden Rechner, und unter Windows hielt sich
+        # der eigenstaendige Rippy fuer einen fremden Worker.
+        fremd=not im_container,
     )
 
 
@@ -124,6 +129,10 @@ def test_nicht_uebersetzter_pfad_beschuldigt_sehr_wohl_die_karte(monkeypatch):
     meldung = tasks._erreichbarkeit_pruefen(
         "/app/media/rippy/job1", "/app/media/rippy/job1",
         "/app/media/movies/X", "/app/media/movies/X",
+        # Ausdruecklich ein FREMDER Worker — nur den betrifft die Pfad-Karte.
+        # Vorher ergab sich das aus „es gibt kein /app", und genau daran hing
+        # der Test am laufenden Rechner (Befund 29.08.2026).
+        fremd=True,
     )
     assert "deckt diesen Pfad aber nicht ab" in meldung
     assert "von keinem Eintrag übersetzt" in meldung

docker/worker/test_medien.py

@@ -121,24 +121,33 @@ def test_pfad_lokal_uebersetzt_fuer_windows_worker():
 # Praxis scheiterte (st_dev war identisch, os.rename trotzdem EXDEV).
 
 
+# Die Wurzeln je Betrieb — eingespritzt, damit BEIDE Faelle ueberall pruefbar
+# sind. Vorher hingen diese Tests am laufenden Rechner: Unter Windows ist
+# `frei` wahr, und die Container-Regeln galten dort nicht mehr (am 29.08.2026
+# prompt rot geworden).
+CONTAINER = ("/app/media", "/app/temp/raw", False)
+NATIV = (r"C:\Users\Tobi\Videos\Rippy", r"C:\Users\Tobi\Videos\Rippy\_arbeit", True)
+
+
 def test_arbeitsverzeichnis_wahl_des_rips_schlaegt_die_einstellung():
     """Pro Rip wählbar (Commander 25.07.2026), Einstellung bleibt Standard.
 
-    Reihenfolge: Wahl dieses Rips -> Setting -> Container-Default. Der
+    Reihenfolge: Wahl dieses Rips -> Setting -> Vorgabe des Betriebs. Der
     Setting-Wert ist genau der, der bei Vollautomatik-Rips greift, weil dort
     niemand gefragt wird.
     """
     import ablauf as tasks
 
     einst = {"workDir": "/app/media/movies"}
-    assert tasks._arbeitsverzeichnis(einst, "/app/media/rippy") == "/app/media/rippy"
-    assert tasks._arbeitsverzeichnis(einst) == "/app/media/movies"
-    assert tasks._arbeitsverzeichnis({}) == tasks.RAW_DIR
+    w = CONTAINER
+    assert tasks._arbeitsverzeichnis(einst, "/app/media/rippy", w) == "/app/media/rippy"
+    assert tasks._arbeitsverzeichnis(einst, "", w) == "/app/media/movies"
+    assert tasks._arbeitsverzeichnis({}, "", w) == "/app/temp/raw"
     # Ausbruchsversuche und Pfade außerhalb /app/media fallen durch
-    assert tasks._arbeitsverzeichnis({}, "/etc") == tasks.RAW_DIR
-    assert tasks._arbeitsverzeichnis({}, "/app/media/../etc") == tasks.RAW_DIR
+    assert tasks._arbeitsverzeichnis({}, "/etc", w) == "/app/temp/raw"
+    assert tasks._arbeitsverzeichnis({}, "/app/media/../etc", w) == "/app/temp/raw"
     # Leere Wahl fällt sauber auf die Einstellung zurück
-    assert tasks._arbeitsverzeichnis(einst, "   ") == "/app/media/movies"
+    assert tasks._arbeitsverzeichnis(einst, "   ", w) == "/app/media/movies"
 
 
 def test_unter_wurzel_faellt_nicht_auf_praefix_namen_herein():
@@ -160,16 +169,67 @@ def test_unter_wurzel_faellt_nicht_auf_praefix_namen_herein():
 
 
 def test_zielbasis_lehnt_praefix_ausbruch_ab():
+    """Im CONTAINER bleibt die Wurzel eine Wurzel — daran ändert die
+    Windows-Reparatur nichts."""
     import ablauf as tasks
 
-    assert tasks._zielbasis("/app/media/movies", "bluray") == "/app/media/movies"
+    w = CONTAINER
+    assert tasks._zielbasis("/app/media/movies", "bluray", w) == "/app/media/movies"
     # Ausbruch per Praefix-Namen fällt auf den Standard zurück
-    assert tasks._zielbasis("/app/media-boese", "bluray") != "/app/media-boese"
-    assert tasks._zielbasis("/etc", "bluray") != "/etc"
+    assert tasks._zielbasis("/app/media-boese", "bluray", w) != "/app/media-boese"
+    assert tasks._zielbasis("/etc", "bluray", w) != "/etc"
 
 
 def test_arbeitsverzeichnis_lehnt_praefix_ausbruch_ab():
     import ablauf as tasks
 
-    assert tasks._arbeitsverzeichnis({}, "/app/media-boese") == tasks.RAW_DIR
-    assert tasks._arbeitsverzeichnis({"workDir": "/app/mediaX"}) == tasks.RAW_DIR
+    w = CONTAINER
+    assert tasks._arbeitsverzeichnis({}, "/app/media-boese", w) == "/app/temp/raw"
+    assert tasks._arbeitsverzeichnis({"workDir": "/app/mediaX"}, "", w) == "/app/temp/raw"
+
+
+# ── Nativ: der Befund vom 29.08.2026 ────────────────────────────────────
+#
+# Beim Nachstellen des leeren Bildschirms lief ein echter Test-Rip durch, und
+# die Rohdaten landeten in `F:\app\temp\raw` — einem Ordner namens `app` auf
+# dem Laufwerk, von dem Rippy gerade lief. Ursache: `RAW_DIR` ist
+# `/app/temp/raw`, und die Pruefung `unter_wurzel(wahl, "/app/media")` verwarf
+# sogar eine AUSDRUECKLICHE Wahl.
+#
+# Damit kam der Arbeitsordner, den der Commander am 28.08.2026 bestellt hat,
+# unter Windows nie an: Der Dialog zeigte ihn, das Setzen ging, der Worker
+# ignorierte ihn — ohne ein Wort.
+
+
+def test_nativ_zaehlt_die_wahl_des_nutzers():
+    """DER Befund. `D:\\Roh` liegt unter keiner Container-Wurzel und wurde
+    deshalb still verworfen."""
+    import ablauf as tasks
+
+    assert tasks._arbeitsverzeichnis({}, r"D:\Roh", NATIV) == r"D:\Roh"
+    assert tasks._arbeitsverzeichnis({"workDir": r"E:\Arbeit"}, "", NATIV) == r"E:\Arbeit"
+
+
+def test_nativ_faellt_auf_den_ort_aus_der_installation_zurueck():
+    """Nicht auf `/app/temp/raw` — das wurde unter Windows zu `X:\\app\\temp`."""
+    import ablauf as tasks
+
+    assert tasks._arbeitsverzeichnis({}, "", NATIV) == NATIV[1]
+    assert "/app/" not in tasks._arbeitsverzeichnis({}, "", NATIV)
+
+
+def test_nativ_nimmt_auch_eine_freigabe_als_ziel():
+    """Sein Ziel ist eine UNC-Freigabe — die liegt unter gar keiner lokalen
+    Wurzel."""
+    import ablauf as tasks
+
+    unc = r"\\192.168.179.62\rippy\movies"
+    assert tasks._zielbasis(unc, "bluray", NATIV) == unc
+
+
+def test_nativ_ohne_wahl_landet_unter_der_eigenen_ablage():
+    import ablauf as tasks
+
+    ziel = tasks._zielbasis("", "bluray", NATIV)
+    assert ziel.startswith(NATIV[0])
+    assert "/app/" not in ziel

docker/worker/test_ripping_helpers.py

@@ -13,7 +13,9 @@ from ripping import (
     build_makemkv_cmd,
     get_progress_from_line,
     get_progress_from_prgv,
+    hb_schluss,
     parse_msg,
+    unbekannter_schalter,
     write_abcde_config,
 )
 
@@ -49,10 +51,56 @@ def test_handbrake_cmd_arbeitet_auf_datei_nicht_geraet():
     assert cmd[cmd.index("--output") + 1] == "/app/media/bluray/x/t00.mkv"
     assert "--preset" in cmd
     assert "--first-audio" in cmd              # beste Spur pro Sprache behalten
-    assert "--audio-codec" in cmd
+    assert "--aencoder" in cmd
     assert "--all-subtitles" in cmd
 
 
+def test_handbrake_kennt_keinen_schalter_audio_codec():
+    """Der Schalter heißt `--aencoder`. `--audio-codec` gibt es nicht.
+
+    Befund 30.08.2026, am mitgelieferten HandBrakeCLI 1.11.2 gemessen:
+
+        unknown option (--audio-codec)
+        HandBrake has exited.        $? = 0
+
+    Rippy baute genau diesen Befehl. HandBrake stieg sofort aus und meldete
+    das mit Rückgabewert 0 als ERFOLG — ein fertiger 16,5-GB-Rip lief damit
+    ins Leere, ohne dass irgendwo ein Grund stand.
+
+    ⚠️ Bis dahin stand hier `assert "--audio-codec" in cmd`: ein Test, der
+    den Fehler festschrieb, statt ihn zu finden. Ein Kommandozeilen-Schalter
+    ist eine externe Schnittstelle (AGENTS Regel D) — er gehört am echten
+    Programm gemessen, nicht aus dem Gedächtnis behauptet.
+    """
+    cmd = build_handbrake_cmd("/tmp/a.mkv", "/tmp/b.mkv")
+    assert "--audio-codec" not in cmd
+    assert cmd[cmd.index("--aencoder") + 1] == "copy"
+
+
+def test_unbekannter_schalter_wird_erkannt():
+    """Wortlaut aus dem echten Lauf (30.08.2026, HandBrakeCLI 1.11.2)."""
+    assert unbekannter_schalter(
+        "unknown option (--audio-codec)") == "--audio-codec"
+    # Mit Zeitstempel davor — HandBrake stellt vielen Zeilen einen voran.
+    assert unbekannter_schalter(
+        "[13:30:54] unknown option (--gibt-es-nicht)") == "--gibt-es-nicht"
+    assert unbekannter_schalter("Encoding: task 1 of 1, 5.00 %") == ""
+    assert unbekannter_schalter("") == ""
+    assert unbekannter_schalter(None) == ""
+
+
+def test_hb_schluss_haengt_handbrakes_letzte_worte_an():
+    """Ohne sie stand im Fehlerfall nur der Rückgabewert da — und wenn der
+    0 ist, sagt er nichts (Befund 30.08.2026)."""
+    assert hb_schluss([]) == ""
+    assert hb_schluss(None) == ""
+    assert hb_schluss(["  ", "   "]) == ""
+    text = hb_schluss(["eins", "zwei", "drei", "vier", "fünf"])
+    assert "fünf" in text and "vier" in text
+    # Nur die letzten HB_ZEILEN_MELDUNG — sonst steht Muxer-Statistik im UI.
+    assert "eins" not in text
+
+
 def test_handbrake_progress_parsing():
     # Testfund 22.07.: echtes HandBrake schreibt 45.50 % MIT Leerzeichen
     assert get_progress_from_line("Encoding: task 1 of 1, 45.50 %") == 45
@@ -375,7 +423,13 @@ def test_falsches_preset_erklaert_den_fehlschlag_statt_nur_den_code():
     assert ergebnis["return_code"] == 3
 
 
-def test_fehler_ohne_preset_problem_bleibt_der_alte():
+def test_fehler_ohne_preset_problem_nennt_handbrakes_letzte_worte():
+    """Der Code allein reicht nicht — HandBrake selbst muss zu Wort kommen.
+
+    Bis zum 30.08.2026 stand hier nur „HandBrake endete mit Code N", und
+    jede Ausgabezeile wurde weggeworfen. Bei Code 0 (den HandBrake auch
+    für Fehler vergibt) blieb damit gar keine Auskunft übrig.
+    """
     import ripping
 
     class FakeProcess:
@@ -390,7 +444,43 @@ def test_fehler_ohne_preset_problem_bleibt_der_alte():
             return 1
 
     ergebnis = ripping._handbrake_schleife(FakeProcess(), "/gibt-es-nicht.mkv")
-    assert ergebnis["error"] == "HandBrake endete mit Code 1"
+    assert ergebnis["error"].startswith("HandBrake endete mit Code 1")
+    assert "irgendwas ganz anderes" in ergebnis["error"]
+    assert ergebnis["return_code"] == 1
+
+
+def test_unbekannter_schalter_schlaegt_den_nichtssagenden_code_null():
+    """Der Fall vom 30.08.2026, nachgestellt: HandBrake steigt an einem
+    Schalter aus, den es nicht kennt, und meldet das mit 0 als Erfolg.
+
+    Ohne diese Erkennung landete er unten bei „HandBrake meldet Erfolg,
+    aber es ist keine Datei entstanden" samt der falschen Vermutung
+    „Zielordner nicht beschreibbar" — und die schickte die Suche in die
+    vollkommen falsche Richtung.
+    """
+    import ripping
+
+    class FakeProcess:
+        def __init__(self):
+            self.stdout = iter([
+                "[13:30:54] hb_init: starting libhb thread\n",
+                "unknown option (--audio-codec)\n",
+                "HandBrake has exited.\n",
+            ])
+            self.returncode = 0
+
+        def kill(self):
+            pass
+
+        def wait(self):
+            return 0
+
+    ergebnis = ripping._handbrake_schleife(FakeProcess(), "/gibt-es-nicht.mkv")
+    assert ergebnis["status"] == "error"
+    assert "--audio-codec" in ergebnis["error"]
+    assert "Fehler in Rippy" in ergebnis["error"]
+    # ... und NICHT die alte Vermutung über den Zielordner
+    assert "beschreibbar" not in ergebnis["error"]
 
 
 # --- Sprachen der Disc: gemessen an der Akira-Blu-ray (26.07.2026) -----------
@@ -519,3 +609,70 @@ def test_handbrake_kommando_mit_sprachauswahl():
     assert cmd[cmd.index("--audio-lang-list") + 1] == "deu,jpn"
     assert cmd[cmd.index("--subtitle-lang-list") + 1] == "deu"
     assert "--first-audio" in cmd and "--all-subtitles" in cmd
+
+
+# ── Erst nachsehen, dann rippen (Befund 29.08.2026) ─────────────────────
+#
+# Commander: „makemkvcon endete mit Code 11 — letzte Meldung: Das Öffnen der
+# Disk schlug fehl  — keine MKV-Datei entstanden"
+#
+# Auffaellig war, was FEHLTE: kein „Ursache:". Waere der Geraetepfad schuld
+# gewesen, stuende dort MSG 2024. Bleibt: kein Datentraeger. Nach einem
+# fertigen Rip wirft Rippy die Disc aus — ein zweiter Versuch trifft dann ein
+# leeres Laufwerk, laeuft zwei Minuten in makemkvcon hinein und meldet einen
+# Satz, aus dem niemand das schliessen kann.
+
+
+def test_ein_leeres_laufwerk_wird_vorher_erkannt():
+    import ripping
+    from rippy.drives.linux import CDS_NO_DISC
+
+    grund = ripping.disc_fehlt("G:", zustand=lambda p: CDS_NO_DISC)
+    assert "Kein Datentraeger" in grund
+    assert "wirft Rippy die Disc aus" in grund, "der Grund muss erklaert sein"
+
+
+def test_offene_schublade_auch():
+    import ripping
+    from rippy.drives.linux import CDS_TRAY_OPEN
+
+    assert "Schublade" in ripping.disc_fehlt("G:", zustand=lambda p: CDS_TRAY_OPEN)
+
+
+def test_mit_disc_wird_nicht_gemeckert():
+    import ripping
+    from rippy.drives.linux import CDS_DISC_OK
+
+    assert ripping.disc_fehlt("G:", zustand=lambda p: CDS_DISC_OK) == ""
+
+
+def test_ein_fehlgeschlagener_blick_verweigert_den_rip_NICHT():
+    """„Ich weiss es nicht" darf nie zu „es geht nicht" werden. Wer das
+    Laufwerk gerade nicht lesen kann, weiss nicht, dass es leer ist."""
+    import ripping
+
+    def wirft(p):
+        raise OSError(5, "Zugriff verweigert")
+
+    assert ripping.disc_fehlt("G:", zustand=wirft) == ""
+
+
+def test_run_makemkv_sieht_vorher_nach():
+    """Waechter: Die Pruefung muss VOR dem Prozessstart stehen, sonst laeuft
+    man weiterhin zwei Minuten ins Leere."""
+    import inspect
+
+    import ripping
+
+    quelle = inspect.getsource(ripping.run_makemkv)
+    vor_popen = quelle.index("subprocess.Popen")
+    assert "disc_fehlt(" in quelle[:vor_popen], \
+        "die Disc-Pruefung gehoert vor den makemkvcon-Start"
+
+
+def test_die_sammelmeldung_5010_wird_erklaert():
+    """5010 ist MakeMKVs „ging nicht" und sagt fuer sich nichts."""
+    from rippy.rip.makemkv_aufruf import KRITISCHE_CODES
+
+    assert 5010 in KRITISCHE_CODES
+    assert "Disc" in KRITISCHE_CODES[5010]

packaging/windows/build.py

@@ -1,202 +0,0 @@
-"""Baut RippySetup.exe — eine Datei, die installiert, laeuft und sich entfernt.
-
-## Aufruf
-
-    python packaging/windows/build.py [--ausgabe ORDNER] [--version 2.0.0]
-
-Voraussetzungen (in der Bau-Umgebung, nicht beim Nutzer):
-  * Python 3.12 mit den API-Abhaengigkeiten (docker/api/requirements.txt)
-  * pyinstaller, pystray, pillow
-  * Das UI muss gebaut sein: cd docker/ui && npm run build
-
-## Warum die Versions-Ressource nicht optional ist
-
-Ohne sie steht im Taskmanager unter „Beschreibung" nichts, und in den
-Datei-Eigenschaften fehlt jede Angabe zu Herausgeber und Version. Eine EXE
-ohne diese Angaben sieht aus wie etwas, das man nicht ausfuehren sollte —
-und Windows SmartScreen sieht das genauso.
-
-Der Commander hat ausdruecklich einen Eintrag im Taskmanager gewuenscht.
-Der Prozessname kommt vom Dateinamen (`Rippy.exe`), die BESCHREIBUNG
-daneben aus dieser Ressource.
-
-## Was mit hinein muss
-
-    docker/api/           die API-Module (main.py und Nachbarn)
-    docker/ui/dist/       die gebaute Weboberflaeche
-    src/rippy/            der Kern (kommt ueber den Import automatisch mit)
-    rippy.ico             Symbol fuer Tray, Verknuepfung und Programmliste
-
-`docker/api` liegt im Paket unter `api/`, `docker/ui/dist` unter `ui/` —
-genau dort sucht `rippy/daemon.py` sie, wenn `sys._MEIPASS` gesetzt ist.
-"""
-
-import argparse
-import os
-import shutil
-import subprocess
-import sys
-
-HIER = os.path.dirname(os.path.abspath(__file__))
-REPO = os.path.dirname(os.path.dirname(HIER))
-
-VERSION_VORLAGE = """
-VSVersionInfo(
-  ffi=FixedFileInfo(
-    filevers=({v0}, {v1}, {v2}, 0),
-    prodvers=({v0}, {v1}, {v2}, 0),
-    mask=0x3f, flags=0x0, OS=0x40004, fileType=0x1, subtype=0x0,
-    date=(0, 0)
-  ),
-  kids=[
-    StringFileInfo([
-      StringTable(u'040704b0', [
-        StringStruct(u'CompanyName', u'Rippy'),
-        StringStruct(u'FileDescription', u'Rippy — automatisches Ripping'),
-        StringStruct(u'FileVersion', u'{version}'),
-        StringStruct(u'InternalName', u'Rippy'),
-        StringStruct(u'OriginalFilename', u'Rippy.exe'),
-        StringStruct(u'ProductName', u'Rippy'),
-        StringStruct(u'ProductVersion', u'{version}')])
-    ]),
-    # 0x0407 = Deutsch, 0x04b0 = Unicode. Ohne den passenden Eintrag zeigt
-    # Windows die Angaben je nach Systemsprache gar nicht an.
-    VarFileInfo([VarStruct(u'Translation', [1031, 1200])])
-  ]
-)
-"""
-
-
-def versionsdatei(version: str, ordner: str) -> str:
-    teile = (version.split("-")[0].split(".") + ["0", "0", "0"])[:3]
-    pfad = os.path.join(ordner, "version_info.txt")
-    with open(pfad, "w", encoding="utf-8") as f:
-        f.write(VERSION_VORLAGE.format(
-            version=version, v0=int(teile[0]), v1=int(teile[1]), v2=int(teile[2])))
-    return pfad
-
-
-def pruefen() -> list:
-    """Alles da? Erst pruefen, dann bauen — wie install.sh es macht.
-
-    Ein Bau, der auf halber Strecke abbricht, hinterlaesst eine EXE, die
-    aussieht wie fertig und es nicht ist.
-    """
-    maengel = []
-    if sys.platform != "win32":
-        maengel.append("Eine Windows-.exe laesst sich nur unter Windows bauen.")
-    if not os.path.isfile(os.path.join(REPO, "docker", "api", "main.py")):
-        maengel.append("docker/api/main.py fehlt.")
-    if not os.path.isfile(os.path.join(REPO, "docker", "worker", "ablauf.py")):
-        maengel.append("docker/worker/ablauf.py fehlt — ohne den Ablauf kann "
-                       "die App nicht rippen.")
-    if not os.path.isdir(os.path.join(REPO, "docker", "ui", "dist")):
-        maengel.append(
-            "docker/ui/dist fehlt — die Oberflaeche ist nicht gebaut. "
-            "Abhilfe: cd docker/ui && npm ci && npm run build")
-    if not os.path.isfile(os.path.join(REPO, "deploy", "worker-windows", "rippy.ico")):
-        maengel.append("deploy/worker-windows/rippy.ico fehlt.")
-    try:
-        import PyInstaller  # noqa: F401
-    except ImportError:
-        maengel.append("pyinstaller fehlt (pip install pyinstaller).")
-    for modul, paket in (("pystray", "pystray"), ("PIL", "pillow")):
-        try:
-            __import__(modul)
-        except ImportError:
-            maengel.append(f"{modul} fehlt (pip install {paket}) — ohne das kein Tray-Symbol.")
-    return maengel
-
-
-def bauen(ausgabe: str, version: str) -> str:
-    arbeit = os.path.join(ausgabe, "_bau")
-    os.makedirs(arbeit, exist_ok=True)
-
-    trenner = ";"          # Windows-Trennzeichen fuer --add-data
-    befehl = [
-        sys.executable, "-m", "PyInstaller",
-        "--noconfirm", "--clean",
-        "--onefile",
-        # --windowed waere schoener (kein Konsolenfenster), macht aber jede
-        # Ausgabe unsichtbar — auch Fehlermeldungen beim Installieren. Der
-        # Installer laeuft deshalb MIT Konsole; der Dienst startet spaeter
-        # ohne Fenster (CREATE_NO_WINDOW in winlauf.py).
-        "--console",
-        "--name", "RippySetup",
-        "--icon", os.path.join(REPO, "deploy", "worker-windows", "rippy.ico"),
-        "--version-file", versionsdatei(version, arbeit),
-        "--distpath", ausgabe,
-        "--workpath", os.path.join(arbeit, "work"),
-        "--specpath", arbeit,
-        "--paths", os.path.join(REPO, "src"),
-        "--paths", os.path.join(REPO, "docker", "api"),
-        "--paths", os.path.join(REPO, "docker", "worker"),
-        "--add-data", os.path.join(REPO, "docker", "api") + trenner + "api",
-        # Die Worker-Module — ohne sie kann Rippy anzeigen, aber nicht rippen.
-        # ablauf.py, ripping.py, medien.py, caps.py und Nachbarn.
-        "--add-data", os.path.join(REPO, "docker", "worker") + trenner + "worker",
-        "--add-data", os.path.join(REPO, "docker", "ui", "dist") + trenner + "ui",
-        "--add-data", os.path.join(REPO, "deploy", "worker-windows", "rippy.ico") + trenner + ".",
-        # Was PyInstaller nicht von allein findet: dynamisch importierte Module.
-        "--hidden-import", "uvicorn.logging",
-        "--hidden-import", "uvicorn.loops.auto",
-        "--hidden-import", "uvicorn.protocols.http.auto",
-        "--hidden-import", "uvicorn.protocols.websockets.auto",
-        "--hidden-import", "uvicorn.lifespan.on",
-        "--hidden-import", "rippy.drives.windows",
-        "--hidden-import", "pystray._win32",
-        # Nicht mitnehmen: Der Windows-Treiber braucht kein psycopg2/celery,
-        # und beides zieht Ballast nach.
-        "--exclude-module", "psycopg2",
-        "--exclude-module", "tkinter",
-        os.path.join(REPO, "packaging", "windows", "einstieg.py"),
-    ]
-
-    print("PyInstaller wird aufgerufen …\n")
-    ergebnis = subprocess.run(befehl, cwd=REPO)
-    if ergebnis.returncode != 0:
-        raise SystemExit("PyInstaller ist gescheitert (Code %d)." % ergebnis.returncode)
-
-    exe = os.path.join(ausgabe, "RippySetup.exe")
-    if not os.path.isfile(exe):
-        raise SystemExit("PyInstaller meldete Erfolg, aber %s gibt es nicht." % exe)
-    return exe
-
-
-def main(argv=None) -> int:
-    p = argparse.ArgumentParser(description="Baut RippySetup.exe")
-    p.add_argument("--ausgabe", default=os.path.join(REPO, "dist", "windows"))
-    p.add_argument("--version", default=os.environ.get("RIPPY_VERSION", "2.0.0"))
-    p.add_argument("--nur-pruefen", action="store_true")
-    args = p.parse_args(argv)
-
-    print("Rippy — Windows-Bau")
-    print("  Repo      %s" % REPO)
-    print("  Ausgabe   %s" % args.ausgabe)
-    print("  Version   %s" % args.version)
-    print()
-
-    maengel = pruefen()
-    if maengel:
-        print("Der Bau kann so nicht laufen:")
-        for m in maengel:
-            print("  X  %s" % m)
-        return 1
-    print("Alle Voraussetzungen erfuellt.")
-    if args.nur_pruefen:
-        return 0
-
-    os.makedirs(args.ausgabe, exist_ok=True)
-    exe = bauen(args.ausgabe, args.version)
-
-    groesse = os.path.getsize(exe) / 1024**2
-    print()
-    print("Fertig:  %s  (%.1f MB)" % (exe, groesse))
-
-    arbeit = os.path.join(args.ausgabe, "_bau")
-    shutil.rmtree(arbeit, ignore_errors=True)
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

packaging/windows/einstieg.py

@@ -1,24 +0,0 @@
-"""Einstiegspunkt der gebuendelten RippySetup.exe.
-
-Bewusst winzig: PyInstaller braucht EINE Datei als Startpunkt, und alles
-Weitere gehoert ins Paket `rippy`, wo es getestet werden kann. Was hier
-steht, laesst sich nicht testen — also steht hier so wenig wie moeglich.
-"""
-
-import multiprocessing
-import sys
-
-
-def main() -> int:
-    # Pflicht in gebuendelten Programmen: Ohne diesen Aufruf startet ein
-    # Kindprozess unter Windows die ganze EXE erneut — eine Startschleife,
-    # die sich als "das Programm oeffnet sich immer wieder" zeigt.
-    multiprocessing.freeze_support()
-
-    from rippy.windows_app import main as rippy_main
-
-    return rippy_main()
-
-
-if __name__ == "__main__":
-    sys.exit(main())

src/rippy/betrieb.py

@@ -0,0 +1,305 @@
+"""In welchem Betrieb läuft Rippy — und was kann dieser Betrieb überhaupt?
+
+## Der Befund des Commanders (28.08.2026)
+
+Im Windows-Fenster stand auf der Server-Status-Kachel:
+
+    Worker erreichbar:   0 von 1
+    Kein Worker antwortet — ohne ihn läuft kein Rip. Prüfen: docker compose ps
+    Container-Platte:    unbekannt
+    Freigaben:           keine eingehängt
+
+Kein einziger dieser Sätze ergibt auf einem Windows-PC einen Sinn. Es gibt
+keinen Container, kein `docker compose`, keinen zweiten Worker — Rippy rippt
+dort selbst. Sein Urteil:
+
+> „Du hast ja quasi nur rippy genommen und die docker installation für Windows
+> gebaut. Das macht ja aber keinen sinn da auf Windows andere dinge relevant
+> sind als für den Windows Client. Das gilt für die ganze standalone version
+> für Windows, auch für die settings und die Anleitung usw."
+
+## Warum das kein Anzeigefehler ist
+
+Die naheliegende Reparatur wäre, an dreißig Stellen `if (windows)` einzubauen.
+Das wäre dieselbe Falle noch einmal: Die Oberfläche wüsste weiterhin nichts
+über ihren Betrieb, sie hätte nur eine zweite Sorte Vermutung.
+
+Die Ursache liegt tiefer: **Die Oberfläche hat nie erfahren, worauf sie
+läuft.** `config.py` kennt das Profil seit V2-2, die API hat es nie
+weitergegeben. Also hat das UI angenommen — und Annahmen sind in diesem
+Projekt schon oft genug teuer geworden.
+
+## Warum FÄHIGKEITEN und nicht ein Modus-Name
+
+Ein `modus == "standalone"` würde die Oberfläche zwingen, aus einem Namen auf
+Verhalten zu schließen — genau die Sorte Ableitung, die bei jedem neuen
+Betriebsfall bricht. Der Kopflos-Betrieb (V2-6) hat keinen Container, aber
+sehr wohl externe Worker; ein Docker-All-in-One hat einen Container, aber
+keinen zweiten Worker.
+
+Deshalb sagt Rippy, **was geht**, nicht **wie es heißt**:
+
+    externe_worker        Gibt es andere Maschinen, die Jobs übernehmen?
+    freigaben_einhaengen  Kann Rippy Netzwerk-Freigaben selbst einhängen?
+    container_pfade       Sind Pfade wie /app/media überhaupt gemeint?
+    werkzeuge_verwalten   Kann Rippy MakeMKV/HandBrake selbst beschaffen?
+
+Der Modus-Name bleibt trotzdem dabei — für Fehlerberichte und Überschriften.
+Aber gerechnet wird mit den Fähigkeiten.
+
+## Was hier GEMESSEN und was gelesen wird
+
+Wo es geht, wird nachgesehen statt geglaubt:
+
+    im_container   `/.dockerenv` existiert (Docker legt sie an)
+    plattform      `sys.platform`
+    externe_worker Queue-Treiber `celery` (ohne Broker gibt es keine)
+
+`profil` aus der Konfiguration ist der Rückfall, nicht die erste Quelle.
+"""
+
+import os
+import sys
+
+from rippy import pfade
+
+# Docker legt diese Datei in jedem Container an. Sie ist das verlässlichste
+# Kennzeichen, das ohne Zusatzpakete zu haben ist — verlässlicher als eine
+# Umgebungsvariable, die jeder setzen (und vergessen) kann.
+DOCKER_KENNZEICHEN = "/.dockerenv"
+
+
+def im_container(pruefen=None) -> bool:
+    """Läuft dieser Prozess in einem Container? (gemessen, nicht geraten)"""
+    pruefen = pruefen or os.path.exists
+    return bool(pruefen(DOCKER_KENNZEICHEN))
+
+
+def plattform(name: str = None) -> str:
+    """`windows`, `linux` oder `macos` — nie der rohe sys.platform-String."""
+    roh = (name if name is not None else sys.platform).lower()
+    if roh.startswith("win"):
+        return "windows"
+    if roh == "darwin":
+        return "macos"
+    return "linux"
+
+
+def modus(werte: dict, container: bool = None) -> str:
+    """Der Name des Betriebs — für Überschriften und Fehlerberichte.
+
+    `standalone`  Ein Prozess macht alles (Windows-App, Docker-All-in-One)
+    `verteilt`    Mehrere Maschinen teilen sich die Arbeit (Celery/Redis)
+    """
+    queue = (werte or {}).get("queue", {}) or {}
+    if queue.get("treiber") == "celery":
+        return "verteilt"
+    profil = (werte or {}).get("profil", "standalone")
+    return "verteilt" if profil in ("api", "node") else "standalone"
+
+
+def auskunft(werte: dict, container: bool = None,
+             plattform_name: str = None) -> dict:
+    """Was ist dieser Betrieb, und was kann er? — die Antwort für die API.
+
+    Reine Funktion: `container` und `plattform_name` sind einspritzbar, damit
+    jeder Betriebsfall prüfbar ist, ohne ihn herzustellen.
+    """
+    werte = werte or {}
+    container = im_container() if container is None else container
+    system = plattform(plattform_name)
+    art = modus(werte, container)
+    verteilt = art == "verteilt"
+
+    return {
+        "modus": art,
+        "plattform": system,
+        "im_container": container,
+        "kann": {
+            # Ohne Celery gibt es niemanden, der von außen Jobs übernimmt.
+            # Die Worker-Liste, das Worker-Setup und jede Rede von
+            # „Kein Worker antwortet" gehören dann nicht auf den Bildschirm.
+            "externe_worker": verteilt,
+            # Einhängen macht seit dem Entscheid vom 28.08.2026 der HOST
+            # (KONZEPT-V2.md § 4.3) — im Container zeigt Rippy nur noch die
+            # Zeile zum Kopieren. Unter Windows hängt man gar nichts ein:
+            # Dort gibt man einen UNC-Pfad an, fertig.
+            "freigaben_einhaengen": container,
+            # `/app/media` ist ein Pfad IM Container. Auf Windows heißt der
+            # Ordner anders und liegt woanders.
+            "container_pfade": container,
+            # Im Image steckt alles fest; ein Update ist ein Rebuild. Nur die
+            # native Installation kann ihre Werkzeuge selbst pflegen.
+            "werkzeuge_verwalten": not container,
+            # Darf die Oberfläche außerhalb der Medien-Wurzel blättern?
+            "frei_blaettern": frei_blaettern(werte, container),
+        },
+        # Was in der Oberfläche als Vorgabe stehen soll. Ein Feld, das mit
+        # `/app/media` vorbelegt ist, ist auf Windows schlicht falsch.
+        "ablage_vorgabe": ablage_vorgabe(werte, container, system),
+        "arbeits_vorgabe": arbeits_vorgabe(werte, container, system),
+        "hilfe_befehl": "docker compose -p rippy ps" if container else "",
+    }
+
+
+def frei_blaettern(werte: dict, container: bool = None) -> bool:
+    """Darf die Oberfläche das ganze Dateisystem sehen? (Befund 28.08.2026)
+
+    ## Warum diese Frage überhaupt gestellt werden muss
+
+    `MEDIA_ROOT = "/app/media"` war in `main.py` zugleich Vorgabe UND
+    Pfadgrenze: `/browse`, `/storage-targets` und jede Datei-Auslieferung
+    prüften `unter_wurzel(pfad, MEDIA_ROOT)`.
+
+    Im Container ist das genau richtig. Die API hängt dort im Netz, und eine
+    Weboberfläche, die jeden Pfad des Wirts ausliefern kann, ist ein Loch.
+
+    Auf dem Windows-PC des Commanders war dieselbe Zeile gleich doppelt
+    falsch: Den Ordner `/app/media` gibt es nicht (also war die Liste der
+    Arbeitsverzeichnisse LEER — sein Befund „momentan geht das nicht"), und
+    sein Ziel ist eine UNC-Freigabe, die unter gar keiner lokalen Wurzel
+    liegt.
+
+    Die Unterscheidung ist nicht „Windows" — sie ist **wer hört zu**. Ein
+    Container und der Kopflos-Betrieb bedienen ein Netz; die native App
+    bedient den Menschen, der vor dem Rechner sitzt und dessen eigene Ordner
+    das sind. Deshalb: kein Container UND kein verteilter Betrieb.
+    """
+    container = im_container() if container is None else container
+    return not container and modus(werte, container) == "standalone"
+
+
+def medien_wurzel(werte: dict, container: bool = None,
+                  plattform_name: str = None) -> str:
+    """Die Wurzel, unter der Rippy ablegt — im Container `/app/media`.
+
+    Eigener Name statt `ablage_vorgabe`, weil die Rolle eine andere ist: Die
+    Vorgabe füllt ein Eingabefeld, die Wurzel begrenzt Pfade. Dass beide
+    denselben Ort meinen, ist Absicht und kein Zufall.
+    """
+    return ablage_vorgabe(werte, im_container() if container is None else container,
+                          plattform(plattform_name))
+
+
+def arbeits_vorgabe(werte: dict, container: bool = None,
+                    plattform_name: str = None) -> str:
+    """Wohin die Rohdaten wandern, wenn niemand etwas anderes wählt.
+
+    Der Roh-Rip einer 4K-UHD ist bis zu 100 GB groß. Wo der landet, ist keine
+    Nebensache — am 25.07.2026 lief damit die Container-Platte voll.
+    """
+    werte = werte or {}
+    container = im_container() if container is None else container
+    system = plattform(plattform_name)
+    eigen = (werte.get("storage", {}) or {}).get("temp")
+    if eigen:
+        return eigen
+    if container:
+        return "/app/temp"
+    return pfade.verbinden(ablage_vorgabe(werte, container, system), "_arbeit")
+
+
+def naechster_vorhandener(pfad: str, existiert=None) -> str:
+    """Der naechste vorhandene Ordner nach oben — siehe `rippy.pfade`."""
+    return pfade.naechster_vorhandener(pfad, existiert)
+
+
+def platz_orte(werte: dict, container: bool = None,
+               plattform_name: str = None) -> list:
+    """Wo Platz gemessen werden soll — je Betrieb andere Orte.
+
+    ## Warum das nicht fest verdrahtet sein darf (28.08.2026)
+
+    In `main.py` stand:
+
+        for name, pfad in (("Media (/app/media)", MEDIA_ROOT),
+                           ("Arbeitsverzeichnis (/app/temp)", "/app/temp")):
+
+    Beide Pfade gibt es unter Windows nicht. `shutil.disk_usage` warf, die
+    Liste blieb leer, und im Windows-Fenster stand **„Platz für Rippy:
+    unbekannt"** — obwohl auf dem Laufwerk natürlich Platz war. Eine
+    Nichtauskunft, die wie eine Auskunft aussieht.
+
+    Gibt eine Liste von `{"name": …, "pfad": …}` zurück; der Aufrufer misst.
+    """
+    werte = werte or {}
+    container = im_container() if container is None else container
+    system = plattform(plattform_name)
+
+    if container:
+        return [{"name": "Media (/app/media)", "pfad": "/app/media"},
+                {"name": "Arbeitsverzeichnis (/app/temp)", "pfad": "/app/temp"}]
+
+    ablage = ablage_vorgabe(werte, container, system)
+    temp = arbeits_vorgabe(werte, container, system)
+    orte = [{"name": "Ablage", "pfad": ablage}]
+    # ## Warum beide Orte IMMER dastehen (Commander 29.08.2026)
+    #
+    # > „bei ‚Platz für rippy' sollte eher das arbeitsverzeichnis und der
+    # > Ablagepfad sein."
+    #
+    # Hier stand vorher: zweite Zeile nur, wenn es ein ANDERES Laufwerk ist —
+    # mit der Begründung, zweimal dieselbe Zahl unter zwei Namen sehe aus wie
+    # zwei Auskünfte und sei eine. Das stimmt für die ZAHL und war der falsche
+    # Schluss für den ORT: Auf seinem Bildschirm stand nur „Platz für Rippy:
+    # 59,9 von 232 GB frei" — welche Ordner das sind, war nicht zu sehen.
+    #
+    # Beides gehört hin, und beides mit Pfad. Dass die Zahl dieselbe ist,
+    # steht jetzt ausdrücklich dabei (`gleiches_laufwerk`), statt die Zeile
+    # wegzulassen.
+    gleich = pfade.gleiches_laufwerk(temp, ablage)
+    orte.append({"name": "Arbeitsverzeichnis", "pfad": temp,
+                 "gleiches_laufwerk": gleich})
+    orte[0]["gleiches_laufwerk"] = gleich
+    return orte
+
+
+def mit_einstellungen(werte: dict, einstellungen: dict) -> dict:
+    r"""Die in der Oberflaeche gesetzten Orte in die Betriebs-Werte legen.
+
+    ## Warum es diese Bruecke braucht (Befund 30.08.2026)
+
+    Der Commander: „die verzeichnise sind andere als dort steht."
+
+    Rippy hat ZWEI Speicher fuer dieselbe Frage:
+
+        Oberflaeche  ->  Datenbank, Schluessel `outputDir` und `workDir`
+        Betrieb      ->  Konfigurationsdatei, `storage.medien` / `storage.temp`
+
+    Geschrieben wird nur der erste — die Einstellungsseite kennt die
+    Konfigurationsdatei gar nicht. `ablage_vorgabe` und `arbeits_vorgabe`
+    lesen aber den zweiten, und der ist leer. Sie fielen deshalb IMMER auf
+    die Vorgabe zurueck: In „Einstellungen -> System" standen dauerhaft
+    `…\Videos\Rippy` und `…\Videos\Rippy\_arbeit`, egal was
+    eingestellt war — waehrend der Rip in Wahrheit nach `F:\` lief.
+
+    Der Worker macht es richtig herum: `_arbeitsverzeichnis()` liest
+    `workDir` aus der Datenbank und faellt erst DANN auf die Vorgabe
+    zurueck. Diese Funktion stellt dieselbe Reihenfolge fuer alle her, die
+    ueber `betrieb` fragen — statt sie ein drittes Mal nachzubauen.
+
+    Pure Funktion: Sie nimmt beide Woerterbuecher und gibt ein neues zurueck.
+    """
+    lager = dict(((werte or {}).get("storage") or {}))
+    ablage = ((einstellungen or {}).get("outputDir") or "").strip()
+    arbeit = ((einstellungen or {}).get("workDir") or "").strip()
+    if ablage:
+        lager["medien"] = ablage
+    if arbeit:
+        lager["temp"] = arbeit
+    zusammen = dict(werte or {})
+    zusammen["storage"] = lager
+    return zusammen
+
+
+def ablage_vorgabe(werte: dict, container: bool, system: str) -> str:
+    """Wohin Rippy standardmäßig ablegt — je Betrieb ein anderer Ort."""
+    eigen = ((werte or {}).get("storage", {}) or {}).get("medien", "")
+    if eigen:
+        return eigen
+    if container:
+        return "/app/media"
+    # Der Windows-Sonderzweig ist mit der Standalone-App gegangen (v5 ist
+    # ein eigenes Produkt, KONZEPT-WINDOWS.md Entscheid 7) — nativ heisst
+    # hier nur noch: ein Entwickler-Lauf ausserhalb des Containers.
+    return os.path.join(os.path.expanduser("~"), "Videos", "Rippy")

src/rippy/bus/test_waechter.py

@@ -6,7 +6,7 @@ genau die Eigenschaft, die dem ersten Anlauf der SSE-Tests gefehlt hat
 (Ampel-Lauf 170 lief rot, weil ein Test eine Datenbank brauchte).
 """
 
-from rippy.bus.waechter import Waechter, laufwerks_unterschiede, unterschiede
+from rippy.bus.waechter import UI_PFLICHTFELDER, _job_kurz, Waechter, laufwerks_unterschiede, unterschiede
 
 
 class FakeBus:
@@ -218,6 +218,50 @@ def test_haengendes_laufwerk_haelt_den_waechter_nicht_an():
     assert bus.typen == ["job.progress"]
 
 
+class FrischGestartet:
+    """Eine Uhr, die gerade erst angefangen hat zu zählen.
+
+    `time.monotonic()` zählt ab einem beliebigen Nullpunkt — unter Linux ab
+    dem Start der Maschine. Auf einem Rechner, der seit Wochen läuft, ist der
+    Wert riesig; auf einem frisch gestarteten (oder in einem Container) ist er
+    klein. Genau dieser Unterschied hat die Ampel rot gemacht.
+    """
+
+    def __init__(self, wert=0.5):
+        self.wert = wert
+
+    def monotonic(self):
+        return self.wert
+
+
+def test_erste_abfrage_faellt_nicht_aus_wenn_die_uhr_bei_null_steht(monkeypatch):
+    """DER Fehler aus den Ampel-Läufen 181–184 (28.08.2026).
+
+    `_laufwerke_geprueft` stand auf `0.0` und sollte „noch nie geprüft"
+    heißen. Verglichen wurde es aber mit `time.monotonic()`. Auf einer frisch
+    gestarteten Maschine ist `jetzt - 0.0` KLEIN — also sah der Wächter aus,
+    als hätte er die Laufwerke gerade eben schon gelesen, und die erste
+    Abfrage fiel ersatzlos aus.
+
+    Unter Windows fiel das nie auf, weil der Zähler dort schon beim ersten
+    Start groß ist. Dieser Test stellt den kleinen Zähler nach und läuft
+    deshalb auf JEDER Plattform.
+    """
+    from rippy.bus import waechter as modul
+
+    monkeypatch.setattr(modul, "time", FrischGestartet(0.5))
+
+    aufrufe = []
+    w = Waechter(FakeStore(), FakeBus(),
+                 laufwerke_lesen=lambda: aufrufe.append(1) or [_lw("/dev/sr0")],
+                 laufwerks_takt=999)
+    w.einmal()
+    assert len(aufrufe) == 1, (
+        "Die erste Laufwerks-Abfrage ist ausgefallen: 0.0 wurde als Zeitpunkt "
+        "gelesen statt als 'noch nie geprueft'."
+    )
+
+
 def test_laufwerke_werden_seltener_abgefragt_als_jobs():
     """Ein ioctl kostet mehr als ein SELECT. Ohne den eigenen Takt liefe
     jede Sekunde eine Laufwerksabfrage — auf einem klemmenden Laufwerk waere
@@ -233,3 +277,94 @@ def test_laufwerke_werden_seltener_abgefragt_als_jobs():
     w.einmal()
     w.einmal()
     assert len(aufrufe) == 1, "Laufwerke wurden mehrfach im selben Takt gelesen"
+
+
+# ── Der Vertrag mit der Oberflaeche (Befund 29.08.2026) ─────────────────
+#
+# Commander: „wenn man auf rippen starten klickt passiert irgendwas, was das
+# Programm nicht mag. Der Hintergrund ist einfach leer und er startet nix. Es
+# gibt auch keine fehlermeldung."
+#
+# Nachgestellt und in der Browser-Konsole gemessen:
+#
+#     TypeError: Cannot read properties of undefined (reading 'toUpperCase')
+#
+# Der Job lief in Wahrheit (gemessen: processing, 12 %). Aber `job.created`
+# trug keinen `type`; das UI fuegte einen halben Job ein, las
+# `job.type.toUpperCase()` — und weil es keine Fehlergrenze gab, riss der
+# Fehler die GANZE Oberflaeche mit.
+#
+# ⚠️ Warum es niemand gefunden hat: `unterschiede()` bekommt die Kurzform
+# schon fertig, die Tests oben reichen ihre eigenen Woerterbuecher herein.
+# **`_job_kurz` selbst war nie geprueft.** Diese Tests schliessen die Luecke.
+
+
+
+def _db_zeile():
+    """Eine Job-Zeile, NACHDEM `job_form` sie umgewandelt hat.
+
+    ⚠️ Hier stand dieselbe Zeile mit denselben Feldnamen — nur habe ich sie
+    mir ausgedacht. Die echte Datenbankzeile heisst `disc_type` und
+    `created_at`, nicht `type` und `startTime`. Der Test hat meine Annahme
+    also bestaetigt statt sie zu pruefen, und beim Commander stand danach
+    „1.1.1970" in der Jobliste.
+
+    Der Waechter bekommt seit dem 29.08.2026 die UMGEWANDELTE Zeile — die
+    Umwandlung selbst prueft `test_api_smoke.py`, wo sie wohnt.
+    """
+    return {"id": "j1", "type": "bluray", "device": r"\\.\G:",
+            "startTime": "2026-08-29T12:07:02", "endTime": None,
+            "status": "processing", "progress": 12, "title": "Evangelion 2.22",
+            "error": None, "meta": {"confidence": 0.3}}
+
+
+def test_ohne_umwandlung_kommt_die_rohe_zeile_NICHT_durch():
+    """Der Waechter darf DB-Feldnamen nicht weiterreichen.
+
+    Die rohe Zeile hat `disc_type`/`created_at`. Wer sie ungewandelt
+    durchreicht, schickt dem UI lauter leere Pflichtfelder — und leer ist
+    schlimmer als fehlend: `new Date(null)` ist der 1.1.1970, sieht also aus
+    wie eine Auskunft.
+    """
+    roh = {"id": "j1", "disc_type": "bluray", "status": "running",
+           "created_at": "2026-08-29T12:07:02", "progress": 12}
+    kurz = _job_kurz(roh)
+    assert kurz["type"] is None and kurz["startTime"] is None
+
+
+def test_ein_job_ereignis_traegt_alles_was_die_oberflaeche_braucht():
+    """DER Waechter. Fehlt hier ein Feld, ist der Bildschirm beim Commander
+    leer — ohne Fehlermeldung."""
+    kurz = _job_kurz(_db_zeile())
+    for feld in UI_PFLICHTFELDER:
+        assert feld in kurz, "%s fehlt — das UI muesste raten" % feld
+        assert kurz[feld] is not None, "%s ist leer" % feld
+
+
+def test_der_typ_kommt_wirklich_durch():
+    """Der konkrete Fehler: `type` fehlte, das UI rief .toUpperCase() darauf."""
+    assert _job_kurz(_db_zeile())["type"] == "bluray"
+
+
+def test_fehlende_felder_werden_zu_None_statt_zu_werfen():
+    """Eine unvollstaendige Zeile darf den Waechter nicht umbringen — er
+    laeuft in der Ereignisschleife des Servers."""
+    kurz = _job_kurz({"id": "j1"})
+    assert kurz["type"] is None and kurz["status"] is None
+
+
+def test_die_kurzform_traegt_NUR_was_gebraucht_wird():
+    """Kein Nachziehen der ganzen Zeile: `meta` und `endTime` gehoeren nicht
+    in ein Aenderungs-Ereignis, sonst feuert es bei jeder Kleinigkeit."""
+    kurz = _job_kurz(_db_zeile())
+    assert "meta" not in kurz
+    assert "endTime" not in kurz
+
+
+def test_unveraenderliche_felder_erzeugen_keine_zusatz_ereignisse():
+    """`type`, `device` und `startTime` aendern sich ueber die Lebenszeit
+    eines Jobs nie — sie kosten also nichts, obwohl sie mitfahren."""
+    eins = _job_kurz(_db_zeile())
+    zwei = _job_kurz(dict(_db_zeile(), progress=13))
+    assert unterschiede({"j1": eins}, {"j1": zwei}) == [
+        ("job.progress", "j1", zwei)]

src/rippy/bus/waechter.py

@@ -79,8 +79,59 @@ ENDE = ("completed", "failed", "canceled")
 
 
 def _job_kurz(zeile: dict) -> dict:
-    """Nur die Felder, deren Änderung ein Ereignis wert ist."""
+    """Nur die Felder, deren Änderung ein Ereignis wert ist.
+
+    ## Warum `type` dazugehört (Befund des Commanders, 29.08.2026)
+
+    > „wenn man auf rippen starten klickt passiert irgendwas, was das Programm
+    > nicht mag. Der Hintergrund ist einfach leer und er startet nix. Es gibt
+    > auch keine fehlermeldung."
+
+    Nachgestellt und in der Browser-Konsole gemessen:
+
+        TypeError: Cannot read properties of undefined (reading 'toUpperCase')
+
+    Der Ablauf: Der Job startet in Wahrheit sehr wohl (gemessen: `processing`,
+    12 %). Aber `job.created` trug nur `status`, `progress`, `title` und
+    `error` — **keinen `type`**. Das UI fügt so einen halben Job in seine
+    Liste ein, das Live-Log liest `job.type.toUpperCase()`, und weil es keine
+    Fehlergrenze gab, riss der Fehler die GESAMTE Oberfläche mit. Leerer
+    Bildschirm, keine Meldung.
+
+    Der Fehler ist damit an drei Stellen zugleich repariert: Das Ereignis
+    trägt den Typ (hier), das UI verträgt sein Fehlen, und eine Fehlergrenze
+    fängt den nächsten Fall dieser Art ab.
+
+    **Ein Ereignis „Job angelegt", das den halben Job weglässt, zwingt jeden
+    Empfänger zum Raten.** `type` und `device` ändern sich über die Lebenszeit
+    eines Jobs nie — sie kosten hier nichts und ersparen dem Empfänger die
+    Frage, ob er gerade einen ganzen oder einen halben Job vor sich hat.
+
+    ## ⚠️ NACHTRAG 29.08.2026 — beim ersten Anlauf falsch gemacht
+
+    Hier stand `zeile.get("startTime")` und `zeile.get("type")`. **Diese
+    Felder gibt es in der Datenbankzeile nicht.** Sie heißen dort `created_at`
+    und `disc_type`; die Übersetzung macht `_job_row_to_model` in `main.py`,
+    und sie bildet auch `running` auf `processing` ab.
+
+    Die Folge war schlimmer als das Problem davor: Statt eines fehlenden
+    Feldes kam ein leeres. Im Bildschirmfoto des Commanders stand
+
+        TYP „DISC"   STARTZEIT „1.1.1970, 01:00:00"   STATUS „running"
+
+    — `new Date(null)` ist der 1. Januar 1970, und „DISC" war der Rückfall,
+    den ich zwei Stunden vorher für genau diesen Fall eingebaut hatte. Aus
+    „offensichtlich kaputt" war „sieht plausibel aus" geworden.
+
+    Und mein Test hat es NICHT gefunden, weil ich seine Beispielzeile selbst
+    geschrieben habe — mit meinen erfundenen Feldnamen. Ein Test, der dieselbe
+    Annahme macht wie der Code, prüft nichts. Deshalb wird die Zeile jetzt
+    zuerst durch dieselbe Umwandlung geschickt, die auch `/jobs` benutzt.
+    """
     return {
+        "type": zeile.get("type"),
+        "device": zeile.get("device"),
+        "startTime": zeile.get("startTime"),
         "status": zeile.get("status"),
         "progress": zeile.get("progress"),
         "title": zeile.get("title"),
@@ -88,6 +139,17 @@ def _job_kurz(zeile: dict) -> dict:
     }
 
 
+#: Was ein Job-Ereignis mitbringen MUSS, damit die Oberflaeche ihn zeichnen
+#: kann, ohne zu raten. Gegengeprueft von test_waechter.py — es gibt kein
+#: gemeinsames Typsystem zwischen Python und dem UI, also steht der Vertrag
+#: hier und wird mechanisch bewacht.
+#:
+#: `startTime` steht dabei, weil ohne ihn in der Jobliste „Invalid Date"
+#: stand (am 29.08.2026 im Browser gesehen), bis Sekunden spaeter der
+#: naechste Schnappschuss kam.
+UI_PFLICHTFELDER = ("type", "startTime", "status", "progress")
+
+
 def unterschiede(vorher: dict, jetzt: dict) -> list:
     """Was hat sich geändert? (pure Funktion — deshalb testbar ohne DB)
 
@@ -173,7 +235,14 @@ class Waechter:
 
     def __init__(self, store, bus, takt: float = TAKT_SEKUNDEN,
                  laufwerke_lesen=None, laufwerks_takt: float = LAUFWERKS_TAKT_SEKUNDEN,
-                 system_lesen=None, system_takt: float = SYSTEM_TAKT_SEKUNDEN):
+                 system_lesen=None, system_takt: float = SYSTEM_TAKT_SEKUNDEN,
+                 job_form=None):
+        # `job_form` uebersetzt eine DB-Zeile in die Form, die das UI kennt
+        # (disc_type -> type, created_at -> startTime, running -> processing).
+        # Eingespritzt, weil die Uebersetzung in main.py wohnt und dieses
+        # Paket nichts von der API weiss. Ohne sie schickte der Waechter die
+        # ROHE Zeile — mit Feldnamen, die es im UI nicht gibt (29.08.2026).
+        self._job_form = job_form or (lambda z: z)
         self._store = store
         self._bus = bus
         self._takt = takt
@@ -181,11 +250,20 @@ class Waechter:
         self._laufwerks_takt = laufwerks_takt
         self._jobs: dict = {}
         self._laufwerke: dict = {}
-        self._laufwerke_geprueft = 0.0
+        # None heißt „noch nie geprüft" — NICHT 0.0. `time.monotonic()` zählt
+        # ab einem beliebigen Nullpunkt; unter Linux ist das der Start der
+        # Maschine. Auf einem frisch gestarteten System ist `jetzt - 0.0`
+        # deshalb KLEIN, und die erste Abfrage fiel schlicht aus.
+        #
+        # Auf dem Linux-Runner der Ampel genau so passiert (28.08.2026): null
+        # Laufwerks-Abfragen statt einer. Unter Windows fällt es nie auf, weil
+        # der Zähler dort schon beim ersten Start groß ist — ein Fehler, den
+        # nur die andere Plattform zeigt.
+        self._laufwerke_geprueft = None
         self._system_lesen = system_lesen
         self._system_takt = system_takt
         self._system = None
-        self._system_geprueft = 0.0
+        self._system_geprueft = None
         self._letzte_log_id = None
         self._letzter_lauf = 0.0
         self._fehler_in_folge = 0
@@ -217,7 +295,8 @@ class Waechter:
         """
         gesendet = 0
 
-        jetzt = {z["id"]: _job_kurz(z) for z in self._store.list_jobs(limit=100)}
+        jetzt = {z["id"]: _job_kurz(self._job_form(z))
+                 for z in self._store.list_jobs(limit=100)}
         erster_lauf = not self._jobs and self._letzte_log_id is None
         if not erster_lauf:
             for typ, job_id, daten in unterschiede(self._jobs, jetzt):
@@ -264,7 +343,8 @@ class Waechter:
         if self._system_lesen is None:
             return 0
         jetzt = time.monotonic()
-        if jetzt - self._system_geprueft < self._system_takt:
+        if (self._system_geprueft is not None
+                and jetzt - self._system_geprueft < self._system_takt):
             return 0
         self._system_geprueft = jetzt
         try:
@@ -289,7 +369,8 @@ class Waechter:
         if self._laufwerke_lesen is None:
             return 0
         jetzt = time.monotonic()
-        if jetzt - self._laufwerke_geprueft < self._laufwerks_takt:
+        if (self._laufwerke_geprueft is not None
+                and jetzt - self._laufwerke_geprueft < self._laufwerks_takt):
             return 0
         self._laufwerke_geprueft = jetzt
         try:

src/rippy/config.py

@@ -223,13 +223,47 @@ def datenbank_url(werte: dict, standard_pfad: str = None) -> str:
 
 
 def standard_datenbankpfad() -> str:
-    """Wo die SQLite-Datei liegt, wenn niemand etwas anderes sagt.
+    r"""Wo die SQLite-Datei liegt, wenn niemand etwas anderes sagt.
 
-    Je Plattform dort, wo Dienste ihre Daten ablegen — nicht neben dem
-    Programm. Ein Programmordner ist unter Windows für einen Dienst nicht
-    zuverlässig beschreibbar, und unter Linux widerspräche es dem FHS.
+    ## Warum unter Windows NICHT mehr %ProgramData% (28.08.2026)
+
+    Hier stand `%ProgramData%\Rippy\rippy.db`, mit der Begründung: „Ein
+    Programmordner ist unter Windows für einen DIENST nicht zuverlässig
+    beschreibbar." Das stimmte — für den Windows-Dienst, den es nie gab.
+    Rippy läuft als der angemeldete Benutzer (Autostart unter `HKCU`, siehe
+    `windows_app.py`), und der Grund ist damit hinfällig.
+
+    Geblieben war der Schaden. Der Commander meldete: **„Es fehlt der 1st run
+    wizzard wenn man es installiert."** Nachgemessen:
+
+        Installation      %LOCALAPPDATA%\Rippy      (wird deinstalliert)
+        Datenbank         %ProgramData%\Rippy       (bleibt liegen)
+
+    Eine „frische" Installation erbte also die alte Datenbank samt
+    `setup.done = true`, und der Ersteinrichtungs-Assistent erschien nie
+    wieder. Ein Deinstallieren, das den Zustand stehen lässt, ist kein
+    Deinstallieren.
+
+    Jetzt liegt alles, was Rippy gehört, in EINEM Ordner: Programm, UI,
+    Werkzeuge, Protokoll, WebView2-Zwischenspeicher — und die Datenbank.
+
+    Unter Linux bleibt `/var/lib/rippy`: Dort läuft Rippy wirklich als
+    Systemdienst, und der FHS sagt genau das.
     """
     if os.name == "nt":
-        basis = os.environ.get("PROGRAMDATA") or os.path.expanduser("~")
+        basis = os.environ.get("LOCALAPPDATA") or os.path.expanduser("~")
         return os.path.join(basis, "Rippy", "rippy.db")
     return "/var/lib/rippy/rippy.db"
+
+
+def alter_datenbankpfad() -> str:
+    r"""Der Ort VOR dem 28.08.2026 — nur noch zum Umziehen und Aufräumen.
+
+    Wer Rippy schon installiert hatte, hat seine Daten dort. Sie kommentarlos
+    liegen zu lassen wäre ein stiller Verlust; sie zu löschen wäre schlimmer.
+    `windows_app.datenbank_umziehen()` holt sie ab.
+    """
+    if os.name != "nt":
+        return ""
+    basis = os.environ.get("PROGRAMDATA") or ""
+    return os.path.join(basis, "Rippy", "rippy.db") if basis else ""

src/rippy/daemon.py

@@ -1,302 +0,0 @@
-"""`rippyd` — Rippy als EIN Prozess, ohne Docker, ohne Postgres, ohne Redis.
-
-## Was hier zusammenkommt
-
-Alles, was die Etappen V2-1 bis V2-3 vorbereitet haben:
-
-    Store    -> SQLite (V2-2)              statt PostgreSQL
-    Queue    -> LocalQueue (V2-2)          statt Celery/Redis
-    Bus      -> In-Process (V2-3)          statt Redis Pub/Sub
-    Drives   -> der Treiber dieser Maschine (V2-1/V2-4)
-    UI       -> von FastAPI ausgeliefert    statt von nginx
-
-Dieselbe API, dasselbe UI, derselbe Rip-Code wie im Docker-Betrieb. Was sich
-unterscheidet, ist allein die Verdrahtung — genau das war der Punkt.
-
-## Warum das UI unter `/` und die API unter `/api` haengt
-
-Das UI ruft seine Endpunkte als `/api/jobs`, `/api/events` usw. auf. Im
-Docker-Betrieb entfernt der nginx dieses Praefix und reicht an die API weiter
-(`ui/nginx.conf`). Ohne nginx muss jemand anderes das tun.
-
-Statt das UI umzubauen — 30+ Aufrufstellen, und die Docker-Variante muesste
-weiter funktionieren — haengt hier die bestehende App als Unteranwendung unter
-`/api`. Ein `mount()`, und beide Betriebsarten sehen fuer den Browser identisch
-aus.
-
-## Was `--profil` bedeutet
-
-    standalone   alles in einem Prozess (Windows-App, Headless-Linux)
-    api          nur die Weboberflaeche, Arbeit machen andere Knoten
-    node         nur Arbeit, keine Weboberflaeche
-
-Fuer V2-4 zaehlt `standalone`; die anderen beiden kommen mit V2-5.
-"""
-
-import argparse
-import os
-import sys
-
-
-def ausgabe_auf_utf8_stellen() -> None:
-    """stdout/stderr auf UTF-8 zwingen — sonst stirbt Rippy an einer Log-Zeile.
-
-    ## Der Vorfall (28.08.2026, erster Standalone-Start unter Windows)
-
-    Der Start brach ab mit:
-
-        File "docker/api/main.py", line 81, in startup_event
-          print(f"⚠️  Konfigurations-Warnung: {e}")
-        UnicodeEncodeError: 'charmap' codec can't encode characters
-        ERROR: Application startup failed. Exiting.
-
-    Windows-Konsolen arbeiten standardmaessig mit cp1252. Rippys Meldungen
-    sind durchgehend deutsch und enthalten Umlaute, Anfuehrungszeichen und
-    Warnzeichen — unter Linux nie ein Thema, unter Windows toedlich.
-
-    Das Bittere daran: Es war nicht die WARNUNG, die den Start verhindert hat,
-    sondern der VERSUCH, sie auszugeben. Eine Meldung ueber ein kleines Problem
-    hat das ganze Programm umgebracht.
-
-    Deshalb zwei Dinge, nicht eins:
-
-    * `encoding="utf-8"` — damit die Zeichen ueberhaupt durchgehen.
-    * `errors="replace"` — damit ein Zeichen, das trotzdem klemmt, ein
-      Fragezeichen wird und NICHT eine Ausnahme. Eine Ausgabe darf unter
-      keinen Umstaenden etwas abbrechen koennen.
-    """
-    for strom in (sys.stdout, sys.stderr):
-        umstellen = getattr(strom, "reconfigure", None)
-        if umstellen is None:
-            continue                       # umgeleitet, kein TextIOWrapper
-        try:
-            umstellen(encoding="utf-8", errors="replace")
-        except (ValueError, OSError):
-            pass                           # dann eben nicht — aber nie werfen
-
-
-ausgabe_auf_utf8_stellen()
-
-
-def _api_pfad() -> str:
-    """Wo liegen die API-Module (main.py, db.py, mounts.py, …)?
-
-    Drei Faelle, und alle drei kommen wirklich vor:
-
-    * **Aus dem Repo gestartet** — `docker/api` neben `src/`.
-    * **Im PyInstaller-Paket** — alles unter `sys._MEIPASS`.
-    * **Installiert** — neben dem Programm.
-
-    Der Umweg ist noetig, weil die API-Module sich flach importieren
-    (`import db`, `import mounts`). Das aufzuloesen ist der naechste
-    Umbauschritt; bis dahin wird der Pfad hier gesetzt statt an drei Stellen
-    geraten.
-    """
-    gebuendelt = getattr(sys, "_MEIPASS", None)
-    if gebuendelt:
-        return os.path.join(gebuendelt, "api")
-
-    hier = os.path.dirname(os.path.abspath(__file__))          # …/src/rippy
-    repo = os.path.dirname(os.path.dirname(hier))              # …/
-    kandidaten = [
-        os.path.join(repo, "docker", "api"),
-        os.path.join(os.path.dirname(sys.executable), "api"),
-    ]
-    for pfad in kandidaten:
-        if os.path.isfile(os.path.join(pfad, "main.py")):
-            return pfad
-    raise RuntimeError(
-        "Die API-Module wurden nicht gefunden. Gesucht wurde in:\n  "
-        + "\n  ".join(kandidaten)
-        + "\nOhne sie kann Rippy nicht starten."
-    )
-
-
-def _ui_pfad() -> str:
-    """Wo liegen die gebauten UI-Dateien? Leerer String = kein UI mitgeliefert."""
-    gebuendelt = getattr(sys, "_MEIPASS", None)
-    if gebuendelt:
-        pfad = os.path.join(gebuendelt, "ui")
-        return pfad if os.path.isdir(pfad) else ""
-
-    hier = os.path.dirname(os.path.abspath(__file__))
-    repo = os.path.dirname(os.path.dirname(hier))
-    for pfad in (os.path.join(repo, "docker", "ui", "dist"),
-                 os.path.join(os.path.dirname(sys.executable), "ui")):
-        if os.path.isdir(pfad):
-            return pfad
-    return ""
-
-
-def argumente(argv=None) -> argparse.Namespace:
-    p = argparse.ArgumentParser(
-        prog="rippyd",
-        description="Rippy als eigenstaendiger Dienst — ohne Docker.",
-    )
-    p.add_argument("--profil", default=None,
-                   choices=["standalone", "api", "node"],
-                   help="Betriebsart (Vorgabe: standalone)")
-    p.add_argument("--config", default=None,
-                   help="Pfad zur rippy.toml")
-    p.add_argument("--host", default=None)
-    p.add_argument("--port", type=int, default=None)
-    p.add_argument("--db", default=None,
-                   help="Pfad zur SQLite-Datei (ueberschreibt die Konfiguration)")
-    p.add_argument("--kein-ui", action="store_true",
-                   help="Weboberflaeche nicht ausliefern")
-    return p.parse_args(argv)
-
-
-def flags_aus_argumenten(args) -> dict:
-    """Nur das, was WIRKLICH angegeben wurde — sonst schlaegt ein
-    argparse-Vorgabewert die Konfigurationsdatei, und niemand versteht,
-    warum der Eintrag dort nicht greift."""
-    flags: dict = {}
-    if args.profil:
-        flags["profil"] = args.profil
-    server = {}
-    if args.host:
-        server["host"] = args.host
-    if args.port:
-        server["port"] = args.port
-    if args.kein_ui:
-        server["ui"] = False
-    if server:
-        flags["server"] = server
-    if args.db:
-        flags["store"] = {"treiber": "sqlite", "pfad": args.db}
-    return flags
-
-
-def einstellungen_laden(args):
-    from rippy import config
-
-    datei = args.config or os.environ.get("RIPPY_CONFIG") or standard_konfigpfad()
-    werte = config.laden(datei if os.path.isfile(datei) else None,
-                         flags=flags_aus_argumenten(args))
-    unbekannt = config.unbekannte_schluessel(
-        config.aus_datei(datei) if os.path.isfile(datei) else {})
-    return werte, datei, unbekannt
-
-
-def standard_konfigpfad() -> str:
-    if os.name == "nt":
-        basis = os.environ.get("PROGRAMDATA") or os.path.expanduser("~")
-        return os.path.join(basis, "Rippy", "rippy.toml")
-    return "/etc/rippy/rippy.toml"
-
-
-def anwendung_bauen(werte: dict):
-    """Baut die ASGI-Anwendung: API unter /api, UI unter /.
-
-    Gibt `(app, ui_pfad)` zurueck — `ui_pfad` ist leer, wenn kein UI
-    ausgeliefert wird.
-    """
-    sys.path.insert(0, _api_pfad())
-
-    from contextlib import asynccontextmanager
-
-    from fastapi import FastAPI
-
-    import main as rippy_api                                    # noqa: E402
-
-    @asynccontextmanager
-    async def lebenszyklus(_):
-        """Den Start der EINGEHAENGTEN Anwendung mit ausloesen.
-
-        ⚠️ Starlette reicht Lifespan-Ereignisse NICHT an `mount()`-Unteranwen-
-        dungen weiter. Ohne diese Zeilen laeuft `startup_event()` in main.py
-        nie — und dann fehlt alles, was dort passiert:
-
-          * `db.init_db()` legt die Tabellen an. Ohne das antwortet /settings
-            mit `sqlite3.OperationalError: no such table: settings`.
-          * Der Ereignis-Waechter startet nicht, der SSE-Strom bleibt stumm.
-          * Gespeicherte Netzwerk-Ziele werden nicht wieder eingehaengt.
-
-        Am 28.08.2026 beim ersten Standalone-Start genau so gemessen: HTTP 200
-        auf /api/health (die Route braucht keine Datenbank), HTTP 500 auf
-        /api/jobs und /api/settings, und der Ereignis-Strom lieferte in sechs
-        Sekunden nichts.
-        """
-        async with rippy_api.app.router.lifespan_context(rippy_api.app):
-            yield
-
-    aussen = FastAPI(title="Rippy", version="2.0", lifespan=lebenszyklus)
-    aussen.mount("/api", rippy_api.app)
-
-    ui = _ui_pfad() if werte.get("server", {}).get("ui", True) else ""
-    if ui:
-        from fastapi.staticfiles import StaticFiles
-
-        # html=True laesst StaticFiles bei unbekannten Pfaden index.html
-        # ausliefern — noetig, weil das UI seine Ansichten selbst verwaltet
-        # (im Docker-Betrieb macht das `try_files $uri /index.html`).
-        aussen.mount("/", StaticFiles(directory=ui, html=True), name="ui")
-    return aussen, ui
-
-
-def starten(argv=None) -> int:
-    args = argumente(argv)
-    werte, konfigdatei, unbekannt = einstellungen_laden(args)
-
-    from rippy import config, drives, store
-
-    # ⚠️ VOR dem Import der API: main.py legt beim Start Tabellen an, und der
-    # Store muss bis dahin auf der richtigen Datenbank stehen. Andersherum
-    # laege die SQLite-Datei am Vorgabeort und die Konfiguration waere
-    # wirkungslos — ohne dass irgendwo etwas stuende.
-    url = config.datenbank_url(werte)
-    store.verbinden(url)
-    os.environ.setdefault("DATABASE_URL", url)
-
-    print("Rippy startet")
-    print(f"  Profil        {werte.get('profil')}")
-    print(f"  Konfiguration {konfigdatei if os.path.isfile(konfigdatei) else '(keine — Vorgaben)'}")
-    print(f"  Datenbank     {url}")
-    print(f"  Laufwerke     {drives.treiber().__name__}")
-    for schluessel in unbekannt:
-        # Ein stillschweigend ignorierter Schluessel ist dieselbe Fehlerklasse
-        # wie ein verschluckter Fehler: sieht gesund aus, wirkt aber nicht.
-        print(f"  ⚠️  Unbekannter Eintrag in der Konfiguration: {schluessel}")
-
-    app, ui = anwendung_bauen(werte)
-    print(f"  Oberflaeche   {ui or '(nicht mitgeliefert)'}")
-
-    # Im Standalone-Betrieb arbeitet DIESER Prozess die Auftraege ab —
-    # es gibt keinen Worker daneben. Ohne diesen Schritt koennte Rippy alles
-    # anzeigen und nichts tun: Ein Rip wuerde eingereiht und laege dann fuer
-    # immer da, weil niemand ihn holt.
-    if werte.get("profil") == "standalone" and werte["queue"]["treiber"] == "lokal":
-        from rippy import standalone
-        from rippy.bus.memory import bus as ereignis_bus
-
-        laeufer = standalone.starten(
-            knoten=werte["queue"].get("knoten") or None,
-            bus=ereignis_bus, store=store,
-            slots=werte["queue"].get("rip_slots", 1),
-        )
-        print(f"  Laeufer       {len(laeufer)} (Auftraege werden hier abgearbeitet)")
-    else:
-        print("  Laeufer       keiner — Auftraege gehen an Celery")
-
-    host = werte["server"]["host"]
-    port = werte["server"]["port"]
-    print(f"  Adresse       http://{'localhost' if host in ('0.0.0.0', '') else host}:{port}")
-    print()
-
-    import uvicorn
-
-    uvicorn.run(app, host=host, port=port, log_level="info")
-    return 0
-
-
-def main() -> int:
-    try:
-        return starten()
-    except KeyboardInterrupt:
-        print("\nRippy beendet.")
-        return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

src/rippy/drives/__init__.py

@@ -41,8 +41,12 @@ def treiber(plattform: str = None):
     """
     plattform = plattform if plattform is not None else sys.platform
     if plattform.startswith("win"):
-        from rippy.drives import windows
-        return windows
+        # Der Windows-Treiber ist mit der Standalone-App gegangen (Rippy v5,
+        # Entscheid 7). Der Platzhalter hält Importe und Test-Sammlung auf
+        # Windows-Entwicklungsrechnern am Leben; jede BENUTZUNG wirft mit
+        # Klartext — siehe kein_windows.py.
+        from rippy.drives import kein_windows
+        return kein_windows
     from rippy.drives import linux
     return linux
 

src/rippy/drives/kein_windows.py

@@ -0,0 +1,34 @@
+"""Der Platzhalter, der unter Windows die Wahrheit sagt.
+
+Der echte Windows-Laufwerkstreiber ist mit der Standalone-App gegangen —
+Rippy für Windows ist seit dem 30.08.2026 ein eigenes Produkt (Rippy v5,
+KONZEPT-WINDOWS.md Entscheid 7). Diese Codebasis ist die Docker/Linux-
+Fassung; der Remote-Encode-Worker auf Windows rippt nicht (Entscheid 8).
+
+Warum ein Modul statt eines Fehlers in `treiber()`: Entwicklungs- und
+Test-Läufe auf einem Windows-PC müssen IMPORTIERBAR bleiben (die Ampel-
+Praxis misst lokal, bevor sie pusht). Erst die BENUTZUNG eines Laufwerks
+ist hier ein Fehler — und zwar einer mit Ansage.
+"""
+
+MELDUNG = (
+    "Kein Windows-Laufwerkstreiber in der Docker-Fassung — fuer Windows "
+    "gibt es Rippy v5 (Branch worktree-windows-electron)."
+)
+
+
+def _fehlt(*_args, **_kwargs):
+    raise RuntimeError(MELDUNG)
+
+
+# Dieselben Namen wie linux.py — test_treiberwahl wacht darüber.
+list_optical_devices = _fehlt
+device_info = _fehlt
+drive_status = _fehlt
+disc_status = _fehlt
+detect_disc_type = _fehlt
+disc_size_bytes = _fehlt
+eject = _fehlt
+auswerfen_versuchen = _fehlt
+auswerfen_mit_grund = _fehlt
+verriegeln = _fehlt

src/rippy/drives/linux.py

@@ -54,6 +54,37 @@ from rippy.drives.cdrom import (  # noqa: F401
     CDS_TRAY_OPEN,
 )
 
+# Was `detection.py` beisteuert — auf Anfrage, nicht beim Import.
+#
+# ## Warum das hier stehen MUSS (Ampel rot seit 28.08.2026, Lauf 181–184)
+#
+# `docker/api/main.py` holt sich beim Import `device_discovery.drive_status`.
+# Der Windows-Treiber hat die Funktion; dieses Modul hatte sie nicht mehr,
+# seit `detection` (und damit `fcntl`) bewusst nicht mehr oben importiert
+# wird. Folge: Unter Windows lief alles, auf Linux starb main.py beim Import
+# mit `AttributeError: module 'rippy.drives.linux' has no attribute
+# 'drive_status'` — **der API-Container wäre gar nicht hochgekommen**.
+#
+# Lokal fiel es nicht auf, weil hier Windows läuft und `treiber()` dann gar
+# nicht zu diesem Modul greift. Genau dafür ist die Ampel da — und genau
+# deshalb ist Regel A („grün, bevor irgendetwas fertig heißt") keine Formalie.
+#
+# PEP 562: `__getattr__` wird nur gefragt, wenn der Name nicht schon als
+# Modul-Variable existiert. Damit bleibt `import rippy.drives.linux` unter
+# Windows möglich (kein `fcntl` nötig), und wer die Funktionen wirklich
+# BENUTZT, bekommt sie — oder einen lauten ImportError.
+_AUS_DETECTION = ("drive_status", "disc_status", "disc_size_bytes",
+                  "detect_disc_type", "classify")
+
+
+def __getattr__(name):
+    if name in _AUS_DETECTION:
+        from rippy.drives import detection
+
+        return getattr(detection, name)
+    raise AttributeError("module %r has no attribute %r" % (__name__, name))
+
+
 # Wie lange auf die Schublade gewartet wird. Ein Laufwerk braucht dafür ein
 # bis zwei Sekunden; fünf sind reichlich und blockieren nichts Wichtiges.
 AUSWURF_WARTEN_SEKUNDEN = 5
@@ -198,6 +229,24 @@ def read_sys_attr(device_name: str, attr: str) -> str:
         return ""
 
 
+def kennung(device_path: str) -> str:
+    """Der kurze Name eines Laufwerks — `/dev/sr0` wird zu `sr0`.
+
+    Gegenstueck zu `pfad_zu_kennung`. Begruendung im Windows-Treiber: Hin-
+    und Rueckweg muessen zusammenpassen, sonst antworten die Endpunkte mit
+    404 (Befund 29.08.2026).
+    """
+    return os.path.basename(device_path)
+
+
+def pfad_zu_kennung(name: str, geraete=None) -> str:
+    """Kennung -> Geraetepfad, oder "" wenn es dieses Laufwerk nicht gibt."""
+    for pfad in (geraete if geraete is not None else list_optical_devices()):
+        if pfad == name or kennung(pfad) == name:
+            return pfad
+    return ""
+
+
 def device_info(device_path: str) -> dict:
     """Baut den Geräte-Eintrag fürs UI: Name aus /sys, Disc-Status per ioctl.
 
@@ -216,23 +265,31 @@ def device_info(device_path: str) -> dict:
         drive_status,
     )
 
-    name = os.path.basename(device_path)
+    name = kennung(device_path)
     vendor = read_sys_attr(name, "vendor")
     model = read_sys_attr(name, "model")
 
+    grund = ""
     try:
         status_code = drive_status(device_path)
-    except OSError:
+    except OSError as e:
         status_code = -1
+        grund = "Das Laufwerk antwortet nicht (%s)." % (e.strerror or e)
 
     disc_type = "unknown"
-    status = "empty"
+    # Ein Laufwerk, das sich nicht ansprechen laesst, ist nicht LEER —
+    # man weiss es nur nicht. Der Windows-Treiber haelt sich seit V2-1
+    # daran („DIE Regel des Ports", siehe dort); hier stand weiterhin
+    # „empty", und damit behauptete derselbe Ereignisstrom je nach
+    # Plattform etwas anderes ueber dieselbe Lage (Befund 30.08.2026).
+    status = "unknown" if status_code < 0 else "empty"
     if status_code == CDS_DISC_OK:
         status = "ready"
         try:
             disc_type = classify(disc_status(device_path), disc_size_bytes(device_path))
-        except OSError:
+        except OSError as e:
             disc_type = "unknown"
+            grund = "Die Disc liess sich nicht einordnen (%s)." % (e.strerror or e)
 
     return {
         "id": name,
@@ -242,4 +299,7 @@ def device_info(device_path: str) -> dict:
         "status": status,
         "model": model,
         "serial": read_sys_attr(name, "wwid"),
+        # Gleiche Felder wie im Windows-Treiber — das UI unterscheidet
+        # nicht nach Plattform (siehe test_windows: Feld-Parität).
+        "grund": grund,
     }

src/rippy/drives/test_treiberwahl.py

@@ -71,4 +71,69 @@ def test_windows_treiber_kann_alles_pflichtgemaesse(name):
                     reason="der Linux-Treiber braucht fcntl")
 @pytest.mark.parametrize("name", PFLICHT)
 def test_linux_treiber_kann_alles_pflichtgemaesse(name):
-    assert callable(getattr(drives.treiber("linux"), name, None))
+    assert callable(getattr(drives.treiber("linux"), name, None)), (
+        f"Dem Linux-Treiber fehlt {name}(). Das faellt sonst erst im Betrieb "
+        "als AttributeError auf — auf der anderen Plattform."
+    )
+
+
+# Was `linux.py` nicht selbst hat, sondern aus `detection.py` durchreicht.
+# Getrennt gefuehrt, weil genau diese Trennung der Fehler war.
+AUS_DETECTION = ("drive_status", "disc_status", "disc_size_bytes",
+                 "detect_disc_type", "classify")
+
+
+@pytest.mark.parametrize("name", AUS_DETECTION)
+def test_linux_treiber_reicht_die_detection_funktionen_durch(name, monkeypatch):
+    """DER Fehler, der die Ampel vier Commits lang rot hielt (28.08.2026).
+
+    `docker/api/main.py` holt sich beim Import `device_discovery.drive_status`.
+    Der Windows-Treiber hat die Funktion. `linux.py` hatte sie NICHT mehr,
+    seit `detection` (und damit `fcntl`) bewusst nicht mehr oben importiert
+    wird — sonst waere `main.py` unter Windows nicht ladbar.
+
+    Folge: Unter Windows lief alles, auf Linux starb `main.py` beim Import
+    mit `AttributeError: module 'rippy.drives.linux' has no attribute
+    'drive_status'`. **Der API-Container waere gar nicht hochgekommen.**
+
+    Der Test oben faellt unter Windows aus (er braucht `fcntl`) — dieser
+    hier NICHT: Er schiebt eine Attrappe von `detection` unter und prueft
+    nur die Durchreiche. Damit haette der Fehler auch hier auffallen muessen,
+    nicht erst auf dem Linux-Runner.
+    """
+    import types
+
+    import rippy.drives
+    from rippy.drives import linux
+
+    attrappe = types.ModuleType("rippy.drives.detection")
+    for wie_es_heisst in AUS_DETECTION:
+        setattr(attrappe, wie_es_heisst,
+                lambda *a, _n=wie_es_heisst, **k: _n)
+
+    # BEIDES ersetzen, nicht nur sys.modules. `from rippy.drives import
+    # detection` sieht zuerst im PAKET nach (`_handle_fromlist` prueft
+    # `hasattr`) und greift erst dann auf sys.modules zurueck. Auf Linux ist
+    # das echte Modul dort laengst gesetzt, weil es importierbar ist — die
+    # Attrappe blieb wirkungslos und der Test lief in die echten Funktionen
+    # (Ampel-Lauf 186: `TypeError: drive_status() missing 1 required
+    # positional argument`). Unter Windows fiel das nicht auf: Dort gibt es
+    # das Attribut mangels `fcntl` gar nicht.
+    monkeypatch.setattr(rippy.drives, "detection", attrappe, raising=False)
+    monkeypatch.setitem(sys.modules, "rippy.drives.detection", attrappe)
+
+    durchgereicht = getattr(linux, name, None)
+    assert callable(durchgereicht), (
+        f"linux.py reicht {name}() nicht durch — genau daran ist die API "
+        "auf Linux beim Import gestorben."
+    )
+    assert durchgereicht() == name
+
+
+def test_unbekannte_namen_werfen_weiter(monkeypatch):
+    """Die Durchreiche darf kein Sammelbecken werden: Ein Tippfehler muss
+    ein AttributeError bleiben, sonst verschwindet er still."""
+    from rippy.drives import linux
+
+    with pytest.raises(AttributeError):
+        linux.gibt_es_nicht

src/rippy/drives/test_win_ioctl.py

@@ -1,84 +0,0 @@
-"""Die Win32-Steuercodes gegen die dokumentierten Zahlen rechnen.
-
-## Warum dieser Test wichtig ist
-
-Ein falscher IOCTL-Code liefert kein „unbekannter Befehl". Windows antwortet
-mit `ERROR_INVALID_FUNCTION` — und das liest sich wie „dieses Laufwerk kann
-das nicht". Man sucht dann tagelang am Gerät statt an einer Zahl.
-
-Die Werte rechts sind die in `winioctl.h` / `ntddcdrm.h` und auf Microsoft
-Learn dokumentierten Konstanten. Links steht, was `ctl_code()` aus den
-Bestandteilen bildet. Stimmen beide überein, ist die Herleitung richtig.
-
-Läuft auf JEDER Plattform: Hier wird nur gerechnet, nichts aufgerufen. Der
-Zahlendreher fällt damit schon auf dem Entwicklungsrechner auf und nicht erst
-an einem echten Laufwerk.
-"""
-
-import pytest
-
-from rippy.drives import win_ioctl as w
-
-
-def test_ctl_code_bildet_das_makro_aus_winioctl_h_ab():
-    """CTL_CODE(DeviceType, Function, Method, Access) =
-    (DeviceType << 16) | (Access << 14) | (Function << 2) | Method"""
-    assert w.ctl_code(0, 0, 0, 0) == 0
-    assert w.ctl_code(1, 0, 0, 0) == 1 << 16
-    assert w.ctl_code(0, 1, 0, 0) == 1 << 2
-    assert w.ctl_code(0, 0, 3, 0) == 3
-    assert w.ctl_code(0, 0, 0, 1) == 1 << 14
-
-
-@pytest.mark.parametrize("name,erwartet", [
-    # Die Zahlen aus der Microsoft-Dokumentation bzw. den SDK-Headern.
-    ("IOCTL_STORAGE_CHECK_VERIFY2", 0x002D0800),
-    ("IOCTL_STORAGE_MEDIA_REMOVAL", 0x002D4804),
-    ("IOCTL_STORAGE_EJECT_MEDIA",   0x002D4808),
-    ("IOCTL_STORAGE_LOAD_MEDIA",    0x002D480C),
-    ("IOCTL_CDROM_DISK_TYPE",       0x00020040),
-    ("IOCTL_DISK_GET_LENGTH_INFO",  0x0007405C),
-])
-def test_steuercode_stimmt_mit_der_dokumentation_ueberein(name, erwartet):
-    assert getattr(w, name) == erwartet, (
-        f"{name} ist {getattr(w, name):#010x}, dokumentiert ist {erwartet:#010x}. "
-        "Ein falscher Steuercode meldet ERROR_INVALID_FUNCTION — das sieht aus "
-        "wie 'das Laufwerk kann das nicht' und schickt die Fehlersuche in die "
-        "falsche Richtung."
-    )
-
-
-# ── Gerätepfad ──────────────────────────────────────────────────────────
-@pytest.mark.parametrize("eingabe", ["D", "D:", "d:", "D:\\", "d:/", " D: "])
-def test_geraetepfad_ist_immer_dieselbe_form(eingabe):
-    assert w.geraetepfad(eingabe) == r"\\.\D:"
-
-
-def test_geraetepfad_haengt_keinen_backslash_an():
-    """Der entscheidende Punkt: MIT abschliessendem Backslash oeffnet
-    CreateFileW das WURZELVERZEICHNIS des Dateisystems statt des Geraets.
-    Die IOCTLs scheitern dann mit ERROR_INVALID_FUNCTION."""
-    assert not w.geraetepfad("E:\\").endswith("\\")
-    assert w.geraetepfad("E:\\") == r"\\.\E:"
-
-
-def test_geraetepfad_ohne_angabe_wirft():
-    for leer in ("", "   ", ":", "\\"):
-        with pytest.raises(ValueError):
-            w.geraetepfad(leer)
-
-
-def test_drive_cdrom_ist_fuenf():
-    """GetDriveTypeW meldet optische Laufwerke als 5. Ein Zahlendreher hier
-    hiesse: Rippy findet entweder gar kein Laufwerk oder haelt die
-    Systemplatte fuer eines."""
-    assert w.DRIVE_CDROM == 5
-    assert w.DRIVE_FIXED == 3
-    assert w.DRIVE_REMOVABLE == 2
-
-
-def test_error_not_ready_ist_einundzwanzig():
-    """Das ist die Antwort von CHECK_VERIFY2 bei leerem Laufwerk — und damit
-    die Windows-Entsprechung von CDS_NO_DISC. Sie ENTSCHEIDET, ob ein
-    Auswurf als geglueckt gilt."""
-    assert w.ERROR_NOT_READY == 21

src/rippy/drives/test_windows.py

@@ -1,232 +0,0 @@
-"""Der Windows-Treiber gegen ein nachgebautes Laufwerk.
-
-## Was diese Tests beweisen — und was nicht
-
-**Sie beweisen den ABLAUF:** dass erst entriegelt und dann ausgeworfen wird,
-dass danach nachgesehen statt geglaubt wird, dass ein verriegeltes Laufwerk als
-Fehlschlag gilt, dass ein unzugängliches Laufwerk „unbekannt" ergibt und nicht
-„leer", und dass beide Verträge (werfend / nicht werfend) stimmen.
-
-**Sie beweisen NICHT, dass echte Hardware sich so verhält.** Dafür braucht es
-ein angestecktes Laufwerk und eine Disc. Bis das gemessen ist, gilt der Treiber
-als gebaut, nicht als bewiesen.
-
-Das nachgebaute Laufwerk unten bildet genau das Verhalten ab, das am
-26.07.2026 am echten BU40N unter Linux GEMESSEN wurde: Der Auswurf-Befehl wird
-auch bei verriegelter Tür mit Erfolg quittiert und tut nichts. Es gibt keinen
-Anlass anzunehmen, dass Windows das anders macht — beide Wege enden im selben
-SCSI-Befehl an dasselbe Gerät.
-"""
-
-import pytest
-
-from rippy.drives import win_ioctl as w
-from rippy.drives import windows
-
-
-class FakeLaufwerk:
-    """Ein Laufwerk aus Papier — verhält sich wie das gemessene echte.
-
-    `verriegelt=True` bildet den Zustand nach einem MakeMKV-Rip ab: Die Tür ist
-    zu, und der Auswurf-Befehl wird trotzdem mit Erfolg quittiert.
-    """
-
-    def __init__(self, medium=True, verriegelt=False, kennt_lockdoor=True,
-                 buchstaben=("C", "D"), typen=None, disk_flags=None,
-                 groesse=None, oeffnen_fehler=None):
-        self.medium = medium
-        self.verriegelt = verriegelt
-        self.kennt_lockdoor = kennt_lockdoor
-        self._buchstaben = list(buchstaben)
-        self._typen = typen or {"C": w.DRIVE_FIXED, "D": w.DRIVE_CDROM}
-        self.disk_flags = disk_flags
-        self.groesse = groesse
-        self.oeffnen_fehler = oeffnen_fehler
-        self.aufrufe = []          # Reihenfolge der Steuercodes
-        self.offen = 0
-
-    # -- Laufwerks-Auflistung
-    def laufwerksbuchstaben(self):
-        return list(self._buchstaben)
-
-    def laufwerkstyp(self, buchstabe):
-        return self._typen.get(buchstabe, w.DRIVE_UNKNOWN)
-
-    # -- Gerät
-    def oeffnen(self, pfad):
-        if self.oeffnen_fehler is not None:
-            raise self.oeffnen_fehler
-        self.offen += 1
-        return 4242
-
-    def schliessen(self, handle):
-        self.offen -= 1
-
-    def steuern(self, handle, code, eingabe=b"", ausgabe_bytes=0):
-        self.aufrufe.append(code)
-
-        if code == w.IOCTL_STORAGE_MEDIA_REMOVAL:
-            if not self.kennt_lockdoor:
-                raise windows.Win32Fehler("MEDIA_REMOVAL", w.ERROR_INVALID_FUNCTION)
-            self.verriegelt = eingabe[:1] == b"\x01"
-            return b""
-
-        if code == w.IOCTL_STORAGE_EJECT_MEDIA:
-            # ⚠️ Der gemessene Punkt: Erfolg wird IMMER gemeldet. Gewirkt hat
-            # er nur, wenn die Tuer nicht verriegelt ist.
-            if not self.verriegelt:
-                self.medium = False
-            return b""
-
-        if code == w.IOCTL_STORAGE_CHECK_VERIFY2:
-            if not self.medium:
-                raise windows.Win32Fehler("CHECK_VERIFY2", w.ERROR_NOT_READY)
-            return b""
-
-        if code == w.IOCTL_CDROM_DISK_TYPE:
-            if self.disk_flags is None:
-                raise windows.Win32Fehler("DISK_TYPE", w.ERROR_INVALID_FUNCTION)
-            return int(self.disk_flags).to_bytes(4, "little")
-
-        if code == w.IOCTL_DISK_GET_LENGTH_INFO:
-            if self.groesse is None:
-                raise windows.Win32Fehler("GET_LENGTH_INFO", w.ERROR_INVALID_FUNCTION)
-            return int(self.groesse).to_bytes(8, "little")
-
-        raise windows.Win32Fehler(f"unerwarteter Code {code:#x}", w.ERROR_INVALID_FUNCTION)
-
-
-# ── Laufwerke finden ────────────────────────────────────────────────────
-def test_nur_optische_laufwerke_werden_gelistet():
-    """Waeren es alle, stuende die Systemplatte als „Laufwerk" im UI."""
-    api = FakeLaufwerk(buchstaben=("C", "D", "E", "Z"), typen={
-        "C": w.DRIVE_FIXED, "D": w.DRIVE_CDROM,
-        "E": w.DRIVE_CDROM, "Z": w.DRIVE_REMOTE,
-    })
-    assert windows.list_optical_devices(api) == [r"\\.\D:", r"\\.\E:"]
-
-
-def test_ohne_optisches_laufwerk_ist_die_liste_leer():
-    api = FakeLaufwerk(buchstaben=("C",), typen={"C": w.DRIVE_FIXED})
-    assert windows.list_optical_devices(api) == []
-
-
-# ── Auswurf: die Reihenfolge ist der Punkt ──────────────────────────────
-def test_auswurf_entriegelt_zuerst_und_klappt_dann():
-    api = FakeLaufwerk(medium=True, verriegelt=True)
-    assert windows.auswerfen_versuchen(r"\\.\D:", api=api, warten=lambda s: None) is True
-    assert api.medium is False
-    # Entriegeln VOR Auswerfen — sonst quittiert das Laufwerk Erfolg und tut nichts.
-    assert api.aufrufe[0] == w.IOCTL_STORAGE_MEDIA_REMOVAL
-    assert api.aufrufe[1] == w.IOCTL_STORAGE_EJECT_MEDIA
-
-
-def test_auswurf_meldet_fehlschlag_wenn_die_disc_drin_bleibt():
-    """Der teure Fehler aus v1, hier vorweggenommen: Ein Laufwerk, das das
-    Entriegeln nicht kennt und verriegelt bleibt, quittiert den Auswurf
-    trotzdem mit Erfolg. Wer dem Rueckgabewert glaubt, schreibt „Disc
-    ausgeworfen" ins Log, waehrend die Schublade zu bleibt."""
-    api = FakeLaufwerk(medium=True, verriegelt=True, kennt_lockdoor=False)
-    assert windows.auswerfen_versuchen(r"\\.\D:", api=api, warten=lambda s: None) is False
-    assert api.medium is True          # nie aufgegangen
-
-
-def test_auswurf_ohne_laufwerk_wirft_nicht():
-    api = FakeLaufwerk(oeffnen_fehler=windows.Win32Fehler("CreateFileW", w.ERROR_FILE_NOT_FOUND))
-    assert windows.auswerfen_versuchen(r"\\.\Z:", api=api, warten=lambda s: None) is False
-
-
-def test_geraet_wird_immer_wieder_geschlossen():
-    """Ein offenes Handle auf einem optischen Laufwerk blockiert den Auswurf
-    fuer JEDEN anderen — auch fuer den Explorer."""
-    api = FakeLaufwerk(medium=True)
-    windows.auswerfen_versuchen(r"\\.\D:", api=api, warten=lambda s: None)
-    assert api.offen == 0
-
-
-# ── Der andere Vertrag: eject() muss werfen ─────────────────────────────
-def test_eject_ist_still_wenn_die_disc_rauskommt():
-    api = FakeLaufwerk(medium=True, verriegelt=True)
-    assert windows.eject(r"\\.\D:", api=api) is None
-
-
-def test_eject_wirft_wenn_die_disc_drin_bleibt():
-    api = FakeLaufwerk(medium=True, verriegelt=True, kennt_lockdoor=False)
-    with pytest.raises(OSError, match="noch"):
-        windows.eject(r"\\.\D:", api=api)
-
-
-def test_eject_reicht_den_urspruenglichen_fehler_weiter():
-    """„Zugriff verweigert" und „Gerät nicht gefunden" sind zwei ganz
-    verschiedene Probleme. Wer sie hinter einer eigenen Meldung versteckt,
-    nimmt dem Nutzer die einzige brauchbare Auskunft."""
-    original = windows.Win32Fehler("CreateFileW", w.ERROR_ACCESS_DENIED)
-    api = FakeLaufwerk(oeffnen_fehler=original)
-    with pytest.raises(OSError) as fehler:
-        windows.eject(r"\\.\D:", api=api)
-    assert fehler.value is original
-    # `code` statt `winerror`: letzteres gibt es nur unter Windows, und der
-    # Treiber wird auch anderswo getestet.
-    assert fehler.value.code == w.ERROR_ACCESS_DENIED
-
-
-# ── Zustand und Typ ─────────────────────────────────────────────────────
-def test_leeres_laufwerk_ist_leer_und_nicht_unbekannt():
-    api = FakeLaufwerk(medium=False)
-    assert windows.detect_disc_type(r"\\.\D:", api=api) == "no_disc"
-    assert windows.device_info(r"\\.\D:", api=api)["status"] == "empty"
-
-
-def test_unzugaengliches_laufwerk_ist_UNBEKANNT_und_nicht_leer():
-    """DIE Regel des Ports. Ein Laufwerk, das gerade belegt ist, hat nicht
-    „keine Disc" — man weiss es nur nicht. In v1 hat genau diese Vermischung
-    Listen im UI geleert."""
-    api = FakeLaufwerk(oeffnen_fehler=windows.Win32Fehler("CreateFileW", w.ERROR_ACCESS_DENIED))
-    assert windows.detect_disc_type(r"\\.\D:", api=api) == "unknown"
-    assert windows.device_info(r"\\.\D:", api=api)["status"] == "unknown"
-
-
-@pytest.mark.parametrize("flags,groesse,erwartet", [
-    (w.CDROM_DISK_AUDIO_TRACK, 700 * 1024**2,      "cd"),
-    (w.CDROM_DISK_DATA_TRACK,  8 * 1024**3,        "dvd"),
-    (w.CDROM_DISK_DATA_TRACK,  25 * 1024**3,       "bluray"),
-    (w.CDROM_DISK_DATA_TRACK,  50 * 1000**3,       "bluray"),   # BD-50
-    (w.CDROM_DISK_DATA_TRACK,  66 * 1000**3,       "uhd"),      # BD-66
-    (w.CDROM_DISK_DATA_TRACK,  100 * 1000**3,      "uhd"),
-])
-def test_disc_typ_kommt_aus_derselben_zuordnung_wie_unter_linux(flags, groesse, erwartet):
-    """Die Einordnung liegt in cdrom.classify() — EINE Funktion fuer beide
-    Plattformen, und die ist eigenstaendig getestet. Hier wird nur geprueft,
-    dass Windows die beiden Eingangswerte richtig beschafft."""
-    api = FakeLaufwerk(medium=True, disk_flags=flags, groesse=groesse)
-    assert windows.detect_disc_type(r"\\.\D:", api=api) == erwartet
-
-
-def test_verriegeln_schickt_das_richtige_byte():
-    api = FakeLaufwerk(medium=True)
-    windows.verriegeln(r"\\.\D:", True, api=api)
-    assert api.verriegelt is True
-    windows.verriegeln(r"\\.\D:", False, api=api)
-    assert api.verriegelt is False
-
-
-def test_device_info_hat_dieselben_felder_wie_unter_linux():
-    """Das UI unterscheidet nicht nach Plattform — fehlt ein Feld, bleibt die
-    Karte im Dashboard leer."""
-    api = FakeLaufwerk(medium=True, disk_flags=w.CDROM_DISK_DATA_TRACK, groesse=25 * 1024**3)
-    eintrag = windows.device_info(r"\\.\D:", api=api)
-    assert set(eintrag) == {"id", "name", "type", "path", "status", "model", "serial"}
-    assert eintrag["id"] == "D"
-    assert eintrag["status"] == "ready"
-    assert eintrag["type"] == "bluray"
-
-
-def test_treiber_verweigert_sich_ausserhalb_von_windows():
-    """Sonst waere der erste Fehler ein kryptischer ctypes-Absturz statt
-    einer Ansage."""
-    import sys as _sys
-
-    if _sys.platform.startswith("win"):
-        pytest.skip("laeuft nur, wenn NICHT unter Windows getestet wird")
-    with pytest.raises(RuntimeError, match="nur unter Windows"):
-        windows.Win32()

src/rippy/drives/win_ioctl.py

@@ -1,128 +0,0 @@
-"""Die Win32-Steuercodes für optische Laufwerke — hergeleitet, nicht abgeschrieben.
-
-## Warum sie hier ausgerechnet werden
-
-`AGENTS.md` Regel D: *„Externe Schnittstellen NIE aus dem Kopf. Vor Nutzung
-fremder CLI-Flags oder Bibliotheks-APIs: --help/Doku prüfen und die Fundstelle
-im Commit nennen."*
-
-Zahlen wie `0x2D4808` sind genau der Fall, in dem sich ein Zahlendreher
-lautlos versteckt: Ein falscher Code liefert kein „unbekannter Befehl", sondern
-`ERROR_INVALID_FUNCTION` — und das sieht aus wie „das Laufwerk kann das nicht".
-Man sucht dann am Gerät statt an der Zahl.
-
-Deshalb steht hier das Makro aus `winioctl.h` als Funktion, und jede Konstante
-wird daraus gebildet. Wer nachrechnen will, sieht die Bestandteile.
-
-    #define CTL_CODE(DeviceType, Function, Method, Access) (          \\
-        ((DeviceType) << 16) | ((Access) << 14) |                     \\
-        ((Function) << 2) | (Method)                                  \\
-    )
-
-Fundstellen (Windows SDK / Microsoft Learn):
-  * CTL_CODE, FILE_DEVICE_*, METHOD_*, FILE_*_ACCESS  — winioctl.h
-  * IOCTL_STORAGE_CHECK_VERIFY2  — learn.microsoft.com/windows/win32/api/
-    winioctl/ni-winioctl-ioctl_storage_check_verify2
-  * IOCTL_STORAGE_MEDIA_REMOVAL / _EJECT_MEDIA / _LOAD_MEDIA — ebenda
-  * IOCTL_CDROM_DISK_TYPE, CDROM_DISK_AUDIO_TRACK/DATA_TRACK — ntddcdrm.h
-  * IOCTL_DISK_GET_LENGTH_INFO — winioctl.h (GET_LENGTH_INFORMATION)
-
-## Gegenprobe
-
-`test_win_ioctl.py` rechnet die hier gebildeten Werte gegen die Zahlen, die in
-der Microsoft-Dokumentation stehen. Stimmt eine nicht, faellt das beim Testen
-auf — auf JEDER Plattform, auch ohne Windows und ohne Laufwerk.
-"""
-
-# ── Bausteine aus winioctl.h ────────────────────────────────────────────
-FILE_DEVICE_CD_ROM = 0x00000002
-FILE_DEVICE_DISK = 0x00000007
-FILE_DEVICE_MASS_STORAGE = 0x0000002D      # = IOCTL_STORAGE_BASE
-
-METHOD_BUFFERED = 0
-METHOD_IN_DIRECT = 1
-METHOD_OUT_DIRECT = 2
-METHOD_NEITHER = 3
-
-FILE_ANY_ACCESS = 0
-FILE_READ_ACCESS = 0x0001
-FILE_WRITE_ACCESS = 0x0002
-
-
-def ctl_code(geraetetyp: int, funktion: int, methode: int, zugriff: int) -> int:
-    """Das CTL_CODE-Makro aus winioctl.h, eins zu eins."""
-    return ((geraetetyp << 16) | (zugriff << 14) | (funktion << 2) | methode)
-
-
-# ── Speicher (IOCTL_STORAGE_*) ──────────────────────────────────────────
-# „Ist ein Medium eingelegt?" — die Windows-Entsprechung von
-# CDROM_DRIVE_STATUS. Antwortet mit ERROR_NOT_READY (21), wenn nichts drin ist.
-IOCTL_STORAGE_CHECK_VERIFY2 = ctl_code(
-    FILE_DEVICE_MASS_STORAGE, 0x0200, METHOD_BUFFERED, FILE_ANY_ACCESS)
-
-# Tür verriegeln/entriegeln — die Entsprechung von CDROM_LOCKDOOR.
-# Erwartet eine PREVENT_MEDIA_REMOVAL-Struktur (ein BOOLEAN).
-IOCTL_STORAGE_MEDIA_REMOVAL = ctl_code(
-    FILE_DEVICE_MASS_STORAGE, 0x0201, METHOD_BUFFERED, FILE_READ_ACCESS)
-
-# Auswerfen — die Entsprechung von CDROMEJECT.
-IOCTL_STORAGE_EJECT_MEDIA = ctl_code(
-    FILE_DEVICE_MASS_STORAGE, 0x0202, METHOD_BUFFERED, FILE_READ_ACCESS)
-
-# Schublade einziehen — die Entsprechung von CDROMCLOSETRAY.
-IOCTL_STORAGE_LOAD_MEDIA = ctl_code(
-    FILE_DEVICE_MASS_STORAGE, 0x0203, METHOD_BUFFERED, FILE_READ_ACCESS)
-
-# ── CD-ROM (IOCTL_CDROM_*) ──────────────────────────────────────────────
-# Audio- oder Datenspur? Grob, aber genau das, was CDROM_DISC_STATUS auch
-# liefert — mehr braucht die Einordnung nicht (die Feinunterscheidung
-# DVD/BD/UHD kommt über die Größe).
-IOCTL_CDROM_DISK_TYPE = ctl_code(
-    FILE_DEVICE_CD_ROM, 0x0010, METHOD_BUFFERED, FILE_ANY_ACCESS)
-
-CDROM_DISK_AUDIO_TRACK = 0x00000001
-CDROM_DISK_DATA_TRACK = 0x00000002
-
-# ── Größe des Mediums ───────────────────────────────────────────────────
-# Die Entsprechung von BLKGETSIZE64. Liefert GET_LENGTH_INFORMATION
-# (ein LARGE_INTEGER, also 8 Byte).
-IOCTL_DISK_GET_LENGTH_INFO = ctl_code(
-    FILE_DEVICE_DISK, 0x0017, METHOD_BUFFERED, FILE_READ_ACCESS)
-
-# ── Rückmeldungen von GetLastError() ────────────────────────────────────
-ERROR_NOT_READY = 21            # kein Medium eingelegt
-ERROR_ACCESS_DENIED = 5
-ERROR_FILE_NOT_FOUND = 2
-ERROR_INVALID_FUNCTION = 1      # Gerät kennt diesen Steuercode nicht
-ERROR_MEDIA_CHANGED = 1110
-ERROR_NO_MEDIA_IN_DRIVE = 1112
-
-# ── GetDriveTypeW ───────────────────────────────────────────────────────
-DRIVE_UNKNOWN = 0
-DRIVE_NO_ROOT_DIR = 1
-DRIVE_REMOVABLE = 2
-DRIVE_FIXED = 3
-DRIVE_REMOTE = 4
-DRIVE_CDROM = 5
-DRIVE_RAMDISK = 6
-
-# ── CreateFileW ─────────────────────────────────────────────────────────
-GENERIC_READ = 0x80000000
-FILE_SHARE_READ = 0x00000001
-FILE_SHARE_WRITE = 0x00000002
-OPEN_EXISTING = 3
-INVALID_HANDLE_VALUE = -1
-
-
-def geraetepfad(buchstabe: str) -> str:
-    r"""„D:" oder „D" oder „D:\" -> r"\\.\D:"
-
-    Der Win32-Gerätepfad hat KEINEN abschließenden Backslash. Mit einem
-    öffnet `CreateFileW` das Wurzelverzeichnis des Dateisystems statt des
-    Geräts — die IOCTLs scheitern dann mit ERROR_INVALID_FUNCTION, was wie
-    „das Laufwerk kann das nicht" aussieht.
-    """
-    kern = (buchstabe or "").strip().rstrip("\\/").rstrip(":")
-    if not kern:
-        raise ValueError("Kein Laufwerksbuchstabe angegeben")
-    return "\\\\.\\" + kern[0].upper() + ":"

src/rippy/drives/windows.py

@@ -1,411 +0,0 @@
-r"""Laufwerks-Treiber für Windows. Erfüllt `rippy.ports.Drives`.
-
-Dieselben Verträge wie `linux.py`, nur mit Win32 statt ioctl:
-
-    auswerfen_versuchen(geraet) -> bool     gibt False zurück, wirft nie
-    eject(geraet)               -> None     wirft OSError
-
-## Warum ctypes und nicht pywin32
-
-pywin32 wäre eine zusätzliche Abhängigkeit von rund 20 MB, die in ein
-PyInstaller-Paket mit hinein muss und bei jedem Python-Wechsel neu passen
-will. Alles, was hier gebraucht wird, sind fünf Funktionen aus `kernel32.dll` —
-die spricht `ctypes` direkt an, ohne irgendetwas mitzuliefern.
-
-## Die zwei Regeln des Ports gelten hier genauso
-
-**1. Auswerfen heißt: entriegeln, auswerfen, NACHSEHEN.** Unter Linux wurde am
-26.07.2026 gemessen, dass ein verriegeltes Laufwerk den Auswurf mit ERFOLG
-quittiert und nichts tut — MakeMKV verriegelt die Tür während des Rips und
-entriegelt sie nicht wieder. Es gibt keinen Grund anzunehmen, dass Windows das
-anders handhabt: `IOCTL_STORAGE_EJECT_MEDIA` meldet ebenfalls nur, dass der
-Befehl angenommen wurde. Deshalb wird auch hier nachgesehen — der Beweis ist
-`IOCTL_STORAGE_CHECK_VERIFY2`, das bei leerem Laufwerk `ERROR_NOT_READY`
-liefert.
-
-**2. Ein unbekannter Zustand heißt UNBEKANNT, nicht leer.** Wenn sich das Gerät
-nicht öffnen lässt oder ein Steuercode scheitert, ist die Antwort „ich weiß es
-nicht" — nicht „da ist keine Disc". Genau diese Vermischung hat in v1 die
-Listen im UI geleert.
-
-## Was hier geprüft ist und was nicht
-
-**Ohne Laufwerk geprüft:** die Steuercodes (`test_win_ioctl.py` rechnet sie
-gegen die Dokumentation), der Ablauf des Auswurfs, die Fehlerunterscheidung,
-die Typ-Zuordnung — alles über eine eingespritzte Win32-Nachbildung
-(`test_windows.py`). Diese Tests laufen auf jeder Plattform.
-
-**An echter Hardware gemessen (28.08.2026, LG BU40N extern am Windows-PC,
-Laufwerk G:, LEER):**
-
-    GetDriveTypeW("G:\")                       -> 5 (DRIVE_CDROM)
-    list_optical_devices()                     -> ['\.\G:']
-    CreateFileW(r"\.\G:")                   -> Handle 380
-    CHECK_VERIFY2 bei leerem Laufwerk          -> ERROR_NOT_READY (21)
-    drive_status()                             -> 1 (CDS_NO_DISC)
-    detect_disc_type()                         -> 'no_disc'
-    device_info()['status']                    -> 'empty'
-    MEDIA_REMOVAL (entriegeln)                 -> Erfolg,   0,1 ms
-    EJECT_MEDIA                                -> Erfolg, 664,8 ms
-
-Die 664,8 ms sind der eigentliche Beleg, dass etwas passiert ist: Ein
-abgelehnter Steuercode kommt in rund 2 ms zurück (siehe die Fehler oben).
-Eine mechanische Bewegung dauert.
-
-**⚠️ DIESES LAUFWERK KANN DIE SCHUBLADE NICHT SELBST EINZIEHEN.**
-`IOCTL_STORAGE_LOAD_MEDIA` antwortet mit `ERROR_INVALID_FUNCTION` (1) — bei
-flachen und extern angeschlossenen Laufwerken ist das die Regel, nicht die
-Ausnahme. Deshalb gibt es hier bewusst KEINE `einziehen()`-Funktion: Ein Knopf
-„Schublade schließen", der auf der Hälfte aller Laufwerke stillschweigend
-nichts tut, wäre genau die Sorte Placebo, die in Etappe 19 aufgeräumt wurde.
-Die Konstante steht in `win_ioctl.py` — wer sie je benutzt, muss den Fehlschlag
-sichtbar machen.
-
-**MIT EINGELEGTER DISC gemessen (28.08.2026, dasselbe Laufwerk, BD-50):**
-
-    drive_status()                             -> 4 (CDS_DISC_OK), sofort
-    IOCTL_CDROM_DISK_TYPE                      -> Bytes 02 00 00 00
-                                                  = DATA_TRACK (0x2)
-    IOCTL_DISK_GET_LENGTH_INFO                 -> 48 149 364 736 Bytes
-                                                  = 44,84 GiB
-    disc_status()                              -> 101 (CDS_DATA_1)
-    detect_disc_type()                         -> 'bluray'
-    device_info()['status']                    -> 'ready'
-    device_info()['type']                      -> 'bluray'
-
-    auswerfen_versuchen()                      -> True, 2,41 s
-    drive_status() davor / danach              -> 4 / 1
-
-**Die letzte Zeile ist der eigentliche Beweis.** Der Auswurf wurde nicht am
-Rückgabewert des Steuercodes festgemacht, sondern am ZUSTAND davor und
-danach: Die Disc war drin (4) und ist danach draußen (1). Genau das, was in
-v1 monatelang gefehlt hat — dort quittierte das ioctl Erfolg, die Schublade
-blieb zu, und im Log stand „Disc ausgeworfen".
-
-Die 44,84 GiB prüfen nebenbei die Schwelle mit: Eine BD-50 liegt knapp unter
-den 55 GiB, ab denen `cdrom.classify()` auf `uhd` geht — und wird korrekt als
-`bluray` eingeordnet.
-
-**Damit gilt die Hardware-Schicht dieses Treibers als BEWIESEN**, nicht mehr
-nur als gebaut. Offen bleibt allein die Ereignis-Erkennung
-(`WM_DEVICECHANGE`) — die wird erst gebaut.
-"""
-
-import sys
-
-from rippy.drives import win_ioctl as w
-from rippy.drives.cdrom import (
-    CDS_AUDIO,
-    CDS_DATA_1,
-    CDS_DISC_OK,
-    CDS_NO_DISC,
-    classify,
-)
-
-# Wie lange nach dem Auswurf-Befehl auf die Schublade gewartet wird.
-# Gleicher Wert wie unter Linux — ein Laufwerk braucht ein bis zwei Sekunden.
-AUSWURF_WARTEN_SEKUNDEN = 5
-
-# Ergebnisse von auswerfen_mit_grund — dieselben wie im Linux-Treiber, damit
-# aufrufender Code nicht wissen muss, auf welcher Plattform er läuft.
-AUSWURF_OK = "ok"
-AUSWURF_KEIN_ZUGRIFF = "kein-zugriff"
-AUSWURF_ABGELEHNT = "abgelehnt"
-AUSWURF_BLEIBT_DRIN = "bleibt-drin"
-
-
-class Win32Fehler(OSError):
-    """Ein fehlgeschlagener Win32-Aufruf, mit dem Code von GetLastError().
-
-    ⚠️ Die Zuweisung MUSS nach `super().__init__()` stehen. Nachgemessen:
-    Ein zweiargumentiges `OSError.__init__(code, text)` setzt `winerror`
-    wieder auf `None` — ein davor gesetzter Wert ist danach fort. Genau
-    daran sind beim Bau dieser Datei vier Tests gescheitert: `_medium_da`
-    erkannte `ERROR_NOT_READY` nicht mehr, hielt jedes leere Laufwerk für
-    einen echten Fehler und meldete „unbekannt" statt „leer".
-
-    `code` steht zusätzlich als eigener Name bereit — `winerror` gibt es nur
-    unter Windows, und dieser Treiber wird auch anderswo getestet.
-    """
-
-    def __init__(self, was: str, code: int):
-        super().__init__(code, f"{was} scheiterte (Win32-Fehler {code})")
-        self.code = code
-        self.winerror = code
-
-
-class Win32:
-    """Die echten kernel32-Aufrufe.
-
-    In Tests wird stattdessen eine Nachbildung eingesetzt — deshalb steckt
-    hier NUR die Anbindung und keine Entscheidung. Was der Treiber tut, steht
-    in den Funktionen darunter und ist damit ohne Windows prüfbar.
-    """
-
-    def __init__(self):
-        if not sys.platform.startswith("win"):
-            raise RuntimeError(
-                "Der Windows-Treiber laeuft nur unter Windows. Auf Linux ist "
-                "rippy.drives.linux zustaendig."
-            )
-        import ctypes
-        from ctypes import wintypes
-
-        self._ctypes = ctypes
-        self._wintypes = wintypes
-        self._k32 = ctypes.WinDLL("kernel32", use_last_error=True)
-
-    # ── Laufwerke finden ────────────────────────────────────────────────
-    def laufwerksbuchstaben(self) -> list:
-        maske = self._k32.GetLogicalDrives()
-        return [chr(ord("A") + i) for i in range(26) if maske & (1 << i)]
-
-    def laufwerkstyp(self, buchstabe: str) -> int:
-        return self._k32.GetDriveTypeW(f"{buchstabe}:\\")
-
-    # ── Gerät öffnen ────────────────────────────────────────────────────
-    def oeffnen(self, geraetepfad: str):
-        handle = self._k32.CreateFileW(
-            geraetepfad,
-            w.GENERIC_READ,
-            w.FILE_SHARE_READ | w.FILE_SHARE_WRITE,
-            None,
-            w.OPEN_EXISTING,
-            0,
-            None,
-        )
-        if handle == w.INVALID_HANDLE_VALUE or handle in (0, None):
-            raise Win32Fehler("CreateFileW", self._ctypes.get_last_error())
-        return handle
-
-    def schliessen(self, handle) -> None:
-        self._k32.CloseHandle(handle)
-
-    # ── Steuercode senden ───────────────────────────────────────────────
-    def steuern(self, handle, code: int, eingabe: bytes = b"",
-                ausgabe_bytes: int = 0) -> bytes:
-        """DeviceIoControl. Wirft Win32Fehler, gibt sonst die Antwort zurück."""
-        ctypes = self._ctypes
-        ein_puffer = ctypes.create_string_buffer(eingabe) if eingabe else None
-        aus_puffer = ctypes.create_string_buffer(ausgabe_bytes) if ausgabe_bytes else None
-        zurueck = self._wintypes.DWORD(0)
-        erfolg = self._k32.DeviceIoControl(
-            handle, code,
-            ein_puffer, len(eingabe),
-            aus_puffer, ausgabe_bytes,
-            ctypes.byref(zurueck), None,
-        )
-        if not erfolg:
-            raise Win32Fehler(f"DeviceIoControl({code:#x})", ctypes.get_last_error())
-        return aus_puffer.raw[:zurueck.value] if aus_puffer else b""
-
-
-def _api(api):
-    return api if api is not None else Win32()
-
-
-# ── Laufwerke finden ────────────────────────────────────────────────────
-def list_optical_devices(api=None) -> list:
-    """Alle optischen Laufwerke — als Gerätepfade wie r"\\\\.\\D:".
-
-    Kein Scan über alle 26 Buchstaben mit Öffnen-Versuch: `GetDriveTypeW`
-    beantwortet die Frage ohne jeden Zugriff auf das Gerät. Ein Öffnen-Versuch
-    auf einem leeren Laufwerk kann sonst mehrere Sekunden dauern (das Laufwerk
-    fährt hoch), und das mal 26.
-    """
-    api = _api(api)
-    return sorted(
-        w.geraetepfad(b) for b in api.laufwerksbuchstaben()
-        if api.laufwerkstyp(b) == w.DRIVE_CDROM
-    )
-
-
-# ── Zustand ─────────────────────────────────────────────────────────────
-def _medium_da(api, handle) -> bool:
-    """Liegt eine Disc ein? Wirft Win32Fehler bei allem außer NOT_READY."""
-    try:
-        api.steuern(handle, w.IOCTL_STORAGE_CHECK_VERIFY2)
-        return True
-    except Win32Fehler as e:
-        if e.code in (w.ERROR_NOT_READY, w.ERROR_NO_MEDIA_IN_DRIVE):
-            return False
-        raise
-
-
-def drive_status(geraet: str, api=None) -> int:
-    """Wie `linux.detection.drive_status`: CDS_DISC_OK oder CDS_NO_DISC.
-
-    Wirft, wenn der Zustand NICHT feststellbar ist. Der Aufrufer muss
-    entscheiden, was er damit macht — ein stilles „leer" wäre eine falsche
-    Aussage über die Welt.
-    """
-    api = _api(api)
-    handle = api.oeffnen(geraet)
-    try:
-        return CDS_DISC_OK if _medium_da(api, handle) else CDS_NO_DISC
-    finally:
-        api.schliessen(handle)
-
-
-def disc_status(geraet: str, api=None) -> int:
-    """Audio- oder Datenträger — übersetzt in die CDS_*-Werte von cdrom.py.
-
-    Damit passt das Ergebnis in dieselbe `classify()`, die der Linux-Treiber
-    benutzt: EINE Zuordnungslogik für beide Plattformen, und die ist getestet.
-    """
-    api = _api(api)
-    handle = api.oeffnen(geraet)
-    try:
-        antwort = api.steuern(handle, w.IOCTL_CDROM_DISK_TYPE, ausgabe_bytes=4)
-        flags = int.from_bytes(antwort[:4], "little") if antwort else 0
-    finally:
-        api.schliessen(handle)
-    if flags & w.CDROM_DISK_AUDIO_TRACK:
-        return CDS_AUDIO
-    if flags & w.CDROM_DISK_DATA_TRACK:
-        return CDS_DATA_1
-    return 0                       # unbekannt -> classify() sagt "unknown"
-
-
-def disc_size_bytes(geraet: str, api=None) -> int:
-    """Größe des eingelegten Mediums — die Entsprechung von BLKGETSIZE64.
-
-    Sie entscheidet zwischen DVD, Blu-ray und 4K-UHD (Schwellen in cdrom.py).
-    """
-    api = _api(api)
-    handle = api.oeffnen(geraet)
-    try:
-        antwort = api.steuern(handle, w.IOCTL_DISK_GET_LENGTH_INFO, ausgabe_bytes=8)
-        return int.from_bytes(antwort[:8], "little") if antwort else 0
-    finally:
-        api.schliessen(handle)
-
-
-def detect_disc_type(geraet: str, api=None) -> str:
-    """cd | dvd | bluray | uhd | no_disc | unknown."""
-    api = _api(api)
-    try:
-        if drive_status(geraet, api) != CDS_DISC_OK:
-            return "no_disc"
-        return classify(disc_status(geraet, api), disc_size_bytes(geraet, api))
-    except OSError:
-        # „konnte nicht nachsehen" — ausdruecklich NICHT "no_disc".
-        return "unknown"
-
-
-# ── Verriegeln ──────────────────────────────────────────────────────────
-def verriegeln(geraet: str, an: bool, api=None) -> None:
-    """Tür verriegeln (True) oder entriegeln (False).
-
-    `PREVENT_MEDIA_REMOVAL` ist eine Struktur mit genau einem BOOLEAN.
-    """
-    api = _api(api)
-    handle = api.oeffnen(geraet)
-    try:
-        api.steuern(handle, w.IOCTL_STORAGE_MEDIA_REMOVAL,
-                    eingabe=b"\x01" if an else b"\x00")
-    finally:
-        api.schliessen(handle)
-
-
-# ── Auswerfen ───────────────────────────────────────────────────────────
-def auswerfen_mit_grund(geraet: str, api=None, warten=None):
-    """Die gemeinsame Mechanik. Wirft NIE.
-
-    Rückgabe `(grund, fehler)` wie im Linux-Treiber. Reihenfolge ist
-    dieselbe und aus demselben Grund: **entriegeln, auswerfen, nachsehen.**
-    """
-    api = _api(api)
-    if warten is None:
-        import time
-        warten = time.sleep
-
-    try:
-        handle = api.oeffnen(geraet)
-    except OSError as e:
-        return AUSWURF_KEIN_ZUGRIFF, e
-
-    try:
-        # Entriegeln zuerst. Scheitert es, wird der Auswurf trotzdem versucht —
-        # bei einem nicht verriegelten Laufwerk klappt er ohnehin.
-        try:
-            api.steuern(handle, w.IOCTL_STORAGE_MEDIA_REMOVAL, eingabe=b"\x00")
-        except OSError:
-            pass
-
-        try:
-            api.steuern(handle, w.IOCTL_STORAGE_EJECT_MEDIA)
-        except OSError as e:
-            return AUSWURF_ABGELEHNT, e
-
-        # NACHSEHEN. Der Befehl oben meldet nur, dass er angenommen wurde.
-        for _ in range(AUSWURF_WARTEN_SEKUNDEN):
-            try:
-                if not _medium_da(api, handle):
-                    return AUSWURF_OK, None
-            except OSError as e:
-                return AUSWURF_ABGELEHNT, e
-            warten(1)
-        return AUSWURF_BLEIBT_DRIN, None
-    finally:
-        try:
-            api.schliessen(handle)
-        except OSError:
-            pass
-
-
-def auswerfen_versuchen(geraet: str, api=None, warten=None) -> bool:
-    """Wirft die Disc aus und prüft nach. Wirft NIE — Vertrag des Workers."""
-    grund, _ = auswerfen_mit_grund(geraet, api=api, warten=warten)
-    return grund == AUSWURF_OK
-
-
-def eject(geraet: str, api=None) -> None:
-    """Wirft die Disc aus. Wirft OSError, wenn sie drin bleibt — Vertrag der API."""
-    grund, fehler = auswerfen_mit_grund(geraet, api=api)
-    if grund == AUSWURF_OK:
-        return
-    if fehler is not None:
-        raise fehler
-    if grund == AUSWURF_KEIN_ZUGRIFF:
-        raise OSError(f"Das Laufwerk {geraet} ließ sich nicht ansprechen.")
-    raise OSError(
-        "Das Laufwerk hat den Auswurf angenommen, die Disc ist aber noch "
-        "drin. Blockiert etwas die Schublade, oder läuft noch ein Zugriff?"
-    )
-
-
-# ── Für das UI ──────────────────────────────────────────────────────────
-def device_info(geraet: str, api=None) -> dict:
-    """Der Geräte-Eintrag fürs UI — gleiche Felder wie beim Linux-Treiber.
-
-    `status` kennt hier drei Werte, nicht zwei: `ready`, `empty` und
-    **`unknown`**. Der dritte ist Absicht — ein Laufwerk, das sich nicht
-    ansprechen lässt (belegt, gerade angesteckt, defekt), ist nicht leer.
-    """
-    api = _api(api)
-    status = "unknown"
-    disc_typ = "unknown"
-    try:
-        if drive_status(geraet, api) == CDS_DISC_OK:
-            status = "ready"
-            try:
-                disc_typ = classify(disc_status(geraet, api),
-                                    disc_size_bytes(geraet, api))
-            except OSError:
-                disc_typ = "unknown"
-        else:
-            status = "empty"
-    except OSError:
-        status = "unknown"
-
-    buchstabe = geraet.rstrip(":").rsplit("\\", 1)[-1].rstrip(":")
-    return {
-        "id": buchstabe,
-        "name": f"Laufwerk {buchstabe}:",
-        "type": disc_typ,
-        "path": geraet,
-        "status": status,
-        "model": "",
-        "serial": "",
-    }

src/rippy/pfade.py

@@ -0,0 +1,103 @@
+r"""Pfade nach IHREN Regeln behandeln, nicht nach denen der laufenden Maschine.
+
+## Warum es dieses Modul gibt (28.08.2026, zweimal bezahlt)
+
+`os.path` richtet sich nach der Plattform, auf der es gerade läuft. Das ist
+fast immer richtig — und in diesem Projekt an drei Stellen falsch, weil dort
+über Pfade einer ANDEREN Maschine gerechnet wird:
+
+* `tools/katalog.py` baut Windows-Installationsorte (`C:\Program Files\…`).
+  Auf dem Linux-Runner der Ampel wurde daraus
+  `C:\Program Files (x86)\MakeMKV/makemkvcon64.exe` — ein Pfad, den es auf
+  keiner Maschine gibt. Fünf Tests rot, und zwar NUR auf Linux.
+* `platform/verknuepfungen.py` leitet den Arbeitsordner einer `.lnk` ab. Eine
+  `.lnk` zeigt IMMER auf einen Windows-Pfad, auch wenn der Code gerade auf
+  Linux läuft. `os.path.dirname` gab dort einen leeren String.
+* `betrieb.py` vergleicht Laufwerksbuchstaben und sucht das nächste
+  vorhandene Elternverzeichnis. Auf Linux kannte `splitdrive` kein `D:`, und
+  `dirname` zerlegte `C:\Users\Test\…` nicht.
+
+Dreimal dasselbe Muster, dreimal einzeln repariert. Beim dritten Mal gehört
+es an EINE Stelle — sonst kommt es ein viertes Mal wieder.
+
+## Die Regel
+
+**Der Pfad entscheidet, nicht der Rechner.** Ein Laufwerksbuchstabe oder ein
+Backslash heißt Windows; alles andere heißt POSIX.
+"""
+
+import ntpath
+import posixpath
+
+
+def ist_windows_pfad(pfad: str) -> bool:
+    r"""`C:\…` oder irgendein Backslash — dann ist es ein Windows-Pfad."""
+    pfad = pfad or ""
+    return "\\" in pfad or (len(pfad) > 1 and pfad[1] == ":")
+
+
+def _modul(pfad: str):
+    return ntpath if ist_windows_pfad(pfad) else posixpath
+
+
+def verbinden(basis: str, *teile) -> str:
+    r"""Pfadteile mit dem Trenner der BASIS verbinden.
+
+    Achtung, Windows-Eigenheit: `verbinden("D:", "Rippy")` ergibt `D:Rippy`,
+    NICHT `D:\Rippy`. `D:` ohne Backslash bedeutet „der aktuelle Ordner auf
+    Laufwerk D" — `ntpath.join` setzt deshalb absichtlich keinen Trenner. Das
+    ist richtig so, auch wenn es überrascht.
+    """
+    return _modul(basis).join(basis, *teile)
+
+
+def ordner_von(datei: str) -> str:
+    """Der Ordner einer Datei — nach dem Trenner der DATEI."""
+    return _modul(datei).dirname(datei)
+
+
+def laufwerk_von(pfad: str) -> str:
+    r"""Der Laufwerksteil (`C:`, `\\server\freigabe`) — leer bei POSIX-Pfaden.
+
+    Für die Frage „liegen zwei Pfade auf demselben Laufwerk". Zwei leere
+    Ergebnisse heißen dabei „beide POSIX" und damit ebenfalls: dasselbe.
+    """
+    return _modul(pfad).splitdrive(pfad)[0]
+
+
+def gleiches_laufwerk(a: str, b: str) -> bool:
+    """Liegen beide auf demselben Laufwerk? (ohne Rücksicht auf Groß/Klein)"""
+    return laufwerk_von(a).lower() == laufwerk_von(b).lower()
+
+
+def naechster_vorhandener(pfad: str, existiert=None) -> str:
+    """Der nächste Ordner nach oben, den es WIRKLICH gibt. "" wenn keiner.
+
+    Frisch installiert gibt es den Ablage-Ordner noch nicht — `disk_usage`
+    wirft dann, und im Dashboard stand „unbekannt". Der Nutzer will aber
+    wissen, ob auf dem LAUFWERK Platz ist, und das lässt sich beantworten.
+    """
+    import os
+
+    existiert = existiert or os.path.isdir
+    modul = _modul(pfad)
+    pfad = (pfad or "").strip()
+    # Den Schluss-Trenner nur abstreifen, wenn danach mehr uebrig bleibt als
+    # der blosse Laufwerksname. Aus "F:\" wurde sonst "F:", und das ist
+    # unter Windows der AKTUELLE Ordner auf Laufwerk F, nicht dessen Wurzel
+    # (siehe `verbinden`). Dieselbe Falle kostete am 30.08.2026 in
+    # `rohdaten.kandidaten` 16,5 GB Sichtbarkeit. Fuer UNC gilt dasselbe:
+    # aus "\\server\freigabe\" darf kein Ort ohne Trenner werden.
+    gekuerzt = pfad.rstrip("\\/")
+    if gekuerzt and gekuerzt != modul.splitdrive(pfad)[0]:
+        pfad = gekuerzt
+    gesehen = set()
+    while pfad and pfad not in gesehen:
+        if existiert(pfad):
+            return pfad
+        gesehen.add(pfad)
+        eltern = modul.dirname(pfad)
+        if eltern == pfad:                    # Wurzel erreicht
+            break
+        pfad = eltern
+    return ""

src/rippy/platform/dateiangaben.py

@@ -0,0 +1,124 @@
+"""Was eine Windows-Datei über sich selbst sagt — und warum das hier zählt.
+
+## Wozu (28.08.2026)
+
+Rippy lädt den MakeMKV-Installer notfalls aus einer Ausweichquelle, weil
+makemkv.com tagelang mit HTTP 525 antwortet. Eine Datei von woanders zu
+holen und ungeprüft auszuführen wäre leichtsinnig.
+
+Der naheliegende Schutz — die digitale Signatur — geht NICHT:
+
+    Get-AuthenticodeSignature Setup_MakeMKV_v1.18.4.exe
+    Status: NotSigned
+
+Am 28.08.2026 an der echten Datei gemessen: **MakeMKV signiert seinen
+Installer nicht.** Eine Signaturprüfung wäre also eine Prüfung, die immer
+fehlschlägt — schlimmer als keine, weil sie Sicherheit vortäuscht und dann
+den richtigen Weg blockiert.
+
+Prüfbar ist die **Versions-Ressource**. An derselben Datei gemessen:
+
+    CompanyName      GuinpinSoft inc
+    FileDescription  MakeMKV installer
+    FileVersion      v1.18.4
+    ProductName      MakeMKV
+
+Das ist kein Ersatz für eine Signatur — wer die Datei fälscht, kann auch die
+Ressource fälschen. Aber es fängt zuverlässig ab, was hier wirklich droht:
+eine Fehlerseite, ein umbenanntes Archiv, eine falsche Version, ein
+abgebrochener Download. Und es sagt dem Nutzer, WAS er da bekommen hat.
+"""
+
+import os
+
+FELDER = ("CompanyName", "FileDescription", "FileVersion", "ProductName",
+          "ProductVersion")
+
+
+def versionsangaben(pfad: str) -> dict:
+    """Die Versions-Ressource einer Windows-Datei. Leer, wenn keine da ist.
+
+    Wirft nicht: Eine Datei ohne Ressource ist ein gültiges Ergebnis (und
+    genau das, was eine Fehlerseite mit `.exe`-Namen hätte).
+    """
+    if os.name != "nt" or not os.path.isfile(pfad):
+        return {}
+    import ctypes
+
+    try:
+        version = ctypes.WinDLL("version")
+        groesse = version.GetFileVersionInfoSizeW(pfad, None)
+        if not groesse:
+            return {}
+        puffer = ctypes.create_string_buffer(groesse)
+        if not version.GetFileVersionInfoW(pfad, 0, groesse, puffer):
+            return {}
+
+        zeiger = ctypes.c_void_p()
+        laenge = ctypes.c_uint()
+        if not version.VerQueryValueW(puffer, r"\VarFileInfo\Translation",
+                                      ctypes.byref(zeiger), ctypes.byref(laenge)):
+            return {}
+        paar = ctypes.cast(zeiger, ctypes.POINTER(ctypes.c_uint16))
+        sprache = "%04x%04x" % (paar[0], paar[1])
+
+        ergebnis = {}
+        for feld in FELDER:
+            z = ctypes.c_void_p()
+            n = ctypes.c_uint()
+            pfad_im_block = "\\StringFileInfo\\%s\\%s" % (sprache, feld)
+            if version.VerQueryValueW(puffer, pfad_im_block,
+                                      ctypes.byref(z), ctypes.byref(n)) and n.value:
+                ergebnis[feld] = ctypes.wstring_at(z.value, n.value - 1).strip()
+        return ergebnis
+    except (AttributeError, OSError, ValueError):
+        return {}
+
+
+def ist_programm(pfad: str) -> bool:
+    """Fängt die Datei mit `MZ` an? (Das tut jedes Windows-Programm.)
+
+    Der billigste und wirksamste Test gegen das, was wirklich passiert: eine
+    HTML-Fehlerseite, die unter dem Namen `Setup_MakeMKV_v1.18.4.exe`
+    gespeichert wurde.
+    """
+    try:
+        with open(pfad, "rb") as f:
+            return f.read(2) == b"MZ"
+    except OSError:
+        return False
+
+
+# ── Die Prüfung als reine Funktion ──────────────────────────────────────
+def passt(angaben: dict, firma: str = "", produkt: str = "",
+          version: str = "") -> tuple:
+    """Passen die Angaben zu dem, was erwartet wird? (ja/nein, Begründung)
+
+    Reine Funktion — damit jeder Fall prüfbar ist, ohne eine Datei zu haben.
+    Leere Erwartungen werden nicht geprüft: Wer nichts fordert, bekommt kein
+    Urteil vorgesetzt.
+    """
+    if not angaben:
+        return False, "Die Datei hat keine Versionsangaben — das ist kein " \
+                      "Installationsprogramm, sondern vermutlich eine Fehlerseite."
+
+    gefunden_firma = angaben.get("CompanyName", "")
+    if firma and firma.lower() not in gefunden_firma.lower():
+        return False, ("Die Datei stammt laut ihren eigenen Angaben von "
+                       "%r, erwartet war %r." % (gefunden_firma or "niemandem", firma))
+
+    text = " ".join(angaben.get(f, "") for f in
+                    ("ProductName", "FileDescription")).lower()
+    if produkt and produkt.lower() not in text:
+        return False, ("Die Datei bezeichnet sich als %r, erwartet war %r."
+                       % (text.strip() or "nichts", produkt))
+
+    if version:
+        gefunden = (angaben.get("FileVersion") or
+                    angaben.get("ProductVersion") or "").lstrip("vV")
+        if gefunden and not gefunden.startswith(version):
+            return False, ("Die Datei ist Fassung %s, erwartet war %s."
+                           % (gefunden, version))
+
+    return True, "%s %s" % (angaben.get("ProductName", "?"),
+                            angaben.get("FileVersion", "?"))

src/rippy/platform/test_dateiangaben.py

@@ -0,0 +1,98 @@
+"""Was eine Windows-Datei ueber sich selbst sagt.
+
+## Warum das geprueft wird
+
+Rippy laedt den MakeMKV-Installer notfalls aus einer Ausweichquelle, weil
+makemkv.com tagelang mit HTTP 525 antwortet. Eine Datei von woanders zu holen
+und ungeprueft auszufuehren waere leichtsinnig.
+
+Der naheliegende Schutz -- die digitale Signatur -- geht NICHT: Am 28.08.2026
+an der echten Datei gemessen, `Get-AuthenticodeSignature` sagt `NotSigned`.
+MakeMKV signiert seinen Installer nicht. Eine Signaturpruefung waere also eine
+Pruefung, die immer fehlschlaegt.
+
+Geprueft wird deshalb die Versions-Ressource. An derselben Datei gemessen:
+
+    CompanyName      GuinpinSoft inc
+    FileDescription  MakeMKV installer
+    FileVersion      v1.18.4
+
+Alle Pruefungen hier sind rein -- keine Datei noetig, laeuft auf jeder
+Plattform.
+"""
+
+import os
+
+from rippy.platform import dateiangaben as d
+
+ECHT = {
+    "CompanyName": "GuinpinSoft inc",
+    "FileDescription": "MakeMKV installer",
+    "FileVersion": "v1.18.4",
+    "ProductName": "MakeMKV",
+}
+
+
+def test_die_echte_datei_wird_erkannt():
+    gut, grund = d.passt(ECHT, firma="GuinpinSoft", produkt="MakeMKV",
+                         version="1.18.4")
+    assert gut is True, grund
+    assert "1.18.4" in grund
+
+
+def test_ohne_versionsangaben_ist_es_keine_programmdatei():
+    """Das ist der haeufigste Fall: eine Fehlerseite mit .exe-Namen."""
+    gut, grund = d.passt({}, firma="GuinpinSoft")
+    assert gut is False
+    assert "Fehlerseite" in grund
+
+
+def test_fremde_firma_wird_abgelehnt():
+    fremd = dict(ECHT, CompanyName="Irgendwer GmbH")
+    gut, grund = d.passt(fremd, firma="GuinpinSoft")
+    assert gut is False
+    assert "Irgendwer" in grund
+
+
+def test_falsche_version_wird_abgelehnt():
+    """Ein Archiv-Schnappschuss koennte eine aeltere Fassung liefern."""
+    gut, grund = d.passt(ECHT, firma="GuinpinSoft", version="1.19.0")
+    assert gut is False
+    assert "1.18.4" in grund and "1.19.0" in grund
+
+
+def test_fremdes_produkt_wird_abgelehnt():
+    fremd = dict(ECHT, ProductName="Notepad", FileDescription="Editor")
+    gut, _ = d.passt(fremd, firma="GuinpinSoft", produkt="MakeMKV")
+    assert gut is False
+
+
+def test_ohne_erwartung_wird_nichts_geurteilt():
+    """Wer nichts fordert, bekommt kein Urteil vorgesetzt."""
+    gut, _ = d.passt(ECHT)
+    assert gut is True
+
+
+def test_das_v_vor_der_version_stoert_nicht():
+    """Die Datei meldet 'v1.18.4', erwartet wird '1.18.4'."""
+    gut, _ = d.passt(ECHT, version="1.18.4")
+    assert gut is True
+
+
+def test_mz_pruefung_an_einer_echten_datei(tmp_path):
+    programm = tmp_path / "p.exe"
+    programm.write_bytes(b"MZ" + b"\x00" * 100)
+    assert d.ist_programm(str(programm)) is True
+
+    seite = tmp_path / "fehler.exe"
+    seite.write_bytes(b"<html>525</html>")
+    assert d.ist_programm(str(seite)) is False
+
+    assert d.ist_programm(str(tmp_path / "gibt-es-nicht.exe")) is False
+
+
+def test_versionsangaben_ohne_windows_sind_leer():
+    if os.name == "nt":
+        import pytest
+        pytest.skip("prueft das Verhalten auf Nicht-Windows")
+    assert d.versionsangaben("/bin/sh") == {}

src/rippy/platform/test_verknuepfungen.py

@@ -1,129 +0,0 @@
-"""Verknuepfungen: der Ordner, das Skript, das Zurueckraeumen.
-
-Das PowerShell-Skript wird als reine Funktion gebaut und geprueft — so faellt
-ein Zitier-Fehler auf, ohne dass eine .lnk entstehen muss. Die Tests, die
-wirklich eine anlegen, laufen nur unter Windows und raeumen hinter sich auf.
-
-Hinweis zu den Pfaden: Windows-Pfade stehen hier in ROHEN Zeichenketten oder
-werden aus `B` (dem Backslash) zusammengesetzt. In normalen Zeichenketten
-waeren `C:\\D` und `C:\\Users` ungueltige Escape-Sequenzen — heute eine
-DeprecationWarning, in einer kuenftigen Python-Version ein harter Fehler.
-"""
-
-import os
-
-import pytest
-
-from rippy.platform import verknuepfungen as vk
-
-nur_windows = pytest.mark.skipif(os.name != "nt", reason="nur unter Windows")
-
-B = chr(92)          # Backslash — haelt jede Escape-Falle aus den Tests raus
-
-
-# ── Das Skript ──────────────────────────────────────────────────────────
-def test_skript_setzt_ziel_und_argumente():
-    lnk = "C:" + B + "D" + B + "Rippy.lnk"
-    exe = "C:" + B + "R" + B + "Rippy.exe"
-    s = vk.skript(lnk, exe, "--oeffnen")
-    assert "CreateShortcut('" + lnk + "')" in s
-    assert "$s.TargetPath = '" + exe + "'" in s
-    assert "$s.Arguments = '--oeffnen'" in s
-    assert s.rstrip().endswith("$s.Save()")
-
-
-def test_apostroph_im_pfad_bricht_das_skript_nicht():
-    """In PowerShell wird ein Apostroph innerhalb einfacher Anfuehrungszeichen
-    durch VERDOPPELN maskiert. Ohne das bricht ein Pfad mit Apostroph das
-    Skript mitten entzwei — und der Fehler sieht aus wie ein Syntaxfehler in
-    Rippy statt wie ein Pfad, der ein Sonderzeichen enthaelt."""
-    s = vk.skript("C:" + B + "Users" + B + "O'Brien" + B + "Rippy.lnk",
-                  "C:" + B + "R" + B + "Rippy.exe")
-    assert "O''Brien" in s
-    # Gerade Zahl von Anfuehrungszeichen — sonst ist ein String offen.
-    assert s.count("'") % 2 == 0
-
-
-def test_ohne_arbeitsordner_wird_der_ordner_des_ziels_genommen():
-    ordner = "C:" + B + "Programme" + B + "Rippy"
-    s = vk.skript("C:" + B + "D" + B + "R.lnk", ordner + B + "Rippy.exe")
-    assert "$s.WorkingDirectory = '" + ordner + "'" in s
-
-
-def test_leere_angaben_erzeugen_keine_leeren_zeilen():
-    """Ein `$s.IconLocation = ''` wuerde das Symbol LOESCHEN statt es
-    unveraendert zu lassen."""
-    s = vk.skript("C:" + B + "D" + B + "R.lnk", "C:" + B + "R" + B + "R.exe")
-    assert "IconLocation" not in s
-    assert "Description" not in s
-
-
-# ── Die Orte ────────────────────────────────────────────────────────────
-@nur_windows
-def test_desktop_und_startmenue_kommen_aus_der_registry():
-    """Ein fest verdrahtetes %USERPROFILE%/Desktop waere eine ANNAHME. Wer
-    OneDrive benutzt oder seine Ordner verschoben hat, dessen Desktop liegt
-    woanders — die Verknuepfung landete dann in einem Ordner, den niemand
-    sieht, und der Nutzer suchte ein Symbol, das es nirgends gibt."""
-    desktop = vk.shell_ordner("Desktop")
-    programme = vk.shell_ordner("Programs")
-    assert desktop and os.path.isdir(desktop)
-    assert programme and os.path.isdir(programme)
-    assert vk.desktop_pfad().endswith("Rippy.lnk")
-    assert "Start Menu" in vk.startmenue_pfad()
-
-
-def test_unbekannter_ordner_ergibt_leer_statt_zu_raten():
-    assert vk.shell_ordner("GibtEsNicht") == ""
-
-
-# ── Wirklich anlegen ────────────────────────────────────────────────────
-@nur_windows
-def test_verknuepfung_entsteht_wirklich(tmp_path):
-    """Nachsehen statt glauben: PowerShell meldet auch dann Erfolg, wenn
-    Save() still scheitert. `anlegen()` prueft deshalb die Datei."""
-    exe = tmp_path / "Rippy.exe"
-    exe.write_bytes(b"x" * 512)
-    lnk = str(tmp_path / "Rippy.lnk")
-
-    assert vk.anlegen(lnk, str(exe), "--oeffnen", beschreibung="Test") is True
-    assert os.path.isfile(lnk)
-    assert os.path.getsize(lnk) > 0
-
-    assert vk.entfernen(lnk) is True
-    assert not os.path.exists(lnk)
-
-
-def _freier_laufwerksbuchstabe() -> str:
-    """Ein Buchstabe, den es auf DIESER Maschine wirklich nicht gibt.
-
-    Der erste Anlauf nahm fest `Z:` — auf dem Commander-PC ist das ein
-    NETZLAUFWERK (X, Y und Z sind dort belegt). Der Test legte damit
-    froehlich eine Verknuepfung auf einer Freigabe an und schlug fehl, weil
-    er einen Misserfolg erwartete. Ein fest verdrahteter Laufwerksbuchstabe
-    ist eine Annahme ueber eine fremde Maschine.
-    """
-    import ctypes
-
-    maske = ctypes.WinDLL("kernel32").GetLogicalDrives()
-    for i in range(25, -1, -1):                       # von Z rueckwaerts
-        if not (maske & (1 << i)):
-            return chr(ord("A") + i)
-    return ""
-
-
-@nur_windows
-def test_anlegen_auf_unmoeglichem_pfad_wirft_nicht(tmp_path):
-    """Eine fehlende Verknuepfung ist aergerlich, aber kein Grund, eine sonst
-    geglueckte Installation scheitern zu lassen."""
-    buchstabe = _freier_laufwerksbuchstabe()
-    if not buchstabe:
-        pytest.skip("Alle 26 Laufwerksbuchstaben sind belegt")
-    exe = tmp_path / "Rippy.exe"
-    exe.write_bytes(b"x")
-    assert vk.anlegen(buchstabe + ":" + B + "gibt-es-nicht" + B + "R.lnk",
-                      str(exe)) is False
-
-
-def test_entfernen_auf_nichts_ist_kein_fehler():
-    assert vk.entfernen("C:" + B + "gibt-es-nicht" + B + "R.lnk") is False

src/rippy/platform/test_win_registry.py

@@ -1,128 +0,0 @@
-"""Die Werte für „Programme und Features" — geprüft, bevor sie geschrieben werden.
-
-Die reinen Funktionen laufen auf jeder Plattform. Die Tests, die wirklich in
-die Registry schreiben, laufen nur unter Windows und räumen hinter sich auf —
-sie benutzen einen eigenen Schlüsselnamen, damit eine echte Installation
-niemals angefasst wird.
-"""
-
-import os
-
-import pytest
-
-from rippy.platform import win_registry as reg
-
-TEST_SCHLUESSEL = "RippyTestEintrag"      # NIE der echte
-nur_windows = pytest.mark.skipif(os.name != "nt", reason="Registry gibt es nur unter Windows")
-
-
-# ── Die Werte selbst ────────────────────────────────────────────────────
-def test_pflichtwerte_sind_gesetzt():
-    """Windows zeigt einen Eintrag OHNE DisplayName gar nicht an, und ohne
-    UninstallString ist der Deinstallieren-Knopf tot."""
-    werte = reg.eintrag_werte(r"C:\Rippy", r"C:\Rippy\RippySetup.exe", "2.0.0")
-    assert werte["DisplayName"]
-    assert werte["UninstallString"]
-
-
-def test_uninstallstring_ist_gequotet():
-    """DER klassische Fehler. Ohne Anfuehrungszeichen liest Windows
-    „C:\\Program Files\\Rippy\\x.exe" als „C:\\Program" mit Argumenten —
-    beim Deinstallieren passiert dann nichts oder etwas Falsches.
-    """
-    werte = reg.eintrag_werte(
-        r"C:\Program Files\Rippy", r"C:\Program Files\Rippy\RippySetup.exe", "2.0.0")
-    assert werte["UninstallString"].startswith('"C:\\Program Files\\Rippy\\RippySetup.exe"')
-    assert werte["UninstallString"].endswith("--deinstallieren")
-
-
-def test_stille_deinstallation_ist_vorgesehen():
-    """Windows benutzt QuietUninstallString bei automatisierten Entfernungen.
-    Fehlt er, faellt Windows auf den lauten zurueck und ein Dialog blockiert
-    eine unbeaufsichtigte Abmeldung."""
-    werte = reg.eintrag_werte(r"C:\Rippy", r"C:\Rippy\s.exe", "2.0.0")
-    assert "--still" in werte["QuietUninstallString"]
-
-
-def test_reparieren_und_aendern_sind_ausgeblendet():
-    """Rippy kann beides nicht. Knoepfe, die ins Leere fuehren, sind
-    dieselbe Sorte Placebo wie ein Fortschrittsbalken ohne Fortschritt."""
-    werte = reg.eintrag_werte(r"C:\Rippy", r"C:\Rippy\s.exe", "2.0.0")
-    assert werte["NoModify"] == 1
-    assert werte["NoRepair"] == 1
-
-
-def test_groesse_wird_in_kib_erwartet():
-    """EstimatedSize ist in KiB. Wer Bytes eintraegt, meldet in „Programme und
-    Features" das Tausendfache — aus 90 MB werden 90 GB."""
-    werte = reg.eintrag_werte(r"C:\Rippy", r"C:\Rippy\s.exe", "2.0.0", groesse_kib=92_160)
-    assert werte["EstimatedSize"] == 92_160        # = 90 MiB
-
-
-def test_ohne_icon_kein_leerer_eintrag():
-    """Ein leerer DisplayIcon laesst Windows das Standard-Symbol zeigen —
-    aber ein Wert, der da ist und ins Leere zeigt, macht ein kaputtes Bild."""
-    assert "DisplayIcon" not in reg.eintrag_werte(r"C:\R", r"C:\R\s.exe", "2.0.0")
-    assert "DisplayIcon" in reg.eintrag_werte(r"C:\R", r"C:\R\s.exe", "2.0.0", icon=r"C:\R\r.ico")
-
-
-def test_uninstall_pfad_liegt_unter_dem_richtigen_schluessel():
-    pfad = reg.uninstall_pfad("Rippy")
-    assert pfad.startswith(r"Software\Microsoft\Windows\CurrentVersion\Uninstall")
-    assert pfad.endswith(r"\Rippy")
-
-
-def test_installationsordner_braucht_keine_adminrechte():
-    """Program Files waere gewohnter, verlangt aber bei JEDER Installation
-    und jedem Update eine UAC-Abfrage."""
-    ordner = reg.standard_installationsordner()
-    assert "Rippy" in ordner
-    if os.name == "nt":
-        assert "Program Files" not in ordner
-
-
-def test_ordnergroesse_zaehlt_wirklich(tmp_path):
-    (tmp_path / "a.bin").write_bytes(b"x" * 4096)
-    unter = tmp_path / "unter"
-    unter.mkdir()
-    (unter / "b.bin").write_bytes(b"y" * 4096)
-    assert reg.ordnergroesse_kib(str(tmp_path)) == 8
-
-
-# ── Wirklich schreiben (nur Windows) ────────────────────────────────────
-@nur_windows
-def test_eintrag_landet_wirklich_in_der_registry(tmp_path):
-    """Nachsehen statt glauben: Ein Schreibvorgang, der quittiert wurde, ist
-    kein Beweis. Genau diese Lehre steht in AGENTS.md."""
-    ordner = str(tmp_path)
-    (tmp_path / "RippySetup.exe").write_bytes(b"x" * 1024)
-    deinstaller = str(tmp_path / "RippySetup.exe")
-    try:
-        reg.eintragen(ordner, deinstaller, "2.0.0-test", schluessel=TEST_SCHLUESSEL)
-        assert reg.ist_eingetragen(TEST_SCHLUESSEL) is True
-
-        gelesen = reg.gelesene_werte(TEST_SCHLUESSEL)
-        assert gelesen["DisplayName"] == "Rippy"
-        assert gelesen["DisplayVersion"] == "2.0.0-test"
-        assert gelesen["UninstallString"].startswith('"' + deinstaller + '"')
-        assert gelesen["NoModify"] == 1
-    finally:
-        reg.austragen(TEST_SCHLUESSEL)
-    assert reg.ist_eingetragen(TEST_SCHLUESSEL) is False
-
-
-@nur_windows
-def test_austragen_auf_nichts_ist_kein_fehler():
-    assert reg.austragen("RippyGibtEsNicht") is False
-
-
-@nur_windows
-def test_autostart_setzen_lesen_entfernen(tmp_path):
-    name = "RippyTestAutostart"
-    befehl = '"' + str(tmp_path / "Rippy.exe") + '"'
-    try:
-        reg.autostart_setzen(befehl, name=name)
-        assert reg.autostart_wert(name) == befehl
-    finally:
-        reg.autostart_entfernen(name)
-    assert reg.autostart_wert(name) == ""

src/rippy/platform/test_winlauf.py

@@ -0,0 +1,209 @@
+"""Kind-Prozesse ohne Fenster — und die Ausgabe ohne Konsole.
+
+Ein Konsolenfenster laesst sich in einem Test nicht ansehen. Geprueft wird
+deshalb das, woran es beim ersten Anlauf gescheitert ist: die ENTSCHEIDUNG,
+wohin die Ausgabe geht, wenn es keine Konsole gibt.
+
+## Warum das nicht Nebensache ist
+
+Die EXE wird seit dem 28.08.2026 als Fenster-Programm gebaut, damit beim
+Doppelklick keine schwarze Box aufgeht. Damit ist `sys.stdout` aber `None`.
+Ohne Umleitung wuerde jede Bibliothek, die auf `stderr` schreibt, mit
+`AttributeError: 'NoneType' object has no attribute 'write'` sterben — mitten
+im Start, und nirgends stuende etwas. Genau der stille Fehlschlag, vor dem
+AGENTS.md warnt.
+"""
+
+import os
+import subprocess
+import sys
+
+import pytest
+
+from rippy.platform import winlauf
+
+nur_windows = pytest.mark.skipif(os.name != "nt", reason="nur unter Windows")
+
+
+# ── Kind-Prozesse ───────────────────────────────────────────────────────
+def test_flag_ist_auf_windows_gesetzt_und_sonst_null():
+    """Auf Linux ist CREATE_NO_WINDOW nicht vorhanden; `creationflags=0` wird
+    dort akzeptiert und ignoriert. So laeuft derselbe Code auf beiden Seiten."""
+    if os.name == "nt":
+        assert winlauf.OHNE_FENSTER == subprocess.CREATE_NO_WINDOW
+    else:
+        assert winlauf.OHNE_FENSTER == 0
+
+
+# ── Gibt es ueberhaupt eine Ausgabe? ────────────────────────────────────
+def test_fehlende_standardausgabe_wird_erkannt(monkeypatch):
+    """Der Fall in der fertigen EXE: PyInstaller setzt `sys.stdout` auf None."""
+    monkeypatch.setattr(sys, "stdout", None)
+    assert winlauf.ohne_konsole() is True
+
+
+def test_ein_strom_ohne_dateinummer_zaehlt_auch_als_ohne_konsole(monkeypatch):
+    """pytest ersetzt stdout durch einen Auffang-Puffer. Der hat kein
+    `fileno` — und ein Meldungsfenster waere in einem Testlauf das Letzte,
+    was jemand gebrauchen kann."""
+    class Puffer:
+        write = staticmethod(lambda _: None)
+
+    monkeypatch.setattr(sys, "stdout", Puffer())
+    assert winlauf.ohne_konsole() is True
+
+
+def test_mit_echter_ausgabe_ist_alles_in_ordnung(monkeypatch, tmp_path):
+    datei = tmp_path / "echt.txt"
+    with open(datei, "w", encoding="utf-8") as f:
+        monkeypatch.setattr(sys, "stdout", f)
+        assert winlauf.ohne_konsole() is False
+
+
+# ── Die Protokolldatei ──────────────────────────────────────────────────
+def test_protokoll_liegt_bei_rippy():
+    """Nicht im TEMP: Was Rippy ueber sich aufschreibt, gehoert zu Rippy und
+    verschwindet beim Deinstallieren mit."""
+    pfad = winlauf.protokolldatei(os.path.join("C:" + os.sep, "Basis"))
+    assert pfad.endswith(os.path.join("Rippy", "rippy.log"))
+    assert pfad.startswith(os.path.join("C:" + os.sep, "Basis"))
+
+
+def test_umleiten_schreibt_wirklich(tmp_path, monkeypatch):
+    ziel = str(tmp_path / "unterordner" / "rippy.log")
+    vorher_out, vorher_err = sys.stdout, sys.stderr
+    try:
+        assert winlauf.ausgabe_umleiten(ziel) == ziel
+        print("eine Zeile mit Umlaut: ä")
+        sys.stdout.flush()
+    finally:
+        sys.stdout, sys.stderr = vorher_out, vorher_err
+    assert "eine Zeile mit Umlaut" in open(ziel, encoding="utf-8").read()
+
+
+def test_umleiten_haengt_an_statt_zu_ueberschreiben(tmp_path):
+    """Sonst waere nach jedem Neustart das Protokoll des letzten Fehlers weg
+    — also genau das, was man dann sucht."""
+    ziel = str(tmp_path / "rippy.log")
+    vorher_out, vorher_err = sys.stdout, sys.stderr
+    try:
+        winlauf.ausgabe_umleiten(ziel)
+        print("erster Start")
+        sys.stdout.flush()
+        winlauf.ausgabe_umleiten(ziel)
+        print("zweiter Start")
+        sys.stdout.flush()
+    finally:
+        sys.stdout, sys.stderr = vorher_out, vorher_err
+    inhalt = open(ziel, encoding="utf-8").read()
+    assert "erster Start" in inhalt and "zweiter Start" in inhalt
+
+
+def test_unbeschreibbarer_ort_laesst_den_start_nicht_platzen(monkeypatch):
+    """Lieber ins Nichts schreiben als beim Start sterben. Ein Programm, das
+    wegen seiner Protokolldatei nicht hochkommt, ist schlimmer als eines
+    ohne Protokoll."""
+    def geht_nicht(*a, **k):
+        raise OSError("kein Platz")
+
+    monkeypatch.setattr(winlauf.os, "makedirs", geht_nicht)
+    vorher_out, vorher_err = sys.stdout, sys.stderr
+    try:
+        winlauf.ausgabe_umleiten("/gibt/es/nicht/rippy.log")
+        print("das darf nicht werfen")
+    finally:
+        sys.stdout, sys.stderr = vorher_out, vorher_err
+
+
+# ── Das Meldungsfenster ─────────────────────────────────────────────────
+def test_ohne_windows_kein_meldungsfenster():
+    if os.name == "nt":
+        pytest.skip("prueft das Verhalten auf Nicht-Windows")
+    assert winlauf.meldung_zeigen("egal") is False
+    assert winlauf.an_elternkonsole_haengen() is False
+
+
+# ── Der Auspack-Ordner (Befund 28.08.2026) ──────────────────────────────
+#
+# Commander, mit Bildschirmfoto:
+#
+#     Failed to remove temporary directory:
+#     C:\Users\TobisPC\AppData\Local\Temp\_MEI0000b0882
+#
+# „Und manchmal kommt dieser fehler."
+#
+# GEMESSEN in seinem Temp-Ordner: 20 zurueckgelassene _MEI-Ordner, zusammen
+# 1,1 GB. Der aus der Meldung liess sich hinterher anstandslos loeschen — die
+# Sperre war also voruebergehend, es ist ein Wettlauf.
+#
+# Ursache: `starte_hintergrund` und `starte_fensterprozess` starten Rippy.exe
+# erneut. `Popen` ohne `env=` reicht PyInstallers Auspack-Zeiger weiter, also
+# laufen beide Kinder im Ordner des Elternprozesses. Der beendet sich zuerst,
+# will loeschen — und die Kinder halten die DLLs offen.
+
+
+def test_der_auspack_zeiger_wird_dem_kind_NICHT_mitgegeben():
+    """Der Test, der 1,1 GB Reste verhindert haette."""
+    eltern = {"PATH": "/usr/bin", "_MEIPASS2": "/tmp/_MEI123",
+              "_PYI_APPLICATION_HOME_DIR": "/tmp/_MEI123",
+              "_PYI_ARCHIVE_FILE": "/x/Rippy.exe",
+              "_PYI_PARENT_PROCESS_LEVEL": "1"}
+    kind = winlauf.umgebung_ohne_bundle(eltern)
+    for name in winlauf.PYI_ZEIGER:
+        assert name not in kind, "%s wuerde das Kind in den Ordner der Eltern schicken" % name
+    assert kind["PATH"] == "/usr/bin", "der Rest der Umgebung muss bleiben"
+
+
+def test_die_elternumgebung_wird_nicht_veraendert():
+    """Ein `del os.environ[...]` haette den eigenen Prozess beschaedigt."""
+    eltern = {"_MEIPASS2": "/tmp/_MEI123"}
+    winlauf.umgebung_ohne_bundle(eltern)
+    assert eltern == {"_MEIPASS2": "/tmp/_MEI123"}
+
+
+
+def test_aufraeumen_laesst_einen_BENUTZTEN_ordner_unangetastet(tmp_path):
+    """Die wichtigste Eigenschaft: Ein laufender Rippy darf nichts verlieren.
+
+    Ein blindes `rmtree(ignore_errors=True)` haette ihm die halbe Bibliothek
+    weggeraeumt, bevor es an der gesperrten DLL scheitert.
+    """
+    lebt = tmp_path / "_MEI111111"
+    lebt.mkdir()
+    (lebt / "python312.dll").write_bytes(b"MZ")
+    (lebt / "wichtig.pyd").write_bytes(b"x")
+
+    def gesperrt(pfad):
+        raise OSError(32, "Datei wird von einem anderen Prozess verwendet")
+
+    assert winlauf.reste_aufraeumen(str(tmp_path), eigener="",
+                                    jetzt_loeschen=gesperrt) == 0
+    assert (lebt / "wichtig.pyd").exists(), "an einem benutzten Ordner wird NICHTS angefasst"
+
+
+def test_aufraeumen_entfernt_die_reste(tmp_path):
+    for name in ("_MEI000035002", "_MEI0000b0882"):
+        ordner = tmp_path / name
+        ordner.mkdir()
+        (ordner / "python312.dll").write_bytes(b"MZ")
+        (ordner / "base_library.zip").write_bytes(b"PK")
+
+    assert winlauf.reste_aufraeumen(str(tmp_path), eigener="") == 2
+    assert not list(tmp_path.glob("_MEI*"))
+
+
+def test_aufraeumen_raeumt_den_EIGENEN_ordner_nicht_weg(tmp_path):
+    """Sonst saegte Rippy waehrend des Startens an seinem eigenen Ast."""
+    eigen = tmp_path / "_MEI999999"
+    eigen.mkdir()
+    (eigen / "python312.dll").write_bytes(b"MZ")
+
+    assert winlauf.reste_aufraeumen(str(tmp_path), eigener=str(eigen)) == 0
+    assert eigen.exists()
+
+
+def test_aufraeumen_ignoriert_fremde_ordner(tmp_path):
+    """Was nicht `_MEI` heisst, geht uns nichts an."""
+    (tmp_path / "wichtige-daten").mkdir()
+    assert winlauf.reste_aufraeumen(str(tmp_path), eigener="") == 0
+    assert (tmp_path / "wichtige-daten").exists()

src/rippy/platform/test_winwaisen.py

@@ -0,0 +1,156 @@
+"""Kein makemkvcon ueberlebt Rippy — und keine Waise haelt das Laufwerk fest.
+
+## Der Befund (29.08.2026, auf dem Rechner des Commanders gemessen)
+
+Ein Elternprozess startete `makemkvcon`, dann wurde er hart beendet
+(`taskkill /F` ohne `/T` — genau das, was beim Dienst-Stopp und beim
+Drueber-Installieren passiert):
+
+    ohne Leine   makemkvcon PID 15368   vor dem Kill: True   danach: True
+    mit Leine    makemkvcon PID 43608   vor dem Kill: True   danach: False
+
+Ohne Leine bleibt die Waise stehen. **Und eine Waise haelt das Laufwerk fest**
+— jeder spaetere Rip scheitert dann mit „Das Öffnen der Disk schlug fehl".
+
+Diese Tests pruefen die Logik, nicht das Betriebssystem: Sie laufen auch unter
+Linux (Vertrag der Portschicht) und brauchen keine Windows-Aufrufe.
+"""
+
+import os
+
+import pytest
+
+from rippy.platform import winlauf
+
+
+# ── Wen raeumt Rippy weg, und wen nicht ────────────────────────────────
+
+
+def test_eine_waise_wird_erkannt():
+    liste = [
+        (100, 4, "explorer.exe"),
+        (200, 999, "makemkvcon64.exe"),      # Elternprozess 999 gibt es nicht
+    ]
+    assert winlauf.waisen_finden(liste) == [(200, "makemkvcon64.exe")]
+
+
+def test_ein_makemkvcon_mit_lebendem_eltern_bleibt_unangetastet():
+    """Das gehoert zu einem laufenden Rip — oder zu einem zweiten Rippy."""
+    liste = [
+        (100, 4, "Rippy.exe"),
+        (200, 100, "makemkvcon64.exe"),      # Kind eines lebenden Rippy
+    ]
+    assert winlauf.waisen_finden(liste) == []
+
+
+def test_die_makemkv_oberflaeche_wird_nie_abgeschossen():
+    """`makemkv.exe` ist das Programm, das der Commander offen haben darf.
+    Nur `makemkvcon` ist das Kommandozeilen-Werkzeug, das Rippy startet."""
+    liste = [(200, 999, "makemkv.exe")]
+    assert winlauf.waisen_finden(liste) == []
+
+
+def test_handbrake_und_flac_zaehlen_mit():
+    liste = [(1, 999, "HandBrakeCLI.exe"), (2, 999, "flac.exe")]
+    assert {name for _, name in winlauf.waisen_finden(liste)} == {
+        "HandBrakeCLI.exe", "flac.exe"}
+
+
+def test_gross_und_kleinschreibung_ist_egal():
+    """Windows meldet mal `makemkvcon64.exe`, mal anders geschrieben."""
+    assert winlauf.waisen_finden([(1, 999, "MakeMKVcon64.EXE")]) == [
+        (1, "MakeMKVcon64.EXE")]
+
+
+def test_beenden_meldet_was_es_beendet_hat():
+    liste = [(1, 999, "makemkvcon64.exe"), (2, 999, "flac.exe")]
+    versucht = []
+
+    def toeten(pid):
+        versucht.append(pid)
+        return True
+
+    assert winlauf.waisen_beenden(liste, toeten=toeten) == [
+        "makemkvcon64.exe", "flac.exe"]
+    assert versucht == [1, 2]
+
+
+def test_ein_prozess_der_sich_nicht_beenden_laesst_bricht_nichts_ab():
+    """Ein fremder Prozess mit demselben Namen, an den Rippy nicht herankommt,
+    darf den Start nicht aufhalten — die anderen werden trotzdem weggeraeumt."""
+    liste = [(1, 999, "makemkvcon64.exe"), (2, 999, "flac.exe")]
+
+    def toeten(pid):
+        if pid == 1:
+            raise OSError(5, "Zugriff verweigert")
+        return True
+
+    assert winlauf.waisen_beenden(liste, toeten=toeten) == ["flac.exe"]
+
+
+# ── Die Leine ──────────────────────────────────────────────────────────
+
+
+def test_ohne_windows_gibt_es_keine_leine():
+    """Unter Linux uebernimmt das der Container bzw. systemd — nicht Rippy."""
+    if os.name == "nt":
+        pytest.skip("hier laeuft Windows")
+    assert winlauf.kinder_an_die_leine() is False
+    assert winlauf.prozessliste() == []
+
+
+@pytest.mark.skipif(os.name != "nt", reason="Arbeitsgruppen gibt es nur unter Windows")
+def test_die_leine_haelt_und_bleibt_gehalten():
+    assert winlauf.kinder_an_die_leine() is True
+    griff = winlauf._ARBEITSGRUPPE
+    assert griff, "der Griff MUSS liegen bleiben — sonst sterben alle Kinder sofort"
+    assert winlauf.kinder_an_die_leine() is True, "ein zweiter Aufruf ist harmlos"
+    assert winlauf._ARBEITSGRUPPE == griff, "und legt keine zweite Gruppe an"
+
+
+@pytest.mark.skipif(os.name != "nt", reason="braucht echte Prozesse")
+def test_die_prozessliste_sieht_diesen_prozess():
+    eigene = {pid for pid, _, _ in winlauf.prozessliste()}
+    assert os.getpid() in eigene
+
+
+# ── Waechter gegen die Falle, die beim Bauen zugeschnappt ist ──────────
+
+
+def test_jeder_kernel32_aufruf_hat_eine_angemeldete_signatur():
+    """⚠️ Ohne `argtypes` reicht ctypes einen Griff als 32-Bit-int weiter.
+
+    `GetCurrentProcess()` liefert den Pseudogriff (HANDLE)-1, also
+    0xFFFFFFFFFFFFFFFF — ctypes wirft dann `ArgumentError: int too long to
+    convert`, das breite `except` verschluckt es, und `kinder_an_die_leine`
+    meldete nur „ging nicht". Genau so ist der erste Anlauf gescheitert.
+    """
+    import inspect
+
+    quelle = inspect.getsource(winlauf.kernel32)
+    for name in ("CreateJobObjectW", "SetInformationJobObject",
+                 "AssignProcessToJobObject", "GetCurrentProcess",
+                 "CreateToolhelp32Snapshot", "OpenProcess", "TerminateProcess"):
+        assert f"k.{name}.argtypes" in quelle, f"{name} ohne argtypes"
+        assert f"k.{name}.restype" in quelle, f"{name} ohne restype"
+
+
+@pytest.mark.skipif(os.name != "nt", reason="Strukturen nur unter Windows")
+def test_die_struktur_hat_die_groesse_die_windows_erwartet():
+    """144 Byte auf 64-Bit — am 29.08.2026 gegen Windows gemessen. Stimmt die
+    Groesse nicht, lehnt SetInformationJobObject stumm ab."""
+    import ctypes
+
+    assert ctypes.sizeof(winlauf._ERWEITERTE_GRENZEN()) == 144
+
+
+
+def test_der_rueckfall_ohne_die_fahne_ist_vorhanden():
+    """Steckt Rippy in einer fremden Arbeitsgruppe ohne Herausloese-Erlaubnis,
+    verweigert Windows den Start rundweg. Ein Fenster, das gar nicht mehr
+    aufgeht, waere schlimmer als eines, das mitstirbt."""
+    import inspect
+
+    quelle = inspect.getsource(winlauf.eigenstaendig_starten)
+    assert "except OSError" in quelle
+    assert quelle.count("subprocess.Popen") == 2, "mit Fahne und ohne"

src/rippy/platform/verknuepfungen.py

@@ -1,171 +0,0 @@
-"""Verknüpfungen auf dem Desktop und im Startmenü.
-
-## Warum über PowerShell und nicht über pywin32
-
-Eine `.lnk` ist keine Textdatei, sondern ein binäres Shell-Objekt. Sie von
-Hand zu schreiben ist Bastelei; `pywin32` könnte es, wäre aber eine
-20-MB-Abhängigkeit für vier Zeilen. Windows bringt die Fähigkeit selbst mit:
-`WScript.Shell` ist seit Jahrzehnten da und braucht keine Installation.
-
-Dieses Projekt geht den Weg schon einmal — der alte Worker-Installer legt
-seine Verknüpfungen ebenfalls „nativ via PowerShell (kein win32com mehr
-nötig)" an.
-
-## Warum die Ordner aus der Registry kommen
-
-`%USERPROFILE%\\Desktop` ist eine ANNAHME. Wer OneDrive benutzt oder seine
-Ordner verschoben hat, dessen Desktop liegt woanders — die Verknüpfung
-landete dann in einem Ordner, den niemand sieht, und der Nutzer suchte ein
-Symbol, das es nirgends gibt.
-
-Die Wahrheit steht unter `Shell Folders` in der Registry. Auf diesem Rechner
-am 28.08.2026 nachgesehen:
-
-    Desktop    C:\\Users\\…\\Desktop
-    Programs   C:\\Users\\…\\AppData\\Roaming\\Microsoft\\Windows\\Start Menu\\Programs
-
-## Worauf die Verknüpfung zeigt
-
-Nicht auf `--dienst`. Ein Doppelklick auf ein Desktop-Symbol soll Rippy
-ÖFFNEN — und dabei ist es dem Nutzer egal, ob der Dienst schon läuft. Die
-Verknüpfung ruft deshalb `Rippy.exe --oeffnen`: Läuft der Dienst, geht nur
-der Browser auf; läuft er nicht, wird er zuerst gestartet. Ein Symbol, das
-beim zweiten Klick einen zweiten Server startet, wäre eine Falle.
-"""
-
-import os
-import subprocess
-
-
-def shell_ordner(name: str) -> str:
-    """Der ECHTE Pfad eines Windows-Sonderordners („Desktop", „Programs").
-
-    Aus der Registry, nicht geraten. Leerer String, wenn er nicht zu
-    ermitteln ist — dann wird eben keine Verknüpfung angelegt, statt eine
-    an einer erfundenen Stelle.
-    """
-    if os.name != "nt":
-        return ""
-    import winreg
-
-    try:
-        with winreg.OpenKey(
-            winreg.HKEY_CURRENT_USER,
-            r"Software\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders",
-        ) as k:
-            wert, _ = winreg.QueryValueEx(k, name)
-            return os.path.expandvars(str(wert))
-    except OSError:
-        return ""
-
-
-def _ps_text(wert: str) -> str:
-    """Text für ein einfach gequotetes PowerShell-Argument.
-
-    In PowerShell wird ein Apostroph innerhalb einfacher Anführungszeichen
-    durch VERDOPPELN maskiert. Ohne das bricht ein Pfad wie
-    `C:\\Users\\O'Brien\\…` das Skript mitten entzwei — und der Fehler sieht
-    aus wie ein Syntaxfehler in Rippy.
-    """
-    return (wert or "").replace("'", "''")
-
-
-def skript(lnk: str, ziel: str, argumente: str = "", icon: str = "",
-           beschreibung: str = "", arbeitsordner: str = "") -> str:
-    """Das PowerShell-Skript, das die Verknüpfung anlegt (reine Funktion)."""
-    zeilen = [
-        "$s = (New-Object -ComObject WScript.Shell).CreateShortcut('%s')" % _ps_text(lnk),
-        "$s.TargetPath = '%s'" % _ps_text(ziel),
-    ]
-    if argumente:
-        zeilen.append("$s.Arguments = '%s'" % _ps_text(argumente))
-    if icon:
-        zeilen.append("$s.IconLocation = '%s'" % _ps_text(icon))
-    if beschreibung:
-        zeilen.append("$s.Description = '%s'" % _ps_text(beschreibung))
-    zeilen.append("$s.WorkingDirectory = '%s'"
-                  % _ps_text(arbeitsordner or os.path.dirname(ziel)))
-    zeilen.append("$s.Save()")
-    return "; ".join(zeilen)
-
-
-def anlegen(lnk: str, ziel: str, argumente: str = "", icon: str = "",
-            beschreibung: str = "", arbeitsordner: str = "") -> bool:
-    """Legt eine Verknüpfung an. False, wenn es nicht geklappt hat.
-
-    Wirft nicht: Eine fehlende Verknüpfung ist ärgerlich, aber kein Grund,
-    eine sonst geglückte Installation scheitern zu lassen. Der Aufrufer
-    sagt es dem Nutzer.
-    """
-    if os.name != "nt":
-        return False
-    from rippy.platform.winlauf import OHNE_FENSTER
-
-    try:
-        # os.makedirs MUSS mit in den try: Auf einem Laufwerk, das es nicht
-        # gibt, wirft es — und dann waere aus "Verknuepfung konnte nicht
-        # angelegt werden" ein Abbruch der ganzen Installation geworden.
-        os.makedirs(os.path.dirname(lnk), exist_ok=True)
-        ergebnis = subprocess.run(
-            ["powershell", "-NoProfile", "-NonInteractive", "-Command",
-             skript(lnk, ziel, argumente, icon, beschreibung, arbeitsordner)],
-            capture_output=True, text=True, timeout=60,
-            creationflags=OHNE_FENSTER,
-        )
-    except (OSError, subprocess.SubprocessError):
-        return False
-    # Nachsehen statt dem Rueckgabewert glauben: PowerShell meldet auch dann
-    # Erfolg, wenn Save() still scheitert.
-    return ergebnis.returncode == 0 and os.path.isfile(lnk)
-
-
-def entfernen(lnk: str) -> bool:
-    try:
-        os.remove(lnk)
-        return True
-    except OSError:
-        return False
-
-
-# ── Die beiden Orte ─────────────────────────────────────────────────────
-def desktop_pfad(name: str = "Rippy") -> str:
-    ordner = shell_ordner("Desktop")
-    return os.path.join(ordner, name + ".lnk") if ordner else ""
-
-
-def startmenue_pfad(name: str = "Rippy") -> str:
-    ordner = shell_ordner("Programs")
-    return os.path.join(ordner, name + ".lnk") if ordner else ""
-
-
-def alle_anlegen(programm: str, icon: str = "", desktop: bool = True,
-                 startmenue: bool = True) -> dict:
-    """Legt beide Verknüpfungen an. Gibt zurück, was WIRKLICH entstanden ist.
-
-    Der Rückgabewert ist die Liste der angelegten Dateien — nicht eine
-    Erfolgsmeldung. So kann der Installer sagen, was er getan hat, statt
-    zu behaupten, es sei alles gut gegangen.
-    """
-    gemacht = {}
-    ziele = []
-    if desktop:
-        ziele.append(("desktop", desktop_pfad()))
-    if startmenue:
-        ziele.append(("startmenue", startmenue_pfad()))
-
-    for schluessel, lnk in ziele:
-        if not lnk:
-            continue
-        if anlegen(lnk, programm, argumente="--oeffnen", icon=icon or programm,
-                   beschreibung="Rippy öffnen — automatisches Ripping"):
-            gemacht[schluessel] = lnk
-    return gemacht
-
-
-def alle_entfernen() -> list:
-    """Nimmt beide Verknüpfungen zurück. Gibt zurück, was entfernt wurde."""
-    entfernt = []
-    for lnk in (desktop_pfad(), startmenue_pfad()):
-        if lnk and os.path.isfile(lnk) and entfernen(lnk):
-            entfernt.append(lnk)
-    return entfernt

src/rippy/platform/win_registry.py

@@ -1,217 +0,0 @@
-"""Windows-Registrierung: „Programme und Features" und Autostart.
-
-## Wie ein Programm in „Programme und Features" landet
-
-Nicht durch das Kopieren von Dateien. Windows liest diese Liste ausschließlich
-aus der Registry, unter:
-
-    HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\<Schlüssel>
-    HKLM\\Software\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\<Schlüssel>
-
-HKCU ist die Installation für DIESEN Benutzer, HKLM die für alle — letztere
-braucht Administratorrechte. Rippy nimmt HKCU: Der Eintrag erscheint genauso in
-„Apps & Features", aber die Installation läuft ohne UAC-Abfrage durch.
-
-Pflicht sind genau zwei Werte:
-
-    DisplayName        was in der Liste steht
-    UninstallString    was Windows startet, wenn man „Deinstallieren" klickt
-
-Alles andere ist Kür, aber es macht den Unterschied zwischen einem
-gepflegten Eintrag und einem, der aussieht wie Schadsoftware:
-`DisplayVersion`, `Publisher`, `InstallLocation`, `DisplayIcon`,
-`EstimatedSize` (in KiB!), `NoModify`, `NoRepair`.
-
-## Autostart
-
-    HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run
-
-Bewusst HKCU und nicht der `Startup`-Ordner: Ein Eintrag in Run ist mit einem
-Registry-Zugriff wieder weg, eine Verknüpfung im Startup-Ordner muss man
-suchen. Und bewusst NICHT als Windows-Dienst — der bräuchte Administrator­
-rechte bei jeder Installation und jedem Update.
-
-## Warum die Werte hier getrennt gebaut werden
-
-`eintrag_werte()` und `uninstall_pfad()` sind reine Funktionen. Damit lässt
-sich prüfen, dass die Pflichtwerte gesetzt sind und der Deinstallations-Befehl
-richtig gequotet ist — ohne in die Registry zu schreiben. Ein falsch
-gequoteter `UninstallString` ist ein klassischer Fehler: Steht der Pfad mit
-Leerzeichen ohne Anführungszeichen drin, startet Windows beim Deinstallieren
-das falsche Programm oder gar nichts.
-"""
-
-import os
-import sys
-
-# Der Schlüsselname unter Uninstall. Muss über Versionen hinweg GLEICH bleiben —
-# ändert er sich, entsteht bei einem Update ein zweiter Eintrag, und der alte
-# bleibt als Leiche stehen.
-SCHLUESSEL = "Rippy"
-
-UNINSTALL_PFAD = r"Software\Microsoft\Windows\CurrentVersion\Uninstall"
-RUN_PFAD = r"Software\Microsoft\Windows\CurrentVersion\Run"
-
-ANZEIGENAME = "Rippy"
-HERAUSGEBER = "Rippy"
-
-
-def uninstall_pfad(schluessel: str = SCHLUESSEL) -> str:
-    return UNINSTALL_PFAD + "\\" + schluessel
-
-
-def _quoten(pfad: str) -> str:
-    """Pfad für die Kommandozeile in Anführungszeichen — immer.
-
-    „C:\\Program Files\\Rippy\\…" ohne Anführungszeichen liest Windows als
-    „C:\\Program" mit den Argumenten „Files\\Rippy\\…". Beim Deinstallieren
-    passiert dann entweder nichts oder etwas Falsches.
-    """
-    return '"' + pfad.strip('"') + '"'
-
-
-def eintrag_werte(installationsordner: str, deinstaller: str, version: str,
-                  icon: str = "", groesse_kib: int = 0) -> dict:
-    """Die Werte für „Programme und Features" (reine Funktion).
-
-    `groesse_kib` ist in KiB — Windows zeigt sie als „Größe" an. Wer Bytes
-    einträgt, meldet 1000-mal zu viel; das ist ein häufiger Fehler.
-    """
-    werte = {
-        "DisplayName": ANZEIGENAME,
-        "DisplayVersion": version,
-        "Publisher": HERAUSGEBER,
-        "InstallLocation": installationsordner,
-        "UninstallString": _quoten(deinstaller) + " --deinstallieren",
-        "QuietUninstallString": _quoten(deinstaller) + " --deinstallieren --still",
-        # Rippy kann sich nicht selbst reparieren oder teilweise installieren —
-        # die Knöpfe dafür gehören also ausgeblendet, statt ins Leere zu führen.
-        "NoModify": 1,
-        "NoRepair": 1,
-    }
-    if icon:
-        werte["DisplayIcon"] = icon
-    if groesse_kib:
-        werte["EstimatedSize"] = int(groesse_kib)
-    return werte
-
-
-def ordnergroesse_kib(ordner: str) -> int:
-    """Größe eines Ordners in KiB — für den EstimatedSize-Wert."""
-    summe = 0
-    for wurzel, _, dateien in os.walk(ordner):
-        for name in dateien:
-            try:
-                summe += os.path.getsize(os.path.join(wurzel, name))
-            except OSError:
-                pass
-    return summe // 1024
-
-
-# ── Schreiben und Entfernen (nur unter Windows) ─────────────────────────
-def _winreg():
-    if os.name != "nt":
-        raise RuntimeError("Registry-Zugriff gibt es nur unter Windows.")
-    import winreg
-
-    return winreg
-
-
-def eintragen(installationsordner: str, deinstaller: str, version: str,
-              icon: str = "", schluessel: str = SCHLUESSEL) -> None:
-    """Schreibt den Eintrag für „Programme und Features"."""
-    winreg = _winreg()
-    werte = eintrag_werte(
-        installationsordner, deinstaller, version, icon,
-        ordnergroesse_kib(installationsordner),
-    )
-    with winreg.CreateKey(winreg.HKEY_CURRENT_USER, uninstall_pfad(schluessel)) as k:
-        for name, wert in werte.items():
-            if isinstance(wert, int):
-                winreg.SetValueEx(k, name, 0, winreg.REG_DWORD, wert)
-            else:
-                winreg.SetValueEx(k, name, 0, winreg.REG_SZ, str(wert))
-
-
-def austragen(schluessel: str = SCHLUESSEL) -> bool:
-    """Entfernt den Eintrag. False, wenn es ihn gar nicht gab."""
-    winreg = _winreg()
-    try:
-        winreg.DeleteKey(winreg.HKEY_CURRENT_USER, uninstall_pfad(schluessel))
-        return True
-    except FileNotFoundError:
-        return False
-
-
-def ist_eingetragen(schluessel: str = SCHLUESSEL) -> bool:
-    winreg = _winreg()
-    try:
-        with winreg.OpenKey(winreg.HKEY_CURRENT_USER, uninstall_pfad(schluessel)):
-            return True
-    except FileNotFoundError:
-        return False
-
-
-def gelesene_werte(schluessel: str = SCHLUESSEL) -> dict:
-    """Was WIRKLICH in der Registry steht — für `rippy doctor` und Tests.
-
-    Nachsehen statt glauben: Ein Schreibvorgang, der quittiert wurde, ist
-    kein Beweis dafür, dass der Eintrag angekommen ist.
-    """
-    winreg = _winreg()
-    ergebnis = {}
-    try:
-        with winreg.OpenKey(winreg.HKEY_CURRENT_USER, uninstall_pfad(schluessel)) as k:
-            i = 0
-            while True:
-                try:
-                    name, wert, _ = winreg.EnumValue(k, i)
-                except OSError:
-                    break
-                ergebnis[name] = wert
-                i += 1
-    except FileNotFoundError:
-        pass
-    return ergebnis
-
-
-# ── Autostart ───────────────────────────────────────────────────────────
-def autostart_setzen(befehl: str, name: str = SCHLUESSEL) -> None:
-    winreg = _winreg()
-    with winreg.CreateKey(winreg.HKEY_CURRENT_USER, RUN_PFAD) as k:
-        winreg.SetValueEx(k, name, 0, winreg.REG_SZ, befehl)
-
-
-def autostart_entfernen(name: str = SCHLUESSEL) -> bool:
-    winreg = _winreg()
-    try:
-        with winreg.OpenKey(winreg.HKEY_CURRENT_USER, RUN_PFAD, 0,
-                            winreg.KEY_ALL_ACCESS) as k:
-            winreg.DeleteValue(k, name)
-        return True
-    except FileNotFoundError:
-        return False
-
-
-def autostart_wert(name: str = SCHLUESSEL) -> str:
-    winreg = _winreg()
-    try:
-        with winreg.OpenKey(winreg.HKEY_CURRENT_USER, RUN_PFAD) as k:
-            return winreg.QueryValueEx(k, name)[0]
-    except (FileNotFoundError, OSError):
-        return ""
-
-
-def standard_installationsordner() -> str:
-    """%LOCALAPPDATA%\\Rippy — dorthin darf ohne Administratorrechte geschrieben werden.
-
-    `Program Files` wäre der gewohnte Ort, verlangt aber bei JEDER Installation
-    und jedem Update eine UAC-Abfrage. Für ein Programm, das sich selbst
-    aktualisieren soll, ist das der falsche Handel.
-    """
-    basis = os.environ.get("LOCALAPPDATA") or os.path.expanduser("~")
-    return os.path.join(basis, "Rippy")
-
-
-def laeuft_als_gebuendelte_exe() -> bool:
-    return getattr(sys, "frozen", False)

src/rippy/platform/winlauf.py

@@ -23,10 +23,549 @@ ripping.py und schluessel.py; jeder hätte das Flag einzeln vergessen können, u
 genau so ist es passiert. Auf Linux ist `CREATE_NO_WINDOW` nicht vorhanden und
 `creationflags=0` eine Nulloperation — im Worker-Container gegengeprüft, damit
 derselbe Code auf beiden Seiten läuft.
+
+## Die eigene Konsole (28.08.2026)
+
+Commander: *„Unterbinde das CMD Fenster was sich beim Öffnen mitöffnet."*
+
+Der erste Anlauf wollte das Fenster VERSTECKEN: `GetConsoleProcessList`
+fragen, und bei genau einem angehängten Prozess `ShowWindow(SW_HIDE)`. Zwei
+Gründe, warum das nicht reicht:
+
+1. **Eine Onefile-EXE ist ZWEI Prozesse** — ein Starter und die eigentliche
+   Anwendung. An der Konsole hängen also immer zwei. Die Prüfung war damit
+   nie wahr, und das Fenster blieb einfach stehen. (Gemessen: PID 33172 mit
+   8 MB, PID 33580 mit 103 MB — beide `Rippy.exe`.)
+2. Selbst wenn sie ginge, wäre das Fenster erst nach ein bis zwei Sekunden
+   weg — so lange braucht Python bis zur ersten eigenen Zeile. Ein
+   Aufblitzen ist kein „unterbunden".
+
+**Die Konsole wird deshalb gar nicht erst erzeugt.** Die EXE ist als
+Fenster-Programm gebaut (`--windowed`), nicht als Konsolen-Programm. Windows
+legt dann für keinen Start eine Konsole an.
+
+Der Preis: Es gibt keine Standardausgabe mehr — `sys.stdout` ist `None`.
+Deshalb die drei Funktionen hier unten:
+
+    an_elternkonsole_haengen()   in einem Terminal gestartet? Dann DORT
+                                 hineinschreiben (fuer --status, --hilfe)
+    ausgabe_umleiten()           sonst: in eine Protokolldatei
+    meldung_zeigen()             und was der Nutzer sehen MUSS, kommt in
+                                 ein Fenster statt in ein schwarzes Nichts
+
+Ein Programm ohne Konsole, das seine Meldungen ins Leere schreibt, wäre
+genau der stille Fehlschlag, vor dem AGENTS.md warnt.
 """
 
+import os
 import subprocess
+import sys
 
 # Auf Windows das Flag, auf Linux 0 (dort wird creationflags=0 akzeptiert und
 # ignoriert — am 26.07.2026 im Worker-Container gemessen).
 OHNE_FENSTER = getattr(subprocess, "CREATE_NO_WINDOW", 0)
+
+ATTACH_PARENT_PROCESS = -1
+MB_OK = 0x0
+MB_ICONINFORMATION = 0x40
+MB_ICONERROR = 0x10
+
+
+#: PyInstaller schreibt den Auspack-Ordner in die eigene Umgebung. Namen je
+#: nach Fassung: `_MEIPASS2` bis 5.x, ab 6.x die drei `_PYI_*`-Variablen
+#: (pyinstaller/PyInstaller/loader/pyiboot01_bootstrap.py). Hier stehen alle,
+#: damit ein Fassungswechsel den Fehler nicht stillschweigend zurückholt.
+PYI_ZEIGER = ("_MEIPASS2", "_PYI_ARCHIVE_FILE", "_PYI_APPLICATION_HOME_DIR",
+              "_PYI_PARENT_PROCESS_LEVEL")
+
+
+def umgebung_ohne_bundle(basis: dict = None) -> dict:
+    """Die eigene Umgebung, aber ohne PyInstallers Auspack-Zeiger.
+
+    ## Der Befund des Commanders (28.08.2026)
+
+        Failed to remove temporary directory:
+        C:\\Users\\TobisPC\\AppData\\Local\\Temp\\_MEI0000b0882
+
+    „Und manchmal kommt dieser fehler." — Manchmal stimmt: Es ist ein
+    Wettlauf.
+
+    ## Was gemessen wurde
+
+    In seinem Temp-Ordner lagen **20 zurückgelassene `_MEI`-Ordner mit
+    zusammen 1,1 GB**. Einer davon war der aus der Meldung, und er ließ sich
+    hinterher anstandslos löschen — die Sperre war also vorübergehend.
+
+    ## Die Ursache
+
+    Eine Onefile-EXE packt sich beim Start nach `%TEMP%\\_MEIxxxxxx` aus und
+    räumt beim Beenden auf. Den Ordner findet der Prozess über eine
+    Umgebungsvariable, die PyInstaller sich selbst setzt.
+
+    `starte_hintergrund` und `starte_fensterprozess` starten `Rippy.exe`
+    erneut — mit `--dienst` und mit `--oeffnen`, denn Tray und Fenster
+    brauchen je einen eigenen Haupt-Thread. `subprocess.Popen` ohne `env=`
+    reicht die ganze Umgebung weiter, also **auch diesen Zeiger**. Die beiden
+    Kinder packen daraufhin gar nichts mehr aus: Sie laufen im Ordner des
+    Elternprozesses.
+
+    Der Eltern-Prozess beendet sich als Erster und will seinen Ordner
+    löschen. Die Kinder haben die DLLs darin noch offen — Windows verweigert.
+    Meldung. Und weil danach niemand mehr zuständig ist, bleibt der Ordner
+    für immer liegen; beim nächsten Start derselbe Ablauf.
+
+    Das war nicht nur unschön: Wäre das Löschen TEILWEISE geglückt, hätten
+    Dienst und Fenster mitten im Betrieb ihre eigenen Dateien verloren.
+
+    Ohne den Zeiger packt sich jedes Kind seinen eigenen Ordner aus und räumt
+    ihn selbst wieder weg. Das kostet je Start etwa eine Sekunde und ein paar
+    Dutzend MB kurzzeitig — deutlich billiger als 1,1 GB Reste.
+    """
+    umgebung = dict(os.environ if basis is None else basis)
+    for name in PYI_ZEIGER:
+        umgebung.pop(name, None)
+    return umgebung
+
+
+def reste_aufraeumen(ordner: str = None, eigener: str = None,
+                     jetzt_loeschen=None) -> int:
+    """Räumt zurückgelassene `_MEI`-Ordner weg. Gibt die Anzahl zurück.
+
+    Der Netzfang für alles, was der Zeiger-Fix nicht mehr erzeugt, aber schon
+    liegen ließ — und für abgestürzte Läufe, die es immer geben wird.
+
+    ## Warum das gefahrlos ist
+
+    Ein LAUFENDER Rippy hat seine `python312.dll` offen, und Windows lässt
+    eine offene Datei nicht löschen. Deshalb wird genau die zuerst versucht:
+    Geht sie nicht weg, gehört der Ordner einem lebenden Prozess, und es wird
+    **nichts weiter angefasst**. Ein blindes `rmtree(ignore_errors=True)`
+    hätte einem laufenden Rippy die halbe Bibliothek unter den Füßen
+    weggeräumt, bevor es an der gesperrten DLL scheitert.
+    """
+    import glob
+    import shutil
+    import tempfile
+
+    ordner = ordner or tempfile.gettempdir()
+    eigener = eigener if eigener is not None else getattr(sys, "_MEIPASS", "")
+    weg = 0
+    for pfad in glob.glob(os.path.join(ordner, "_MEI*")):
+        if not os.path.isdir(pfad) or os.path.normcase(pfad) == os.path.normcase(eigener or "\0"):
+            continue
+        wache = [d for d in glob.glob(os.path.join(pfad, "python3*.dll"))]
+        try:
+            for datei in wache:
+                (jetzt_loeschen or os.remove)(datei)
+        except OSError:
+            continue          # In Benutzung — Finger weg vom ganzen Ordner.
+        shutil.rmtree(pfad, ignore_errors=True)
+        weg += 1
+    return weg
+
+
+# ═══════════════════════════════════ Kinder ueberleben Rippy nicht ══
+#
+# ## Der Befund (29.08.2026, auf diesem Rechner gemessen)
+#
+# Ein Python-Elternprozess startete `makemkvcon`, dann wurde der Elternprozess
+# hart beendet (`taskkill /F`, ohne `/T` — genau das, was Windows beim
+# Dienst-Stopp und beim Drueber-Installieren tut):
+#
+#     vor dem Kill: Eltern True,  Kind True
+#     danach:       Eltern False, Kind True      <-- die Waise
+#
+# Zwei `makemkvcon64.exe` blieben danach im Taskmanager stehen. **Eine solche
+# Waise haelt das Laufwerk fest.** Jeder spaetere Rip scheitert dann mit
+# „Das Oeffnen der Disk schlug fehl" — dem Satz, den der Commander gemeldet hat.
+#
+# Windows raeumt Kindprozesse nicht auf. Es gibt genau ein Mittel dagegen, und
+# das ist die Arbeitsgruppe (Job Object): Prozesse darin sterben, wenn die
+# Gruppe geschlossen wird — und geschlossen wird sie automatisch, wenn der
+# letzte Griff darauf verschwindet, also wenn Rippy endet. Auch beim Absturz.
+#
+# ⚠️ `_ARBEITSGRUPPE` MUSS ein Modulwert bleiben. Wird der Griff eingesammelt,
+# schliesst Windows die Gruppe — und bringt damit sofort alle Kinder um.
+
+TH32CS_SNAPPROCESS = 0x00000002
+JOB_OBJECT_LIMIT_BREAKAWAY_OK = 0x0800
+JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE = 0x2000
+JOB_OBJECT_ERWEITERTE_GRENZEN = 9
+CREATE_BREAKAWAY_FROM_JOB = 0x01000000
+PROCESS_TERMINATE = 0x0001
+
+# Nur diese werden je als Waise beendet. `makemkv.exe` steht bewusst NICHT
+# dabei: Das ist die Oberflaeche von MakeMKV, die der Commander offen haben
+# darf, ohne dass Rippy sie abschiesst.
+WERKZEUG_PROZESSE = ("makemkvcon.exe", "makemkvcon64.exe",
+                     "handbrakecli.exe", "flac.exe")
+
+_ARBEITSGRUPPE = None
+_K32 = None
+
+
+if os.name == "nt":
+    import ctypes
+    from ctypes import wintypes
+
+    class _BASIS_GRENZEN(ctypes.Structure):
+        _fields_ = [
+            ("PerProcessUserTimeLimit", ctypes.c_longlong),
+            ("PerJobUserTimeLimit", ctypes.c_longlong),
+            ("LimitFlags", wintypes.DWORD),
+            ("MinimumWorkingSetSize", ctypes.c_size_t),
+            ("MaximumWorkingSetSize", ctypes.c_size_t),
+            ("ActiveProcessLimit", wintypes.DWORD),
+            ("Affinity", ctypes.c_size_t),
+            ("PriorityClass", wintypes.DWORD),
+            ("SchedulingClass", wintypes.DWORD),
+        ]
+
+    class _EA_ZAEHLER(ctypes.Structure):
+        _fields_ = [(name, ctypes.c_ulonglong) for name in (
+            "ReadOperationCount", "WriteOperationCount", "OtherOperationCount",
+            "ReadTransferCount", "WriteTransferCount", "OtherTransferCount")]
+
+    class _ERWEITERTE_GRENZEN(ctypes.Structure):
+        _fields_ = [
+            ("BasicLimitInformation", _BASIS_GRENZEN),
+            ("IoInfo", _EA_ZAEHLER),
+            ("ProcessMemoryLimit", ctypes.c_size_t),
+            ("JobMemoryLimit", ctypes.c_size_t),
+            ("PeakProcessMemoryUsed", ctypes.c_size_t),
+            ("PeakJobMemoryUsed", ctypes.c_size_t),
+        ]
+
+    class _PROZESSEINTRAG(ctypes.Structure):
+        _fields_ = [
+            ("dwSize", wintypes.DWORD),
+            ("cntUsage", wintypes.DWORD),
+            ("th32ProcessID", wintypes.DWORD),
+            ("th32DefaultHeapID", ctypes.c_size_t),
+            ("th32ModuleID", wintypes.DWORD),
+            ("cntThreads", wintypes.DWORD),
+            ("th32ParentProcessID", wintypes.DWORD),
+            ("pcPriClassBase", ctypes.c_long),
+            ("dwFlags", wintypes.DWORD),
+            ("szExeFile", wintypes.WCHAR * 260),
+        ]
+
+
+def eigenstaendig_starten(befehl, **kw):
+    """Startet einen Prozess, der Rippy UEBERLEBEN soll.
+
+    Drei Prozesse duerfen nicht mitsterben: der Dienst (vom Starter aus), das
+    Fensterprogramm und das Aufraeum-Skript der Deinstallation. Sie loesen
+    sich mit `CREATE_BREAKAWAY_FROM_JOB` aus der Arbeitsgruppe.
+
+    ⚠️ Der Rueckfall ohne die Fahne ist Pflicht, nicht Vorsicht: Steckt Rippy
+    in einer FREMDEN Arbeitsgruppe, die kein Herausloesen erlaubt, verweigert
+    Windows den Start rundweg (Zugriff verweigert). Ein Fenster, das gar nicht
+    mehr aufgeht, waere schlimmer als eines, das mitstirbt.
+    """
+    fahnen = kw.pop("creationflags", 0)
+    try:
+        return subprocess.Popen(
+            befehl, creationflags=fahnen | CREATE_BREAKAWAY_FROM_JOB, **kw)
+    except OSError:
+        return subprocess.Popen(befehl, creationflags=fahnen, **kw)
+
+
+def kernel32():
+    """kernel32 mit vollstaendig angemeldeten Signaturen.
+
+    ## Warum die `argtypes` hier keine Formsache sind (Befund 29.08.2026)
+
+    Ohne sie reicht ctypes einen Python-Integer als **32-Bit-int** weiter.
+    `GetCurrentProcess()` liefert aber den Pseudogriff `(HANDLE)-1`, also
+    0xFFFFFFFFFFFFFFFF — und ctypes wirft beim Weiterreichen
+
+        ArgumentError: int too long to convert
+
+    Der erste Anlauf fing das mit einem breiten `except` ab und meldete
+    schlicht „ging nicht". Gemessen: alle drei Aufrufe gelingen, sobald die
+    Signaturen stehen. Ein Griff ist 64 Bit breit; das muss man Windows sagen.
+    """
+    global _K32
+    if _K32 is not None:
+        return _K32
+    k = ctypes.WinDLL("kernel32", use_last_error=True)
+    k.CreateJobObjectW.argtypes = [ctypes.c_void_p, wintypes.LPCWSTR]
+    k.CreateJobObjectW.restype = wintypes.HANDLE
+    k.SetInformationJobObject.argtypes = [wintypes.HANDLE, ctypes.c_int,
+                                          ctypes.c_void_p, wintypes.DWORD]
+    k.SetInformationJobObject.restype = wintypes.BOOL
+    k.AssignProcessToJobObject.argtypes = [wintypes.HANDLE, wintypes.HANDLE]
+    k.AssignProcessToJobObject.restype = wintypes.BOOL
+    k.GetCurrentProcess.argtypes = []
+    k.GetCurrentProcess.restype = wintypes.HANDLE
+    k.CloseHandle.argtypes = [wintypes.HANDLE]
+    k.CloseHandle.restype = wintypes.BOOL
+    k.CreateToolhelp32Snapshot.argtypes = [wintypes.DWORD, wintypes.DWORD]
+    k.CreateToolhelp32Snapshot.restype = wintypes.HANDLE
+    k.Process32FirstW.argtypes = [wintypes.HANDLE, ctypes.c_void_p]
+    k.Process32FirstW.restype = wintypes.BOOL
+    k.Process32NextW.argtypes = [wintypes.HANDLE, ctypes.c_void_p]
+    k.Process32NextW.restype = wintypes.BOOL
+    k.OpenProcess.argtypes = [wintypes.DWORD, wintypes.BOOL, wintypes.DWORD]
+    k.OpenProcess.restype = wintypes.HANDLE
+    k.TerminateProcess.argtypes = [wintypes.HANDLE, wintypes.UINT]
+    k.TerminateProcess.restype = wintypes.BOOL
+    _K32 = k
+    return k
+
+
+def kinder_an_die_leine() -> bool:
+    """Bindet alle kuenftigen Kindprozesse an das Leben dieses Prozesses.
+
+    Stirbt Rippy — geordnet, abgestuerzt oder per Taskmanager —, sterben
+    makemkvcon, HandBrake und flac mit. Das Laufwerk ist danach frei.
+
+    Einmal beim Start aufrufen. Wirft nie; ein Rippy ohne Arbeitsgruppe laeuft
+    wie bisher weiter, nur ohne diesen Schutz.
+
+    `BREAKAWAY_OK` ist Absicht: Der Dienst startet das Fensterprogramm und das
+    Aufraeum-Skript der Deinstallation. Beide sollen Rippy ueberleben und
+    loesen sich mit `CREATE_BREAKAWAY_FROM_JOB` heraus.
+    """
+    global _ARBEITSGRUPPE
+    if os.name != "nt":
+        return False
+    if _ARBEITSGRUPPE is not None:
+        return True
+    try:
+        k32 = kernel32()
+        gruppe = k32.CreateJobObjectW(None, None)
+        if not gruppe:
+            return False
+        grenzen = _ERWEITERTE_GRENZEN()
+        grenzen.BasicLimitInformation.LimitFlags = (
+            JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE | JOB_OBJECT_LIMIT_BREAKAWAY_OK)
+        if not k32.SetInformationJobObject(
+                gruppe, JOB_OBJECT_ERWEITERTE_GRENZEN,
+                ctypes.byref(grenzen), ctypes.sizeof(grenzen)):
+            k32.CloseHandle(gruppe)
+            return False
+        if not k32.AssignProcessToJobObject(gruppe, k32.GetCurrentProcess()):
+            # Steckt Rippy schon in einer fremden Gruppe, die kein Herausloesen
+            # erlaubt, geht das nicht. Kein Grund zu scheitern — nur kein Schutz.
+            k32.CloseHandle(gruppe)
+            return False
+        _ARBEITSGRUPPE = gruppe          # Griff offenhalten, siehe oben
+        return True
+    except Exception:                    # noqa: BLE001
+        return False
+
+
+def prozessliste() -> list:
+    """[(pid, eltern_pid, name), ...] aller laufenden Prozesse. Leer bei Fehlern."""
+    if os.name != "nt":
+        return []
+    try:
+        k32 = kernel32()
+        schnappschuss = k32.CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0)
+        if not schnappschuss or schnappschuss == wintypes.HANDLE(-1).value:
+            return []
+        try:
+            eintrag = _PROZESSEINTRAG()
+            eintrag.dwSize = ctypes.sizeof(_PROZESSEINTRAG)
+            liste = []
+            weiter = k32.Process32FirstW(schnappschuss, ctypes.byref(eintrag))
+            while weiter:
+                liste.append((eintrag.th32ProcessID,
+                              eintrag.th32ParentProcessID,
+                              eintrag.szExeFile))
+                weiter = k32.Process32NextW(schnappschuss, ctypes.byref(eintrag))
+            return liste
+        finally:
+            k32.CloseHandle(schnappschuss)
+    except Exception:                    # noqa: BLE001
+        return []
+
+
+def waisen_finden(liste=None, namen=WERKZEUG_PROZESSE) -> list:
+    """Werkzeug-Prozesse, deren Elternprozess es nicht mehr gibt.
+
+    Nur elternlose: Ein makemkvcon, das gerade zu einem laufenden Rippy
+    gehoert, hat einen lebenden Elternprozess und bleibt unangetastet. Das
+    gilt auch fuer ein zweites Rippy und fuer einen Aufruf von Hand.
+    """
+    liste = prozessliste() if liste is None else liste
+    lebende = {pid for pid, _, _ in liste}
+    return [(pid, name) for pid, eltern, name in liste
+            if (name or "").lower() in namen and eltern not in lebende]
+
+
+def waisen_beenden(liste=None, toeten=None) -> list:
+    """Beendet elternlose Werkzeug-Prozesse. Gibt ihre Namen zurueck.
+
+    ## Warum das beim Start passieren muss
+
+    Eine Waise haelt das Laufwerk fest — der naechste Rip scheitert dann mit
+    „Das Oeffnen der Disk schlug fehl", und niemand kann sich das erklaeren.
+    `kinder_an_die_leine` verhindert neue Waisen; diese hier raeumt weg, was
+    eine aeltere Fassung oder ein Absturz hinterlassen hat.
+    """
+    if toeten is None:
+        def toeten(pid):
+            k32 = kernel32()
+            griff = k32.OpenProcess(PROCESS_TERMINATE, False, pid)
+            if not griff:
+                return False
+            try:
+                return bool(k32.TerminateProcess(griff, 1))
+            finally:
+                k32.CloseHandle(griff)
+
+    beendet = []
+    for pid, name in waisen_finden(liste):
+        try:
+            if toeten(pid):
+                beendet.append(name)
+        except Exception:                # noqa: BLE001
+            pass
+    return beendet
+
+
+def ohne_konsole() -> bool:
+    """Läuft dieser Prozess ohne Standardausgabe?
+
+    Das ist der Normalfall in einer `--windowed` gebauten EXE. `print()` würde
+    dann werfen oder ins Leere gehen — beides schlecht, deshalb wird es
+    abgefragt statt angenommen.
+    """
+    return sys.stdout is None or getattr(sys.stdout, "fileno", None) is None
+
+
+def an_elternkonsole_haengen() -> bool:
+    """An die Konsole des Aufrufers andocken, falls es eine gibt.
+
+    Wer `Rippy.exe --status` in PowerShell eintippt, soll die Antwort DORT
+    sehen. Ein Fenster-Programm hat zwar keine eigene Konsole, darf sich aber
+    an die des Aufrufers hängen — genau dafür gibt es
+    `ATTACH_PARENT_PROCESS`. Beim Doppelklick gibt es keine, dann ist das
+    Ergebnis schlicht False und der Aufrufer leitet um.
+    """
+    if os.name != "nt":
+        return False
+    import ctypes
+
+    try:
+        return bool(ctypes.WinDLL("kernel32", use_last_error=True)
+                    .AttachConsole(ATTACH_PARENT_PROCESS))
+    except (AttributeError, OSError):
+        return False
+
+
+def protokolldatei(basis: str = None) -> str:
+    """Wohin die Ausgabe geht, wenn niemand zusieht. (reine Funktion)
+
+    Neben die Datenbank, nicht ins TEMP: Was Rippy über sich selbst
+    aufschreibt, gehört zu Rippy und wird beim Deinstallieren mit entfernt.
+    """
+    wurzel = basis or os.environ.get("LOCALAPPDATA") or os.path.expanduser("~")
+    return os.path.join(wurzel, "Rippy", "rippy.log")
+
+
+def ausgabe_umleiten(pfad: str = None) -> str:
+    """Standardausgabe in die Protokolldatei. Gibt den Pfad zurück, sonst "".
+
+    OHNE das würde jede Bibliothek, die auf `sys.stderr` schreibt, in einer
+    `--windowed` EXE mit `AttributeError: 'NoneType' object has no attribute
+    'write'` sterben — mitten im Start, ohne dass irgendwo etwas stünde.
+    """
+    pfad = pfad or protokolldatei()
+    try:
+        os.makedirs(os.path.dirname(pfad), exist_ok=True)
+        strom = open(pfad, "a", encoding="utf-8", errors="replace", buffering=1)
+    except OSError:
+        # Selbst das ging nicht. Dann lieber ins Nichts als beim Start sterben.
+        try:
+            strom = open(os.devnull, "w")
+        except OSError:
+            return ""
+    sys.stdout = strom
+    sys.stderr = strom
+    return pfad
+
+
+def mit_rechteabfrage_starten(programm: str, argumente: str = "") -> bool:
+    r"""Startet ein Programm über die Shell — mit UAC-Abfrage, falls nötig.
+
+    Der Unterschied zu `subprocess.Popen` ist der ganze Punkt: `Popen` benutzt
+    `CreateProcess`, und das **zeigt keine UAC-Abfrage**. Verlangt das Ziel im
+    Manifest Administratorrechte, bricht es mit `ERROR_ELEVATION_REQUIRED`
+    (740) ab. Genau daran ist am 28.08.2026 der MakeMKV-Installer gescheitert.
+
+    Ohne Verb: Windows entscheidet selbst, ob eine Abfrage nötig ist. Ein
+    festes „runas" würde auch dort erhöhen, wo es nicht gebraucht wird.
+    """
+    if os.name != "nt":
+        return False
+    import ctypes
+
+    SW_SHOWNORMAL = 1
+    try:
+        ergebnis = ctypes.WinDLL("shell32").ShellExecuteW(
+            None, None, programm, argumente or None, None, SW_SHOWNORMAL)
+    except (AttributeError, OSError):
+        return False
+    # Über 32 heißt Erfolg (dokumentierter Rückgabewert von ShellExecute).
+    # 5 = ACCESS_DENIED: Der Nutzer hat die UAC-Abfrage weggeklickt.
+    return int(ergebnis) > 32
+
+
+def als_admin_neu_starten(programm: str, argumente: str = "") -> bool:
+    r"""Startet ein Programm mit Administratorrechten neu (löst UAC aus).
+
+    True heißt: Windows hat den Start angenommen. False heißt: Der Nutzer hat
+    die Abfrage abgebrochen oder es ging nicht — dann läuft der aufrufende
+    Prozess einfach weiter, statt sich zu beenden.
+
+    ## Warum das NICHT der Normalfall ist (gemessen 28.08.2026)
+
+    Ein erhöhter Prozess bekommt ein anderes Zugriffstoken, und eingebundene
+    Netzlaufwerke hängen am Token der SITZUNG. Auf diesem Rechner gemessen:
+
+        ohne Erhöhung             X:, Y:, Z: sichtbar
+        EnableLinkedConnections   nicht gesetzt (Windows-Standard)
+
+    Erhöht wären die drei also weg — genau der Befund, den der Commander
+    gemeldet hat („als Admin kann man kein netzlaufwerk wählen"). Deshalb ist
+    das hier ein Knopf und keine Voreinstellung: Wer nach `Programme`
+    installieren will, braucht ihn; wer eine Freigabe als Ablage will, darf
+    ihn NICHT drücken.
+    """
+    if os.name != "nt":
+        return False
+    import ctypes
+
+    SW_SHOWNORMAL = 1
+    try:
+        # ShellExecuteW mit dem Verb „runas" ist der dokumentierte Weg. Ein
+        # Rückgabewert über 32 heißt Erfolg; 5 (ACCESS_DENIED) heißt: Der
+        # Nutzer hat die UAC-Abfrage weggeklickt.
+        ergebnis = ctypes.WinDLL("shell32").ShellExecuteW(
+            None, "runas", programm, argumente or None, None, SW_SHOWNORMAL)
+    except (AttributeError, OSError):
+        return False
+    return int(ergebnis) > 32
+
+
+def meldung_zeigen(text: str, titel: str = "Rippy", fehler: bool = False) -> bool:
+    """Ein Meldungsfenster. True, wenn es wirklich gezeigt wurde.
+
+    Für alles, was der Nutzer sehen MUSS und ohne Konsole sonst nie sähe —
+    vor allem das Ergebnis der Installation.
+    """
+    if os.name != "nt":
+        return False
+    import ctypes
+
+    symbol = MB_ICONERROR if fehler else MB_ICONINFORMATION
+    try:
+        ctypes.WinDLL("user32", use_last_error=True).MessageBoxW(
+            None, str(text), str(titel), MB_OK | symbol)
+        return True
+    except (AttributeError, OSError):
+        return False

src/rippy/queue/__init__.py

@@ -1,10 +0,0 @@
-"""Queue-Schicht: Aufträge verteilen (KONZEPT-V2.md § 3.4).
-
-Zwei Treiber, ein Port (`rippy.ports.Queue`):
-
-    lokal.py    Auftragstabelle + Lease, ohne Broker — Standalone-Betrieb
-    celery.py   Celery über Redis — verteilter Betrieb (V2-5)
-
-Beide stehen auf demselben Grundsatz: Die Datenbank ist die Wahrheit über den
-Job-Zustand, der Broker ist nur der Wecker.
-"""

src/rippy/queue/laeufer.py

@@ -1,152 +0,0 @@
-"""Der Läufer: nimmt Aufträge aus der LocalQueue und arbeitet sie ab.
-
-## Wofür er da ist
-
-Im verteilten Betrieb macht Celery das: Ein Worker-Prozess wartet auf
-Nachrichten und ruft die Task-Funktion auf. Im Standalone-Betrieb gibt es
-keinen Broker und keinen zweiten Prozess — also übernimmt dieser Läufer die
-Rolle. Er ist das letzte Stück, das gefehlt hat, damit Rippy unter Windows
-nicht nur anzeigen, sondern auch **arbeiten** kann.
-
-## Die Lease ist der Kern, nicht ein Detail
-
-Ein Rip läuft 30 bis 90 Minuten. In dieser Zeit muss zweierlei stimmen:
-
-* **Niemand sonst darf denselben Auftrag anfassen.** Zwei Rips auf einem
-  Laufwerk wären zwei kaputte Dateien.
-* **Stürzt der Läufer ab, muss der Auftrag zurückfallen.** Sonst bliebe er
-  für immer als „läuft" stehen — genau der Zustand, den v1 mit
-  `zombies.py` nachträglich einsammeln musste.
-
-Beides erledigt die Lease aus `rippy.queue.lokal`: Der Läufer verlängert sie
-alle 15 Sekunden aus einem eigenen Thread. Hört er auf zu leben, läuft sie
-nach 60 Sekunden ab und der Auftrag ist wieder frei.
-
-## Warum der Herzschlag NICHT im Arbeits-Thread liegt
-
-Weil er dann mit der Arbeit stillstünde. Der Rip verbringt seine Zeit in
-`subprocess.communicate()` — dort läuft kein Python-Code, der nebenbei eine
-Lease verlängern könnte. Der Herzschlag braucht deshalb einen eigenen Thread,
-der nichts anderes tut.
-
-## Was der Läufer NICHT tut
-
-Er kennt den Rip-Vorgang nicht. Er bekommt eine Funktion `ausfuehren(auftrag)`
-und ruft sie auf. Das hält ihn testbar (die Tests hier rippen nichts) und
-erlaubt dieselbe Mechanik später für andere Auftragsarten.
-"""
-
-import threading
-import time
-import traceback
-
-from rippy.queue import lokal
-
-
-class Laeufer:
-    """Ein Arbeiter: holt einen Auftrag, hält ihn, arbeitet ihn ab."""
-
-    def __init__(self, ausfuehren, knoten: str, kann: set = None,
-                 bus=None, store=None,
-                 herzschlag_sekunden: float = lokal.LEASE_ERNEUERN_SEKUNDEN):
-        self._ausfuehren = ausfuehren
-        self.knoten = knoten
-        self.kann = kann or set()
-        self._bus = bus
-        self._store = store
-        self._herzschlag_sekunden = herzschlag_sekunden
-        self._laeuft = False
-        self.aktueller_auftrag = None
-
-    # ── Ein Auftrag ─────────────────────────────────────────────────────
-    def einmal(self) -> bool:
-        """Holt EINEN Auftrag und arbeitet ihn ab. False, wenn nichts da war.
-
-        Blockiert für die Dauer der Arbeit — bei einem Rip also Stunden. Das
-        ist Absicht: Der Aufrufer entscheidet, ob das in einem eigenen Thread
-        passiert.
-        """
-        auftrag = lokal.uebernehmen(self.knoten, self.kann)
-        if auftrag is None:
-            return False
-
-        self.aktueller_auftrag = auftrag
-        schlagen = self._herzschlag_starten(auftrag["id"])
-        try:
-            ergebnis = self._ausfuehren(auftrag)
-            lokal.abschliessen(auftrag["id"], ergebnis if isinstance(ergebnis, dict) else {})
-            self._melden("job.finished", auftrag, {"status": "fertig"})
-        except Exception as e:
-            # Ein Fehlschlag darf den Laeufer NICHT mitnehmen — sonst bleibt
-            # nach einem kaputten Auftrag jeder weitere liegen. Der Auftrag
-            # geht zurueck in die Queue (bis MAX_VERSUCHE), der Grund wird
-            # protokolliert, und zwar mit Rueckverfolgung: Ein "Fehler" ohne
-            # Stelle ist beim naechsten Mal wertlos.
-            self._protokollieren(auftrag, e)
-            lokal.fehlgeschlagen(auftrag["id"], f"{type(e).__name__}: {e}")
-            self._melden("job.finished", auftrag, {"status": "fehler", "fehler": str(e)})
-        finally:
-            schlagen.set()
-            self.aktueller_auftrag = None
-        return True
-
-    def _herzschlag_starten(self, auftrag_id: str) -> threading.Event:
-        """Verlängert die Lease, solange gearbeitet wird. Eigener Thread."""
-        fertig = threading.Event()
-
-        def schlagen():
-            while not fertig.wait(self._herzschlag_sekunden):
-                if not lokal.lebenszeichen(auftrag_id, self.knoten):
-                    # Der Auftrag gehoert uns nicht mehr — jemand anderes hat
-                    # ihn uebernommen, weil unsere Lease abgelaufen war. Dann
-                    # ist Weiterarbeiten falsch, aber Abbrechen mitten im Rip
-                    # waere schlimmer. Also: laut sagen und weiterlaufen.
-                    self._protokollieren_text(
-                        f"Auftrag {auftrag_id} ist an einen anderen Knoten "
-                        "gefallen — die Lease war abgelaufen.")
-                    return
-
-        threading.Thread(target=schlagen, daemon=True,
-                         name=f"lease-{auftrag_id[:8]}").start()
-        return fertig
-
-    # ── Die Schleife ────────────────────────────────────────────────────
-    def schleife(self, takt: float = 1.0) -> None:
-        """Läuft, bis `stoppen()` gerufen wird. Für einen eigenen Thread."""
-        self._laeuft = True
-        while self._laeuft:
-            try:
-                if not self.einmal():
-                    time.sleep(takt)
-            except Exception as e:      # die Schleife selbst darf nie sterben
-                self._protokollieren_text(f"Läufer-Fehler: {e}")
-                time.sleep(takt * 5)
-
-    def stoppen(self) -> None:
-        self._laeuft = False
-
-    # ── Melden ──────────────────────────────────────────────────────────
-    def _melden(self, typ: str, auftrag: dict, daten: dict) -> None:
-        if not self._bus:
-            return
-        try:
-            self._bus.senden(typ, {**daten, "art": auftrag.get("art")},
-                             entitaet="job", entitaet_id=auftrag.get("job_id"))
-        except Exception:
-            pass        # eine Meldung darf die Arbeit nicht aufhalten
-
-    def _protokollieren(self, auftrag: dict, fehler: Exception) -> None:
-        self._protokollieren_text(
-            f"Auftrag {auftrag.get('art')} für Job {auftrag.get('job_id')} "
-            f"gescheitert: {type(fehler).__name__}: {fehler}\n"
-            + "".join(traceback.format_exception_only(type(fehler), fehler)).strip()
-        )
-
-    def _protokollieren_text(self, text: str) -> None:
-        if self._store:
-            try:
-                self._store.add_log("error", "laeufer", text)
-                return
-            except Exception:
-                pass
-        print("[Läufer] " + text)

src/rippy/queue/lokal.py

@@ -1,290 +0,0 @@
-"""LocalQueue — Aufträge ohne Broker. Erfüllt `rippy.ports.Queue`.
-
-## Der Grundsatz, aus dem alles folgt (KONZEPT-V2.md § 3.1)
-
-    Die Datenbank ist die Wahrheit über den Job-Zustand.
-    Der Broker ist nur der Wecker.
-
-In v1 war es umgekehrt gedacht: Celery hielt den Auftrag, die Datenbank
-spiegelte ihn nach. Deshalb gibt es dort `zombies.py` (206 Zeilen) plus
-`test_zombies.py` (263 Zeilen) — einen nachträglichen Reparaturmechanismus für
-Jobs, die in der Datenbank laufen, während in Celery niemand mehr an ihnen
-arbeitet. Nach einer Gnadenfrist werden sie „ehrlich auf failed gesetzt".
-
-Wenn die Datenbank die Wahrheit ist, verschwindet dieses Problem, statt
-repariert zu werden:
-
-* Ein Auftrag ist eine Zeile mit `status`, `claimed_by`, `lease_until`.
-* Ein Knoten übernimmt ihn per **bedingtem UPDATE** — atomar, es gewinnt genau
-  einer, auch wenn zehn gleichzeitig fragen.
-* Er hält ihn per Lease am Leben: alle `LEASE_ERNEUERN_SEKUNDEN` wird
-  `lease_until` vorgerückt.
-* Läuft die Lease ab, ist der Auftrag frei. Egal ob der Knoten abgestürzt ist,
-  das Netz weg war oder jemand den Stecker gezogen hat.
-
-Es gibt also keinen Zustand „läuft, aber niemand arbeitet daran" mehr, den
-jemand erkennen müsste. Er kann höchstens `LEASE_DAUER_SEKUNDEN` lang bestehen
-und heilt sich dann selbst.
-
-## Warum keine Queue-Bibliothek (Taskiq, ARQ, Celery-lite)
-
-Drei Gründe, alle am konkreten Fall gemessen:
-
-1. **Der teure Teil ist kein Task, sondern ein Subprozess.** Ein Rip ist ein
-   30–90-Minuten-`makemkvcon`-Aufruf, dessen stdout zeilenweise geparst wird
-   (`ripping.get_progress_from_prgv`). Was die Bibliotheken liefern —
-   Serialisierung, Retry, Broker-Anbindung — löst davon nichts. Was gebraucht
-   wird — Fortschritts-Streaming, Abbruch mitten im Lauf, Lease — muss man
-   ohnehin selbst bauen.
-2. **Zwei Bibliotheken heißen zwei Programmiermodelle.** Der verteilte Modus
-   behält Celery (funktioniert, der Remote-Windows-Worker ist bewiesen). Eine
-   zweite Queue-Bibliothek daneben bedeutet zwei Fehlerbilder, zwei
-   Retry-Semantiken, zwei Sorten Doku.
-3. **Mit dem Grundsatz oben ist der Treiber trivial** — die eigentliche
-   Auswahl unten ist ein SELECT und ein bedingtes UPDATE.
-
-## Wozu die Zeitgrenzen
-
-`LEASE_DAUER_SEKUNDEN` muss deutlich größer sein als
-`LEASE_ERNEUERN_SEKUNDEN`, sonst gilt ein arbeitender Knoten bei jedem
-Aussetzer als tot und ein zweiter greift sich denselben Auftrag. Faktor 4 ist
-reichlich: Drei Erneuerungen dürfen ausfallen, bevor jemand übernimmt.
-"""
-
-import json
-import uuid
-from datetime import timedelta
-
-from sqlalchemy import or_
-
-from rippy import store
-from rippy.store import auftraege
-
-# ⚠️ NICHT `from rippy.store import engine`. Ein Import bindet den Wert EINMAL,
-# beim Laden des Moduls — ein späteres `store.verbinden(...)` (Standalone-Start,
-# Tests) käme hier nie an, und dieses Modul spräche weiter mit der alten
-# Datenbank. Über `store.engine` wird bei jedem Aufruf nachgesehen.
-
-# Wie lange ein übernommener Auftrag als „in Arbeit" gilt, ohne Lebenszeichen.
-LEASE_DAUER_SEKUNDEN = 60
-# In welchem Abstand ein arbeitender Knoten die Lease verlängert.
-LEASE_ERNEUERN_SEKUNDEN = 15
-
-# Zustände
-WARTEND = "wartend"
-LAUFEND = "laufend"
-FERTIG = "fertig"
-FEHLER = "fehler"
-ABGEBROCHEN = "abgebrochen"
-
-# Wie oft ein Auftrag höchstens neu vergeben wird, bevor er als Fehler gilt.
-# Ohne Obergrenze würde ein Auftrag, der den bearbeitenden Knoten jedes Mal
-# umbringt, endlos im Kreis laufen und dabei jeden freien Knoten mitnehmen.
-MAX_VERSUCHE = 3
-
-
-def _jetzt():
-    return store.utcnow()
-
-
-def einreihen(job_id: str, art: str, faehigkeiten: dict = None,
-              payload: dict = None, prioritaet: int = 0) -> str:
-    """Legt einen Auftrag an und gibt seine Kennung zurück."""
-    auftrag_id = str(uuid.uuid4())
-    with store.engine.begin() as conn:
-        conn.execute(auftraege.insert().values(
-            id=auftrag_id,
-            job_id=job_id,
-            art=art,
-            status=WARTEND,
-            faehigkeiten=json.dumps(faehigkeiten or {}),
-            payload=json.dumps(payload or {}),
-            prioritaet=prioritaet,
-            versuche=0,
-            created_at=_jetzt(),
-        ))
-    return auftrag_id
-
-
-def _passt(auftrag_faehigkeiten: str, knoten_kann: set) -> bool:
-    """Kann dieser Knoten den Auftrag bedienen? (pure Funktion)
-
-    Ein Auftrag verlangt Fähigkeiten als Schlüssel-Wert-Paare, z. B.
-    `{"art": "rip", "drive": "sr0"}`. Der Knoten meldet, was er kann, als
-    Menge von `"schluessel=wert"`-Strings bzw. blanken Schlüsseln.
-
-    Leere Anforderung heißt: jeder darf. Das ist Absicht — ein Auftrag ohne
-    besondere Ansprüche soll nicht liegen bleiben, nur weil niemand explizit
-    „kann nichts Besonderes" gemeldet hat.
-    """
-    try:
-        verlangt = json.loads(auftrag_faehigkeiten or "{}")
-    except (ValueError, TypeError):
-        verlangt = {}
-    if not verlangt:
-        return True
-    for schluessel, wert in verlangt.items():
-        if f"{schluessel}={wert}" in knoten_kann or schluessel in knoten_kann:
-            continue
-        return False
-    return True
-
-
-def uebernehmen(knoten: str, kann: set = None):
-    """Holt EINEN passenden Auftrag und markiert ihn als übernommen.
-
-    Gibt den Auftrag als dict zurück oder None, wenn nichts passt.
-
-    ## Warum das UPDATE eine Bedingung trägt
-
-    Zwischen dem SELECT und dem UPDATE kann ein anderer Knoten denselben
-    Auftrag genommen haben. Das `WHERE … AND claimed_by IS NULL` (bzw. eine
-    abgelaufene Lease) sorgt dafür, dass genau EINER gewinnt: Der Verlierer
-    ändert null Zeilen und sucht weiter. Das ist derselbe Mechanismus auf
-    SQLite wie auf PostgreSQL — beide führen ein UPDATE atomar aus.
-
-    Ohne die Bedingung hätte man das klassische Doppel-Rip: zwei Knoten am
-    selben Laufwerk, und der zweite überschreibt die Ausgabe des ersten.
-    """
-    kann = kann or set()
-    jetzt = _jetzt()
-    with store.engine.begin() as conn:
-        kandidaten = conn.execute(
-            auftraege.select()
-            .where(auftraege.c.status.in_((WARTEND, LAUFEND)))
-            .where(or_(
-                auftraege.c.claimed_by.is_(None),
-                auftraege.c.lease_until.is_(None),
-                auftraege.c.lease_until < jetzt,     # Lease abgelaufen = frei
-            ))
-            .where(auftraege.c.versuche < MAX_VERSUCHE)
-            .order_by(auftraege.c.prioritaet.desc(), auftraege.c.created_at)
-            .limit(20)
-        ).mappings().all()
-
-        for kandidat in kandidaten:
-            if not _passt(kandidat["faehigkeiten"], kann):
-                continue
-            betroffen = conn.execute(
-                auftraege.update()
-                .where(auftraege.c.id == kandidat["id"])
-                .where(or_(
-                    auftraege.c.claimed_by.is_(None),
-                    auftraege.c.lease_until.is_(None),
-                    auftraege.c.lease_until < jetzt,
-                ))
-                .values(
-                    status=LAUFEND,
-                    claimed_by=knoten,
-                    lease_until=jetzt + timedelta(seconds=LEASE_DAUER_SEKUNDEN),
-                    versuche=(kandidat["versuche"] or 0) + 1,
-                )
-            ).rowcount
-            if betroffen == 1:
-                eintrag = dict(kandidat)
-                eintrag.update({
-                    "status": LAUFEND,
-                    "claimed_by": knoten,
-                    "versuche": (kandidat["versuche"] or 0) + 1,
-                })
-                return eintrag
-    return None
-
-
-def lebenszeichen(auftrag_id: str, knoten: str) -> bool:
-    """Verlängert die Lease. False, wenn der Auftrag inzwischen weg ist.
-
-    Der `knoten`-Vergleich ist kein Beiwerk: Hat ein anderer den Auftrag
-    übernommen (weil diese Lease einmal abgelaufen war), darf der alte
-    Bearbeiter ihn NICHT wieder an sich ziehen. Ein False heißt für den
-    Aufrufer: aufhören, jemand anderes macht das jetzt.
-    """
-    with store.engine.begin() as conn:
-        betroffen = conn.execute(
-            auftraege.update()
-            .where(auftraege.c.id == auftrag_id)
-            .where(auftraege.c.claimed_by == knoten)
-            .where(auftraege.c.status == LAUFEND)
-            .values(lease_until=_jetzt() + timedelta(seconds=LEASE_DAUER_SEKUNDEN))
-        ).rowcount
-    return betroffen == 1
-
-
-def abschliessen(auftrag_id: str, ergebnis: dict = None) -> None:
-    with store.engine.begin() as conn:
-        conn.execute(
-            auftraege.update()
-            .where(auftraege.c.id == auftrag_id)
-            .values(status=FERTIG, finished_at=_jetzt(),
-                    payload=json.dumps(ergebnis or {}), lease_until=None)
-        )
-
-
-def fehlgeschlagen(auftrag_id: str, fehler: str, erneut: bool = True) -> None:
-    """Auftrag ist gescheitert.
-
-    `erneut=True` gibt ihn wieder frei, solange die Versuche reichen — ein
-    abgestürzter Encoder soll den Job nicht endgültig verlieren. Ist
-    MAX_VERSUCHE erreicht, bleibt er auf `fehler` stehen: Ein Auftrag, der
-    dreimal denselben Knoten umgebracht hat, wird beim vierten Mal nicht
-    plötzlich funktionieren.
-    """
-    with store.engine.begin() as conn:
-        zeile = conn.execute(
-            auftraege.select().where(auftraege.c.id == auftrag_id)
-        ).mappings().first()
-        if not zeile:
-            return
-        wieder_frei = erneut and (zeile["versuche"] or 0) < MAX_VERSUCHE
-        conn.execute(
-            auftraege.update()
-            .where(auftraege.c.id == auftrag_id)
-            .values(
-                status=WARTEND if wieder_frei else FEHLER,
-                claimed_by=None,
-                lease_until=None,
-                fehler=(fehler or "")[:2000],
-                finished_at=None if wieder_frei else _jetzt(),
-            )
-        )
-
-
-def abbrechen(auftrag_id: str) -> None:
-    with store.engine.begin() as conn:
-        conn.execute(
-            auftraege.update()
-            .where(auftraege.c.id == auftrag_id)
-            .values(status=ABGEBROCHEN, claimed_by=None, lease_until=None,
-                    finished_at=_jetzt())
-        )
-
-
-def offene_auftraege(job_id: str = None) -> list:
-    """Alles, was noch nicht durch ist — für `rippy queue` und das UI."""
-    abfrage = auftraege.select().where(
-        auftraege.c.status.in_((WARTEND, LAUFEND))
-    ).order_by(auftraege.c.prioritaet.desc(), auftraege.c.created_at)
-    if job_id:
-        abfrage = abfrage.where(auftraege.c.job_id == job_id)
-    with store.engine.connect() as conn:
-        return [dict(z) for z in conn.execute(abfrage).mappings().all()]
-
-
-def verwaiste_freigeben() -> int:
-    """Gibt Aufträge frei, deren Lease abgelaufen ist. Gibt die Anzahl zurück.
-
-    Braucht man streng genommen nicht — `uebernehmen` behandelt abgelaufene
-    Leases ohnehin als frei. Diese Funktion macht es nur SICHTBAR: Nach einem
-    Absturz soll im UI und im Log stehen, dass etwas zurückgefallen ist, statt
-    dass es stillschweigend wieder auftaucht.
-    """
-    jetzt = _jetzt()
-    with store.engine.begin() as conn:
-        betroffen = conn.execute(
-            auftraege.update()
-            .where(auftraege.c.status == LAUFEND)
-            .where(auftraege.c.lease_until.isnot(None))
-            .where(auftraege.c.lease_until < jetzt)
-            .values(status=WARTEND, claimed_by=None, lease_until=None)
-        ).rowcount
-    return betroffen or 0

src/rippy/queue/test_laeufer.py

@@ -1,185 +0,0 @@
-"""Der Läufer: hält er den Auftrag, gibt er ihn zurück, überlebt er Fehler?
-
-Gerippt wird hier nichts — die Arbeit ist eine eingespritzte Funktion. Geprüft
-wird das Drumherum, und genau dort sitzen die Fehler, die man im Betrieb
-teuer bezahlt: ein Läufer, der nach dem ersten kaputten Auftrag stehenbleibt,
-oder eine Lease, die während eines dreistündigen Encodes abläuft.
-"""
-
-import threading
-import time
-
-import pytest
-
-from rippy import store
-from rippy.queue import laeufer as laeufer_modul
-from rippy.queue import lokal
-
-
-@pytest.fixture
-def q(tmp_path):
-    vorher = store.zustand_sichern()
-    store.verbinden(f"sqlite:///{(tmp_path / 'l.db').as_posix()}")
-    store.init_db()
-    yield lokal
-    store.engine_holen().dispose()
-    store.zustand_wiederherstellen(vorher)
-
-
-class FakeBus:
-    def __init__(self):
-        self.gesendet = []
-
-    def senden(self, typ, daten=None, entitaet=None, entitaet_id=None):
-        self.gesendet.append((typ, entitaet_id, daten or {}))
-
-
-class FakeStore:
-    def __init__(self):
-        self.protokoll = []
-
-    def add_log(self, level, quelle, text):
-        self.protokoll.append((level, quelle, text))
-
-
-# ── Grundfall ───────────────────────────────────────────────────────────
-def test_ohne_auftrag_passiert_nichts(q):
-    lauf = laeufer_modul.Laeufer(lambda a: {}, "knoten-a")
-    assert lauf.einmal() is False
-
-
-def test_auftrag_wird_geholt_und_abgearbeitet(q):
-    gesehen = []
-    q.einreihen("job1", "rip", payload={"device": "/dev/sr0"})
-    lauf = laeufer_modul.Laeufer(lambda a: gesehen.append(a) or {"ok": True}, "knoten-a")
-
-    assert lauf.einmal() is True
-    assert len(gesehen) == 1
-    assert gesehen[0]["art"] == "rip"
-    assert q.offene_auftraege() == []          # abgeschlossen, nicht mehr offen
-
-
-def test_zweiter_laeufer_bekommt_ihn_nicht(q):
-    """Die zentrale Zusage — sonst zwei Rips auf einem Laufwerk."""
-    q.einreihen("job1", "rip")
-    lauf_a = laeufer_modul.Laeufer(lambda a: {}, "knoten-a")
-    lauf_b = laeufer_modul.Laeufer(lambda a: {}, "knoten-b")
-
-    langsam = threading.Event()
-    lauf_a._ausfuehren = lambda a: langsam.wait(2) or {}
-    t = threading.Thread(target=lauf_a.einmal, daemon=True)
-    t.start()
-    time.sleep(0.3)
-    try:
-        assert lauf_b.einmal() is False, "Knoten B hat denselben Auftrag bekommen"
-    finally:
-        langsam.set()
-        t.join(timeout=5)
-
-
-# ── Fehler ──────────────────────────────────────────────────────────────
-def test_ein_kaputter_auftrag_nimmt_den_laeufer_nicht_mit(q):
-    """Ohne das bliebe nach dem ersten Fehlschlag JEDER weitere Auftrag
-    liegen — und im UI saehe es aus, als tue Rippy nichts mehr."""
-    protokoll = FakeStore()
-    q.einreihen("job1", "rip")
-
-    def kaputt(_):
-        raise RuntimeError("MakeMKV ist abgestuerzt")
-
-    lauf = laeufer_modul.Laeufer(kaputt, "knoten-a", store=protokoll)
-    assert lauf.einmal() is True               # er hat gearbeitet, nicht geworfen
-    assert any("MakeMKV ist abgestuerzt" in text for _, _, text in protokoll.protokoll)
-
-
-def test_gescheiterter_auftrag_geht_zurueck_in_die_queue(q):
-    """Ein abgestuerzter Encoder soll den Job nicht endgueltig verlieren."""
-    auftrag_id = q.einreihen("job1", "transcode")
-
-    def kaputt(_):
-        raise RuntimeError("weg")
-
-    laeufer_modul.Laeufer(kaputt, "knoten-a", store=FakeStore()).einmal()
-    offen = q.offene_auftraege()
-    assert len(offen) == 1 and offen[0]["id"] == auftrag_id
-
-
-def test_fehler_wird_mit_typ_gemeldet(q):
-    """„Fehler" allein ist beim naechsten Mal wertlos. Der Typ gehoert dazu."""
-    q.einreihen("job1", "rip")
-    protokoll = FakeStore()
-
-    def kaputt(_):
-        raise FileNotFoundError("makemkvcon fehlt")
-
-    laeufer_modul.Laeufer(kaputt, "knoten-a", store=protokoll).einmal()
-    text = " ".join(t for _, _, t in protokoll.protokoll)
-    assert "FileNotFoundError" in text
-    assert "makemkvcon fehlt" in text
-
-
-# ── Lease ───────────────────────────────────────────────────────────────
-def test_lease_wird_waehrend_der_arbeit_verlaengert(q):
-    """DER Punkt bei einem Rip: Er dauert Stunden, die Lease 60 Sekunden.
-    Ohne Herzschlag fiele der Auftrag mitten im Lauf zurueck — und ein
-    zweiter Laeufer finge an, dieselbe Disc zu lesen.
-    """
-    from datetime import timedelta
-
-    auftrag_id = q.einreihen("job1", "rip")
-    weiter = threading.Event()
-
-    def langsam(_):
-        # Waehrend der Arbeit die Lease kuenstlich ablaufen lassen —
-        # der Herzschlag muss sie zurueckholen.
-        with store.engine_holen().begin() as conn:
-            conn.execute(
-                store.auftraege.update()
-                .where(store.auftraege.c.id == auftrag_id)
-                .values(lease_until=store.utcnow() - timedelta(seconds=10)))
-        weiter.wait(3)
-        return {}
-
-    lauf = laeufer_modul.Laeufer(langsam, "knoten-a", herzschlag_sekunden=0.2)
-    t = threading.Thread(target=lauf.einmal, daemon=True)
-    t.start()
-    time.sleep(1.0)                             # dem Herzschlag Zeit geben
-    try:
-        assert laeufer_modul.lokal.uebernehmen("knoten-b") is None, \
-            "Die Lease wurde nicht verlaengert — ein zweiter Knoten kam ran"
-    finally:
-        weiter.set()
-        t.join(timeout=5)
-
-
-def test_aktueller_auftrag_ist_sichtbar_und_danach_wieder_leer(q):
-    """Fuer das UI und fuer die Diagnose: Woran arbeitet dieser Knoten gerade?"""
-    q.einreihen("job1", "rip")
-    gesehen = {}
-    lauf = laeufer_modul.Laeufer(
-        lambda a: gesehen.update(id=lauf.aktueller_auftrag["id"]) or {}, "knoten-a")
-    lauf.einmal()
-    assert gesehen["id"]
-    assert lauf.aktueller_auftrag is None
-
-
-# ── Meldungen ───────────────────────────────────────────────────────────
-def test_abschluss_wird_gemeldet(q):
-    bus = FakeBus()
-    q.einreihen("job1", "rip")
-    laeufer_modul.Laeufer(lambda a: {}, "knoten-a", bus=bus).einmal()
-    assert [t for t, _, _ in bus.gesendet] == ["job.finished"]
-    assert bus.gesendet[0][1] == "job1"
-
-
-def test_ein_kaputter_bus_haelt_die_arbeit_nicht_auf(q):
-    """Eine Meldung ist Beiwerk. Wenn sie scheitert, ist der Rip trotzdem
-    fertig — und darf nicht als Fehlschlag gelten."""
-    class KaputterBus:
-        def senden(self, *a, **k):
-            raise RuntimeError("Bus weg")
-
-    q.einreihen("job1", "rip")
-    lauf = laeufer_modul.Laeufer(lambda a: {"ok": True}, "knoten-a", bus=KaputterBus())
-    assert lauf.einmal() is True
-    assert q.offene_auftraege() == []

src/rippy/queue/test_lokal.py

@@ -1,215 +0,0 @@
-"""LocalQueue: übernehmen, Lease, Rückfall — gegen echtes SQLite (V2-2).
-
-Der Grundsatz, den diese Tests prüfen: **Die Datenbank ist die Wahrheit, der
-Broker ist nur der Wecker.** Konkret heißt das, dass zwei Dinge stimmen müssen,
-und beide sind hier nachgestellt:
-
-1. Zwei Knoten dürfen sich denselben Auftrag NICHT teilen. Ohne diese Zusage
-   liefen zwei Rips auf demselben Laufwerk, und der zweite überschriebe die
-   Ausgabe des ersten.
-2. Ein abgestürzter Knoten muss seinen Auftrag von SELBST wieder hergeben.
-   Genau das konnte v1 nicht — dort brauchte es `zombies.py` (206 Zeilen plus
-   263 Zeilen Tests), um hinterher aufzuräumen.
-"""
-
-from datetime import timedelta
-
-import pytest
-
-from rippy import store
-from rippy.queue import lokal
-
-
-@pytest.fixture
-def q(tmp_path):
-    """Frische SQLite-Datenbank je Test, danach zurückdrehen."""
-    vorher = store.zustand_sichern()
-    store.verbinden(f"sqlite:///{(tmp_path / 'q.db').as_posix()}")
-    store.init_db()
-    yield lokal
-    store.engine_holen().dispose()
-    store.zustand_wiederherstellen(vorher)
-
-
-def _lease_zuruecksetzen(auftrag_id, sekunden):
-    """Schiebt die Lease künstlich in die Vergangenheit — so sieht ein
-    abgestürzter Knoten aus, ohne dass ein Test eine Minute warten muss."""
-    with store.engine.begin() as conn:
-        conn.execute(
-            store.auftraege.update()
-            .where(store.auftraege.c.id == auftrag_id)
-            .values(lease_until=store.utcnow() - timedelta(seconds=sekunden))
-        )
-
-
-# ── Grundfall ───────────────────────────────────────────────────────────
-def test_eingereihter_auftrag_wird_uebernommen(q):
-    q.einreihen("job1", "rip")
-    auftrag = q.uebernehmen("knoten-a")
-    assert auftrag is not None
-    assert auftrag["art"] == "rip"
-    assert auftrag["claimed_by"] == "knoten-a"
-    assert auftrag["status"] == lokal.LAUFEND
-
-
-def test_ohne_auftrag_kommt_none(q):
-    assert q.uebernehmen("knoten-a") is None
-
-
-def test_hoehere_prioritaet_kommt_zuerst(q):
-    q.einreihen("job1", "transcode", prioritaet=0)
-    q.einreihen("job2", "rip", prioritaet=5)
-    assert q.uebernehmen("knoten-a")["job_id"] == "job2"
-
-
-# ── Die zentrale Zusage: genau EINER gewinnt ────────────────────────────
-def test_zwei_knoten_bekommen_nicht_denselben_auftrag(q):
-    """DIE Zusage der ganzen Queue. Ohne sie: zwei Rips auf einem Laufwerk."""
-    q.einreihen("job1", "rip")
-    erster = q.uebernehmen("knoten-a")
-    zweiter = q.uebernehmen("knoten-b")
-    assert erster is not None
-    assert zweiter is None, "Der zweite Knoten hat denselben Auftrag bekommen"
-
-
-def test_zwei_auftraege_gehen_an_zwei_knoten(q):
-    """Die Gegenprobe — sonst wäre die Sperre oben nur eine kaputte Queue."""
-    q.einreihen("job1", "rip")
-    q.einreihen("job2", "rip")
-    a = q.uebernehmen("knoten-a")
-    b = q.uebernehmen("knoten-b")
-    assert a and b and a["id"] != b["id"]
-
-
-# ── Lease: ein abgestürzter Knoten gibt von selbst her ──────────────────
-def test_abgelaufene_lease_macht_den_auftrag_wieder_frei(q):
-    """Das ist der Ersatz für zombies.py.
-
-    In v1 blieb ein Job nach einem Worker-Absturz auf `transcoding` stehen,
-    und ein eigener Mechanismus musste ihn nach einer Gnadenfrist „ehrlich auf
-    failed setzen". Hier passiert nichts dergleichen: Die Lease läuft ab, und
-    der Auftrag ist wieder zu haben.
-    """
-    auftrag_id = q.einreihen("job1", "rip")
-    erster = q.uebernehmen("knoten-a")
-    assert erster is not None
-    assert q.uebernehmen("knoten-b") is None      # solange die Lease lebt
-
-    _lease_zuruecksetzen(auftrag_id, 10)           # Knoten A ist abgestürzt
-
-    zweiter = q.uebernehmen("knoten-b")
-    assert zweiter is not None
-    assert zweiter["claimed_by"] == "knoten-b"
-    assert zweiter["versuche"] == 2
-
-
-def test_lebenszeichen_haelt_den_auftrag(q):
-    auftrag_id = q.einreihen("job1", "rip")
-    q.uebernehmen("knoten-a")
-    _lease_zuruecksetzen(auftrag_id, 10)
-
-    assert q.lebenszeichen(auftrag_id, "knoten-a") is True
-    assert q.uebernehmen("knoten-b") is None, "Lease wurde nicht verlaengert"
-
-
-def test_fremder_knoten_kann_die_lease_nicht_verlaengern(q):
-    """Sonst könnte ein Knoten, dessen Lease einmal abgelaufen ist, den Auftrag
-    dem neuen Bearbeiter wieder wegnehmen — und beide arbeiteten daran."""
-    auftrag_id = q.einreihen("job1", "rip")
-    q.uebernehmen("knoten-a")
-    assert q.lebenszeichen(auftrag_id, "knoten-b") is False
-
-
-def test_lebenszeichen_auf_unbekannten_auftrag_ist_false(q):
-    assert q.lebenszeichen("gibt-es-nicht", "knoten-a") is False
-
-
-def test_verwaiste_freigeben_macht_den_rueckfall_sichtbar(q):
-    """Nötig ist die Funktion nicht — uebernehmen() behandelt abgelaufene
-    Leases ohnehin als frei. Sie macht den Rückfall aber SICHTBAR, statt ihn
-    stillschweigend passieren zu lassen."""
-    auftrag_id = q.einreihen("job1", "rip")
-    q.uebernehmen("knoten-a")
-    assert q.verwaiste_freigeben() == 0
-    _lease_zuruecksetzen(auftrag_id, 10)
-    assert q.verwaiste_freigeben() == 1
-    assert q.offene_auftraege()[0]["status"] == lokal.WARTEND
-
-
-# ── Fähigkeiten ─────────────────────────────────────────────────────────
-def test_passt_ohne_anforderung_darf_jeder():
-    assert lokal._passt("{}", set()) is True
-    assert lokal._passt(None, set()) is True
-
-
-def test_passt_verlangt_alle_faehigkeiten():
-    verlangt = '{"art": "transcode", "encoder": "nvenc"}'
-    assert lokal._passt(verlangt, {"art=transcode", "encoder=nvenc"}) is True
-    assert lokal._passt(verlangt, {"art=transcode"}) is False
-
-
-def test_passt_bei_kaputtem_json_nicht_abstuerzen():
-    """Ein beschädigtes Feld darf die Auftragsvergabe nicht anhalten —
-    sonst blockiert eine einzige kaputte Zeile die ganze Queue."""
-    assert lokal._passt("{kein json", {"art=rip"}) is True
-
-
-def test_knoten_ohne_die_faehigkeit_bekommt_nichts(q):
-    q.einreihen("job1", "transcode", faehigkeiten={"encoder": "nvenc"})
-    assert q.uebernehmen("nur-cpu", kann={"encoder=x265"}) is None
-    assert q.uebernehmen("gpu-knoten", kann={"encoder=nvenc"}) is not None
-
-
-def test_passender_auftrag_wird_gefunden_obwohl_ein_fremder_vorne_liegt(q):
-    """Der GPU-Knoten darf nicht leer ausgehen, nur weil ein CPU-Auftrag mit
-    höherer Prioritaet davor steht."""
-    q.einreihen("job1", "transcode", faehigkeiten={"encoder": "x265"}, prioritaet=9)
-    q.einreihen("job2", "transcode", faehigkeiten={"encoder": "nvenc"})
-    auftrag = q.uebernehmen("gpu", kann={"encoder=nvenc"})
-    assert auftrag is not None and auftrag["job_id"] == "job2"
-
-
-# ── Abschluss und Fehlschlag ────────────────────────────────────────────
-def test_abgeschlossener_auftrag_kommt_nicht_zurueck(q):
-    auftrag_id = q.einreihen("job1", "rip")
-    q.uebernehmen("knoten-a")
-    q.abschliessen(auftrag_id, {"pfad": "/app/media/Akira"})
-    assert q.uebernehmen("knoten-b") is None
-    assert q.offene_auftraege() == []
-
-
-def test_fehlschlag_gibt_den_auftrag_wieder_frei(q):
-    auftrag_id = q.einreihen("job1", "transcode")
-    q.uebernehmen("knoten-a")
-    q.fehlgeschlagen(auftrag_id, "Encoder abgestuerzt")
-    zweiter = q.uebernehmen("knoten-b")
-    assert zweiter is not None and zweiter["id"] == auftrag_id
-
-
-def test_nach_max_versuchen_ist_schluss(q):
-    """Ohne Obergrenze liefe ein Auftrag, der jeden Knoten umbringt, endlos im
-    Kreis und nähme dabei jeden freien Knoten mit."""
-    auftrag_id = q.einreihen("job1", "transcode")
-    for _ in range(lokal.MAX_VERSUCHE):
-        q.uebernehmen("knoten-a")
-        q.fehlgeschlagen(auftrag_id, "immer derselbe Fehler")
-    assert q.uebernehmen("knoten-a") is None
-    with store.engine.connect() as conn:
-        zeile = conn.execute(
-            store.auftraege.select().where(store.auftraege.c.id == auftrag_id)
-        ).mappings().first()
-    assert zeile["status"] == lokal.FEHLER
-    assert "immer derselbe Fehler" in zeile["fehler"]
-
-
-def test_abbrechen_nimmt_den_auftrag_aus_dem_verkehr(q):
-    auftrag_id = q.einreihen("job1", "rip")
-    q.abbrechen(auftrag_id)
-    assert q.uebernehmen("knoten-a") is None
-
-
-def test_offene_auftraege_lassen_sich_nach_job_filtern(q):
-    q.einreihen("job1", "rip")
-    q.einreihen("job2", "rip")
-    assert len(q.offene_auftraege()) == 2
-    assert len(q.offene_auftraege(job_id="job1")) == 1

src/rippy/rip/handbrake_aufruf.py

@@ -0,0 +1,44 @@
+"""Wie HandBrakeCLI angesprochen und wie seine Ausgabe gelesen wird.
+
+## Warum das im GEMEINSAMEN Paket liegt
+
+Zwei Module rufen HandBrake auf: `docker/worker/ripping.py` (der Encode) und
+`docker/worker/caps.py` (Preset-Liste, Hilfe, Version). `caps` wird auch vom
+Standalone-Betrieb geladen und darf `ripping` nicht importieren, nur um an
+eine Konstante zu kommen.
+
+Dasselbe Muster wie bei `makemkv_aufruf.py`: Eine Entscheidung, zwei Orte —
+einer altert. Dort kostete es die Formatzeile, hier waere es die Kodierung.
+"""
+
+#: Wie HandBrakes Ausgabe gelesen wird — und warum mit errors="replace".
+#:
+#: ## Der Befund (30.08.2026, am mitgelieferten HandBrakeCLI 1.11.2 gemessen)
+#:
+#: HandBrake schreibt **zwei Kodierungen in denselben Strom**. Eine Datei
+#: namens „Glück über München.mkv" gescannt, die Bytes des Pfades in
+#: derselben Ausgabe:
+#:
+#:     Zeile „Opening ..."       C3 BC     = UTF-8
+#:     Zeile „..., title 1 ..."  81        = CP850 (OEM)
+#:
+#: Es gibt hier also keine richtige Kodierung, nur eine, die nicht
+#: abstuerzt. Und ohne diese Zeile stuerzte es ab: In CP850 ist ü das Byte
+#: **0x81**, und 0x81 ist in cp1252 — der Gebietsschema-Kodierung eines
+#: deutschen Windows, die text=True von sich aus waehlt — **undefiniert**:
+#:
+#:     UnicodeDecodeError: 'charmap' codec can't decode byte 0x81
+#:     in position 785: character maps to <undefined>
+#:
+#: In `run_handbrake` faellt das mitten in der Leseschleife an, wird von
+#: `except Exception` eingefangen und landet als Fehlertext im Job. **Jeder
+#: Film, dessen Pfad ein ü enthaelt, liess sich damit nicht komprimieren**
+#: — „Glück", „Tür", „München", „Über", „Grün". Dasselbe gilt fuer
+#: ì, Å, É, Ø (0x8D, 0x8F, 0x90, 0x9D).
+#:
+#: ⚠️ NICHT `text_von()` wie bei makemkvcon: Das liest binaer, und im
+#: Binaermodus gibt es keine Universal-Newlines. HandBrake trennt seine
+#: Fortschrittszeilen aber mit CR (0x0D) — der Balken waere weg. Alles, was
+#: Rippy aus der Ausgabe liest, ist ASCII (Prozente, „Invalid preset",
+#: „unknown option"); ersetzt wird also nur, was ohnehin nur Anzeige ist.
+HB_LESEN = {"text": True, "errors": "replace"}

src/rippy/rip/makemkv_aufruf.py

@@ -0,0 +1,390 @@
+"""Wie makemkvcon angesprochen und wie seine Antwort gelesen wird.
+
+## Warum das im GEMEINSAMEN Paket liegt
+
+Beide Seiten rufen makemkvcon auf: der Worker zum Rippen
+(`docker/worker/ripping.py`) und die API beim Vor-Scan
+(`docker/api/prescan/prescan.py`). Sie stecken in verschiedenen Images und
+können einander nicht importieren — deshalb stand die Formatzeile zweimal da,
+und beide Male falsch.
+
+Genau das ist das Muster, das in diesem Projekt schon dreimal Geld gekostet
+hat: `os.path` (viermal repariert, jetzt `rippy/pfade.py`), `/app/media` und
+`/root/.MakeMKV`. Eine Entscheidung, zwei Orte — einer altert.
+"""
+
+import sys
+
+
+def quelle(device_path: str, plattform_name: str = None) -> str:
+    """Wie MakeMKV DIESES Laufwerk nennt (pure Funktion, testbar).
+
+    ## Der Befund des Commanders (29.08.2026)
+
+    > „Das Rippen der disk funktioniert nicht. makemkvcon endete mit Code 11 —
+    > letzte Meldung: Das Öffnen der Disk schlug fehl — keine MKV-Datei
+    > entstanden"
+
+    An seinem Laufwerk gemessen, mit `info` (öffnet die Disc genauso wie
+    `mkv`, rippt aber nichts):
+
+        dev:\\\\.\\G:  MSG:2024 „Unknown device" -> MSG:5010 Öffnen schlug fehl
+        dev:G:     68 TINFO-Zeilen, „Die Aufgabe wurde erfolgreich
+                   abgeschlossen"
+
+    Vorher stand überall `f"dev:{device_path}"`. Unter Linux ist das richtig:
+    dort heißt das Laufwerk `/dev/sr0`, und genau so will MakeMKV es haben.
+    Unter Windows meldet `rippy.drives.windows` den Geräte-Namensraum
+    `\\\\.\\G:` — den braucht `CreateFileW` für die IOCTLs, aber MakeMKV kennt
+    ihn nicht. Es will den Laufwerksbuchstaben.
+
+    `plattform_name` ist einspritzbar, damit beide Fälle überall prüfbar sind.
+    Entschieden wird aber nach der FORM des Pfades, nicht nach dem Rechner —
+    dieselbe Regel wie in `rippy.pfade`: Ein Windows-Pfad bleibt ein
+    Windows-Pfad, auch wenn gerade Linux danach fragt.
+    """
+    pfad = (device_path or "").strip()
+    if not pfad:
+        return ""
+    # Geraete-Namensraum abstreifen: \\.\G: -> G:  (auch \\?\ kommt vor)
+    for vorsatz in ("\\\\.\\", "\\\\?\\"):
+        if pfad.startswith(vorsatz):
+            pfad = pfad[len(vorsatz):]
+            break
+    # „G:\" -> „G:" — mit Trenner geht es zwar auch (gemessen), aber ohne ist
+    # es das, was MakeMKV in seiner eigenen Laufwerksliste ausgibt.
+    if len(pfad) == 3 and pfad[1] == ":" and pfad[2] in "\\/":
+        pfad = pfad[:2]
+    return "dev:%s" % pfad
+
+
+def text_von(roh) -> str:
+    """makemkvcon-Ausgabe lesbar machen — egal in welcher Kodierung sie kommt.
+
+    ## Der Befund des Commanders (29.08.2026)
+
+    > „letzte Meldung: Das Öffnen der Disk schlug fehl"
+
+    `Ö` ist `Ö` als UTF-8 (Bytes C3 96), gelesen als cp1252. Die Ausgabe kam
+    also in einer anderen Kodierung an, als sie gelesen wurde.
+
+    Beide Seiten waren für sich richtig: `subprocess` stand auf `text=True`
+    **ohne** `encoding=`, benutzt also die Gebietsschema-Kodierung — auf einem
+    deutschen Windows cp1252. Und Rippy stellt seine Konsole beim Start
+    ausdrücklich auf UTF-8 (`daemon.ausgabe_auf_utf8_stellen`, sonst stirbt
+    der Start an einer Umlaut-Logzeile). Ein Konsolenprogramm richtet sich
+    danach — makemkvcon schrieb UTF-8 in eine Leitung, an deren Ende cp1252
+    erwartet wurde.
+
+    Direkt an makemkvcon gemessen, ohne unsere Konsolen-Umstellung: die Bytes
+    sind dann **cp1252** (`Das Öffnen` liest sich nur so richtig). Die
+    Kodierung hängt also wirklich an der Umgebung und ist nicht festzulegen.
+
+    Deshalb wird sie nicht behauptet, sondern bestimmt: UTF-8 streng
+    versuchen, sonst cp1252. Streng ist hier der Punkt — mit `errors=replace`
+    ginge jeder Umlaut still in einem Fragezeichen unter, und wir würden es
+    nie erfahren.
+    """
+    if isinstance(roh, str):
+        return roh
+    if not roh:
+        return ""
+    try:
+        return roh.decode("utf-8")
+    except UnicodeDecodeError:
+        # cp1252 kann jedes Byte abbilden -> hier kann nichts mehr scheitern.
+        return roh.decode("cp1252", "replace")
+
+
+#: Meldungs-Nummern, die die URSACHE eines Fehlschlags benennen. Sie sind
+#: sprachunabhängig — anders als die Texte, auf die vorher geprüft wurde.
+#:
+#: Bis zum 29.08.2026 suchte `ripping.py` nur englische Textbausteine
+#: („evaluation period has expired", „volume key is unknown"). Auf dem
+#: Commander-PC meldet MakeMKV deutsch, also traf keiner: Im Fehler stand nur
+#: „Das Öffnen der Disk schlug fehl" — die Ursache eine Zeile darüber fiel
+#: unter den Tisch.
+#:
+#: ⚠️ Jede Nummer hier ist an seinem Laufwerk GESEHEN worden, im Wortlaut.
+#: Beim ersten Anlauf hatte ich 5021 aus dem Kopf mit „Volume-Key unbekannt"
+#: beschriftet — falsch, und meine eigene Ausgabe zeigte nur meine
+#: Beschriftung statt MakeMKVs Text, sodass es fast durchgegangen wäre.
+#: Genau der Fehler, vor dem AGENTS Regel D warnt. Der echte Wortlaut:
+#:
+#:   2024  „Unknown device - '\\\\.\\G:'"
+#:   5020  „Der hinterlegte Aktivierungsschlüssel ist ungültig."
+#:   5021  „Diese Programmversion ist zu alt. Bitte laden Sie die aktuelle
+#:          Version von http://www.makemkv.com/ herunter."
+#:   5051  „Der Testzeitraum ist abgelaufen. Erwerben Sie bitte einen
+#:          Aktivierungsschlüssel …"
+KRITISCHE_CODES = {
+    2024: "MakeMKV kennt dieses Laufwerk nicht",
+    # 5010 stand bis zum 29.08.2026 NICHT hier — und genau das war das
+    # Problem: Der Commander bekam „makemkvcon endete mit Code 11 — letzte
+    # Meldung: Das Öffnen der Disk schlug fehl". Das ist MakeMKVs
+    # Sammelmeldung für „ging nicht" und sagt für sich genommen nichts.
+    #
+    # Auffällig war, was FEHLTE: kein „Ursache:" davor. Wäre der Gerätepfad
+    # schuld gewesen, stünde dort 2024. Bleibt: kein Datenträger, oder ein
+    # anderes Programm hält das Laufwerk. Nach einem fertigen Rip wirft Rippy
+    # die Disc aus — ein zweiter Versuch trifft dann ein leeres Laufwerk.
+    5010: "Das Laufwerk liess sich nicht öffnen — liegt die Disc noch drin? "
+          "Nach einem fertigen Rip wirft Rippy sie aus",
+    5020: "Der hinterlegte MakeMKV-Schlüssel wird nicht angenommen",
+    5021: "MakeMKV ist zu alt für den aktuellen Beta-Schlüssel — bitte MakeMKV "
+          "aktualisieren",
+    5051: "MakeMKV ist nicht freigeschaltet (Testzeitraum abgelaufen)",
+}
+
+#: Meldungen, die sagen: DIESER Schlüssel taugt für DIESE Fassung nicht.
+KEY_ABGELEHNT = (5020, 5021)
+
+
+def plattform(name: str = None) -> str:
+    """Nur für Tests, die den Rechner ausdrücklich benennen wollen."""
+    return (name if name is not None else sys.platform).lower()
+
+
+#: Wo MakeMKV unter Windows SEINE Einstellungen hält — gemessen, nicht geraten.
+REGISTRY_PFAD = r"Software\MakeMKV"
+KEY_NAME = "app_Key"
+
+
+def key_ablegen(key: str, plattform_name: str = None, schreiber=None,
+                datei_schreiber=None) -> str:
+    """Den Beta-Key dorthin legen, wo makemkvcon ihn WIRKLICH sucht.
+
+    Gibt zurück, wohin geschrieben wurde (für die Protokollzeile).
+
+    ## Der Befund des Commanders (29.08.2026)
+
+    Beim ersten echten Rip-Versuch meldete makemkvcon:
+
+        MSG:5051 „Der Testzeitraum ist abgelaufen. Erwerben Sie bitte einen
+                 Aktivierungsschlüssel"
+
+    — obwohl in Rippys Einstellungen ein aktueller Beta-Key lag. Zwei Fehler
+    hintereinander, beide gemessen:
+
+    **1. Falscher Ordner.** `makemkv_daten.DATEN_DIR` war fest
+    `/root/.MakeMKV`, ein Container-Pfad. Repariert (siehe dort).
+
+    **2. Falsche ART von Ablage.** Auch mit richtigem Ordner blieb die Meldung
+    stehen. Nachgesehen, was auf seinem Rechner wirklich existiert:
+
+        C:\\Users\\TobisPC\\.MakeMKV\\   nur _private_data.tar (6,4 MB)
+        HKCU\\Software\\MakeMKV          app_UpdateLastCheck, app_SiteInfoString,
+                                       app_BackupDecrypted, path_BackupDirMRU …
+
+    **Unter Windows hält MakeMKV seine Einstellungen in der Registry.** Die
+    `settings.conf` ist der Linux-Weg; im Container stimmt sie, hier nicht. Der
+    Ordner `.MakeMKV` existiert trotzdem — aber nur für den Schlüsselspeicher.
+
+    Rippy hat den Key also zweimal brav gespeichert und beide Male an einen
+    Ort, den niemand liest. Eine Automatik, die ins Leere schreibt, ist
+    schlimmer als keine: Sie sieht aus wie erledigt.
+
+    ## Warum hier NUR ein einziger Wert geschrieben wird
+
+    Weil in dieser Registry die Arbeit des Commanders steckt —
+    Laufwerksprofile, Fensterlage, zuletzt benutzte Ordner. Es wird genau
+    `app_Key` gesetzt und sonst nichts angefasst; gelöscht wird nie. (Am
+    28.08.2026 hat eine zu großzügige Testsuite schon einmal echte
+    Registry-Einträge von ihm entfernt.)
+    """
+    key = (key or "").strip()
+    if not key:
+        return ""
+    if not plattform(plattform_name).startswith("win"):
+        # Linux/Container: die settings.conf, wie gehabt.
+        return (datei_schreiber or _in_datei)(key)
+    return (schreiber or _in_registry)(key)
+
+
+def _in_registry(key: str) -> str:
+    import winreg
+
+    with winreg.CreateKey(winreg.HKEY_CURRENT_USER, REGISTRY_PFAD) as schluessel:
+        winreg.SetValueEx(schluessel, KEY_NAME, 0, winreg.REG_SZ, key)
+    return "HKCU\\" + REGISTRY_PFAD
+
+
+#: Einstellungen, die der Docker-Betrieb beim Start AUSDRÜCKLICH setzt
+#: (`docker/worker/entrypoint.sh`) — hier für Windows übersetzt.
+#:
+#: `app_UpdateEnable` ist MakeMKVs Web-Kontakt. Er ist ab Werk an, und genau
+#: deshalb steht er in der entrypoint.sh: „damit die Einstellung
+#: nachvollziehbar ist und nicht versehentlich kippt". Quelle dort:
+#: forum.makemkv.com/forum/viewtopic.php?t=20364
+#:
+#: Für Rippy hängt daran mehr als Kosmetik: Über diesen Kanal holt MakeMKV die
+#: Disc-Schlüssel für 4K-UHD nach (Meldung 3338 „Downloading latest HK to …",
+#: am 25.07.2026 auf einem Windows-PC gemessen — unter Linux passiert es nie).
+#: Ohne ihn scheitert jede unbekannte UHD-Pressung.
+#:
+#: Auf dem Rechner des Commanders nachgesehen (29.08.2026): **nicht gesetzt.**
+#: Die Werte daneben (`app_UpdateLastCheck`, `app_BackupDecrypted`) zeigen die
+#: native Form — Wahrheitswerte stehen in der Registry als DWORD, nicht als
+#: Text wie in der settings.conf.
+DOCKER_EINSTELLUNGEN = {"app_UpdateEnable": 1}
+
+
+def einstellungen_sicherstellen(plattform_name: str = None, setzer=None,
+                                lesen=None) -> list:
+    """Setzt fehlende MakeMKV-Einstellungen. Gibt zurück, was gesetzt wurde.
+
+    **Nur was FEHLT.** Wer den Web-Kontakt bewusst abgeschaltet hat, soll ihn
+    abgeschaltet behalten — Rippy stellt einen Ausgangszustand her, es
+    überstimmt keine Entscheidung.
+    """
+    if not plattform(plattform_name).startswith("win"):
+        # Im Container macht das die entrypoint.sh, und zwar in der
+        # settings.conf. Hier nichts tun statt es doppelt zu machen.
+        return []
+    lesen = lesen or _registry_hat
+    setzer = setzer or _registry_dword
+    gesetzt = []
+    for name, wert in DOCKER_EINSTELLUNGEN.items():
+        try:
+            if lesen(name):
+                continue
+            setzer(name, wert)
+            gesetzt.append(name)
+        except OSError:
+            continue          # Registry nicht schreibbar — kein Beinbruch
+    return gesetzt
+
+
+def _registry_hat(name: str) -> bool:
+    import winreg
+
+    try:
+        with winreg.OpenKey(winreg.HKEY_CURRENT_USER, REGISTRY_PFAD) as s:
+            winreg.QueryValueEx(s, name)
+        return True
+    except OSError:
+        return False
+
+
+def _registry_dword(name: str, wert: int) -> None:
+    import winreg
+
+    with winreg.CreateKey(winreg.HKEY_CURRENT_USER, REGISTRY_PFAD) as s:
+        winreg.SetValueEx(s, name, 0, winreg.REG_DWORD, int(wert))
+
+
+def key_zuruecknehmen(plattform_name: str = None, entferner=None) -> bool:
+    """Einen abgelehnten Schlüssel wieder entfernen. True, wenn etwas wegging."""
+    if not plattform(plattform_name).startswith("win"):
+        return False
+    return (entferner or _aus_registry)()
+
+
+def _aus_registry() -> bool:
+    import winreg
+
+    try:
+        with winreg.OpenKey(winreg.HKEY_CURRENT_USER, REGISTRY_PFAD, 0,
+                            winreg.KEY_ALL_ACCESS) as schluessel:
+            winreg.DeleteValue(schluessel, KEY_NAME)
+        return True
+    except OSError:
+        return False           # war nicht da — auch gut
+
+
+def key_pruefen(programm: str, laufen=None) -> dict:
+    """Nimmt MakeMKV den hinterlegten Schlüssel an? — es selbst gefragt.
+
+    `{"ok": bool, "code": int|None, "grund": str}`.
+
+    ## Warum GEFRAGT und nicht gerechnet (Befund 29.08.2026)
+
+    Rippy hat den frischen Beta-Key aus dem Forum geholt und abgelegt — alles
+    richtig. Auf dem Rechner des Commanders antwortete MakeMKV darauf:
+
+        5020  „Der hinterlegte Aktivierungsschlüssel ist ungültig."
+        5021  „Diese Programmversion ist zu alt."
+
+    Sein MakeMKV 1.18.4 ist älter als der Schlüssel verlangt. Rippys
+    Update-Prüfung kann das NICHT sehen: makemkv.com antwortet seit Tagen mit
+    HTTP 525, und die Ausweichquellen kennen als höchste Fassung genau 1.18.4
+    (gemessen). Die einzige Instanz, die die Wahrheit kennt, ist MakeMKV
+    selbst.
+
+    ## Warum das wichtiger ist, als es klingt
+
+    **Ein abgelehnter Schlüssel ist schlimmer als gar keiner.** Ohne Schlüssel
+    lief MakeMKV im abgelaufenen Testmodus und las die Disc immerhin noch (68
+    TINFO-Zeilen). Mit dem abgelehnten verweigerte es alles — 0 Titel, kein
+    Laufwerk. Wer also blind schreibt, verschlechtert den Zustand.
+
+    Der Aufruf ist billig: kein Datenträger nötig, MakeMKV meldet die
+    Freischaltung schon beim Start.
+    """
+    if not programm:
+        return {"ok": False, "code": None, "grund": "MakeMKV nicht gefunden"}
+    laufen = laufen or _makemkvcon_laufen
+    try:
+        ausgabe = laufen(programm)
+    except Exception as e:                            # noqa: BLE001
+        return {"ok": False, "code": None,
+                "grund": "MakeMKV nicht befragbar (%s)" % type(e).__name__}
+
+    for zeile in text_von(ausgabe).splitlines():
+        if not zeile.startswith("MSG:"):
+            continue
+        try:
+            code = int(zeile[4:].split(",", 1)[0])
+        except ValueError:
+            continue
+        if code in KEY_ABGELEHNT:
+            return {"ok": False, "code": code, "grund": KRITISCHE_CODES[code]}
+    return {"ok": True, "code": None, "grund": ""}
+
+
+def _makemkvcon_laufen(programm: str):
+    import subprocess
+
+    from rippy.platform.winlauf import OHNE_FENSTER
+
+    # `info disc:9999` fragt nur die Laufwerksliste ab — kein Datenträger
+    # nötig, und die Freischaltungs-Meldung kommt trotzdem.
+    ergebnis = subprocess.run([programm, "-r", "--noscan", "info", "disc:9999"],
+                              capture_output=True, timeout=120,
+                              creationflags=OHNE_FENSTER)
+    return ergebnis.stdout
+
+
+def key_setzen_und_pruefen(key: str, programm: str, plattform_name: str = None,
+                           schreiber=None, pruefer=None, entferner=None) -> dict:
+    """Schlüssel ablegen — und wieder wegnehmen, wenn MakeMKV ihn ablehnt.
+
+    Gibt `{"ok", "wohin", "grund"}` zurück. Siehe `key_pruefen`, warum das
+    Zurücknehmen wichtig ist.
+    """
+    wohin = key_ablegen(key, plattform_name, schreiber=schreiber)
+    if not wohin:
+        return {"ok": False, "wohin": "", "grund": "kein Schlüssel angegeben"}
+    urteil = (pruefer or key_pruefen)(programm)
+    if urteil["ok"]:
+        return {"ok": True, "wohin": wohin, "grund": ""}
+    key_zuruecknehmen(plattform_name, entferner=entferner)
+    return {"ok": False, "wohin": wohin, "grund": urteil["grund"]}
+
+
+def _in_datei(key: str) -> str:
+    import os
+
+    from rippy.rip import makemkv_daten
+
+    ordner = makemkv_daten.DATEN_DIR
+    pfad = os.path.join(ordner, "settings.conf")
+    os.makedirs(ordner, exist_ok=True)
+    try:
+        with open(pfad, encoding="utf-8", errors="replace") as f:
+            alt = f.read()
+    except OSError:
+        alt = ""
+    with open(pfad, "w", encoding="utf-8", newline="\n") as f:
+        f.write(makemkv_daten.settings_conf_zusammenfuehren(alt, key))
+    return pfad

src/rippy/rip/makemkv_daten.py

@@ -62,13 +62,68 @@ es eins: `rippy`. Die Kopie ist weg, der Wächter-Test damit gegenstandslos.
 import io
 import os
 import re
+import sys
 import tarfile
 from datetime import datetime, timezone
 
-# Container-Pfad aus der Umgebung: /root/.MakeMKV im Worker (nur dort sucht
-# makemkvcon), /app/makemkv-data in der API. Beide zeigen laut
-# docker-compose.yml auf DASSELBE Host-Verzeichnis.
-DATEN_DIR = os.getenv("MAKEMKV_DATA_DIR", "/root/.MakeMKV")
+def daten_verzeichnis(umgebung=None, plattform_name=None, existiert=None) -> str:
+    """Wo makemkvcon SEINE Einstellungen sucht — je Rechner ein anderer Ort.
+
+    ## Der Befund des Commanders (29.08.2026)
+
+    Beim ersten echten Rip-Versuch meldete makemkvcon neben dem Öffnen-Fehler
+    auch das hier (an seiner Disc gemessen):
+
+        MSG:5051 „Der Testzeitraum ist abgelaufen. Erwerben Sie bitte einen
+                 Aktivierungsschlüssel"
+
+    Und das, obwohl in seinen Einstellungen ein gültiger Beta-Key lag.
+
+    Hier stand `os.getenv("MAKEMKV_DATA_DIR", "/root/.MakeMKV")`. Im Container
+    stimmt das. Auf einem Windows-PC schrieb Rippy den Key damit nach
+    `/root/.MakeMKV` — was dort ein Ordner namens `root\\.MakeMKV` auf dem
+    aktuellen Laufwerk ist. MakeMKV liest `%USERPROFILE%\\.MakeMKV`
+    (gemessen am 26.07.2026 auf genau diesem Rechner, MakeMKV 1.18.4), und
+    dort lag **keine settings.conf**.
+
+    Der Key wurde also brav geholt, brav gespeichert — nur an einer Stelle,
+    die niemand liest. Eine Automatik, die ins Leere schreibt, ist schlimmer
+    als keine: Sie sieht aus wie erledigt.
+
+    `docker/worker/schluessel.py` kannte den richtigen Ort seit einem Monat.
+    Zwei Module, zwei Antworten, eine davon falsch — dieselbe Sorte Fund wie
+    `os.path` und `/app/media`.
+
+    Alles einspritzbar, damit jeder Betriebsfall ohne ihn prüfbar ist.
+    """
+    umgebung = os.environ if umgebung is None else umgebung
+    existiert = existiert or os.path.isdir
+    gesetzt = (umgebung.get("MAKEMKV_DATA_DIR") or "").strip()
+    if gesetzt:
+        return gesetzt          # docker-compose entscheidet, wenn es das tut
+
+    system = (plattform_name if plattform_name is not None else sys.platform).lower()
+    if not system.startswith("win"):
+        return "/root/.MakeMKV"
+
+    # Windows: MakeMKV ist über die Versionen umgezogen. Geprüft wird, welcher
+    # Ort wirklich da ist, statt einen zu behaupten. Der erste ist zugleich
+    # der Ort zum ANLEGEN, wenn es noch gar keinen gibt — MakeMKV legt sein
+    # Verzeichnis erst beim ersten Speichern an.
+    profil = umgebung.get("USERPROFILE") or os.path.expanduser("~")
+    kandidaten = [
+        os.path.join(profil, ".MakeMKV"),
+        os.path.join(umgebung.get("APPDATA") or "", "MakeMKV"),
+        os.path.join(umgebung.get("LOCALAPPDATA") or "", "MakeMKV"),
+    ]
+    for pfad in kandidaten:
+        if pfad and existiert(pfad):
+            return pfad
+    return kandidaten[0]
+
+
+#: Beim Laden ausgerechnet — die Aufrufer kennen ihn als Konstante.
+DATEN_DIR = daten_verzeichnis()
 
 # GROSS geschrieben — unter Linux case-sensitiv, "keydb.cfg" wird ignoriert.
 KEYDB_NAME = "KEYDB.cfg"

src/rippy/rip/test_handbrake_aufruf.py

@@ -0,0 +1,32 @@
+"""Warum HandBrakes Ausgabe mit errors="replace" gelesen wird.
+
+Der Test prueft die VORAUSSETZUNG, nicht die Zuweisung: dass HandBrakes
+OEM-Bytes in cp1252 wirklich nicht dekodierbar sind. Gemessen am 30.08.2026
+am mitgelieferten HandBrakeCLI 1.11.2 (AGENTS Regel D).
+"""
+
+from rippy.rip import handbrake_aufruf
+
+
+def test_oem_umlaute_sprengen_cp1252():
+    """u-Umlaut ist in CP850 das Byte 0x81 — und in cp1252 undefiniert."""
+    oem = "Glück über München".encode("cp850")
+    assert b"\x81" in oem
+    try:
+        oem.decode("cp1252")
+        raise AssertionError("cp1252 haette 0x81 ablehnen muessen")
+    except UnicodeDecodeError:
+        pass
+
+
+def test_mit_der_eingestellten_fehlerbehandlung_bricht_nichts_mehr():
+    oem = "Glück über München".encode("cp850")
+    text = oem.decode("cp1252", handbrake_aufruf.HB_LESEN["errors"])
+    assert text.startswith("Gl")          # ASCII bleibt heil
+    assert "ber" in text and "nchen" in text
+
+
+def test_universal_newlines_bleiben_an():
+    """HandBrake trennt Fortschrittszeilen mit CR — ohne text=True waere der
+    Fortschrittsbalken weg (deshalb NICHT binaer wie bei makemkvcon)."""
+    assert handbrake_aufruf.HB_LESEN["text"] is True

src/rippy/rip/test_makemkv_aufruf.py

@@ -0,0 +1,288 @@
+"""Wie makemkvcon angesprochen und wie seine Antwort gelesen wird.
+
+## Der Befund des Commanders (29.08.2026)
+
+> „Das Rippen der disk funktioniert nicht. makemkvcon endete mit Code 11 —
+> letzte Meldung: Das Öffnen der Disk schlug fehl — keine MKV-Datei
+> entstanden"
+
+In dem einen Satz stecken DREI Fehler, und alle drei sind an seinem Laufwerk
+gemessen worden:
+
+**1. Die Quellenangabe.** Rippy uebergab `dev:\\\\.\\G:`.
+
+    dev:\\\\.\\G:  MSG:2024 „Unknown device" -> MSG:5010 Öffnen schlug fehl
+    dev:G:     68 TINFO-Zeilen, „Die Aufgabe wurde erfolgreich abgeschlossen"
+
+**2. `Ö` statt `Ö`.** Das ist `Ö` als UTF-8 (C3 96), gelesen als cp1252 —
+also eine Ausgabe, die anders geschrieben als gelesen wurde.
+
+**3. Die Ursache fehlte.** Im selben Lauf meldete makemkvcon MSG:5051 „Der
+Testzeitraum ist abgelaufen". Gesucht wurde aber nur nach dem ENGLISCHEN
+„evaluation period has expired" — auf einem deutschen Windows trifft das nie.
+Uebrig blieb die nichtssagende letzte Zeile.
+"""
+
+import pytest
+
+from rippy.rip import makemkv_aufruf as auf
+
+
+# ── 1. Die Quellenangabe ────────────────────────────────────────────────
+@pytest.mark.parametrize("geraet,erwartet", [
+    # DER Fall des Commanders: so meldet rippy.drives.windows das Laufwerk.
+    (r"\\.\G:", "dev:G:"),
+    (r"\\?\G:", "dev:G:"),
+    ("G:", "dev:G:"),
+    ("G:\\", "dev:G:"),
+    ("G:/", "dev:G:"),
+    # Linux bleibt unveraendert — die Reparatur darf den Container nicht anfassen.
+    ("/dev/sr0", "dev:/dev/sr0"),
+    ("/dev/sr1", "dev:/dev/sr1"),
+])
+def test_jede_schreibweise_wird_zu_dem_was_makemkv_versteht(geraet, erwartet):
+    assert auf.quelle(geraet) == erwartet
+
+
+def test_ohne_geraet_kommt_nichts():
+    """Ein `dev:` ohne Pfad waere eine Quellenangabe, die nichts benennt."""
+    assert auf.quelle("") == ""
+    assert auf.quelle(None) == ""
+    assert auf.quelle("   ") == ""
+
+
+def test_ein_langer_windows_pfad_wird_nicht_verstuemmelt():
+    """Die Kuerzung gilt NUR fuer die nackte Laufwerkswurzel."""
+    assert auf.quelle(r"\\.\D:\Ordner") == "dev:D:\\Ordner"
+
+
+# ── 2. Die Kodierung ────────────────────────────────────────────────────
+def test_utf8_ausgabe_wird_richtig_gelesen():
+    """So kommt es an, wenn Rippy die Konsole auf UTF-8 gestellt hat."""
+    assert auf.text_von("Das Öffnen".encode("utf-8")) == "Das Öffnen"
+
+
+def test_cp1252_ausgabe_wird_AUCH_richtig_gelesen():
+    """So kommt es an, wenn nicht — direkt an makemkvcon gemessen."""
+    assert auf.text_von("Das Öffnen".encode("cp1252")) == "Das Öffnen"
+
+
+def test_der_fehler_des_commanders_kommt_NICHT_zurueck():
+    """`Ö` darf nirgends mehr entstehen."""
+    for kodierung in ("utf-8", "cp1252"):
+        gelesen = auf.text_von("Das Öffnen der Disk schlug fehl".encode(kodierung))
+        assert "Ã" not in gelesen, "Doppelt kodiert: %r" % gelesen
+        assert gelesen == "Das Öffnen der Disk schlug fehl"
+
+
+def test_text_bleibt_text_und_leer_bleibt_leer():
+    assert auf.text_von("schon Text") == "schon Text"
+    assert auf.text_von(b"") == ""
+    assert auf.text_von(None) == ""
+
+
+def test_unlesbare_bytes_werfen_nicht():
+    """Eine kaputte Zeile darf keinen laufenden Rip umwerfen."""
+    assert auf.text_von(b"\xff\xfe kaputt") is not None
+
+
+# ── 3. Die Ursache ──────────────────────────────────────────────────────
+def test_die_gemessenen_ursachen_haben_eine_nummer():
+    """Nummern gelten in jeder Sprache, Texte nicht."""
+    assert 2024 in auf.KRITISCHE_CODES, "Unknown device"
+    assert 5051 in auf.KRITISCHE_CODES, "Testzeitraum abgelaufen"
+    assert 5020 in auf.KRITISCHE_CODES, "Aktivierungsschluessel ungueltig"
+    assert 5021 in auf.KRITISCHE_CODES, "Programmversion zu alt"
+
+
+def test_jede_ursache_ist_auf_deutsch_erklaert():
+    """Der Commander liest diese Zeile — eine Nummer allein hilft ihm nicht."""
+    for code, text in auf.KRITISCHE_CODES.items():
+        assert len(text) > 20, "%d ist nicht erklaert: %r" % (code, text)
+        assert not text.startswith("MSG"), code
+
+
+# ── 4. Wohin gehoert der Schluessel — und was, wenn er abgelehnt wird ────
+#
+# Weiterer Befund vom 29.08.2026, in zwei Schritten gemessen:
+#
+# Erst schrieb Rippy den Beta-Key nach `/root/.MakeMKV/settings.conf` — ein
+# Container-Pfad. Nach der Reparatur des Ordners blieb MSG:5051
+# („Testzeitraum abgelaufen") trotzdem stehen. Nachgesehen, was auf dem
+# Rechner wirklich existiert:
+#
+#     C:\Users\TobisPC\.MakeMKV\   nur _private_data.tar (6,4 MB)
+#     HKCU\Software\MakeMKV        app_UpdateLastCheck, app_SiteInfoString, …
+#
+# Unter Windows haelt MakeMKV seine Einstellungen in der REGISTRY. Rippy hat
+# den Key also zweimal brav gespeichert — beide Male an einen Ort, den
+# niemand liest.
+#
+# Und dann der Nachschlag: Mit dem Key in der Registry verschwand 5051, dafuer
+# kam 5020 („Aktivierungsschluessel ungueltig") und 5021 („Diese
+# Programmversion ist zu alt"). Sein MakeMKV 1.18.4 ist aelter als der
+# aktuelle Beta-Key verlangt. WICHTIG: Ohne Key las MakeMKV die Disc noch (68
+# TINFO-Zeilen), mit dem abgelehnten verweigerte es alles — 0 Titel.
+# **Ein abgelehnter Schluessel ist schlimmer als gar keiner.**
+
+
+def test_unter_windows_geht_der_key_in_die_registry():
+    gelandet = []
+    auf.key_ablegen("T-abc", plattform_name="win32",
+                    schreiber=lambda k: gelandet.append(k) or r"HKCU\Software\MakeMKV")
+    assert gelandet == ["T-abc"]
+
+
+def test_unter_linux_bleibt_es_die_datei():
+    """Der Container-Weg darf sich durch die Reparatur NICHT aendern."""
+    gelandet = []
+    wohin = auf.key_ablegen("T-abc", plattform_name="linux",
+                            datei_schreiber=lambda k: gelandet.append(k) or "/root/.MakeMKV/settings.conf")
+    assert gelandet == ["T-abc"]
+    assert wohin.endswith("settings.conf")
+
+
+def test_ohne_key_wird_nichts_geschrieben():
+    """Sonst stuende ein leerer app_Key da — und der ist ein ungueltiger."""
+    assert auf.key_ablegen("", plattform_name="win32",
+                           schreiber=lambda k: 1 / 0) == ""
+    assert auf.key_ablegen(None, plattform_name="win32",
+                           schreiber=lambda k: 1 / 0) == ""
+
+
+AUSGABE_ABGELEHNT = (
+    'MSG:1005,0,1,"MakeMKV v1.18.4 win(x64-release) gestartet"\n'
+    'MSG:5020,0,0,"Der hinterlegte Aktivierungsschlüssel ist ungültig."\n'
+    'MSG:5021,0,0,"Diese Programmversion ist zu alt."\n'
+).encode("utf-8")
+
+AUSGABE_GUT = (
+    'MSG:1005,0,1,"MakeMKV v1.18.4 win(x64-release) gestartet"\n'
+    'DRV:0,2,999,12,"BD-RE BU40N","","G:"\n'
+).encode("utf-8")
+
+
+def test_ein_abgelehnter_schluessel_wird_erkannt():
+    urteil = auf.key_pruefen("makemkvcon", laufen=lambda p: AUSGABE_ABGELEHNT)
+    assert urteil["ok"] is False
+    assert urteil["code"] == 5020
+    assert "nicht angenommen" in urteil["grund"]
+
+
+def test_ein_angenommener_schluessel_auch():
+    assert auf.key_pruefen("makemkvcon", laufen=lambda p: AUSGABE_GUT)["ok"] is True
+
+
+def test_ohne_makemkv_wird_nichts_behauptet():
+    """„Nicht befragbar" ist keine Aussage ueber den Schluessel."""
+    urteil = auf.key_pruefen("")
+    assert urteil["ok"] is False
+    assert "nicht gefunden" in urteil["grund"]
+
+
+def test_ein_abgelehnter_schluessel_wird_WIEDER_ENTFERNT():
+    """Der Kern des Befundes: Ohne Key las MakeMKV die Disc noch, mit dem
+    abgelehnten verweigerte es alles. Blind schreiben verschlechtert."""
+    geschrieben, entfernt = [], []
+    ergebnis = auf.key_setzen_und_pruefen(
+        "T-zualt", "makemkvcon", plattform_name="win32",
+        schreiber=lambda k: geschrieben.append(k) or r"HKCU\Software\MakeMKV",
+        pruefer=lambda p: {"ok": False, "code": 5021,
+                           "grund": auf.KRITISCHE_CODES[5021]},
+        entferner=lambda: entfernt.append(True) or True)
+    assert geschrieben == ["T-zualt"]
+    assert entfernt == [True], "der abgelehnte Schluessel muss wieder weg"
+    assert ergebnis["ok"] is False
+    assert "zu alt" in ergebnis["grund"]
+
+
+def test_ein_angenommener_schluessel_bleibt_liegen():
+    entfernt = []
+    ergebnis = auf.key_setzen_und_pruefen(
+        "T-gut", "makemkvcon", plattform_name="win32",
+        schreiber=lambda k: r"HKCU\Software\MakeMKV",
+        pruefer=lambda p: {"ok": True, "code": None, "grund": ""},
+        entferner=lambda: entfernt.append(True) or True)
+    assert ergebnis["ok"] is True
+    assert entfernt == [], "ein gueltiger Schluessel darf nicht angefasst werden"
+
+
+def test_die_codes_stehen_so_da_wie_gemessen():
+    """Waechter gegen den Fehler, den ich am 29.08.2026 selbst gemacht habe:
+    5021 aus dem Kopf mit „Volume-Key unbekannt" zu beschriften."""
+    assert "zu alt" in auf.KRITISCHE_CODES[5021]
+    assert "Volume" not in auf.KRITISCHE_CODES[5021]
+    assert auf.KEY_ABGELEHNT == (5020, 5021)
+
+
+# ── 5. Was der Docker-Betrieb setzt, gilt auch auf Windows ──────────────
+#
+# Commander 29.08.2026: „Prüfe doch einfach mal wie die Docker Rippy heute
+# funktioniert. Schau was du davon abschließend übernehmen kannst. Wichtig ist
+# das du das für Windows Umschreibst."
+#
+# `docker/worker/entrypoint.sh` setzt vor JEDEM Worker-Start zwei Dinge in
+# MakeMKVs settings.conf: `app_Key` und `app_UpdateEnable`. Der Key war schon
+# uebernommen — `app_UpdateEnable` nicht.
+#
+# Das ist MakeMKVs Web-Kontakt. Ueber ihn holt MakeMKV die Disc-Schluessel
+# fuer 4K-UHD nach (Meldung 3338, auf Windows gemessen; unter Linux passiert
+# es nie). Auf dem Rechner des Commanders nachgesehen: NICHT gesetzt.
+#
+# „Fuer Windows umschreiben" heisst hier konkret: Registry statt Datei, und
+# DWORD statt Text — die Nachbarwerte (`app_BackupDecrypted`) zeigen die Form.
+
+
+def test_windows_setzt_was_der_entrypoint_setzt():
+    gesetzt = {}
+    namen = auf.einstellungen_sicherstellen(
+        plattform_name="win32",
+        lesen=lambda n: False,
+        setzer=lambda n, w: gesetzt.__setitem__(n, w))
+    assert "app_UpdateEnable" in namen
+    assert gesetzt["app_UpdateEnable"] == 1, "in der Registry ein DWORD, kein Text"
+
+
+def test_eine_vorhandene_einstellung_wird_NICHT_ueberschrieben():
+    """Wer den Web-Kontakt bewusst abgeschaltet hat, behaelt ihn abgeschaltet.
+    Rippy stellt einen Ausgangszustand her, es ueberstimmt keine Entscheidung."""
+    angefasst = []
+    namen = auf.einstellungen_sicherstellen(
+        plattform_name="win32",
+        lesen=lambda n: True,
+        setzer=lambda n, w: angefasst.append(n))
+    assert namen == [] and angefasst == []
+
+
+def test_im_container_macht_das_der_entrypoint():
+    """Dort steht es in der settings.conf — doppelt waere zwei Wahrheiten."""
+    assert auf.einstellungen_sicherstellen(plattform_name="linux",
+                                           lesen=lambda n: False,
+                                           setzer=lambda n, w: 1 / 0) == []
+
+
+def test_eine_gesperrte_registry_wirft_nicht():
+    """Ein Einstellungswert ist kein Grund, warum nichts geht."""
+    def sperrt(n, w):
+        raise OSError(5, "Zugriff verweigert")
+
+    assert auf.einstellungen_sicherstellen(plattform_name="win32",
+                                           lesen=lambda n: False,
+                                           setzer=sperrt) == []
+
+
+def test_der_entrypoint_und_windows_kennen_DIESELBEN_namen():
+    """Waechter: Kommt in der entrypoint.sh eine Einstellung dazu, muss sie
+    hier auftauchen — sonst driften Docker und Windows auseinander."""
+    import io
+    import os
+    import re
+
+    hier = os.path.dirname(os.path.abspath(__file__))
+    pfad = os.path.join(hier, "..", "..", "..", "docker", "worker", "entrypoint.sh")
+    with io.open(os.path.abspath(pfad), encoding="utf-8") as f:
+        text = f.read()
+    im_entrypoint = set(re.findall(r"\bapp_[A-Za-z]+", text))
+    # app_Key laeuft ueber `key_ablegen`, der Rest ueber DOCKER_EINSTELLUNGEN.
+    offen = im_entrypoint - {"app_Key"} - set(auf.DOCKER_EINSTELLUNGEN)
+    assert not offen, "entrypoint.sh setzt %s — Windows nicht" % sorted(offen)

src/rippy/standalone.py

@@ -1,243 +0,0 @@
-"""Standalone-Betrieb: Auftraege lokal zustellen und im selben Prozess abarbeiten.
-
-## Was hier zusammenkommt
-
-Das ist das letzte Stueck, damit Rippy unter Windows nicht nur ANZEIGEN,
-sondern auch ARBEITEN kann:
-
-    celery_client.zusteller_setzen(…)   die API reiht lokal ein statt an Celery
-    rippy.queue.lokal                   die Auftragstabelle mit Lease
-    rippy.queue.laeufer                 holt sie und arbeitet sie ab
-    ablauf.rippen / .komprimieren       der Ablauf selbst, ohne Celery
-
-Der Ablauf ist derselbe wie im Docker-Betrieb — Zeile fuer Zeile dieselbe
-Datei. Was sich unterscheidet, ist allein die Zustellung.
-
-## Warum die Task-NAMEN erhalten bleiben
-
-Die API schickt `"worker.tasks.rip_disc"` los. Dieser Name ist der Vertrag
-zwischen API und Worker; `test_api_smoke.py` nagelt ihn ausdruecklich fest.
-Hier wird er deshalb NICHT durch etwas Eigenes ersetzt, sondern uebersetzt —
-so bleibt beides gueltig, und ein Betrieb laesst sich umstellen, ohne dass
-die API etwas davon merkt.
-
-## Warum die Kompression NICHT weitergereicht wird
-
-`ablauf.rippen()` nimmt einen Rueckruf `weiterreichen`, mit dem die
-Kompression an einen anderen Knoten geht. Im Standalone-Betrieb gibt es
-keinen anderen Knoten — hier komprimiert derselbe Prozess weiter. Deshalb
-wird der Rueckruf bewusst NICHT gestellt: `ablauf` ruft dann selbst
-`komprimieren()` auf, im selben Auftrag, ohne Umweg ueber die Queue.
-
-Das ist auch das Ehrlichere: Eine Queue mit genau einem Bearbeiter, die
-Arbeit an sich selbst weiterreicht, ist nur Zeremonie.
-"""
-
-import os
-import sys
-import threading
-
-# Die Auftragsarten, die die API kennt — auf die Formen, die `ablauf` versteht.
-AUFTRAGSARTEN = {
-    "worker.tasks.rip_disc": "rip",
-    "worker.tasks.transcode_files": "transcode",
-    "worker.tasks.scan_tracks": "scan",
-}
-
-
-def _worker_pfad() -> str:
-    """Wo liegen die Worker-Module (ablauf.py, ripping.py, medien.py)?
-
-    Dieselben drei Faelle wie bei der API (siehe `daemon._api_pfad`): aus dem
-    Repo gestartet, im PyInstaller-Paket, oder installiert.
-    """
-    gebuendelt = getattr(sys, "_MEIPASS", None)
-    if gebuendelt:
-        return os.path.join(gebuendelt, "worker")
-
-    hier = os.path.dirname(os.path.abspath(__file__))
-    repo = os.path.dirname(os.path.dirname(hier))
-    kandidaten = [
-        os.path.join(repo, "docker", "worker"),
-        os.path.join(os.path.dirname(sys.executable), "worker"),
-    ]
-    for pfad in kandidaten:
-        if os.path.isfile(os.path.join(pfad, "ablauf.py")):
-            return pfad
-    raise RuntimeError(
-        "Die Worker-Module wurden nicht gefunden. Gesucht wurde in:\n  "
-        + "\n  ".join(kandidaten)
-        + "\nOhne sie kann Rippy nicht rippen."
-    )
-
-
-def _ablauf():
-    """`ablauf` importieren — erst beim ersten Bedarf.
-
-    Nicht auf Modulebene: Das Modul zieht `ripping`, `medien` und `db` nach,
-    und die brauchen einen gesetzten sys.path. Ausserdem soll der Import
-    nicht schon beim Start des Servers passieren, sondern dann, wenn wirklich
-    gearbeitet wird.
-    """
-    pfad = _worker_pfad()
-    if pfad not in sys.path:
-        sys.path.insert(0, pfad)
-    import ablauf
-
-    return ablauf
-
-
-# ── Zustellung ──────────────────────────────────────────────────────────
-def zustellung_bauen(bus=None):
-    """Gibt die Funktion zurueck, die `celery_client.zusteller_setzen` erwartet."""
-    from rippy.queue import lokal
-
-    def zustellen(task_name: str, args: list, queue: str = None):
-        art = AUFTRAGSARTEN.get(task_name)
-        if art is None:
-            raise ValueError(
-                f"Unbekannte Auftragsart {task_name!r}. Bekannt sind: "
-                + ", ".join(sorted(AUFTRAGSARTEN))
-                + ". Wer eine neue einfuehrt, traegt sie in "
-                  "rippy/standalone.py AUFTRAGSARTEN ein — sonst landet sie "
-                  "im Standalone-Betrieb nirgends, und zwar lautlos."
-            )
-        if art == "rip":
-            device_path, job_id, target_dir = (list(args) + [None, None, None])[:3]
-            auftrag_id = lokal.einreihen(
-                job_id, "rip", faehigkeiten={"art": "rip"},
-                payload={"device_path": device_path, "target_dir": target_dir})
-        elif art == "transcode":
-            job_id, raw_dir, final_dir = (list(args) + [None, None, None])[:3]
-            auftrag_id = lokal.einreihen(
-                job_id, "transcode", faehigkeiten={"art": "transcode"},
-                payload={"raw_dir": raw_dir, "final_dir": final_dir})
-        else:                                   # scan
-            device_path = args[0] if args else ""
-            auftrag_id = lokal.einreihen(
-                "", "scan", faehigkeiten={"art": "scan"},
-                payload={"device_path": device_path})
-
-        if bus:
-            try:
-                bus.senden("system.notice",
-                           {"level": "info", "text": f"{art} eingereiht"})
-            except Exception:
-                pass
-        return auftrag_id
-
-    return zustellen
-
-
-# ── Ausfuehrung ─────────────────────────────────────────────────────────
-def ausfuehren(auftrag: dict):
-    """Arbeitet EINEN Auftrag ab — der Laeufer ruft das auf."""
-    import json
-
-    ablauf = _ablauf()
-    try:
-        payload = json.loads(auftrag.get("payload") or "{}")
-    except (ValueError, TypeError):
-        payload = {}
-
-    art = auftrag.get("art")
-    if art == "rip":
-        # KEIN `weiterreichen`: Im Standalone-Betrieb komprimiert derselbe
-        # Prozess weiter (siehe Modul-Docstring).
-        return ablauf.rippen(payload.get("device_path"), auftrag["job_id"],
-                             payload.get("target_dir"))
-    if art == "transcode":
-        return ablauf.komprimieren(auftrag["job_id"], payload.get("raw_dir"),
-                                   payload.get("final_dir"))
-    if art == "scan":
-        return ablauf.scan_tracks(payload.get("device_path"))
-    raise ValueError(f"Unbekannte Auftragsart im Auftrag: {art!r}")
-
-
-# ── Herzschlag ──────────────────────────────────────────────────────────
-HERZSCHLAG_SEKUNDEN = 60
-
-
-def herzschlag_starten(knoten: str, store, takt: float = HERZSCHLAG_SEKUNDEN):
-    """Meldet DIESEN Prozess als Arbeiter — mit seinen Faehigkeiten.
-
-    ## Warum das noetig ist
-
-    `/capabilities` liest die `workers`-Tabelle. Gefuellt hat sie bisher der
-    Celery-Herzschlag in `celery_app.py`. Im Standalone-Betrieb gibt es den
-    nicht — also stand dort „0 Worker", und im UI blieb die Encoder-Auswahl
-    LEER. Rippy haette auf einem Rechner mit AMD-Hardwarebeschleunigung
-    behauptet, es koenne nichts.
-
-    Gemeldet wird, was `caps.py` MISST: die Encoder, die HandBrake auf dieser
-    Maschine wirklich anbietet, die Preset-Namen dieser HandBrake-Fassung,
-    CPU-Modell, Kerne und Vektorbefehle. Nichts davon wird behauptet — das
-    ist die Lehre aus Etappe 19 („Encoder wurden behauptet statt gemessen").
-    """
-    import threading
-    import time
-
-    def schlagen():
-        while True:
-            try:
-                pfad = _worker_pfad()
-                if pfad not in sys.path:
-                    sys.path.insert(0, pfad)
-                import caps
-
-                store.save_worker(knoten, caps.erkenne_encoder(),
-                                  caps.werkzeug_versionen())
-            except Exception as e:
-                # Nicht sterben — aber auch nicht schweigen.
-                try:
-                    store.add_log("warning", "standalone",
-                                  f"Faehigkeiten-Meldung fehlgeschlagen: {e}")
-                except Exception:
-                    pass
-            time.sleep(takt)
-
-    threading.Thread(target=schlagen, daemon=True, name="rippy-herzschlag").start()
-
-
-# ── Alles zusammen ──────────────────────────────────────────────────────
-def starten(knoten: str = None, bus=None, store=None, slots: int = 1) -> list:
-    """Zustellung umbiegen und die Laeufer starten. Gibt die Laeufer zurueck.
-
-    `slots` ist die Zahl gleichzeitiger Auftraege. Vorgabe 1: Ein Rip belegt
-    das Laufwerk, und zwei gleichzeitige Encodes auf einem Rechner sind
-    langsamer als zwei nacheinander.
-    """
-    import socket
-
-    from rippy.queue.laeufer import Laeufer
-
-    knoten = knoten or socket.gethostname()
-
-    # Die API reiht ab jetzt lokal ein statt an Celery.
-    sys.path.insert(0, os.path.join(
-        os.path.dirname(os.path.dirname(os.path.dirname(
-            os.path.abspath(__file__)))), "docker", "api"))
-    try:
-        import celery_client
-    except ImportError:                          # im Paket liegt sie woanders
-        from rippy.daemon import _api_pfad
-
-        sys.path.insert(0, _api_pfad())
-        import celery_client
-
-    celery_client.zusteller_setzen(zustellung_bauen(bus))
-
-    # Sich selbst als Arbeiter melden — sonst zeigt das UI "0 Worker" und
-    # eine leere Encoder-Auswahl, obwohl dieser Rechner alles kann.
-    if store is not None:
-        herzschlag_starten(knoten, store)
-
-    laeufer = []
-    for nummer in range(max(1, slots)):
-        lauf = Laeufer(ausfuehren, f"{knoten}#{nummer}",
-                       kann={"art=rip", "art=transcode", "art=scan"},
-                       bus=bus, store=store)
-        threading.Thread(target=lauf.schleife, daemon=True,
-                         name=f"rippy-laeufer-{nummer}").start()
-        laeufer.append(lauf)
-    return laeufer

src/rippy/store/__init__.py

@@ -361,6 +361,47 @@ def has_active_job(device: str) -> bool:
     return zeile is not None
 
 
+# Ein Job ist erst fertig, wenn er FERTIG ist. Die Kompression gehoert dazu.
+#
+# ⚠️ Nicht dasselbe wie `has_active_job`. Das fragt „haelt gerade jemand das
+# Laufwerk?" — waehrend der Kompression tut das niemand, ein Auswurf ist dann
+# erlaubt. Hier wird gefragt „ist der Vorgang durch?", und das ist er nicht.
+JOB_OFFEN = ("pending", "running", "transcoding", "canceling")
+
+
+def job_offen(device: str) -> bool:
+    """True, solange auf dem Geraet ein Job noch nicht abgeschlossen ist.
+
+    ## Warum es diese zweite Frage gibt (Befund 29.08.2026)
+
+    Der Commander meldete einen Rip-Fehlschlag „bei der Komprimierung", obwohl
+    der Rip laengst durch war. Der Ablauf dahinter:
+
+      1. Rip fertig  → Rippy wirft die Disc aus (Standardeinstellung)
+      2. Status wird auf `transcoding` gesetzt — und ab hier sagte
+         `has_active_job` NEIN, das Laufwerk sei frei
+      3. Die Disc-Wache sieht beim Auswurf einen Statuswechsel und meldet
+         „eingelegt"
+      4. Die Vollautomatik (`autoRipStart`) startet einen ZWEITEN Rip — auf
+         ein Laufwerk, dessen Schublade gerade herausfaehrt
+
+    Der zweite Rip lief in ein leeres Laufwerk und endete mit „Das Oeffnen der
+    Disk schlug fehl". Auf dem Bildschirm sah das aus, als sei die Kompression
+    gescheitert — sie lief in Wahrheit ungestoert weiter.
+
+    Solange ein Vorgang auf diesem Laufwerk laeuft, faengt die Automatik
+    keinen zweiten an. Von Hand darf der Commander weiterhin alles.
+    """
+    with engine_holen().connect() as conn:
+        zeile = conn.execute(
+            select(jobs.c.id)
+            .where(jobs.c.device == device)
+            .where(jobs.c.status.in_(JOB_OFFEN))
+            .limit(1)
+        ).first()
+    return zeile is not None
+
+
 def meta_merken(job_id: str, **felder) -> None:
     """Ergänzt EINZELNE Schlüssel in den Job-Metadaten. Wirft nie.
 

src/rippy/test_arbeitsort.py

@@ -0,0 +1,124 @@
+"""Wo liegt die Ablage, wo die Rohdaten — und wer darf wohin blaettern?
+
+## Der Befund des Commanders (28.08.2026)
+
+> „Warum heißt das hier noch container platte? Er holt sich das
+> Arbeitsverzeichnis ja von der Installation. Wäre es möglich das
+> Arbeitsverzeichnis zu ändern? momentan geht das nicht."
+
+Beide Haelften desselben Fehlers, und beide gehen auf EINE Zeile zurueck:
+
+    MEDIA_ROOT = "/app/media"
+
+Sie war zugleich Vorgabe UND Pfadgrenze. Auf einem Windows-PC gibt es den
+Ordner nicht:
+
+* `/storage-targets` machte `os.listdir("/app/media")`, fing den `OSError`
+  und gab still `[]` zurueck. Im Auswahlfeld stand genau ein Eintrag — eine
+  Auswahl ohne Auswahl. **Das ist „momentan geht das nicht".**
+* Der Text dieses einen Eintrags war fest verdrahtet „(Container-Platte)".
+  **Das ist „warum heisst das hier noch container platte".**
+* `/browse` prueft `unter_wurzel(pfad, MEDIA_ROOT)` — auf Windows also 422
+  fuer jeden Pfad. Der Ordner-Browser konnte gar nichts anzeigen.
+
+Kein Absturz, keine Meldung. Nur eine Oberflaeche, die stillschweigend
+nichts kann.
+
+## Warum die Grenze nicht einfach faellt
+
+Im Container ist sie richtig. Die API haengt dort im Netz, und eine
+Weboberflaeche, die jeden Pfad des Wirts ausliefert, ist ein Loch. Die
+Unterscheidung ist deshalb nicht „Windows", sondern **wer zuhoert**: Container
+und Kopflos-Betrieb bedienen ein Netz, die native App den Menschen davor.
+
+Alles hier ist eingespritzt — kein Container, kein Windows, keine Platte
+noetig.
+"""
+
+import pytest
+
+from rippy import betrieb
+
+
+CONTAINER = {"profil": "standalone"}
+WINDOWS = {"profil": "standalone"}
+VERTEILT = {"profil": "api", "queue": {"treiber": "celery"}}
+
+
+# ── Wer darf frei blaettern ─────────────────────────────────────────────
+def test_im_container_gilt_die_wurzel():
+    """Die API haengt dort im Netz — freies Blaettern waere ein Loch."""
+    assert betrieb.frei_blaettern(CONTAINER, container=True) is False
+
+
+def test_die_native_app_darf_frei_blaettern():
+    """Sie bedient den Menschen, der vor dem Rechner sitzt. Sein Ziel ist
+    eine UNC-Freigabe, die unter gar keiner lokalen Wurzel liegt."""
+    assert betrieb.frei_blaettern(WINDOWS, container=False) is True
+
+
+def test_der_verteilte_betrieb_darf_NICHT_frei_blaettern():
+    """Kopflos (V2-6) laeuft nativ, bedient aber ein Netz. Der Fall, an dem
+    ein blosses `not container` falsch waere."""
+    assert betrieb.frei_blaettern(VERTEILT, container=False) is False
+
+
+# ── Wo liegt was ────────────────────────────────────────────────────────
+def test_im_container_bleibt_alles_wie_es_war():
+    """Der Docker-Weg darf sich durch diese Reparatur NICHT aendern."""
+    assert betrieb.medien_wurzel({}, container=True) == "/app/media"
+    assert betrieb.arbeits_vorgabe({}, container=True) == "/app/temp"
+
+
+def test_auf_windows_kommt_der_ort_aus_der_installation():
+    """Genau das, was der Commander erwartet hat: „Er holt sich das
+    Arbeitsverzeichnis ja von der Installation."""
+    werte = {"storage": {"medien": "D:\\Rippy\\Medien"}}
+    assert betrieb.medien_wurzel(werte, container=False,
+                                 plattform_name="win32") == "D:\\Rippy\\Medien"
+    assert betrieb.arbeits_vorgabe(werte, container=False,
+                                   plattform_name="win32") == "D:\\Rippy\\Medien\\_arbeit"
+
+
+def test_ein_eigenes_arbeitsverzeichnis_gewinnt():
+    """Wer es eingestellt hat, bekommt es — auf ein anderes Laufwerk zeigend."""
+    werte = {"storage": {"medien": "D:\\Rippy", "temp": "E:\\Roh"}}
+    assert betrieb.arbeits_vorgabe(werte, container=False,
+                                   plattform_name="win32") == "E:\\Roh"
+
+
+def test_die_auskunft_nennt_beide_orte():
+    """Ohne `arbeits_vorgabe` in der Antwort muesste die Oberflaeche wieder
+    raten — und genau daraus wurde „Container-Platte"."""
+    antwort = betrieb.auskunft({"storage": {"medien": "D:\\Rippy"}},
+                               container=False, plattform_name="win32")
+    assert antwort["ablage_vorgabe"] == "D:\\Rippy"
+    assert antwort["arbeits_vorgabe"] == "D:\\Rippy\\_arbeit"
+    assert antwort["kann"]["frei_blaettern"] is True
+
+
+def test_die_auskunft_im_container_nennt_die_container_orte():
+    antwort = betrieb.auskunft({}, container=True, plattform_name="linux")
+    assert antwort["ablage_vorgabe"] == "/app/media"
+    assert antwort["arbeits_vorgabe"] == "/app/temp"
+    assert antwort["kann"]["frei_blaettern"] is False
+
+
+# ── Die Laufwerke ───────────────────────────────────────────────────────
+
+
+@pytest.mark.parametrize("werte,container", [
+    ({}, True),                                       # Media + /app/temp
+    ({"storage": {"medien": "D:\\M"}}, False),        # gleiches Laufwerk
+    ({"storage": {"medien": "D:\\M", "temp": "E:\\R"}}, False),
+])
+def test_es_stehen_immer_beide_orte_da(werte, container):
+    """Ablage UND Arbeitsverzeichnis — in jedem Betrieb, mit Pfad.
+
+    Geaendert am 29.08.2026 auf Wunsch des Commanders: „bei ‚Platz für rippy'
+    sollte eher das arbeitsverzeichnis und der Ablagepfad sein." Vorher fiel
+    die zweite Zeile weg, wenn beide auf derselben Platte lagen.
+    """
+    orte = betrieb.platz_orte(werte, container=container, plattform_name="win32")
+    assert len(orte) == 2
+    assert all(o["pfad"] for o in orte), orte

src/rippy/test_betrieb.py

@@ -0,0 +1,260 @@
+"""Der Betriebsmodus und seine Faehigkeiten.
+
+## Warum es diese Tests gibt
+
+Commander am 28.08.2026, zum Windows-Fenster:
+
+    Worker erreichbar:   0 von 1
+    Kein Worker antwortet — Pruefen: docker compose ps
+    Container-Platte:    unbekannt
+    Freigaben:           keine eingehaengt
+
+Kein Satz davon ergibt auf einem Windows-PC einen Sinn. Die Oberflaeche hatte
+nie erfahren, worauf sie laeuft — also hat sie angenommen.
+
+Alle Pruefungen hier sind eingespritzt: Jeder Betriebsfall ist pruefbar, ohne
+ihn herzustellen. Das ist der Punkt — sonst waere „laeuft im Container" nur
+auf einem Container-Rechner testbar, und genau dort faellt der Windows-Fehler
+nie auf.
+"""
+
+from rippy import betrieb
+
+B = chr(92)          # Backslash, nie woertlich (siehe test_pfade)
+
+DOCKER = {"profil": "api", "queue": {"treiber": "celery", "broker": "redis://x"}}
+WINDOWS = {"profil": "standalone", "queue": {"treiber": "lokal"}}
+
+
+# ── Plattform ───────────────────────────────────────────────────────────
+def test_plattform_wird_zu_einem_klaren_namen():
+    assert betrieb.plattform("win32") == "windows"
+    assert betrieb.plattform("linux") == "linux"
+    assert betrieb.plattform("darwin") == "macos"
+
+
+def test_unbekannte_plattform_gilt_als_linux():
+    """FreeBSD und Verwandte verhalten sich wie Linux — und ein Rueckfall auf
+    etwas Bekanntes ist besser als ein leeres Feld."""
+    assert betrieb.plattform("freebsd14") == "linux"
+
+
+# ── Container ───────────────────────────────────────────────────────────
+def test_container_wird_gemessen_nicht_geraten():
+    """`/.dockerenv` legt Docker selbst an — verlaesslicher als eine
+    Umgebungsvariable, die jeder setzen und vergessen kann."""
+    assert betrieb.im_container(lambda p: p == "/.dockerenv") is True
+    assert betrieb.im_container(lambda p: False) is False
+
+
+# ── Modus ───────────────────────────────────────────────────────────────
+def test_celery_heisst_verteilt():
+    assert betrieb.modus(DOCKER) == "verteilt"
+
+
+def test_lokale_queue_heisst_standalone():
+    assert betrieb.modus(WINDOWS) == "standalone"
+
+
+def test_ohne_angaben_gilt_standalone():
+    """Der harmlosere Rueckfall: Ein standalone-Rippy zeigt nichts an, was es
+    nicht gibt. Andersherum entstuenden die Phantom-Worker wieder."""
+    assert betrieb.modus({}) == "standalone"
+
+
+# ── Die Faehigkeiten — hier sass der gemeldete Fehler ───────────────────
+def test_windows_hat_KEINE_externen_worker():
+    """DER Befund: „Worker erreichbar: 0 von 1 — Kein Worker antwortet."
+    Unter Windows rippt Rippy selbst; es gibt keinen zweiten, auf den man
+    warten koennte. Die Meldung war nicht nur unpassend, sie war falsch."""
+    a = betrieb.auskunft(WINDOWS, container=False, plattform_name="win32")
+    assert a["kann"]["externe_worker"] is False
+
+
+def test_windows_kennt_KEINE_container_pfade():
+    """`/app/media` ist ein Pfad IM Container. Auf Windows heisst der Ordner
+    anders und liegt woanders — ein damit vorbelegtes Feld ist schlicht
+    falsch."""
+    a = betrieb.auskunft(WINDOWS, container=False, plattform_name="win32")
+    assert a["kann"]["container_pfade"] is False
+    assert "/app/" not in a["ablage_vorgabe"]
+
+
+def test_windows_haengt_keine_freigaben_ein():
+    """Unter Windows gibt man einen UNC-Pfad an, fertig. Eine Maske zum
+    Einhaengen waere eine Bedienung, die ins Leere fuehrt."""
+    a = betrieb.auskunft(WINDOWS, container=False, plattform_name="win32")
+    assert a["kann"]["freigaben_einhaengen"] is False
+
+
+def test_windows_darf_seine_werkzeuge_selbst_pflegen():
+    """Im Image steckt alles fest, ein Update ist ein Rebuild. Nur die native
+    Installation kann MakeMKV/HandBrake selbst beschaffen."""
+    a = betrieb.auskunft(WINDOWS, container=False, plattform_name="win32")
+    assert a["kann"]["werkzeuge_verwalten"] is True
+
+
+def test_docker_behaelt_alles_was_es_hatte():
+    """Die Windows-Reparatur darf dem Docker-Betrieb nichts wegnehmen."""
+    a = betrieb.auskunft(DOCKER, container=True, plattform_name="linux")
+    assert a["kann"]["externe_worker"] is True
+    assert a["kann"]["container_pfade"] is True
+    assert a["kann"]["freigaben_einhaengen"] is True
+    assert a["ablage_vorgabe"] == "/app/media"
+    assert a["hilfe_befehl"] == "docker compose -p rippy ps"
+
+
+def test_der_docker_hinweis_taucht_ausserhalb_von_docker_NICHT_auf():
+    """„Pruefen: docker compose ps" auf einem Windows-PC ist ein Rat, den
+    niemand befolgen kann."""
+    a = betrieb.auskunft(WINDOWS, container=False, plattform_name="win32")
+    assert a["hilfe_befehl"] == ""
+
+
+def test_docker_allinone_hat_container_aber_keine_externen_worker():
+    """Der Fall, an dem ein blosser Modus-Name zerbrechen wuerde: EIN
+    Container, der alles selbst macht. Er hat Container-Pfade, aber niemanden,
+    der von aussen Jobs uebernimmt."""
+    a = betrieb.auskunft({"profil": "standalone", "queue": {"treiber": "lokal"}},
+                         container=True, plattform_name="linux")
+    assert a["kann"]["container_pfade"] is True
+    assert a["kann"]["externe_worker"] is False
+
+
+# ── Die Ablage-Vorgabe ──────────────────────────────────────────────────
+def test_eingestellte_ablage_schlaegt_jede_vorgabe():
+    a = betrieb.auskunft({"storage": {"medien": "D:\\Filme"}},
+                         container=False, plattform_name="win32")
+    assert a["ablage_vorgabe"] == "D:\\Filme"
+
+
+def test_native_vorgabe_liegt_beim_nutzer():
+    """Der USERPROFILE-Sonderzweig ist mit der Standalone-App gegangen
+    (Rippy v5, Entscheid 7) — nativ heisst hier nur noch: ein
+    Entwickler-Lauf ausserhalb des Containers, und die Vorgabe liegt im
+    Benutzerordner dieser Maschine."""
+    import os
+
+    a = betrieb.auskunft(WINDOWS, container=False, plattform_name="win32")
+    assert a["ablage_vorgabe"].startswith(os.path.expanduser("~"))
+    assert a["ablage_vorgabe"].endswith("Rippy")
+
+
+# ── Der Vertrag als Ganzes ──────────────────────────────────────────────
+def test_die_auskunft_ist_vollstaendig():
+    """Ein fehlendes Feld waere im UI ein `undefined` — und `undefined` ist
+    in JavaScript falsch, also verschwaende die Oberflaeche stillschweigend
+    einen Bereich. Lieber hier rot."""
+    a = betrieb.auskunft(WINDOWS, container=False, plattform_name="win32")
+    assert set(a) == {"modus", "plattform", "im_container", "kann",
+                      "ablage_vorgabe", "arbeits_vorgabe", "hilfe_befehl"}
+    assert set(a["kann"]) == {"externe_worker", "freigaben_einhaengen",
+                              "container_pfade", "werkzeuge_verwalten",
+                              "frei_blaettern"}
+    assert all(isinstance(v, bool) for v in a["kann"].values())
+
+
+# ── Wo Platz gemessen wird ──────────────────────────────────────────────
+def test_windows_misst_NICHT_in_app_media():
+    """DER Befund: Im Windows-Fenster stand „Platz fuer Rippy: unbekannt".
+
+    `main.py` mass fest an `/app/media` und `/app/temp`. Beide gibt es unter
+    Windows nicht, `shutil.disk_usage` warf, die Liste blieb leer — und aus
+    einer Nichtauskunft wurde eine Anzeige, die wie eine Auskunft aussieht.
+    """
+    orte = betrieb.platz_orte(WINDOWS, container=False, plattform_name="win32")
+    assert orte, "es muss mindestens ein Ort gemessen werden"
+    assert all("/app/" not in o["pfad"] for o in orte), orte
+
+
+def test_docker_misst_weiter_die_container_pfade():
+    orte = betrieb.platz_orte(DOCKER, container=True, plattform_name="linux")
+    assert [o["pfad"] for o in orte] == ["/app/media", "/app/temp"]
+
+
+def test_beide_orte_stehen_da_MIT_pfad():
+    """Geaenderte Regel (Commander 29.08.2026).
+
+    > „bei ‚Platz für rippy' sollte eher das arbeitsverzeichnis und der
+    > Ablagepfad sein."
+
+    Vorher fiel die zweite Zeile weg, wenn beide auf demselben Laufwerk
+    lagen — mit der Begruendung, zweimal dieselbe Zahl sei eine Auskunft. Das
+    stimmt fuer die ZAHL und war der falsche Schluss fuer den ORT: Auf seinem
+    Bildschirm stand nur „Platz für Rippy: 59,9 von 232 GB frei", und welche
+    Ordner gemeint waren, sah man nicht.
+    """
+    orte = betrieb.platz_orte({"storage": {"medien": r"D:\Filme"}},
+                              container=False, plattform_name="win32")
+    assert [o["name"] for o in orte] == ["Ablage", "Arbeitsverzeichnis"]
+    assert orte[0]["pfad"] == r"D:\Filme"
+    assert orte[1]["pfad"] == r"D:\Filme\_arbeit"
+
+
+def test_gleiches_laufwerk_wird_als_solches_GEMELDET():
+    """Statt die Zeile wegzulassen: ausdruecklich sagen, dass es dieselbe
+    Platte ist. Sonst wirken zwei gleiche Zahlen wie ein Fehler."""
+    orte = betrieb.platz_orte({"storage": {"medien": r"D:\Filme"}},
+                              container=False, plattform_name="win32")
+    assert all(o["gleiches_laufwerk"] for o in orte)
+
+
+def test_zwei_laufwerke_werden_als_getrennt_gemeldet():
+    orte = betrieb.platz_orte(
+        {"storage": {"medien": r"D:\Filme", "temp": r"E:\Arbeit"}},
+        container=False, plattform_name="win32")
+    assert len(orte) == 2, orte
+    assert not any(o["gleiches_laufwerk"] for o in orte)
+
+
+def test_im_container_bleibt_es_bei_den_zwei_container_orten():
+    """Der Docker-Weg darf sich durch die Aenderung NICHT verschieben."""
+    orte = betrieb.platz_orte({}, container=True, plattform_name="linux")
+    assert [o["pfad"] for o in orte] == ["/app/media", "/app/temp"]
+
+
+def test_noch_nicht_angelegter_ordner_faellt_auf_das_laufwerk_zurueck():
+    """Frisch installiert gibt es den Ablage-Ordner noch nicht. Der Nutzer
+    will trotzdem wissen, ob auf dem LAUFWERK Platz ist."""
+    da = r"C:\Users\Test"
+    assert betrieb.naechster_vorhandener(
+        r"C:\Users\Test\Videos\Rippy", existiert=lambda p: p == da) == da
+
+
+def test_wenn_gar_nichts_existiert_wird_nichts_behauptet():
+    assert betrieb.naechster_vorhandener(r"Z:\gibt\es\nicht",
+                                         existiert=lambda p: False) == ""
+
+
+def test_eingestellte_orte_schlagen_die_vorgabe():
+    """Der Befund vom 30.08.2026: „die verzeichnise sind andere als dort
+    steht."
+
+    Die Oberflaeche schreibt `outputDir`/`workDir` in die Datenbank,
+    `betrieb` las `storage.*` aus der Konfigurationsdatei — und die ist
+    leer. In „Einstellungen -> System" stand deshalb dauerhaft die Vorgabe,
+    waehrend der Rip woanders hin lief.
+    """
+    werte = betrieb.mit_einstellungen(
+        {"storage": {"medien": "", "temp": ""}},
+        {"outputDir": "F:" + B + "Filme", "workDir": "F:" + B})
+    assert werte["storage"]["medien"] == "F:" + B + "Filme"
+    assert werte["storage"]["temp"] == "F:" + B
+    assert betrieb.ablage_vorgabe(werte, False, "windows") == "F:" + B + "Filme"
+    assert betrieb.arbeits_vorgabe(werte, False, "windows") == "F:" + B
+
+
+def test_ohne_einstellung_bleibt_die_vorgabe():
+    """Leere Felder duerfen NICHTS ueberschreiben — sonst waere ein
+    ungesetztes Feld schlimmer als gar keine Bruecke."""
+    vorher = {"storage": {"medien": "/app/media", "temp": "/app/temp"}}
+    werte = betrieb.mit_einstellungen(vorher, {"outputDir": "", "workDir": "   "})
+    assert werte["storage"]["medien"] == "/app/media"
+    assert werte["storage"]["temp"] == "/app/temp"
+    # ... und das Original bleibt unangetastet (pure Funktion)
+    assert vorher["storage"]["medien"] == "/app/media"
+
+
+def test_bruecke_vertraegt_leere_eingaben():
+    assert betrieb.mit_einstellungen({}, {})["storage"] == {}
+    assert betrieb.mit_einstellungen(None, None)["storage"] == {}

src/rippy/test_daemon.py

@@ -1,99 +0,0 @@
-"""Der Daemon-Start — die Teile, die ohne laufenden Server pruefbar sind.
-
-Nicht geprueft wird hier, dass uvicorn hochkommt; das ist ein Rauchtest fuer
-den Betrieb. Geprueft wird, was davor entschieden wird — und genau dort
-sitzen die Fehler, die man spaeter nicht mehr findet:
-
-* Ein argparse-Vorgabewert, der die Konfigurationsdatei schlaegt.
-* Eine Datenbank, die am falschen Ort landet, weil der Store erst NACH dem
-  Import der API umgestellt wird.
-"""
-
-import os
-
-from rippy import config, daemon
-
-
-# ── Argumente ───────────────────────────────────────────────────────────
-def test_ohne_argumente_bleibt_alles_offen():
-    """DIE Falle bei argparse: Ein Vorgabewert im Parser sieht aus wie eine
-    Angabe des Nutzers und schlaegt damit die Konfigurationsdatei. Der
-    Eintrag dort waere wirkungslos, und niemand wuesste warum.
-    """
-    assert daemon.flags_aus_argumenten(daemon.argumente([])) == {}
-
-
-def test_port_kommt_als_flag_durch():
-    flags = daemon.flags_aus_argumenten(daemon.argumente(["--port", "9000"]))
-    assert flags == {"server": {"port": 9000}}
-
-
-def test_mehrere_angaben_landen_im_richtigen_abschnitt():
-    flags = daemon.flags_aus_argumenten(
-        daemon.argumente(["--host", "127.0.0.1", "--port", "8080",
-                          "--profil", "standalone", "--kein-ui"]))
-    assert flags["profil"] == "standalone"
-    assert flags["server"] == {"host": "127.0.0.1", "port": 8080, "ui": False}
-
-
-def test_db_flag_stellt_auf_sqlite_um():
-    flags = daemon.flags_aus_argumenten(daemon.argumente(["--db", "C:/tmp/r.db"]))
-    assert flags["store"] == {"treiber": "sqlite", "pfad": "C:/tmp/r.db"}
-
-
-def test_flag_schlaegt_die_konfigurationsdatei():
-    """Die Praezedenz aus config.py — hier am echten Daemon-Weg nachgeprueft."""
-    werte = config.laden(
-        umgebung={"RIPPY_SERVER__PORT": "5000"},
-        flags=daemon.flags_aus_argumenten(daemon.argumente(["--port", "9999"])),
-    )
-    assert werte["server"]["port"] == 9999
-
-
-# ── Pfade ───────────────────────────────────────────────────────────────
-def test_api_pfad_wird_gefunden():
-    """Ohne die API-Module startet gar nichts. Wenn sich die Verzeichnis-
-    struktur aendert, soll das HIER auffallen und nicht beim Nutzer."""
-    pfad = daemon._api_pfad()
-    assert os.path.isfile(os.path.join(pfad, "main.py"))
-
-
-def test_ui_pfad_ist_entweder_da_oder_ehrlich_leer():
-    """Leerer String heisst „kein UI mitgeliefert" — das ist ein gueltiger
-    Zustand (Kopfloser Betrieb). Was NICHT passieren darf: ein Pfad, den es
-    nicht gibt; dann liefe StaticFiles ins Leere."""
-    pfad = daemon._ui_pfad()
-    assert pfad == "" or os.path.isdir(pfad)
-
-
-def test_standard_konfigpfad_passt_zur_plattform():
-    pfad = daemon.standard_konfigpfad()
-    if os.name == "nt":
-        assert pfad.endswith(os.path.join("Rippy", "rippy.toml"))
-    else:
-        assert pfad == "/etc/rippy/rippy.toml"
-
-
-# ── Konfiguration einlesen ──────────────────────────────────────────────
-def test_fehlende_konfigdatei_ist_kein_fehler(tmp_path, monkeypatch):
-    monkeypatch.delenv("RIPPY_CONFIG", raising=False)
-    args = daemon.argumente(["--config", str(tmp_path / "gibt-es-nicht.toml")])
-    werte, datei, unbekannt = daemon.einstellungen_laden(args)
-    assert werte["server"]["port"] == 7788      # Vorgabe
-    assert unbekannt == []
-
-
-def test_unbekannte_eintraege_werden_gemeldet(tmp_path, monkeypatch):
-    """Sie werden NICHT uebernommen (config.py) — aber sie muessen sichtbar
-    sein. Ein Tippfehler, der stillschweigend wirkungslos bleibt, kostet
-    Stunden."""
-    if config.tomllib is None:
-        import pytest
-        pytest.skip("tomllib gibt es erst ab Python 3.11")
-    datei = tmp_path / "rippy.toml"
-    datei.write_text("[server]\nport = 8080\nprot = 9090\n", encoding="utf-8")
-    monkeypatch.delenv("RIPPY_CONFIG", raising=False)
-    werte, _, unbekannt = daemon.einstellungen_laden(
-        daemon.argumente(["--config", str(datei)]))
-    assert werte["server"]["port"] == 8080
-    assert unbekannt == ["server.prot"]

src/rippy/test_kette.py

@@ -1,137 +0,0 @@
-"""Die ganze Kette im Standalone-Betrieb — von der Zustellung bis zum Job-Ende.
-
-## Was hier bewiesen wird
-
-    celery_client.abschicken(...)   die API stellt zu
-      -> standalone.zustellung      uebersetzt in einen Auftrag
-        -> lokal.einreihen          Auftragstabelle mit Lease
-          -> Laeufer.einmal()       holt ihn und arbeitet ihn ab
-            -> ablauf.rippen()      der echte Ablauf, ohne Celery
-              -> db.update_job()    der Job endet in einem ehrlichen Zustand
-
-Das ist der Weg, der unter Windows bis V2-4 gar nicht existierte: Dort haette
-die API einen Rip eingereiht, und er waere fuer immer liegengeblieben, weil
-niemand ihn holt.
-
-## Warum ohne Laufwerk getestet wird
-
-Es gibt hier keins (es haengt an der VM). Das ist kein Mangel, sondern der
-wichtigere Fall: Ein Rip auf ein Geraet, das nicht antwortet, muss **ehrlich
-scheitern** — mit einem Zustand und einer Begruendung, die im UI ankommen.
-Was NICHT passieren darf: dass der Job auf „pending" stehenbleibt und
-niemand erfaehrt, warum nichts geschieht.
-"""
-
-import time
-
-import pytest
-
-from rippy import standalone, store
-from rippy.queue import laeufer as laeufer_modul
-from rippy.queue import lokal
-
-
-@pytest.fixture
-def umgebung(tmp_path):
-    vorher = store.zustand_sichern()
-    store.verbinden(f"sqlite:///{(tmp_path / 'kette.db').as_posix()}")
-    store.init_db()
-    yield store
-    store.engine_holen().dispose()
-    store.zustand_wiederherstellen(vorher)
-
-
-class FakeBus:
-    def __init__(self):
-        self.gesendet = []
-
-    def senden(self, typ, daten=None, entitaet=None, entitaet_id=None):
-        self.gesendet.append((typ, entitaet_id, daten or {}))
-
-
-def test_die_ganze_kette_bis_zum_ehrlichen_fehlschlag(umgebung):
-    """Ein Rip auf ein Geraet, das es nicht gibt.
-
-    Erwartet wird KEIN Erfolg — erwartet wird, dass der Job in einem
-    ENDZUSTAND landet und die Begruendung im Log steht. Ein Job, der auf
-    „pending" haengenbleibt, waere der schlimmere Ausgang: Der Nutzer saehe
-    einen Balken, der sich nie bewegt, und nirgends stuende warum.
-    """
-    umgebung.insert_job("job-kette", "/dev/gibt-es-nicht", disc_type=None)
-
-    bus = FakeBus()
-    zustellen = standalone.zustellung_bauen(bus)
-    zustellen("worker.tasks.rip_disc", ["/dev/gibt-es-nicht", "job-kette", None])
-
-    assert len(lokal.offene_auftraege()) == 1, "Der Auftrag wurde nicht eingereiht"
-
-    lauf = laeufer_modul.Laeufer(standalone.ausfuehren, "test-knoten",
-                                 kann={"art=rip"}, bus=bus, store=umgebung)
-    assert lauf.einmal() is True, "Der Laeufer hat den Auftrag nicht geholt"
-
-    job = umgebung.get_job("job-kette")
-    assert job["status"] in ("failed", "completed"), (
-        f"Der Job steht auf {job['status']!r} — er muss in einem Endzustand "
-        "landen, sonst wartet der Nutzer auf etwas, das nie passiert.")
-    assert job["status"] == "failed"
-    assert job["error"], "Ein Fehlschlag ohne Begruendung ist im UI wertlos"
-
-    meldungen = " ".join(z["message"] for z in umgebung.list_logs(limit=50))
-    assert "job-kette" in meldungen, "Im Log steht nichts ueber diesen Job"
-
-    assert lokal.offene_auftraege() == [], "Der Auftrag blieb in der Queue liegen"
-
-
-def test_der_laeufer_bleibt_danach_arbeitsfaehig(umgebung):
-    """Nach einem Fehlschlag muss der naechste Auftrag trotzdem laufen —
-    sonst legt ein einziger kaputter Rip die ganze Installation lahm."""
-    umgebung.insert_job("job-a", "/dev/gibt-es-nicht")
-    umgebung.insert_job("job-b", "/dev/gibt-es-auch-nicht")
-    zustellen = standalone.zustellung_bauen()
-    zustellen("worker.tasks.rip_disc", ["/dev/gibt-es-nicht", "job-a", None])
-    zustellen("worker.tasks.rip_disc", ["/dev/gibt-es-auch-nicht", "job-b", None])
-
-    lauf = laeufer_modul.Laeufer(standalone.ausfuehren, "test-knoten",
-                                 kann={"art=rip"}, store=umgebung)
-    assert lauf.einmal() is True
-    assert lauf.einmal() is True
-    assert umgebung.get_job("job-a")["status"] == "failed"
-    assert umgebung.get_job("job-b")["status"] == "failed"
-
-
-def test_die_api_stellt_ueber_dieselbe_stelle_zu(umgebung, monkeypatch):
-    """`celery_client.start_rip` ist der Weg, den POST /jobs geht. Er MUSS
-    im Standalone-Betrieb in der lokalen Queue landen — sonst reiht die API
-    an einen Broker ein, den es nicht gibt, und der Job verschwindet."""
-    import sys
-
-    from rippy.daemon import _api_pfad
-
-    if _api_pfad() not in sys.path:
-        sys.path.insert(0, _api_pfad())
-    import celery_client
-
-    umgebung.insert_job("job-api", "/dev/sr0")
-    monkeypatch.setattr(celery_client, "_zusteller", standalone.zustellung_bauen())
-
-    celery_client.start_rip("/dev/sr0", "job-api", "/app/media/x")
-
-    offen = lokal.offene_auftraege()
-    assert len(offen) == 1
-    assert offen[0]["job_id"] == "job-api"
-    assert offen[0]["art"] == "rip"
-
-
-def test_ein_rip_haengt_nicht_ewig(umgebung):
-    """Zeitgrenze als Zusage: Ein Auftrag auf ein totes Geraet muss ZUEGIG
-    scheitern. Haengt er, merkt es im Betrieb niemand — der Job steht auf
-    „laeuft", und der Laeufer nimmt keinen weiteren an."""
-    umgebung.insert_job("job-zeit", "/dev/nichts")
-    standalone.zustellung_bauen()("worker.tasks.rip_disc", ["/dev/nichts", "job-zeit", None])
-
-    lauf = laeufer_modul.Laeufer(standalone.ausfuehren, "k", kann={"art=rip"},
-                                 store=umgebung)
-    start = time.monotonic()
-    lauf.einmal()
-    dauer = time.monotonic() - start
-    assert dauer < 30, f"Der Fehlschlag brauchte {dauer:.1f}s — das ist zu lang"

src/rippy/test_pfade.py

@@ -0,0 +1,87 @@
+"""Pfade nach IHREN Regeln, nicht nach denen der laufenden Maschine.
+
+Dreimal dieselbe Falle in drei Dateien (katalog, verknuepfungen, betrieb) —
+jedes Mal nur auf der ANDEREN Plattform sichtbar. Diese Tests laufen ueberall
+und pruefen beide Zweige, damit es kein viertes Mal gibt.
+"""
+
+from rippy import pfade
+
+B = chr(92)
+
+
+def test_windows_pfad_wird_erkannt():
+    assert pfade.ist_windows_pfad("C:" + B + "Users") is True
+    assert pfade.ist_windows_pfad("D:") is True
+    assert pfade.ist_windows_pfad("/usr/local/bin") is False
+    assert pfade.ist_windows_pfad("") is False
+    assert pfade.ist_windows_pfad(None) is False
+
+
+def test_verbinden_folgt_dem_pfad():
+    assert pfade.verbinden("C:" + B + "Program Files", "MakeMKV") == \
+        "C:" + B + "Program Files" + B + "MakeMKV"
+    assert pfade.verbinden("/usr/local/bin", "makemkvcon") == \
+        "/usr/local/bin/makemkvcon"
+
+
+def test_ordner_von_folgt_dem_pfad():
+    assert pfade.ordner_von("C:" + B + "R" + B + "x.exe") == "C:" + B + "R"
+    assert pfade.ordner_von("/opt/r/x") == "/opt/r"
+
+
+def test_laufwerke_werden_unterschieden():
+    """Auf dem Linux-Runner kannte `os.path.splitdrive` kein `D:` und hielt
+    zwei verschiedene Laufwerke fuer eines."""
+    assert pfade.gleiches_laufwerk("D:" + B + "Filme", "E:" + B + "Arbeit") is False
+    assert pfade.gleiches_laufwerk("D:" + B + "Filme", "d:" + B + "Anderes") is True
+    assert pfade.gleiches_laufwerk("/a", "/b") is True
+
+
+def test_naechster_vorhandener_geht_nach_oben():
+    da = "C:" + B + "Users" + B + "Test"
+    assert pfade.naechster_vorhandener(
+        da + B + "Videos" + B + "Rippy", existiert=lambda p: p == da) == da
+
+
+def test_naechster_vorhandener_auf_posix():
+    assert pfade.naechster_vorhandener(
+        "/srv/rippy/media", existiert=lambda p: p == "/srv") == "/srv"
+
+
+def test_wenn_gar_nichts_existiert_wird_nichts_behauptet():
+    assert pfade.naechster_vorhandener("Z:" + B + "nix",
+                                       existiert=lambda p: False) == ""
+
+
+def test_laufwerks_wurzel_bleibt_absolut():
+    """Befund 30.08.2026: Der Schluss-Trenner wurde immer abgestreift.
+
+    Aus "F:\" wurde "F:" — unter Windows der AKTUELLE Ordner auf
+    Laufwerk F, nicht dessen Wurzel. Wer das Ergebnis weiterverbindet,
+    landet woanders; genau so verschwanden in `rohdaten.kandidaten` 16,5 GB.
+    """
+    assert pfade.naechster_vorhandener(
+        "F:" + B, existiert=lambda p: True) == "F:" + B
+    # UNC-Wurzel genauso
+    unc = B + B + "server" + B + "freigabe" + B
+    assert pfade.naechster_vorhandener(unc, existiert=lambda p: True) == unc
+    # Und POSIX bleibt POSIX
+    assert pfade.naechster_vorhandener("/", existiert=lambda p: True) == "/"
+
+
+def test_unterordner_verliert_seinen_schluss_trenner_weiterhin():
+    """Das Abstreifen war ja richtig — nur nicht bis auf den Laufwerksnamen."""
+    da = "F:" + B + "Roh"
+    assert pfade.naechster_vorhandener(da + B, existiert=lambda p: p == da) == da
+
+
+def test_fehlendes_laufwerk_terminiert():
+    """Die Endlosschleife, an der `ablauf._frei_bytes` haengen blieb.
+
+    `ntpath.dirname("Q:\\")` gibt sich selbst zurueck (30.08.2026 an
+    einem freien Laufwerksbuchstaben gemessen). Ohne den Abbruch bei
+    `eltern == pfad` dreht die Suche fuer immer — vor dem Rip, ohne Meldung.
+    """
+    assert pfade.naechster_vorhandener("Q:" + B + "Rippy" + B + "_arbeit",
+                                       existiert=lambda p: False) == ""

src/rippy/test_standalone.py

@@ -1,100 +0,0 @@
-"""Die lokale Zustellung: kommt der Auftrag an, und in der richtigen Form?
-
-Gerippt wird nichts — geprueft wird die Uebersetzung von Celery-Task-Namen in
-Auftraege und die Frage, was bei einem unbekannten Namen passiert.
-"""
-
-import json
-
-import pytest
-
-from rippy import standalone, store
-from rippy.queue import lokal
-
-
-@pytest.fixture
-def q(tmp_path):
-    vorher = store.zustand_sichern()
-    store.verbinden(f"sqlite:///{(tmp_path / 's.db').as_posix()}")
-    store.init_db()
-    yield lokal
-    store.engine_holen().dispose()
-    store.zustand_wiederherstellen(vorher)
-
-
-def test_rip_wird_zum_rip_auftrag(q):
-    zustellen = standalone.zustellung_bauen()
-    zustellen("worker.tasks.rip_disc", ["/dev/sr0", "job1", "/app/media/x"])
-
-    offen = q.offene_auftraege()
-    assert len(offen) == 1
-    auftrag = offen[0]
-    assert auftrag["art"] == "rip"
-    assert auftrag["job_id"] == "job1"
-    nutzlast = json.loads(auftrag["payload"])
-    assert nutzlast["device_path"] == "/dev/sr0"
-    assert nutzlast["target_dir"] == "/app/media/x"
-
-
-def test_transcode_wird_zum_transcode_auftrag(q):
-    standalone.zustellung_bauen()(
-        "worker.tasks.transcode_files", ["job2", "/raw", "/final"])
-    auftrag = q.offene_auftraege()[0]
-    assert auftrag["art"] == "transcode"
-    nutzlast = json.loads(auftrag["payload"])
-    assert nutzlast["raw_dir"] == "/raw" and nutzlast["final_dir"] == "/final"
-
-
-def test_scan_braucht_keinen_job(q):
-    """Ein Track-Scan gehoert zu keinem Job — er passiert VOR dem Anlegen."""
-    standalone.zustellung_bauen()("worker.tasks.scan_tracks", ["/dev/sr0"])
-    auftrag = q.offene_auftraege()[0]
-    assert auftrag["art"] == "scan"
-    assert auftrag["job_id"] == ""
-
-
-def test_fehlendes_zielverzeichnis_ist_kein_fehler(q):
-    """POST /jobs darf target_dir weglassen — dann gilt der Standard."""
-    standalone.zustellung_bauen()("worker.tasks.rip_disc", ["/dev/sr0", "job3"])
-    assert json.loads(q.offene_auftraege()[0]["payload"])["target_dir"] is None
-
-
-def test_unbekannter_taskname_fliegt_auf(q):
-    """Wuerde er stillschweigend verworfen, waere der Auftrag weg und niemand
-    wuesste warum — der Nutzer sieht nur einen Job, der nie anfaengt."""
-    with pytest.raises(ValueError, match="Unbekannte Auftragsart"):
-        standalone.zustellung_bauen()("worker.tasks.gibts_nicht", ["x"])
-
-
-def test_faehigkeiten_werden_gesetzt(q):
-    """Damit ein reiner Encode-Knoten spaeter keine Rip-Auftraege bekommt."""
-    zustellen = standalone.zustellung_bauen()
-    zustellen("worker.tasks.rip_disc", ["/dev/sr0", "job1"])
-    zustellen("worker.tasks.transcode_files", ["job1", "/raw", "/final"])
-    arten = {a["art"]: json.loads(a["faehigkeiten"]) for a in q.offene_auftraege()}
-    assert arten["rip"] == {"art": "rip"}
-    assert arten["transcode"] == {"art": "transcode"}
-
-
-def test_ein_kaputter_bus_haelt_die_zustellung_nicht_auf(q):
-    class KaputterBus:
-        def senden(self, *a, **k):
-            raise RuntimeError("weg")
-
-    standalone.zustellung_bauen(KaputterBus())(
-        "worker.tasks.rip_disc", ["/dev/sr0", "job1"])
-    assert len(q.offene_auftraege()) == 1
-
-
-def test_ausfuehren_lehnt_unbekannte_art_ab():
-    with pytest.raises(ValueError, match="Unbekannte Auftragsart"):
-        standalone.ausfuehren({"art": "quatsch", "job_id": "j", "payload": "{}"})
-
-
-def test_worker_pfad_wird_gefunden():
-    """Ohne die Worker-Module kann Rippy nicht rippen. Wenn sich die
-    Verzeichnisstruktur aendert, soll das HIER auffallen."""
-    import os
-
-    pfad = standalone._worker_pfad()
-    assert os.path.isfile(os.path.join(pfad, "ablauf.py"))

src/rippy/test_windows_app.py

@@ -1,156 +0,0 @@
-"""Die Windows-App: Installation, Deinstallation, Aufraeum-Skript.
-
-Die reinen Funktionen laufen ueberall. Was wirklich installiert, laeuft nur
-unter Windows und in einem Testordner — die echte Installation wird nie
-angefasst.
-
-Hinweis zu den Backslashes: Windows-Pfade stehen hier durchweg in ROHEN
-Zeichenketten. In einer normalen waere ein Pfad wie C:\\Program die
-ungueltige Escape-Sequenz Backslash-P — heute eine DeprecationWarning, in
-einer kuenftigen Python-Version ein harter Fehler.
-"""
-
-import os
-
-import pytest
-
-from rippy import windows_app
-
-nur_windows = pytest.mark.skipif(os.name != "nt", reason="nur unter Windows")
-
-BACKSLASH = chr(92)
-
-
-# ── Das Aufraeum-Skript ─────────────────────────────────────────────────
-def test_pfade_stehen_in_anfuehrungszeichen():
-    """DER Fehler vom 28.08.2026.
-
-    Der Loeschbefehl ging als EIN Argument an cmd. Python maskiert dabei die
-    inneren Anfuehrungszeichen, bei cmd kam ein Dateiname MIT vorangestellten
-    Backslashes an. `del` loeschte nichts und meldete nichts (die Ausgabe war
-    nach nul umgeleitet) — Registry-Eintrag und Autostart waren weg, die
-    28-MB-Datei blieb liegen. Ein Skript hat das Problem nicht: Sein Inhalt
-    geht durch keine Argument-Zerlegung.
-    """
-    s = windows_app.aufraeum_skript(
-        r"C:\Program Files\Rippy\Rippy.exe", r"C:\Program Files\Rippy")
-    assert '"' + r"C:\Program Files\Rippy\Rippy.exe" + '"' in s
-    assert BACKSLASH + '"' not in s, "Anfuehrungszeichen duerfen NICHT maskiert sein"
-
-
-def test_skript_versucht_es_mehrfach():
-    """Eine PyInstaller-Onefile-EXE laeuft als ZWEI Prozesse; der Starter
-    haelt die Datei nach dem Ende noch offen. Ein einziger Versuch schlaegt
-    dann manchmal fehl — und zwar unsichtbar."""
-    s = windows_app.aufraeum_skript(r"C:\R\Rippy.exe", r"C:\R")
-    assert "for /l" in s
-    assert "(1,1,15)" in s
-
-
-def test_skript_loescht_sich_selbst():
-    """Sonst bleibt nach jeder Deinstallation eine .bat im Temp liegen."""
-    assert "%~f0" in windows_app.aufraeum_skript(r"C:\R\Rippy.exe", r"C:\R")
-
-
-def test_ordner_ohne_abschliessenden_trenner():
-    """rmdir will den Ordner OHNE Schluss-Backslash — mit scheitert es."""
-    s = windows_app.aufraeum_skript(r"C:\R\Rippy.exe", "C:" + BACKSLASH + "R" + BACKSLASH)
-    assert 'rmdir "' + r"C:\R" + '"' in s
-
-
-# ── Installation (echt, in einem Testordner) ────────────────────────────
-@nur_windows
-def test_installation_legt_die_dateien_an_und_meldet_sich_bei_windows(tmp_path, monkeypatch):
-    """Der ganze Kreislauf. Der Registry-Schluessel ist der ECHTE — deshalb
-    wird am Ende immer aufgeraeumt, auch wenn der Test scheitert.
-
-    ## ⚠️ WARUM HIER KEINE VERKNUEPFUNGEN ANGELEGT WERDEN (28.08.2026)
-
-    Genau das ist einmal passiert, und es hat den Rechner des Commanders
-    kaputtgemacht: `installieren()` legt Verknuepfungen auf dem ECHTEN
-    Desktop und im ECHTEN Startmenue an — die kennen kein `tmp_path`. Der
-    Test ueberschrieb damit die funktionierende Desktop-Verknuepfung durch
-    eine, die auf `…\\Temp\\pytest-of-…\\installiert\\Rippy.exe` zeigte. Und
-    dort liegt die 2-KB-ATTRAPPE von unten, kein Programm.
-
-    Der Commander klickte darauf und bekam von Windows:
-    „Diese App kann auf dem PC nicht ausgefuehrt werden."
-
-    Aufgeraeumt hatte der Test nur Registry und Autostart — die
-    Verknuepfungen nicht, weil es sie beim Schreiben des Tests noch nicht
-    gab. Ein Test, der Spuren ausserhalb von `tmp_path` hinterlaesst, ist
-    kein Test, sondern ein Eingriff.
-
-    Deshalb jetzt ZWEI Sicherungen statt einer:
-      1. `verknuepfen=False` — die Funktion legt gar keine an.
-      2. Die Anlege-Funktion ist trotzdem ersetzt. Wer den Schalter
-         irgendwann umdreht oder die Vorgabe aendert, kann damit trotzdem
-         nichts am echten System anrichten.
-    """
-    from rippy.platform import verknuepfungen as vk
-    from rippy.platform import win_registry as reg
-
-    # Sicherung 2: Selbst ein versehentliches `verknuepfen=True` bliebe folgenlos.
-    angelegt = []
-    monkeypatch.setattr(
-        vk, "alle_anlegen",
-        lambda programm, icon="", desktop=True, startmenue=True:
-            angelegt.append(programm) or {})
-
-    # Nicht die eigene Datei kopieren (das waere python.exe), sondern eine
-    # Attrappe: geprueft wird die Verdrahtung, nicht shutil.copy2.
-    attrappe = tmp_path / "quelle" / "RippySetup.exe"
-    attrappe.parent.mkdir()
-    attrappe.write_bytes(b"x" * 2048)
-    monkeypatch.setattr(windows_app, "_eigene_datei", lambda: str(attrappe))
-
-    ziel = str(tmp_path / "installiert")
-    try:
-        ordner = windows_app.installieren(ziel=ziel, autostart=True,
-                                          starten_danach=False,
-                                          verknuepfen=False)
-        assert os.path.isfile(os.path.join(ordner, "Rippy.exe"))
-        assert reg.ist_eingetragen() is True
-
-        werte = reg.gelesene_werte()
-        assert werte["InstallLocation"] == ziel
-        assert werte["DisplayName"] == "Rippy"
-        assert reg.autostart_wert().endswith("--dienst")
-    finally:
-        reg.autostart_entfernen()
-        reg.austragen()
-
-    assert reg.ist_eingetragen() is False
-    assert reg.autostart_wert() == ""
-    assert angelegt == [], "Es haette KEINE Verknuepfung angelegt werden duerfen"
-
-
-@nur_windows
-def test_installation_ruehrt_die_echten_verknuepfungen_nicht_an(tmp_path, monkeypatch):
-    """Der Waechter gegen genau den Vorfall vom 28.08.2026.
-
-    Er prueft, dass eine Installation mit `verknuepfen=False` die
-    Verknuepfungs-Funktionen NICHT aufruft — unabhaengig davon, was sie
-    tun wuerden. Waere dieser Test frueher dagewesen, haette der Commander
-    keine kaputte Desktop-Verknuepfung bekommen.
-    """
-    from rippy.platform import verknuepfungen as vk
-    from rippy.platform import win_registry as reg
-
-    aufrufe = []
-    monkeypatch.setattr(vk, "anlegen",
-                        lambda *a, **k: aufrufe.append(a) or True)
-    monkeypatch.setattr(vk, "alle_anlegen",
-                        lambda *a, **k: aufrufe.append(a) or {})
-
-    attrappe = tmp_path / "q" / "RippySetup.exe"
-    attrappe.parent.mkdir()
-    attrappe.write_bytes(b"x" * 16)
-    monkeypatch.setattr(windows_app, "_eigene_datei", lambda: str(attrappe))
-
-    try:
-        windows_app.installieren(ziel=str(tmp_path / "i"), autostart=False,
-                                 starten_danach=False, verknuepfen=False)
-    finally:
-        reg.austragen()
-    assert aufrufe == []

src/rippy/tools/beschaffen.py

@@ -48,9 +48,11 @@ mehr geht.
 
 import json
 import os
+import re
 import shutil
 import subprocess
 import tempfile
+import time
 import urllib.error
 import urllib.request
 import zipfile
@@ -58,13 +60,34 @@ import zipfile
 from rippy.tools import katalog
 
 HANDBRAKE_API = "https://api.github.com/repos/HandBrake/HandBrake/releases/latest"
-MAKEMKV_SEITE = "https://www.makemkv.com/download/"
+
+# FLAC-Encoder fuer Audio-CDs (Befund 29.08.2026). Der offizielle Xiph-Spiegel
+# listet die Windows-Pakete als `flac-<version>-win.zip`; am 29.08.2026
+# gemessen: HTTP 200, hoechste Fassung 1.5.0.
+#
+# Warum ein eigenes Werkzeug und nicht HandBrake: HandBrake schreibt FLAC nur
+# IN einen Container (MKV/MKA), nie als `.flac`-Datei. Eine Musiksammlung will
+# aber `.flac`.
+FLAC_SPIEGEL = "https://ftp.osuosl.org/pub/xiph/releases/flac/"
+FLAC_DATEI = re.compile(r"flac-(\d+\.\d+\.\d+)-win\.zip")
 
 # Wie lange auf eine Antwort gewartet wird. Großzügig für den Download,
 # knapp für die Versionsabfrage — die soll das UI nicht aufhalten.
 ABFRAGE_TIMEOUT = 20
 DOWNLOAD_TIMEOUT = 600
 
+# Wackelige Quellen bekommen einen zweiten Anlauf. Gemessen am 28.08.2026:
+# forum.makemkv.com scheiterte zweimal und antwortete beim dritten Versuch.
+VERSUCHE = 2
+WARTEN_ZWISCHEN_VERSUCHEN = 2.0
+
+# Fuer die Versionsabfrage: knapp. Eine Seite zu lesen dauert bei einem
+# gesunden Server Millisekunden; 20 s Zeitgrenze mal zwei Versuche mal zwei
+# wacklige Quellen waren am 28.08.2026 SECHSUNDVIERZIG Sekunden, in denen
+# das Setup eingefroren aussah. Acht Sekunden sind fuer eine Seite reichlich
+# und begrenzen den schlimmsten Fall auf gut zwanzig.
+VERSIONS_TIMEOUT = 8
+
 # Eine HandBrakeCLI-ZIP ist rund 25 MB. Alles unter einem MB ist keine —
 # sondern eine Fehlerseite, die mit HTTP 200 ausgeliefert wurde.
 MINDESTGROESSE_BYTES = 1024 * 1024
@@ -74,14 +97,38 @@ class BeschaffungsFehler(RuntimeError):
     """Es hat nicht geklappt — mit einer Begründung, die man lesen kann."""
 
 
-def _laden(url: str, timeout: int = ABFRAGE_TIMEOUT) -> bytes:
+def _laden(url: str, timeout: int = ABFRAGE_TIMEOUT,
+           versuche: int = VERSUCHE) -> bytes:
+    """Eine Seite holen — mit Wiederholung bei wackligen Servern.
+
+    ## Warum wiederholt wird (gemessen 28.08.2026)
+
+    Drei Abrufe von `forum.makemkv.com` hintereinander:
+
+        1: TimeoutError            (20,1 s)
+        2: HTTP 522                (19,7 s)   Cloudflare erreicht den Ursprung nicht
+        3: OK, 127.311 Bytes        (0,2 s)
+
+    Der Server ist nicht tot, er wackelt. Ohne Wiederholung fiel die Quelle
+    in zwei von drei Fällen aus — und dann gewann der ältere Archiv-Stand,
+    also 1.18.2 statt 1.18.4. Ein zweiter Anlauf kostet Sekunden und ändert
+    das Ergebnis.
+    """
     anfrage = urllib.request.Request(url, headers={
         # GitHub verlangt eine Kennung; ohne sie kommt 403.
         "User-Agent": "Rippy/2.0 (+https://github.com/)",
         "Accept": "*/*",
     })
-    with urllib.request.urlopen(anfrage, timeout=timeout) as antwort:
-        return antwort.read()
+    letzter = None
+    for nummer in range(max(1, versuche)):
+        try:
+            with urllib.request.urlopen(anfrage, timeout=timeout) as antwort:
+                return antwort.read()
+        except (urllib.error.URLError, OSError) as e:
+            letzter = e
+            if nummer + 1 < max(1, versuche):
+                time.sleep(WARTEN_ZWISCHEN_VERSUCHEN)
+    raise letzter
 
 
 # ── HandBrake ───────────────────────────────────────────────────────────
@@ -124,6 +171,86 @@ def waehle_handbrake_datei(assets: list, maschine: str = None) -> dict:
     return {}
 
 
+def neueste_flac_fassung(seite: str) -> str:
+    """Hoechste Windows-Fassung aus dem Verzeichnis-HTML (pure Funktion).
+
+    Der Xiph-Spiegel listet die Pakete als `flac-1.5.0-win.zip`. Sortiert
+    wird NUMERISCH — alphabetisch waere 1.4.10 kleiner als 1.4.2.
+    """
+    fassungen = set(FLAC_DATEI.findall(seite or ""))
+    if not fassungen:
+        return ""
+    return max(fassungen, key=lambda v: [int(t) for t in v.split(".")])
+
+
+def _flac_ordner(eintraege) -> str:
+    """Der Ordner im Archiv, der flac.exe enthaelt (pure Funktion).
+
+    Bevorzugt `Win64`. Zurueck kommt das Praefix samt Schraegstrich, damit
+    der Aufrufer alle Dateien daraus greifen kann — die DLLs eingeschlossen.
+    """
+    kandidaten = [n for n in eintraege if n.lower().endswith("/flac.exe")]
+    bevorzugt = [n for n in kandidaten if "win64" in n.lower()] or kandidaten
+    return bevorzugt[0].rsplit("/", 1)[0] + "/" if bevorzugt else ""
+
+
+def flac_holen(ziel_ordner: str = None, fortschritt=None, seite_laden=None) -> str:
+    """Laedt den FLAC-Encoder und legt ihn in Rippys Werkzeug-Ordner.
+
+    Fuer Audio-CDs (Befund 29.08.2026): Windows hat weder `cdparanoia` noch
+    `abcde`. Das LESEN macht Rippy selbst ueber Win32 (`rippy.rip.audio_cd`),
+    zum Kodieren fehlte ein Encoder.
+    """
+    ziel_ordner = ziel_ordner or os.path.join(katalog.werkzeug_ordner(), "flac")
+
+    def melden(text, anteil=None):
+        if fortschritt:
+            fortschritt(text, anteil)
+
+    melden("FLAC-Encoder wird gesucht …", 0.0)
+    seite = (seite_laden or (lambda: _laden(FLAC_SPIEGEL).decode("utf-8", "replace")))()
+    version = neueste_flac_fassung(seite)
+    if not version:
+        raise BeschaffungsFehler(
+            "Im Verzeichnis %s steht kein Windows-Paket (flac-*-win.zip). "
+            "Hat sich der Spiegel geaendert?" % FLAC_SPIEGEL)
+
+    url = "%sflac-%s-win.zip" % (FLAC_SPIEGEL, version)
+    with tempfile.TemporaryDirectory(prefix="rippy-flac-") as arbeit:
+        archiv = os.path.join(arbeit, "flac.zip")
+        melden("FLAC %s wird geladen …" % version, 0.1)
+        _datei_laden(url, archiv, 0, melden)
+
+        melden("Wird entpackt …", 0.9)
+        with zipfile.ZipFile(archiv) as z:
+            eintraege = z.namelist()
+            # ⚠️ Den GANZEN Ordner auspacken, nicht nur die exe (Befund
+            # 29.08.2026): `flac.exe` braucht `libFLAC.dll` daneben. Mit nur
+            # der exe endete jeder Aufruf mit 0xC0000135 — „DLL nicht
+            # gefunden" — und zwar ohne eine einzige Zeile Ausgabe.
+            #
+            # Das Paket bringt 32- und 64-Bit mit. `Win64/` ist die richtige
+            # Wahl; ohne sie liefe auf einem 64-Bit-System die 32-Bit-Fassung.
+            ordner = _flac_ordner(eintraege)
+            if not ordner:
+                raise BeschaffungsFehler(
+                    "Im FLAC-Archiv steckt keine flac.exe. Format geaendert?")
+            os.makedirs(ziel_ordner, exist_ok=True)
+            for name in eintraege:
+                if not name.startswith(ordner) or name.endswith("/"):
+                    continue
+                z.extract(name, arbeit)
+                quelle = os.path.join(arbeit, name)
+                ziel_datei = os.path.join(ziel_ordner, os.path.basename(name))
+                vorlaeufig = ziel_datei + ".neu"
+                shutil.copy2(quelle, vorlaeufig)
+                os.replace(vorlaeufig, ziel_datei)
+        ziel = os.path.join(ziel_ordner, "flac.exe")
+
+    melden("FLAC %s ist einsatzbereit." % version, 1.0)
+    return ziel
+
+
 def handbrake_holen(ziel_ordner: str = None, fortschritt=None) -> str:
     """Lädt HandBrakeCLI und legt es in Rippys Werkzeug-Ordner. Gibt den Pfad zurück."""
     ziel_ordner = ziel_ordner or os.path.join(katalog.werkzeug_ordner(), "handbrake")
@@ -161,19 +288,43 @@ def handbrake_holen(ziel_ordner: str = None, fortschritt=None) -> str:
 
 
 def _datei_laden(url: str, ziel: str, erwartet: int, melden) -> None:
+    """Lädt eine Datei und meldet den Fortschritt.
+
+    ## Warum hier IMMER ein Text kommt (28.08.2026)
+
+    Vorher stand hier `melden(None, anteil)` — „nur der Fortschritt hat sich
+    geändert". Der erste echte Aufrufer, der den Text ausgab, starb daran:
+
+        can only concatenate str (not "NoneType") to str
+
+    Ein Rückruf, den man nur mit einer Sonderbehandlung benutzen kann, die
+    nirgends dokumentiert ist, ist eine Falle. Jetzt kommt immer ein Satz —
+    der steht dann auch im Protokoll, wo er beim Suchen hilft.
+    """
     anfrage = urllib.request.Request(url, headers={"User-Agent": "Rippy/2.0"})
     try:
         with urllib.request.urlopen(anfrage, timeout=DOWNLOAD_TIMEOUT) as antwort, \
                 open(ziel, "wb") as datei:
             geladen = 0
+            letzte_stufe = -1
             while True:
                 brocken = antwort.read(256 * 1024)
                 if not brocken:
                     break
                 datei.write(brocken)
                 geladen += len(brocken)
-                if erwartet:
-                    melden(None, min(0.85, 0.85 * geladen / erwartet))
+                if not erwartet:
+                    continue
+                anteil = min(1.0, geladen / erwartet)
+                # Nur bei jedem zehnten Prozent melden: 24 MB in
+                # 256-KB-Häppchen wären sonst hundert Zeilen im Protokoll.
+                stufe = int(anteil * 10)
+                if stufe != letzte_stufe:
+                    letzte_stufe = stufe
+                    melden("%d %% geladen (%.1f von %.1f MB)"
+                           % (anteil * 100, geladen / 1024**2,
+                              erwartet / 1024**2),
+                           min(0.85, 0.85 * anteil))
     except (urllib.error.URLError, OSError) as e:
         raise BeschaffungsFehler(f"Der Download ist gescheitert: {e}") from e
 
@@ -186,49 +337,214 @@ def _datei_laden(url: str, ziel: str, erwartet: int, melden) -> None:
 
 
 # ── MakeMKV ─────────────────────────────────────────────────────────────
-def makemkv_neueste_version(seite: str = None) -> str:
-    """Die neueste Fassung laut makemkv.com. "" wenn die Seite nicht antwortet.
+#
+# ## Warum es hier eine Quellenkette gibt (28.08.2026)
+#
+# Der Commander: „bitte baue für MakeMKV fallback seiten ein."
+#
+# Anlass war ein echter Ausfall. Am 28.08.2026 gemessen:
+#
+#     https://www.makemkv.com/download/   HTTP 525
+#     https://makemkv.com/download/       HTTP 525
+#     http://www.makemkv.com/download/    HTTP 403
+#     https://www.makemkv.com/            HTTP 525
+#     https://forum.makemkv.com/          HTTP 200   <- lebt
+#
+# 525 heißt: Cloudflare erreicht den Ursprungsserver nicht. Das ist eine
+# Störung beim Hersteller, nichts, was Rippy reparieren könnte — und
+# dieselbe, die im Projekt schon einmal jeden Worker-Build lahmgelegt hat.
+#
+# ## Woher die Version kommt, wenn die Seite schweigt
+#
+# Das Forum liegt auf einem ANDEREN Host und war erreichbar. Im
+# Ankündigungs-Bereich steht die aktuelle Fassung; am 28.08.2026 gemessen:
+# `1.18.4` — dieselbe, die auf dem Rechner des Commanders installiert war.
+#
+# ## Woher die DATEI kommt
+#
+# Aus dem Internet Archive, das eine Kopie der Datei DES HERSTELLERS hält.
+# Gemessen:
+#
+#     web/2024id_/…/Setup_MakeMKV_v1.18.4.exe   200, 16.432.607 Bytes
+#     web/2025id_/…                              200, dieselbe Datei
+#     web/3000id_/…                              525  <- leitet auf die tote Seite
+#     web/id_/…                                  HTML statt Programm
+#
+# Ein Zeitstempel in der VERGANGENHEIT ist nötig: Ohne ihn holt das Archiv
+# die Datei live nach — und die Quelle ist ja gerade tot.
+#
+# ## Warum das trotzdem sicher ist
+#
+# Weil nachgesehen wird, WAS ankommt. Der naheliegende Schutz — die digitale
+# Signatur — geht nicht: MakeMKV signiert seinen Installer nicht
+# (`Get-AuthenticodeSignature` → `NotSigned`, an der echten Datei gemessen).
+# Geprüft wird deshalb die Versions-Ressource, ebenfalls gemessen:
+#
+#     CompanyName      GuinpinSoft inc
+#     FileDescription  MakeMKV installer
+#     FileVersion      v1.18.4
+#
+# Das ersetzt keine Signatur — wer die Datei fälscht, fälscht auch die
+# Ressource. Es fängt aber zuverlässig ab, was hier wirklich droht: eine
+# Fehlerseite, ein abgebrochener Download, eine falsche Version.
+#
+# ## Und die Reihenfolge ist Absicht
+#
+# Der Hersteller zuerst, immer. Das Archiv ist die Rückfallebene, nicht der
+# Normalfall — und Rippy sagt hinterher, woher die Datei kam.
 
-    ⚠️ Am 28.08.2026 antwortete makemkv.com mit HTTP 525 (Cloudflare), auch
-    mit Browser-Kennung. Das ist kein Fehler auf unserer Seite und auch nicht
-    reparierbar — deshalb gibt diese Funktion "" zurück statt zu werfen: Ein
-    nicht erreichbarer Update-Server ist kein Grund, warum Rippy nicht laufen
-    sollte.
+MAKEMKV_SEITE = "https://www.makemkv.com/download/"
+MAKEMKV_FORUM = "https://forum.makemkv.com/forum/viewforum.php?f=3"
+
+# Der Pfad beim Hersteller — an EINER Stelle, damit die Archiv-Adresse ihn
+# nicht abschreiben muss.
+MAKEMKV_DATEI = "https://www.makemkv.com/download/Setup_MakeMKV_v%s.exe"
+
+# Ein Zeitstempel in der Vergangenheit. Ohne ihn holt das Archiv live nach.
+ARCHIV_STAND = "2025"
+
+MAKEMKV_FIRMA = "GuinpinSoft"
+MAKEMKV_PRODUKT = "MakeMKV"
+
+VERSION_RE = r"MakeMKV\s+v?(\d+\.\d+\.\d+)"
+
+
+def hoechste_version(text: str) -> str:
+    """Die höchste Fassung, die in einem Text vorkommt. (reine Funktion)
+
+    Höchste und nicht erste: Das Forum listet alte Ankündigungen mit; die
+    neueste Fassung ist die mit der größten Nummer. Und verglichen wird nach
+    Zahlen, nicht nach Zeichen — sonst wäre „1.9.2" größer als „1.18.4".
     """
     import re
 
-    try:
-        text = (seite if seite is not None
-                else _laden(MAKEMKV_SEITE).decode("utf-8", "replace"))
-    except (urllib.error.URLError, OSError):
+    funde = re.findall(VERSION_RE, text or "")
+    if not funde:
         return ""
-    treffer = re.search(r"MakeMKV\s+v?(\d+\.\d+\.\d+)", text or "")
-    return treffer.group(1) if treffer else ""
+    return max(funde, key=lambda v: [int(t) for t in v.split(".")])
+
+
+def versionsquellen() -> list:
+    """Wo nach der aktuellen Fassung gesucht wird.
+
+    `massgeblich` heißt: Diese Quelle IST die Wahrheit — wer sie erreicht,
+    braucht nicht weiterzusuchen. Das gilt nur für den Hersteller selbst.
+    """
+    return [
+        {"name": "Hersteller-Seite", "url": MAKEMKV_SEITE, "massgeblich": True},
+        {"name": "Hersteller-Forum", "url": MAKEMKV_FORUM, "massgeblich": False},
+        {"name": "Archiv der Hersteller-Seite", "massgeblich": False,
+         "url": "https://web.archive.org/web/%s/%s" % (ARCHIV_STAND, MAKEMKV_SEITE)},
+    ]
+
+
+def makemkv_neueste_version(seite: str = None, quellen: list = None) -> str:
+    """Die neueste Fassung. "" wenn KEINE Quelle antwortet.
+
+    ## Warum die HÖCHSTE gewinnt und nicht die erste (gemessen 28.08.2026)
+
+    Vier Läufe hintereinander:
+
+        Lauf 1: 1.18.4   (0,3 s)   Forum hat geantwortet
+        Lauf 2: 1.18.4   (0,4 s)
+        Lauf 3: 1.18.2  (21,3 s)   Forum lief in die Zeitgrenze
+        Lauf 4: 1.18.2  (21,0 s)
+
+    `forum.makemkv.com` antwortet unzuverlässig. Fällt es aus, gewinnt sonst
+    der ältere Archiv-Schnappschuss — und Rippy holt 1.18.2, obwohl 1.18.4
+    aktuell ist. „Neueste Fassung" wäre dann eine falsche Aussage.
+
+    Deshalb: Antwortet der HERSTELLER, ist die Sache entschieden. Sonst wird
+    zusammengetragen, was die übrigen Quellen melden, und die höchste Nummer
+    gewinnt — eine Quelle kann nur eine Fassung nennen, die es wirklich gab.
+
+    `seite` bleibt als Einspritzpunkt für Tests (fertiger HTML-Text).
+    """
+    if seite is not None:
+        return hoechste_version(seite)
+
+    gefunden = []
+    for quelle in (quellen if quellen is not None else versionsquellen()):
+        try:
+            text = _laden(quelle["url"],
+                          timeout=VERSIONS_TIMEOUT).decode("utf-8", "replace")
+        except (urllib.error.URLError, OSError):
+            continue
+        version = hoechste_version(text)
+        if not version:
+            continue
+        if quelle.get("massgeblich"):
+            return version
+        gefunden.append(version)
+    if not gefunden:
+        return ""
+    return max(gefunden, key=lambda v: [int(t) for t in v.split(".")])
 
 
 def makemkv_setup_url(version: str, basis: str = None) -> str:
-    """Die Adresse der Windows-Installationsdatei.
+    """Die Adresse beim Hersteller (oder unter einer eigenen Basis).
 
-    Das Namensmuster stammt von makemkv.com selbst
-    (`Setup_MakeMKV_v<version>.exe`). `basis` ist übersteuerbar — aus
-    demselben Grund wie `MAKEMKV_URL_BASE` beim Docker-Bau: Wenn die
-    Hauptquelle klemmt, soll ein Ausweichweg möglich sein, ohne den Code
-    anzufassen.
+    `basis` ist übersteuerbar — aus demselben Grund wie `MAKEMKV_URL_BASE`
+    beim Docker-Bau: Wer eine eigene Kopie im Netz liegen hat, soll sie
+    benutzen können, ohne den Code anzufassen.
     """
-    basis = (basis or "https://www.makemkv.com/download").rstrip("/")
-    return f"{basis}/Setup_MakeMKV_v{version}.exe"
+    if basis:
+        return "%s/Setup_MakeMKV_v%s.exe" % (basis.rstrip("/"), version)
+    return MAKEMKV_DATEI % version
+
+
+def makemkv_quellen(version: str, basis: str = None) -> list:
+    """Alle Bezugsquellen für den Installer, in Reihenfolge.
+
+    Der Hersteller zuerst, IMMER. Eine eigene Basis steht davor — wer sie
+    einträgt, hat sich etwas dabei gedacht.
+    """
+    quellen = []
+    if basis:
+        quellen.append(("eigene Quelle", makemkv_setup_url(version, basis)))
+    quellen.append(("Hersteller", MAKEMKV_DATEI % version))
+    quellen.append(("Internet Archive",
+                    "https://web.archive.org/web/%sid_/%s"
+                    % (ARCHIV_STAND, MAKEMKV_DATEI % version)))
+    return quellen
+
+
+def pruefe_makemkv_datei(pfad: str, version: str = "") -> tuple:
+    """Ist das WIRKLICH der MakeMKV-Installer? (ja/nein, Begründung)
+
+    Ohne diese Prüfung wäre eine Ausweichquelle leichtsinnig. Mit ihr wird
+    aus „von woanders geladen" ein „nachweislich die Datei des Herstellers".
+    Begründung vollständig in `rippy/platform/dateiangaben.py`.
+    """
+    from rippy.platform import dateiangaben
+
+    if not dateiangaben.ist_programm(pfad):
+        return False, ('Die geladene Datei ist kein Windows-Programm '
+                       '(sie beginnt nicht mit „MZ") — vermutlich eine '
+                       'Fehlerseite.')
+    if os.name != "nt":
+        # Auf Linux gibt es keine Versions-Ressourcen. Der MZ-Test hat schon
+        # gegriffen; mehr ist dort nicht zu holen, und eine Prüfung, die man
+        # nicht durchführen kann, darf nicht als bestanden gelten — aber auch
+        # nicht als Fehlschlag.
+        return True, "Windows-Programm (Versionsangaben nur unter Windows lesbar)"
+    return dateiangaben.passt(dateiangaben.versionsangaben(pfad),
+                              firma=MAKEMKV_FIRMA, produkt=MAKEMKV_PRODUKT,
+                              version=version)
 
 
 def makemkv_holen(version: str = "", basis: str = None, fortschritt=None,
-                  still: bool = True) -> str:
+                  still: bool = True, quellen: list = None) -> str:
     """Lädt MakeMKV und startet den offiziellen Installer.
 
-    **Rippy liefert MakeMKV NICHT mit** — es lädt die offizielle Datei vom
-    Hersteller und startet sie. Das ist dieselbe Black-Box-Trennung, die
-    `KONZEPT.md` § 6 für den Container festhält: MakeMKV bleibt ein fremdes
-    Programm, das der Nutzer bezieht; Rippy nimmt ihm nur die Handgriffe ab.
+    **Rippy liefert MakeMKV NICHT mit** — es lädt die offizielle Datei und
+    startet sie. Das ist dieselbe Black-Box-Trennung, die `KONZEPT.md` § 6
+    für den Container festhält: MakeMKV bleibt ein fremdes Programm, das der
+    Nutzer bezieht; Rippy nimmt ihm nur die Handgriffe ab.
 
-    Gibt den Pfad der heruntergeladenen Datei zurück.
+    Gibt den Pfad der heruntergeladenen Datei zurück. Wirft mit dem Bericht
+    ALLER Versuche, wenn keine Quelle geliefert hat — eine Meldung, die nur
+    „ging nicht" sagt, lässt den Nutzer ratlos zurück.
     """
     def melden(text, anteil=None):
         if fortschritt:
@@ -237,40 +553,105 @@ def makemkv_holen(version: str = "", basis: str = None, fortschritt=None,
     version = version or makemkv_neueste_version()
     if not version:
         raise BeschaffungsFehler(
-            "Die Download-Seite von MakeMKV war nicht erreichbar, deshalb ist "
-            "unbekannt, welche Fassung aktuell ist. (Am 28.08.2026 antwortete "
-            "makemkv.com mit HTTP 525 — eine Störung auf deren Seite.) "
-            "Ausweg: MakeMKV von Hand von makemkv.com laden und installieren; "
-            "Rippy findet es danach von allein.")
+            "Keine der Quellen konnte sagen, welche Fassung aktuell ist "
+            "(Hersteller-Seite, Forum, Archiv). Ausweg: MakeMKV von Hand von "
+            "makemkv.com laden und installieren; Rippy findet es danach von "
+            "allein.")
 
     ordner = os.path.join(katalog.werkzeug_ordner(), "downloads")
     os.makedirs(ordner, exist_ok=True)
-    ziel = os.path.join(ordner, f"Setup_MakeMKV_v{version}.exe")
+    ziel = os.path.join(ordner, "Setup_MakeMKV_v%s.exe" % version)
+    vorlaeufig = ziel + ".neu"
 
-    melden(f"MakeMKV {version} wird geladen …", 0.0)
-    _datei_laden(makemkv_setup_url(version, basis), ziel, 0, melden)
+    fehlschlaege = []
+    for name, url in (quellen if quellen is not None
+                      else makemkv_quellen(version, basis)):
+        melden("MakeMKV %s wird geladen (%s) …" % (version, name), 0.0)
+        try:
+            _datei_laden(url, vorlaeufig, 0, melden)
+            gut, grund = pruefe_makemkv_datei(vorlaeufig, version)
+            if not gut:
+                raise BeschaffungsFehler(grund)
+        except Exception as e:                       # noqa: BLE001
+            fehlschlaege.append("%s: %s" % (name, e))
+            melden("  %s hat nicht geliefert." % name)
+            try:
+                os.remove(vorlaeufig)
+            except OSError:
+                pass
+            continue
 
-    melden("Der Installer von MakeMKV wird gestartet …", 0.9)
-    starte_installer(ziel, still=still)
-    melden(f"MakeMKV {version} wird installiert.", 1.0)
-    return ziel
+        # Erst tauschen, wenn die Datei geprüft ist. Ein halber Download darf
+        # eine gute Datei nicht ersetzen.
+        os.replace(vorlaeufig, ziel)
+        melden("Der Installer von MakeMKV wird gestartet (Quelle: %s) …" % name, 0.9)
+        starte_installer(ziel, still=still)
+        melden("MakeMKV %s wird installiert." % version, 1.0)
+        return ziel
+
+    raise BeschaffungsFehler(
+        "Keine Quelle hat den MakeMKV-Installer geliefert:\n  "
+        + "\n  ".join(fehlschlaege)
+        + "\nAusweg: MakeMKV von Hand von makemkv.com laden und installieren; "
+          "Rippy findet es danach von allein.")
 
 
-def starte_installer(pfad: str, still: bool = True) -> None:
-    """Startet eine Installationsdatei — auf Wunsch ohne Rückfragen.
+def starte_installer(pfad: str, still: bool = True, starter=None) -> None:
+    r"""Startet eine Installationsdatei — auf Wunsch ohne Rückfragen.
 
     `/S` ist der stille Modus von NSIS, mit dem MakeMKVs Windows-Installer
     gebaut ist. Ohne Kennzeichen erscheint der gewohnte Dialog; das ist der
     ehrlichere Vorgabewert, wenn jemand zusieht.
-    """
-    from rippy.platform.winlauf import OHNE_FENSTER
 
-    befehl = [pfad] + (["/S"] if still else [])
-    try:
-        subprocess.Popen(befehl, creationflags=OHNE_FENSTER, close_fds=True)
-    except OSError as e:
+    ## Warum ShellExecute und NICHT subprocess.Popen (28.08.2026)
+
+    Der Commander: *„Das Problem ist, das make MKV sich nicht installieren
+    lässt weil der vorgang erhöhte rechte benötigt."*
+
+    Er hat den Kern getroffen, und der Fehler lag hier. MakeMKV installiert
+    nach `C:\Program Files (x86)` — sein Installer fordert im Manifest
+    Administratorrechte an. `subprocess.Popen` benutzt `CreateProcess`, und
+    das **zeigt keine UAC-Abfrage**: Es bricht mit `ERROR_ELEVATION_REQUIRED`
+    (740) ab. `ShellExecuteW` ist der dokumentierte Weg, der die Abfrage
+    auslöst.
+
+    ## Warum trotzdem nicht das ganze Setup erhöht läuft
+
+    Weil ein erhöhter Prozess die eingebundenen Netzlaufwerke NICHT sieht —
+    auf diesem Rechner gemessen: X:, Y:, Z: ohne Erhöhung sichtbar,
+    `EnableLinkedConnections` nicht gesetzt. Der Commander hat genau das
+    vorher als Fehler gemeldet. Erhöht wird deshalb nur DIESER eine Aufruf:
+    eine UAC-Abfrage für MakeMKVs Installer, und Rippy behält seine
+    Laufwerke.
+
+    `starter` ist einspritzbar, damit der Weg prüfbar ist, ohne etwas zu
+    installieren.
+    """
+    if starter is not None:
+        if not starter(pfad, "/S" if still else ""):
+            raise BeschaffungsFehler(
+                "Der Installer wurde nicht gestartet (Abfrage abgebrochen?).")
+        return
+
+    if os.name != "nt":
+        from rippy.platform.winlauf import OHNE_FENSTER
+
+        try:
+            subprocess.Popen([pfad] + (["/S"] if still else []),
+                             creationflags=OHNE_FENSTER, close_fds=True)
+        except OSError as e:
+            raise BeschaffungsFehler(
+                f"Der Installer ließ sich nicht starten: {e}") from e
+        return
+
+    from rippy.platform import winlauf
+
+    if not winlauf.mit_rechteabfrage_starten(pfad, "/S" if still else ""):
         raise BeschaffungsFehler(
-            f"Der Installer ließ sich nicht starten: {e}") from e
+            'Der Installer von MakeMKV wurde nicht gestartet. Er braucht '
+            'Administratorrechte (er installiert nach „Programme") — die '
+            'Abfrage von Windows muss bestätigt werden. Rippy selbst braucht '
+            'sie nicht.')
 
 
 # ── Gemeinsam ───────────────────────────────────────────────────────────

src/rippy/tools/katalog.py

@@ -42,6 +42,8 @@ import os
 import shutil
 import subprocess
 
+from rippy import pfade
+
 # ── Die Werkzeuge ───────────────────────────────────────────────────────
 # `programme`  Dateinamen, in dieser Reihenfolge probiert (64 Bit zuerst).
 # `orte`       Bekannte Installationsordner, mit %UMGEBUNGSVARIABLEN%.
@@ -59,6 +61,20 @@ WERKZEUGE = {
         "version_flag": None,      # kennt keinen Versions-Schalter
         "pflicht": True,
     },
+    "flac": {
+        "titel": "FLAC",
+        "zweck": "Wandelt die von der Audio-CD gelesenen Rohdaten in FLAC.",
+        "programme": ("flac.exe", "flac"),
+        "orte": (
+            r"%ProgramFiles%\FLAC",
+            r"%ProgramFiles(x86)%\FLAC",
+        ),
+        "anzeige": "FLAC",
+        "version_flag": "--version",
+        # KEINE Pflicht: Ohne FLAC laeuft alles ausser Audio-CDs. Wer nie eine
+        # CD rippt, soll deswegen keine Fehlermeldung im Setup sehen.
+        "pflicht": False,
+    },
     "handbrake": {
         "titel": "HandBrakeCLI",
         "zweck": "Komprimiert den verlustfreien Rip auf Arbeitsgröße.",
@@ -84,11 +100,46 @@ def werkzeug_ordner(basis: str = None) -> str:
     return os.path.join(os.path.expanduser("~"), ".local", "share", "rippy", "tools")
 
 
+# Die drei Pfad-Helfer stehen in `rippy.pfade` — dreimal dieselbe Falle in
+# drei Dateien war zweimal zu viel. Hier bleiben nur die Namen, damit die
+# Aufrufe unten lesbar bleiben.
+verbinden = pfade.verbinden
+ordner_von = pfade.ordner_von
+_sieht_nach_windows_aus = pfade.ist_windows_pfad
+
+
 def _entfalten(pfad: str, umgebung: dict) -> str:
-    """%ProgramFiles%\\X -> C:\\Program Files\\X (mit eigener Umgebung testbar)."""
+    r"""%ProgramFiles%\X -> C:\Program Files\X (mit eigener Umgebung testbar).
+
+    ## Warum das GROSS- UND KLEINSCHREIBUNG ignorieren muss (28.08.2026)
+
+    Windows behandelt Umgebungsvariablen ohne Rücksicht auf die Schreibweise,
+    und Python speichert sie unter Windows deshalb GROSS in `os.environ`.
+    Gemessen auf dem Rechner des Commanders:
+
+        os.environ            PROGRAMFILES(X86) = C:\Program Files (x86)
+        WERKZEUGE["orte"]     %ProgramFiles(x86)%\MakeMKV
+
+    Der Vergleich schlug fehl, `%` blieb stehen, und die Funktion gab "" —
+    der Kandidat fiel aus der Liste. **Die bekannten Installationsorte haben
+    auf einer echten Maschine also nie funktioniert.** MakeMKV wurde nur über
+    die Registry-Rückfallebene gefunden; wo die fehlt oder anders aussieht,
+    fand Rippy nichts.
+
+    Aufgefallen ist es nur, weil hier eine ECHTE Umgebung eingesetzt wurde.
+    Der Test spritzte `{"ProgramFiles(x86)": …}` in genau der Schreibweise
+    ein, die im Muster steht — er war damit grüner als die Wirklichkeit.
+    """
+    gross = {("%" + name + "%").upper(): wert for name, wert in umgebung.items()}
     ergebnis = pfad
-    for name, wert in umgebung.items():
-        ergebnis = ergebnis.replace("%" + name + "%", wert)
+    for marke, wert in gross.items():
+        # Suchen ohne Rücksicht auf die Schreibweise, ersetzen an der
+        # gefundenen Stelle — `str.replace` kann das nicht von allein.
+        while True:
+            stelle = ergebnis.upper().find(marke)
+            if stelle < 0:
+                break
+            ergebnis = ergebnis[:stelle] + wert + ergebnis[stelle + len(marke):]
     return ergebnis if "%" not in ergebnis else ""
 
 
@@ -107,15 +158,15 @@ def kandidaten(name: str, eigener_ordner: str = None, umgebung: dict = None) ->
     # 2. Rippys eigener Ordner — VOR dem System, damit eine selbst gepflegte
     #    Fassung eine alte Systeminstallation schlägt.
     for programm in werkzeug["programme"]:
-        pfade.append(os.path.join(eigener_ordner, name, programm))
-        pfade.append(os.path.join(eigener_ordner, programm))
+        pfade.append(verbinden(eigener_ordner, name, programm))
+        pfade.append(verbinden(eigener_ordner, programm))
     # 4. Bekannte Installationsorte.
     for ort in werkzeug["orte"]:
         entfaltet = _entfalten(ort, umgebung)
         if not entfaltet:
             continue
         for programm in werkzeug["programme"]:
-            pfade.append(os.path.join(entfaltet, programm))
+            pfade.append(verbinden(entfaltet, programm))
     return pfade
 
 
@@ -151,7 +202,7 @@ def finden(name: str, eingestellt: str = "", eigener_ordner: str = None,
         ordner = aus_registry(WERKZEUGE[name]["anzeige"]).get("ordner", "")
         if ordner:
             for programm in WERKZEUGE[name]["programme"]:
-                pfad = os.path.join(ordner, programm)
+                pfad = verbinden(ordner, programm)
                 if existiert(pfad):
                     return pfad
     return ""
@@ -179,7 +230,7 @@ def ordner_aus_eintrag(werte: dict) -> str:
     for schluessel in ("DisplayIcon", "UninstallString"):
         datei = programmdatei_aus(werte.get(schluessel) or "")
         if datei:
-            return os.path.dirname(datei)
+            return ordner_von(datei)
     return ""
 
 

src/rippy/tools/test_beschaffen.py

@@ -12,6 +12,64 @@ import pytest
 from rippy.tools import beschaffen
 
 
+# ── Der Fortschritts-Rueckruf ───────────────────────────────────────────
+class GefaelschteAntwort:
+    """Ein urlopen-Ergebnis mit vorgegebenem Inhalt."""
+
+    def __init__(self, daten):
+        self._daten = daten
+        self._gelesen = 0
+
+    def read(self, n):
+        stueck = self._daten[self._gelesen:self._gelesen + n]
+        self._gelesen += len(stueck)
+        return stueck
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *a):
+        return False
+
+
+def test_fortschritt_bekommt_IMMER_einen_text(tmp_path, monkeypatch):
+    """DER Fehler vom 28.08.2026 beim ersten echten Aufrufer:
+
+        can only concatenate str (not "NoneType") to str
+
+    `_datei_laden` schickte `None` als Text, wenn sich nur der Fortschritt
+    geaendert hatte. Wer den Text ausgab — der Bau, das Setup — starb daran.
+    Ein Rueckruf, den man nur mit einer nirgends dokumentierten
+    Sonderbehandlung benutzen kann, ist eine Falle.
+    """
+    inhalt = b"x" * (3 * 1024 * 1024)
+    monkeypatch.setattr(beschaffen.urllib.request, "urlopen",
+                        lambda *a, **k: GefaelschteAntwort(inhalt))
+
+    meldungen = []
+    beschaffen._datei_laden(
+        "http://egal", str(tmp_path / "d.bin"), len(inhalt),
+        lambda text, anteil=None: meldungen.append(text))
+
+    assert meldungen, "es kam ueberhaupt keine Meldung"
+    assert all(isinstance(m, str) for m in meldungen), meldungen
+    # Und der Aufrufer darf sie bedenkenlos verketten:
+    assert all(("  " + m) for m in meldungen)
+
+
+def test_fortschritt_flutet_das_protokoll_nicht(tmp_path, monkeypatch):
+    """24 MB in 256-KB-Haeppchen waeren fast hundert Zeilen."""
+    inhalt = b"x" * (24 * 1024 * 1024)
+    monkeypatch.setattr(beschaffen.urllib.request, "urlopen",
+                        lambda *a, **k: GefaelschteAntwort(inhalt))
+
+    meldungen = []
+    beschaffen._datei_laden(
+        "http://egal", str(tmp_path / "d.bin"), len(inhalt),
+        lambda text, anteil=None: meldungen.append(text))
+    assert len(meldungen) <= 12, len(meldungen)
+
+
 # ── Welche Datei aus dem Release? ───────────────────────────────────────
 # Woertlich aus der GitHub-Antwort vom 28.08.2026 (Release 1.11.2), gekuerzt.
 ASSETS = [
@@ -142,3 +200,116 @@ def test_werkzeug_ordner_liegt_dort_wo_geschrieben_werden_darf():
     assert "tools" in ordner
     if os.name == "nt":
         assert "Program Files" not in ordner
+
+
+# ── Die MakeMKV-Quellenkette ────────────────────────────────────────────
+#
+# Anlass: Commander am 28.08.2026 -- "bitte baue fuer MakeMKV fallback seiten
+# ein." Gemessen an dem Tag:
+#
+#     https://www.makemkv.com/download/   HTTP 525
+#     https://forum.makemkv.com/          HTTP 200   <- lebt
+#     web.archive.org/web/2025id_/...exe  HTTP 200, 16.432.607 Bytes
+def test_hoechste_version_statt_der_ersten():
+    """Das Forum listet alte Ankuendigungen mit. Die neueste Fassung ist die
+    mit der GROESSTEN Nummer -- und verglichen wird nach Zahlen, nicht nach
+    Zeichen, sonst waere 1.9.2 groesser als 1.18.4."""
+    text = "MakeMKV v1.9.2 ... MakeMKV v1.18.4 ... MakeMKV v1.17.0"
+    assert beschaffen.hoechste_version(text) == "1.18.4"
+
+
+def test_ohne_version_im_text_kommt_leer():
+    assert beschaffen.hoechste_version("nichts hier") == ""
+    assert beschaffen.hoechste_version("") == ""
+    assert beschaffen.hoechste_version(None) == ""
+
+
+def test_der_hersteller_kommt_immer_zuerst():
+    """Das Archiv ist die Rueckfallebene, nicht der Normalfall."""
+    quellen = beschaffen.makemkv_quellen("1.18.4")
+    assert [n for n, _ in quellen] == ["Hersteller", "Internet Archive"]
+    assert quellen[0][1].startswith("https://www.makemkv.com/")
+
+
+def test_eine_eigene_quelle_steht_ganz_vorn():
+    """Wer sie eintraegt, hat sich etwas dabei gedacht."""
+    quellen = beschaffen.makemkv_quellen("1.18.4", basis="https://nas/mkv")
+    assert quellen[0][0] == "eigene Quelle"
+    assert quellen[0][1] == "https://nas/mkv/Setup_MakeMKV_v1.18.4.exe"
+
+
+def test_die_archiv_adresse_hat_einen_zeitstempel():
+    """web/3000id_/ und web/id_/ holen die Datei LIVE nach -- und die Quelle
+    ist ja gerade tot. Am 28.08.2026 gemessen: 3000id_ gab 525, id_ gab HTML
+    statt Programm."""
+    _, url = beschaffen.makemkv_quellen("1.18.4")[-1]
+    assert "web.archive.org" in url
+    assert "id_/" in url
+    assert beschaffen.ARCHIV_STAND in url
+    assert url.endswith("Setup_MakeMKV_v1.18.4.exe")
+
+
+def test_versionsquellen_haben_alle_drei_wege():
+    quellen = beschaffen.versionsquellen()
+    assert len(quellen) == 3
+    urls = [q["url"] for q in quellen]
+    assert any("forum.makemkv.com" in u for u in urls), "das Forum lebte als einziges"
+    assert any("web.archive.org" in u for u in urls)
+    # Genau EINE Quelle ist massgeblich: der Hersteller selbst.
+    assert [q["massgeblich"] for q in quellen] == [True, False, False]
+
+
+def test_eine_tote_quelle_wird_uebersprungen(monkeypatch):
+    """Der eigentliche Zweck der Kette."""
+    gefragt = []
+
+    def laden(url, timeout=20):
+        gefragt.append(url)
+        if "makemkv.com/download" in url and "archive" not in url:
+            raise OSError("HTTP 525")
+        return b"MakeMKV v1.18.4"
+
+    monkeypatch.setattr(beschaffen, "_laden", laden)
+    assert beschaffen.makemkv_neueste_version() == "1.18.4"
+    assert len(gefragt) >= 2, "die zweite Quelle wurde nie gefragt"
+
+
+def test_ein_alter_archiv_stand_gewinnt_NICHT(monkeypatch):
+    """DER gemessene Fall vom 28.08.2026: forum.makemkv.com antwortet
+    unzuverlaessig. Vier Laeufe hintereinander:
+
+        1.18.4 (0,3s)  1.18.4 (0,4s)  1.18.2 (21,3s)  1.18.2 (21,0s)
+
+    Lief das Forum in die Zeitgrenze, gewann der aeltere Archiv-Schnappschuss
+    -- und Rippy haette 1.18.2 geholt, obwohl 1.18.4 aktuell ist."""
+    def laden(url, timeout=20):
+        if "forum" in url:
+            return b"MakeMKV v1.18.4"
+        if "archive" in url:
+            return b"MakeMKV v1.18.2 MakeMKV v1.18.1"
+        raise OSError("HTTP 525")
+
+    monkeypatch.setattr(beschaffen, "_laden", laden)
+    assert beschaffen.makemkv_neueste_version() == "1.18.4"
+
+
+def test_der_hersteller_beendet_die_suche(monkeypatch):
+    """Antwortet er, ist die Sache entschieden -- auch wenn irgendwo eine
+    hoehere Nummer herumliegt. Er IST die Wahrheit."""
+    gefragt = []
+
+    def laden(url, timeout=20):
+        gefragt.append(url)
+        return b"MakeMKV v1.18.4"
+
+    monkeypatch.setattr(beschaffen, "_laden", laden)
+    assert beschaffen.makemkv_neueste_version() == "1.18.4"
+    assert len(gefragt) == 1, "nach der massgeblichen Quelle wurde weitergesucht"
+
+
+def test_wenn_KEINE_quelle_antwortet_kommt_leer(monkeypatch):
+    def platzt(url, timeout=20):
+        raise OSError("weg")
+
+    monkeypatch.setattr(beschaffen, "_laden", platzt)
+    assert beschaffen.makemkv_neueste_version() == ""

src/rippy/tools/test_katalog.py

@@ -14,10 +14,20 @@ laeuft auf jeder Plattform.
 
 from rippy.tools import katalog
 
+BACKSLASH = chr(92)
+
 # Eine Umgebung ohne echte Systemvariablen, damit die Pfade vorhersagbar sind.
+#
+# ⚠️ Die Schluessel stehen GROSS — genau so, wie Windows sie in `os.environ`
+# ablegt (am 28.08.2026 nachgesehen: `PROGRAMFILES(X86)`). Vorher stand hier
+# die huebsche Schreibweise `ProgramFiles(x86)`, und damit war dieser Test
+# gruener als die Wirklichkeit: Die Entfaltung verglich Zeichen fuer Zeichen,
+# fand auf einer echten Maschine nie eine Uebereinstimmung und lieferte "".
+# Die bekannten Installationsorte haben deshalb NIE funktioniert; MakeMKV
+# wurde nur ueber die Registry-Rueckfallebene gefunden.
 UMGEBUNG = {
-    "ProgramFiles": r"C:\Program Files",
-    "ProgramFiles(x86)": r"C:\Program Files (x86)",
+    "PROGRAMFILES": r"C:\Program Files",
+    "PROGRAMFILES(X86)": r"C:\Program Files (x86)",
 }
 
 
@@ -35,6 +45,52 @@ def _keine_registry(_):
     return {}
 
 
+# ── Pfade zusammensetzen ────────────────────────────────────────────────
+#
+# Diese fuenf Tests gibt es wegen der Ampel-Laeufe 181–184 (28.08.2026): Sie
+# waren rot, und zwar NUR auf Linux. `os.path.join` nimmt immer den Trenner
+# der laufenden Maschine — auf dem Linux-Runner wurde aus
+# `C:\Program Files (x86)\MakeMKV` + `makemkvcon64.exe` dann
+# `C:\Program Files (x86)\MakeMKV/makemkvcon64.exe`, ein Pfad, den es auf
+# keiner Maschine gibt.
+#
+# Sie pruefen BEIDE Zweige, laufen also ueberall und faenden den Fehler auch
+# unter Windows. Genau das war vorher nicht so.
+def test_windows_pfad_bekommt_backslashes():
+    assert katalog.verbinden(r"C:\Program Files (x86)\MakeMKV",
+                             "makemkvcon64.exe") == \
+        r"C:\Program Files (x86)\MakeMKV\makemkvcon64.exe"
+
+
+def test_linux_pfad_bekommt_schraegstriche():
+    assert katalog.verbinden("/usr/local/bin", "makemkvcon") == \
+        "/usr/local/bin/makemkvcon"
+
+
+def test_laufwerksbuchstabe_allein_reicht_als_hinweis():
+    """`D:` ohne Backslash ist trotzdem Windows — und wird auch so verbunden.
+
+    Der erste Anlauf dieses Tests erwartete `D:\\Rippy\\tools` und war damit
+    falsch: `D:` OHNE Backslash bedeutet unter Windows „der aktuelle Ordner
+    auf Laufwerk D", nicht dessen Wurzel. `ntpath.join` setzt deshalb
+    absichtlich keinen Trenner davor. Geprueft wird hier also, dass die
+    Windows-Regeln gelten — nicht, dass eine bequeme Erwartung erfuellt wird.
+    """
+    assert katalog.verbinden("D:", "Rippy", "tools") == r"D:Rippy\tools"
+    assert katalog.verbinden("D:" + BACKSLASH, "Rippy") == r"D:\Rippy"
+
+
+def test_ordner_von_folgt_dem_pfad_nicht_der_maschine():
+    assert katalog.ordner_von(r"C:\Program Files (x86)\MakeMKV\uninstall.exe") \
+        == r"C:\Program Files (x86)\MakeMKV"
+    assert katalog.ordner_von("/opt/makemkv/bin/makemkvcon") == "/opt/makemkv/bin"
+
+
+def test_leerer_pfad_gilt_nicht_als_windows():
+    assert katalog._sieht_nach_windows_aus("") is False
+    assert katalog._sieht_nach_windows_aus(None) is False
+
+
 # ── Suchreihenfolge ─────────────────────────────────────────────────────
 def test_eingestellter_pfad_schlaegt_alles():
     """Wer einen Pfad eintraegt, will genau den — sonst haette er nichts
@@ -174,3 +230,30 @@ def test_programmdatei_aus_beiden_formen():
     assert p(r"C:\R\x.exe") == r"C:\R\x.exe"
     assert p("") == ""
     assert p("irgendwas ohne Programm") == ""
+
+
+def test_schreibweise_der_umgebungsvariablen_ist_egal():
+    """DER Fehler vom 28.08.2026. Windows legt Umgebungsvariablen GROSS ab,
+    das Muster in WERKZEUGE steht huebsch geschrieben. Ohne diese Pruefung
+    faellt der Unterschied nie auf — der alte Test spritzte genau die
+    Schreibweise ein, die im Muster stand."""
+    for schreibweise in ("ProgramFiles(x86)", "PROGRAMFILES(X86)",
+                         "programfiles(x86)"):
+        entfaltet = katalog._entfalten(
+            r"%ProgramFiles(x86)%\MakeMKV", {schreibweise: r"C:\PF86"})
+        assert entfaltet == r"C:\PF86\MakeMKV", (schreibweise, entfaltet)
+
+
+def test_mit_der_ECHTEN_umgebung_kommen_die_systempfade_heraus():
+    """Die Gegenprobe an os.environ statt an einer gepflegten Attrappe.
+    Genau die hat gefehlt."""
+    import os
+
+    if os.name != "nt":
+        import pytest
+        pytest.skip("ProgramFiles gibt es nur unter Windows")
+    pfade = katalog.kandidaten("makemkv", r"C:\Rippy	ools", os.environ)
+    assert any("Program Files" in p for p in pfade), (
+        "Kein einziger Systempfad in der Kandidatenliste — dann findet Rippy "
+        "eine normale MakeMKV-Installation nur noch ueber die Registry."
+    )

src/rippy/windows_app.py

@@ -1,505 +0,0 @@
-"""Rippy für Windows: Installer, Hintergrunddienst und Deinstallation in EINER Datei.
-
-## Warum eine Datei und nicht drei
-
-Die naheliegende Aufteilung wäre `RippySetup.exe`, `Rippy.exe` und
-`RippyUninstall.exe`. Drei PyInstaller-Bauten, drei Signaturen, drei
-Versionsstände, die auseinanderlaufen können — und ein Deinstaller, der sich
-selbst löschen müsste.
-
-Stattdessen: **ein Programm, drei Betriebsarten.**
-
-    RippySetup.exe                    installiert (Doppelklick)
-    Rippy.exe --dienst                laeuft im Hintergrund
-    Rippy.exe --deinstallieren        raeumt sich weg
-
-Bei der Installation kopiert sich die Datei nach
-`%LOCALAPPDATA%\\Rippy\\Rippy.exe`. Der Name ist Absicht: **Im Taskmanager
-steht dann „Rippy.exe"** — was der Commander ausdrücklich wollte. Ein Prozess,
-den man nicht wiederfindet, kann man auch nicht beenden.
-
-## Warum kein Windows-Dienst
-
-Ein echter Dienst startet vor der Anmeldung — klingt besser, kostet aber bei
-JEDER Installation und jedem Update eine Administrator-Abfrage, und ein Dienst
-kann kein Tray-Symbol zeigen (er hat keine Benutzersitzung). Rippy nimmt den
-Autostart-Eintrag unter `HKCU\\...\\Run`: kein UAC, Tray funktioniert, und mit
-einem Registry-Eintrag wieder weg.
-
-## Warum das Tray-Symbol keine Nebensache ist
-
-Ein Hintergrundprozess ohne sichtbaren Zugang ist eine Zumutung: Man weiß
-nicht, ob er läuft, kommt nicht an die Oberfläche und kann ihn nicht beenden,
-ohne den Taskmanager zu bemühen. Das Symbol beantwortet alle drei Fragen.
-"""
-
-import os
-import shutil
-import subprocess
-import sys
-import threading
-import time
-import webbrowser
-
-from rippy.platform import verknuepfungen
-from rippy.platform import win_registry as reg
-
-VERSION = os.environ.get("RIPPY_VERSION", "2.0.0")
-STANDARD_PORT = 7788
-
-
-# ═══════════════════════════════════════════════════════════ Hilfen ═════
-def _eigene_datei() -> str:
-    """Der Pfad DIESER ausführbaren Datei (auch im PyInstaller-Paket)."""
-    if getattr(sys, "frozen", False):
-        return sys.executable
-    return os.path.abspath(sys.argv[0])
-
-
-def _mitgeliefert(name: str) -> str:
-    """Eine mitgepackte Datei (Icon, UI, API) im Paket oder im Repo finden."""
-    gebuendelt = getattr(sys, "_MEIPASS", None)
-    if gebuendelt:
-        return os.path.join(gebuendelt, name)
-    hier = os.path.dirname(os.path.abspath(__file__))
-    repo = os.path.dirname(os.path.dirname(hier))
-    return os.path.join(repo, name)
-
-
-def _icon_pfad() -> str:
-    for kandidat in (_mitgeliefert("rippy.ico"),
-                     _mitgeliefert(os.path.join("deploy", "worker-windows", "rippy.ico"))):
-        if os.path.isfile(kandidat):
-            return kandidat
-    return ""
-
-
-def melden(text: str) -> None:
-    """Ausgabe, die auch ohne Konsole nicht abstürzt.
-
-    Eine als `--windowed` gebaute EXE hat keine Standardausgabe; `print()`
-    schreibt dann ins Leere oder wirft. Und unter Windows kann eine
-    Konsolen-Ausgabe an einem Umlaut sterben (cp1252) — genau daran ist der
-    erste Standalone-Start gescheitert. Deshalb hier: nie werfen.
-    """
-    try:
-        sys.stdout.write(text + "\n")
-        sys.stdout.flush()
-    except Exception:
-        pass
-
-
-# ═══════════════════════════════════════════════════ Installation ═══════
-def installieren(ziel: str = None, autostart: bool = True,
-                 starten_danach: bool = True, verknuepfen: bool = True) -> str:
-    """Kopiert Rippy an seinen Platz und meldet es bei Windows an.
-
-    Gibt den Installationsordner zurück. Wirft bei echten Fehlern — eine
-    halb geglückte Installation soll NICHT wie ein Erfolg aussehen.
-    """
-    ziel = ziel or reg.standard_installationsordner()
-    os.makedirs(ziel, exist_ok=True)
-
-    quelle = _eigene_datei()
-    programm = os.path.join(ziel, "Rippy.exe")
-
-    # Sich selbst kopieren. Läuft gerade eine ältere Fassung, ist die Datei
-    # gesperrt — dann daneben legen und beim nächsten Start tauschen.
-    if os.path.abspath(quelle).lower() != os.path.abspath(programm).lower():
-        try:
-            shutil.copy2(quelle, programm)
-        except PermissionError:
-            ersatz = programm + ".neu"
-            shutil.copy2(quelle, ersatz)
-            melden("Rippy läuft gerade — die neue Fassung wird beim nächsten "
-                   "Start übernommen.")
-            programm = ersatz
-
-    icon = _icon_pfad()
-    if icon and os.path.isfile(icon):
-        try:
-            shutil.copy2(icon, os.path.join(ziel, "rippy.ico"))
-        except OSError:
-            pass
-
-    # Der Eintrag in „Programme und Features" — ohne ihn ist Rippy ein
-    # Programm, das man nur von Hand wieder loswird.
-    reg.eintragen(ziel, programm, VERSION,
-                  icon=os.path.join(ziel, "rippy.ico") if icon else "")
-
-    if autostart:
-        reg.autostart_setzen('"%s" --dienst' % programm)
-
-    if verknuepfen:
-        # Ohne Symbol auf dem Desktop und ohne Startmenue-Eintrag ist ein
-        # Hintergrundprogramm praktisch unauffindbar: Es laeuft, aber der
-        # Nutzer hat keinen Weg hinein ausser der Adresse im Kopf.
-        angelegt = verknuepfungen.alle_anlegen(
-            programm, icon=os.path.join(ziel, "rippy.ico"))
-        for ort in ("desktop", "startmenue"):
-            if ort in angelegt:
-                melden("  Verknuepfung angelegt: %s" % angelegt[ort])
-            else:
-                # Sagen, was NICHT geklappt hat — sonst sucht der Nutzer ein
-                # Symbol, das es nie gab.
-                melden("  Verknuepfung (%s) konnte nicht angelegt werden." % ort)
-
-    if starten_danach:
-        starte_hintergrund(programm)
-
-    return ziel
-
-
-def starte_hintergrund(programm: str) -> None:
-    """Startet Rippy als Hintergrundprozess — ohne aufblitzendes Fenster."""
-    from rippy.platform.winlauf import OHNE_FENSTER
-
-    subprocess.Popen([programm, "--dienst"], creationflags=OHNE_FENSTER,
-                     close_fds=True)
-
-
-def deinstallieren(still: bool = False) -> None:
-    """Nimmt alle Spuren zurück: Autostart, Registry-Eintrag, Dateien."""
-    # WOHIN wurde installiert? Das steht in der Registry, nicht im Code.
-    # Vorher stand hier `reg.standard_installationsordner()` — wer nach
-    # `--ziel D:\Rippy` installiert hatte, dessen Dateien waeren geblieben,
-    # waehrend ein fremder Ordner unter %LOCALAPPDATA% angefasst worden waere.
-    # InstallLocation wird genau dafuer beim Eintragen mitgeschrieben.
-    ordner = (reg.gelesene_werte().get("InstallLocation")
-              or reg.standard_installationsordner())
-
-    for lnk in verknuepfungen.alle_entfernen():
-        if not still:
-            melden("  Verknuepfung entfernt: %s" % lnk)
-
-    reg.autostart_entfernen()
-    reg.austragen()
-    laeuft_von_hier = os.path.abspath(_eigene_datei()).lower().startswith(
-        os.path.abspath(ordner).lower())
-
-    # Die eigene Datei kann sich nicht selbst loeschen, solange sie laeuft.
-    # Also: alles andere jetzt, die EXE per Aufraeum-Befehl danach.
-    for name in os.listdir(ordner) if os.path.isdir(ordner) else []:
-        pfad = os.path.join(ordner, name)
-        if laeuft_von_hier and os.path.abspath(pfad).lower() == os.path.abspath(_eigene_datei()).lower():
-            continue
-        try:
-            shutil.rmtree(pfad) if os.path.isdir(pfad) else os.remove(pfad)
-        except OSError:
-            pass
-
-    if laeuft_von_hier:
-        selbst_loeschen(_eigene_datei(), ordner)
-
-    if not still:
-        melden("Rippy wurde entfernt.")
-
-
-AUFRAEUM_SKRIPT = """@echo off
-rem Erzeugt von Rippy beim Deinstallieren. Loescht sich selbst am Ende.
-for /l %%n in (1,1,15) do (
-  ping 127.0.0.1 -n 3 >nul
-  del /q "{exe}" >nul 2>&1
-  if not exist "{exe}" goto weg
-)
-goto ende
-:weg
-rmdir "{ordner}" >nul 2>&1
-:ende
-del /q "%~f0" >nul 2>&1
-"""
-
-
-def aufraeum_skript(exe: str, ordner: str) -> str:
-    """Der Inhalt des Aufraeum-Skripts (reine Funktion, damit pruefbar)."""
-    return AUFRAEUM_SKRIPT.format(exe=exe, ordner=ordner.rstrip("\\/"))
-
-
-def selbst_loeschen(exe: str, ordner: str) -> str:
-    r"""Loescht die eigene EXE und den Ordner — nachdem dieser Prozess weg ist.
-
-    Gibt den Pfad des Aufraeum-Skripts zurueck (fuer Tests und Diagnose).
-
-    ## Warum ein Skript und kein cmd-Einzeiler (gemessen 28.08.2026)
-
-    Der erste Versuch uebergab den ganzen Befehl als EIN Argument an
-    `cmd /c`. Python maskiert dabei die inneren Anfuehrungszeichen — bei cmd
-    kam an:
-
-        del /q \"C:\Users\...\Rippy.exe\"
-
-    Mit den Backslashes davor ist das ein anderer Dateiname, also loeschte
-    `del` nichts und meldete auch nichts (die Ausgabe war nach >nul
-    umgeleitet). Ergebnis: Registry-Eintrag und Autostart waren weg, die
-    28-MB-Datei blieb liegen — und der Fehlschlag war unsichtbar. Genau die
-    Sorte still scheiternder Hintergrundprozess, vor der AGENTS.md warnt.
-
-    Ein Skript hat das Problem nicht: Sein Inhalt geht durch keine
-    Argument-Zerlegung.
-
-    ## Warum es fuenfzehnmal versucht
-
-    Eine PyInstaller-Onefile-EXE laeuft als ZWEI Prozesse — ein Starter und
-    die eigentliche Anwendung. Der Starter raeumt nach dem Ende noch sein
-    Entpack-Verzeichnis auf und haelt die Datei so lange offen. Zwei Sekunden
-    sind dafuer mal genug und mal nicht.
-
-    Klappt es in einer halben Minute nicht, bleibt eine Datei liegen. Das ist
-    unschoen, aber harmlos: Registry-Eintrag und Autostart sind da schon weg,
-    Rippy startet also nicht mehr mit.
-    """
-    import tempfile
-
-    from rippy.platform.winlauf import OHNE_FENSTER
-
-    skript = os.path.join(tempfile.gettempdir(), "rippy-aufraeumen.bat")
-    # ascii + replace: Der Pfad kann Umlaute enthalten, und cmd liest .bat
-    # in der Konsolen-Codepage. Ein Fragezeichen im Pfad ist besser als ein
-    # Skript, das cmd gar nicht erst annimmt.
-    with open(skript, "w", encoding="ascii", errors="replace", newline="\r\n") as f:
-        f.write(aufraeum_skript(exe, ordner))
-
-    subprocess.Popen(["cmd", "/c", skript], creationflags=OHNE_FENSTER,
-                     close_fds=True)
-    return skript
-
-
-# ═══════════════════════════════════════════════ Der Hintergrunddienst ══
-class Dienst:
-    """Rippy im Hintergrund: der Server in einem Thread, das Tray-Symbol davor."""
-
-    def __init__(self, port: int = STANDARD_PORT):
-        self.port = port
-        self._server = None
-        self._laeuft = False
-
-    # ── Server ──────────────────────────────────────────────────────────
-    def server_starten(self) -> None:
-        from rippy import config, daemon, store
-
-        werte = config.laden(flags={"server": {"port": self.port}})
-        store.verbinden(config.datenbank_url(werte))
-        app, _ = daemon.anwendung_bauen(werte)
-
-        # Ohne diesen Schritt koennte Rippy alles anzeigen und nichts tun.
-        from rippy import standalone
-        from rippy.bus.memory import bus as ereignis_bus
-
-        standalone.starten(bus=ereignis_bus, store=store,
-                           slots=werte["queue"].get("rip_slots", 1))
-
-        import uvicorn
-
-        self._server = uvicorn.Server(uvicorn.Config(
-            app, host="127.0.0.1", port=self.port, log_level="warning"))
-        self._laeuft = True
-        self._server.run()
-
-    def stoppen(self) -> None:
-        self._laeuft = False
-        if self._server is not None:
-            self._server.should_exit = True
-
-    @property
-    def adresse(self) -> str:
-        return "http://127.0.0.1:%d" % self.port
-
-    def erreichbar(self, timeout: float = 1.0) -> bool:
-        """Antwortet der Server WIRKLICH? Nicht: läuft der Thread noch.
-
-        Ein lebender Thread ist kein Beweis dafür, dass jemand bedient wird —
-        dieselbe Unterscheidung wie überall sonst in diesem Projekt.
-        """
-        import urllib.error
-        import urllib.request
-
-        try:
-            with urllib.request.urlopen(self.adresse + "/api/health", timeout=timeout):
-                return True
-        except (urllib.error.URLError, OSError):
-            return False
-
-
-def dienst_starten(port: int = STANDARD_PORT) -> int:
-    """Server im Hintergrund-Thread, Tray-Symbol im Vordergrund.
-
-    Die Reihenfolge ist unter Windows Pflicht: `pystray` muss im HAUPT-Thread
-    laufen, sonst bekommt es keine Fensternachrichten und das Symbol
-    erscheint nie.
-    """
-    dienst = Dienst(port)
-    threading.Thread(target=dienst.server_starten, daemon=True,
-                     name="rippy-server").start()
-
-    # Kurz warten und NACHSEHEN, ob der Server wirklich antwortet.
-    for _ in range(30):
-        if dienst.erreichbar(timeout=0.5):
-            break
-        time.sleep(0.5)
-
-    symbol = tray_bauen(dienst)
-    if symbol is None:
-        # Kein Tray möglich (fehlende Bibliothek): Dann eben ohne — der
-        # Dienst ist wichtiger als sein Symbol. Aber es wird gesagt.
-        melden("Tray-Symbol nicht verfügbar — Rippy läuft trotzdem auf "
-               + dienst.adresse)
-        try:
-            while True:
-                time.sleep(3600)
-        except KeyboardInterrupt:
-            pass
-        return 0
-
-    symbol.run()
-    dienst.stoppen()
-    return 0
-
-
-def oeffnen(port: int = STANDARD_PORT) -> int:
-    """Rippy oeffnen — Dienst starten, falls noetig, dann den Browser.
-
-    ## Warum die Verknuepfungen hierher zeigen und nicht auf --dienst
-
-    Ein Doppelklick auf ein Desktop-Symbol soll Rippy OEFFNEN. Ob der Dienst
-    schon laeuft, ist dem Nutzer egal — und er kann es auch nicht wissen.
-
-    Zeigte die Verknuepfung auf `--dienst`, startete jeder Klick einen
-    ZWEITEN Server. Der zweite scheiterte am belegten Port, das Fenster
-    blitzte auf und verschwand, und im Browser passierte nichts. Ein Symbol,
-    das beim zweiten Klick nichts tut, ist schlimmer als keins.
-
-    Deshalb: erst NACHSEHEN, ob jemand antwortet. Nur wenn nicht, starten —
-    und dann warten, bis er wirklich da ist, statt sofort einen Browser auf
-    eine tote Adresse zu schicken.
-    """
-    dienst = Dienst(port)
-
-    if not dienst.erreichbar(timeout=1.5):
-        melden("Rippy wird gestartet …")
-        programm = _eigene_datei()
-        starte_hintergrund(programm)
-        # Warten, bis er ANTWORTET — nicht bis der Prozess existiert.
-        for _ in range(60):
-            if dienst.erreichbar(timeout=1.0):
-                break
-            time.sleep(0.5)
-        else:
-            melden("Rippy antwortet nicht. Laeuft schon etwas auf Port %d?" % port)
-            return 1
-
-    webbrowser.open(dienst.adresse)
-    return 0
-
-
-def tray_bauen(dienst):
-    """Das Tray-Symbol. None, wenn pystray/Pillow fehlen."""
-    try:
-        import pystray
-        from PIL import Image
-    except ImportError:
-        return None
-
-    icon = _icon_pfad()
-    try:
-        bild = Image.open(icon) if icon and os.path.isfile(icon) else None
-    except OSError:
-        bild = None
-    if bild is None:
-        from PIL import ImageDraw
-
-        bild = Image.new("RGB", (64, 64), (16, 20, 32))
-        zeichner = ImageDraw.Draw(bild)
-        zeichner.ellipse((8, 8, 56, 56), outline=(245, 158, 11), width=6)
-        zeichner.ellipse((26, 26, 38, 38), fill=(245, 158, 11))
-
-    def oeffnen(_=None, __=None):
-        webbrowser.open(dienst.adresse)
-
-    def beenden(symbol, _=None):
-        dienst.stoppen()
-        symbol.stop()
-
-    def zustand(_=None):
-        return "Läuft — " + dienst.adresse if dienst.erreichbar() else "Startet …"
-
-    menue = pystray.Menu(
-        pystray.MenuItem("Rippy öffnen", oeffnen, default=True),
-        pystray.MenuItem(zustand, None, enabled=False),
-        pystray.Menu.SEPARATOR,
-        pystray.MenuItem("Beenden", beenden),
-    )
-    return pystray.Icon("Rippy", bild, "Rippy", menue)
-
-
-# ═══════════════════════════════════════════════════════ Einstieg ═══════
-HILFE = """Rippy für Windows
-
-  RippySetup.exe                 installieren (Doppelklick)
-  Rippy.exe --oeffnen            oeffnen (startet den Dienst, falls noetig)
-  Rippy.exe --dienst             im Hintergrund laufen lassen
-  Rippy.exe --deinstallieren     entfernen
-  Rippy.exe --status             nachsehen, was installiert ist
-
-Optionen:
-  --port N        Port (Vorgabe: 7788)
-  --ziel PFAD     Installationsordner
-  --kein-autostart
-  --keine-verknuepfungen   ohne Desktop-Symbol und Startmenue-Eintrag
-  --still         ohne Rückmeldungen
-"""
-
-
-def status() -> int:
-    melden("Rippy %s" % VERSION)
-    melden("  Diese Datei          %s" % _eigene_datei())
-    melden("  Installationsordner  %s" % reg.standard_installationsordner())
-    if os.name != "nt":
-        melden("  (kein Windows — Registry wird nicht gelesen)")
-        return 0
-    melden("  In Programme+Features %s" % ("ja" if reg.ist_eingetragen() else "nein"))
-    melden("  Autostart             %s" % (reg.autostart_wert() or "nein"))
-    for name, pfad in (("Desktop-Symbol", verknuepfungen.desktop_pfad()),
-                       ("Startmenue", verknuepfungen.startmenue_pfad())):
-        melden("  %-21s %s" % (name, pfad if pfad and os.path.isfile(pfad)
-                               else "nein"))
-    for name, wert in sorted(reg.gelesene_werte().items()):
-        melden("      %-18s %s" % (name, wert))
-    return 0
-
-
-def main(argv=None) -> int:
-    argv = list(sys.argv[1:] if argv is None else argv)
-
-    def wert(flag, standard=None):
-        return argv[argv.index(flag) + 1] if flag in argv else standard
-
-    if "--hilfe" in argv or "--help" in argv or "-h" in argv:
-        melden(HILFE)
-        return 0
-    if "--status" in argv:
-        return status()
-    if "--deinstallieren" in argv:
-        deinstallieren(still="--still" in argv)
-        return 0
-    if "--oeffnen" in argv:
-        return oeffnen(int(wert("--port", STANDARD_PORT)))
-    if "--dienst" in argv:
-        return dienst_starten(int(wert("--port", STANDARD_PORT)))
-
-    # Ohne Argument: installieren. Das ist der Doppelklick-Fall.
-    ziel = installieren(
-        ziel=wert("--ziel"),
-        autostart="--kein-autostart" not in argv,
-        starten_danach="--nicht-starten" not in argv,
-        verknuepfen="--keine-verknuepfungen" not in argv,
-    )
-    melden("Rippy wurde nach %s installiert." % ziel)
-    melden("Die Oberfläche öffnet sich gleich im Browser.")
-    if "--nicht-starten" not in argv:
-        time.sleep(3)
-        webbrowser.open("http://127.0.0.1:%d" % int(wert("--port", STANDARD_PORT)))
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())