From c78ff22ab76f657be1ebd58007a9c8ed05187bed Mon Sep 17 00:00:00 2001
From: Hitonabi <Hitonabi@dreivontanke.ddnsfree.com>
Date: Sun, 30 Aug 2026 18:47:39 +0200
Subject: [PATCH] =?UTF-8?q?feat(v5):=20Etappe=20W-5=20=E2=80=94=20Oberflae?=
 =?UTF-8?q?che:=20Tray,=20Toasts,=20Taskleiste,=20Einstellungen,=20Bibliot?=
 =?UTF-8?q?hek?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

haupt/: tray.ts (Symbol mit Zustand, Kontextmenue, Fenster zu = weiter-
laufen, Beenden nur noch gewollt), Windows-Toasts bei Disc erkannt /
fertig / Fehler (Klick holt das Fenster), Taskleisten-Fortschritt
(setProgressBar, Fehlermodus), echter Windows-Ordnerdialog per IPC.
Eigenes Icon (bau/icon.png + tray.png, Disc-Optik).

Kern: Einstellungen lesen/schreiben NUR ueber die eine Quelle (§ 6.7,
Whitelist der Schluessel), Werkzeug-Auskunft (Katalog + gemessene
HandBrake-Presets/Backends), Bibliothek in db.ts (Schema v2 —
fingerprint, Titel, Groesse, Ort, Dauer), Duplikat-Erkennung beim
Einlegen (§ 6.6: 'schon einmal gerippt am …' als disc-info + Toast),
Pipeline traegt fertige Vorgaenge ein.

Fenster: drei Bereiche (Uebersicht / Einstellungen / Bibliothek).
Einstellungen: Ablage mit Durchsuchen-Dialog, Kompression je Disc-Typ
(Preset-Liste VOM eigenen HandBrake gemessen, 'NICHT komprimieren'
waehlbar), Sprachlisten, TMDb/OMDb-Keys, Medienserver, Werkzeug-Stand
mit Klartext (gefunden/fehlt + Folgen). Bibliothek als Tabelle.

Der Smoke-Screenshot zeigt nebenbei den Ernstfall in schoen: Das
Laufwerk ist nach dem rc11-Vorfall inzwischen auch am Storage-Stack in
'unknown' gekippt — und die Kachel zeigt den ZUGRIFFS_GRUENDE-Klartext
samt Abhilfe statt eines stummen Zustands.

165 Tests gruen, Smoke gruen.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 rippy-windows/bau/icon.png                  | Bin 0 -> 7358 bytes
 rippy-windows/bau/tray.png                  | Bin 0 -> 486 bytes
 rippy-windows/src/bruecke/index.ts          |   4 +
 rippy-windows/src/fenster/App.tsx           | 463 +++++++++++++++-----
 rippy-windows/src/fenster/global.d.ts       |   1 +
 rippy-windows/src/fenster/kernverbindung.ts |  33 ++
 rippy-windows/src/gemeinsam/nachrichten.ts  |  42 +-
 rippy-windows/src/haupt/index.ts            | 126 +++++-
 rippy-windows/src/haupt/tray.ts             |  52 +++
 rippy-windows/src/kern/ablauf/pipeline.ts   |  35 +-
 rippy-windows/src/kern/index.ts             |  92 +++-
 rippy-windows/src/kern/speicher/db.ts       |  58 ++-
 rippy-windows/test/db.test.ts               |   4 +-
 13 files changed, 782 insertions(+), 128 deletions(-)
 create mode 100644 rippy-windows/bau/icon.png
 create mode 100644 rippy-windows/bau/tray.png
 create mode 100644 rippy-windows/src/haupt/tray.ts

diff --git a/rippy-windows/bau/icon.png b/rippy-windows/bau/icon.png
new file mode 100644
index 0000000000000000000000000000000000000000..cb5d7f4dd20e8a3a991dd026b977ba297d712a4b
GIT binary patch
literal 7358
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
Giu@mdQAyqa

literal 0
HcmV?d00001

