fix(v5): 5.7.1 — Titel lesen wartet, solange MakeMKV arbeitet; Grenze gilt für Stille, Dialog zeigt Schritt, Prozent und Meldung

WAS: Der Info-Lauf verlangt --progress=-same und wertet die Ausgabe
zeilenweise aus (PRGC/PRGT/PRGV/MSG). titelInfoLesen beendet makemkvcon
nur noch, wenn er so lange STILL ist, wie die Einstellung erlaubt
(Vorgabe 15 min) — jede Fortschritts- oder Meldungszeile setzt die Uhr
zurück. Kündigt MakeMKV den VOB-Scan an („IFO-Datei … beschädigt, die
VOB-Datei muss gescannt werden"), gilt nur noch eine Obergrenze von 4 h.
Der Dialog zeigt während des Lesens Schritt, Prozent und letzte Meldung
(titelLaufZwischenstand), beim VOB-Scan mit Erklärung (20–60 min, im
MakeMKV-Programm genauso). Bricht Rippy ab, stehen die letzten acht
Zeilen von makemkvcon im Fehler und im Protokoll. Einstellungs-Text
„Titel lesen — ohne Lebenszeichen höchstens". Tests mit nachgebautem
makemkvcon (redselig über die Stille-Grenze hinaus, stumm, VOB-Scan mit
Obergrenze). Version 5.7.1, Änderungsnotizen.
WARUM: Commander 12.09.2026 spät: „Der Patriot" (DVD, IFO für VTS #1
beschädigt) scheiterte in 5.7.0 erneut nach 15 Minuten, das MakeMKV-
Programm las die Disc fertig — MakeMKV liest bei so einer Disc die ganze
VOB durch, das dauert so lange wie die Disc braucht. Eine feste
Gesamtgrenze ist dafür immer zu kurz; Stille ist das richtige Maß.

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

rippy-windows/src/fenster/einstellungen/Karten.tsx

@@ -579,7 +579,7 @@ export function AllgemeinKarte({ verbindung, haupt }: { verbindung: Verbindung;
     <SektionsKarte id="allgemein" titel="ALLGEMEIN" intro="Rippy lebt im Infobereich neben der Uhr: Fenster zu heißt weiterlaufen, beendet wird über das Tray-Menü.">
       <Schalter an={haupt?.autostart === true} aufWechsel={(an) => void window.rippy.autostartSetzen(an)} label="Rippy mit Windows starten (Autostart im Benutzerkonto — kein Dienst, keine Adminrechte)" />
       <label className="block max-w-sm">
-        <span className="text-xs font-semibold text-dunst">Titel lesen — höchstens</span>
+        <span className="text-xs font-semibold text-dunst">Titel lesen — ohne Lebenszeichen höchstens</span>
         <select value={werte['titelLesenMinuten'] ?? '15'} onChange={(e) => setzen('titelLesenMinuten', e.target.value)} className={FELD_KLASSE}>
           <option value="5">5 Minuten</option>
           <option value="10">10 Minuten</option>
@@ -587,7 +587,7 @@ export function AllgemeinKarte({ verbindung, haupt }: { verbindung: Verbindung;
           <option value="30">30 Minuten</option>
           <option value="60">60 Minuten</option>
         </select>
-        <span className="mt-1 block text-[11px] leading-4 text-nebel">So lange darf MakeMKV die Titel einer Disc lesen. Kopiergeschützte DVDs und Discs mit vielen Playlisten brauchen im MakeMKV-Programm oft länger als fünf Minuten — braucht eine Disc dort länger als hier eingestellt, erhöhe den Wert.</span>
+        <span className="mt-1 block text-[11px] leading-4 text-nebel">So lange darf MakeMKV still sein (kein Fortschritt, keine Meldung), bevor Rippy das Titel-Lesen beendet. Solange MakeMKV arbeitet und Fortschritt meldet — etwa beim Durchlesen einer DVD mit beschädigter IFO-Datei, was 20–60 Minuten dauern kann — wartet Rippy; „Abbrechen" im Dialog geht jederzeit.</span>
       </label>
       <label className="block max-w-sm">
         <span className="text-xs font-semibold text-dunst">Erscheinungsbild</span>

rippy-windows/src/kern/dienste/erkennung.ts

@@ -16,7 +16,7 @@ import { discFingerprint, discTitel, type DiscTitel } from '../metadaten/discmer
 import { OmdbClient } from '../metadaten/omdb'
 import { TmdbClient } from '../metadaten/tmdb'
 import { LEERER_TREFFER, ausDetails, nachpruefen, zuordnen, type Zuordnung } from '../metadaten/zuordnung'
-import { ABGELOEST, titelInfoLesen } from '../rip/makemkv'
+import { ABGELOEST, titelInfoLesen, type Lebenszeichen } from '../rip/makemkv'
 import { spurenFuerTitel, sprachenFuerTitel, type TitelInfo } from '../rip/parser'
 import { strukturHinweis, titelVorauswahl } from '../rip/titelwahl'
 
@@ -316,19 +316,32 @@ export class ErkennungDienst {
     // 5.7.0 (Kandidat 2): Die Grenze kommt aus den Einstellungen (Vorgabe
     // 15 min statt fest fünf), und ab der zweiten Minute sagt der Dialog,
     // dass es länger dauert — mit Abbrechen-Knopf, statt stumm zu drehen.
+    // 5.7.1 (Der Patriot): Die Grenze gilt für STILLE — solange MakeMKV
+    // Fortschritt oder Meldungen schickt, wartet Rippy, und der Dialog zeigt,
+    // was MakeMKV gerade tut.
     const minuten = this.abh.titelLesenMinuten?.() ?? 15
-    const zwischenstand = setInterval(() => {
+    let lebens: Lebenszeichen = { prozent: -1, schritt: '', meldung: '', vobScan: false }
+    let letztesLebenszeichen = start
+    let letzteSendung = start
+    const zwischenstandSenden = (): void => {
       if (!nochAktuell()) return
-      const vergangen = Math.round((Date.now() - start) / 60_000)
-      senden({
-        ...leer,
-        laeuft: true,
-        einordnung: `MakeMKV liest seit ${vergangen} min. Kopiergeschützte DVDs und Discs mit vielen Playlisten brauchen länger — Rippy wartet bis ${minuten} min (Einstellungen → Allgemein), „Abbrechen" beendet den Lauf.`,
-      })
-    }, 60_000)
+      letzteSendung = Date.now()
+      senden({ ...leer, laeuft: true, einordnung: titelLaufZwischenstand(Date.now() - start, Date.now() - letztesLebenszeichen, minuten, lebens) })
+    }
+    const zwischenstand = setInterval(zwischenstandSenden, 60_000)
     zwischenstand.unref()
     try {
-      const info = await titelInfoLesen(programm, geraet.pfad, minuten * 60_000, abbruch.signal)
+      const info = await titelInfoLesen(programm, geraet.pfad, {
+        stillMs: minuten * 60_000,
+        abbruch: abbruch.signal,
+        aufLebenszeichen: (stand) => {
+          const neueMeldung = stand.meldung !== lebens.meldung || stand.schritt !== lebens.schritt
+          lebens = stand
+          letztesLebenszeichen = Date.now()
+          // Neue Meldung oder neuer Schritt sofort, Prozente höchstens alle 5 s.
+          if (Date.now() - start >= 30_000 && (neueMeldung || Date.now() - letzteSendung >= 5_000)) zwischenstandSenden()
+        },
+      })
       if (!nochAktuell()) return { ...leer, fehler: ABGELOEST }
       const merkmale = this.merkmale.get(id)
       const wahl = titelVorauswahl(info.titel, {
@@ -369,10 +382,14 @@ export class ErkennungDienst {
       if (String(fehler).includes(ABGELOEST) || !nochAktuell()) return { ...leer, fehler: ABGELOEST }
       // R4: sonst laut scheitern. „Konnte nicht nachsehen" ist etwas anderes
       // als „die Disc hat keine Titel" — beides zu vermischen erzeugt Unsinn.
-      const grund = String(fehler).includes('keine Antwort nach')
-        ? `MakeMKV hat die Titel nach ${minuten} Minuten nicht gelesen — Rippy hat den Versuch beendet und das Laufwerk freigegeben. Das kann an einer beschädigten Disc liegen, aber auch an Kopierschutz oder vielen Playlisten, die einfach länger brauchen: Die Grenze steht unter Einstellungen → Allgemein. Zur Probe die Disc im MakeMKV-Programm öffnen und die Zeit stoppen.`
-        : `Titel lesen: ${String(fehler).slice(0, 200)}`
-      this.kontext.protokoll.schreiben(`Titel-Lauf ${id} gescheitert: ${grund}`)
+      const grund = String(fehler).includes('kein Lebenszeichen seit')
+        ? `MakeMKV hat ${minuten} Minuten lang kein Lebenszeichen gegeben (kein Fortschritt, keine Meldung) — Rippy hat den Versuch nach ${Math.round((Date.now() - start) / 60_000)} min beendet und das Laufwerk freigegeben.${
+            lebens.meldung.length > 0 ? ` Letzte Meldung: „${lebens.meldung}".` : ''
+          } Das kann an einer beschädigten Disc oder am Laufwerk liegen. Die Geduld steht unter Einstellungen → Allgemein; zur Probe die Disc im MakeMKV-Programm öffnen.`
+        : String(fehler).includes('VOB-Scan nach')
+          ? `MakeMKV liest die beschädigte DVD-Struktur seit ${Math.round((Date.now() - start) / 60_000)} min und ist nicht fertig geworden — Rippy hat den Versuch beendet und das Laufwerk freigegeben. Zur Probe die Disc im MakeMKV-Programm öffnen.`
+          : `Titel lesen: ${String(fehler).slice(0, 200)}`
+      this.kontext.protokoll.schreiben(`Titel-Lauf ${id} gescheitert: ${grund} [${String(fehler).slice(0, 900)}]`)
       return senden({ ...leer, fehler: grund })
     } finally {
       clearInterval(zwischenstand)
@@ -448,3 +465,22 @@ export class ErkennungDienst {
     this.kontext.anFenster({ art: 'poster-vorschau', pfade })
   }
 }
+
+/** Was der Dialog während des Titel-Lesens zeigt (pur, 5.7.1): wie lange
+ *  MakeMKV schon liest, was es gerade tut, wann Rippy aufgeben würde. */
+export function titelLaufZwischenstand(vergangenMs: number, stillMs: number, geduldMinuten: number, lebens: Lebenszeichen): string {
+  const min = Math.max(1, Math.round(vergangenMs / 60_000))
+  const teile: string[] = [`MakeMKV liest seit ${min} min`]
+  if (lebens.schritt.length > 0 || lebens.prozent >= 0) {
+    teile.push(`${lebens.schritt.length > 0 ? lebens.schritt : 'Fortschritt'}${lebens.prozent >= 0 ? ` ${lebens.prozent} %` : ''}`)
+  }
+  if (lebens.meldung.length > 0) teile.push(`letzte Meldung: „${lebens.meldung.trim().slice(0, 160)}"`)
+  let text = teile.join(' · ') + '.'
+  if (lebens.vobScan) {
+    text += ` Die DVD-Struktur ist beschädigt — MakeMKV liest die ganze VOB-Datei durch; das dauert so lange wie das Lesen der Disc (oft 20–60 min), im MakeMKV-Programm genauso. Rippy wartet, solange makemkvcon läuft.`
+  } else {
+    const stillMin = Math.floor(stillMs / 60_000)
+    text += ` Solange MakeMKV Fortschritt meldet, wartet Rippy; ohne Lebenszeichen bricht es nach ${geduldMinuten} min ab (Einstellungen → Allgemein)${stillMin >= 1 ? ` — still seit ${stillMin} min` : ''}.`
+  }
+  return text + ' „Abbrechen" beendet den Lauf.'
+}

rippy-windows/src/kern/rip/makemkv.ts

@@ -15,6 +15,8 @@ import { werkzeugSpawn } from '../werkzeuge/aufruf'
 import { mkdirSync, readdirSync } from 'node:fs'
 import { join } from 'node:path'
 import {
+  aufgabeAusPrg,
+  istVobScanMeldung,
   KRITISCHE_CODES,
   KRITISCHE_TEXTE,
   LESEFEHLER_MARKE,
@@ -31,8 +33,11 @@ import {
   type TitelStreams,
 } from './parser'
 
+/** 5.7.1: auch der Info-Lauf meldet Fortschritt (--progress=-same) — daran
+ *  erkennt Rippy, dass MakeMKV noch arbeitet, statt nach fester Zeit
+ *  abzubrechen. */
 export function buildInfoArgs(geraetepfad: string): string[] {
-  return ['-r', '--noscan', 'info', quelle(geraetepfad)]
+  return ['-r', '--noscan', '--progress=-same', 'info', quelle(geraetepfad)]
 }
 
 export function buildRipArgs(geraetepfad: string, zielOrdner: string, titel: string): string[] {
@@ -151,26 +156,106 @@ export interface DiscInfo {
   sprachen: { audio: SprachEintrag[]; untertitel: SprachEintrag[] }
 }
 
+/** Was der Info-Lauf gerade tut — für den Dialog (5.7.1). */
+export interface Lebenszeichen {
+  /** Gesamtfortschritt 0–100, -1 ohne Angabe. */
+  prozent: number
+  /** Der aktuelle Schritt laut PRGC, '' wenn unbekannt. */
+  schritt: string
+  /** Die letzte Meldung (MSG-Klartext), '' wenn keine. */
+  meldung: string
+  /** MakeMKV hat den VOB-Scan einer beschädigten DVD angekündigt. */
+  vobScan: boolean
+}
+
+export interface TitelInfoOptionen {
+  /** So lange darf makemkvcon STILL sein (kein Byte Ausgabe), bevor Rippy
+   *  ihn beendet. Solange Fortschritt oder Meldungen kommen, wartet Rippy —
+   *  eine feste Gesamtgrenze warf den Patriot-Lauf weg, während das
+   *  MakeMKV-Programm dieselbe Disc fertig las (Commander, 12.09.2026). */
+  stillMs?: number
+  /** Hat MakeMKV den VOB-Scan angekündigt, gilt statt der Stille-Grenze
+   *  nur diese Obergrenze — der Scan liest die ganze Disc, und ob er dabei
+   *  Fortschritt meldet, ist nicht gemessen. */
+  vobScanHoechstensMs?: number
+  abbruch?: AbortSignal
+  aufLebenszeichen?: (stand: Lebenszeichen) => void
+}
+
+export const VOB_SCAN_HOECHSTENS_MS = 4 * 60 * 60_000
+
 /** EIN Info-Lauf liefert Titel UND Sprachen — er dauert je Disc 20–120 s,
- *  zweimal holen wäre eine Minute Wartezeit für nichts (ripping.py). */
-export function titelInfoLesen(
-  programm: string,
-  geraetepfad: string,
-  timeoutMs = 300_000,
-  abbruch?: AbortSignal,
-): Promise<DiscInfo> {
+ *  zweimal holen wäre eine Minute Wartezeit für nichts (ripping.py).
+ *  5.7.1: Die Grenze ist eine STILLE-Grenze — makemkvcon wird nur beendet,
+ *  wenn er so lange nichts mehr sagt; wer Fortschritt meldet, darf weiter. */
+export function titelInfoLesen(programm: string, geraetepfad: string, optionen: TitelInfoOptionen = {}): Promise<DiscInfo> {
+  const stillMs = optionen.stillMs ?? 300_000
+  const vobHoechstensMs = optionen.vobScanHoechstensMs ?? VOB_SCAN_HOECHSTENS_MS
+  const abbruch = optionen.abbruch
   return new Promise((fertig, scheitert) => {
     const kind = werkzeugSpawn(programm, buildInfoArgs(geraetepfad), {
       windowsHide: true,
       stdio: ['ignore', 'pipe', 'pipe'],
     })
     const stuecke: Buffer[] = []
-    kind.stdout.on('data', (stueck: Buffer) => stuecke.push(stueck))
-    kind.stderr.on('data', (stueck: Buffer) => stuecke.push(stueck))
-    const zeiger = setTimeout(() => {
+    const stand: Lebenszeichen = { prozent: -1, schritt: '', meldung: '', vobScan: false }
+    const start = Date.now()
+    let zeiger: NodeJS.Timeout
+    // Die letzten Zeilen reisen im Fehler mit — fürs Protokoll, damit ein
+    // fremder PC sagen kann, WO makemkvcon stehen blieb.
+    const letzteZeilen: string[] = []
+    const stumm = (): void => {
       kind.kill()
-      scheitert(new Error(`makemkvcon info: keine Antwort nach ${Math.round(timeoutMs / 1000)} s`))
-    }, timeoutMs)
+      const grund = stand.vobScan
+        ? `makemkvcon info: VOB-Scan nach ${Math.round(vobHoechstensMs / 60_000)} min nicht fertig`
+        : `makemkvcon info: kein Lebenszeichen seit ${Math.round(stillMs / 1000)} s`
+      scheitert(new Error(letzteZeilen.length > 0 ? `${grund} — letzte Zeilen: ${letzteZeilen.join(' | ')}` : grund))
+    }
+    const neuWarten = (): void => {
+      clearTimeout(zeiger)
+      // Beim VOB-Scan zählt nur die Obergrenze ab Start des Laufs.
+      const frist = stand.vobScan ? Math.max(0, vobHoechstensMs - (Date.now() - start)) : stillMs
+      zeiger = setTimeout(stumm, frist)
+    }
+    neuWarten()
+    const leserAus = new ZeilenLeser()
+    const leserFehler = new ZeilenLeser()
+    const aufStueck = (leser: ZeilenLeser, stueck: Buffer): void => {
+      stuecke.push(stueck)
+      let neu = false
+      for (const zeile of leser.hinzu(stueck)) {
+        if (zeile.trim().length > 0) {
+          letzteZeilen.push(zeile.trim().slice(0, 200))
+          if (letzteZeilen.length > 8) letzteZeilen.shift()
+        }
+        const p = progressAusPrgv(zeile)
+        if (p >= 0) {
+          if (p !== stand.prozent) {
+            stand.prozent = p
+            neu = true
+          }
+          continue
+        }
+        const aufgabe = aufgabeAusPrg(zeile)
+        if (aufgabe !== null) {
+          if (aufgabe.art === 'schritt' && aufgabe.name !== stand.schritt) {
+            stand.schritt = aufgabe.name
+            neu = true
+          }
+          continue
+        }
+        const meldung = parseMsg(zeile)
+        if (meldung !== null && meldung.text !== stand.meldung) {
+          stand.meldung = meldung.text
+          if (istVobScanMeldung(meldung.text)) stand.vobScan = true
+          neu = true
+        }
+      }
+      neuWarten()
+      if (neu) optionen.aufLebenszeichen?.({ ...stand })
+    }
+    kind.stdout.on('data', (stueck: Buffer) => aufStueck(leserAus, stueck))
+    kind.stderr.on('data', (stueck: Buffer) => aufStueck(leserFehler, stueck))
     // Ein abgelöster Lauf lässt das Laufwerk sofort los — zwei makemkvcon
     // auf derselben Disc machen beide langsamer (Commander-Fund 01.09.2026:
     // Ein alter Lauf meldete 300 s später seinen Timeout und legte ihn über

rippy-windows/src/kern/rip/parser.ts

@@ -68,6 +68,27 @@ export function progressAusPrgv(zeile: string): number {
   return Math.min(100, Math.floor((gesamt * 100) / maximum))
 }
 
+// ── PRGC/PRGT: Was MakeMKV gerade tut ───────────────────────────────────
+// PRGC:code,id,"name" ist der aktuelle Schritt („Analysieren von seamless
+// segments"), PRGT:code,id,"name" die Gesamtaufgabe („Öffnen der DVD-Disc").
+// Für die Lebenszeichen im Titel-Dialog (5.7.1, Der Patriot).
+const PRG_ZEILE = /^PRG([CT]):(\d+),(\d+),"((?:[^"\\]|\\.)*)"/
+
+export function aufgabeAusPrg(zeile: string): { art: 'schritt' | 'aufgabe'; name: string } | null {
+  const treffer = PRG_ZEILE.exec(zeile.trim())
+  if (treffer === null) return null
+  return { art: treffer[1] === 'C' ? 'schritt' : 'aufgabe', name: treffer[4].replaceAll('\\"', '"') }
+}
+
+/** MakeMKV kündigt den langen Weg an: „IFO file for VTS #1 is corrupt, VOB
+ *  file needs to be scanned. This may take a long time" — deutsch „IFO-Datei
+ *  für VTS #1 ist beschädigt, die VOB-Datei muss gescannt werden". Dann liest
+ *  MakeMKV die ganze VOB durch, so lange wie die Disc braucht (Der Patriot,
+ *  Commander 12.09.2026: 15 Minuten reichten nicht, das GUI schaffte es). */
+export function istVobScanMeldung(text: string): boolean {
+  return /\bIFO\b/i.test(text) && /\bVOB\b/i.test(text)
+}
+
 // ── TINFO: Titel-Liste ──────────────────────────────────────────────────
 // Attribut-IDs laut MakeMKV apdefs.h: 8 = ChapterCount, 9 = Duration
 // ("H:MM:SS"), 11 = DiskSizeBytes.