diff --git a/rippy-windows/bau/tray.png b/rippy-windows/bau/tray.png
new file mode 100644
index 0000000000000000000000000000000000000000..12e8754a62a59e0941a165b6366a6c19ebaf6de3
GIT binary patch
literal 486
zcmV<C0U7>@P)<h;3K|Lk000e1NJLTq001BW001Be1^@s6b9#F800001b5ch_0Itp)
z=>Px#1ZP1_K>z@;j|==^1poj532;bRa{vGi!vFvd!vV){sAK>D0eeYAK~z{r)t5a^
z!$1&)bAXs2p*RH%6&o6&NGM9l5jX-R$Drc^G&B_SG*mR{($Udy0=hKm=!iDTSd-7Y
z8}F_y!IM5IKQr$=+mY<_djDO6k-6q)o$06?|2BoYS)zFi^ommd<a|uS`Qqmw+)27j
zGzkSXonwYqdTILn=`{>7dtYyNu3o?6O6b#`5=`jPFE4JGxhEN%zI<he3)W}$wyNGU
zvl5qRlmq>ky_Fue*N`ST*x!OK!R$_tUZAhD0Dm-XLT_&YF1AUl1>}fgcjR?e0UaDu
zLeC9G=4=;k?py;QILG%s^jtAC_kZIIq!f@@;rMh?``(52ufkIcq|m59S0(7}EFgni
zZUg%670@N@An)V3OrAdcM=#O~Y?}-Hm|aN*<cWqxDFm-QRSeCoZ!raW6s37!W=+~a
z&V+qJqIrnR$7L<t!Yr?7C}uPyp*dz8l)gu}0(@|%(P<BfhB449OEeF`-A-ixa@kvI
c(qFHgHqiJ(Th?5XZvX%Q07*qoM6N<$f+LsEasU7T

literal 0
HcmV?d00001

diff --git a/rippy-windows/src/bruecke/index.ts b/rippy-windows/src/bruecke/index.ts
index 75f2818..ad963b0 100644
--- a/rippy-windows/src/bruecke/index.ts
+++ b/rippy-windows/src/bruecke/index.ts
@@ -48,4 +48,8 @@ contextBridge.exposeInMainWorld('rippy', {
   melden(art: string): void {
     ipcRenderer.send('fenster-meldung', String(art))
   },
+  /** Echter Windows-Ordnerdialog (§ 7). null = abgebrochen. */
+  ordnerWaehlen(titel: string): Promise<string | null> {
+    return ipcRenderer.invoke('ordner-waehlen', String(titel)) as Promise<string | null>
+  },
 })
diff --git a/rippy-windows/src/fenster/App.tsx b/rippy-windows/src/fenster/App.tsx
index 6bfce0c..14cee29 100644
--- a/rippy-windows/src/fenster/App.tsx
+++ b/rippy-windows/src/fenster/App.tsx
@@ -1,11 +1,12 @@
-// Statusbild W-0/W-1: die drei Prozesse plus die echten Laufwerke aus der
-// Disc-Wache. Die große Oberfläche (Dashboard, Bibliothek, Einstellungen)
-// ist Etappe W-5 — hier wird das Gerüst SICHTBAR bewiesen.
+// Die Oberfläche (W-5): Übersicht (Laufwerke + Gerüst-Status),
+// Einstellungen (EINE Quelle — alles läuft über den Kern, § 6.7) und die
+// Bibliothek (§ 6.6). Design-Sprache wie das heutige Rippy: dunkel, Kacheln.
 import { useEffect, useState } from 'react'
 import type { DiscInfoStand, GeraeteInfo, HauptStatus, RipStatus } from '../gemeinsam/nachrichten'
 import {
   aufVerbindung,
   auswerfen,
+  einstellungSetzen,
   ripAbbrechen,
   ripStarten,
   verbindungStarten,
@@ -32,6 +33,15 @@ const TYP_NAMEN: Record<GeraeteInfo['typ'], string> = {
   unknown: 'unbekannt',
 }
 
+const LAUFENDE_PHASEN = ['liest-info', 'rippt', 'komprimiert', 'legt-ab']
+
+function sicherheitsWort(confidence: number): string {
+  if (confidence >= 0.9) return 'sehr wahrscheinlich'
+  if (confidence >= 0.8) return 'wahrscheinlich'
+  if (confidence >= 0.6) return 'Vorschlag'
+  return 'unsicher'
+}
+
 interface KachelProps {
   titel: string
   zustand: 'ok' | 'fehler' | 'wartet'
@@ -58,15 +68,6 @@ function Kachel({ titel, zustand, zeilen }: KachelProps) {
   )
 }
 
-const LAUFENDE_PHASEN = ['liest-info', 'rippt', 'komprimiert', 'legt-ab']
-
-function sicherheitsWort(confidence: number): string {
-  if (confidence >= 0.9) return 'sehr wahrscheinlich'
-  if (confidence >= 0.8) return 'wahrscheinlich'
-  if (confidence >= 0.6) return 'Vorschlag'
-  return 'unsicher'
-}
-
 function LaufwerkKachel({
   geraet,
   rip,
@@ -105,7 +106,7 @@ function LaufwerkKachel({
               onClick={() => ripStarten(geraet.id)}
               disabled={geraet.status !== 'ready'}
               className="rounded-lg border border-emerald-500/60 px-3 py-1 text-xs text-emerald-300 hover:bg-emerald-500/10 disabled:cursor-not-allowed disabled:opacity-40"
-              title="Alle Titel, verlustfrei (MakeMKV)"
+              title="Alle Titel, verlustfrei (MakeMKV) — danach Kompression laut Einstellungen"
             >
               Rippen
             </button>
@@ -135,6 +136,11 @@ function LaufwerkKachel({
             {info.quelle.length > 0 ? ` · ${info.quelle}` : ''}
           </p>
         )}
+        {geraet.status === 'ready' && info !== undefined && info.schonGerippt !== null && (
+          <p className="text-amber-300">
+            ⚠ Diese Disc wurde schon einmal gerippt ({info.schonGerippt.slice(0, 10)}) — siehe Bibliothek.
+          </p>
+        )}
         {geraet.status === 'empty' && <p>keine Disc eingelegt</p>}
         {geraet.status === 'unknown' && <p className="text-red-300">{geraet.grund}</p>}
         {geraet.status !== 'unknown' && geraet.grund.length > 0 && (
@@ -176,8 +182,240 @@ function LaufwerkKachel({
   )
 }
 
+// ── Einstellungen ───────────────────────────────────────────────────────
+function Feld({
+  name,
+  wert,
+  hinweis,
+  geheim,
+  aufAendern,
+}: {
+  name: string
+  wert: string
+  hinweis?: string
+  geheim?: boolean
+  aufAendern: (wert: string) => void
+}) {
+  const [entwurf, setEntwurf] = useState(wert)
+  useEffect(() => setEntwurf(wert), [wert])
+  return (
+    <label className="block">
+      <span className="text-xs font-semibold text-slate-300">{name}</span>
+      {hinweis !== undefined && <span className="ml-2 text-xs text-slate-500">{hinweis}</span>}
+      <input
+        type={geheim === true ? 'password' : 'text'}
+        value={entwurf}
+        onChange={(e) => setEntwurf(e.target.value)}
+        onBlur={() => {
+          if (entwurf !== wert) aufAendern(entwurf)
+        }}
+        className="mt-1 w-full rounded-lg border border-slate-600 bg-slate-900 px-3 py-1.5 font-mono text-xs text-slate-200 focus:border-sky-400 focus:outline-none"
+      />
+    </label>
+  )
+}
+
+function PresetWahl({
+  name,
+  schluessel,
+  wert,
+  presets,
+  aufAendern,
+}: {
+  name: string
+  schluessel: string
+  wert: string
+  presets: string[]
+  aufAendern: (schluessel: string, wert: string) => void
+}) {
+  return (
+    <label className="block">
+      <span className="text-xs font-semibold text-slate-300">{name}</span>
+      <select
+        value={wert}
+        onChange={(e) => aufAendern(schluessel, e.target.value)}
+        className="mt-1 w-full rounded-lg border border-slate-600 bg-slate-900 px-3 py-1.5 font-mono text-xs text-slate-200 focus:border-sky-400 focus:outline-none"
+      >
+        <option value="">(allgemeines Preset)</option>
+        <option value="keine">NICHT komprimieren (verlustfrei lassen)</option>
+        {presets.map((preset) => (
+          <option key={preset} value={preset}>
+            {preset}
+          </option>
+        ))}
+      </select>
+    </label>
+  )
+}
+
+function Einstellungen({ verbindung }: { verbindung: Verbindung }) {
+  const werte = verbindung.einstellungen
+  const presets = verbindung.werkzeuge?.presets ?? []
+  const setzen = einstellungSetzen
+
+  const ordnerWaehlen = async (): Promise<void> => {
+    const ordner = await window.rippy.ordnerWaehlen('Ablage-Ordner wählen')
+    if (ordner !== null) setzen('ablage', ordner)
+  }
+
+  return (
+    <div className="max-w-2xl space-y-6">
+      <section className="space-y-3">
+        <h2 className="text-xs font-semibold uppercase tracking-widest text-slate-500">Ablage</h2>
+        <div className="flex items-end gap-2">
+          <div className="flex-1">
+            <Feld name="Ablage-Ordner" wert={werte['ablage'] ?? ''} aufAendern={(w) => setzen('ablage', w)} />
+          </div>
+          <button
+            onClick={() => void ordnerWaehlen()}
+            className="rounded-lg border border-slate-600 px-3 py-1.5 text-xs text-slate-300 hover:bg-slate-700"
+          >
+            Durchsuchen …
+          </button>
+        </div>
+      </section>
+
+      <section className="space-y-3">
+        <h2 className="text-xs font-semibold uppercase tracking-widest text-slate-500">
+          Kompression {verbindung.werkzeuge !== null && verbindung.werkzeuge.handbrake.length === 0 && (
+            <span className="text-red-400">— HandBrakeCLI nicht gefunden</span>
+          )}
+        </h2>
+        <label className="flex items-center gap-2 text-xs text-slate-300">
+          <input
+            type="checkbox"
+            checked={werte['transcodeEnabled'] !== 'false'}
+            onChange={(e) => setzen('transcodeEnabled', e.target.checked ? 'true' : 'false')}
+          />
+          Nach dem Rip komprimieren (der verlustfreie Rip bleibt bis zum Erfolg erhalten)
+        </label>
+        <div className="grid gap-3 sm:grid-cols-3">
+          <PresetWahl name="DVD" schluessel="transcodePresetDvd" wert={werte['transcodePresetDvd'] ?? ''} presets={presets} aufAendern={setzen} />
+          <PresetWahl name="Blu-ray" schluessel="transcodePresetBluray" wert={werte['transcodePresetBluray'] ?? ''} presets={presets} aufAendern={setzen} />
+          <PresetWahl name="4K-UHD" schluessel="transcodePresetUhd" wert={werte['transcodePresetUhd'] ?? ''} presets={presets} aufAendern={setzen} />
+        </div>
+        <Feld
+          name="Allgemeines Preset"
+          hinweis="gilt, wo oben nichts gewählt ist"
+          wert={werte['transcodePreset'] ?? ''}
+          aufAendern={(w) => setzen('transcodePreset', w)}
+        />
+        <div className="grid gap-3 sm:grid-cols-2">
+          <Feld
+            name="Tonspuren (Sprachen)"
+            hinweis="ISO-639-2, z. B. deu,eng — leer = alle"
+            wert={werte['audioSprachen'] ?? ''}
+            aufAendern={(w) => setzen('audioSprachen', w)}
+          />
+          <Feld
+            name="Untertitel (Sprachen)"
+            hinweis="leer = alle"
+            wert={werte['untertitelSprachen'] ?? ''}
+            aufAendern={(w) => setzen('untertitelSprachen', w)}
+          />
+        </div>
+      </section>
+
+      <section className="space-y-3">
+        <h2 className="text-xs font-semibold uppercase tracking-widest text-slate-500">Metadaten</h2>
+        <div className="grid gap-3 sm:grid-cols-2">
+          <Feld name="TMDb-API-Key" geheim wert={werte['tmdbApiKey'] ?? ''} aufAendern={(w) => setzen('tmdbApiKey', w)} />
+          <Feld name="OMDb-API-Key" geheim wert={werte['omdbApiKey'] ?? ''} aufAendern={(w) => setzen('omdbApiKey', w)} />
+        </div>
+      </section>
+
+      <section className="space-y-3">
+        <h2 className="text-xs font-semibold uppercase tracking-widest text-slate-500">Medienserver</h2>
+        <div className="grid gap-3 sm:grid-cols-3">
+          <label className="block">
+            <span className="text-xs font-semibold text-slate-300">System</span>
+            <select
+              value={werte['mediaServer'] ?? 'none'}
+              onChange={(e) => setzen('mediaServer', e.target.value)}
+              className="mt-1 w-full rounded-lg border border-slate-600 bg-slate-900 px-3 py-1.5 font-mono text-xs text-slate-200 focus:border-sky-400 focus:outline-none"
+            >
+              <option value="none">keiner</option>
+              <option value="jellyfin">Jellyfin</option>
+              <option value="emby">Emby</option>
+              <option value="kodi">Kodi</option>
+              <option value="plex">Plex (nur Benennung)</option>
+            </select>
+          </label>
+          <Feld name="Adresse" hinweis="http(s)://…" wert={werte['mediaServerUrl'] ?? ''} aufAendern={(w) => setzen('mediaServerUrl', w)} />
+          <Feld name="API-Key" geheim hinweis="Kodi: benutzer:passwort" wert={werte['mediaServerApiKey'] ?? ''} aufAendern={(w) => setzen('mediaServerApiKey', w)} />
+        </div>
+      </section>
+
+      <section className="space-y-3">
+        <h2 className="text-xs font-semibold uppercase tracking-widest text-slate-500">Werkzeuge</h2>
+        <div className="space-y-1 rounded-xl border border-slate-700/60 bg-slate-800/40 p-4 font-mono text-xs">
+          <p className={verbindung.werkzeuge === null ? 'text-slate-400' : verbindung.werkzeuge.makemkvcon.length > 0 ? 'text-emerald-300' : 'text-red-300'}>
+            makemkvcon: {verbindung.werkzeuge === null ? 'wird gesucht …' : verbindung.werkzeuge.makemkvcon || 'NICHT GEFUNDEN — MakeMKV installieren'}
+          </p>
+          <p className={verbindung.werkzeuge === null ? 'text-slate-400' : verbindung.werkzeuge.handbrake.length > 0 ? 'text-emerald-300' : 'text-amber-300'}>
+            HandBrakeCLI: {verbindung.werkzeuge === null ? 'wird gesucht …' : verbindung.werkzeuge.handbrake || 'nicht gefunden — Rippen geht, Kompression nicht'}
+          </p>
+          <p className={verbindung.werkzeuge === null ? 'text-slate-400' : verbindung.werkzeuge.flac.length > 0 ? 'text-emerald-300' : 'text-amber-300'}>
+            flac: {verbindung.werkzeuge === null ? 'wird gesucht …' : verbindung.werkzeuge.flac || 'nicht gefunden — nur für Audio-CDs nötig'}
+          </p>
+          {verbindung.werkzeuge !== null && verbindung.werkzeuge.backends.length > 0 && (
+            <p className="text-slate-400">Encoder: {verbindung.werkzeuge.backends.join(', ')}</p>
+          )}
+        </div>
+      </section>
+    </div>
+  )
+}
+
+// ── Bibliothek ──────────────────────────────────────────────────────────
+function Bibliothek({ verbindung }: { verbindung: Verbindung }) {
+  if (verbindung.bibliothek.length === 0) {
+    return (
+      <p className="font-mono text-xs text-slate-500">
+        Noch nichts gerippt — die Bibliothek füllt sich mit jedem fertigen Vorgang.
+      </p>
+    )
+  }
+  return (
+    <div className="overflow-x-auto rounded-xl border border-slate-700/60">
+      <table className="w-full text-left font-mono text-xs">
+        <thead className="bg-slate-800/60 text-slate-400">
+          <tr>
+            <th className="px-3 py-2">Titel</th>
+            <th className="px-3 py-2">Typ</th>
+            <th className="px-3 py-2">Größe</th>
+            <th className="px-3 py-2">Datum</th>
+            <th className="px-3 py-2">Dauer</th>
+            <th className="px-3 py-2">Ablageort</th>
+          </tr>
+        </thead>
+        <tbody className="text-slate-300">
+          {verbindung.bibliothek.map((eintrag) => (
+            <tr key={eintrag.fingerprint} className="border-t border-slate-700/40">
+              <td className="px-3 py-2">
+                {eintrag.titel}
+                {eintrag.jahr !== null ? ` (${eintrag.jahr})` : ''}
+              </td>
+              <td className="px-3 py-2">{eintrag.typ}</td>
+              <td className="px-3 py-2">{gb(eintrag.groesseBytes)}</td>
+              <td className="px-3 py-2">{eintrag.datum.slice(0, 16).replace('T', ' ')}</td>
+              <td className="px-3 py-2">{Math.round(eintrag.dauerS / 60)} min</td>
+              <td className="max-w-64 truncate px-3 py-2 text-slate-500" title={eintrag.ablageort}>
+                {eintrag.ablageort}
+              </td>
+            </tr>
+          ))}
+        </tbody>
+      </table>
+    </div>
+  )
+}
+
+type Bereich = 'uebersicht' | 'einstellungen' | 'bibliothek'
+
 export default function App() {
   const [haupt, setHaupt] = useState<HauptStatus | null>(null)
+  const [bereich, setBereich] = useState<Bereich>('uebersicht')
   const [verbindung, setVerbindung] = useState<Verbindung>({
     verbunden: false,
     kern: null,
@@ -185,6 +423,9 @@ export default function App() {
     laufwerke: [],
     rips: {},
     discInfos: {},
+    einstellungen: {},
+    werkzeuge: null,
+    bibliothek: [],
     meldungen: [],
   })
 
@@ -198,102 +439,124 @@ export default function App() {
 
   const db = verbindung.kern?.datenbank ?? null
 
+  const knopf = (ziel: Bereich, text: string): React.JSX.Element => (
+    <button
+      onClick={() => setBereich(ziel)}
+      className={`rounded-lg px-3 py-1 text-xs ${
+        bereich === ziel
+          ? 'bg-sky-500/20 text-sky-300'
+          : 'text-slate-400 hover:bg-slate-800 hover:text-slate-200'
+      }`}
+    >
+      {text}
+    </button>
+  )
+
   return (
     <div className="flex min-h-screen flex-col bg-slate-900 text-slate-100">
       <header className="border-b border-slate-700/60 px-6 py-4">
-        <div className="flex items-baseline gap-3">
-          <h1 className="text-2xl font-bold tracking-tight">Rippy</h1>
-          <span className="font-mono text-xs text-slate-400">
-            v{haupt?.version ?? '…'} · Etappe W-1 — Laufwerk
-          </span>
+        <div className="flex items-baseline justify-between gap-3">
+          <div className="flex items-baseline gap-3">
+            <h1 className="text-2xl font-bold tracking-tight">Rippy</h1>
+            <span className="font-mono text-xs text-slate-400">v{haupt?.version ?? '…'}</span>
+          </div>
+          <nav className="flex gap-1">
+            {knopf('uebersicht', 'Übersicht')}
+            {knopf('einstellungen', 'Einstellungen')}
+            {knopf('bibliothek', `Bibliothek${verbindung.bibliothek.length > 0 ? ` (${verbindung.bibliothek.length})` : ''}`)}
+          </nav>
         </div>
-        <p className="mt-1 text-sm text-slate-400">
-          Drei Prozesse, eine Datenbank, eine Leine — und die Disc-Wache läuft.
-        </p>
       </header>
 
       <main className="flex-1 space-y-6 p-6">
-        <section>
-          <h2 className="mb-3 text-xs font-semibold uppercase tracking-widest text-slate-500">
-            Laufwerke
-          </h2>
-          {verbindung.laufwerke.length === 0 ? (
-            <p className="font-mono text-xs text-slate-500">
-              {verbindung.verbunden ? 'Kein optisches Laufwerk gefunden.' : 'Warte auf den Kern …'}
-            </p>
-          ) : (
-            <div className="grid gap-4 sm:grid-cols-2">
-              {verbindung.laufwerke.map((geraet) => (
-                <LaufwerkKachel
-                  key={geraet.id}
-                  geraet={geraet}
-                  rip={verbindung.rips[geraet.id]}
-                  info={verbindung.discInfos[geraet.id]}
-                />
-              ))}
-            </div>
-          )}
-        </section>
-
-        <section>
-          <h2 className="mb-3 text-xs font-semibold uppercase tracking-widest text-slate-500">
-            Gerüst
-          </h2>
-          <div className="grid content-start gap-4 sm:grid-cols-2">
-            <Kachel
-              titel="Kern (utilityProcess)"
-              zustand={verbindung.kern !== null ? 'ok' : haupt?.kern.laeuft ? 'wartet' : 'fehler'}
-              zeilen={
-                verbindung.kern !== null
-                  ? [
-                      `PID ${verbindung.kern.pid} · Node ${verbindung.kern.nodeVersion}`,
-                      `Neustarts: ${haupt?.kern.neustarts ?? 0}`,
-                    ]
-                  : ['wartet auf Meldung …']
-              }
-            />
-            <Kachel
-              titel="Datenbank (node:sqlite)"
-              zustand={db === null ? 'wartet' : db.ok ? 'ok' : 'fehler'}
-              zeilen={db === null ? ['wartet auf Kern …'] : db.ok ? [db.pfad] : [db.fehler]}
-            />
-            <Kachel
-              titel="Prozess-Leine (Job Object)"
-              zustand={haupt === null ? 'wartet' : haupt.leine.ok ? 'ok' : 'fehler'}
-              zeilen={
-                haupt === null
-                  ? ['wartet auf Haupt …']
-                  : haupt.leine.ok
-                    ? ['gesetzt — Kern und Werkzeuge sterben mit Rippy']
-                    : [haupt.leine.fehler ?? 'nicht gesetzt']
-              }
-            />
-            <Kachel
-              titel="Fenster ↔ Kern (MessagePort)"
-              zustand={verbindung.pongLatenzMs !== null ? 'ok' : 'wartet'}
-              zeilen={
-                verbindung.pongLatenzMs !== null
-                  ? [`Ping → Pong in ${verbindung.pongLatenzMs} ms`]
-                  : ['Ping unterwegs …']
-              }
-            />
-          </div>
-        </section>
-
-        {verbindung.meldungen.length > 0 && (
-          <section>
-            <h2 className="mb-3 text-xs font-semibold uppercase tracking-widest text-slate-500">
-              Ereignisse
-            </h2>
-            <div className="space-y-1 rounded-xl border border-slate-700/60 bg-slate-800/40 p-4">
-              {verbindung.meldungen.map((zeile, i) => (
-                <p key={i} className="font-mono text-xs text-slate-400">
-                  {zeile}
+        {bereich === 'uebersicht' && (
+          <>
+            <section>
+              <h2 className="mb-3 text-xs font-semibold uppercase tracking-widest text-slate-500">
+                Laufwerke
+              </h2>
+              {verbindung.laufwerke.length === 0 ? (
+                <p className="font-mono text-xs text-slate-500">
+                  {verbindung.verbunden ? 'Kein optisches Laufwerk gefunden.' : 'Warte auf den Kern …'}
                 </p>
-              ))}
-            </div>
-          </section>
+              ) : (
+                <div className="grid gap-4 sm:grid-cols-2">
+                  {verbindung.laufwerke.map((geraet) => (
+                    <LaufwerkKachel
+                      key={geraet.id}
+                      geraet={geraet}
+                      rip={verbindung.rips[geraet.id]}
+                      info={verbindung.discInfos[geraet.id]}
+                    />
+                  ))}
+                </div>
+              )}
+            </section>
+
+            <section>
+              <h2 className="mb-3 text-xs font-semibold uppercase tracking-widest text-slate-500">
+                Status
+              </h2>
+              <div className="grid content-start gap-4 sm:grid-cols-2">
+                <Kachel
+                  titel="Kern (utilityProcess)"
+                  zustand={verbindung.kern !== null ? 'ok' : haupt?.kern.laeuft ? 'wartet' : 'fehler'}
+                  zeilen={
+                    verbindung.kern !== null
+                      ? [
+                          `PID ${verbindung.kern.pid} · Node ${verbindung.kern.nodeVersion}`,
+                          `Neustarts: ${haupt?.kern.neustarts ?? 0}`,
+                        ]
+                      : ['wartet auf Meldung …']
+                  }
+                />
+                <Kachel
+                  titel="Datenbank (node:sqlite)"
+                  zustand={db === null ? 'wartet' : db.ok ? 'ok' : 'fehler'}
+                  zeilen={db === null ? ['wartet auf Kern …'] : db.ok ? [db.pfad] : [db.fehler]}
+                />
+                <Kachel
+                  titel="Prozess-Leine (Job Object)"
+                  zustand={haupt === null ? 'wartet' : haupt.leine.ok ? 'ok' : 'fehler'}
+                  zeilen={
+                    haupt === null
+                      ? ['wartet auf Haupt …']
+                      : haupt.leine.ok
+                        ? ['gesetzt — Kern und Werkzeuge sterben mit Rippy']
+                        : [haupt.leine.fehler ?? 'nicht gesetzt']
+                  }
+                />
+                <Kachel
+                  titel="Fenster ↔ Kern (MessagePort)"
+                  zustand={verbindung.pongLatenzMs !== null ? 'ok' : 'wartet'}
+                  zeilen={
+                    verbindung.pongLatenzMs !== null
+                      ? [`Ping → Pong in ${verbindung.pongLatenzMs} ms`]
+                      : ['Ping unterwegs …']
+                  }
+                />
+              </div>
+            </section>
+
+            {verbindung.meldungen.length > 0 && (
+              <section>
+                <h2 className="mb-3 text-xs font-semibold uppercase tracking-widest text-slate-500">
+                  Ereignisse
+                </h2>
+                <div className="space-y-1 rounded-xl border border-slate-700/60 bg-slate-800/40 p-4">
+                  {verbindung.meldungen.map((zeile, i) => (
+                    <p key={i} className="break-all font-mono text-xs text-slate-400">
+                      {zeile}
+                    </p>
+                  ))}
+                </div>
+              </section>
+            )}
+          </>
         )}
+
+        {bereich === 'einstellungen' && <Einstellungen verbindung={verbindung} />}
+        {bereich === 'bibliothek' && <Bibliothek verbindung={verbindung} />}
       </main>
 
       <footer className="border-t border-slate-700/60 px-6 py-3 text-center text-xs text-slate-500">
diff --git a/rippy-windows/src/fenster/global.d.ts b/rippy-windows/src/fenster/global.d.ts
index eeaaa17..94f2bec 100644
--- a/rippy-windows/src/fenster/global.d.ts
+++ b/rippy-windows/src/fenster/global.d.ts
@@ -7,6 +7,7 @@ declare global {
       bereit(): void
       aufStatus(horcher: (status: unknown) => void): void
       melden(art: string): void
+      ordnerWaehlen(titel: string): Promise<string | null>
     }
   }
 }
diff --git a/rippy-windows/src/fenster/kernverbindung.ts b/rippy-windows/src/fenster/kernverbindung.ts
index 72de71a..aeaac0d 100644
--- a/rippy-windows/src/fenster/kernverbindung.ts
+++ b/rippy-windows/src/fenster/kernverbindung.ts
@@ -8,10 +8,12 @@
 // Laufwerksliste: Sie ändert sich NUR durch eine neue Liste vom Kern.
 import {
   istKernNachricht,
+  type BibliothekEintrag,
   type DiscInfoStand,
   type GeraeteInfo,
   type KernNachricht,
   type RipStatus,
+  type WerkzeugAuskunft,
 } from '../gemeinsam/nachrichten'
 
 export interface Verbindung {
@@ -24,6 +26,9 @@ export interface Verbindung {
   rips: Record<string, RipStatus>
   /** Was Rippy über die eingelegte Disc weiß (§ 5 Schritt 3). */
   discInfos: Record<string, DiscInfoStand>
+  einstellungen: Record<string, string>
+  werkzeuge: WerkzeugAuskunft | null
+  bibliothek: BibliothekEintrag[]
   /** Kurze Ereigniszeilen (neueste zuerst): Disc rein/raus, Auswurf, Fehler. */
   meldungen: string[]
 }
@@ -39,6 +44,9 @@ const stand: Verbindung = {
   laufwerke: [],
   rips: {},
   discInfos: {},
+  einstellungen: {},
+  werkzeuge: null,
+  bibliothek: [],
   meldungen: [],
 }
 const horcher = new Set<Horcher>()
@@ -52,6 +60,8 @@ function melden(): void {
       laufwerke: [...stand.laufwerke],
       rips: { ...stand.rips },
       discInfos: { ...stand.discInfos },
+      einstellungen: { ...stand.einstellungen },
+      bibliothek: [...stand.bibliothek],
       meldungen: [...stand.meldungen],
     })
   }
@@ -103,6 +113,15 @@ function kernNachricht(nachricht: KernNachricht): void {
       }
       break
     }
+    case 'einstellungen':
+      stand.einstellungen = nachricht.werte
+      break
+    case 'werkzeuge':
+      stand.werkzeuge = nachricht.auskunft
+      break
+    case 'bibliothek':
+      stand.bibliothek = nachricht.eintraege
+      break
     case 'rip-status': {
       stand.rips = { ...stand.rips, [nachricht.status.id]: nachricht.status }
       if (nachricht.status.phase === 'fertig') {
@@ -130,6 +149,9 @@ function portAnnehmen(neuerPort: MessagePort): void {
   }
   neuerPort.start()
   neuerPort.postMessage({ art: 'ping', zeit: Date.now() })
+  neuerPort.postMessage({ art: 'einstellungen-laden' })
+  neuerPort.postMessage({ art: 'werkzeuge-laden' })
+  neuerPort.postMessage({ art: 'bibliothek-laden' })
   melden()
 }
 
@@ -159,6 +181,8 @@ export function aufVerbindung(h: Horcher): () => void {
     laufwerke: [...stand.laufwerke],
     rips: { ...stand.rips },
     discInfos: { ...stand.discInfos },
+    einstellungen: { ...stand.einstellungen },
+    bibliothek: [...stand.bibliothek],
     meldungen: [...stand.meldungen],
   })
   return () => horcher.delete(h)
@@ -184,3 +208,12 @@ export function ripStarten(id: string): void {
 export function ripAbbrechen(id: string): void {
   anKern({ art: 'rip-abbruch', id }, `Rip-Abbruch ${id}`)
 }
+
+export function einstellungSetzen(schluessel: string, wert: string): void {
+  if (port === null) {
+    meldung(`⚠ Einstellung ${schluessel}: keine Verbindung zum Kern`)
+    melden()
+    return
+  }
+  port.postMessage({ art: 'einstellung-setzen', schluessel, wert })
+}
diff --git a/rippy-windows/src/gemeinsam/nachrichten.ts b/rippy-windows/src/gemeinsam/nachrichten.ts
index c44b7e5..98f20c6 100644
--- a/rippy-windows/src/gemeinsam/nachrichten.ts
+++ b/rippy-windows/src/gemeinsam/nachrichten.ts
@@ -68,6 +68,30 @@ export interface DiscInfoStand {
   confidence: number
   quelle: string
   posterPfad: string
+  /** Datum des früheren Rips dieser Disc — die Bibliothek erkennt sie am
+   *  Fingerabdruck wieder (§ 6.6); null wenn neu. */
+  schonGerippt: string | null
+}
+
+/** Ein Eintrag der Bibliothek (§ 6.6). */
+export interface BibliothekEintrag {
+  fingerprint: string
+  titel: string
+  jahr: number | null
+  typ: string
+  groesseBytes: number
+  ablageort: string
+  datum: string
+  dauerS: number
+}
+
+/** Auskunft über die Werkzeuge (Katalog + gemessene HandBrake-Listen). */
+export interface WerkzeugAuskunft {
+  makemkvcon: string
+  handbrake: string
+  flac: string
+  presets: string[]
+  backends: string[]
 }
 
 /** Nachrichten, die der Kern verschickt. */
@@ -79,6 +103,9 @@ export type KernNachricht =
   | { art: 'auswurf-ergebnis'; id: string; grund: AuswurfGrund; fehler: string | null }
   | { art: 'rip-status'; status: RipStatus }
   | { art: 'disc-info'; info: DiscInfoStand }
+  | { art: 'einstellungen'; werte: Record<string, string> }
+  | { art: 'werkzeuge'; auskunft: WerkzeugAuskunft }
+  | { art: 'bibliothek'; eintraege: BibliothekEintrag[] }
 
 /** Nachrichten, die das Fenster über den MessagePort an den Kern schickt. */
 export type FensterNachricht =
@@ -86,6 +113,10 @@ export type FensterNachricht =
   | { art: 'auswerfen'; id: string }
   | { art: 'rip-start'; id: string }
   | { art: 'rip-abbruch'; id: string }
+  | { art: 'einstellung-setzen'; schluessel: string; wert: string }
+  | { art: 'einstellungen-laden' }
+  | { art: 'werkzeuge-laden' }
+  | { art: 'bibliothek-laden' }
 
 /** Nachrichten, die das Haupt an den Kern schickt (Port-Übergabe). */
 export type HauptNachricht = { art: 'fenster-port' }
@@ -132,6 +163,12 @@ export function istKernNachricht(wert: unknown): wert is KernNachricht {
         typeof (wert.info as Record<string, unknown>).titel === 'string' &&
         typeof (wert.info as Record<string, unknown>).confidence === 'number'
       )
+    case 'einstellungen':
+      return istObjekt(wert.werte)
+    case 'werkzeuge':
+      return istObjekt(wert.auskunft) && Array.isArray((wert.auskunft as Record<string, unknown>).presets)
+    case 'bibliothek':
+      return Array.isArray(wert.eintraege)
     default:
       return false
   }
@@ -162,7 +199,10 @@ export function istFensterNachricht(wert: unknown): wert is FensterNachricht {
   if (wert.art === 'auswerfen' || wert.art === 'rip-start' || wert.art === 'rip-abbruch') {
     return typeof wert.id === 'string' && wert.id.length > 0
   }
-  return false
+  if (wert.art === 'einstellung-setzen') {
+    return typeof wert.schluessel === 'string' && wert.schluessel.length > 0 && typeof wert.wert === 'string'
+  }
+  return wert.art === 'einstellungen-laden' || wert.art === 'werkzeuge-laden' || wert.art === 'bibliothek-laden'
 }
 
 export function istHauptNachricht(wert: unknown): wert is HauptNachricht {
diff --git a/rippy-windows/src/haupt/index.ts b/rippy-windows/src/haupt/index.ts
index 414f983..283397f 100644
--- a/rippy-windows/src/haupt/index.ts
+++ b/rippy-windows/src/haupt/index.ts
@@ -1,18 +1,21 @@
 // Rippy v5 — Haupt-Prozess (KONZEPT-WINDOWS.md § 4.1).
 // Ablauf: Einzelinstanz-Sperre → Prozess-Leine → Kern starten → Fenster
-// öffnen → Fenster und Kern über einen MessagePort verdrahten.
+// öffnen → Fenster und Kern über einen MessagePort verdrahten. Seit W-5
+// mit Tray: Fenster zu heißt weiterlaufen (§ 4.1 Punkt 3), beendet wird
+// über das Tray-Menü; dazu Windows-Toasts und Taskleisten-Fortschritt (§ 7).
 //
 // Smoke-Modus (`electron . --smoke`): beweist das W-0-Fertigkriterium
 // („Ein Fenster geht auf, der Kern läuft") maschinell — alle drei Prozesse,
 // beide IPC-Wege und die Datenbank — und endet mit Code 0 (grün) oder 2.
 // RIPPY_SMOKE_BILD=<pfad.png> legt zusätzlich einen Screenshot ab.
-import { app, ipcMain, type BrowserWindow } from 'electron'
+import { app, dialog, ipcMain, Notification, type BrowserWindow } from 'electron'
 import { writeFile } from 'node:fs/promises'
 import { join } from 'node:path'
 import type { HauptStatus, KernNachricht } from '../gemeinsam/nachrichten'
 import { fensterErstellen } from './fenster'
 import { KernVerwaltung } from './kernstart'
 import { leineSetzen, type LeineStatus } from './leine'
+import { trayErstellen, trayHinweis } from './tray'
 
 const smokeModus = process.argv.includes('--smoke')
 
@@ -40,6 +43,7 @@ function start(): void {
 
   let fenster: BrowserWindow | null = null
   let kernBereit: Extract<KernNachricht, { art: 'kern-bereit' }> | null = null
+  let beendenGewollt = smokeModus
 
   const smoke = {
     fenster: false,
@@ -61,11 +65,60 @@ function start(): void {
         }
         statusSenden()
         smokePruefen()
+      } else if (nachricht.art === 'rip-status') {
+        ripStatusVerarbeiten(nachricht.status)
+      } else if (nachricht.art === 'disc-info' && nachricht.info.titel.length > 0 && !smokeModus) {
+        // Windows-Toast beim Erkennen (§ 7) — Klick holt das Fenster hoch.
+        toast(
+          'Disc erkannt',
+          `${nachricht.info.titel}${nachricht.info.jahr !== null ? ` (${nachricht.info.jahr})` : ''} · ${Math.round(nachricht.info.confidence * 100)} %` +
+            (nachricht.info.schonGerippt !== null
+              ? ` — schon einmal gerippt (${nachricht.info.schonGerippt.slice(0, 10)})`
+              : ''),
+        )
       }
     },
     () => statusSenden(),
   )
 
+  // § 7: Toasts, Taskleisten-Fortschritt und Tray-Zustand aus dem
+  // Rip-Status — die Information, die man will, ohne das Fenster zu öffnen.
+  function ripStatusVerarbeiten(status: Extract<KernNachricht, { art: 'rip-status' }>['status']): void {
+    if (fenster !== null && !fenster.isDestroyed()) {
+      if ((status.phase === 'rippt' || status.phase === 'komprimiert') && status.prozent >= 0) {
+        fenster.setProgressBar(status.prozent / 100)
+      } else if (status.phase === 'fehler') {
+        fenster.setProgressBar(1, { mode: 'error' })
+      } else {
+        fenster.setProgressBar(-1)
+      }
+    }
+    if (status.phase === 'rippt') {
+      trayHinweis(`rippt Laufwerk ${status.id}${status.prozent >= 0 ? ` (${status.prozent} %)` : ''}`)
+    } else if (status.phase === 'komprimiert') {
+      trayHinweis(`komprimiert Laufwerk ${status.id}${status.prozent >= 0 ? ` (${status.prozent} %)` : ''}`)
+    } else {
+      trayHinweis('')
+    }
+    if (smokeModus) return
+    if (status.phase === 'fertig') {
+      toast('Rippy ist fertig', status.text)
+    } else if (status.phase === 'fehler') {
+      toast('Rippy: Fehler', status.text)
+    }
+  }
+
+  function toast(titel: string, text: string): void {
+    try {
+      if (!Notification.isSupported()) return
+      const meldung = new Notification({ title: titel, body: text.slice(0, 200) })
+      meldung.on('click', () => fensterZeigen())
+      meldung.show()
+    } catch (fehler) {
+      console.error(`[haupt] Toast fehlgeschlagen: ${String(fehler)}`)
+    }
+  }
+
   function statusSenden(): void {
     if (fenster === null || fenster.isDestroyed()) return
     const status: HauptStatus = {
@@ -76,6 +129,39 @@ function start(): void {
     fenster.webContents.send('haupt-status', status)
   }
 
+  function fensterVerdrahten(): void {
+    if (fenster === null) return
+    fenster.webContents.on('did-finish-load', () => {
+      smoke.fenster = true
+      // Verdrahtung NACH dem Laden: Die Seite lauscht erst dann auf den Port.
+      kernVerwaltung.fensterVerbinden(fenster!.webContents)
+      statusSenden()
+      smokePruefen()
+    })
+    // § 4.1 Punkt 3: Fenster zu, Rip läuft weiter — Rippy lebt im Tray.
+    fenster.on('close', (ereignis) => {
+      if (beendenGewollt) return
+      ereignis.preventDefault()
+      fenster?.hide()
+    })
+  }
+
+  function fensterZeigen(): void {
+    if (fenster === null || fenster.isDestroyed()) {
+      fenster = fensterErstellen()
+      fensterVerdrahten()
+      return
+    }
+    if (fenster.isMinimized()) fenster.restore()
+    fenster.show()
+    fenster.focus()
+  }
+
+  function beenden(): void {
+    beendenGewollt = true
+    app.quit()
+  }
+
   // Kurze Rückmeldungen aus dem Fenster (Brücke: rippy.melden). Im
   // Smoke-Lauf ist 'kern-pong' der Beweis, dass der MessagePort
   // Fenster ↔ Kern in BEIDE Richtungen trägt.
@@ -86,33 +172,39 @@ function start(): void {
     }
   })
 
-  app.on('second-instance', () => {
-    if (fenster !== null && !fenster.isDestroyed()) {
-      if (fenster.isMinimized()) fenster.restore()
-      fenster.focus()
-    }
+  // Echter Windows-Ordnerdialog (§ 7) — der Nutzer sieht seine
+  // Netzlaufwerke und Schnellzugriffe statt eines nachgebauten Browsers.
+  ipcMain.handle('ordner-waehlen', async (_ereignis, titel: unknown) => {
+    if (fenster === null) return null
+    const ergebnis = await dialog.showOpenDialog(fenster, {
+      title: typeof titel === 'string' && titel.length > 0 ? titel : 'Ordner wählen',
+      properties: ['openDirectory', 'createDirectory'],
+    })
+    return ergebnis.canceled || ergebnis.filePaths.length === 0 ? null : ergebnis.filePaths[0]
   })
 
-  // W-0: Fenster zu = Rippy zu. Erst W-5 bringt das Tray-Symbol — dann lebt
-  // Rippy nach dem Schließen im Hintergrund weiter (§ 4.1, Punkt 3).
+  app.on('second-instance', () => {
+    fensterZeigen()
+  })
+
+  // Mit Tray beendet ein geschlossenes Fenster Rippy NICHT mehr — es läuft
+  // im Hintergrund weiter. Beendet wird über das Tray-Menü.
   app.on('window-all-closed', () => {
-    app.quit()
+    if (beendenGewollt) app.quit()
   })
 
   app.on('before-quit', () => {
+    beendenGewollt = true
     kernVerwaltung.beenden()
   })
 
   void app.whenReady().then(() => {
     kernVerwaltung.starten()
+    if (!smokeModus) {
+      trayErstellen(fensterZeigen, beenden)
+    }
     fenster = fensterErstellen()
-    fenster.webContents.on('did-finish-load', () => {
-      smoke.fenster = true
-      // Verdrahtung NACH dem Laden: Die Seite lauscht erst dann auf den Port.
-      kernVerwaltung.fensterVerbinden(fenster!.webContents)
-      statusSenden()
-      smokePruefen()
-    })
+    fensterVerdrahten()
   })
 
   let smokeAbgeschlossen = false
diff --git a/rippy-windows/src/haupt/tray.ts b/rippy-windows/src/haupt/tray.ts
new file mode 100644
index 0000000..fc1f4da
--- /dev/null
+++ b/rippy-windows/src/haupt/tray.ts
@@ -0,0 +1,52 @@
+// Tray-Symbol mit Zustand (KONZEPT § 7): auf einen Blick, ob ein Rip
+// läuft und wie weit. Mit dem Tray ändert sich das Schließen-Verhalten:
+// Fenster zu heißt „im Hintergrund weiterarbeiten" (§ 4.1 Punkt 3) —
+// beendet wird über das Kontextmenü oder den Menüpunkt.
+import { Menu, nativeImage, Tray } from 'electron'
+import { join } from 'node:path'
+
+let tray: Tray | null = null
+
+export function trayErstellen(oeffnen: () => void, beenden: () => void): Tray | null {
+  try {
+    // Das Bau-Icon liegt neben dem Bundle: out/haupt → ../../bau/tray.png
+    // im Quell-Lauf; im gepackten Programm über resourcesPath (W-6 legt es
+    // per extraResources dorthin).
+    const kandidaten = [
+      join(__dirname, '..', '..', 'bau', 'tray.png'),
+      join(process.resourcesPath ?? '', 'bau', 'tray.png'),
+    ]
+    let bild = nativeImage.createEmpty()
+    for (const kandidat of kandidaten) {
+      const versuch = nativeImage.createFromPath(kandidat)
+      if (!versuch.isEmpty()) {
+        bild = versuch
+        break
+      }
+    }
+    tray = new Tray(bild)
+    tray.setToolTip('Rippy — bereit')
+    tray.setContextMenu(
+      Menu.buildFromTemplate([
+        { label: 'Rippy öffnen', click: oeffnen },
+        { type: 'separator' },
+        { label: 'Beenden', click: beenden },
+      ]),
+    )
+    tray.on('click', oeffnen)
+    return tray
+  } catch (fehler) {
+    // R4: Ohne Tray läuft Rippy trotzdem — aber der Grund steht im Log.
+    console.error(`[haupt] Tray nicht erstellt: ${String(fehler)}`)
+    return null
+  }
+}
+
+export function trayHinweis(text: string): void {
+  tray?.setToolTip(text.length > 0 ? `Rippy — ${text}` : 'Rippy — bereit')
+}
+
+export function trayWeg(): void {
+  tray?.destroy()
+  tray = null
+}
diff --git a/rippy-windows/src/kern/ablauf/pipeline.ts b/rippy-windows/src/kern/ablauf/pipeline.ts
index 81ec940..5bfc18e 100644
--- a/rippy-windows/src/kern/ablauf/pipeline.ts
+++ b/rippy-windows/src/kern/ablauf/pipeline.ts
@@ -7,10 +7,10 @@
 // Roh-Ordner; die echten Titel ersetzen das dann. Roh-Dateien werden in
 // dieser Etappe GRUNDSÄTZLICH BEHALTEN — Löschen bekommt erst mit der
 // Einstellung im UI (W-5) eine Stimme.
-import { copyFileSync, mkdirSync, writeFileSync } from 'node:fs'
+import { copyFileSync, mkdirSync, statSync, writeFileSync } from 'node:fs'
 // Plattform-Pfade wie in struktur.ts: Laufzeit-Wurzeln, CI testet auf Linux.
 import { basename, join } from 'node:path'
-import type { GeraeteInfo, RipStatus } from '../../gemeinsam/nachrichten'
+import type { BibliothekEintrag, GeraeteInfo, RipStatus } from '../../gemeinsam/nachrichten'
 import { baueNfo } from '../ablage/nfo'
 import { bibliothekRefresh } from '../ablage/medienserver'
 import { posterSpeichern } from '../ablage/poster'
@@ -38,6 +38,10 @@ export interface PipelineUmgebung {
   melden: (status: RipStatus) => void
   /** Die letzte Metadaten-Zuordnung dieses Laufwerks (W-4) — oder null. */
   zuordnung?: (id: string) => Zuordnung | null
+  /** Disc-Fingerabdruck fürs Wiedererkennen (§ 6.6) — oder null. */
+  fingerprint?: (id: string) => string | null
+  /** Trägt einen fertigen Vorgang in die Bibliothek ein (§ 6.6). */
+  bibliothekEintragen?: (eintrag: BibliothekEintrag) => void
   /** Zeitstempel für Ordnernamen — injizierbar für Tests. */
   jetzt?: () => Date
 }
@@ -99,7 +103,8 @@ export class Pipeline {
     }
 
     const abbruch = new AbortController()
-    const zeit = (this.umgebung.jetzt?.() ?? new Date()).toISOString().replaceAll(/[:.]/g, '-').slice(0, 19)
+    const startZeit = this.umgebung.jetzt?.() ?? new Date()
+    const zeit = startZeit.toISOString().replaceAll(/[:.]/g, '-').slice(0, 19)
     const vorgangsName = `${geraet.typ}-${zeit}`
     const rohOrdner = join(this.umgebung.ablage(), 'roh', vorgangsName)
 
@@ -267,6 +272,30 @@ export class Pipeline {
     const serverKey = String(einstellungen['mediaServerApiKey'] ?? '')
     const refresh = await bibliothekRefresh(server, serverUrl, serverKey)
 
+    // § 6.6: Merken — beim nächsten Einlegen wird die Disc wiedererkannt.
+    const fingerprint = this.umgebung.fingerprint?.(id) ?? null
+    if (fingerprint !== null && this.umgebung.bibliothekEintragen !== undefined) {
+      let groesse = 0
+      for (const datei of fertigeDateien) {
+        try {
+          groesse += statSync(datei).size
+        } catch {
+          // Größe ist Anzeige-Komfort — eine unlesbare Datei ändert nichts
+          // am Eintrag selbst.
+        }
+      }
+      this.umgebung.bibliothekEintragen({
+        fingerprint,
+        titel: zuordnung !== null && zuordnung.titel.length > 0 ? zuordnung.titel : vorgangsName,
+        jahr: zuordnung?.jahr ?? null,
+        typ: geraet.typ,
+        groesseBytes: groesse,
+        ablageort: fertigOrdner,
+        datum: startZeit.toISOString(),
+        dauerS: Math.round(((this.umgebung.jetzt?.() ?? new Date()).getTime() - startZeit.getTime()) / 1000),
+      })
+    }
+
     this.laufend.delete(id)
     this.melden({
       id,
diff --git a/rippy-windows/src/kern/index.ts b/rippy-windows/src/kern/index.ts
index 1cb5cb8..965b1f0 100644
--- a/rippy-windows/src/kern/index.ts
+++ b/rippy-windows/src/kern/index.ts
@@ -18,7 +18,7 @@ import { Pipeline } from './ablauf/pipeline'
 import type { LaufwerkApi } from './laufwerk/codes'
 import { auswerfenMitGrund, geraeteInfo, kennung, listOptischeLaufwerke } from './laufwerk/disc'
 import { DiscWache } from './laufwerk/wache'
-import { discTitel } from './metadaten/discmerkmale'
+import { discFingerprint, discTitel } from './metadaten/discmerkmale'
 import { OmdbClient } from './metadaten/omdb'
 import { TmdbClient } from './metadaten/tmdb'
 import { zuordnen, type Zuordnung } from './metadaten/zuordnung'
@@ -84,10 +84,13 @@ let wache: DiscWache | null = null
 
 // ── Metadaten (W-4): Was liegt da drin? ─────────────────────────────────
 const discZuordnungen = new Map<string, Zuordnung>()
+const discFingerprints = new Map<string, string>()
 
-async function discErmitteln(id: string, geraetepfad: string): Promise<void> {
+async function discErmitteln(id: string, geraetepfad: string, groesseBytes: number): Promise<void> {
   try {
     const gefunden = discTitel(geraetepfad)
+    const fingerprint = discFingerprint(geraetepfad, groesseBytes)
+    discFingerprints.set(id, fingerprint)
     const tmdb = new TmdbClient(db?.einstellungLesen('tmdbApiKey') ?? '')
     const omdb = new OmdbClient(db?.einstellungLesen('omdbApiKey') ?? '')
     const zuordnung = await zuordnen(gefunden.titel, tmdb, omdb)
@@ -101,6 +104,9 @@ async function discErmitteln(id: string, geraetepfad: string): Promise<void> {
         confidence: zuordnung.confidence,
         quelle: zuordnung.meta.quelle,
         posterPfad: zuordnung.meta.posterPfad,
+        // § 6.6: Rippy erkennt beim Einlegen, wenn eine Disc schon einmal
+        // durchgelaufen ist — und fragt nach, statt stumm zu doppeln.
+        schonGerippt: db?.bibliothekSchonGerippt(fingerprint) ?? null,
       },
     })
   } catch (fehler) {
@@ -124,12 +130,21 @@ const laufwerkeBereit: Promise<void> = (async () => {
         anHauptUndFenster({ art: 'laufwerke', liste: meldung.laufwerke, ereignisse: meldung.ereignisse })
         for (const ereignis of meldung.ereignisse) {
           if (ereignis.art === 'disc-eingelegt') {
-            void discErmitteln(ereignis.geraet.id, ereignis.geraet.pfad)
+            void discErmitteln(ereignis.geraet.id, ereignis.geraet.pfad, ereignis.geraet.groesseBytes)
           } else if (ereignis.art === 'disc-entnommen') {
             discZuordnungen.delete(ereignis.geraet.id)
+            discFingerprints.delete(ereignis.geraet.id)
             anHauptUndFenster({
               art: 'disc-info',
-              info: { id: ereignis.geraet.id, titel: '', jahr: null, confidence: 0, quelle: '', posterPfad: '' },
+              info: {
+                id: ereignis.geraet.id,
+                titel: '',
+                jahr: null,
+                confidence: 0,
+                quelle: '',
+                posterPfad: '',
+                schonGerippt: null,
+              },
             })
           }
         }
@@ -193,8 +208,62 @@ const ripVerwaltung = new Pipeline({
   einstellungen: einstellungenLaden,
   melden: (status) => anHauptUndFenster({ art: 'rip-status', status }),
   zuordnung: (id) => discZuordnungen.get(id) ?? null,
+  fingerprint: (id) => discFingerprints.get(id) ?? null,
+  bibliothekEintragen: (eintrag) => {
+    try {
+      db?.bibliothekEintragen(eintrag)
+      anFenster({ art: 'bibliothek', eintraege: db?.bibliothekListe() ?? [] })
+    } catch (fehler) {
+      // R4: Ein Bibliotheks-Fehler kippt keinen gelungenen Rip, wird aber
+      // gesagt.
+      anFenster({ art: 'kern-fehler', text: `Bibliothek: ${String(fehler)}` })
+    }
+  },
 })
 
+// ── Einstellungen (§ 6.7): das Fenster liest und schreibt NUR über den
+//    Kern; erlaubt sind genau diese Schlüssel ───────────────────────────
+const ERLAUBTE_EINSTELLUNGEN = new Set([
+  'ablage',
+  'transcodeEnabled',
+  'transcodePreset',
+  'transcodePresetDvd',
+  'transcodePresetBluray',
+  'transcodePresetUhd',
+  'audioSprachen',
+  'untertitelSprachen',
+  'mediaServer',
+  'mediaServerUrl',
+  'mediaServerApiKey',
+  'tmdbApiKey',
+  'omdbApiKey',
+  'autoAuswurf',
+  'werkzeug.makemkv',
+  'werkzeug.handbrake',
+  'werkzeug.flac',
+])
+
+function einstellungenSenden(): void {
+  const werte: Record<string, string> = { ablage: ablageOrdner() }
+  for (const schluessel of ERLAUBTE_EINSTELLUNGEN) {
+    const wert = db?.einstellungLesen(schluessel)
+    if (wert !== null && wert !== undefined) werte[schluessel] = wert
+  }
+  anFenster({ art: 'einstellungen', werte })
+}
+
+async function werkzeugeSenden(): Promise<void> {
+  const makemkvcon = finden('makemkv', db?.einstellungLesen('werkzeug.makemkv') ?? '')
+  const handbrake = finden('handbrake', db?.einstellungLesen('werkzeug.handbrake') ?? '')
+  const flac = finden('flac', db?.einstellungLesen('werkzeug.flac') ?? '')
+  const { encoderMessen } = await import('./komprimieren/encoder')
+  const gemessen = await encoderMessen(handbrake)
+  anFenster({
+    art: 'werkzeuge',
+    auskunft: { makemkvcon, handbrake, flac, presets: gemessen.presets, backends: gemessen.backends },
+  })
+}
+
 async function auswerfen(id: string): Promise<void> {
   await laufwerkeBereit
   if (ripVerwaltung.laeuft(id)) {
@@ -242,6 +311,21 @@ process.parentPort.on('message', (ereignis) => {
         void laufwerkeBereit.then(() => ripVerwaltung.starten(frage.id))
       } else if (frage.art === 'rip-abbruch') {
         ripVerwaltung.abbrechen(frage.id)
+      } else if (frage.art === 'einstellung-setzen') {
+        if (!ERLAUBTE_EINSTELLUNGEN.has(frage.schluessel)) {
+          anFenster({ art: 'kern-fehler', text: `Unbekannter Einstellungs-Schlüssel: ${frage.schluessel}` })
+        } else if (db === null) {
+          anFenster({ art: 'kern-fehler', text: 'Einstellung nicht gespeichert — die Datenbank ist nicht da.' })
+        } else {
+          db.einstellungSchreiben(frage.schluessel, frage.wert)
+          einstellungenSenden()
+        }
+      } else if (frage.art === 'einstellungen-laden') {
+        einstellungenSenden()
+      } else if (frage.art === 'werkzeuge-laden') {
+        void werkzeugeSenden()
+      } else if (frage.art === 'bibliothek-laden') {
+        anFenster({ art: 'bibliothek', eintraege: db?.bibliothekListe() ?? [] })
       }
     })
     fensterPort.start()
diff --git a/rippy-windows/src/kern/speicher/db.ts b/rippy-windows/src/kern/speicher/db.ts
index 4e150d1..f665646 100644
--- a/rippy-windows/src/kern/speicher/db.ts
+++ b/rippy-windows/src/kern/speicher/db.ts
@@ -10,8 +10,9 @@
 import { DatabaseSync } from 'node:sqlite'
 import { mkdirSync } from 'node:fs'
 import { dirname } from 'node:path'
+import type { BibliothekEintrag } from '../../gemeinsam/nachrichten'
 
-const SCHEMA_VERSION = 1
+export const SCHEMA_VERSION = 2
 
 export class Datenbank {
   readonly pfad: string
@@ -36,6 +37,16 @@ export class Datenbank {
        CREATE TABLE IF NOT EXISTS einstellungen (
          schluessel TEXT PRIMARY KEY,
          wert       TEXT NOT NULL
+       );
+       CREATE TABLE IF NOT EXISTS bibliothek (
+         fingerprint  TEXT PRIMARY KEY,
+         titel        TEXT NOT NULL,
+         jahr         INTEGER,
+         typ          TEXT NOT NULL,
+         groesse_bytes INTEGER NOT NULL,
+         ablageort    TEXT NOT NULL,
+         datum        TEXT NOT NULL,
+         dauer_s      INTEGER NOT NULL
        );`,
     )
     this.db
@@ -64,6 +75,51 @@ export class Datenbank {
     return zeile === undefined ? 0 : Number(zeile.wert)
   }
 
+  // ── Bibliothek (§ 6.6): alles Gerippte, wiedererkennbar am
+  //    Disc-Fingerabdruck ────────────────────────────────────────────────
+  bibliothekEintragen(eintrag: BibliothekEintrag): void {
+    this.db
+      .prepare(
+        `INSERT OR REPLACE INTO bibliothek
+         (fingerprint, titel, jahr, typ, groesse_bytes, ablageort, datum, dauer_s)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+      )
+      .run(
+        eintrag.fingerprint,
+        eintrag.titel,
+        eintrag.jahr,
+        eintrag.typ,
+        eintrag.groesseBytes,
+        eintrag.ablageort,
+        eintrag.datum,
+        eintrag.dauerS,
+      )
+  }
+
+  bibliothekListe(): BibliothekEintrag[] {
+    const zeilen = this.db
+      .prepare(`SELECT * FROM bibliothek ORDER BY datum DESC`)
+      .all() as Array<Record<string, unknown>>
+    return zeilen.map((z) => ({
+      fingerprint: String(z.fingerprint),
+      titel: String(z.titel),
+      jahr: z.jahr === null ? null : Number(z.jahr),
+      typ: String(z.typ),
+      groesseBytes: Number(z.groesse_bytes),
+      ablageort: String(z.ablageort),
+      datum: String(z.datum),
+      dauerS: Number(z.dauer_s),
+    }))
+  }
+
+  /** Datum des früheren Rips dieser Disc — oder null (neu). */
+  bibliothekSchonGerippt(fingerprint: string): string | null {
+    const zeile = this.db
+      .prepare(`SELECT datum FROM bibliothek WHERE fingerprint = ?`)
+      .get(fingerprint) as { datum: string } | undefined
+    return zeile === undefined ? null : zeile.datum
+  }
+
   schliessen(): void {
     this.db.close()
   }
diff --git a/rippy-windows/test/db.test.ts b/rippy-windows/test/db.test.ts
index ca847a9..f97e0e2 100644
--- a/rippy-windows/test/db.test.ts
+++ b/rippy-windows/test/db.test.ts
@@ -4,7 +4,7 @@ import { mkdtempSync, rmSync, existsSync } from 'node:fs'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
 import { afterEach, describe, expect, it } from 'vitest'
-import { Datenbank } from '../src/kern/speicher/db'
+import { Datenbank, SCHEMA_VERSION } from '../src/kern/speicher/db'
 
 let aufraeumen: Array<() => void> = []
 
@@ -26,7 +26,7 @@ describe('Datenbank', () => {
     const db = new Datenbank(pfad)
     aufraeumen.push(() => db.schliessen())
     expect(existsSync(pfad)).toBe(true)
-    expect(db.schemaVersion()).toBe(1)
+    expect(db.schemaVersion()).toBe(SCHEMA_VERSION)
   })
 
   it('schreibt und liest eine Einstellung', () => {