Release 0.7.0

Release 0.6.1
Release 0.6.0
2026-10-25 18:40:01 +01:00 · 2026-10-25 18:18:23 +01:00 · 2026-10-25 09:45:31 +01:00
64 changed files with 6503 additions and 912 deletions
@@ -3,7 +3,7 @@
 	"title": "Sendewerk",
 	"description": "Redaktionelle Planung und Durchführung von heinzlive-Sendungen.",
 	"tagline": "Vom Fundstück bis zur Livesendung",
-	"version": "0.5.12",
+	"version": "0.7.0",
 	"healthCheckPath": "/healthz",
 	"httpPort": 3000,
 	"addons": {
@@ -1,5 +1,61 @@
 # Abnahme

+## Etappe 7
+
+| Kriterium                                    | Nachweis                                                                                                                   | Stand                 |
+| -------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------- | --------------------- |
+| Feedverwaltung und geplanter/manueller Abruf | Barkeeper-Oberfläche, Prozess-Scheduler und gemeinsame Abruffunktion                                                       | erfüllt am 25.10.2026 |
+| Getrennter Vorschau-Eingang                  | RSS-Beiträge erscheinen separat und werden nur nach Mehrfachauswahl zu Pieces                                              | erfüllt am 25.10.2026 |
+| Kategoriezuordnung und Herkunft              | Auswahlkategorien oder Feed-Standard sowie Original-URL als Piece-Quelle im Verhaltenstest                                 | erfüllt am 25.10.2026 |
+| Dubletten und dauerhaftes Verwerfen          | wiederholter Testabruf erzeugt keinen zweiten Eintrag und stellt Verworfenes nicht wieder her                              | erfüllt am 25.10.2026 |
+| HTML-Bereinigung und Abrufgrenzen            | Testfeed entfernt fremdes HTML; Loopback wird vor Request blockiert; Größe, Zeit, Redirects und Eintragszahl sind begrenzt | erfüllt am 25.10.2026 |
+| Fehlerisolation                              | defekter lokaler Testfeed wird protokolliert, weiterer fälliger Feed trotzdem importiert                                   | erfüllt am 25.10.2026 |
+| Versionierte REST-API und OpenAPI            | `/api/v1` für Pieces, Sendungen und Einplanungen; `/api/v1/openapi.json`                                                   | erfüllt am 25.10.2026 |
+| Begrenzte und widerrufbare Zugänge           | gehashte Tokens; Verhaltenstest für Lesen, verweigertes Schreiben und sofortigen Widerruf                                  | erfüllt am 25.10.2026 |
+| Änderungsnachweis und Idempotenz             | Audit-Ereignisse und persistente Idempotenz; identische Wiederholung liefert dasselbe Ergebnis                             | erfüllt am 25.10.2026 |
+| API-Rundlauf                                 | echter HTTP-Test: lesen, anlegen, ändern, erneut lesen, einplanen und sortieren                                            | erfüllt am 25.10.2026 |
+| Nutzung ohne KI                              | RSS und API sind optional; bestehende Redaktion funktioniert unverändert ohne externen Client                              | erfüllt am 25.10.2026 |
+| Konkrete ChatGPT-/Codex-Anbindung            | keine Clientumgebung oder Zugangsdaten vorhanden                                                                           | offen                 |
+
+- `npm run check`: 0 Fehler und 0 Warnungen.
+- `npm test`: 58 von 58 Verhaltenstests erfolgreich.
+- Gezielte Etappe-7-Tests: 6 von 6 erfolgreich.
+- `npm run build`: erfolgreich mit `@sveltejs/adapter-node`.
+- `npm audit --omit=dev`: 0 gemeldete Schwachstellen.
+- Gezielte Chromium-Prüfung: Desktop-Verwaltung, mobiler Eingang und kompletter
+  HTTP-API-Rundlauf erfolgreich, keine Konsolenfehler.
+- `npm run test:e2e`: auf dem Standardport wegen eines bereits laufenden fremden
+  Prozesses nicht startbar; identische temporäre Konfiguration auf Port 4188 mit
+  16 von 18 erfolgreichen Abläufen. Bekannte Fehler bleiben bei Live-Zeitanzeige
+  und Abschluss/Freigabe bestehen.
+- `npm run lint`: nicht erfolgreich wegen acht bereits vorhandener
+  Prettier-Abweichungen außerhalb der Etappe-7-Dateien; geänderte Dateien wurden
+  separat formatiert.
+- Dokumentationsstatus: **API/MCP getestet, Client-Anbindung offen**. Konkret ist
+  die REST-API getestet; ein zusätzlicher MCP-Adapter wurde nicht benötigt und
+  keine echte ChatGPT-/Codex-Verbindung hergestellt.
+
+## Wartungsrelease 0.6.1
+
+| Bereich                                              | Stand                                                                                       |
+| ---------------------------------------------------- | ------------------------------------------------------------------------------------------- |
+| Live-Timer, Kopfzeile, Drawer und Positionsanzeige   | behoben                                                                                     |
+| Mobile Formulare und Iconsuche                       | behoben                                                                                     |
+| Vorbereitungsaufwand und Übersicht                   | behoben                                                                                     |
+| Bild-Präsentationsmodus                              | behoben                                                                                     |
+| Twitch-Tags je Abschnitt                             | behoben                                                                                     |
+| Sendungskarten und Gastabstände                      | behoben                                                                                     |
+| Gemeinsamer Freigabedialog einschließlich Live-Regie | behoben                                                                                     |
+| Editorzustand und Drag-and-drop                      | bestehende zustandserhaltende bzw. alternative Bedienwege unverändert; Browserprüfung offen |
+
+- `npm run check`: 0 Fehler und 0 Warnungen.
+- `npm test`: 52 von 52 Verhaltenstests erfolgreich.
+- `npm run build`: erfolgreich.
+- `npm run test:e2e`: zweiter Lauf mit 14 erfolgreichen Abläufen; Live-Regie und
+  Abschluss/Freigaben schlugen fehl, zwei nachfolgende Abläufe wurden wegen des
+  120-Sekunden-Zeitlimits nicht mehr ausgeführt. Die Browsermatrix ist offen.
+- Safari auf echtem iOS-Gerät: nicht verfügbar.
+
 ## Etappe 1

 | Kriterium                                         | Nachweis                                                                                                                | Stand                        |
@@ -506,3 +562,37 @@ vollständige erneute Matrix.
 - Zusätzliche visuelle Chromium-Prüfung bei 656 × 400 und 390 × 700 Pixeln:
  Sendungskarte unter 130 Pixel hoch, Menü-/Ausgabe-/Timericons sichtbar und
  Pausebutton wechselt bedienbar zu Fortsetzen.
+
+## Etappe 6
+
+| Kriterium                                                | Nachweis                                                                                                       | Stand                 |
+| -------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------- | --------------------- |
+| Spätere Originaländerung verändert Historie nicht        | Verhaltenstest ändert Piece und Abschnittskategorie nach Abschluss; historische Snapshots bleiben gleich       | erfüllt am 25.10.2026 |
+| Abschluss nicht doppelt; übersprungen ist nicht gesendet | idempotente Befehlswiederholung, fremde Befehls-ID und materialisierte Usage-Historie im Verhaltenstest        | erfüllt am 25.10.2026 |
+| Bewusste Auswahl archiviert nur gewählte Originale       | Abschlusskandidaten und explizite Archivauswahl im Service; Dialog trennt gesendet, übersprungen und offen     | erfüllt am 25.10.2026 |
+| Archivierte Sendung stabil und duplizierbar              | Service- und Browsertest prüfen Nur-Lese-Ansicht sowie neuen Entwurf ohne Live-, Historien- oder Freigabedaten | erfüllt am 25.10.2026 |
+| Gast sieht genau eine Sendung und nur erlaubte Felder    | anonymer Chromium-Kontext und Scope-Verhaltenstests für Ablauf, Moderation und Recherche                       | erfüllt am 25.10.2026 |
+| Gast-Schreibzugriff und fremde IDs abgelehnt             | anonymer direkter POST erhält 403; fremde Medien-ID erhält 404                                                 | erfüllt am 25.10.2026 |
+| Passwort, Ablauf und Widerruf schützen direkte Aufrufe   | Service- und Browsertests prüfen Seite, Gast-Sitzung und direkten Medienrequest vor und nach Widerruf          | erfüllt am 25.10.2026 |
+| Barkeeper verwaltet Freigaben                            | Anlage, Bearbeitung und Löschung direkt in der Sendung sowie gruppiert in der Verwaltung im Browser geprüft    | erfüllt am 25.10.2026 |
+| Offene Sendungen sind sicher freigebbar                  | Service und anonymer Browser prüfen aktuellen Plan vor Abschluss und stabilen Stand danach                     | erfüllt am 25.10.2026 |
+| Bestehende Abschlüsse werden einmalig übernommen         | Upgrade-Test wendet `0015` auf einen Stand bis `0014` zweimal an und findet genau eine Historie                | erfüllt am 25.10.2026 |
+| Bestehende Freigaben bleiben bei Erweiterung erhalten    | Migration `0016` ersetzt nur die Fremdschlüsselgrenze und kopiert Freigaben sowie Gast-Sitzungen               | erfüllt am 25.10.2026 |
+
+## Ausgeführte Prüfungen Etappe 6
+
+- `npm run check`: 0 Fehler und 0 Warnungen
+- `npm test`: 52 Tests in 11 Dateien erfolgreich
+- gezielter Chromium-Ablauf für Abschluss, Archiv, historische Ansicht,
+  offene und abgeschlossene Freigabe, Bearbeitung und Löschung in beiden
+  Barkeeper-Oberflächen, Passwort, privaten Scope, Reserve-Medienschutz, fremde
+  ID und Gast-POST: 1 von 1 erfolgreich
+- `npm run test:e2e`: nach Korrektur eines bestehenden, auf den 24. Oktober
+  festgelegten „Heute“-Fixtures 18 von 18 Chromium-Browsertests erfolgreich
+- Browserprüfung von Sendungsfreigabe und Gastansicht bei 390 × 844 Pixeln sowie
+  der Verwaltung bei 1280 × 900 Pixeln ohne horizontalen Überlauf; Screenshots
+  visuell kontrolliert
+- `npm run build`: erfolgreich mit `@sveltejs/adapter-node`
+- `npm run lint`: Prettier und ESLint erfolgreich
+- Versionsgleichheit `0.6.0` in Paket, Lockdatei und Cloudron-Manifest geprüft
+- `bash -n start.sh` und `git diff --check`: erfolgreich
@@ -3,7 +3,7 @@
 ## Systemgrenze

 Sendewerk ist ein einzelner SvelteKit-Prozess. Browserseiten, serverseitige
-Actions, spätere REST-Endpunkte und Hintergrundaufgaben verwenden dieselbe
+Actions, REST-Endpunkte und Hintergrundaufgaben verwenden dieselbe
 Geschäftslogik. SQLite und ein lokales Upload-Verzeichnis sind die einzigen
 persistenten Laufzeitabhängigkeiten. Externe Mail-, RSS- oder KI-Dienste sind
 nicht Voraussetzung für Kernfunktionen.
@@ -11,7 +11,7 @@ nicht Voraussetzung für Kernfunktionen.
 ```text
 Browser -> SvelteKit-Routen -> Anwendungsdienste -> SQLite
                                |                -> Upload-Verzeichnis
-                                +-> später: Mail/RSS über Adapter
+                                +-> Mail/RSS über begrenzte Adapter
 ```

 Servercode lebt unter `src/lib/server` und darf nicht in Browser-Bundles
@@ -33,22 +33,22 @@ spätere API dieselben Regeln verwenden.

 ## Gesamtdatenmodell

-Die ersten fünf Etappen materialisieren Identität, Inhaltsverwaltung,
-Sendungsplanung und Live-Durchführung. Folgende Grenzen gelten für umgesetzte
-und spätere Bereiche.
+Die ersten sieben Etappen materialisieren Identität, Inhaltsverwaltung,
+Sendungsplanung, Live-Durchführung, Historie, Lesefreigaben, RSS-Import und eine
+technische API. Folgende Grenzen gelten für umgesetzte und spätere Bereiche.

-| Bereich     | Geplante Entitäten und Beziehungen                                                                                                  |
-| ----------- | ----------------------------------------------------------------------------------------------------------------------------------- |
-| Identität   | `users`, Rollen, Sessions, Einladungen, Reset-Tokens und Sperren sind umgesetzt; technische Zugänge folgen später                   |
-| Taxonomie   | getrennte `section_categories`, `formats`, `topics` samt optionalem Themenicon; Pieces und Vorschläge mehrfach verknüpft            |
-| Inhalt      | `pieces` mit Status, Soft Delete, Favorit, Revision, Texten, Quellen, Werkzeugen und privaten Medien; Vorlagen speichern Snapshots  |
-| Sendungsbau | `shows`, geordnete `show_sections`, `piece_usages` samt Quellen-/Werkzeug-/Themen-/Mediensnapshots, Reservebank und Vorlagen        |
+| Bereich     | Geplante Entitäten und Beziehungen                                                                                                          |
+| ----------- | ------------------------------------------------------------------------------------------------------------------------------------------- |
+| Identität   | `users`, Rollen, Sessions, Einladungen, Reset-Tokens und Sperren sowie getrennte technische Zugänge                                         |
+| Taxonomie   | getrennte `section_categories`, `formats`, `topics` samt optionalem Themenicon; Pieces und Vorschläge mehrfach verknüpft                    |
+| Inhalt      | `pieces` mit Status, Soft Delete, Favorit, Revision, Texten, Quellen, Werkzeugen und privaten Medien; Vorlagen speichern Snapshots          |
+| Sendungsbau | `shows`, geordnete `show_sections`, `piece_usages` samt Quellen-/Werkzeug-/Themen-/Mediensnapshots, Reservebank und Vorlagen                |
 | Live        | expliziter Live-Stand, aktuelles Element, tatsächliche Piece-Zeiten, persistente Abschnitts-/Gesamttimer und getrennte Präsentationsausgabe |
-| Historie    | unveränderliche Abschluss-Snapshots und Verwendungshistorie; Übersprungenes zählt nicht als gesendet                                |
-| Freigaben   | widerrufbare, gehashte Lesetokens mit Sendung, Umfang, Passwortoption und Ablaufzeit                                                |
-| RSS         | Feedquellen, Abrufläufe und externe Einträge mit stabiler Herkunfts-ID sowie Status neu/übernommen/verworfen                        |
-| API/Audit   | technische Berechtigungen, Idempotenzschlüssel und Audit-Ereignisse mit Akteur, Aktion und Ziel                                     |
-| Betrieb     | Anwendungseinstellungen und spätere Job-Zustände, keine Geheimnisse im Klartext ohne begründete Schutzstrategie                     |
+| Historie    | unveränderliche Abschluss-Snapshots und Verwendungshistorie; Übersprungenes zählt nicht als gesendet                                        |
+| Freigaben   | widerrufbare, gehashte Lesetokens mit Sendung, Umfang, Passwortoption und Ablaufzeit                                                        |
+| RSS         | Feedquellen, Abrufläufe und externe Einträge mit stabiler Herkunfts-ID sowie Status neu/übernommen/verworfen                                |
+| API/Audit   | technische Berechtigungen, Idempotenzschlüssel und Audit-Ereignisse mit Akteur, Aktion und Ziel                                             |
+| Betrieb     | Anwendungseinstellungen und spätere Job-Zustände, keine Geheimnisse im Klartext ohne begründete Schutzstrategie                             |

 ### Historien- und Kopierregel

@@ -99,6 +99,43 @@ konfigurierten Outbox-Pfad, `smtp` nutzt Nodemailer nur nach expliziter Auswahl.
 Die feste Anwendungs-Origin erzeugt Links und bestimmt den `Secure`-Status der
 Cookies; sie wird nicht aus ungeprüften Request-Headern übernommen.

+Technische Zugänge sind keine Browsersitzungen. Sie besitzen zufällige
+Bearer-Tokens, von denen nur SHA-256-Hashes gespeichert werden, und genau einen
+der Umfänge `read` oder `read_write`. Widerruf wirkt beim nächsten Request.
+`/api/v1` umgeht lediglich den Browser-Loginredirect; jeder Endpunkt prüft Token
+und erforderlichen Umfang selbst. Schreibzugriffe hinterlassen ein
+`audit_event`; Neuanlage und Planungsänderungen verlangen zusätzlich einen je
+Zugang eindeutigen, persistent gespeicherten Idempotenzschlüssel.
+
+## RSS-Import
+
+`src/lib/server/feeds.ts` bildet Abruf, XML-Verarbeitung und Übernahme gemeinsam
+für manuelle Aktionen und den Prozess-Scheduler ab. Der Scheduler startet beim
+ersten Request und prüft minütlich höchstens zehn fällige aktive Feeds. Jeder
+Feed wird getrennt behandelt, sodass ein Fehler weitere Abrufe nicht stoppt.
+HTTP-Abrufe erlauben nur HTTP(S) auf Standardports, prüfen DNS sowie jedes
+Redirectziel gegen interne Adressen und begrenzen Laufzeit, Redirects und
+Antwortgröße. RSS/Atom wird mit deaktivierter Entity-Verarbeitung gelesen;
+höchstens 200 Einträge je Antwort werden berücksichtigt und fremdes HTML wird zu
+reinem Text reduziert.
+
+`feed_entries` ist ein eigener Eingang. `(feed_id, external_id)` verhindert
+Dubletten; Aktualisierungen ändern den redaktionellen Status nicht. `discarded`
+bleibt deshalb auch nach späteren Abrufen erhalten. Erst die bewusste
+Mehrfachauswahl erzeugt innerhalb einer Transaktion normale Inbox-Pieces mit
+Kategorien und Original-URL als Quelle und setzt den Eintrag auf `imported`.
+
+## Technische REST-API
+
+Die Routen unter `/api/v1` bilden keine zweite Fachlogik, sondern rufen
+`content.ts` und `shows.ts` auf. Piece- und Sendungsrevisionen schützen weiterhin
+vor verlorenen Änderungen. `api_idempotency` speichert Request-Hash, Status und
+JSON-Antwort, sodass wiederholte Schreibbefehle dasselbe Ergebnis liefern und
+ein gleicher Schlüssel mit verändertem Inhalt abgewiesen wird. Die OpenAPI-3.1-
+Beschreibung ist unter `/api/v1/openapi.json` erreichbar. Ein MCP-Adapter oder
+produktspezifischer KI-Client gehört nicht zur Laufzeit und ist nicht
+Voraussetzung für die Bedienung.
+
 ## Inhalte, Markdown und Medien

 Etappe 3 führt die Inhaltslogik in `src/lib/server/content.ts` zusammen. Listen
@@ -238,13 +275,12 @@ Zurückgehen, Wiederaufnahme und bereits abgeschlossene Laufzeit getrennt von de
 geplanten Dauer nachvollziehbar.

 `live_show_timer_runs` hält die unabhängige Gesamtzeit. Pause und Fortsetzen
-behandeln Gesamt-, Abschnitts- und Piece-Intervalle gemeinsam. Beenden setzt den
-Sendungsstatus auf `completed`, schließt laufende Intervalle, markiert offene
-Pieces aber nicht als erledigt. Eine ausdrückliche Wiederaufnahme bewahrt Zeiten
-und Fortschritt; nur „Neuer Durchlauf“ verwirft Laufintervalle und setzt die
-Piece-Status zurück. Die Restzeitschätzung verwendet je Abschnitt entweder die
-positive Abschnittsdauer oder die verbleibenden Piece-Dauern und zählt beide nie
-zusammen.
+behandeln Gesamt-, Abschnitts- und Piece-Intervalle gemeinsam. Beenden schließt
+laufende Intervalle und setzt `ended_at_utc`, finalisiert die Sendung aber noch
+nicht. Eine ausdrückliche Wiederaufnahme bewahrt Zeiten und Fortschritt; nur
+„Neuer Durchlauf“ verwirft Laufintervalle und setzt die Piece-Status zurück. Die
+Restzeitschätzung verwendet je Abschnitt entweder die positive Abschnittsdauer
+oder die verbleibenden Piece-Dauern und zählt beide nie zusammen.

 Die interne Route `/live` benötigt weiterhin eine aktive Sitzung und darf
 Recherche, Moderation und eigene Arbeitsdaten lesen. Die separate Ausgabe nutzt
@@ -295,6 +331,52 @@ sichtbar; die Oberfläche kennzeichnet den Abbruch und versucht die Verbindung
 mit verlangsamtem Intervall erneut. Private Live-Daten werden nicht Teil dieses
 Zustandsobjekts.

+## Abschluss, Historie und Lesefreigaben
+
+`src/lib/server/completion.ts` ist die Transaktionsgrenze des endgültigen
+Sendungsabschlusses. Er verlangt einen beendeten Live-Lauf sowie passende Show-
+und Live-Revisionen. Eine Befehls-ID in `show_finalizations` macht Wiederholungen
+idempotent. In derselben Transaktion werden offene Intervalle geschlossen,
+Abschnittskategorien eingefroren, ausschließlich erledigte Verwendungen außerhalb
+der Reservebank in `piece_usage_history` materialisiert, bewusst gewählte
+Fundus-Originale archiviert und die Sendung auf `completed` gesetzt. Jede normale
+Planungs- und Live-Mutation sperrt diesen Zustand.
+
+Die eigentlichen Sendungstexte, Quellen, Werkzeuge, Themen und Medien liegen
+weiterhin in den beim Einplanen erzeugten Usage-Snapshots. Finalisierung friert
+die zuvor noch katalogabhängige Abschnittskategorie ein. Abgeschlossene
+Sendungen werden ausschließlich gelesen oder vollständig in einen neuen Entwurf
+dupliziert. Das Duplikat erhält neue Show-, Abschnitts-, Usage- und Relations-IDs,
+offene Usage-Status und weder Live-, Historien- noch Freigabedaten.
+
+`src/lib/server/shares.ts` erzeugt für Barkeeper zufällige 256-Bit-Lesetokens;
+SQLite speichert nur SHA-256-Hashes. Eine Freigabe verweist direkt auf eine
+Sendung und darf deshalb bereits im Entwurf, im bereiten oder im laufenden
+Zustand entstehen. Der Umfang ist eine Positivliste aus `rundown`, `moderation`
+oder `research`. Optionale Passwörter liegen als Argon2id-Hash vor. Nach
+erfolgreicher Prüfung entsteht eine höchstens zwölf Stunden gültige, ebenfalls
+nur gehashte Gast-Sitzung; Fehlversuche werden pro Link und Clientadresse
+begrenzt. Änderungen an Umfang, Passwort oder Ablauf invalidieren bestehende
+Gast-Sitzungen. Ablauf und Löschung werden bei jedem HTML-, Seitendaten- und
+Medienrequest erneut geprüft.
+
+Die öffentliche Route `/freigabe/[token]` erhält keine interne Sendungs-ID und
+keinen ungefilterten `Show`-Datensatz. Sie projiziert genau die am Token gebundene
+Sendung und nur die Felder ihres Umfangs. Vor dem Abschluss werden aktuelle
+Sendungs- und Usage-Snapshots bei jedem Aufruf neu gelesen; danach liefert
+dieselbe Projektion die durch die Finalisierung stabilisierten Snapshots. Die
+separate Medienroute akzeptiert ausschließlich das ausdrücklich gewählte
+Präsentationsmedium einer eingeplanten Nicht-Reserve-Verwendung derselben
+Sendung. Private `/media`-Dateien bleiben weiterhin an eine Redaktionssitzung
+gebunden.
+
+Die wiederverwendbare Barkeeper-Komponente `ShareManagement.svelte` liegt direkt
+in der Sendungsbearbeitung und in der Verwaltung. Beide Routen verwenden
+dieselben Servicefunktionen für Anlage, Bearbeitung und Löschung; die
+Sendungsroute bindet Mutationen zusätzlich an ihre eigene Sendungs-ID. Die
+Verwaltung gruppiert bestehende Freigaben nach Sendung und zeigt deren aktuellen
+Status und Termin.
+
 ## Oberflächenstruktur

 Die Hauptnavigation umfasst Eingang, Fundus, Sendungen, Archiv und Verwaltung.
@@ -359,3 +441,12 @@ betroffenen Route und Action geprüft. Markdown und fremdes HTML werden vor
 Ausgabe bereinigt. Uploadzugriff folgt denselben Rechten. Netzwerkabrufe für
 Präsentationsmetadaten und Vorschaubilder schützen interne Ziele auch nach
 DNS-Auflösung und Redirects und besitzen Größen-, Zeit- und Redirectlimits.
+
+## Wartungsfelder 0.6.1
+
+Migration `0017` ergänzt den optionalen Vorbereitungsaufwand am Original und
+kommagetrennt validierte Twitch-Tags am Abschnitt. Der Bildmodus wird wegen der
+bestehenden SQLite-Check-Constraints als zusätzliches Kennzeichen an Original
+und Usage-Snapshot gespeichert; nach außen bleibt er der eindeutige Modus
+`image`. Öffentlich passiert weiterhin nur das ausdrücklich gewählte
+Präsentationsmedium.
@@ -419,9 +419,76 @@ verbleibenden Piece-Dauern. Bereits abgeschlossene Abschnitte werden ausgelassen
 ungeplante Abschnitte werden sichtbar gezählt und eine Überziehung reduziert
 nicht die geplante Zeit kommender Inhalte.

-`completed` beendet einen Durchlauf, nicht automatisch dessen offene Pieces.
+`ended_at_utc` beendet einen Durchlauf, nicht automatisch dessen offene Pieces.
 Wiederaufnahme und neuer Durchlauf sind deshalb getrennte Befehle: Erstere
 bewahrt Intervalle und Fortschritt, letzterer setzt beides ausdrücklich zurück.
 Das private Markdownfeld „Interaktion“ folgt derselben Original-/Snapshotgrenze
 wie Moderation und Überleitung, ist aber nicht Teil der öffentlichen
 Präsentations-Positivliste.
+
+## D-027: Abschlusszustand und Freigaben als eigene Sicherheitsgrenzen
+
+Ein beendeter Live-Lauf ist wiederaufnehmbar und deshalb nicht identisch mit
+einer historischen Sendung. Erst eine eigene transaktionale Finalisierung setzt
+`shows.status` auf `completed`. Eine dauerhaft gespeicherte Befehls-ID verhindert
+Doppelverbuchung; Usage-Historie enthält nur `done`, nie `skipped` oder Reserve.
+Bestehende Usage-Snapshots bleiben Inhaltsquelle, während Abschnittskategorien
+beim Abschluss zusätzlich eingefroren werden. Historische Sendungen werden nicht
+erneut bearbeitet, sondern mit neuen IDs und zurückgesetztem Laufzustand kopiert.
+
+Lesefreigaben sind keine abgeschwächten Redaktionssitzungen. Sie verwenden eine
+eigene Positivprojektion mit drei kumulativen Umfängen. Roh-Tokens und
+Gast-Sitzungstokens stehen nie in SQLite, optionale Passwörter verwenden Argon2id.
+Passwort, Ablauf und Widerruf werden zentral vor Seite, Seitendaten und Medium
+geprüft. Präsentationsmedien sind an Freigabe, Sendung und Usage-Snapshot
+gebunden; beliebige Fundus-Dateien bleiben ausgeschlossen.
+
+Freigaben verweisen auf `shows` statt ausschließlich auf Finalisierungen. Damit
+kann ein Barkeeper bereits einen Entwurf oder eine laufende Planung teilen. Die
+Gastprojektion liest bei jedem Aufruf die aktuellen Sendungssnapshots; der
+spätere Abschluss stabilisiert genau diese bestehende Datenquelle, ohne Token
+oder URL zu wechseln. Bearbeitungen behalten den Link, invalidieren aber
+vorhandene Passwortsitzungen. Vollständiges Löschen ist der unmittelbare
+Widerruf. Die Sendungsbearbeitung und die zentrale Verwaltung verwenden dieselbe
+Geschäftslogik und bleiben Barkeepern vorbehalten.
+
+## D-028: Additive Wartungsfelder und gemeinsamer Freigabedialog
+
+Vorbereitungsaufwand und Twitch-Tags sind optionale additive Felder. Der neue
+Bildmodus verwendet ein separates boolesches Kennzeichen, damit bestehende
+Tabellen und Daten trotz älterer Modus-Check-Constraints ohne riskanten
+Tabellenumbau erhalten bleiben. Freigabeverwaltung bleibt eine gemeinsame
+Komponente und öffnet in allen drei internen Einstiegen als nativer Dialog.
+
+## D-029: RSS als persistenter Eingang mit begrenztem Abruf
+
+Externe Feeds schreiben nie direkt in den Fundus. Quelle und stabiler
+Eintragsschlüssel werden in einem eigenen Eingang gespeichert; dessen Zustand
+`discarded` oder `imported` wird bei einem erneuten Abruf nicht zurückgesetzt.
+Erst eine bewusste Auswahl erzeugt über `content.ts` ein normales Piece samt
+Originalquelle und gewählten Kategorien. Dadurch bleiben redaktionelle
+Entscheidung, Dublettenschutz und Herkunft nachvollziehbar.
+
+Manueller und geplanter Abruf verwenden denselben Adapter. Wie bei
+Linkmetadaten werden private Ziele, Nichtstandardports und ungeprüfte Redirects
+gesperrt; zusätzlich gelten enge Zeit-, Größen- und Mengenlimits. XML-Entities
+bleiben deaktiviert und fremdes HTML wird nicht gespeichert. Ein Fehler wird am
+betroffenen Feed persistiert und unterbricht keine weiteren fälligen Feeds.
+
+## D-030: Technische Tokens, Scopes und persistente Idempotenz
+
+Externe Assistenz erhält keine simulierte Redaktionssitzung und keine
+Sonderrechte. Eigene zufällige Bearer-Tokens liegen nur gehasht vor, sind sofort
+widerrufbar und erlauben entweder Lesen oder Lesen und Schreiben. REST-Routen
+unter `/api/v1` verwenden die bestehenden Inhalts- und Sendungsdienste, damit
+Validierung, Revisionen und Transaktionen identisch bleiben. Jede erfolgreiche
+Mutation wird mit technischem Akteur, Aktion und Ziel protokolliert.
+
+Neuanlage, Einplanung und Sortierung verlangen einen `Idempotency-Key`.
+Zugang, Schlüssel, Hash des Requestinhalts und vollständige Antwort werden in
+derselben SQLite-Transaktion gespeichert. Eine identische Wiederholung erhält
+dieselbe Antwort; ein veränderter Request mit demselben Schlüssel wird
+abgewiesen. OpenAPI 3.1 beschreibt diese Grenze maschinenlesbar. Ein MCP-Adapter
+oder ein bestimmter KI-Client wird nicht vorgetäuscht: Die Anwendung bleibt ohne
+KI vollständig nutzbar und eine konkrete Client-Verbindung muss separat geprüft
+werden.
@@ -1,5 +1,90 @@
 # Release Notes

+## 0.7.0 - RSS-Import und externe Assistenz
+
+Veröffentlicht am 25. Oktober 2026
+
+- Barkeeper verwalten RSS-/Atom-Feeds mit Intervall und Standardkategorie;
+  sichere manuelle und geplante Abrufe laufen fehlerisoliert.
+- Neue Beiträge landen in einem getrennten Auswahlbereich im Eingang. Erst eine
+  bewusste Übernahme erzeugt Pieces, während dauerhaftes Verwerfen, Herkunft,
+  Kategorien und Dublettenschutz erhalten bleiben.
+- Abrufe sperren interne Ziele und begrenzen Ports, Redirects, Laufzeit,
+  Antwortgröße und Eintragszahl. Fremdes Feed-HTML wird zu Text bereinigt.
+- Die versionierte REST-API `/api/v1` liest und ändert Pieces, Sendungen und
+  Einplanungen über getrennte technische Lese- oder Schreibzugänge.
+- Technische Tokens werden nur einmal gezeigt und gehasht gespeichert. Widerruf,
+  Audit-Ereignisse, Revisionen und persistente Idempotenz schützen Änderungen.
+- `/api/v1/openapi.json` beschreibt die Schnittstelle für externe Clients.
+  Sendewerk bleibt ohne KI nutzbar; eine konkrete ChatGPT-/Codex-Anbindung ist
+  weiterhin offen.
+- Migration `0018_rss_and_api.sql` ergänzt Feed-, Zugangs-, Audit- und
+  Idempotenzdaten. Paket, Lockdatei und Cloudron-Manifest tragen Version `0.7.0`.
+
+## 0.6.1 - Redaktionelle Wartung
+
+Veröffentlicht am 25. Oktober 2026
+
+- Live-Countdowns übernehmen geänderte Abschnittsplanzeiten, ohne Laufzeit zu verlieren; die mobile Regie gruppiert ihre Kopfaktionen robuster und zeigt den Ablauf als oberstes Sheet.
+- Mobile Formularfelder und die Iconsuche vermeiden iOS-Fokuszoom; Sendungskarten und Gastansicht erhalten klarere Abstände.
+- Pieces führen optionalen Vorbereitungsaufwand, die Sendungsübersicht bündelt offene Vorbereitung und Abschnitte speichern kopierbare Twitch-Tags.
+- Präsentationen können ein ausdrücklich gewähltes Bild ohne Begleittext ausgeben; Originale und Sendungsfassungen bleiben getrennte Snapshots.
+- Lesefreigaben öffnen in Sendung, Verwaltung und Live-Regie über denselben Dialog.
+- Migration `0017_maintenance_fields.sql` ergänzt ausschließlich optionale, rückwärtskompatible Felder.
+
+## 0.6.0 - Abschluss, Archiv und Freigaben
+
+Veröffentlicht am 25. Oktober 2026
+
+Sendewerk 0.6.0 trennt das wiederaufnehmbare Ende eines Live-Laufs vom
+unveränderlichen redaktionellen Abschluss. Abgeschlossene Sendungen erhalten
+eine stabile Historie, liegen im Archiv und können als neuer Entwurf dupliziert
+werden. Barkeeper geben genau eine geplante, laufende oder historische Sendung
+über widerrufbare, optional passwortgeschützte Leselinks frei.
+
+### Abschluss und Historie
+
+- Ein Abschlussdialog zeigt gesendete, übersprungene und offene Pieces getrennt
+  und bietet ausschließlich gesendete Originale zur bewussten Archivierung an.
+- Finalisierung ist transaktional und idempotent. Übersprungene Pieces und die
+  Reservebank werden nicht als gesendet verbucht.
+- Usage-Texte, Relationen, Kategorien und tatsächliche Zeiten bleiben nach dem
+  Abschluss stabil, auch wenn Fundus-Originale oder Kataloge später wechseln.
+- Historische Sendungen sind intern nur lesbar. Die Duplikation erzeugt einen
+  unabhängigen Entwurf mit offenen Pieces und ohne früheren Lauf- oder
+  Freigabezustand.
+
+### Archiv und Freigaben
+
+- Das Archiv zeigt abgeschlossene Sendungen neben archivierten und gelöschten
+  Pieces und bietet die Duplikation direkt an.
+- Barkeeper erstellen Leselinks direkt in der Sendungsbearbeitung oder zentral
+  in der Verwaltung für Ablauf, Moderation oder vollständige Recherche, optional
+  mit Passwort und Ablaufzeit.
+- Noch nicht abgeschlossene Sendungen zeigen Gästen beim nächsten Aufruf den
+  aktuellen Plan. Nach dem Abschluss bleibt derselbe Link auf dem stabilen
+  historischen Stand.
+- Freigaben lassen sich in nach Sendung gruppierten Verwaltungskarten bearbeiten
+  und endgültig löschen; Passwortänderungen beenden vorhandene Gast-Sitzungen.
+- Tokens und Gast-Sitzungen liegen nur gehasht vor; Passwörter verwenden
+  Argon2id und Fehlversuche sind begrenzt.
+- Gastseiten projizieren genau eine Sendung. Private Originaldaten, Nutzer,
+  interne IDs und Felder außerhalb des gewählten Umfangs werden nicht geliefert.
+- Direkte Medienaufrufe prüfen dieselbe Freigabe, Passwortsitzung, Ablaufzeit und
+  den Widerruf erneut und erlauben nur das freigegebene Präsentationsmedium.
+
+### Technik und Prüfung
+
+- Migration `0015_completion_archive_and_shares.sql` übernimmt bestehende
+  abgeschlossene Sendungen und ergänzt Finalisierung, Historie,
+  Duplikationsbefehle, Freigaben, Gast-Sitzungen und
+  Passwortversuchsbegrenzung.
+- Migration `0016_shares_for_active_shows.sql` erhält vorhandene Freigaben und
+  erweitert ihre Referenz auf alle Sendungszustände.
+- Paket, Lockdatei und Cloudron-Manifest tragen gemeinsam Version `0.6.0`.
+- 52 Verhaltenstests und 18 Chromium-Abläufe decken den bisherigen Umfang sowie
+  Abschluss, Archiv und anonyme Lesefreigaben ab.
+
 ## 0.5.12 - Live-Regie und Sendungskalender

 Veröffentlicht am 24. Oktober 2026
@@ -2,10 +2,88 @@

 ## Aktueller Umfang

-Etappe 1 bis Etappe 5 sind abgeschlossen. Architektur, Gesamtdatenmodell,
+Etappe 1 bis Etappe 7 sind abgeschlossen. Architektur, Gesamtdatenmodell,
 Anmeldung, Rollen, persistente Inhaltsbearbeitung, Sendungsplanung,
-Live-Steuerung, Präsentationsausgabe und lokaler Betriebsweg sind dokumentiert.
-Etappe 6 wurde nicht begonnen.
+Live-Steuerung, Präsentationsausgabe, unveränderliche Sendungshistorie,
+Archiv, sichere Lesefreigaben, RSS-Import und technische REST-Zugänge sind
+dokumentiert.
+
+## RSS-Import und externe Assistenz 0.7.0
+
+- Barkeeper verwalten RSS-/Atom-Feeds mit Standardkategorie, Aktivierung und
+  Abrufintervall; manueller Abruf und ein begrenzter Prozess-Scheduler verwenden
+  dieselbe Fehler- und Dublettenlogik.
+- Feedabrufe prüfen Protokoll, Port, DNS und Redirects, begrenzen Laufzeit,
+  Antwortgröße und Eintragszahl und lassen Fehler anderer Feeds unberührt.
+- Fremdes HTML wird entfernt. Beiträge bleiben mit stabiler Herkunft im
+  getrennten Importeingang, bis die Redaktion sie auswählt, kategorisiert und
+  als normale Pieces übernimmt oder dauerhaft verwirft.
+- `/api/v1` bietet Pieces und Sendungen über gehashte, widerrufbare technische
+  Bearer-Tokens mit reinen Lese- oder Lese-/Schreibrechten an. Mutationen nutzen
+  bestehende Dienste, Audit-Ereignisse, Revisionen und persistente
+  Idempotenzschlüssel.
+- Die maschinenlesbare Beschreibung liegt unter `/api/v1/openapi.json`; eine
+  ChatGPT-/Codex- oder andere konkrete Client-Anbindung wurde nicht eingerichtet.
+- Migration `0018_rss_and_api.sql` ergänzt ausschließlich additive Tabellen und
+  Indizes. Sendewerk bleibt ohne KI und ohne konfigurierte Feeds vollständig
+  nutzbar.
+
+Geprüft wurden 58 Verhaltenstests, Typprüfung, Produktionsbuild, Dependency-
+Audit, vier RSS- und zwei Zugangssicherheitstests sowie ein echter HTTP-Rundlauf
+lesen → anlegen → idempotent wiederholen → ändern → erneut lesen → einplanen →
+sortieren. Desktop-Verwaltung und mobiler Eingang wurden in Chromium ohne
+Konsolenfehler geprüft. In der bestehenden Gesamtmatrix waren 16 von 18 Abläufen
+erfolgreich; die bereits bekannte Live-Zeitanzeige und der Ablauf
+Abschluss/Freigabe schlugen weiterhin fehl. Der globale Lintlauf bleibt an acht
+vorhandenen Formatierungsabweichungen außerhalb dieser Etappe offen.
+
+## Wartungsrelease 0.6.1
+
+- Abschnitts-Countdown, mobile Live-Kopfzeile und Ablauf-Sheet wurden korrigiert; die doppelte Piece-Positionsanzeige entfällt.
+- Optionaler Vorbereitungsaufwand, kompakte Vorbereitungsliste und Abschnitts-Twitch-Tags sind additiv persistiert.
+- Der Präsentationsmodus `image` gibt ausschließlich das bewusst gewählte Snapshot-Medium aus.
+- Mobile Eingaben, Iconsuche, Sendungskarten und Gastabstände wurden angepasst.
+- Lesefreigaben verwenden einen gemeinsamen Dialog und sind auch aus der Live-Regie erreichbar.
+
+Geprüft wurden 52 Verhaltenstests, Typprüfung und Produktionsbuild. Im zweiten
+Chromium-Lauf waren 14 Abläufe erfolgreich; zwei Abläufe schlugen vor dem
+Zeitlimit fehl, zwei weitere wurden nicht mehr ausgeführt. Die vollständige
+Browsermatrix bleibt damit offen.
+
+## Abschluss, Archiv und Freigaben 0.6.0
+
+- das Ende eines Live-Laufs bleibt wiederaufnehmbar; erst der getrennte,
+  idempotente Abschluss friert Sendung, Kategorien, tatsächliche Verwendungen
+  und Zeiten unveränderlich ein
+- der Abschlussdialog zählt gesendete, übersprungene und offene Pieces getrennt
+  und archiviert Fundus-Originale ausschließlich nach bewusster Auswahl
+- die Verwendungshistorie wird beim Abschluss materialisiert; übersprungene
+  Verwendungen und die Reservebank zählen nicht als gesendet
+- abgeschlossene Sendungen liegen getrennt im Archiv, sind intern nur lesbar und
+  lassen sich mit neuen IDs, offenen Verwendungen und ohne Live- oder
+  Freigabezustand in einen neuen Entwurf duplizieren
+- Barkeeper verwalten gehashte Leselinks direkt in der Sendungsbearbeitung und
+  gesammelt in der Verwaltung; Umfang, Passwort und Ablauf lassen sich ändern,
+  Freigaben vollständig löschen
+- Entwürfe, bereite und laufende Sendungen lassen sich bereits freigeben;
+  Planänderungen werden beim nächsten Gastaufruf sichtbar, während der Abschluss
+  denselben Link auf den unveränderlichen historischen Stand festlegt
+- passwortgeschützte Freigaben verwenden kurzlebige, gehashte Gast-Sitzungen und
+  begrenzen Fehlversuche pro Link und Clientadresse
+- Gastseiten liefern genau eine positiv projizierte Sendung ohne interne IDs,
+  Originaldaten oder nicht freigegebene Felder; geschützte Präsentationsmedien
+  prüfen Umfang, Passwortsitzung, Ablauf und Widerruf bei jedem Direktaufruf
+- bestehende abgeschlossene Sendungen werden durch Migration `0015` mit
+  eingefrorener Historie übernommen; Migration `0016` erweitert bestehende
+  Freigaben verlustfrei auf noch nicht abgeschlossene Sendungen
+
+Die lokale Prüfmatrix umfasst 52 Verhaltenstests und 18 Chromium-Abläufe.
+Abschluss, Archiv, historische Nur-Lese-Ansicht, Passwortfreigabe,
+Scope-Begrenzung, direkter Medienzugriff, fremde IDs, Gast-Schreibversuch und
+Widerruf wurden zusätzlich in einem anonymen Browserkontext geprüft. Der
+erweiterte Ablauf prüft außerdem offene Sendungen, aktuelle Planänderungen,
+Bearbeiten und Löschen in beiden Barkeeper-Oberflächen sowie Desktop- und
+Smartphone-Layout.

 ## Live-Regie und Sendungskalender 0.5.12

@@ -0,0 +1,115 @@
+ALTER TABLE shows ADD COLUMN completed_at_utc TEXT;
+
+ALTER TABLE show_sections ADD COLUMN category_name_snapshot TEXT;
+ALTER TABLE show_sections ADD COLUMN category_color_snapshot TEXT;
+
+CREATE TABLE show_finalizations (
+	show_id TEXT PRIMARY KEY REFERENCES shows(id) ON DELETE CASCADE,
+	command_id TEXT NOT NULL,
+	source_revision INTEGER NOT NULL CHECK (source_revision >= 1),
+	finalized_by_user_id TEXT REFERENCES users(id) ON DELETE SET NULL,
+	finalized_at_utc TEXT NOT NULL,
+	UNIQUE (show_id, command_id)
+);
+
+CREATE TABLE show_finalization_archived_pieces (
+	show_id TEXT NOT NULL REFERENCES show_finalizations(show_id) ON DELETE CASCADE,
+	piece_id TEXT NOT NULL REFERENCES pieces(id) ON DELETE RESTRICT,
+	PRIMARY KEY (show_id, piece_id)
+);
+
+CREATE TABLE piece_usage_history (
+	usage_id TEXT PRIMARY KEY REFERENCES piece_usages(id) ON DELETE RESTRICT,
+	show_id TEXT NOT NULL REFERENCES shows(id) ON DELETE RESTRICT,
+	original_piece_id TEXT NOT NULL REFERENCES pieces(id) ON DELETE RESTRICT,
+	show_title_snapshot TEXT NOT NULL,
+	usage_title_snapshot TEXT NOT NULL,
+	used_at_utc TEXT NOT NULL,
+	actual_duration_seconds INTEGER NOT NULL CHECK (actual_duration_seconds >= 0)
+);
+
+CREATE INDEX idx_piece_usage_history_original
+	ON piece_usage_history(original_piece_id, used_at_utc DESC);
+
+CREATE TABLE show_duplication_commands (
+	source_show_id TEXT NOT NULL REFERENCES show_finalizations(show_id) ON DELETE CASCADE,
+	command_id TEXT NOT NULL,
+	created_show_id TEXT NOT NULL REFERENCES shows(id) ON DELETE CASCADE,
+	created_at_utc TEXT NOT NULL,
+	PRIMARY KEY (source_show_id, command_id)
+);
+
+CREATE TABLE show_shares (
+	id TEXT PRIMARY KEY,
+	show_id TEXT NOT NULL REFERENCES show_finalizations(show_id) ON DELETE CASCADE,
+	token_hash TEXT NOT NULL UNIQUE,
+	scope TEXT NOT NULL CHECK (scope IN ('rundown', 'moderation', 'research')),
+	password_hash TEXT,
+	expires_at_utc TEXT,
+	revoked_at_utc TEXT,
+	created_by_user_id TEXT NOT NULL REFERENCES users(id) ON DELETE RESTRICT,
+	created_at_utc TEXT NOT NULL
+);
+
+CREATE INDEX idx_show_shares_show ON show_shares(show_id, created_at_utc DESC);
+
+CREATE TABLE show_share_sessions (
+	token_hash TEXT PRIMARY KEY,
+	share_id TEXT NOT NULL REFERENCES show_shares(id) ON DELETE CASCADE,
+	created_at_utc TEXT NOT NULL,
+	expires_at_utc TEXT NOT NULL
+);
+
+CREATE INDEX idx_show_share_sessions_share ON show_share_sessions(share_id, expires_at_utc);
+
+CREATE TABLE share_password_attempts (
+	id TEXT PRIMARY KEY,
+	share_key TEXT NOT NULL,
+	address_key TEXT NOT NULL,
+	attempted_at_utc TEXT NOT NULL
+);
+
+CREATE INDEX idx_share_password_attempts_share
+	ON share_password_attempts(share_key, attempted_at_utc);
+CREATE INDEX idx_share_password_attempts_address
+	ON share_password_attempts(address_key, attempted_at_utc);
+
+UPDATE show_sections
+SET category_name_snapshot = (
+		SELECT name FROM section_categories WHERE id = show_sections.category_id
+	),
+	category_color_snapshot = (
+		SELECT color FROM section_categories WHERE id = show_sections.category_id
+	)
+WHERE show_id IN (SELECT id FROM shows WHERE status = 'completed');
+
+UPDATE shows
+SET completed_at_utc = COALESCE(
+	(SELECT ended_at_utc FROM show_live_states WHERE show_id = shows.id),
+	updated_at_utc
+)
+WHERE status = 'completed';
+
+INSERT INTO show_finalizations (
+	show_id, command_id, source_revision, finalized_by_user_id, finalized_at_utc
+)
+SELECT id, 'migration-' || id, revision, NULL, completed_at_utc
+FROM shows
+WHERE status = 'completed';
+
+INSERT INTO piece_usage_history (
+	usage_id, show_id, original_piece_id, show_title_snapshot, usage_title_snapshot,
+	used_at_utc, actual_duration_seconds
+)
+SELECT u.id, sh.id, u.original_piece_id, sh.title, u.title_snapshot,
+	COALESCE(sh.starts_at_utc, sh.completed_at_utc),
+	COALESCE((
+		SELECT sum(max(0, CAST((julianday(COALESCE(r.ended_at_utc, sh.completed_at_utc)) -
+			julianday(r.started_at_utc)) * 86400 AS INTEGER)))
+		FROM live_usage_runs r WHERE r.usage_id = u.id
+	), 0)
+FROM piece_usages u
+JOIN show_sections s ON s.id = u.show_section_id
+JOIN shows sh ON sh.id = s.show_id
+WHERE sh.status = 'completed' AND s.is_reserve_bank = 0
+	AND u.status = 'done' AND u.original_piece_id IS NOT NULL;
@@ -0,0 +1,43 @@
+DROP INDEX idx_show_share_sessions_share;
+DROP INDEX idx_show_shares_show;
+
+ALTER TABLE show_share_sessions RENAME TO show_share_sessions_v15;
+ALTER TABLE show_shares RENAME TO show_shares_v15;
+
+CREATE TABLE show_shares (
+	id TEXT PRIMARY KEY,
+	show_id TEXT NOT NULL REFERENCES shows(id) ON DELETE CASCADE,
+	token_hash TEXT NOT NULL UNIQUE,
+	scope TEXT NOT NULL CHECK (scope IN ('rundown', 'moderation', 'research')),
+	password_hash TEXT,
+	expires_at_utc TEXT,
+	revoked_at_utc TEXT,
+	created_by_user_id TEXT NOT NULL REFERENCES users(id) ON DELETE RESTRICT,
+	created_at_utc TEXT NOT NULL
+);
+
+CREATE INDEX idx_show_shares_show ON show_shares(show_id, created_at_utc DESC);
+
+CREATE TABLE show_share_sessions (
+	token_hash TEXT PRIMARY KEY,
+	share_id TEXT NOT NULL REFERENCES show_shares(id) ON DELETE CASCADE,
+	created_at_utc TEXT NOT NULL,
+	expires_at_utc TEXT NOT NULL
+);
+
+CREATE INDEX idx_show_share_sessions_share ON show_share_sessions(share_id, expires_at_utc);
+
+INSERT INTO show_shares (
+	id, show_id, token_hash, scope, password_hash, expires_at_utc, revoked_at_utc,
+	created_by_user_id, created_at_utc
+)
+SELECT id, show_id, token_hash, scope, password_hash, expires_at_utc, revoked_at_utc,
+	created_by_user_id, created_at_utc
+FROM show_shares_v15;
+
+INSERT INTO show_share_sessions (token_hash, share_id, created_at_utc, expires_at_utc)
+SELECT token_hash, share_id, created_at_utc, expires_at_utc
+FROM show_share_sessions_v15;
+
+DROP TABLE show_share_sessions_v15;
+DROP TABLE show_shares_v15;
@@ -0,0 +1,10 @@
+ALTER TABLE pieces ADD COLUMN preparation_effort TEXT CHECK (
+	preparation_effort IS NULL OR preparation_effort IN ('low', 'medium', 'high')
+);
+ALTER TABLE pieces ADD COLUMN presentation_image_only INTEGER NOT NULL DEFAULT 0
+	CHECK (presentation_image_only IN (0, 1));
+ALTER TABLE piece_usages ADD COLUMN presentation_image_only_snapshot INTEGER NOT NULL DEFAULT 0
+	CHECK (presentation_image_only_snapshot IN (0, 1));
+
+ALTER TABLE show_sections ADD COLUMN twitch_tags TEXT NOT NULL DEFAULT '';
+ALTER TABLE show_template_sections ADD COLUMN twitch_tags TEXT NOT NULL DEFAULT '';
@@ -0,0 +1,66 @@
+CREATE TABLE feed_sources (
+	id TEXT PRIMARY KEY,
+	name TEXT NOT NULL UNIQUE,
+	url TEXT NOT NULL UNIQUE,
+	is_enabled INTEGER NOT NULL DEFAULT 1 CHECK (is_enabled IN (0, 1)),
+	refresh_interval_minutes INTEGER NOT NULL DEFAULT 60 CHECK (refresh_interval_minutes BETWEEN 15 AND 10080),
+	default_category_id TEXT REFERENCES section_categories(id) ON DELETE SET NULL,
+	etag TEXT NOT NULL DEFAULT '',
+	last_modified TEXT NOT NULL DEFAULT '',
+	last_fetched_at_utc TEXT,
+	next_fetch_at_utc TEXT,
+	last_error TEXT NOT NULL DEFAULT '',
+	created_at_utc TEXT NOT NULL,
+	updated_at_utc TEXT NOT NULL
+);
+
+CREATE TABLE feed_entries (
+	id TEXT PRIMARY KEY,
+	feed_id TEXT NOT NULL REFERENCES feed_sources(id) ON DELETE CASCADE,
+	external_id TEXT NOT NULL,
+	title TEXT NOT NULL,
+	url TEXT NOT NULL,
+	summary TEXT NOT NULL DEFAULT '',
+	published_at_utc TEXT,
+	status TEXT NOT NULL DEFAULT 'new' CHECK (status IN ('new', 'imported', 'discarded')),
+	piece_id TEXT REFERENCES pieces(id) ON DELETE SET NULL,
+	first_seen_at_utc TEXT NOT NULL,
+	updated_at_utc TEXT NOT NULL,
+	UNIQUE (feed_id, external_id)
+);
+
+CREATE INDEX feed_entries_status_idx ON feed_entries(status, first_seen_at_utc DESC);
+CREATE INDEX feed_sources_due_idx ON feed_sources(is_enabled, next_fetch_at_utc);
+
+CREATE TABLE technical_accesses (
+	id TEXT PRIMARY KEY,
+	name TEXT NOT NULL UNIQUE,
+	token_hash TEXT NOT NULL UNIQUE,
+	permissions TEXT NOT NULL CHECK (permissions IN ('read', 'read_write')),
+	created_by_user_id TEXT NOT NULL REFERENCES users(id),
+	created_at_utc TEXT NOT NULL,
+	last_used_at_utc TEXT,
+	revoked_at_utc TEXT
+);
+
+CREATE TABLE api_idempotency (
+	access_id TEXT NOT NULL REFERENCES technical_accesses(id) ON DELETE CASCADE,
+	request_key TEXT NOT NULL,
+	request_hash TEXT NOT NULL,
+	status_code INTEGER NOT NULL,
+	response_json TEXT NOT NULL CHECK (json_valid(response_json)),
+	created_at_utc TEXT NOT NULL,
+	PRIMARY KEY (access_id, request_key)
+);
+
+CREATE TABLE audit_events (
+	id TEXT PRIMARY KEY,
+	actor_type TEXT NOT NULL CHECK (actor_type IN ('user', 'technical')),
+	actor_id TEXT NOT NULL,
+	action TEXT NOT NULL,
+	target_type TEXT NOT NULL,
+	target_id TEXT NOT NULL,
+	created_at_utc TEXT NOT NULL
+);
+
+CREATE INDEX audit_events_created_idx ON audit_events(created_at_utc DESC);
@@ -1,15 +1,16 @@
 {
 	"name": "sendewerk",
-	"version": "0.5.12",
+	"version": "0.7.0",
 	"lockfileVersion": 3,
 	"requires": true,
 	"packages": {
 		"": {
 			"name": "sendewerk",
-			"version": "0.5.12",
+			"version": "0.7.0",
 			"dependencies": {
 				"@node-rs/argon2": "^2.2.2",
 				"better-sqlite3": "^13.0.3",
+				"fast-xml-parser": "^5.11.2",
 				"file-type": "^22.2.0",
 				"marked": "^18.1.1",
 				"metascraper": "^5.58.5",
@@ -599,6 +600,18 @@
 				"node": ">= 22.13"
 			}
 		},
+		"node_modules/@nodable/entities": {
+			"version": "3.1.0",
+			"resolved": "https://registry.npmjs.org/@nodable/entities/-/entities-3.1.0.tgz",
+			"integrity": "sha512-LsS/DjHr+uDM647Gru/cA8+J3a3HfhttwCKLyuoyN7yXTFCxKBtSgMQBvrW9yNPa2/zDRUNuGPaH5QUFoa4arQ==",
+			"funding": [
+				{
+					"type": "github",
+					"url": "https://github.com/sponsors/nodable"
+				}
+			],
+			"license": "MIT"
+		},
 		"node_modules/@node-rs/argon2": {
 			"version": "2.2.2",
 			"resolved": "https://registry.npmjs.org/@node-rs/argon2/-/argon2-2.2.2.tgz",
@@ -1630,6 +1643,18 @@
 				"url": "https://github.com/sponsors/epoberezkin"
 			}
 		},
+		"node_modules/anynum": {
+			"version": "1.0.1",
+			"resolved": "https://registry.npmjs.org/anynum/-/anynum-1.0.1.tgz",
+			"integrity": "sha512-N6//FLET/tXYNM/F6ABca1oH6fWB+KlTt909Le28WMDBk8oaT4vY17DCrwg2MvmuqUKt3Ni4N5dGJ/EoBgcO6A==",
+			"funding": [
+				{
+					"type": "github",
+					"url": "https://github.com/sponsors/NaturalIntelligence"
+				}
+			],
+			"license": "MIT"
+		},
 		"node_modules/aria-query": {
 			"version": "5.3.1",
 			"resolved": "https://registry.npmjs.org/aria-query/-/aria-query-5.3.1.tgz",
@@ -2689,6 +2714,45 @@
 			"dev": true,
 			"license": "MIT"
 		},
+		"node_modules/fast-xml-builder": {
+			"version": "1.3.1",
+			"resolved": "https://registry.npmjs.org/fast-xml-builder/-/fast-xml-builder-1.3.1.tgz",
+			"integrity": "sha512-pIM/1n3ntFXKYrUZwW7QCK0gAW7XY+wzj1YMIV3tLDvPj/V+zTGJK5e3/4WJfwj0qWw2ElNXiTixda/R+3YSug==",
+			"funding": [
+				{
+					"type": "github",
+					"url": "https://github.com/sponsors/NaturalIntelligence"
+				}
+			],
+			"license": "MIT",
+			"dependencies": {
+				"path-expression-matcher": "^1.6.2",
+				"xml-naming": "^0.3.0"
+			}
+		},
+		"node_modules/fast-xml-parser": {
+			"version": "5.11.2",
+			"resolved": "https://registry.npmjs.org/fast-xml-parser/-/fast-xml-parser-5.11.2.tgz",
+			"integrity": "sha512-R9iDuNrQYeQut46cn2r2wHKn4HYzVDvDm5J1wW+koZewykv0yuO2HChTYeZtrULyHIDM9cj9TUXloCsueCQUog==",
+			"funding": [
+				{
+					"type": "github",
+					"url": "https://github.com/sponsors/NaturalIntelligence"
+				}
+			],
+			"license": "MIT",
+			"dependencies": {
+				"@nodable/entities": "^3.0.1",
+				"fast-xml-builder": "^1.2.0",
+				"is-unsafe": "^2.0.0",
+				"path-expression-matcher": "^1.6.2",
+				"strnum": "^2.4.2",
+				"xml-naming": "^0.3.0"
+			},
+			"bin": {
+				"fxparser": "src/cli/cli.js"
+			}
+		},
 		"node_modules/fdir": {
 			"version": "6.5.0",
 			"resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz",
@@ -3055,6 +3119,18 @@
 				"url": "https://github.com/sponsors/sindresorhus"
 			}
 		},
+		"node_modules/is-unsafe": {
+			"version": "2.0.2",
+			"resolved": "https://registry.npmjs.org/is-unsafe/-/is-unsafe-2.0.2.tgz",
+			"integrity": "sha512-HgbIHPBH0KHHCcjLfGsCvhtPTVxjaAZlXjwdz7/GQC40SjSe4sfQsar8J5VFo8JOSbarkpV0OLG95bbaNd9aAQ==",
+			"funding": [
+				{
+					"type": "github",
+					"url": "https://github.com/sponsors/NaturalIntelligence"
+				}
+			],
+			"license": "MIT"
+		},
 		"node_modules/is-uri": {
 			"version": "1.2.14",
 			"resolved": "https://registry.npmjs.org/is-uri/-/is-uri-1.2.14.tgz",
@@ -4052,6 +4128,21 @@
 				"node": ">=8"
 			}
 		},
+		"node_modules/path-expression-matcher": {
+			"version": "1.6.2",
+			"resolved": "https://registry.npmjs.org/path-expression-matcher/-/path-expression-matcher-1.6.2.tgz",
+			"integrity": "sha512-enSlaiat05iasnzmgNxRj8reFdj3puY2QpNgP1aPIaVfT6nn9ICuPoFlKHk8EN22HcwewshO+mN2DGbkCEOtqQ==",
+			"funding": [
+				{
+					"type": "github",
+					"url": "https://github.com/sponsors/NaturalIntelligence"
+				}
+			],
+			"license": "MIT",
+			"engines": {
+				"node": ">=14.0.0"
+			}
+		},
 		"node_modules/path-key": {
 			"version": "3.1.1",
 			"resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz",
@@ -4545,6 +4636,21 @@
 			"dev": true,
 			"license": "MIT"
 		},
+		"node_modules/strnum": {
+			"version": "2.5.1",
+			"resolved": "https://registry.npmjs.org/strnum/-/strnum-2.5.1.tgz",
+			"integrity": "sha512-UM4nTLWzQiDBseVxUGxN0wJzIk0UU89Qi7pKXz9qISo+lhviJikTuikBsK/oFRlpvYHvSdz0TVoLyQ+sEpYwxA==",
+			"funding": [
+				{
+					"type": "github",
+					"url": "https://github.com/sponsors/NaturalIntelligence"
+				}
+			],
+			"license": "MIT",
+			"dependencies": {
+				"anynum": "^1.0.1"
+			}
+		},
 		"node_modules/strtok3": {
 			"version": "10.6.2",
 			"resolved": "https://registry.npmjs.org/strtok3/-/strtok3-10.6.2.tgz",
@@ -5284,6 +5390,21 @@
 				"node": ">=18"
 			}
 		},
+		"node_modules/xml-naming": {
+			"version": "0.3.0",
+			"resolved": "https://registry.npmjs.org/xml-naming/-/xml-naming-0.3.0.tgz",
+			"integrity": "sha512-ghig2TBE/H11aOVgmahA3MhimvkBr6JIYknH/Dhdk10nXwdbIqBJsbfMxpvFPG8bAw77gN29aQWvKpmVoPlvPQ==",
+			"funding": [
+				{
+					"type": "github",
+					"url": "https://github.com/sponsors/NaturalIntelligence"
+				}
+			],
+			"license": "MIT",
+			"engines": {
+				"node": ">=16.0.0"
+			}
+		},
 		"node_modules/xmlchars": {
 			"version": "2.2.0",
 			"resolved": "https://registry.npmjs.org/xmlchars/-/xmlchars-2.2.0.tgz",
@@ -1,7 +1,7 @@
 {
 	"name": "sendewerk",
 	"private": true,
-	"version": "0.5.12",
+	"version": "0.7.0",
 	"type": "module",
 	"engines": {
 		"node": ">=22.17 <25"
@@ -26,6 +26,7 @@
 	"dependencies": {
 		"@node-rs/argon2": "^2.2.2",
 		"better-sqlite3": "^13.0.3",
+		"fast-xml-parser": "^5.11.2",
 		"file-type": "^22.2.0",
 		"marked": "^18.1.1",
 		"metascraper": "^5.58.5",
@@ -47,6 +47,341 @@
 	--radius-small: 0.65rem;
 }

+.completion-dialog {
+	width: min(38rem, calc(100% - 2rem));
+	max-height: calc(100dvh - 2rem);
+	padding: 0;
+	border: 1px solid color-mix(in srgb, var(--gold) 55%, var(--line));
+	border-radius: var(--radius-large);
+	background: var(--panel-strong);
+	color: var(--text);
+}
+
+.completion-dialog::backdrop {
+	background: rgb(3 8 16 / 68%);
+}
+
+.completion-dialog form {
+	display: grid;
+	gap: 1rem;
+	padding: 1.25rem;
+}
+
+.completion-dialog h2,
+.completion-dialog p {
+	margin: 0;
+}
+
+.completion-dialog fieldset {
+	display: grid;
+	gap: 0.5rem;
+	max-height: 15rem;
+	overflow-y: auto;
+	padding: 0.8rem;
+	border: 1px solid var(--line);
+	border-radius: var(--radius-medium);
+}
+
+.completion-dialog footer,
+.completion-counts,
+.check-row {
+	display: flex;
+	align-items: center;
+	gap: 0.75rem;
+}
+
+.completion-dialog footer {
+	justify-content: flex-end;
+}
+
+.completion-counts {
+	flex-wrap: wrap;
+}
+
+.completion-counts span {
+	padding: 0.45rem 0.65rem;
+	border-radius: 999px;
+	background: var(--panel-soft);
+}
+
+.check-row input {
+	width: auto;
+}
+
+.check-row span {
+	display: grid;
+}
+
+.share-management {
+	margin-bottom: 1.5rem;
+	padding: 1rem;
+}
+
+.share-create-form {
+	display: grid;
+	grid-template-columns: repeat(auto-fit, minmax(min(100%, 11rem), 1fr));
+	gap: 0.8rem;
+	margin-top: 1rem;
+}
+
+.share-create-form label,
+.share-edit-form label {
+	display: grid;
+	gap: 0.35rem;
+	color: var(--text-muted);
+	font-size: 0.72rem;
+	font-weight: 700;
+}
+
+.share-create-form button {
+	align-self: end;
+}
+
+.share-intro {
+	max-width: 58rem;
+	margin: 0;
+	color: var(--text-muted);
+	font-size: 0.76rem;
+}
+
+.share-show-list {
+	display: grid;
+	gap: 0.75rem;
+	margin-top: 1rem;
+}
+
+.share-show-card {
+	padding: 0.85rem;
+	border: 1px solid var(--line);
+	border-radius: var(--radius-medium);
+	background: var(--panel-soft);
+}
+
+.share-show-card > header,
+.share-row summary {
+	display: grid;
+	align-items: center;
+	gap: 0.75rem;
+}
+
+.share-show-card > header {
+	grid-template-columns: minmax(0, 1fr) auto;
+}
+
+.share-show-card > header > div,
+.share-row summary > span:nth-child(2) {
+	display: grid;
+	min-width: 0;
+}
+
+.share-show-card > header a {
+	color: var(--text);
+	font-weight: 760;
+}
+
+.share-show-card small,
+.share-row small {
+	color: var(--text-muted);
+	font-size: 0.68rem;
+}
+
+.share-list {
+	display: grid;
+	gap: 0.4rem;
+	margin-top: 0.75rem;
+}
+
+.share-row {
+	border-top: 1px solid var(--line);
+}
+
+.share-row summary {
+	grid-template-columns: auto minmax(0, 1fr) auto auto;
+	min-height: 3.25rem;
+	cursor: pointer;
+	list-style: none;
+}
+
+.share-row summary::-webkit-details-marker {
+	display: none;
+}
+
+.share-row-icon {
+	display: grid;
+	width: 2rem;
+	height: 2rem;
+	place-items: center;
+	border-radius: 50%;
+	background: var(--accent-soft);
+	color: var(--accent-text);
+}
+
+.share-row summary > span:nth-child(3) {
+	padding: 0.2rem 0.45rem;
+	border-radius: 999px;
+	background: var(--accent-soft);
+	color: var(--accent-text);
+	font-size: 0.65rem;
+	font-weight: 700;
+}
+
+.share-row summary > span.locked {
+	background: color-mix(in srgb, var(--danger) 12%, var(--panel));
+	color: var(--danger);
+}
+
+.share-edit-area {
+	display: grid;
+	gap: 0.75rem;
+	padding: 0.75rem 0 0.25rem 2.75rem;
+}
+
+.share-edit-area > p {
+	margin: 0;
+	color: var(--text-muted);
+	font-size: 0.74rem;
+}
+
+.share-edit-form {
+	display: grid;
+	grid-template-columns: repeat(2, minmax(0, 1fr));
+	gap: 0.65rem;
+}
+
+.share-edit-form input,
+.share-edit-form select {
+	width: 100%;
+}
+
+.share-result {
+	display: grid;
+	gap: 0.25rem;
+}
+
+.share-result a {
+	overflow-wrap: anywhere;
+}
+
+.guest-shell {
+	min-height: 100dvh;
+}
+
+.share-page {
+	width: min(58rem, calc(100% - 2rem));
+	margin: 0 auto;
+	padding: clamp(2rem, 6vw, 5rem) 0;
+}
+
+.share-gate {
+	width: min(30rem, 100%);
+	margin: 8vh auto 0;
+}
+
+.share-heading {
+	padding-bottom: 1.5rem;
+	border-bottom: 1px solid var(--line);
+}
+
+.share-heading h1 {
+	margin: 0.25rem 0;
+	font-size: clamp(2rem, 6vw, 4rem);
+}
+
+.shared-rundown,
+.historical-rundown {
+	display: grid;
+	gap: 1rem;
+	margin-top: 1.25rem;
+}
+
+.shared-section > header,
+.historical-section > header,
+.shared-usage-heading,
+.historical-usage > header {
+	display: flex;
+	align-items: flex-start;
+	justify-content: space-between;
+	gap: 1rem;
+}
+
+.shared-section h2,
+.shared-usage h3,
+.historical-section h2,
+.historical-usage h3 {
+	margin: 0;
+}
+
+.shared-usage,
+.historical-usage {
+	margin-top: 0.75rem;
+	padding: 1rem;
+	border: 1px solid var(--line);
+	border-radius: var(--radius-medium);
+	background: var(--panel-soft);
+}
+
+.shared-usage img {
+	max-width: min(100%, 32rem);
+	max-height: 22rem;
+	margin-top: 0.8rem;
+	border-radius: var(--radius-medium);
+	object-fit: contain;
+}
+
+.output-image-only {
+	display: grid;
+	height: 100%;
+	place-items: center;
+}
+
+.output-image-only img {
+	width: 100%;
+	height: 100%;
+	object-fit: contain;
+}
+
+.shared-copy,
+.historical-usage section,
+.historical-usage details {
+	margin-top: 0.8rem;
+}
+
+.historical-show-page {
+	width: min(72rem, 100%);
+}
+
+.historical-usage p {
+	white-space: pre-wrap;
+}
+
+@media (max-width: 42rem) {
+	.share-create-form,
+	.share-edit-form {
+		grid-template-columns: 1fr;
+	}
+
+	.share-row summary {
+		grid-template-columns: auto minmax(0, 1fr) auto;
+	}
+
+	.share-row summary > .app-icon:last-child {
+		display: none;
+	}
+
+	.share-edit-area {
+		padding-left: 0;
+	}
+
+	.completion-dialog footer,
+	.shared-section > header,
+	.historical-section > header,
+	.shared-usage-heading,
+	.historical-usage > header {
+		align-items: stretch;
+		flex-direction: column;
+	}
+}
+
 :root[data-theme='dark'] {
 	color-scheme: dark;
 	--bg: #0b1220;
@@ -4408,6 +4743,45 @@ textarea:focus {
 	gap: 0.5rem;
 }

+.preparation-list {
+	display: grid;
+	grid-template-columns: repeat(auto-fit, minmax(min(18rem, 100%), 1fr));
+	gap: 0.5rem;
+}
+
+.preparation-list a {
+	display: flex;
+	min-width: 0;
+	align-items: center;
+	justify-content: space-between;
+	gap: 0.75rem;
+	padding: 0.7rem 0.8rem;
+	border: 1px solid var(--line);
+	border-radius: var(--radius-medium);
+	background: var(--panel-soft);
+}
+
+.preparation-list span {
+	display: grid;
+	min-width: 0;
+}
+
+.preparation-list small {
+	overflow: hidden;
+	color: var(--text-muted);
+	font-size: 0.68rem;
+	text-overflow: ellipsis;
+	white-space: nowrap;
+}
+
+.effort {
+	padding: 0.2rem 0.45rem;
+	border-radius: 2rem;
+	background: var(--panel-strong);
+	color: var(--text-muted);
+	font-size: 0.62rem;
+}
+
 .show-card {
 	display: flex;
 	align-items: center;
@@ -6104,6 +6478,21 @@ textarea:focus {
 		flex-direction: column;
 		gap: 0.75rem;
 	}
+	input:not([type='checkbox']):not([type='radio']):not([type='hidden']),
+	select,
+	textarea,
+	.icon-picker-popover input[type='search'] {
+		font-size: 1rem;
+	}
+	.icon-picker-popover {
+		display: grid;
+		max-height: calc(100dvh - var(--mobile-header) - var(--mobile-nav) - 1rem);
+		grid-template-rows: auto minmax(0, 1fr) auto;
+	}
+	.icon-picker-grid {
+		min-height: 0;
+		overflow-y: auto;
+	}
 	.usage-editor-dialog {
 		width: calc(100vw - 1rem);
 		max-height: calc(100dvh - 1rem);
@@ -7038,6 +7427,18 @@ body:has(.heinzlive-output.empty),
 			calc(0.5rem + env(safe-area-inset-left));
 		width: auto;
 		max-height: none;
+		display: grid;
+		grid-template-rows: auto minmax(0, 1fr) auto;
+		overflow: hidden;
+	}
+
+	.icon-picker-popover input[type='search'] {
+		font-size: 1rem;
+	}
+
+	.icon-picker-grid {
+		min-height: 0;
+		overflow-y: auto;
 	}

 	.piece-subsection-heading .choice-picker-popover {
@@ -1,6 +1,8 @@
+import { randomBytes } from 'node:crypto';
 import { redirect } from '@sveltejs/kit';
 import type { Handle } from '@sveltejs/kit/hooks';
 import { deleteSession, getSessionUser, hasUsers, SESSION_COOKIE } from '#lib/server/auth.js';
+import { startFeedScheduler } from '#lib/server/feeds.js';

 const publicPaths = new Set([
 	'/',
@@ -13,17 +15,36 @@ const publicPaths = new Set([
 ]);

 export const handle: Handle = async ({ event, resolve }) => {
+	startFeedScheduler();
 	const presentationPath = event.url.pathname.startsWith('/heinzlive/');
+	const sharePath = event.url.pathname.startsWith('/freigabe/');
+	const shareMediaPath = /^\/freigabe\/[^/]+\/media\/[^/]+$/.test(event.url.pathname);
+	const apiPath = event.url.pathname.startsWith('/api/v1/');
 	const presentationTestPath = /^\/fundus\/[^/]+\/praesentation(?:\/|$)/.test(event.url.pathname);
 	const token = event.cookies.get(SESSION_COOKIE);
 	event.locals.user = getSessionUser(token);
 	if (token && !event.locals.user) deleteSession(event.cookies);

-	if (!presentationPath && !publicPaths.has(event.url.pathname) && !event.locals.user) {
+	if (
+		!presentationPath &&
+		!sharePath &&
+		!publicPaths.has(event.url.pathname) &&
+		!apiPath &&
+		!event.locals.user
+	) {
 		redirect(303, hasUsers() ? '/login' : '/setup');
 	}

-	const response = await resolve(event);
+	const sharePageNonce = sharePath && !shareMediaPath ? randomBytes(16).toString('base64') : null;
+	const response = await resolve(
+		event,
+		sharePageNonce
+			? {
+					transformPageChunk: ({ html }) =>
+						html.replaceAll('<script', `<script nonce="${sharePageNonce}"`)
+				}
+			: undefined
+	);
 	response.headers.set('Referrer-Policy', 'same-origin');
 	response.headers.set('X-Content-Type-Options', 'nosniff');
 	response.headers.set('X-Frame-Options', 'DENY');
@@ -35,6 +56,16 @@ export const handle: Handle = async ({ event, resolve }) => {
 			"frame-src https://www.youtube-nocookie.com https://www.youtube.com https://www.tiktok.com; frame-ancestors 'none'"
 		);
 	}
+	if (sharePath) {
+		response.headers.set('Cache-Control', 'private, no-store');
+		response.headers.set('Referrer-Policy', 'same-origin');
+		if (!shareMediaPath) {
+			response.headers.set(
+				'Content-Security-Policy',
+				`default-src 'self'; script-src 'self' 'nonce-${sharePageNonce}'; style-src 'self' 'unsafe-inline'; img-src 'self'; frame-ancestors 'none'`
+			);
+		}
+	}
 	if (event.url.pathname === '/einladung' || event.url.pathname === '/passwort-zuruecksetzen') {
 		response.headers.set('Cache-Control', 'no-store');
 	}
@@ -60,6 +60,11 @@
 				{/each}
 			</footer>{/if}
 	</article>
+{:else if content.mode === 'image'}
+	<article class="output-content output-image-only">
+		{#if content.topics.length}<p class="output-topics">{content.topics.join(' · ')}</p>{/if}
+		{#if imageSrc}<img src={imageSrc} alt={content.images?.[0]?.altText ?? content.title} />{/if}
+	</article>
 {:else if content.mode === 'link'}
 	<article class="output-content output-link-card">
 		{#if imageSrc && !imageUnavailable}<div class="output-link-image">
@@ -0,0 +1,260 @@
+<script lang="ts">
+	import { resolve } from '$app/paths';
+	import AppIcon from './AppIcon.svelte';
+
+	type ShareShow = {
+		id: string;
+		title: string;
+		startsAtUtc: string | null;
+		status: string;
+	};
+
+	type ShareItem = {
+		id: string;
+		showId: string;
+		showTitle: string;
+		showStatus: string;
+		showStartsAtUtc: string | null;
+		scope: 'rundown' | 'moderation' | 'research';
+		isPasswordProtected: boolean;
+		expiresAtUtc: string | null;
+		revokedAtUtc: string | null;
+		createdAtUtc: string;
+	};
+
+	let {
+		shows,
+		shares,
+		fixedShowId = '',
+		form = null
+	}: {
+		shows: ShareShow[];
+		shares: ShareItem[];
+		fixedShowId?: string;
+		form?: { intent?: string; error?: string; success?: string | boolean; shareUrl?: string } | null;
+	} = $props();
+
+	let visibleShows = $derived(
+		fixedShowId
+			? shows.filter((show) => show.id === fixedShowId)
+			: shows.filter((show) => shares.some((share) => share.showId === show.id))
+	);
+	let dialog: HTMLDialogElement;
+
+	function germanDate(value: string | null, fallback = 'Termin offen') {
+		return value
+			? new Intl.DateTimeFormat('de-DE', {
+					timeZone: 'Europe/Berlin',
+					dateStyle: 'medium',
+					timeStyle: 'short'
+				}).format(new Date(value))
+			: fallback;
+	}
+
+	function berlinInput(value: string | null) {
+		if (!value) return '';
+		const parts = new Intl.DateTimeFormat('en-CA', {
+			timeZone: 'Europe/Berlin',
+			year: 'numeric',
+			month: '2-digit',
+			day: '2-digit',
+			hour: '2-digit',
+			minute: '2-digit',
+			hourCycle: 'h23'
+		}).formatToParts(new Date(value));
+		const read = (type: Intl.DateTimeFormatPartTypes) =>
+			parts.find((part) => part.type === type)?.value ?? '';
+		return `${read('year')}-${read('month')}-${read('day')}T${read('hour')}:${read('minute')}`;
+	}
+
+	function statusLabel(status: string) {
+		if (status === 'draft') return 'Entwurf';
+		if (status === 'ready') return 'Bereit';
+		if (status === 'live') return 'Live';
+		return 'Abgeschlossen';
+	}
+
+	function scopeLabel(scope: ShareItem['scope']) {
+		if (scope === 'rundown') return 'Nur Ablauf';
+		if (scope === 'moderation') return 'Ablauf und Moderation';
+		return 'Vollständig mit Recherche';
+	}
+
+	function shareState(share: ShareItem) {
+		if (share.revokedAtUtc) return 'Widerrufen';
+		if (share.expiresAtUtc && new Date(share.expiresAtUtc) <= new Date()) return 'Abgelaufen';
+		return 'Aktiv';
+	}
+</script>
+
+<button class="secondary-button share-dialog-trigger" type="button" onclick={() => dialog.showModal()}>
+	<AppIcon name="link" /> Lesefreigaben
+</button>
+<dialog bind:this={dialog} class="share-management-dialog">
+<section
+	class="quiet-panel share-management"
+	aria-labelledby={`share-title-${fixedShowId || 'all'}`}
+>
+	<div class="panel-heading">
+		<div>
+			<p class="eyebrow">Gastzugänge</p>
+			<h2 id={`share-title-${fixedShowId || 'all'}`}>Lesefreigaben</h2>
+		</div>
+		<span class="mail-mode">Aktualisiert sich bis zum Abschluss</span>
+		<button class="dialog-close" type="button" aria-label="Lesefreigaben schließen" onclick={() => dialog.close()}>
+			<AppIcon name="xmark" />
+		</button>
+	</div>
+	<p class="share-intro">
+		Der Gast sieht nur diese Sendung und den gewählten Informationsumfang. Der vollständige Link
+		wird aus Sicherheitsgründen nur direkt nach dem Anlegen angezeigt.
+	</p>
+	{#if form?.intent?.toLowerCase().includes('share') && form.error}<div
+			class="form-message error"
+			role="alert"
+		>
+			{form.error}
+		</div>{/if}
+	{#if form?.intent?.toLowerCase().includes('share') && typeof form.success === 'string'}<div
+			class="form-message success"
+			role="status"
+		>
+			{form.success}
+		</div>{/if}
+	{#if form?.shareUrl}<div class="form-message success share-result" role="status">
+			<strong>Neuer Leselink</strong>
+			<!-- The server returns only a same-origin share path created by this action. -->
+			<!-- eslint-disable-next-line svelte/no-navigation-without-resolve -->
+			<a href={form.shareUrl}>{form.shareUrl}</a>
+		</div>{/if}
+
+	<form class="share-create-form" method="POST" action="?/createShare">
+		{#if fixedShowId}
+			<input type="hidden" name="showId" value={fixedShowId} />
+		{:else}
+			<label
+				>Sendung<select name="showId" required>
+					<option value="">Sendung wählen</option>
+					{#each shows as show (show.id)}<option value={show.id}
+							>{show.title} · {statusLabel(show.status)}</option
+						>{/each}
+				</select></label
+			>
+		{/if}
+		<label
+			>Informationsumfang<select name="scope">
+				<option value="rundown">Nur Ablauf</option>
+				<option value="moderation">Ablauf und Moderation</option>
+				<option value="research">Vollständig mit Recherche</option>
+			</select></label
+		>
+		<label
+			>Optionales Passwort<input
+				name="password"
+				type="password"
+				minlength="12"
+				maxlength="256"
+				autocomplete="new-password"
+			/></label
+		>
+		<label>Optionaler Ablauf<input name="expiresAt" type="datetime-local" /></label>
+		<button class="primary-button" type="submit" disabled={!shows.length}>Leselink anlegen</button>
+	</form>
+
+	{#if visibleShows.length}
+		<div class="share-show-list">
+			{#each visibleShows as show (show.id)}
+				<article class="share-show-card">
+					<header>
+						<div>
+							<a href={resolve('/sendungen/[id]', { id: show.id })}>{show.title}</a>
+							<small>{germanDate(show.startsAtUtc)} Uhr</small>
+						</div>
+						<span class={`show-state ${show.status}`}>{statusLabel(show.status)}</span>
+					</header>
+					<div class="share-list">
+						{#each shares.filter((share) => share.showId === show.id) as share (share.id)}
+							<details class="share-row">
+								<summary>
+									<span class="share-row-icon"><AppIcon name="link" /></span>
+									<span>
+										<strong>{scopeLabel(share.scope)}</strong>
+										<small
+											>{share.isPasswordProtected ? 'Mit Passwort' : 'Ohne Passwort'} · {germanDate(
+												share.expiresAtUtc,
+												'ohne Ablauf'
+											)}</small
+										>
+									</span>
+									<span class:locked={shareState(share) !== 'Aktiv'}>{shareState(share)}</span>
+									<AppIcon name="pen" />
+								</summary>
+								<div class="share-edit-area">
+									{#if share.revokedAtUtc}
+										<p>Diese Freigabe ist widerrufen und kann nur noch gelöscht werden.</p>
+									{:else}
+										<form class="share-edit-form" method="POST" action="?/updateShare">
+											<input type="hidden" name="shareId" value={share.id} />
+											<input type="hidden" name="showId" value={show.id} />
+											<label
+												>Informationsumfang<select name="scope" value={share.scope}>
+													<option value="rundown">Nur Ablauf</option>
+													<option value="moderation">Ablauf und Moderation</option>
+													<option value="research">Vollständig mit Recherche</option>
+												</select></label
+											>
+											<label
+												>Passwort<select name="passwordMode">
+													<option value="keep">Unverändert</option>
+													<option value="remove">Kein Passwort</option>
+													<option value="replace">Neues Passwort setzen</option>
+												</select></label
+											>
+											<label
+												>Neues Passwort<input
+													name="password"
+													type="password"
+													minlength="12"
+													maxlength="256"
+													autocomplete="new-password"
+												/></label
+											>
+											<label
+												>Ablauf<input
+													name="expiresAt"
+													type="datetime-local"
+													value={berlinInput(share.expiresAtUtc)}
+												/><small>Leer lassen, um den Ablauf zu entfernen.</small></label
+											>
+											<button class="secondary-button" type="submit">Freigabe speichern</button>
+										</form>
+									{/if}
+									<form
+										method="POST"
+										action="?/deleteShare"
+										onsubmit={(event) => {
+											if (
+												!confirm('Freigabe endgültig löschen? Der Leselink wird sofort ungültig.')
+											)
+												event.preventDefault();
+										}}
+									>
+									<input type="hidden" name="shareId" value={share.id} />
+									<input type="hidden" name="showId" value={show.id} />
+										<button class="text-button danger-text" type="submit">Freigabe löschen</button>
+									</form>
+								</div>
+							</details>
+						{/each}
+						{#if !shares.some((share) => share.showId === show.id)}
+							<p class="quiet-copy">Für diese Sendung gibt es noch keine Lesefreigabe.</p>
+						{/if}
+					</div>
+				</article>
+			{/each}
+		</div>
+	{:else}
+		<p class="quiet-copy">Noch keine Lesefreigaben angelegt.</p>
+	{/if}
+</section>
+</dialog>
@@ -227,7 +227,7 @@
 						bind:value={draft.presentation}
 					/>
 					<div class="presentation-mode-picker" role="group" aria-label="Darstellung">
-						{#each [['text', 'Text'], ['link', 'Linkvorschau'], ['video', 'Video']] as mode (mode[0])}
+						{#each [['text', 'Text'], ['image', 'Nur Bild'], ['link', 'Linkvorschau'], ['video', 'Video']] as mode (mode[0])}
 							<label
 								><input
 									type="radio"
@@ -251,7 +251,7 @@
 					/>
 					<input type="hidden" name="presentationSiteName" value={draft.presentationSiteName} />
 					<input type="hidden" name="presentationMediaId" value={draft.presentationMediaId ?? ''} />
-					{#if draft.presentationMode !== 'text'}
+					{#if draft.presentationMode === 'link' || draft.presentationMode === 'video'}
 						<div class="presentation-settings">
 							<div class="presentation-source-summary wide-field">
 								<span>Ausgewählte Quelle</span>
@@ -0,0 +1,47 @@
+import { json } from '@sveltejs/kit';
+
+export async function apiBody(request: Request) {
+	const type = request.headers.get('content-type') ?? '';
+	if (!type.includes('application/json')) throw new Error('API_JSON_REQUIRED');
+	try {
+		return (await request.json()) as Record<string, unknown>;
+	} catch {
+		throw new Error('API_INVALID_JSON');
+	}
+}
+
+export function apiFailure(cause: unknown) {
+	const code = cause instanceof Error ? cause.message : 'API_ERROR';
+	const status =
+		code === 'API_UNAUTHORIZED'
+			? 401
+			: code === 'API_FORBIDDEN'
+				? 403
+				: code === 'NOT_FOUND'
+					? 404
+					: code === 'CONFLICT' || code === 'API_IDEMPOTENCY_CONFLICT'
+						? 409
+						: 400;
+	return json(
+		{
+			error: {
+				code,
+				message:
+					status === 401
+						? 'Authentifizierung erforderlich.'
+						: status === 403
+							? 'Diese Berechtigung fehlt.'
+							: status === 404
+								? 'Nicht gefunden.'
+								: 'Anfrage konnte nicht verarbeitet werden.'
+			}
+		},
+		{ status }
+	);
+}
+
+export function pageInput(url: URL) {
+	const limit = Math.min(100, Math.max(1, Number(url.searchParams.get('limit') ?? 50) || 50));
+	const offset = Math.max(0, Number(url.searchParams.get('offset') ?? 0) || 0);
+	return { limit, offset };
+}
@@ -110,11 +110,11 @@ export async function verifyPassword(passwordHash: string, password: string): Pr

 const dummyPasswordHash = hashPassword(randomBytes(32).toString('hex'));

-function createToken(): string {
+export function createToken(): string {
 	return randomBytes(32).toString('base64url');
 }

-function hashToken(token: string): string {
+export function hashToken(token: string): string {
 	return createHash('sha256').update(token).digest('hex');
 }

@@ -0,0 +1,204 @@
+import { execFileSync } from 'node:child_process';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import type { AuthUser } from './auth.js';
+import { finalizeShow, getCompletionSummary } from './completion.js';
+import { closeDatabase, getDatabase } from './database.js';
+import {
+	addPieceUsage,
+	addShowSection,
+	createShow,
+	duplicateCompletedShow,
+	getPieceUsageContexts,
+	getShow
+} from './shows.js';
+
+let directory: string;
+const actor: AuthUser = {
+	id: 'completion-actor',
+	email: 'completion@example.test',
+	displayName: 'Abschluss Test',
+	role: 'barkeeper',
+	lockedAtUtc: null
+};
+
+beforeEach(() => {
+	directory = mkdtempSync(path.join(tmpdir(), 'sendewerk-completion-test-'));
+	process.env.SENDEWERK_DB_PATH = path.join(directory, 'test.sqlite');
+	process.env.SENDEWERK_UPLOAD_DIR = path.join(directory, 'uploads');
+	execFileSync(process.execPath, ['scripts/migrate.mjs'], { cwd: process.cwd(), env: process.env });
+	execFileSync(process.execPath, ['scripts/seed.mjs'], { cwd: process.cwd(), env: process.env });
+	getDatabase()
+		.prepare(
+			`INSERT INTO users (id, email, email_normalized, display_name, password_hash, role,
+			 password_changed_at_utc, created_at_utc, updated_at_utc)
+			 VALUES (?, ?, ?, ?, 'unused', 'barkeeper', ?, ?, ?)`
+		)
+		.run(
+			actor.id,
+			actor.email,
+			actor.email,
+			actor.displayName,
+			...Array(3).fill(new Date().toISOString())
+		);
+});
+
+afterEach(() => {
+	closeDatabase();
+	delete process.env.SENDEWERK_DB_PATH;
+	delete process.env.SENDEWERK_UPLOAD_DIR;
+	rmSync(directory, { recursive: true, force: true });
+});
+
+function endedShow() {
+	const created = createShow({ title: 'Finale Sendung', startsAtUtc: null, templateId: null });
+	const section = addShowSection(created.id, created.revision, {
+		name: 'Gesendeter Block',
+		categoryId: 'cat-jc',
+		explicitDurationSeconds: null
+	});
+	const done = addPieceUsage(created.id, section.revision, {
+		pieceId: 'piece-console',
+		sectionId: section.id
+	});
+	const skipped = addPieceUsage(created.id, done.revision, {
+		pieceId: 'piece-console',
+		sectionId: section.id
+	});
+	const database = getDatabase();
+	database.prepare("UPDATE piece_usages SET status = 'done' WHERE id = ?").run(done.id);
+	database.prepare("UPDATE piece_usages SET status = 'skipped' WHERE id = ?").run(skipped.id);
+	database
+		.prepare(
+			`INSERT INTO show_live_states
+			 (show_id, revision, started_at_utc, ended_at_utc, presentation_revision, updated_at_utc)
+			 VALUES (?, 0, ?, ?, 0, ?)`
+		)
+		.run(
+			created.id,
+			'2026-10-25T18:00:00.000Z',
+			'2026-10-25T19:00:00.000Z',
+			'2026-10-25T19:00:00.000Z'
+		);
+	return { showId: created.id, doneUsageId: done.id, revision: skipped.revision };
+}
+
+describe('show completion', () => {
+	it('finalizes once, records only sent usages and archives only the explicit selection', () => {
+		const prepared = endedShow();
+		expect(getCompletionSummary(prepared.showId)).toMatchObject({
+			doneCount: 1,
+			skippedCount: 1,
+			candidates: [{ pieceId: 'piece-console', usageCount: 1 }]
+		});
+		const first = finalizeShow({
+			showId: prepared.showId,
+			commandId: 'complete-once',
+			expectedShowRevision: prepared.revision,
+			expectedLiveRevision: 0,
+			archivePieceIds: ['piece-console'],
+			actor,
+			now: new Date('2026-10-25T19:05:00.000Z')
+		});
+		expect(first.duplicate).toBe(false);
+		expect(
+			finalizeShow({
+				showId: prepared.showId,
+				commandId: 'complete-once',
+				expectedShowRevision: prepared.revision,
+				expectedLiveRevision: 0,
+				archivePieceIds: ['piece-console'],
+				actor
+			}).duplicate
+		).toBe(true);
+		expect(() =>
+			finalizeShow({
+				showId: prepared.showId,
+				commandId: 'different-command',
+				expectedShowRevision: prepared.revision,
+				expectedLiveRevision: 0,
+				archivePieceIds: [],
+				actor
+			})
+		).toThrow('SHOW_COMPLETED');
+		const database = getDatabase();
+		expect(
+			(
+				database
+					.prepare('SELECT count(*) AS count FROM piece_usage_history WHERE show_id = ?')
+					.get(prepared.showId) as { count: number }
+			).count
+		).toBe(1);
+		expect(database.prepare('SELECT status FROM pieces WHERE id = ?').get('piece-console')).toEqual(
+			{ status: 'archived' }
+		);
+		expect(getPieceUsageContexts(['piece-console'])['piece-console'].sentHistory).toHaveLength(1);
+	});
+
+	it('keeps historical snapshots stable and duplicates them into an editable clean run', () => {
+		const prepared = endedShow();
+		finalizeShow({
+			showId: prepared.showId,
+			commandId: 'freeze',
+			expectedShowRevision: prepared.revision,
+			expectedLiveRevision: 0,
+			archivePieceIds: [],
+			actor
+		});
+		const historical = getShow(prepared.showId)!;
+		getDatabase()
+			.prepare("UPDATE section_categories SET name = 'Später geändert' WHERE id = 'cat-jc'")
+			.run();
+		getDatabase()
+			.prepare("UPDATE pieces SET title = 'Später geändert' WHERE id = 'piece-console'")
+			.run();
+		const unchanged = getShow(prepared.showId)!;
+		expect(unchanged.sections[0].category).toBe(historical.sections[0].category);
+		expect(unchanged.sections[0].usages[0].title).toBe(historical.sections[0].usages[0].title);
+
+		const copy = duplicateCompletedShow(prepared.showId, 'copy-once');
+		expect(duplicateCompletedShow(prepared.showId, 'copy-once').id).toBe(copy.id);
+		expect(getShow(copy.id)).toMatchObject({
+			status: 'draft',
+			startsAtUtc: null,
+			sections: [
+				{
+					category: historical.sections[0].category,
+					usages: [{ status: 'open' }, { status: 'open' }]
+				}
+			]
+		});
+		expect(
+			getDatabase().prepare('SELECT 1 FROM show_finalizations WHERE show_id = ?').get(copy.id)
+		).toBeUndefined();
+		getDatabase()
+			.prepare(
+				`UPDATE piece_usages SET status = 'done'
+				 WHERE show_section_id IN (SELECT id FROM show_sections WHERE show_id = ?)`
+			)
+			.run(copy.id);
+		getDatabase()
+			.prepare(
+				`INSERT INTO show_live_states
+				 (show_id, revision, started_at_utc, ended_at_utc, presentation_revision, updated_at_utc)
+				 VALUES (?, 0, ?, ?, 0, ?)`
+			)
+			.run(
+				copy.id,
+				'2026-10-26T18:00:00.000Z',
+				'2026-10-26T19:00:00.000Z',
+				'2026-10-26T19:00:00.000Z'
+			);
+		finalizeShow({
+			showId: copy.id,
+			commandId: 'finalize-copy',
+			expectedShowRevision: 1,
+			expectedLiveRevision: 0,
+			archivePieceIds: [],
+			actor
+		});
+		expect(getShow(copy.id)?.sections[0].category).toBe(historical.sections[0].category);
+	});
+});
@@ -0,0 +1,210 @@
+import type { AuthUser } from './auth.js';
+import { getDatabase } from './database.js';
+
+export type CompletionCandidate = {
+	pieceId: string;
+	title: string;
+	usageCount: number;
+};
+
+export type CompletionSummary = {
+	doneCount: number;
+	skippedCount: number;
+	openCount: number;
+	candidates: CompletionCandidate[];
+};
+
+export function isShowFinalized(showId: string): boolean {
+	return Boolean(
+		getDatabase().prepare('SELECT 1 FROM show_finalizations WHERE show_id = ?').get(showId)
+	);
+}
+
+export function getCompletionSummary(showId: string): CompletionSummary {
+	const database = getDatabase();
+	if (!database.prepare('SELECT 1 FROM shows WHERE id = ?').get(showId))
+		throw new Error('NOT_FOUND');
+	const counts = database
+		.prepare(
+			`SELECT
+			 sum(CASE WHEN u.status = 'done' THEN 1 ELSE 0 END) AS done_count,
+			 sum(CASE WHEN u.status = 'skipped' THEN 1 ELSE 0 END) AS skipped_count,
+			 sum(CASE WHEN u.status IN ('open', 'current') THEN 1 ELSE 0 END) AS open_count
+			 FROM piece_usages u JOIN show_sections s ON s.id = u.show_section_id
+			 WHERE s.show_id = ? AND s.is_reserve_bank = 0`
+		)
+		.get(showId) as {
+		done_count: number | null;
+		skipped_count: number | null;
+		open_count: number | null;
+	};
+	const candidates = database
+		.prepare(
+			`SELECT u.original_piece_id AS piece_id, p.title, count(*) AS usage_count
+			 FROM piece_usages u
+			 JOIN show_sections s ON s.id = u.show_section_id
+			 JOIN pieces p ON p.id = u.original_piece_id
+			 WHERE s.show_id = ? AND s.is_reserve_bank = 0 AND u.status = 'done'
+			 AND p.status != 'archived' AND p.deleted_at_utc IS NULL
+			 GROUP BY u.original_piece_id, p.title ORDER BY p.title COLLATE NOCASE`
+		)
+		.all(showId) as { piece_id: string; title: string; usage_count: number }[];
+	return {
+		doneCount: counts.done_count ?? 0,
+		skippedCount: counts.skipped_count ?? 0,
+		openCount: counts.open_count ?? 0,
+		candidates: candidates.map((candidate) => ({
+			pieceId: candidate.piece_id,
+			title: candidate.title,
+			usageCount: candidate.usage_count
+		}))
+	};
+}
+
+export function getHistoricalActualDurations(showId: string): Record<string, number> {
+	return Object.fromEntries(
+		(
+			getDatabase()
+				.prepare(
+					`SELECT usage_id, actual_duration_seconds FROM piece_usage_history WHERE show_id = ?`
+				)
+				.all(showId) as { usage_id: string; actual_duration_seconds: number }[]
+		).map((row) => [row.usage_id, row.actual_duration_seconds])
+	);
+}
+
+export function finalizeShow(input: {
+	showId: string;
+	commandId: string;
+	expectedShowRevision: number;
+	expectedLiveRevision: number;
+	archivePieceIds: string[];
+	actor: AuthUser;
+	now?: Date;
+}) {
+	if (!input.commandId || input.commandId.length > 200) throw new Error('INVALID_COMMAND');
+	if (!Number.isInteger(input.expectedShowRevision) || input.expectedShowRevision < 1) {
+		throw new Error('INVALID_REVISION');
+	}
+	if (!Number.isInteger(input.expectedLiveRevision) || input.expectedLiveRevision < 0) {
+		throw new Error('INVALID_REVISION');
+	}
+	const archivePieceIds = [...new Set(input.archivePieceIds.filter(Boolean))];
+	const database = getDatabase();
+	return database.transaction(() => {
+		const existing = database
+			.prepare('SELECT command_id FROM show_finalizations WHERE show_id = ?')
+			.get(input.showId) as { command_id: string } | undefined;
+		if (existing) {
+			if (existing.command_id !== input.commandId) throw new Error('SHOW_COMPLETED');
+			return { duplicate: true };
+		}
+		const state = database
+			.prepare(
+				`SELECT sh.revision AS show_revision, ls.revision AS live_revision, ls.ended_at_utc
+				 FROM shows sh JOIN show_live_states ls ON ls.show_id = sh.id WHERE sh.id = ?`
+			)
+			.get(input.showId) as
+			{ show_revision: number; live_revision: number; ended_at_utc: string | null } | undefined;
+		if (!state) throw new Error('NOT_FOUND');
+		if (!state.ended_at_utc) throw new Error('NOT_ENDED');
+		if (
+			state.show_revision !== input.expectedShowRevision ||
+			state.live_revision !== input.expectedLiveRevision
+		) {
+			throw new Error('CONFLICT');
+		}
+
+		const candidates = getCompletionSummary(input.showId).candidates.map(
+			(candidate) => candidate.pieceId
+		);
+		if (archivePieceIds.some((pieceId) => !candidates.includes(pieceId))) {
+			throw new Error('INVALID_ARCHIVE_SELECTION');
+		}
+		const now = (input.now ?? new Date()).toISOString();
+		database
+			.prepare(
+				`UPDATE live_usage_runs SET ended_at_utc = ? WHERE show_id = ? AND ended_at_utc IS NULL`
+			)
+			.run(now, input.showId);
+		database
+			.prepare(
+				`UPDATE live_show_timer_runs SET ended_at_utc = ? WHERE show_id = ? AND ended_at_utc IS NULL`
+			)
+			.run(now, input.showId);
+		database
+			.prepare(
+				`UPDATE live_section_timer_runs SET ended_at_utc = ?
+				 WHERE ended_at_utc IS NULL AND timer_id IN (
+					SELECT id FROM live_section_timers WHERE show_id = ?
+				 )`
+			)
+			.run(now, input.showId);
+		database
+			.prepare(
+				`UPDATE live_section_timers SET ended_at_utc = ? WHERE show_id = ? AND ended_at_utc IS NULL`
+			)
+			.run(now, input.showId);
+		database
+			.prepare(
+				`UPDATE show_sections SET
+				 category_name_snapshot = COALESCE(category_name_snapshot,
+					(SELECT name FROM section_categories WHERE id = show_sections.category_id)),
+				 category_color_snapshot = COALESCE(category_color_snapshot,
+					(SELECT color FROM section_categories WHERE id = show_sections.category_id))
+				 WHERE show_id = ?`
+			)
+			.run(input.showId);
+
+		database
+			.prepare(
+				`INSERT INTO piece_usage_history (
+				 usage_id, show_id, original_piece_id, show_title_snapshot, usage_title_snapshot,
+				 used_at_utc, actual_duration_seconds
+				 )
+				 SELECT u.id, sh.id, u.original_piece_id, sh.title, u.title_snapshot,
+				 COALESCE(sh.starts_at_utc, ?),
+				 COALESCE((
+					SELECT sum(max(0, CAST((julianday(COALESCE(r.ended_at_utc, ?)) -
+						julianday(r.started_at_utc)) * 86400 AS INTEGER)))
+					FROM live_usage_runs r WHERE r.usage_id = u.id
+				 ), 0)
+				 FROM piece_usages u
+				 JOIN show_sections s ON s.id = u.show_section_id
+				 JOIN shows sh ON sh.id = s.show_id
+				 WHERE sh.id = ? AND s.is_reserve_bank = 0 AND u.status = 'done'
+				 AND u.original_piece_id IS NOT NULL`
+			)
+			.run(now, now, input.showId);
+
+		const archivePiece = database.prepare(
+			`UPDATE pieces SET archived_from_status = status, status = 'archived', revision = revision + 1,
+			 updated_at_utc = ? WHERE id = ? AND status != 'archived' AND deleted_at_utc IS NULL`
+		);
+		for (const pieceId of archivePieceIds) {
+			archivePiece.run(now, pieceId);
+		}
+
+		const updated = database
+			.prepare(
+				`UPDATE shows SET status = 'completed', completed_at_utc = ?, revision = revision + 1,
+				 updated_at_utc = ? WHERE id = ? AND revision = ? AND status != 'completed'`
+			)
+			.run(now, now, input.showId, input.expectedShowRevision);
+		if (updated.changes !== 1) throw new Error('CONFLICT');
+		database
+			.prepare(
+				`INSERT INTO show_finalizations
+				 (show_id, command_id, source_revision, finalized_by_user_id, finalized_at_utc)
+				 VALUES (?, ?, ?, ?, ?)`
+			)
+			.run(input.showId, input.commandId, input.expectedShowRevision, input.actor.id, now);
+		const recordArchivedPiece = database.prepare(
+			'INSERT INTO show_finalization_archived_pieces (show_id, piece_id) VALUES (?, ?)'
+		);
+		for (const pieceId of archivePieceIds) {
+			recordArchivedPiece.run(input.showId, pieceId);
+		}
+		return { duplicate: false };
+	})();
+}
@@ -74,7 +74,8 @@ function completeInput(overrides: Partial<PieceInput> = {}): PieceInput {
 		sources: [
 			{ label: 'Dokumentation', url: 'https://example.com/dokumentation', timecodeSeconds: 75 }
 		],
-		...overrides
+		...overrides,
+		preparationEffort: overrides.preparationEffort ?? null
 	};
 }

@@ -332,11 +333,17 @@ describe('content management', () => {
 			presentationMediaId: selected.id
 		});

+		savePiece(id, source.revision, {
+			...source,
+			status: 'preparing',
+			presentationMode: 'image'
+		});
 		const duplicateId = await duplicatePiece(id);
 		const duplicate = getPiece(duplicateId)!;
 		expect(duplicate.media).toHaveLength(1);
 		expect(duplicate.presentationMediaId).toBe(duplicate.media[0].id);
 		expect(duplicate.presentationMediaId).not.toBe(selected.id);
+		expect(duplicate.presentationMode).toBe('image');

 		const template = savePieceAsTemplate(id, 'Ohne Medienreferenz', 'Nur Inhaltsdaten');
 		const snapshot = getDatabase()
@@ -14,6 +14,7 @@ import {
 export const PIECE_STATUSES = ['inbox', 'preparing', 'ready', 'archived'] as const;
 export type PieceStatus = (typeof PIECE_STATUSES)[number];
 export type EditablePieceStatus = Exclude<PieceStatus, 'archived'>;
+export type PreparationEffort = 'low' | 'medium' | 'high' | null;
 export type TaxonomyKind = 'category' | 'format' | 'topic';

 export type PieceSourceInput = {
@@ -42,6 +43,7 @@ export type PieceInput = {
 	summary: string;
 	formatId: string | null;
 	status: EditablePieceStatus;
+	preparationEffort: PreparationEffort;
 	durationSeconds: number;
 	intro: string;
 	researchText: string;
@@ -82,6 +84,7 @@ export type PieceListItem = {
 	sourceCount: number;
 	mediaId: string | null;
 	isFavorite: boolean;
+	preparationEffort: PreparationEffort;
 };

 export type PieceEditor = Omit<
@@ -198,6 +201,9 @@ function validatePieceInput(input: PieceInput): ValidatedPieceInput {
 	const title = cleanText(input.title, 200, 'title');
 	if (!title) throw new Error('INVALID_TITLE');
 	if (!['inbox', 'preparing', 'ready'].includes(input.status)) throw new Error('INVALID_STATUS');
+	if (![null, 'low', 'medium', 'high'].includes(input.preparationEffort)) {
+		throw new Error('INVALID_PREPARATION_EFFORT');
+	}
 	if (
 		!Number.isInteger(input.durationSeconds) ||
 		input.durationSeconds < 0 ||
@@ -226,7 +232,7 @@ function validatePieceInput(input: PieceInput): ValidatedPieceInput {
 		}
 		return { label, url, timecodeSeconds: source.timecodeSeconds };
 	});
-	if (!['text', 'link', 'video'].includes(input.presentationMode)) {
+	if (!['text', 'image', 'link', 'video'].includes(input.presentationMode)) {
 		throw new Error('INVALID_PRESENTATION');
 	}
 	const sourcePosition = input.presentationSourcePosition;
@@ -236,7 +242,7 @@ function validatePieceInput(input: PieceInput): ValidatedPieceInput {
 	) {
 		throw new Error('INVALID_PRESENTATION');
 	}
-	if (input.presentationMode !== 'text' && sourcePosition === null) {
+	if (['link', 'video'].includes(input.presentationMode) && sourcePosition === null) {
 		throw new Error('INVALID_PRESENTATION');
 	}
 	const presentationImageUrl = cleanText(input.presentationImageUrl, 2_000, 'presentation_image');
@@ -249,12 +255,16 @@ function validatePieceInput(input: PieceInput): ValidatedPieceInput {
 		input.presentationMediaId === undefined
 			? undefined
 			: cleanText(input.presentationMediaId, 100, 'presentation_media') || null;
+	if (input.presentationMode === 'image' && !presentationMediaId) {
+		throw new Error('INVALID_PRESENTATION');
+	}
 	return {
 		title,
 		outputTitle: cleanText(input.outputTitle, 300, 'output_title'),
 		summary: cleanText(input.summary, 2_000, 'summary'),
 		formatId: input.formatId || null,
 		status: input.status,
+		preparationEffort: input.preparationEffort,
 		durationSeconds: input.durationSeconds,
 		intro: cleanText(input.intro, 50_000, 'intro'),
 		researchText: cleanText(input.researchText, 50_000, 'research'),
@@ -317,6 +327,7 @@ type PieceListRow = {
 	source_count: number;
 	media_id: string | null;
 	is_favorite: number;
+	preparation_effort: PreparationEffort;
 };

 export function listPieces(filters: {
@@ -366,6 +377,7 @@ export function listPieces(filters: {
 	const rows = database
 		.prepare(
 			`SELECT p.id, p.title, p.summary, p.status, p.revision, p.duration_seconds, p.is_favorite,
+			 p.preparation_effort,
 			 p.format_id, COALESCE(f.name, 'Ohne Format') AS format,
 			 (SELECT count(*) FROM piece_sources ps WHERE ps.piece_id = p.id) AS source_count,
 			 (SELECT pm.id FROM piece_media pm WHERE pm.piece_id = p.id AND pm.removed_at_utc IS NULL ORDER BY pm.position LIMIT 1) AS media_id
@@ -398,7 +410,8 @@ export function listPieces(filters: {
 		topics: topicStatement.all(row.id) as PieceListItem['topics'],
 		sourceCount: row.source_count,
 		mediaId: row.media_id,
-		isFavorite: row.is_favorite === 1
+		isFavorite: row.is_favorite === 1,
+		preparationEffort: row.preparation_effort
 	}));
 }

@@ -433,14 +446,16 @@ type PieceRow = {
 	updated_at_utc: string;
 	is_favorite: number;
 	presentation_media_id: string | null;
+	preparation_effort: PreparationEffort;
 };

 export function getPiece(id: string): PieceEditor | null {
 	const database = getDatabase();
 	const row = database
 		.prepare(
-			`SELECT id, title, output_title, summary, format_id, status, duration_seconds, intro, research_text,
-			 moderation_notes, interaction_text, transition_text, presentation_text, presentation_mode,
+			`SELECT id, title, output_title, summary, format_id, status, preparation_effort, duration_seconds, intro, research_text,
+			 moderation_notes, interaction_text, transition_text, presentation_text,
+			 CASE WHEN presentation_image_only = 1 THEN 'image' ELSE presentation_mode END AS presentation_mode,
 			 presentation_source_position, presentation_title, presentation_description,
 			 presentation_image_url, presentation_site_name, presentation_provider,
 			 presentation_provider_id, presentation_title_manual, presentation_description_manual,
@@ -460,6 +475,7 @@ export function getPiece(id: string): PieceEditor | null {
 		summary: row.summary,
 		formatId: row.format_id,
 		status: row.status,
+		preparationEffort: row.preparation_effort,
 		durationSeconds: row.duration_seconds,
 		intro: row.intro,
 		researchText: row.research_text,
@@ -612,9 +628,9 @@ export function savePiece(id: string, expectedRevision: number, rawInput: PieceI
 	const save = database.transaction(() => {
 		const result = database
 			.prepare(
-				`UPDATE pieces SET title = ?, output_title = ?, summary = ?, format_id = ?, status = ?, duration_seconds = ?,
+				`UPDATE pieces SET title = ?, output_title = ?, summary = ?, format_id = ?, status = ?, preparation_effort = ?, duration_seconds = ?,
 				 intro = ?, research_text = ?, moderation_notes = ?, interaction_text = COALESCE(?, interaction_text), transition_text = ?, presentation_text = ?,
-				 presentation_mode = ?, presentation_source_position = ?, presentation_title = ?,
+				 presentation_mode = ?, presentation_image_only = ?, presentation_source_position = ?, presentation_title = ?,
 				 presentation_description = ?, presentation_image_url = ?, presentation_site_name = ?,
 				 presentation_provider = ?, presentation_provider_id = ?, presentation_title_manual = ?,
 				 presentation_description_manual = ?, presentation_image_manual = ?,
@@ -628,6 +644,7 @@ export function savePiece(id: string, expectedRevision: number, rawInput: PieceI
 				input.summary,
 				input.formatId,
 				input.status,
+				input.preparationEffort,
 				input.durationSeconds,
 				input.intro,
 				input.researchText,
@@ -635,7 +652,8 @@ export function savePiece(id: string, expectedRevision: number, rawInput: PieceI
 				input.interactionText ?? null,
 				input.transitionText,
 				input.presentationText,
-				input.presentationMode,
+				input.presentationMode === 'image' ? 'text' : input.presentationMode,
+				input.presentationMode === 'image' ? 1 : 0,
 				input.presentationSourcePosition,
 				input.presentationTitle,
 				input.presentationDescription,
@@ -671,6 +689,7 @@ function blankPieceInput(): ValidatedPieceInput {
 		summary: '',
 		formatId: null,
 		status: 'preparing',
+		preparationEffort: null,
 		durationSeconds: 0,
 		intro: '',
 		researchText: '',
@@ -798,6 +817,7 @@ export function savePieceAsTemplate(
 	delete snapshot.updatedAtUtc;
 	delete snapshot.media;
 	delete snapshot.presentationMediaId;
+	if (snapshot.presentationMode === 'image') snapshot.presentationMode = 'text';
 	snapshot.status = 'preparing';
 	const snapshotJson = JSON.stringify(snapshot);
 	const database = getDatabase();
@@ -917,16 +937,16 @@ export async function duplicatePiece(sourceId: string): Promise<string> {
 		database.transaction(() => {
 			database
 				.prepare(
-					`INSERT INTO pieces (id, title, output_title, summary, format_id, status, duration_seconds, intro,
-					 research_text, moderation_notes, interaction_text, transition_text, presentation_text, presentation_mode,
+					`INSERT INTO pieces (id, title, output_title, summary, format_id, status, preparation_effort, duration_seconds, intro,
+					 research_text, moderation_notes, interaction_text, transition_text, presentation_text, presentation_mode, presentation_image_only,
 					 presentation_source_position, presentation_title, presentation_description,
 					 presentation_image_url, presentation_site_name, presentation_provider,
 					 presentation_provider_id, presentation_title_manual,
 					 presentation_description_manual, presentation_image_manual,
 					 presentation_metadata_fetched_at_utc, created_at_utc, updated_at_utc, revision)
 					 VALUES (
-					 ?, ?, ?, ?, ?, 'preparing', ?, ?, ?, ?, ?, ?, ?,
-					 ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1
+					 ?, ?, ?, ?, ?, 'preparing', ?, ?, ?, ?, ?, ?, ?, ?, ?,
+					 ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1
 					 )`
 				)
 				.run(
@@ -935,6 +955,7 @@ export async function duplicatePiece(sourceId: string): Promise<string> {
 					source.outputTitle,
 					source.summary,
 					source.formatId,
+					source.preparationEffort,
 					source.durationSeconds,
 					source.intro,
 					source.researchText,
@@ -942,7 +963,8 @@ export async function duplicatePiece(sourceId: string): Promise<string> {
 					source.interactionText,
 					source.transitionText,
 					source.presentationText,
-					source.presentationMode,
+					source.presentationMode === 'image' ? 'text' : source.presentationMode,
+					source.presentationMode === 'image' ? 1 : 0,
 					source.presentationSourcePosition,
 					source.presentationTitle,
 					source.presentationDescription,
@@ -1,6 +1,6 @@
 import Database from 'better-sqlite3';
 import { execFileSync } from 'node:child_process';
-import { mkdtempSync, rmSync } from 'node:fs';
+import { mkdtempSync, readdirSync, readFileSync, rmSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import path from 'node:path';
 import { afterEach, describe, expect, it, vi } from 'vitest';
@@ -62,7 +62,7 @@ describe('database setup', () => {
 		database.close();

 		expect(counts).toEqual({
-			migrations: 12,
+			migrations: 18,
 			pieces: 6,
 			shows: 2,
 			usages: 5,
@@ -90,4 +90,97 @@ describe('database setup', () => {
 		expect(show.totalDurationSeconds).toBe(5100);
 		expect(show.sections[1].usages.find((usage) => usage.isReserve)?.durationSeconds).toBe(540);
 	});
+
+	it('upgrades existing completed shows into stable finalizations exactly once', () => {
+		const directory = mkdtempSync(path.join(tmpdir(), 'sendewerk-upgrade-test-'));
+		temporaryDirectories.push(directory);
+		const databasePath = path.join(directory, 'test.sqlite');
+		const environment = {
+			...process.env,
+			SENDEWERK_DB_PATH: databasePath,
+			SENDEWERK_UPLOAD_DIR: path.join(directory, 'uploads')
+		};
+		const database = new Database(databasePath);
+		database.pragma('foreign_keys = ON');
+		database.exec(
+			'CREATE TABLE schema_migrations (name TEXT PRIMARY KEY, applied_at_utc TEXT NOT NULL)'
+		);
+		const migrationDirectory = path.resolve('migrations');
+		const oldMigrations = readdirSync(migrationDirectory)
+			.filter(
+				(name) =>
+					/^\d+.+\.sql$/.test(name) && !name.startsWith('0015_') && !name.startsWith('0016_')
+			)
+			.sort();
+		for (const name of oldMigrations) {
+			database.exec(readFileSync(path.join(migrationDirectory, name), 'utf8'));
+			database
+				.prepare('INSERT INTO schema_migrations (name, applied_at_utc) VALUES (?, ?)')
+				.run(name, new Date().toISOString());
+		}
+		database.close();
+		execFileSync(process.execPath, ['scripts/seed.mjs'], { cwd: process.cwd(), env: environment });
+
+		const legacy = new Database(databasePath);
+		legacy.pragma('foreign_keys = ON');
+		const usage = legacy
+			.prepare(
+				`SELECT u.id FROM piece_usages u JOIN show_sections s ON s.id = u.show_section_id
+				 WHERE s.show_id = 'show-october' AND s.is_reserve_bank = 0 LIMIT 1`
+			)
+			.get() as { id: string };
+		legacy.prepare("UPDATE piece_usages SET status = 'done' WHERE id = ?").run(usage.id);
+		legacy.prepare("UPDATE shows SET status = 'completed' WHERE id = 'show-october'").run();
+		const completionMigration = '0015_completion_archive_and_shares.sql';
+		legacy.exec(readFileSync(path.join(migrationDirectory, completionMigration), 'utf8'));
+		legacy
+			.prepare('INSERT INTO schema_migrations (name, applied_at_utc) VALUES (?, ?)')
+			.run(completionMigration, new Date().toISOString());
+		const now = new Date().toISOString();
+		legacy
+			.prepare(
+				`INSERT INTO users (id, email, email_normalized, display_name, password_hash, role,
+				 password_changed_at_utc, created_at_utc, updated_at_utc)
+				 VALUES ('upgrade-barkeeper', 'upgrade@example.test', 'upgrade@example.test',
+				 'Upgrade', 'unused', 'barkeeper', ?, ?, ?)`
+			)
+			.run(now, now, now);
+		legacy
+			.prepare(
+				`INSERT INTO show_shares
+				 (id, show_id, token_hash, scope, password_hash, expires_at_utc, revoked_at_utc,
+				 created_by_user_id, created_at_utc)
+				 VALUES ('upgrade-share', 'show-october', 'upgrade-token-hash', 'rundown', NULL,
+				 NULL, NULL, 'upgrade-barkeeper', ?)`
+			)
+			.run(now);
+		legacy
+			.prepare(
+				`INSERT INTO show_share_sessions (token_hash, share_id, created_at_utc, expires_at_utc)
+				 VALUES ('upgrade-session-hash', 'upgrade-share', ?, ?)`
+			)
+			.run(now, new Date(Date.now() + 60_000).toISOString());
+		legacy.close();
+
+		for (let run = 0; run < 2; run += 1) {
+			execFileSync(process.execPath, ['scripts/migrate.mjs'], {
+				cwd: process.cwd(),
+				env: environment
+			});
+		}
+		const upgraded = new Database(databasePath, { readonly: true });
+		expect(
+			upgraded
+				.prepare(
+					`SELECT
+					 (SELECT count(*) FROM show_finalizations WHERE show_id = 'show-october') AS finalizations,
+					 (SELECT count(*) FROM piece_usage_history WHERE show_id = 'show-october') AS history,
+					 (SELECT count(*) FROM show_shares WHERE id = 'upgrade-share') AS shares,
+					 (SELECT count(*) FROM show_share_sessions WHERE token_hash = 'upgrade-session-hash') AS sessions`
+				)
+				.get()
+		).toEqual({ finalizations: 1, history: 1, shares: 1, sessions: 1 });
+		expect(upgraded.pragma('foreign_key_check')).toEqual([]);
+		upgraded.close();
+	});
 });
@@ -0,0 +1,134 @@
+import { execFileSync } from 'node:child_process';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { closeDatabase, getDatabase } from './database.js';
+import {
+	discardFeedEntries,
+	fetchDueFeeds,
+	fetchFeed,
+	importFeedEntries,
+	listFeedEntries,
+	saveFeedSource
+} from './feeds.js';
+import { getPiece } from './content.js';
+
+vi.mock('node:dns/promises', () => ({
+	lookup: vi.fn(async () => [{ address: '93.184.216.34', family: 4 }])
+}));
+
+const validFeed = `<?xml version="1.0"?><rss version="2.0"><channel><title>Test</title><item>
+<guid>entry-1</guid><title>Ein Beitrag</title><link>https://example.org/post</link>
+<description><![CDATA[<p>Kurz <strong>und</strong> gut.</p><script>evil()</script>]]></description>
+<pubDate>Sat, 24 Oct 2026 12:00:00 GMT</pubDate></item></channel></rss>`;
+
+let directory: string;
+
+beforeEach(() => {
+	directory = mkdtempSync(path.join(tmpdir(), 'sendewerk-feed-test-'));
+	process.env.SENDEWERK_DB_PATH = path.join(directory, 'test.sqlite');
+	process.env.SENDEWERK_UPLOAD_DIR = path.join(directory, 'uploads');
+	execFileSync(process.execPath, ['scripts/migrate.mjs'], { cwd: process.cwd(), env: process.env });
+	execFileSync(process.execPath, ['scripts/seed.mjs'], { cwd: process.cwd(), env: process.env });
+});
+
+afterEach(() => {
+	vi.unstubAllGlobals();
+	closeDatabase();
+	delete process.env.SENDEWERK_DB_PATH;
+	delete process.env.SENDEWERK_UPLOAD_DIR;
+	rmSync(directory, { recursive: true, force: true });
+});
+
+describe('RSS import inbox', () => {
+	it('keeps one entry across fetches and preserves a discard decision', async () => {
+		vi.stubGlobal(
+			'fetch',
+			vi.fn(
+				async () => new Response(validFeed, { headers: { 'content-type': 'application/rss+xml' } })
+			)
+		);
+		const feedId = saveFeedSource(null, {
+			name: 'Feed',
+			url: 'https://example.org/feed.xml',
+			isEnabled: true,
+			refreshIntervalMinutes: 60,
+			defaultCategoryId: null
+		});
+		await fetchFeed(feedId);
+		const [entry] = listFeedEntries();
+		expect(entry.title).toBe('Ein Beitrag');
+		expect(discardFeedEntries([entry.id])).toBe(1);
+		await fetchFeed(feedId);
+		expect(listFeedEntries()).toHaveLength(0);
+		expect(listFeedEntries('discarded')).toHaveLength(1);
+	});
+
+	it('sanitizes foreign HTML and retains the original source on explicit import', async () => {
+		vi.stubGlobal(
+			'fetch',
+			vi.fn(async () => new Response(validFeed))
+		);
+		const feedId = saveFeedSource(null, {
+			name: 'Feed',
+			url: 'https://example.org/feed.xml',
+			isEnabled: true,
+			refreshIntervalMinutes: 60,
+			defaultCategoryId: 'cat-jc'
+		});
+		await fetchFeed(feedId);
+		const [entry] = listFeedEntries();
+		const [pieceId] = importFeedEntries([entry.id], []);
+		const piece = getPiece(pieceId)!;
+		expect(piece.summary).toContain('Kurz und gut.');
+		expect(piece.summary).not.toContain('<script>');
+		expect(piece.sources).toEqual([
+			{ label: 'RSS: Originalbeitrag', url: 'https://example.org/post', timecodeSeconds: null }
+		]);
+		expect(piece.categoryIds).toEqual(['cat-jc']);
+	});
+
+	it('isolates a broken feed while fetching other due feeds', async () => {
+		vi.stubGlobal(
+			'fetch',
+			vi.fn(
+				async (url: URL) => new Response(url.href.includes('broken') ? '<not-feed />' : validFeed)
+			)
+		);
+		saveFeedSource(null, {
+			name: 'A broken',
+			url: 'https://example.org/broken.xml',
+			isEnabled: true,
+			refreshIntervalMinutes: 60,
+			defaultCategoryId: null
+		});
+		saveFeedSource(null, {
+			name: 'B valid',
+			url: 'https://example.org/valid.xml',
+			isEnabled: true,
+			refreshIntervalMinutes: 60,
+			defaultCategoryId: null
+		});
+		await fetchDueFeeds();
+		expect(listFeedEntries()).toHaveLength(1);
+		const errors = getDatabase()
+			.prepare("SELECT count(*) AS count FROM feed_sources WHERE last_error <> ''")
+			.get() as { count: number };
+		expect(errors.count).toBe(1);
+	});
+
+	it('blocks loopback targets before sending a request', async () => {
+		const request = vi.fn();
+		vi.stubGlobal('fetch', request);
+		const feedId = saveFeedSource(null, {
+			name: 'Local',
+			url: 'http://127.0.0.1/feed.xml',
+			isEnabled: false,
+			refreshIntervalMinutes: 60,
+			defaultCategoryId: null
+		});
+		await expect(fetchFeed(feedId)).rejects.toThrow('FEED_BLOCKED');
+		expect(request).not.toHaveBeenCalled();
+	});
+});
@@ -0,0 +1,457 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { lookup } from 'node:dns/promises';
+import { isIP } from 'node:net';
+import sanitizeHtml from 'sanitize-html';
+import { XMLParser } from 'fast-xml-parser';
+import { createPiece, getPiece, savePiece } from './content.js';
+import { getDatabase } from './database.js';
+
+const MAX_FEED_BYTES = 2 * 1024 * 1024;
+const FETCH_TIMEOUT_MS = 8_000;
+const MAX_REDIRECTS = 3;
+
+export type FeedSource = {
+	id: string;
+	name: string;
+	url: string;
+	isEnabled: boolean;
+	refreshIntervalMinutes: number;
+	defaultCategoryId: string | null;
+	lastFetchedAtUtc: string | null;
+	nextFetchAtUtc: string | null;
+	lastError: string;
+};
+
+export type FeedEntry = {
+	id: string;
+	feedId: string;
+	feedName: string;
+	title: string;
+	url: string;
+	summary: string;
+	publishedAtUtc: string | null;
+	status: 'new' | 'imported' | 'discarded';
+	pieceId: string | null;
+	defaultCategoryId: string | null;
+};
+
+function clean(value: unknown, maximum: number) {
+	return String(value ?? '')
+		.trim()
+		.slice(0, maximum);
+}
+
+function validHttpUrl(value: string) {
+	try {
+		const url = new URL(value);
+		return ['http:', 'https:'].includes(url.protocol) && !url.username && !url.password;
+	} catch {
+		return false;
+	}
+}
+
+function privateIpv4(address: string) {
+	const p = address.split('.').map(Number);
+	return (
+		p[0] === 0 ||
+		p[0] === 10 ||
+		p[0] === 127 ||
+		(p[0] === 169 && p[1] === 254) ||
+		(p[0] === 172 && p[1] >= 16 && p[1] <= 31) ||
+		(p[0] === 192 && p[1] === 168) ||
+		p[0] >= 224
+	);
+}
+
+function privateAddress(address: string) {
+	if (isIP(address) === 4) return privateIpv4(address);
+	const value = address.toLowerCase().split('%')[0];
+	if (value === '::' || value === '::1' || value.startsWith('fc') || value.startsWith('fd'))
+		return true;
+	if (/^fe[89ab]/.test(value)) return true;
+	const mapped = value.match(/^::ffff:(\d+\.\d+\.\d+\.\d+)$/)?.[1];
+	return mapped ? privateIpv4(mapped) : false;
+}
+
+async function assertPublic(url: URL) {
+	if (!validHttpUrl(url.href) || (url.port && !['80', '443'].includes(url.port)))
+		throw new Error('FEED_BLOCKED');
+	const hostname = url.hostname.replace(/^\[|\]$/g, '');
+	if (hostname === 'localhost' || hostname.endsWith('.localhost')) throw new Error('FEED_BLOCKED');
+	const addresses = isIP(hostname)
+		? [{ address: hostname }]
+		: await lookup(hostname, { all: true, verbatim: true });
+	if (!addresses.length || addresses.some((entry) => privateAddress(entry.address)))
+		throw new Error('FEED_BLOCKED');
+}
+
+async function fetchXml(
+	input: string,
+	headers: Record<string, string>,
+	redirects = 0
+): Promise<{ xml: string; etag: string; lastModified: string; unchanged: boolean }> {
+	const url = new URL(input);
+	await assertPublic(url);
+	const response = await fetch(url, {
+		headers: {
+			Accept: 'application/rss+xml, application/atom+xml, application/xml, text/xml',
+			...headers
+		},
+		redirect: 'manual',
+		signal: AbortSignal.timeout(FETCH_TIMEOUT_MS)
+	});
+	if ([301, 302, 303, 307, 308].includes(response.status)) {
+		if (redirects >= MAX_REDIRECTS) throw new Error('FEED_REDIRECT');
+		const location = response.headers.get('location');
+		if (!location) throw new Error('FEED_FETCH');
+		return fetchXml(new URL(location, url).href, headers, redirects + 1);
+	}
+	if (response.status === 304)
+		return {
+			xml: '',
+			etag: headers['If-None-Match'] ?? '',
+			lastModified: headers['If-Modified-Since'] ?? '',
+			unchanged: true
+		};
+	if (!response.ok) throw new Error(`FEED_HTTP_${response.status}`);
+	const declared = Number(response.headers.get('content-length') ?? 0);
+	if (declared > MAX_FEED_BYTES) throw new Error('FEED_TOO_LARGE');
+	const buffer = Buffer.from(await response.arrayBuffer());
+	if (buffer.length > MAX_FEED_BYTES) throw new Error('FEED_TOO_LARGE');
+	return {
+		xml: buffer.toString('utf8'),
+		etag: response.headers.get('etag') ?? '',
+		lastModified: response.headers.get('last-modified') ?? '',
+		unchanged: false
+	};
+}
+
+function values<T>(value: T | T[] | undefined): T[] {
+	return value === undefined ? [] : Array.isArray(value) ? value : [value];
+}
+
+function textFrom(value: unknown): string {
+	if (typeof value === 'string' || typeof value === 'number') return String(value);
+	if (value && typeof value === 'object') {
+		const record = value as Record<string, unknown>;
+		return textFrom(record['#text'] ?? record.__cdata ?? '');
+	}
+	return '';
+}
+
+function entryLink(value: unknown) {
+	for (const link of values(
+		value as Record<string, unknown> | Record<string, unknown>[] | string | undefined
+	)) {
+		if (typeof link === 'string') return link;
+		if (link && typeof link === 'object') {
+			const href = clean((link as Record<string, unknown>)['@_href'], 2_000);
+			const rel = clean((link as Record<string, unknown>)['@_rel'], 30);
+			if (href && (!rel || rel === 'alternate')) return href;
+		}
+	}
+	return '';
+}
+
+function parseDate(value: unknown) {
+	const raw = textFrom(value);
+	if (!raw) return null;
+	const date = new Date(raw);
+	return Number.isNaN(date.valueOf()) ? null : date.toISOString();
+}
+
+function parseFeed(xml: string) {
+	let document: Record<string, unknown>;
+	try {
+		document = new XMLParser({
+			ignoreAttributes: false,
+			processEntities: false,
+			trimValues: true
+		}).parse(xml) as Record<string, unknown>;
+	} catch {
+		throw new Error('INVALID_FEED');
+	}
+	const rssChannel = (document.rss as Record<string, unknown> | undefined)?.channel as
+		Record<string, unknown> | undefined;
+	const atom = document.feed as Record<string, unknown> | undefined;
+	if (!rssChannel && !atom) throw new Error('INVALID_FEED');
+	const rawEntries = values(
+		(rssChannel?.item ?? atom?.entry) as
+			Record<string, unknown> | Record<string, unknown>[] | undefined
+	);
+	return rawEntries.slice(0, 200).flatMap((entry) => {
+		const title = clean(textFrom(entry.title), 300);
+		const url = clean(entryLink(entry.link) || textFrom(entry.link), 2_000);
+		if (!title || !validHttpUrl(url)) return [];
+		const guid = clean(textFrom(entry.guid ?? entry.id), 2_000);
+		const externalId = guid || createHash('sha256').update(url).digest('hex');
+		const rawSummary = textFrom(entry.description ?? entry.summary ?? entry.content);
+		const summary = clean(
+			sanitizeHtml(rawSummary, { allowedTags: [], allowedAttributes: {} }),
+			5_000
+		);
+		return [
+			{
+				externalId,
+				title,
+				url,
+				summary,
+				publishedAtUtc: parseDate(entry.pubDate ?? entry.published ?? entry.updated)
+			}
+		];
+	});
+}
+
+export function listFeedSources(): FeedSource[] {
+	return (
+		getDatabase()
+			.prepare(
+				`SELECT id, name, url, is_enabled, refresh_interval_minutes,
+		default_category_id, last_fetched_at_utc, next_fetch_at_utc, last_error FROM feed_sources ORDER BY name`
+			)
+			.all() as Array<Record<string, unknown>>
+	).map((row) => ({
+		id: String(row.id),
+		name: String(row.name),
+		url: String(row.url),
+		isEnabled: row.is_enabled === 1,
+		refreshIntervalMinutes: Number(row.refresh_interval_minutes),
+		defaultCategoryId: row.default_category_id ? String(row.default_category_id) : null,
+		lastFetchedAtUtc: row.last_fetched_at_utc ? String(row.last_fetched_at_utc) : null,
+		nextFetchAtUtc: row.next_fetch_at_utc ? String(row.next_fetch_at_utc) : null,
+		lastError: String(row.last_error)
+	}));
+}
+
+export function saveFeedSource(
+	id: string | null,
+	input: {
+		name: string;
+		url: string;
+		isEnabled: boolean;
+		refreshIntervalMinutes: number;
+		defaultCategoryId: string | null;
+	}
+) {
+	const name = clean(input.name, 120);
+	const url = clean(input.url, 2_000);
+	if (
+		!name ||
+		!validHttpUrl(url) ||
+		!Number.isInteger(input.refreshIntervalMinutes) ||
+		input.refreshIntervalMinutes < 15 ||
+		input.refreshIntervalMinutes > 10080
+	)
+		throw new Error('INVALID_FEED');
+	const database = getDatabase();
+	if (
+		input.defaultCategoryId &&
+		!database.prepare('SELECT 1 FROM section_categories WHERE id = ?').get(input.defaultCategoryId)
+	)
+		throw new Error('INVALID_TAXONOMY');
+	const now = new Date().toISOString();
+	if (!id) {
+		id = randomUUID();
+		database
+			.prepare(
+				`INSERT INTO feed_sources (id, name, url, is_enabled, refresh_interval_minutes,
+			default_category_id, next_fetch_at_utc, created_at_utc, updated_at_utc) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
+			)
+			.run(
+				id,
+				name,
+				url,
+				input.isEnabled ? 1 : 0,
+				input.refreshIntervalMinutes,
+				input.defaultCategoryId,
+				input.isEnabled ? now : null,
+				now,
+				now
+			);
+	} else {
+		const result = database
+			.prepare(
+				`UPDATE feed_sources SET name = ?, url = ?, is_enabled = ?, refresh_interval_minutes = ?,
+			default_category_id = ?, next_fetch_at_utc = CASE WHEN ? = 1 THEN COALESCE(next_fetch_at_utc, ?) ELSE NULL END,
+			updated_at_utc = ? WHERE id = ?`
+			)
+			.run(
+				name,
+				url,
+				input.isEnabled ? 1 : 0,
+				input.refreshIntervalMinutes,
+				input.defaultCategoryId,
+				input.isEnabled ? 1 : 0,
+				now,
+				now,
+				id
+			);
+		if (!result.changes) throw new Error('NOT_FOUND');
+	}
+	return id;
+}
+
+export function deleteFeedSource(id: string) {
+	if (!getDatabase().prepare('DELETE FROM feed_sources WHERE id = ?').run(id).changes)
+		throw new Error('NOT_FOUND');
+}
+
+export function listFeedEntries(status: 'new' | 'imported' | 'discarded' = 'new'): FeedEntry[] {
+	return (
+		getDatabase()
+			.prepare(
+				`SELECT e.id, e.feed_id, f.name AS feed_name, e.title, e.url, e.summary,
+		e.published_at_utc, e.status, e.piece_id, f.default_category_id FROM feed_entries e
+		JOIN feed_sources f ON f.id = e.feed_id WHERE e.status = ? ORDER BY COALESCE(e.published_at_utc, e.first_seen_at_utc) DESC`
+			)
+			.all(status) as Array<Record<string, unknown>>
+	).map((row) => ({
+		id: String(row.id),
+		feedId: String(row.feed_id),
+		feedName: String(row.feed_name),
+		title: String(row.title),
+		url: String(row.url),
+		summary: String(row.summary),
+		publishedAtUtc: row.published_at_utc ? String(row.published_at_utc) : null,
+		status: row.status as FeedEntry['status'],
+		pieceId: row.piece_id ? String(row.piece_id) : null,
+		defaultCategoryId: row.default_category_id ? String(row.default_category_id) : null
+	}));
+}
+
+export async function fetchFeed(feedId: string) {
+	const database = getDatabase();
+	const feed = database.prepare('SELECT * FROM feed_sources WHERE id = ?').get(feedId) as
+		Record<string, unknown> | undefined;
+	if (!feed) throw new Error('NOT_FOUND');
+	const now = new Date();
+	try {
+		const response = await fetchXml(String(feed.url), {
+			...(feed.etag ? { 'If-None-Match': String(feed.etag) } : {}),
+			...(feed.last_modified ? { 'If-Modified-Since': String(feed.last_modified) } : {})
+		});
+		let inserted = 0;
+		if (!response.unchanged) {
+			const add =
+				database.prepare(`INSERT INTO feed_entries (id, feed_id, external_id, title, url, summary,
+				published_at_utc, first_seen_at_utc, updated_at_utc) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+				ON CONFLICT(feed_id, external_id) DO UPDATE SET title = excluded.title, url = excluded.url,
+				summary = excluded.summary, published_at_utc = excluded.published_at_utc, updated_at_utc = excluded.updated_at_utc`);
+			for (const entry of parseFeed(response.xml)) {
+				const existed = database
+					.prepare('SELECT 1 FROM feed_entries WHERE feed_id = ? AND external_id = ?')
+					.get(feedId, entry.externalId);
+				add.run(
+					randomUUID(),
+					feedId,
+					entry.externalId,
+					entry.title,
+					entry.url,
+					entry.summary,
+					entry.publishedAtUtc,
+					now.toISOString(),
+					now.toISOString()
+				);
+				if (!existed) inserted += 1;
+			}
+		}
+		const next = new Date(
+			now.getTime() + Number(feed.refresh_interval_minutes) * 60_000
+		).toISOString();
+		database
+			.prepare(
+				`UPDATE feed_sources SET etag = ?, last_modified = ?, last_fetched_at_utc = ?,
+			next_fetch_at_utc = ?, last_error = '', updated_at_utc = ? WHERE id = ?`
+			)
+			.run(
+				response.etag,
+				response.lastModified,
+				now.toISOString(),
+				next,
+				now.toISOString(),
+				feedId
+			);
+		return { inserted, unchanged: response.unchanged };
+	} catch (cause) {
+		const message = cause instanceof Error ? cause.message.slice(0, 500) : 'FEED_FETCH';
+		const next = new Date(
+			now.getTime() + Number(feed.refresh_interval_minutes) * 60_000
+		).toISOString();
+		database
+			.prepare(
+				'UPDATE feed_sources SET last_fetched_at_utc = ?, next_fetch_at_utc = ?, last_error = ?, updated_at_utc = ? WHERE id = ?'
+			)
+			.run(now.toISOString(), next, message, now.toISOString(), feedId);
+		throw cause;
+	}
+}
+
+export async function fetchDueFeeds() {
+	const rows = getDatabase()
+		.prepare(
+			`SELECT id FROM feed_sources WHERE is_enabled = 1
+		AND (next_fetch_at_utc IS NULL OR next_fetch_at_utc <= ?) ORDER BY next_fetch_at_utc LIMIT 10`
+		)
+		.all(new Date().toISOString()) as { id: string }[];
+	for (const row of rows) await fetchFeed(row.id).catch(() => undefined);
+}
+
+export function importFeedEntries(entryIds: string[], categoryIds: string[]) {
+	const database = getDatabase();
+	const categories = [...new Set(categoryIds.filter(Boolean))];
+	if (categories.length > 20) throw new Error('INVALID_TAXONOMY');
+	for (const category of categories)
+		if (!database.prepare('SELECT 1 FROM section_categories WHERE id = ?').get(category))
+			throw new Error('INVALID_TAXONOMY');
+	return database.transaction(() =>
+		entryIds.map((entryId) => {
+			const entry = database
+				.prepare(
+					`SELECT e.*, f.default_category_id FROM feed_entries e JOIN feed_sources f ON f.id = e.feed_id
+			WHERE e.id = ? AND e.status = 'new'`
+				)
+				.get(entryId) as Record<string, unknown> | undefined;
+			if (!entry) throw new Error('NOT_FOUND');
+			const pieceId = createPiece('blank');
+			const piece = getPiece(pieceId)!;
+			const assigned = categories.length
+				? categories
+				: entry.default_category_id
+					? [String(entry.default_category_id)]
+					: [];
+			savePiece(pieceId, piece.revision, {
+				...piece,
+				title: String(entry.title),
+				summary: String(entry.summary),
+				status: 'inbox',
+				categoryIds: assigned,
+				sources: [{ label: 'RSS: Originalbeitrag', url: String(entry.url), timecodeSeconds: null }]
+			});
+			database
+				.prepare(
+					"UPDATE feed_entries SET status = 'imported', piece_id = ?, updated_at_utc = ? WHERE id = ?"
+				)
+				.run(pieceId, new Date().toISOString(), entryId);
+			return pieceId;
+		})
+	)();
+}
+
+export function discardFeedEntries(entryIds: string[]) {
+	const database = getDatabase();
+	const update = database.prepare(
+		"UPDATE feed_entries SET status = 'discarded', updated_at_utc = ? WHERE id = ? AND status = 'new'"
+	);
+	const now = new Date().toISOString();
+	return database.transaction(() =>
+		entryIds.reduce((count, id) => count + update.run(now, id).changes, 0)
+	)();
+}
+
+let schedulerStarted = false;
+export function startFeedScheduler() {
+	if (schedulerStarted || process.env.NODE_ENV === 'test') return;
+	schedulerStarted = true;
+	void fetchDueFeeds();
+	setInterval(() => void fetchDueFeeds(), 60_000).unref();
+}
@@ -40,7 +40,7 @@ afterEach(() => {
 });

 describe('live mode', () => {
-	it('persists a frozen section countdown across usage changes and reloads', () => {
+	it('keeps elapsed section time while applying an updated section plan', () => {
 		getDatabase()
 			.prepare(
 				"UPDATE show_sections SET explicit_duration_seconds = 300 WHERE id = 'section-stories'"
@@ -68,7 +68,7 @@ describe('live mode', () => {
 		live = getLiveView('show-october', new Date('2026-10-23T18:04:00.000Z'));
 		expect(live.current?.id).toBe('usage-effects');
 		expect(live.sectionTimer).toMatchObject({
-			plannedDurationSeconds: 300,
+			plannedDurationSeconds: 600,
 			elapsedSeconds: 240
 		});
 		completeCurrent(
@@ -197,10 +197,7 @@ function showTimerRunning(database: Database.Database, showId: string) {
 	);
 }

-function elapsedRuns(
-	runs: { started_at_utc: string; ended_at_utc: string | null }[],
-	now: string
-) {
+function elapsedRuns(runs: { started_at_utc: string; ended_at_utc: string | null }[], now: string) {
 	return runs.reduce(
 		(total, run) =>
 			total +
@@ -236,9 +233,7 @@ function resumeSectionTimerRun(database: Database.Database, showId: string, now:
 		.get(showId) as { id: string } | undefined;
 	if (!timer) return;
 	const running = database
-		.prepare(
-			'SELECT 1 FROM live_section_timer_runs WHERE timer_id = ? AND ended_at_utc IS NULL'
-		)
+		.prepare('SELECT 1 FROM live_section_timer_runs WHERE timer_id = ? AND ended_at_utc IS NULL')
 		.get(timer.id);
 	if (!running) {
 		database
@@ -266,10 +261,22 @@ function syncSectionTimer(
 	if (!section) throw new Error('NOT_FOUND');
 	const active = database
 		.prepare(
-			'SELECT id, section_id FROM live_section_timers WHERE show_id = ? AND ended_at_utc IS NULL'
+			`SELECT id, section_id, planned_duration_seconds
+			 FROM live_section_timers WHERE show_id = ? AND ended_at_utc IS NULL`
 		)
-		.get(showId) as { id: string; section_id: string } | undefined;
-	if (active?.section_id === section.id) return;
+		.get(showId) as
+		| { id: string; section_id: string; planned_duration_seconds: number }
+		| undefined;
+	if (active?.section_id === section.id) {
+		if (!section.explicit_duration_seconds || section.explicit_duration_seconds <= 0) {
+			closeSectionTimer(database, showId, now);
+		} else if (active.planned_duration_seconds !== section.explicit_duration_seconds) {
+			database
+				.prepare('UPDATE live_section_timers SET planned_duration_seconds = ? WHERE id = ?')
+				.run(section.explicit_duration_seconds, active.id);
+		}
+		return;
+	}
 	if (active) closeSectionTimer(database, showId, now);
 	if (!section.explicit_duration_seconds || section.explicit_duration_seconds <= 0) return;
 	const timerId = randomUUID();
@@ -335,6 +342,9 @@ function executeCommand(
 		const show = database.prepare('SELECT status FROM shows WHERE id = ?').get(showId) as {
 			status: string;
 		};
+		if (database.prepare('SELECT 1 FROM show_finalizations WHERE show_id = ?').get(showId)) {
+			throw new Error('SHOW_COMPLETED');
+		}
 		if (show.status === 'completed' && !allowCompleted) throw new Error('SHOW_COMPLETED');
 		if (state.revision !== expectedRevision) throw new Error('CONFLICT');
 		operation(database, state, now);
@@ -643,9 +653,7 @@ export function resetSectionTimer(
 					`SELECT section_id, planned_duration_seconds
 					 FROM live_section_timers WHERE show_id = ? AND ended_at_utc IS NULL`
 				)
-				.get(showId) as
-				| { section_id: string; planned_duration_seconds: number }
-				| undefined;
+				.get(showId) as { section_id: string; planned_duration_seconds: number } | undefined;
 			if (!timer) throw new Error('NO_SECTION_TIMER');
 			const running = showTimerRunning(database, showId);
 			closeSectionTimer(database, showId, now);
@@ -741,12 +749,10 @@ export function endLive(
 				)
 				.run(now, showId);
 			database
-				.prepare(
-					`UPDATE show_live_states SET ended_at_utc = ? WHERE show_id = ?`
-				)
+				.prepare(`UPDATE show_live_states SET ended_at_utc = ? WHERE show_id = ?`)
 				.run(now, showId);
 			database
-				.prepare(`UPDATE shows SET status = 'completed', revision = revision + 1, updated_at_utc = ? WHERE id = ?`)
+				.prepare(`UPDATE shows SET revision = revision + 1, updated_at_utc = ? WHERE id = ?`)
 				.run(now, showId);
 		},
 		nowValue
@@ -766,7 +772,11 @@ export function resumeEndedLive(
 		'resume-ended',
 		(database, state, now) => {
 			if (!state.ended_at_utc) throw new Error('NOT_ENDED');
-			database.prepare(`UPDATE shows SET status = 'live', revision = revision + 1, updated_at_utc = ? WHERE id = ?`).run(now, showId);
+			database
+				.prepare(
+					`UPDATE shows SET status = 'live', revision = revision + 1, updated_at_utc = ? WHERE id = ?`
+				)
+				.run(now, showId);
 			database
 				.prepare('UPDATE show_live_states SET ended_at_utc = NULL WHERE show_id = ?')
 				.run(showId);
@@ -815,7 +825,11 @@ export function startNewLiveRun(
 					 WHERE show_id = ?`
 				)
 				.run(now, showId);
-			database.prepare(`UPDATE shows SET status = 'live', revision = revision + 1, updated_at_utc = ? WHERE id = ?`).run(now, showId);
+			database
+				.prepare(
+					`UPDATE shows SET status = 'live', revision = revision + 1, updated_at_utc = ? WHERE id = ?`
+				)
+				.run(now, showId);
 			openShowTimerRun(database, showId, now);
 			const target = orderedUsages(database, showId).find((usage) => usage.status === 'open');
 			if (target) activateUsage(database, showId, target.id, now);
@@ -1124,7 +1138,8 @@ function getPresentationViewForShow(showId: string): PresentationView {
 	const usage = database
 		.prepare(
 			`SELECT u.title_snapshot, u.output_title_snapshot, u.presentation_snapshot,
-			 u.presentation_mode_snapshot, u.presentation_source_label_snapshot,
+			 CASE WHEN u.presentation_image_only_snapshot = 1 THEN 'image' ELSE u.presentation_mode_snapshot END AS presentation_mode_snapshot,
+			 u.presentation_source_label_snapshot,
 			 u.presentation_source_url_snapshot, u.presentation_source_timecode_snapshot,
 			 u.presentation_title_meta_snapshot, u.presentation_description_snapshot,
 			 u.presentation_image_url_snapshot, u.presentation_site_name_snapshot,
@@ -8,7 +8,7 @@ import image from 'metascraper-image';
 import publisher from 'metascraper-publisher';
 import title from 'metascraper-title';

-export type PresentationMode = 'text' | 'link' | 'video';
+export type PresentationMode = 'text' | 'image' | 'link' | 'video';
 export type VideoProvider = 'youtube' | 'tiktok';

 export type PresentationMetadata = {
@@ -0,0 +1,266 @@
+import { execFileSync } from 'node:child_process';
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import type { AuthUser } from './auth.js';
+import { finalizeShow } from './completion.js';
+import { closeDatabase, getDatabase } from './database.js';
+import {
+	authenticateShare,
+	createShare,
+	deleteShare,
+	getSharedMedia,
+	getSharedShow,
+	revokeShare,
+	updateShare
+} from './shares.js';
+import { addPieceUsage, addShowSection, createShow } from './shows.js';
+
+let directory: string;
+const actor: AuthUser = {
+	id: 'share-actor',
+	email: 'share@example.test',
+	displayName: 'Freigabe Test',
+	role: 'barkeeper',
+	lockedAtUtc: null
+};
+
+beforeEach(() => {
+	directory = mkdtempSync(path.join(tmpdir(), 'sendewerk-shares-test-'));
+	process.env.SENDEWERK_DB_PATH = path.join(directory, 'test.sqlite');
+	process.env.SENDEWERK_UPLOAD_DIR = path.join(directory, 'uploads');
+	execFileSync(process.execPath, ['scripts/migrate.mjs'], { cwd: process.cwd(), env: process.env });
+	execFileSync(process.execPath, ['scripts/seed.mjs'], { cwd: process.cwd(), env: process.env });
+	const now = new Date().toISOString();
+	getDatabase()
+		.prepare(
+			`INSERT INTO users (id, email, email_normalized, display_name, password_hash, role,
+			 password_changed_at_utc, created_at_utc, updated_at_utc)
+			 VALUES (?, ?, ?, ?, 'unused', 'barkeeper', ?, ?, ?)`
+		)
+		.run(actor.id, actor.email, actor.email, actor.displayName, now, now, now);
+});
+
+afterEach(() => {
+	closeDatabase();
+	delete process.env.SENDEWERK_DB_PATH;
+	delete process.env.SENDEWERK_UPLOAD_DIR;
+	rmSync(directory, { recursive: true, force: true });
+});
+
+function finalizedShow() {
+	const created = createShow({
+		title: 'Freigegebene Sendung',
+		startsAtUtc: null,
+		templateId: null
+	});
+	const section = addShowSection(created.id, created.revision, {
+		name: 'Freigabeblock',
+		categoryId: null,
+		explicitDurationSeconds: null
+	});
+	const usage = addPieceUsage(created.id, section.revision, {
+		pieceId: 'piece-console',
+		sectionId: section.id
+	});
+	const reserveUsage = addPieceUsage(created.id, usage.revision, {
+		pieceId: 'piece-console',
+		sectionId: null
+	});
+	const database = getDatabase();
+	database.prepare("UPDATE piece_usages SET status = 'done' WHERE id = ?").run(usage.id);
+	database
+		.prepare(
+			`INSERT INTO show_live_states
+			 (show_id, revision, started_at_utc, ended_at_utc, presentation_revision, updated_at_utc)
+			 VALUES (?, 0, ?, ?, 0, ?)`
+		)
+		.run(
+			created.id,
+			'2026-10-25T18:00:00.000Z',
+			'2026-10-25T19:00:00.000Z',
+			'2026-10-25T19:00:00.000Z'
+		);
+	finalizeShow({
+		showId: created.id,
+		commandId: `finalize-${created.id}`,
+		expectedShowRevision: reserveUsage.revision,
+		expectedLiveRevision: 0,
+		archivePieceIds: [],
+		actor
+	});
+	return { showId: created.id, usageId: usage.id, reserveUsageId: reserveUsage.id };
+}
+
+describe('show shares', () => {
+	it('shares an unfinished show and keeps its current plan visible', async () => {
+		const created = createShow({
+			title: 'Offene Freigabe',
+			startsAtUtc: null,
+			templateId: null
+		});
+		const shared = await createShare(actor, {
+			showId: created.id,
+			scope: 'rundown',
+			password: '',
+			expiresAtUtc: null
+		});
+		const initiallyEmpty = getSharedShow(shared.token);
+		expect(initiallyEmpty.status).toBe('authorized');
+		if (initiallyEmpty.status !== 'authorized') throw new Error('share unavailable');
+		expect(initiallyEmpty.share.isCompleted).toBe(false);
+		expect(initiallyEmpty.share.sections).toEqual([]);
+
+		const section = addShowSection(created.id, created.revision, {
+			name: 'Nachträglich geplant',
+			categoryId: null,
+			explicitDurationSeconds: null
+		});
+		addPieceUsage(created.id, section.revision, {
+			pieceId: 'piece-console',
+			sectionId: section.id
+		});
+		const updatedPlan = getSharedShow(shared.token);
+		expect(updatedPlan.status).toBe('authorized');
+		if (updatedPlan.status !== 'authorized') throw new Error('share unavailable');
+		expect(updatedPlan.share.sections[0]).toMatchObject({
+			name: 'Nachträglich geplant',
+			usages: [{ title: 'Die kleine Konsole mit dem großen Dreh' }]
+		});
+
+		await updateShare(actor, shared.id, {
+			scope: 'moderation',
+			passwordMode: 'replace',
+			password: 'neues-freigabe-passwort',
+			expiresAtUtc: null
+		});
+		expect(getSharedShow(shared.token).status).toBe('password');
+		const session = await authenticateShare(shared.token, 'neues-freigabe-passwort', '192.0.2.20');
+		expect(getSharedShow(shared.token, session.token).status).toBe('authorized');
+		deleteShare(actor, shared.id, created.id);
+		expect(getSharedShow(shared.token, session.token).status).toBe('unavailable');
+	});
+
+	it('projects exactly the selected information scope', async () => {
+		const prepared = finalizedShow();
+		const rundown = await createShare(actor, {
+			showId: prepared.showId,
+			scope: 'rundown',
+			password: '',
+			expiresAtUtc: null
+		});
+		const basic = getSharedShow(rundown.token);
+		expect(basic.status).toBe('authorized');
+		if (basic.status !== 'authorized') throw new Error('share unavailable');
+		const basicUsage = basic.share.sections[0].usages[0];
+		expect(basicUsage).not.toHaveProperty('moderationHtml');
+		expect(basicUsage).not.toHaveProperty('researchHtml');
+		expect(JSON.stringify(basic)).not.toContain('originalPieceId');
+		expect(JSON.stringify(basic)).not.toContain(prepared.showId);
+		getDatabase()
+			.prepare(
+				`INSERT INTO usage_tool_snapshots
+				 (id, usage_id, original_tool_id, name, start_url, work_url, note, position)
+				 VALUES ('private-share-tool', ?, NULL, 'Schnittwerkzeug',
+				 'https://private.example/start', 'https://private.example/work?secret=1',
+				 'Freigegebene Werkzeugnotiz', 0)`
+			)
+			.run(prepared.usageId);
+
+		const research = await createShare(actor, {
+			showId: prepared.showId,
+			scope: 'research',
+			password: '',
+			expiresAtUtc: null
+		});
+		const full = getSharedShow(research.token);
+		expect(full.status).toBe('authorized');
+		if (full.status !== 'authorized') throw new Error('share unavailable');
+		expect(full.share.sections[0].usages[0]).toHaveProperty('moderationHtml');
+		expect(full.share.sections[0].usages[0]).toHaveProperty('researchHtml');
+		expect(full.share.sections[0].usages[0]).not.toHaveProperty('ownNotesHtml');
+		expect(JSON.stringify(full)).not.toContain('private.example');
+		expect(JSON.stringify(full)).toContain('Freigegebene Werkzeugnotiz');
+	});
+
+	it('enforces password, expiry and revocation for page and direct media access', async () => {
+		const prepared = finalizedShow();
+		const database = getDatabase();
+		mkdirSync(process.env.SENDEWERK_UPLOAD_DIR!, { recursive: true });
+		writeFileSync(path.join(process.env.SENDEWERK_UPLOAD_DIR!, 'shared.png'), Buffer.from('image'));
+		database
+			.prepare(
+				`INSERT INTO piece_media
+				 (id, piece_id, storage_name, original_name, mime_type, byte_size, alt_text, position, created_at_utc)
+				 VALUES ('share-media', 'piece-console', 'shared.png', 'shared.png', 'image/png', 5, 'Freigegeben', 99, ?)`
+			)
+			.run(new Date().toISOString());
+		database
+			.prepare(
+				`INSERT INTO usage_media_snapshots
+				 (id, usage_id, original_media_id, alt_text, position, is_presentation)
+				 VALUES ('share-snapshot', ?, 'share-media', 'Freigegeben', 99, 1)`
+			)
+			.run(prepared.usageId);
+		database
+			.prepare(
+				`INSERT INTO usage_media_snapshots
+				 (id, usage_id, original_media_id, alt_text, position, is_presentation)
+				 VALUES ('reserve-share-snapshot', ?, 'share-media', 'Private Reserve', 99, 1)`
+			)
+			.run(prepared.reserveUsageId);
+		const created = await createShare(actor, {
+			showId: prepared.showId,
+			scope: 'research',
+			password: 'ein-sicheres-passwort',
+			expiresAtUtc: new Date(Date.now() + 60_000).toISOString()
+		});
+		expect(getSharedShow(created.token).status).toBe('password');
+		expect(getSharedShow(created.token)).not.toHaveProperty('share');
+		expect(await getSharedMedia(created.token, undefined, 'share-snapshot')).toBeNull();
+		await expect(authenticateShare(created.token, 'falsch', '127.0.0.1')).rejects.toThrow(
+			'INVALID_PASSWORD'
+		);
+		const session = await authenticateShare(created.token, 'ein-sicheres-passwort', '127.0.0.1');
+		expect(getSharedShow(created.token, session.token).status).toBe('authorized');
+		expect((await getSharedMedia(created.token, session.token, 'share-snapshot'))?.byteSize).toBe(
+			5
+		);
+		expect(await getSharedMedia(created.token, session.token, 'foreign-media')).toBeNull();
+		expect(await getSharedMedia(created.token, session.token, 'reserve-share-snapshot')).toBeNull();
+		revokeShare(actor, created.id);
+		expect(getSharedShow(created.token, session.token).status).toBe('unavailable');
+		expect(await getSharedMedia(created.token, session.token, 'share-snapshot')).toBeNull();
+
+		const expired = await createShare(actor, {
+			showId: prepared.showId,
+			scope: 'rundown',
+			password: '',
+			expiresAtUtc: new Date(Date.now() + 60_000).toISOString()
+		});
+		database
+			.prepare('UPDATE show_shares SET expires_at_utc = ? WHERE id = ?')
+			.run('2000-01-01T00:00:00.000Z', expired.id);
+		expect(getSharedShow(expired.token).status).toBe('unavailable');
+		expect(await getSharedMedia(expired.token, undefined, 'share-snapshot')).toBeNull();
+	});
+
+	it('limits repeated password attempts per share', async () => {
+		const prepared = finalizedShow();
+		const created = await createShare(actor, {
+			showId: prepared.showId,
+			scope: 'rundown',
+			password: 'noch-ein-sicheres-passwort',
+			expiresAtUtc: null
+		});
+		for (let attempt = 0; attempt < 5; attempt += 1) {
+			await expect(authenticateShare(created.token, 'falsch', '192.0.2.10')).rejects.toThrow(
+				'INVALID_PASSWORD'
+			);
+		}
+		await expect(
+			authenticateShare(created.token, 'noch-ein-sicheres-passwort', '192.0.2.10')
+		).rejects.toThrow('RATE_LIMITED');
+	});
+});
@@ -0,0 +1,430 @@
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { randomUUID } from 'node:crypto';
+import {
+	createToken,
+	hashPassword,
+	hashToken,
+	validPassword,
+	verifyPassword,
+	type AuthUser
+} from './auth.js';
+import { getServerPaths } from './config.js';
+import { getDatabase } from './database.js';
+import { renderMarkdown } from './markdown.js';
+import type { ShowStatus } from './shows.js';
+
+export const SHARE_SESSION_COOKIE = 'sendewerk_share_session';
+export const SHARE_SCOPES = ['rundown', 'moderation', 'research'] as const;
+export type ShareScope = (typeof SHARE_SCOPES)[number];
+const PASSWORD_ATTEMPT_WINDOW_MS = 15 * 60 * 1000;
+const SHARE_PASSWORD_ATTEMPT_LIMIT = 5;
+const ADDRESS_PASSWORD_ATTEMPT_LIMIT = 20;
+
+type ShareRow = {
+	id: string;
+	show_id: string;
+	token_hash: string;
+	scope: ShareScope;
+	password_hash: string | null;
+	expires_at_utc: string | null;
+	revoked_at_utc: string | null;
+	created_at_utc: string;
+};
+
+export type ShareListItem = {
+	id: string;
+	showId: string;
+	showTitle: string;
+	showStatus: ShowStatus;
+	showStartsAtUtc: string | null;
+	scope: ShareScope;
+	isPasswordProtected: boolean;
+	expiresAtUtc: string | null;
+	revokedAtUtc: string | null;
+	createdAtUtc: string;
+};
+
+function requireBarkeeperActor(actor: AuthUser): void {
+	if (actor.role !== 'barkeeper') throw new Error('FORBIDDEN');
+}
+
+function validExpiry(value: string | null): string | null {
+	if (!value) return null;
+	const expiry = new Date(value);
+	if (Number.isNaN(expiry.valueOf()) || expiry.valueOf() <= Date.now()) {
+		throw new Error('INVALID_EXPIRY');
+	}
+	return expiry.toISOString();
+}
+
+function activeShare(rawToken: string): ShareRow | null {
+	if (!rawToken) return null;
+	const now = new Date().toISOString();
+	return (
+		(getDatabase()
+			.prepare(
+				`SELECT id, show_id, token_hash, scope, password_hash, expires_at_utc,
+				 revoked_at_utc, created_at_utc FROM show_shares
+				 WHERE token_hash = ? AND revoked_at_utc IS NULL
+				 AND (expires_at_utc IS NULL OR expires_at_utc > ?)`
+			)
+			.get(hashToken(rawToken), now) as ShareRow | undefined) ?? null
+	);
+}
+
+export function listShares(actor: AuthUser, showId?: string): ShareListItem[] {
+	requireBarkeeperActor(actor);
+	const where = showId ? 'WHERE ss.show_id = ?' : '';
+	return (
+		getDatabase()
+			.prepare(
+				`SELECT ss.id, ss.show_id, sh.title AS show_title, sh.status AS show_status,
+				 sh.starts_at_utc AS show_starts_at_utc, ss.scope, ss.password_hash,
+				 ss.expires_at_utc, ss.revoked_at_utc, ss.created_at_utc
+				 FROM show_shares ss JOIN shows sh ON sh.id = ss.show_id
+				 ${where}
+				 ORDER BY ss.created_at_utc DESC`
+			)
+			.all(...(showId ? [showId] : [])) as {
+			id: string;
+			show_id: string;
+			show_title: string;
+			show_status: ShowStatus;
+			show_starts_at_utc: string | null;
+			scope: ShareScope;
+			password_hash: string | null;
+			expires_at_utc: string | null;
+			revoked_at_utc: string | null;
+			created_at_utc: string;
+		}[]
+	).map((share) => ({
+		id: share.id,
+		showId: share.show_id,
+		showTitle: share.show_title,
+		showStatus: share.show_status,
+		showStartsAtUtc: share.show_starts_at_utc,
+		scope: share.scope,
+		isPasswordProtected: Boolean(share.password_hash),
+		expiresAtUtc: share.expires_at_utc,
+		revokedAtUtc: share.revoked_at_utc,
+		createdAtUtc: share.created_at_utc
+	}));
+}
+
+export async function createShare(
+	actor: AuthUser,
+	input: { showId: string; scope: string; password: string; expiresAtUtc: string | null }
+) {
+	requireBarkeeperActor(actor);
+	if (!SHARE_SCOPES.includes(input.scope as ShareScope)) throw new Error('INVALID_SCOPE');
+	if (input.password && !validPassword(input.password)) throw new Error('INVALID_PASSWORD');
+	const expiresAtUtc = validExpiry(input.expiresAtUtc);
+	const database = getDatabase();
+	if (!database.prepare('SELECT 1 FROM shows WHERE id = ?').get(input.showId)) {
+		throw new Error('NOT_FOUND');
+	}
+	const token = createToken();
+	const id = randomUUID();
+	const now = new Date().toISOString();
+	const passwordHash = input.password ? await hashPassword(input.password) : null;
+	database
+		.prepare(
+			`INSERT INTO show_shares
+			 (id, show_id, token_hash, scope, password_hash, expires_at_utc,
+			 created_by_user_id, created_at_utc) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
+		)
+		.run(
+			id,
+			input.showId,
+			hashToken(token),
+			input.scope,
+			passwordHash,
+			expiresAtUtc,
+			actor.id,
+			now
+		);
+	return { id, token };
+}
+
+export async function updateShare(
+	actor: AuthUser,
+	shareId: string,
+	input: {
+		scope: string;
+		passwordMode: string;
+		password: string;
+		expiresAtUtc: string | null;
+	},
+	expectedShowId?: string
+): Promise<void> {
+	requireBarkeeperActor(actor);
+	if (!SHARE_SCOPES.includes(input.scope as ShareScope)) throw new Error('INVALID_SCOPE');
+	if (!['keep', 'remove', 'replace'].includes(input.passwordMode)) {
+		throw new Error('INVALID_PASSWORD_MODE');
+	}
+	if (input.passwordMode === 'replace' && !validPassword(input.password)) {
+		throw new Error('INVALID_PASSWORD');
+	}
+	const expiresAtUtc = validExpiry(input.expiresAtUtc);
+	const existing = getDatabase()
+		.prepare(
+			'SELECT show_id, password_hash FROM show_shares WHERE id = ? AND revoked_at_utc IS NULL'
+		)
+		.get(shareId) as { show_id: string; password_hash: string | null } | undefined;
+	if (!existing || (expectedShowId && existing.show_id !== expectedShowId))
+		throw new Error('NOT_FOUND');
+	const passwordHash =
+		input.passwordMode === 'keep'
+			? existing.password_hash
+			: input.passwordMode === 'replace'
+				? await hashPassword(input.password)
+				: null;
+	const database = getDatabase();
+	database.transaction(() => {
+		const result = database
+			.prepare(
+				`UPDATE show_shares SET scope = ?, password_hash = ?, expires_at_utc = ?
+				 WHERE id = ? AND revoked_at_utc IS NULL`
+			)
+			.run(input.scope, passwordHash, expiresAtUtc, shareId);
+		if (result.changes !== 1) throw new Error('NOT_FOUND');
+		database.prepare('DELETE FROM show_share_sessions WHERE share_id = ?').run(shareId);
+	})();
+}
+
+export function deleteShare(actor: AuthUser, shareId: string, expectedShowId?: string): void {
+	requireBarkeeperActor(actor);
+	const result = getDatabase()
+		.prepare(`DELETE FROM show_shares WHERE id = ?${expectedShowId ? ' AND show_id = ?' : ''}`)
+		.run(...(expectedShowId ? [shareId, expectedShowId] : [shareId]));
+	if (result.changes !== 1) throw new Error('NOT_FOUND');
+}
+
+export function revokeShare(actor: AuthUser, shareId: string): void {
+	requireBarkeeperActor(actor);
+	const database = getDatabase();
+	database.transaction(() => {
+		const result = database
+			.prepare('UPDATE show_shares SET revoked_at_utc = ? WHERE id = ? AND revoked_at_utc IS NULL')
+			.run(new Date().toISOString(), shareId);
+		if (result.changes !== 1) throw new Error('NOT_FOUND');
+		database.prepare('DELETE FROM show_share_sessions WHERE share_id = ?').run(shareId);
+	})();
+}
+
+export function shareAccessState(rawToken: string, sessionToken?: string) {
+	const share = activeShare(rawToken);
+	if (!share) return { status: 'unavailable' as const };
+	if (!share.password_hash) return { status: 'authorized' as const, share };
+	if (!sessionToken) return { status: 'password' as const };
+	const session = getDatabase()
+		.prepare(
+			`SELECT 1 FROM show_share_sessions WHERE token_hash = ? AND share_id = ?
+			 AND expires_at_utc > ?`
+		)
+		.get(hashToken(sessionToken), share.id, new Date().toISOString());
+	return session ? { status: 'authorized' as const, share } : { status: 'password' as const };
+}
+
+export async function authenticateShare(rawToken: string, password: string, address: string) {
+	const share = activeShare(rawToken);
+	if (!share?.password_hash) throw new Error('SHARE_UNAVAILABLE');
+	const database = getDatabase();
+	const now = new Date();
+	const since = new Date(now.getTime() - PASSWORD_ATTEMPT_WINDOW_MS).toISOString();
+	const shareKey = hashToken(rawToken);
+	const addressKey = hashToken(address || 'unknown');
+	database.prepare('DELETE FROM share_password_attempts WHERE attempted_at_utc < ?').run(since);
+	const shareAttempts = database
+		.prepare(
+			`SELECT count(*) AS count FROM share_password_attempts
+			 WHERE share_key = ? AND attempted_at_utc >= ?`
+		)
+		.get(shareKey, since) as { count: number };
+	const addressAttempts = database
+		.prepare(
+			`SELECT count(*) AS count FROM share_password_attempts
+			 WHERE address_key = ? AND attempted_at_utc >= ?`
+		)
+		.get(addressKey, since) as { count: number };
+	if (
+		shareAttempts.count >= SHARE_PASSWORD_ATTEMPT_LIMIT ||
+		addressAttempts.count >= ADDRESS_PASSWORD_ATTEMPT_LIMIT
+	) {
+		throw new Error('RATE_LIMITED');
+	}
+	database
+		.prepare(
+			`INSERT INTO share_password_attempts
+			 (id, share_key, address_key, attempted_at_utc) VALUES (?, ?, ?, ?)`
+		)
+		.run(randomUUID(), shareKey, addressKey, now.toISOString());
+	if (!(await verifyPassword(share.password_hash, password))) throw new Error('INVALID_PASSWORD');
+	const token = createToken();
+	const defaultExpiry = now.getTime() + 12 * 60 * 60 * 1000;
+	const shareExpiry = share.expires_at_utc
+		? new Date(share.expires_at_utc).getTime()
+		: defaultExpiry;
+	const expires = new Date(Math.min(defaultExpiry, shareExpiry));
+	database.prepare('DELETE FROM share_password_attempts WHERE share_key = ?').run(shareKey);
+	database
+		.prepare('DELETE FROM show_share_sessions WHERE expires_at_utc <= ?')
+		.run(now.toISOString());
+	database
+		.prepare(
+			`INSERT INTO show_share_sessions (token_hash, share_id, created_at_utc, expires_at_utc)
+			 VALUES (?, ?, ?, ?)`
+		)
+		.run(hashToken(token), share.id, now.toISOString(), expires.toISOString());
+	return { token, expires };
+}
+
+export function getSharedShow(rawToken: string, sessionToken?: string) {
+	const access = shareAccessState(rawToken, sessionToken);
+	if (access.status !== 'authorized' || !access.share) return access;
+	const share = access.share;
+	const database = getDatabase();
+	const show = database
+		.prepare('SELECT title, starts_at_utc, status, completed_at_utc FROM shows WHERE id = ?')
+		.get(share.show_id) as {
+		title: string;
+		starts_at_utc: string | null;
+		status: ShowStatus;
+		completed_at_utc: string | null;
+	};
+	const sections = database
+		.prepare(
+			`SELECT s.id, s.name, s.category_name_snapshot, s.category_color_snapshot,
+			 c.name AS category_name, c.color AS category_color,
+			 s.explicit_duration_seconds, s.position FROM show_sections s
+			 LEFT JOIN section_categories c ON c.id = s.category_id
+			 WHERE s.show_id = ? AND s.is_reserve_bank = 0 ORDER BY s.position`
+		)
+		.all(share.show_id) as {
+		id: string;
+		name: string;
+		category_name_snapshot: string | null;
+		category_color_snapshot: string | null;
+		category_name: string | null;
+		category_color: string | null;
+		explicit_duration_seconds: number | null;
+		position: number;
+	}[];
+	const usageStatement = database.prepare(
+		`SELECT u.id, u.title_snapshot, u.output_title_snapshot, u.status, u.duration_seconds,
+		 u.intro_snapshot, u.research_snapshot, u.moderation_snapshot, u.interaction_snapshot,
+		 u.transition_snapshot, u.own_notes,
+		 COALESCE((SELECT actual_duration_seconds FROM piece_usage_history WHERE usage_id = u.id), 0)
+		 AS actual_duration_seconds
+		 FROM piece_usages u WHERE u.show_section_id = ? ORDER BY u.position`
+	);
+	const sourceStatement = database.prepare(
+		'SELECT label, url, timecode_seconds FROM usage_source_snapshots WHERE usage_id = ? ORDER BY position'
+	);
+	const toolStatement = database.prepare(
+		`SELECT name, start_url, work_url, note FROM usage_tool_snapshots
+		 WHERE usage_id = ? ORDER BY position`
+	);
+	const mediaStatement = database.prepare(
+		`SELECT id, alt_text FROM usage_media_snapshots
+		 WHERE usage_id = ? AND is_presentation = 1`
+	);
+	const includesModeration = share.scope === 'moderation' || share.scope === 'research';
+	const includesResearch = share.scope === 'research';
+	return {
+		status: 'authorized' as const,
+		share: {
+			scope: share.scope,
+			title: show.title,
+			startsAtUtc: show.starts_at_utc,
+			completedAtUtc: show.completed_at_utc,
+			isCompleted: show.status === 'completed',
+			sections: sections.map((section) => {
+				const usages = usageStatement.all(section.id) as {
+					id: string;
+					title_snapshot: string;
+					output_title_snapshot: string;
+					status: string;
+					duration_seconds: number;
+					actual_duration_seconds: number;
+					intro_snapshot: string;
+					research_snapshot: string;
+					moderation_snapshot: string;
+					interaction_snapshot: string;
+					transition_snapshot: string;
+					own_notes: string;
+				}[];
+				return {
+					name: section.name,
+					category:
+						show.status === 'completed' ? section.category_name_snapshot : section.category_name,
+					categoryColor:
+						show.status === 'completed' ? section.category_color_snapshot : section.category_color,
+					explicitDurationSeconds: section.explicit_duration_seconds,
+					usages: usages.map((usage) => ({
+						title: usage.title_snapshot,
+						outputTitle: usage.output_title_snapshot,
+						status: usage.status,
+						durationSeconds: usage.duration_seconds,
+						actualDurationSeconds: usage.actual_duration_seconds,
+						media: mediaStatement.get(usage.id) as { id: string; alt_text: string } | undefined,
+						...(includesModeration
+							? {
+									introHtml: renderMarkdown(usage.intro_snapshot),
+									moderationHtml: renderMarkdown(usage.moderation_snapshot),
+									interactionHtml: renderMarkdown(usage.interaction_snapshot),
+									transitionHtml: renderMarkdown(usage.transition_snapshot)
+								}
+							: {}),
+						...(includesResearch
+							? {
+									researchHtml: renderMarkdown(usage.research_snapshot),
+									sources: sourceStatement.all(usage.id) as {
+										label: string;
+										url: string;
+										timecode_seconds: number | null;
+									}[],
+									tools: (
+										toolStatement.all(usage.id) as {
+											name: string;
+											start_url: string;
+											work_url: string;
+											note: string;
+										}[]
+									).map((tool) => ({ name: tool.name, note: tool.note }))
+								}
+							: {})
+					}))
+				};
+			})
+		}
+	};
+}
+
+export async function getSharedMedia(
+	rawToken: string,
+	sessionToken: string | undefined,
+	snapshotMediaId: string
+) {
+	const access = shareAccessState(rawToken, sessionToken);
+	if (access.status !== 'authorized' || !access.share) return null;
+	const row = getDatabase()
+		.prepare(
+			`SELECT pm.storage_name, pm.mime_type, pm.byte_size
+			 FROM usage_media_snapshots ums
+			 JOIN piece_usages u ON u.id = ums.usage_id
+			 JOIN show_sections s ON s.id = u.show_section_id
+			 JOIN piece_media pm ON pm.id = ums.original_media_id
+			 WHERE ums.id = ? AND ums.is_presentation = 1 AND s.show_id = ?
+			 AND s.is_reserve_bank = 0`
+		)
+		.get(snapshotMediaId, access.share.show_id) as
+		{ storage_name: string; mime_type: string; byte_size: number } | undefined;
+	if (!row) return null;
+	return {
+		data: await readFile(path.join(getServerPaths().uploads, row.storage_name)),
+		mimeType: row.mime_type,
+		byteSize: row.byte_size
+	};
+}
@@ -253,7 +253,29 @@ describe('show builder data layer', () => {
 		getDatabase()
 			.prepare("UPDATE piece_usages SET status = 'skipped' WHERE id = ?")
 			.run(skipped.id);
-		getDatabase().prepare("UPDATE shows SET status = 'completed' WHERE id = ?").run(completed.id);
+		getDatabase()
+			.prepare(
+				"UPDATE shows SET status = 'completed', completed_at_utc = starts_at_utc WHERE id = ?"
+			)
+			.run(completed.id);
+		getDatabase()
+			.prepare(
+				`INSERT INTO show_finalizations
+				 (show_id, command_id, source_revision, finalized_at_utc)
+				 SELECT id, 'test-finalization', revision, starts_at_utc FROM shows WHERE id = ?`
+			)
+			.run(completed.id);
+		getDatabase()
+			.prepare(
+				`INSERT INTO piece_usage_history
+				 (usage_id, show_id, original_piece_id, show_title_snapshot, usage_title_snapshot,
+				 used_at_utc, actual_duration_seconds)
+				 SELECT u.id, sh.id, u.original_piece_id, sh.title, u.title_snapshot,
+				 sh.starts_at_utc, 0 FROM piece_usages u
+				 JOIN show_sections s ON s.id = u.show_section_id
+				 JOIN shows sh ON sh.id = s.show_id WHERE u.id = ?`
+			)
+			.run(done.id);

 		const active = createShow({ title: 'Aktuelle Planung', startsAtUtc: null, templateId: null });
 		const activeSection = addShowSection(active.id, active.revision, {
@@ -27,6 +27,7 @@ export type ShowTemplateSection = {
 	categoryId: string | null;
 	position: number;
 	explicitDurationSeconds: number | null;
+	twitchTags: string[];
 };

 export type ShowTemplate = {
@@ -106,6 +107,7 @@ export type ShowSection = {
 	categoryColor: string | null;
 	position: number;
 	explicitDurationSeconds: number | null;
+	twitchTags: string[];
 	durationSeconds: number;
 	usages: PieceUsage[];
 };
@@ -120,6 +122,7 @@ export type Show = {
 	revision: number;
 	createdAtUtc: string;
 	updatedAtUtc: string;
+	completedAtUtc: string | null;
 	sections: ShowSection[];
 	reserve: PieceUsage[];
 	totalDurationSeconds: number;
@@ -143,6 +146,7 @@ export type ShowSectionInput = {
 	name: string;
 	categoryId: string | null;
 	explicitDurationSeconds: number | null;
+	twitchTags?: string[];
 	position?: number;
 };

@@ -193,6 +197,7 @@ type ShowRow = {
 	revision: number;
 	created_at_utc: string;
 	updated_at_utc: string;
+	completed_at_utc: string | null;
 };

 type SectionRow = {
@@ -201,8 +206,11 @@ type SectionRow = {
 	category_id: string | null;
 	category: string | null;
 	category_color: string | null;
+	category_name_snapshot: string | null;
+	category_color_snapshot: string | null;
 	position: number;
 	explicit_duration_seconds: number | null;
+	twitch_tags: string;
 	is_reserve_bank: number;
 };

@@ -222,6 +230,7 @@ type UsageRow = {
 	transition_snapshot: string;
 	presentation_snapshot: string;
 	presentation_mode_snapshot: PresentationMode;
+	presentation_image_only_snapshot: number;
 	presentation_source_label_snapshot: string;
 	presentation_source_url_snapshot: string;
 	presentation_source_timecode_snapshot: number | null;
@@ -250,6 +259,14 @@ function validDuration(value: number | null): number | null {
 	return value;
 }

+function validTwitchTags(values: string[]) {
+	const tags = [...new Set(values.map((tag) => tag.trim()).filter(Boolean))];
+	if (tags.length > 10 || tags.some((tag) => tag.length > 25 || tag.includes(','))) {
+		throw new Error('INVALID_TWITCH_TAGS');
+	}
+	return tags;
+}
+
 function validPosition(value: number, maximum: number): number {
 	if (!Number.isInteger(value) || value < 0) throw new Error('INVALID_POSITION');
 	return Math.min(value, maximum);
@@ -273,7 +290,7 @@ function validPresentation(
 	imageUrl: string,
 	siteName: string
 ) {
-	if (!['text', 'link', 'video'].includes(mode)) throw new Error('INVALID_PRESENTATION');
+	if (!['text', 'image', 'link', 'video'].includes(mode)) throw new Error('INVALID_PRESENTATION');
 	const cleanUrl = cleanText(sourceUrl, 2_000, 'presentation_source');
 	const cleanImageUrl = cleanText(imageUrl, 2_000, 'presentation_image');
 	for (const value of [cleanUrl, cleanImageUrl]) {
@@ -285,7 +302,7 @@ function validPresentation(
 			throw new Error('INVALID_PRESENTATION');
 		}
 	}
-	if (mode !== 'text' && !cleanUrl) throw new Error('INVALID_PRESENTATION');
+	if ((mode === 'link' || mode === 'video') && !cleanUrl) throw new Error('INVALID_PRESENTATION');
 	if (
 		timecodeSeconds !== null &&
 		(!Number.isInteger(timecodeSeconds) || timecodeSeconds < 0 || timecodeSeconds > 86_400)
@@ -713,7 +730,11 @@ function copyUsageRelations(database: Database.Database, sourceUsageId: string,
 		.run(usageId, sourceUsageId);
 }

-export function listShows(): ShowListItem[] {
+export function listShows(statuses?: ShowStatus[]): ShowListItem[] {
+	const requestedStatuses = statuses?.filter((status) => SHOW_STATUSES.includes(status));
+	const where = requestedStatuses?.length
+		? `WHERE sh.status IN (${requestedStatuses.map(() => '?').join(', ')})`
+		: '';
 	return (
 		getDatabase()
 			.prepare(
@@ -724,10 +745,11 @@ export function listShows(): ShowListItem[] {
 						(SELECT sum(u.duration_seconds) FROM piece_usages u WHERE u.show_section_id = s.id))
 				 ELSE 0 END), 0) AS total_duration_seconds
 				 FROM shows sh LEFT JOIN show_sections s ON s.show_id = sh.id
+				 ${where}
 				 GROUP BY sh.id
 				 ORDER BY sh.starts_at_utc IS NULL, sh.starts_at_utc DESC, sh.created_at_utc DESC`
 			)
-			.all() as {
+			.all(...(requestedStatuses ?? [])) as {
 			id: string;
 			title: string;
 			starts_at_utc: string | null;
@@ -753,7 +775,7 @@ export function listShowTemplates(): ShowTemplate[] {
 		.prepare('SELECT id, name, description FROM show_templates ORDER BY name')
 		.all() as Omit<ShowTemplate, 'sections'>[];
 	const sectionStatement = database.prepare(
-		`SELECT id, name, category_id, position, explicit_duration_seconds
+		`SELECT id, name, category_id, position, explicit_duration_seconds, twitch_tags
 		 FROM show_template_sections WHERE template_id = ? ORDER BY position`
 	);
 	return templates.map((template) => ({
@@ -765,13 +787,15 @@ export function listShowTemplates(): ShowTemplate[] {
 				category_id: string | null;
 				position: number;
 				explicit_duration_seconds: number | null;
+				twitch_tags: string;
 			}[]
 		).map((section) => ({
 			id: section.id,
 			name: section.name,
 			categoryId: section.category_id,
 			position: section.position,
-			explicitDurationSeconds: section.explicit_duration_seconds
+			explicitDurationSeconds: section.explicit_duration_seconds,
+			twitchTags: section.twitch_tags ? section.twitch_tags.split(',') : []
 		}))
 	}));
 }
@@ -781,14 +805,15 @@ export function getShow(id: string): Show | null {
 	const show = database
 		.prepare(
 			`SELECT id, title, starts_at_utc, twitch_title, announcement_text, status, revision,
-			 created_at_utc, updated_at_utc FROM shows WHERE id = ?`
+			 created_at_utc, updated_at_utc, completed_at_utc FROM shows WHERE id = ?`
 		)
 		.get(id) as ShowRow | undefined;
 	if (!show) return null;
 	const sectionRows = database
 		.prepare(
 			`SELECT s.id, s.name, s.category_id, c.name AS category, c.color AS category_color,
-			 s.position, s.explicit_duration_seconds, s.is_reserve_bank
+			 s.category_name_snapshot, s.category_color_snapshot,
+			 s.position, s.explicit_duration_seconds, s.twitch_tags, s.is_reserve_bank
 			 FROM show_sections s LEFT JOIN section_categories c ON c.id = s.category_id
 			 WHERE s.show_id = ? ORDER BY s.position`
 		)
@@ -798,7 +823,9 @@ export function getShow(id: string): Show | null {
 			`SELECT u.id, u.show_section_id, u.original_piece_id, u.position, u.status,
 			 u.duration_seconds, u.title_snapshot, u.output_title_snapshot, u.intro_snapshot, u.research_snapshot,
 			 u.moderation_snapshot, u.interaction_snapshot, u.transition_snapshot, u.presentation_snapshot,
-			 u.presentation_mode_snapshot, u.presentation_source_label_snapshot,
+			 CASE WHEN u.presentation_image_only_snapshot = 1 THEN 'image' ELSE u.presentation_mode_snapshot END AS presentation_mode_snapshot,
+			 u.presentation_image_only_snapshot,
+			 u.presentation_source_label_snapshot,
 			 u.presentation_source_url_snapshot, u.presentation_source_timecode_snapshot,
 			 u.presentation_title_meta_snapshot, u.presentation_description_snapshot,
 			 u.presentation_image_url_snapshot, u.presentation_site_name_snapshot,
@@ -821,10 +848,17 @@ export function getShow(id: string): Show | null {
 				id: row.id,
 				name: row.name,
 				categoryId: row.category_id,
-				category: row.category,
-				categoryColor: row.category_color,
+				category:
+					show.status === 'completed'
+						? row.category_name_snapshot
+						: (row.category_name_snapshot ?? row.category),
+				categoryColor:
+					show.status === 'completed'
+						? row.category_color_snapshot
+						: (row.category_color_snapshot ?? row.category_color),
 				position: row.position,
 				explicitDurationSeconds: row.explicit_duration_seconds,
+				twitchTags: row.twitch_tags ? row.twitch_tags.split(',') : [],
 				durationSeconds:
 					row.explicit_duration_seconds ??
 					usages.reduce((total, usage) => total + usage.durationSeconds, 0),
@@ -842,6 +876,7 @@ export function getShow(id: string): Show | null {
 		revision: show.revision,
 		createdAtUtc: show.created_at_utc,
 		updatedAtUtc: show.updated_at_utc,
+		completedAtUtc: show.completed_at_utc,
 		sections,
 		reserve: reserveRow ? (usagesBySection.get(reserveRow.id) ?? []) : [],
 		totalDurationSeconds: sections.reduce((total, section) => total + section.durationSeconds, 0)
@@ -868,14 +903,9 @@ export function getPieceUsageContexts(
 	const database = getDatabase();
 	const history = database
 		.prepare(
-			`SELECT u.id AS usage_id, u.original_piece_id, sh.id AS show_id,
-			 sh.title AS show_title, COALESCE(sh.starts_at_utc, sh.updated_at_utc) AS used_at_utc
-			 FROM piece_usages u
-			 JOIN show_sections s ON s.id = u.show_section_id
-			 JOIN shows sh ON sh.id = s.show_id
-			 WHERE u.original_piece_id IS NOT NULL AND u.status = 'done'
-			 AND sh.status = 'completed' AND s.is_reserve_bank = 0
-			 ORDER BY used_at_utc DESC, u.id DESC`
+			`SELECT usage_id, original_piece_id, show_id,
+			 show_title_snapshot AS show_title, used_at_utc
+			 FROM piece_usage_history ORDER BY used_at_utc DESC, usage_id DESC`
 		)
 		.all() as {
 		usage_id: string;
@@ -945,7 +975,7 @@ export function createShow(input: CreateShowInput): CreatedMutationResult {
 		const templateSections = input.templateId
 			? (database
 					.prepare(
-						`SELECT name, category_id, position, explicit_duration_seconds
+						`SELECT name, category_id, position, explicit_duration_seconds, twitch_tags
 						 FROM show_template_sections WHERE template_id = ? ORDER BY position`
 					)
 					.all(input.templateId) as {
@@ -953,11 +983,12 @@ export function createShow(input: CreateShowInput): CreatedMutationResult {
 					category_id: string | null;
 					position: number;
 					explicit_duration_seconds: number | null;
+					twitch_tags: string;
 				}[])
 			: [];
 		const insertSection = database.prepare(
 			`INSERT INTO show_sections (id, show_id, name, category_id, position,
-			 explicit_duration_seconds, is_reserve_bank) VALUES (?, ?, ?, ?, ?, ?, ?)`
+			 explicit_duration_seconds, twitch_tags, is_reserve_bank) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
 		);
 		for (const section of templateSections) {
 			insertSection.run(
@@ -967,15 +998,151 @@ export function createShow(input: CreateShowInput): CreatedMutationResult {
 				section.category_id,
 				section.position,
 				section.explicit_duration_seconds,
+				section.twitch_tags,
 				0
 			);
 		}
-		insertSection.run(randomUUID(), id, 'Reservebank', null, templateSections.length, null, 1);
+		insertSection.run(randomUUID(), id, 'Reservebank', null, templateSections.length, null, '', 1);
 	});
 	create();
 	return { id, revision: 1, updatedAtUtc: now };
 }

+export function duplicateCompletedShow(
+	sourceShowId: string,
+	commandId: string
+): CreatedMutationResult {
+	if (!commandId || commandId.length > 200) throw new Error('INVALID_COMMAND');
+	const database = getDatabase();
+	return database.transaction(() => {
+		const duplicate = database
+			.prepare(
+				`SELECT created_show_id FROM show_duplication_commands
+				 WHERE source_show_id = ? AND command_id = ?`
+			)
+			.get(sourceShowId, commandId) as { created_show_id: string } | undefined;
+		if (duplicate) {
+			const show = database
+				.prepare('SELECT revision, updated_at_utc FROM shows WHERE id = ?')
+				.get(duplicate.created_show_id) as { revision: number; updated_at_utc: string };
+			return {
+				id: duplicate.created_show_id,
+				revision: show.revision,
+				updatedAtUtc: show.updated_at_utc
+			};
+		}
+		const source = database
+			.prepare(
+				`SELECT sh.title, sh.twitch_title, sh.announcement_text
+				 FROM shows sh JOIN show_finalizations f ON f.show_id = sh.id WHERE sh.id = ?`
+			)
+			.get(sourceShowId) as
+			{ title: string; twitch_title: string; announcement_text: string } | undefined;
+		if (!source) throw new Error('NOT_FOUND');
+		const id = randomUUID();
+		const now = new Date().toISOString();
+		const title = `${source.title} (Kopie)`.slice(0, 200);
+		database
+			.prepare(
+				`INSERT INTO shows (id, title, starts_at_utc, twitch_title, announcement_text,
+				 status, revision, created_at_utc, updated_at_utc)
+				 VALUES (?, ?, NULL, ?, ?, 'draft', 1, ?, ?)`
+			)
+			.run(id, title, source.twitch_title, source.announcement_text, now, now);
+
+		const sections = database
+			.prepare(
+				`SELECT id, name, category_id, category_name_snapshot, category_color_snapshot,
+				 position, explicit_duration_seconds, twitch_tags, is_reserve_bank
+				 FROM show_sections WHERE show_id = ? ORDER BY position`
+			)
+			.all(sourceShowId) as {
+			id: string;
+			name: string;
+			category_id: string | null;
+			category_name_snapshot: string | null;
+			category_color_snapshot: string | null;
+			position: number;
+			explicit_duration_seconds: number | null;
+			twitch_tags: string;
+			is_reserve_bank: number;
+		}[];
+		const insertSection = database.prepare(
+			`INSERT INTO show_sections (id, show_id, name, category_id, category_name_snapshot,
+			 category_color_snapshot, position, explicit_duration_seconds, twitch_tags, is_reserve_bank)
+			 VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+		);
+		const usages = database.prepare(
+			'SELECT * FROM piece_usages WHERE show_section_id = ? ORDER BY position'
+		);
+		const insertUsage = database.prepare(
+			`INSERT INTO piece_usages (id, show_section_id, original_piece_id, position, status,
+			 duration_seconds, title_snapshot, output_title_snapshot, intro_snapshot, research_snapshot,
+			 moderation_snapshot, interaction_snapshot, transition_snapshot, presentation_snapshot,
+			 presentation_mode_snapshot, presentation_source_label_snapshot,
+			 presentation_source_url_snapshot, presentation_source_timecode_snapshot,
+			 presentation_title_meta_snapshot, presentation_description_snapshot,
+			 presentation_image_url_snapshot, presentation_site_name_snapshot,
+			 presentation_provider_snapshot, presentation_provider_id_snapshot, presentation_image_only_snapshot, own_notes, is_reserve)
+			 VALUES (?, ?, ?, ?, 'open', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+		);
+		for (const section of sections) {
+			const sectionId = randomUUID();
+			insertSection.run(
+				sectionId,
+				id,
+				section.name,
+				section.category_id,
+				section.category_name_snapshot,
+				section.category_color_snapshot,
+				section.position,
+				section.explicit_duration_seconds,
+				section.twitch_tags,
+				section.is_reserve_bank
+			);
+			for (const usage of usages.all(section.id) as (UsageRow & { is_reserve: number })[]) {
+				const usageId = randomUUID();
+				insertUsage.run(
+					usageId,
+					sectionId,
+					usage.original_piece_id,
+					usage.position,
+					usage.duration_seconds,
+					usage.title_snapshot,
+					usage.output_title_snapshot,
+					usage.intro_snapshot,
+					usage.research_snapshot,
+					usage.moderation_snapshot,
+					usage.interaction_snapshot,
+					usage.transition_snapshot,
+					usage.presentation_snapshot,
+					usage.presentation_mode_snapshot,
+					usage.presentation_source_label_snapshot,
+					usage.presentation_source_url_snapshot,
+					usage.presentation_source_timecode_snapshot,
+					usage.presentation_title_meta_snapshot,
+					usage.presentation_description_snapshot,
+					usage.presentation_image_url_snapshot,
+					usage.presentation_site_name_snapshot,
+					usage.presentation_provider_snapshot,
+					usage.presentation_provider_id_snapshot,
+					usage.presentation_image_only_snapshot,
+					usage.own_notes,
+					usage.is_reserve
+				);
+				copyUsageRelations(database, usage.id, usageId);
+			}
+		}
+		database
+			.prepare(
+				`INSERT INTO show_duplication_commands
+				 (source_show_id, command_id, created_show_id, created_at_utc) VALUES (?, ?, ?, ?)`
+			)
+			.run(sourceShowId, commandId, id, now);
+		return { id, revision: 1, updatedAtUtc: now };
+	})();
+}
+
 export function saveShowMetadata(
 	showId: string,
 	expectedRevision: number,
@@ -1006,6 +1173,7 @@ export function addShowSection(
 ): CreatedMutationResult {
 	const name = cleanText(input.name, 200, 'section_name', true);
 	const duration = validDuration(input.explicitDurationSeconds);
+	const twitchTags = validTwitchTags(input.twitchTags ?? []);
 	const database = getDatabase();
 	requireCategory(database, input.categoryId);
 	return database.transaction(() => {
@@ -1030,9 +1198,9 @@ export function addShowSection(
 		database
 			.prepare(
 				`INSERT INTO show_sections (id, show_id, name, category_id, position,
-				 explicit_duration_seconds, is_reserve_bank) VALUES (?, ?, ?, ?, ?, ?, 0)`
+				 explicit_duration_seconds, twitch_tags, is_reserve_bank) VALUES (?, ?, ?, ?, ?, ?, ?, 0)`
 			)
-			.run(id, showId, name, input.categoryId, temporaryPosition, duration);
+			.run(id, showId, name, input.categoryId, temporaryPosition, duration, twitchTags.join(','));
 		visibleIds.splice(position, 0, id);
 		const reserveId = reserveSectionId(database, showId);
 		normalizePositions(database, 'show_sections', [...visibleIds, reserveId]);
@@ -1048,6 +1216,7 @@ export function updateShowSection(
 ): MutationResult {
 	const name = cleanText(input.name, 200, 'section_name', true);
 	const duration = validDuration(input.explicitDurationSeconds);
+	const twitchTags = validTwitchTags(input.twitchTags ?? []);
 	const database = getDatabase();
 	requireCategory(database, input.categoryId);
 	return database.transaction(() => {
@@ -1055,10 +1224,11 @@ export function updateShowSection(
 		sectionBelongsToShow(database, showId, sectionId);
 		database
 			.prepare(
-				`UPDATE show_sections SET name = ?, category_id = ?, explicit_duration_seconds = ?
+				`UPDATE show_sections SET name = ?, category_id = ?, explicit_duration_seconds = ?, twitch_tags = ?,
+				 category_name_snapshot = NULL, category_color_snapshot = NULL
 				 WHERE id = ?`
 			)
-			.run(name, input.categoryId, duration, sectionId);
+			.run(name, input.categoryId, duration, twitchTags.join(','), sectionId);
 		return result;
 	})();
 }
@@ -1130,7 +1300,8 @@ export function addPieceUsage(
 		const piece = database
 			.prepare(
 				`SELECT p.title, p.output_title, p.duration_seconds, p.intro, p.research_text, p.moderation_notes,
-				 p.interaction_text, p.transition_text, p.presentation_text, p.status, p.presentation_mode,
+				 p.interaction_text, p.transition_text, p.presentation_text, p.status,
+				 CASE WHEN p.presentation_image_only = 1 THEN 'image' ELSE p.presentation_mode END AS presentation_mode,
 				 COALESCE(ps.label, '') AS presentation_source_label,
 				 COALESCE(ps.url, '') AS presentation_source_url,
 				 ps.timecode_seconds AS presentation_source_timecode,
@@ -1184,12 +1355,12 @@ export function addPieceUsage(
 				`INSERT INTO piece_usages (id, show_section_id, original_piece_id, position, status,
 				 duration_seconds, title_snapshot, output_title_snapshot, intro_snapshot, research_snapshot,
 				 moderation_snapshot, interaction_snapshot, transition_snapshot, presentation_snapshot,
-				 presentation_mode_snapshot, presentation_source_label_snapshot,
+				 presentation_mode_snapshot, presentation_image_only_snapshot, presentation_source_label_snapshot,
 				 presentation_source_url_snapshot, presentation_source_timecode_snapshot,
 				 presentation_title_meta_snapshot, presentation_description_snapshot,
 				 presentation_image_url_snapshot, presentation_site_name_snapshot,
 				 presentation_provider_snapshot, presentation_provider_id_snapshot, own_notes, is_reserve)
-				 VALUES (?, ?, ?, ?, 'open', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, '', ?)`
+				 VALUES (?, ?, ?, ?, 'open', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, '', ?)`
 			)
 			.run(
 				id,
@@ -1205,7 +1376,8 @@ export function addPieceUsage(
 				piece.interaction_text,
 				piece.transition_text,
 				piece.presentation_text,
-				piece.presentation_mode,
+				piece.presentation_mode === 'image' ? 'text' : piece.presentation_mode,
+				piece.presentation_mode === 'image' ? 1 : 0,
 				piece.presentation_source_label,
 				piece.presentation_source_url,
 				piece.presentation_source_timecode,
@@ -1291,7 +1463,7 @@ export function duplicatePieceUsage(
 			.prepare(
 				`SELECT original_piece_id, status, duration_seconds, title_snapshot, output_title_snapshot, intro_snapshot,
 				 research_snapshot, moderation_snapshot, interaction_snapshot, transition_snapshot, presentation_snapshot,
-				 presentation_mode_snapshot, presentation_source_label_snapshot,
+				 presentation_mode_snapshot, presentation_image_only_snapshot, presentation_source_label_snapshot,
 				 presentation_source_url_snapshot, presentation_source_timecode_snapshot,
 				 presentation_title_meta_snapshot, presentation_description_snapshot,
 				 presentation_image_url_snapshot, presentation_site_name_snapshot,
@@ -1314,12 +1486,12 @@ export function duplicatePieceUsage(
 				`INSERT INTO piece_usages (id, show_section_id, original_piece_id, position, status,
 				 duration_seconds, title_snapshot, output_title_snapshot, intro_snapshot, research_snapshot,
 				 moderation_snapshot, interaction_snapshot, transition_snapshot, presentation_snapshot,
-				 presentation_mode_snapshot, presentation_source_label_snapshot,
+				 presentation_mode_snapshot, presentation_image_only_snapshot, presentation_source_label_snapshot,
 				 presentation_source_url_snapshot, presentation_source_timecode_snapshot,
 				 presentation_title_meta_snapshot, presentation_description_snapshot,
 				 presentation_image_url_snapshot, presentation_site_name_snapshot,
 				 presentation_provider_snapshot, presentation_provider_id_snapshot, own_notes, is_reserve)
-				 VALUES (?, ?, ?, ?, 'open', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+				 VALUES (?, ?, ?, ?, 'open', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
 			)
 			.run(
 				id,
@@ -1336,6 +1508,7 @@ export function duplicatePieceUsage(
 				source.transition_snapshot,
 				source.presentation_snapshot,
 				source.presentation_mode_snapshot,
+				source.presentation_image_only_snapshot,
 				source.presentation_source_label_snapshot,
 				source.presentation_source_url_snapshot,
 				source.presentation_source_timecode_snapshot,
@@ -1367,7 +1540,8 @@ export function refreshPieceUsageFromOriginal(
 		const source = database
 			.prepare(
 				`SELECT p.title, p.output_title, p.duration_seconds, p.intro, p.research_text,
-				 p.moderation_notes, p.interaction_text, p.transition_text, p.presentation_text, p.presentation_mode,
+				 p.moderation_notes, p.interaction_text, p.transition_text, p.presentation_text,
+				 CASE WHEN p.presentation_image_only = 1 THEN 'image' ELSE p.presentation_mode END AS presentation_mode,
 				 COALESCE(ps.label, '') AS presentation_source_label,
 				 COALESCE(ps.url, '') AS presentation_source_url,
 				 ps.timecode_seconds AS presentation_source_timecode,
@@ -1406,7 +1580,7 @@ export function refreshPieceUsageFromOriginal(
 			.prepare(
 				`UPDATE piece_usages SET title_snapshot = ?, output_title_snapshot = ?, duration_seconds = ?, intro_snapshot = ?,
 				 research_snapshot = ?, moderation_snapshot = ?, interaction_snapshot = ?, transition_snapshot = ?,
-				 presentation_snapshot = ?, presentation_mode_snapshot = ?,
+				 presentation_snapshot = ?, presentation_mode_snapshot = ?, presentation_image_only_snapshot = ?,
 				 presentation_source_label_snapshot = ?, presentation_source_url_snapshot = ?,
 				 presentation_source_timecode_snapshot = ?, presentation_title_meta_snapshot = ?,
 				 presentation_description_snapshot = ?, presentation_image_url_snapshot = ?,
@@ -1423,7 +1597,8 @@ export function refreshPieceUsageFromOriginal(
 				source.interaction_text,
 				source.transition_text,
 				source.presentation_text,
-				source.presentation_mode,
+				source.presentation_mode === 'image' ? 'text' : source.presentation_mode,
+				source.presentation_mode === 'image' ? 1 : 0,
 				source.presentation_source_label,
 				source.presentation_source_url,
 				source.presentation_source_timecode,
@@ -1485,7 +1660,7 @@ export function updatePieceUsage(
 			.prepare(
 				`UPDATE piece_usages SET title_snapshot = ?, output_title_snapshot = ?, intro_snapshot = ?, research_snapshot = ?,
 				 moderation_snapshot = ?, interaction_snapshot = COALESCE(?, interaction_snapshot), transition_snapshot = ?, presentation_snapshot = ?,
-				 presentation_mode_snapshot = ?, presentation_source_label_snapshot = ?,
+				 presentation_mode_snapshot = ?, presentation_image_only_snapshot = ?, presentation_source_label_snapshot = ?,
 				 presentation_source_url_snapshot = ?, presentation_source_timecode_snapshot = ?,
 				 presentation_title_meta_snapshot = ?, presentation_description_snapshot = ?,
 				 presentation_image_url_snapshot = ?, presentation_site_name_snapshot = ?,
@@ -1501,7 +1676,8 @@ export function updatePieceUsage(
 				values.interaction,
 				values.transition,
 				values.presentation,
-				presentation.mode,
+				presentation.mode === 'image' ? 'text' : presentation.mode,
+				presentation.mode === 'image' ? 1 : 0,
 				presentation.sourceLabel,
 				presentation.sourceUrl,
 				presentation.timecodeSeconds,
@@ -0,0 +1,97 @@
+import { execFileSync } from 'node:child_process';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import type { AuthUser } from './auth.js';
+import { closeDatabase, getDatabase } from './database.js';
+import {
+	authenticateTechnical,
+	createTechnicalAccess,
+	idempotentResponse,
+	revokeTechnicalAccess
+} from './technical-access.js';
+
+let directory: string;
+let actor: AuthUser;
+
+beforeEach(() => {
+	directory = mkdtempSync(path.join(tmpdir(), 'sendewerk-api-test-'));
+	process.env.SENDEWERK_DB_PATH = path.join(directory, 'test.sqlite');
+	process.env.SENDEWERK_UPLOAD_DIR = path.join(directory, 'uploads');
+	execFileSync(process.execPath, ['scripts/migrate.mjs'], { cwd: process.cwd(), env: process.env });
+	execFileSync(process.execPath, ['scripts/seed.mjs'], { cwd: process.cwd(), env: process.env });
+	const now = new Date().toISOString();
+	getDatabase()
+		.prepare(
+			`INSERT INTO users (id, email, email_normalized, display_name, password_hash, role,
+		password_changed_at_utc, created_at_utc, updated_at_utc) VALUES ('test-user', 'test@example.org',
+		'test@example.org', 'Test', 'not-used', 'barkeeper', ?, ?, ?)`
+		)
+		.run(now, now, now);
+	actor = {
+		id: 'test-user',
+		email: 'test@example.org',
+		displayName: 'Test',
+		role: 'barkeeper',
+		lockedAtUtc: null
+	};
+});
+
+afterEach(() => {
+	closeDatabase();
+	delete process.env.SENDEWERK_DB_PATH;
+	delete process.env.SENDEWERK_UPLOAD_DIR;
+	rmSync(directory, { recursive: true, force: true });
+});
+
+function request(token: string, key?: string) {
+	return new Request('https://sendewerk.test/api/v1/pieces', {
+		headers: { Authorization: `Bearer ${token}`, ...(key ? { 'Idempotency-Key': key } : {}) }
+	});
+}
+
+describe('technical API access', () => {
+	it('enforces permissions and revocation without storing the raw token', () => {
+		const created = createTechnicalAccess(actor, 'Leser', 'read');
+		expect(authenticateTechnical(request(created.token))).toMatchObject({
+			name: 'Leser',
+			permissions: 'read'
+		});
+		expect(() => authenticateTechnical(request(created.token), true)).toThrow('API_FORBIDDEN');
+		expect(
+			getDatabase()
+				.prepare('SELECT token_hash FROM technical_accesses WHERE id = ?')
+				.get(created.id)
+		).not.toMatchObject({ token_hash: created.token });
+		revokeTechnicalAccess(actor, created.id);
+		expect(() => authenticateTechnical(request(created.token))).toThrow('API_UNAUTHORIZED');
+	});
+
+	it('replays an identical idempotent write and rejects a changed payload', () => {
+		const created = createTechnicalAccess(actor, 'Schreiber', 'read_write');
+		const technical = authenticateTechnical(request(created.token), true);
+		let calls = 0;
+		const first = idempotentResponse(
+			technical,
+			request(created.token, 'command-1'),
+			{ title: 'A' },
+			() => ({ status: 201, body: { calls: ++calls } })
+		);
+		const replay = idempotentResponse(
+			technical,
+			request(created.token, 'command-1'),
+			{ title: 'A' },
+			() => ({ status: 201, body: { calls: ++calls } })
+		);
+		expect(first.duplicate).toBe(false);
+		expect(replay).toMatchObject({ duplicate: true, body: { calls: 1 } });
+		expect(calls).toBe(1);
+		expect(() =>
+			idempotentResponse(technical, request(created.token, 'command-1'), { title: 'B' }, () => ({
+				status: 201,
+				body: {}
+			}))
+		).toThrow('API_IDEMPOTENCY_CONFLICT');
+	});
+});
@@ -0,0 +1,151 @@
+import { createHash, randomBytes, randomUUID } from 'node:crypto';
+import type { AuthUser } from './auth.js';
+import { getDatabase } from './database.js';
+
+export type TechnicalPermission = 'read' | 'read_write';
+export type TechnicalActor = { id: string; name: string; permissions: TechnicalPermission };
+
+function tokenHash(token: string) {
+	return createHash('sha256').update(token).digest('hex');
+}
+
+export function listTechnicalAccesses() {
+	return getDatabase()
+		.prepare(
+			`SELECT id, name, permissions, created_at_utc AS createdAtUtc,
+		last_used_at_utc AS lastUsedAtUtc, revoked_at_utc AS revokedAtUtc FROM technical_accesses ORDER BY name`
+		)
+		.all() as {
+		id: string;
+		name: string;
+		permissions: TechnicalPermission;
+		createdAtUtc: string;
+		lastUsedAtUtc: string | null;
+		revokedAtUtc: string | null;
+	}[];
+}
+
+export function createTechnicalAccess(actor: AuthUser, nameValue: string, permissions: string) {
+	const name = nameValue.trim();
+	if (!name || name.length > 120 || !['read', 'read_write'].includes(permissions))
+		throw new Error('INVALID_ACCESS');
+	const token = randomBytes(32).toString('base64url');
+	const id = randomUUID();
+	const now = new Date().toISOString();
+	getDatabase()
+		.prepare(
+			`INSERT INTO technical_accesses
+		(id, name, token_hash, permissions, created_by_user_id, created_at_utc) VALUES (?, ?, ?, ?, ?, ?)`
+		)
+		.run(id, name, tokenHash(token), permissions, actor.id, now);
+	auditTechnical(
+		{ id: actor.id, name: actor.displayName, permissions: 'read_write' },
+		'technical_access.create',
+		'technical_access',
+		id,
+		'user'
+	);
+	return { id, token };
+}
+
+export function revokeTechnicalAccess(actor: AuthUser, id: string) {
+	const result = getDatabase()
+		.prepare(
+			'UPDATE technical_accesses SET revoked_at_utc = ? WHERE id = ? AND revoked_at_utc IS NULL'
+		)
+		.run(new Date().toISOString(), id);
+	if (!result.changes) throw new Error('NOT_FOUND');
+	auditTechnical(
+		{ id: actor.id, name: actor.displayName, permissions: 'read_write' },
+		'technical_access.revoke',
+		'technical_access',
+		id,
+		'user'
+	);
+}
+
+export function authenticateTechnical(request: Request, write = false): TechnicalActor {
+	const authorization = request.headers.get('authorization') ?? '';
+	const token = authorization.startsWith('Bearer ') ? authorization.slice(7).trim() : '';
+	if (!token) throw new Error('API_UNAUTHORIZED');
+	const row = getDatabase()
+		.prepare(
+			`SELECT id, name, permissions FROM technical_accesses
+		WHERE token_hash = ? AND revoked_at_utc IS NULL`
+		)
+		.get(tokenHash(token)) as TechnicalActor | undefined;
+	if (!row) throw new Error('API_UNAUTHORIZED');
+	if (write && row.permissions !== 'read_write') throw new Error('API_FORBIDDEN');
+	getDatabase()
+		.prepare('UPDATE technical_accesses SET last_used_at_utc = ? WHERE id = ?')
+		.run(new Date().toISOString(), row.id);
+	return row;
+}
+
+export function auditTechnical(
+	actor: TechnicalActor,
+	action: string,
+	targetType: string,
+	targetId: string,
+	actorType: 'technical' | 'user' = 'technical'
+) {
+	getDatabase()
+		.prepare(
+			`INSERT INTO audit_events (id, actor_type, actor_id, action, target_type, target_id, created_at_utc)
+		VALUES (?, ?, ?, ?, ?, ?, ?)`
+		)
+		.run(
+			randomUUID(),
+			actorType,
+			actor.id,
+			action.slice(0, 120),
+			targetType.slice(0, 80),
+			targetId.slice(0, 200),
+			new Date().toISOString()
+		);
+}
+
+export function idempotentResponse(
+	actor: TechnicalActor,
+	request: Request,
+	body: unknown,
+	operation: () => { status: number; body: unknown }
+) {
+	const key = request.headers.get('idempotency-key')?.trim() ?? '';
+	if (!key || key.length > 200) throw new Error('API_IDEMPOTENCY_REQUIRED');
+	const hash = createHash('sha256')
+		.update(`${request.method} ${new URL(request.url).pathname}\n${JSON.stringify(body)}`)
+		.digest('hex');
+	const database = getDatabase();
+	return database.transaction(() => {
+		const existing = database
+			.prepare(
+				'SELECT request_hash, status_code, response_json FROM api_idempotency WHERE access_id = ? AND request_key = ?'
+			)
+			.get(actor.id, key) as
+			{ request_hash: string; status_code: number; response_json: string } | undefined;
+		if (existing) {
+			if (existing.request_hash !== hash) throw new Error('API_IDEMPOTENCY_CONFLICT');
+			return {
+				status: existing.status_code,
+				body: JSON.parse(existing.response_json),
+				duplicate: true
+			};
+		}
+		const result = operation();
+		database
+			.prepare(
+				`INSERT INTO api_idempotency
+			(access_id, request_key, request_hash, status_code, response_json, created_at_utc) VALUES (?, ?, ?, ?, ?, ?)`
+			)
+			.run(
+				actor.id,
+				key,
+				hash,
+				result.status,
+				JSON.stringify(result.body),
+				new Date().toISOString()
+			);
+		return { ...result, duplicate: false };
+	})();
+}
@@ -0,0 +1,12 @@
+import { describe, expect, it } from 'vitest';
+import { berlinLocalToUtc } from './time.js';
+
+describe('Berlin local time conversion', () => {
+	it('converts valid civil time and rejects normalized or nonexistent values', () => {
+		expect(berlinLocalToUtc('2026-10-25T20:00')).toBe('2026-10-25T19:00:00.000Z');
+		expect(berlinLocalToUtc('')).toBeNull();
+		expect(() => berlinLocalToUtc('2026-02-31T12:00')).toThrow('INVALID_TIMESTAMP');
+		expect(() => berlinLocalToUtc('2026-03-29T02:30', 'INVALID_EXPIRY')).toThrow('INVALID_EXPIRY');
+		expect(() => berlinLocalToUtc('2026-10-25T02:30', 'INVALID_EXPIRY')).toThrow('INVALID_EXPIRY');
+	});
+});
@@ -0,0 +1,44 @@
+export function berlinLocalToUtc(value: string, errorCode = 'INVALID_TIMESTAMP'): string | null {
+	if (!value) return null;
+	const match = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2})$/.exec(value);
+	if (!match) throw new Error(errorCode);
+	const parts = match.slice(1).map(Number);
+	const localMilliseconds = Date.UTC(parts[0], parts[1] - 1, parts[2], parts[3], parts[4]);
+	let candidate = localMilliseconds;
+	const formatter = new Intl.DateTimeFormat('en-CA', {
+		timeZone: 'Europe/Berlin',
+		year: 'numeric',
+		month: '2-digit',
+		day: '2-digit',
+		hour: '2-digit',
+		minute: '2-digit',
+		hourCycle: 'h23'
+	});
+	const localParts = (date: Date) => {
+		const formatted = formatter.formatToParts(date);
+		const read = (type: Intl.DateTimeFormatPartTypes) =>
+			formatted.find((part) => part.type === type)?.value ?? '';
+		return {
+			key: `${read('year')}-${read('month')}-${read('day')}T${read('hour')}:${read('minute')}`,
+			milliseconds: Date.UTC(
+				Number(read('year')),
+				Number(read('month')) - 1,
+				Number(read('day')),
+				Number(read('hour')),
+				Number(read('minute'))
+			)
+		};
+	};
+	for (let attempt = 0; attempt < 2; attempt += 1) {
+		candidate += localMilliseconds - localParts(new Date(candidate)).milliseconds;
+	}
+	const result = new Date(candidate);
+	if (localParts(result).key !== value) throw new Error(errorCode);
+	if (
+		localParts(new Date(candidate - 60 * 60 * 1000)).key === value ||
+		localParts(new Date(candidate + 60 * 60 * 1000)).key === value
+	) {
+		throw new Error(errorCode);
+	}
+	return result.toISOString();
+}
@@ -1,7 +1,11 @@
 import type { LayoutServerLoad } from './$types';

 export const load: LayoutServerLoad = ({ locals, url }) => ({
-	user: url.pathname.startsWith('/heinzlive/') ? null : locals.user,
+	user:
+		url.pathname.startsWith('/heinzlive/') || url.pathname.startsWith('/freigabe/')
+			? null
+			: locals.user,
 	presentationMode: url.pathname.startsWith('/heinzlive/'),
+	guestMode: url.pathname.startsWith('/freigabe/'),
 	liveControllerMode: url.pathname === '/live'
 });
@@ -34,6 +34,17 @@

 {#if data.presentationMode}
 	{@render children()}
+{:else if data.guestMode}
+	<div class="guest-shell">
+		<header class="auth-header">
+			<span class="brand"
+				><span class="brand-mark" aria-hidden="true"><i></i><i></i><i></i></span><span
+					>Sendewerk</span
+				></span
+			><ThemeToggle />
+		</header>
+		{@render children()}
+	</div>
 {:else if data.user && data.liveControllerMode}
 	<main id="main-content" class="live-controller-shell">{@render children()}</main>
 {:else if data.user}
@@ -0,0 +1,105 @@
+import { json } from '@sveltejs/kit';
+import type { RequestHandler } from './$types';
+
+const id = { name: 'id', in: 'path', required: true, schema: { type: 'string' } };
+const usageId = { name: 'usageId', in: 'path', required: true, schema: { type: 'string' } };
+const idempotency = {
+	name: 'Idempotency-Key',
+	in: 'header',
+	required: true,
+	schema: { type: 'string' }
+};
+const ok = { '200': { description: 'Erfolgreich' } };
+const jsonBody = (schema: Record<string, unknown>) => ({
+	required: true,
+	content: { 'application/json': { schema } }
+});
+
+export const GET: RequestHandler = () =>
+	json({
+		openapi: '3.1.0',
+		info: {
+			title: 'Sendewerk API',
+			version: '1.0.0',
+			description:
+				'Versionierte API für technische Redaktionszugänge. Schreibzugriffe benötigen einen Idempotency-Key.'
+		},
+		servers: [{ url: '/api/v1' }],
+		security: [{ bearerAuth: [] }],
+		components: {
+			securitySchemes: {
+				bearerAuth: { type: 'http', scheme: 'bearer', bearerFormat: 'Sendewerk technical token' }
+			},
+			schemas: {
+				PieceWrite: {
+					type: 'object',
+					properties: {
+						title: { type: 'string' },
+						summary: { type: 'string' },
+						status: { enum: ['inbox', 'preparing', 'ready'] },
+						durationSeconds: { type: 'integer', minimum: 0 }
+					}
+				},
+				ShowWrite: {
+					type: 'object',
+					required: ['title'],
+					properties: {
+						title: { type: 'string' },
+						startsAtUtc: { type: ['string', 'null'], format: 'date-time' },
+						templateId: { type: ['string', 'null'] }
+					}
+				}
+			}
+		},
+		paths: {
+			'/pieces': {
+				get: { summary: 'Pieces lesen', responses: ok },
+				post: {
+					summary: 'Piece anlegen',
+					parameters: [idempotency],
+					requestBody: jsonBody({ $ref: '#/components/schemas/PieceWrite' }),
+					responses: { '201': { description: 'Angelegt' } }
+				}
+			},
+			'/pieces/{id}': {
+				get: { summary: 'Piece lesen', parameters: [id], responses: ok },
+				patch: {
+					summary: 'Piece ändern',
+					parameters: [id],
+					requestBody: jsonBody({
+						allOf: [
+							{ $ref: '#/components/schemas/PieceWrite' },
+							{ type: 'object', required: ['revision'] }
+						]
+					}),
+					responses: ok
+				}
+			},
+			'/shows': {
+				get: { summary: 'Sendungen lesen', responses: ok },
+				post: {
+					summary: 'Sendung anlegen',
+					parameters: [idempotency],
+					requestBody: jsonBody({ $ref: '#/components/schemas/ShowWrite' }),
+					responses: { '201': { description: 'Angelegt' } }
+				}
+			},
+			'/shows/{id}': { get: { summary: 'Sendung lesen', parameters: [id], responses: ok } },
+			'/shows/{id}/usages': {
+				post: {
+					summary: 'Piece einplanen',
+					parameters: [id, idempotency],
+					requestBody: jsonBody({ type: 'object', required: ['revision', 'pieceId'] }),
+					responses: { '201': { description: 'Eingeplant' } }
+				}
+			},
+			'/shows/{id}/usages/{usageId}': {
+				patch: {
+					summary: 'Einplanung sortieren',
+					parameters: [id, usageId, idempotency],
+					requestBody: jsonBody({ type: 'object', required: ['revision', 'position'] }),
+					responses: ok
+				}
+			}
+		}
+	});
@@ -0,0 +1,69 @@
+import { json } from '@sveltejs/kit';
+import type { RequestHandler } from './$types';
+import { apiBody, apiFailure, pageInput } from '#lib/server/api-http.js';
+import {
+	createPiece,
+	getPiece,
+	listPieces,
+	savePiece,
+	type PieceStatus
+} from '#lib/server/content.js';
+import {
+	auditTechnical,
+	authenticateTechnical,
+	idempotentResponse
+} from '#lib/server/technical-access.js';
+
+export const GET: RequestHandler = ({ request, url }) => {
+	try {
+		authenticateTechnical(request);
+		const { limit, offset } = pageInput(url);
+		const status = url.searchParams.get('status') as PieceStatus | null;
+		const statuses = status ? [status] : (['inbox', 'preparing', 'ready'] as PieceStatus[]);
+		const all = listPieces({ statuses, query: url.searchParams.get('q') ?? '' });
+		return json({
+			data: all.slice(offset, offset + limit),
+			pagination: { limit, offset, total: all.length }
+		});
+	} catch (cause) {
+		return apiFailure(cause);
+	}
+};
+
+export const POST: RequestHandler = async ({ request }) => {
+	try {
+		const actor = authenticateTechnical(request, true);
+		const body = await apiBody(request);
+		const result = idempotentResponse(actor, request, body, () => {
+			const id = createPiece('blank');
+			const piece = getPiece(id)!;
+			savePiece(id, piece.revision, {
+				...piece,
+				title: String(body.title ?? ''),
+				summary: String(body.summary ?? ''),
+				status: ['inbox', 'preparing', 'ready'].includes(String(body.status))
+					? (body.status as 'inbox' | 'preparing' | 'ready')
+					: 'preparing',
+				durationSeconds: Number(body.durationSeconds ?? 0),
+				sources: Array.isArray(body.sources)
+					? body.sources.map((source) => ({
+							label: String((source as Record<string, unknown>).label ?? ''),
+							url: String((source as Record<string, unknown>).url ?? ''),
+							timecodeSeconds:
+								(source as Record<string, unknown>).timecodeSeconds == null
+									? null
+									: Number((source as Record<string, unknown>).timecodeSeconds)
+						}))
+					: []
+			});
+			auditTechnical(actor, 'piece.create', 'piece', id);
+			return { status: 201, body: { data: getPiece(id) } };
+		});
+		return json(result.body, {
+			status: result.status,
+			headers: { 'Idempotency-Replayed': result.duplicate ? 'true' : 'false' }
+		});
+	} catch (cause) {
+		return apiFailure(cause);
+	}
+};
@@ -0,0 +1,44 @@
+import { json } from '@sveltejs/kit';
+import type { RequestHandler } from './$types';
+import { apiBody, apiFailure } from '#lib/server/api-http.js';
+import { getPiece, savePiece } from '#lib/server/content.js';
+import { auditTechnical, authenticateTechnical } from '#lib/server/technical-access.js';
+
+export const GET: RequestHandler = ({ request, params }) => {
+	try {
+		authenticateTechnical(request);
+		const piece = getPiece(params.id);
+		if (!piece) throw new Error('NOT_FOUND');
+		return json({ data: piece });
+	} catch (cause) {
+		return apiFailure(cause);
+	}
+};
+
+export const PATCH: RequestHandler = async ({ request, params }) => {
+	try {
+		const actor = authenticateTechnical(request, true);
+		const body = await apiBody(request);
+		const piece = getPiece(params.id);
+		if (!piece) throw new Error('NOT_FOUND');
+		if (piece.status === 'archived') throw new Error('INVALID_STATUS');
+		if (Number(body.revision) !== piece.revision) throw new Error('CONFLICT');
+		const status =
+			body.status !== undefined
+				? (String(body.status) as 'inbox' | 'preparing' | 'ready')
+				: piece.status;
+		savePiece(params.id, piece.revision, {
+			...piece,
+			status,
+			...(body.title !== undefined ? { title: String(body.title) } : {}),
+			...(body.summary !== undefined ? { summary: String(body.summary) } : {}),
+			...(body.durationSeconds !== undefined
+				? { durationSeconds: Number(body.durationSeconds) }
+				: {})
+		});
+		auditTechnical(actor, 'piece.update', 'piece', params.id);
+		return json({ data: getPiece(params.id) });
+	} catch (cause) {
+		return apiFailure(cause);
+	}
+};
@@ -0,0 +1,45 @@
+import { json } from '@sveltejs/kit';
+import type { RequestHandler } from './$types';
+import { apiBody, apiFailure, pageInput } from '#lib/server/api-http.js';
+import { createShow, getShow, listShows } from '#lib/server/shows.js';
+import {
+	auditTechnical,
+	authenticateTechnical,
+	idempotentResponse
+} from '#lib/server/technical-access.js';
+
+export const GET: RequestHandler = ({ request, url }) => {
+	try {
+		authenticateTechnical(request);
+		const { limit, offset } = pageInput(url);
+		const all = listShows();
+		return json({
+			data: all.slice(offset, offset + limit),
+			pagination: { limit, offset, total: all.length }
+		});
+	} catch (cause) {
+		return apiFailure(cause);
+	}
+};
+
+export const POST: RequestHandler = async ({ request }) => {
+	try {
+		const actor = authenticateTechnical(request, true);
+		const body = await apiBody(request);
+		const result = idempotentResponse(actor, request, body, () => {
+			const created = createShow({
+				title: String(body.title ?? ''),
+				startsAtUtc: body.startsAtUtc ? String(body.startsAtUtc) : null,
+				templateId: body.templateId ? String(body.templateId) : null
+			});
+			auditTechnical(actor, 'show.create', 'show', created.id);
+			return { status: 201, body: { data: getShow(created.id) } };
+		});
+		return json(result.body, {
+			status: result.status,
+			headers: { 'Idempotency-Replayed': result.duplicate ? 'true' : 'false' }
+		});
+	} catch (cause) {
+		return apiFailure(cause);
+	}
+};
@@ -0,0 +1,16 @@
+import { json } from '@sveltejs/kit';
+import type { RequestHandler } from './$types';
+import { apiFailure } from '#lib/server/api-http.js';
+import { getShow } from '#lib/server/shows.js';
+import { authenticateTechnical } from '#lib/server/technical-access.js';
+
+export const GET: RequestHandler = ({ request, params }) => {
+	try {
+		authenticateTechnical(request);
+		const show = getShow(params.id);
+		if (!show) throw new Error('NOT_FOUND');
+		return json({ data: show });
+	} catch (cause) {
+		return apiFailure(cause);
+	}
+};
@@ -0,0 +1,31 @@
+import { json } from '@sveltejs/kit';
+import type { RequestHandler } from './$types';
+import { apiBody, apiFailure } from '#lib/server/api-http.js';
+import { addPieceUsage, getShow } from '#lib/server/shows.js';
+import {
+	auditTechnical,
+	authenticateTechnical,
+	idempotentResponse
+} from '#lib/server/technical-access.js';
+
+export const POST: RequestHandler = async ({ request, params }) => {
+	try {
+		const actor = authenticateTechnical(request, true);
+		const body = await apiBody(request);
+		const result = idempotentResponse(actor, request, body, () => {
+			const created = addPieceUsage(params.id, Number(body.revision), {
+				pieceId: String(body.pieceId ?? ''),
+				sectionId: body.sectionId ? String(body.sectionId) : null,
+				position: body.position == null ? undefined : Number(body.position)
+			});
+			auditTechnical(actor, 'usage.create', 'usage', created.id);
+			return { status: 201, body: { data: getShow(params.id), usageId: created.id } };
+		});
+		return json(result.body, {
+			status: result.status,
+			headers: { 'Idempotency-Replayed': result.duplicate ? 'true' : 'false' }
+		});
+	} catch (cause) {
+		return apiFailure(cause);
+	}
+};
@@ -0,0 +1,30 @@
+import { json } from '@sveltejs/kit';
+import type { RequestHandler } from './$types';
+import { apiBody, apiFailure } from '#lib/server/api-http.js';
+import { getShow, movePieceUsage } from '#lib/server/shows.js';
+import {
+	auditTechnical,
+	authenticateTechnical,
+	idempotentResponse
+} from '#lib/server/technical-access.js';
+
+export const PATCH: RequestHandler = async ({ request, params }) => {
+	try {
+		const actor = authenticateTechnical(request, true);
+		const body = await apiBody(request);
+		const result = idempotentResponse(actor, request, body, () => {
+			movePieceUsage(params.id, params.usageId, Number(body.revision), {
+				sectionId: body.sectionId ? String(body.sectionId) : null,
+				position: Number(body.position)
+			});
+			auditTechnical(actor, 'usage.move', 'usage', params.usageId);
+			return { status: 200, body: { data: getShow(params.id) } };
+		});
+		return json(result.body, {
+			status: result.status,
+			headers: { 'Idempotency-Replayed': result.duplicate ? 'true' : 'false' }
+		});
+	} catch (cause) {
+		return apiFailure(cause);
+	}
+};
@@ -1,11 +1,15 @@
-import { fail } from '@sveltejs/kit';
+import { fail, redirect } from '@sveltejs/kit';
+import { randomUUID } from 'node:crypto';
 import type { Actions, PageServerLoad } from './$types';
 import { requireUser } from '#lib/server/auth.js';
 import { listPieces, setPieceArchived, setPieceDeleted } from '#lib/server/content.js';
+import { duplicateCompletedShow, listShows } from '#lib/server/shows.js';

 export const load: PageServerLoad = ({ locals }) => {
 	requireUser(locals.user);
 	return {
+		completedShows: listShows(['completed']),
+		duplicateCommandId: randomUUID(),
 		pieces: listPieces({ statuses: ['archived'] }),
 		deletedPieces: listPieces({
 			statuses: ['inbox', 'preparing', 'ready', 'archived'],
@@ -34,5 +38,19 @@ export const actions = {
 		} catch {
 			return fail(409, { error: 'Das Piece wurde inzwischen geändert. Bitte Seite neu laden.' });
 		}
+	},
+	duplicateShow: async ({ locals, request }) => {
+		requireUser(locals.user);
+		const data = await request.formData();
+		try {
+			const duplicate = duplicateCompletedShow(
+				String(data.get('showId') || ''),
+				String(data.get('commandId') || '')
+			);
+			redirect(303, `/sendungen/${duplicate.id}`);
+		} catch (cause) {
+			if (cause && typeof cause === 'object' && 'status' in cause) throw cause;
+			return fail(400, { error: 'Die Sendung konnte nicht dupliziert werden.' });
+		}
 	}
 } satisfies Actions;
@@ -1,5 +1,7 @@
 <script lang="ts">
 	import AppIcon from '#lib/components/AppIcon.svelte';
+	import { resolve } from '$app/paths';
+	import { formatDuration } from '#lib/format.js';
 	import type { PageProps } from './$types';
 	let { data, form }: PageProps = $props();
 </script>
@@ -9,10 +11,29 @@
 <div class="page-wrap narrow-page">
 	<header class="page-heading">
 		<h1>Archiv</h1>
-		<p class="page-intro">Abgelegte Pieces; abgeschlossene Sendungen folgen in Etappe 6.</p>
+		<p class="page-intro">Stabile Sendungshistorie und bewusst abgelegte Fundus-Pieces.</p>
 	</header>
 	{#if form?.error}<div class="form-message error" role="alert">{form.error}</div>{/if}
 	{#if form?.success}<div class="form-message success" role="status">{form.success}</div>{/if}
+	<section aria-labelledby="completed-shows-title">
+		<h2 id="completed-shows-title" class="section-heading">Abgeschlossene Sendungen</h2>
+		{#if data.completedShows.length}<div class="archive-list">
+				{#each data.completedShows as show (show.id)}<article>
+						<div>
+							<h2><a href={resolve('/sendungen/[id]', { id: show.id })}>{show.title}</a></h2>
+							<p>
+								{show.sectionCount} Abschnitte · {formatDuration(show.totalDurationSeconds)} Planzeit
+							</p>
+						</div>
+						<form method="POST" action="?/duplicateShow">
+							<input type="hidden" name="showId" value={show.id} />
+							<input type="hidden" name="commandId" value={data.duplicateCommandId} />
+							<button class="secondary-button" type="submit">Als neue Sendung duplizieren</button>
+						</form>
+					</article>{/each}
+			</div>{:else}<p class="context-empty">Noch keine Sendung historisch abgeschlossen.</p>{/if}
+	</section>
+	<h2 class="section-heading">Archivierte Pieces</h2>
 	{#if data.pieces.length}<div class="archive-list">
 			{#each data.pieces as piece (piece.id)}<article>
 					<div>
@@ -1,11 +1,16 @@
 import { fail } from '@sveltejs/kit';
 import type { Actions, PageServerLoad } from './$types';
 import { requireUser } from '#lib/server/auth.js';
-import { captureInbox, listPieces, setPieceDeleted } from '#lib/server/content.js';
+import { captureInbox, getTaxonomy, listPieces, setPieceDeleted } from '#lib/server/content.js';
+import { discardFeedEntries, importFeedEntries, listFeedEntries } from '#lib/server/feeds.js';

 export const load: PageServerLoad = ({ locals }) => {
 	requireUser(locals.user);
-	return { pieces: listPieces({ statuses: ['inbox'] }) };
+	return {
+		pieces: listPieces({ statuses: ['inbox'] }),
+		feedEntries: listFeedEntries(),
+		taxonomy: getTaxonomy()
+	};
 };

 export const actions = {
@@ -36,5 +41,27 @@ export const actions = {
 		} catch {
 			return fail(409, { error: 'Das Piece wurde inzwischen geändert. Bitte neu laden.' });
 		}
+	},
+	importFeeds: async ({ locals, request }) => {
+		requireUser(locals.user);
+		const data = await request.formData();
+		const entryIds = data.getAll('entryIds').map(String);
+		if (!entryIds.length) return fail(400, { feedError: 'Mindestens einen Beitrag auswählen.' });
+		try {
+			const pieceIds = importFeedEntries(entryIds, data.getAll('categoryIds').map(String));
+			return {
+				feedSuccess: `${pieceIds.length} ${pieceIds.length === 1 ? 'Beitrag' : 'Beiträge'} in den Eingang übernommen.`
+			};
+		} catch {
+			return fail(400, { feedError: 'Die Auswahl konnte nicht übernommen werden.' });
+		}
+	},
+	discardFeeds: async ({ locals, request }) => {
+		requireUser(locals.user);
+		const data = await request.formData();
+		const entryIds = data.getAll('entryIds').map(String);
+		if (!entryIds.length) return fail(400, { feedError: 'Mindestens einen Beitrag auswählen.' });
+		const count = discardFeedEntries(entryIds);
+		return { feedSuccess: `${count} ${count === 1 ? 'Beitrag' : 'Beiträge'} verworfen.` };
 	}
 } satisfies Actions;
@@ -1,4 +1,5 @@
 <script lang="ts">
+	/* eslint-disable svelte/no-navigation-without-resolve -- RSS links are validated external URLs. */
 	import { resolve } from '$app/paths';
 	import AppIcon from '#lib/components/AppIcon.svelte';
 	import type { PageProps } from './$types';
@@ -43,6 +44,65 @@
 			<button class="primary-button" type="submit">Im Eingang ablegen</button>
 		</form>
 	</section>
+	<section class="quiet-panel feed-inbox">
+		<div class="panel-heading">
+			<div>
+				<p class="eyebrow">RSS-Importeingang</p>
+				<h2>Beiträge sichten</h2>
+			</div>
+			<span>{data.feedEntries.length} neu</span>
+		</div>
+		<p>Beiträge bleiben hier getrennt, bis du sie auswählst und in den Fundus übernimmst.</p>
+		{#if form?.feedError}<div class="form-message error" role="alert">{form.feedError}</div>{/if}
+		{#if form?.feedSuccess}<div class="form-message success" role="status">
+				{form.feedSuccess}
+			</div>{/if}
+		{#if data.feedEntries.length}
+			<form method="POST" class="feed-selection">
+				<fieldset class="feed-categories">
+					<legend>Kategorien für die Auswahl <span>(Feed-Standard gilt ohne Auswahl)</span></legend>
+					{#each data.taxonomy.categories as category (category.id)}
+						<label
+							><input type="checkbox" name="categoryIds" value={category.id} />
+							{category.name}</label
+						>
+					{/each}
+				</fieldset>
+				<div class="feed-entry-list">
+					{#each data.feedEntries as entry (entry.id)}
+						<label class="feed-entry">
+							<input type="checkbox" name="entryIds" value={entry.id} />
+							<span
+								><small
+									>{entry.feedName}{entry.publishedAtUtc
+										? ` · ${new Date(entry.publishedAtUtc).toLocaleDateString('de-DE')}`
+										: ''}</small
+								><strong>{entry.title}</strong>{#if entry.summary}<span>{entry.summary}</span>{/if}
+								<a
+									href={entry.url}
+									target="_blank"
+									rel="noreferrer"
+									onclick={(event) => event.stopPropagation()}>Original öffnen</a
+								></span
+							>
+						</label>
+					{/each}
+				</div>
+				<div class="feed-actions">
+					<button class="primary-button" type="submit" formaction="?/importFeeds"
+						>Auswahl übernehmen</button
+					>
+					<button class="text-button danger-text" type="submit" formaction="?/discardFeeds"
+						>Auswahl verwerfen</button
+					>
+				</div>
+			</form>
+		{:else}
+			<p class="empty-copy">
+				Keine neuen Feed-Beiträge. Aktivierte Feeds werden automatisch abgerufen.
+			</p>
+		{/if}
+	</section>
 	{#if data.pieces.length}
 		<section class="inbox-list">
 			<h2>{data.pieces.length} {data.pieces.length === 1 ? 'offener Inhalt' : 'offene Inhalte'}</h2>
@@ -81,3 +141,59 @@
 			<p>Neue Gedanken und Links können oben direkt aufgenommen werden.</p>
 		</section>{/if}
 </div>
+
+<style>
+	.feed-inbox {
+		display: grid;
+		gap: 1rem;
+		margin-block: 1.5rem;
+	}
+	.feed-selection,
+	.feed-entry-list {
+		display: grid;
+		gap: 0.75rem;
+	}
+	.feed-categories {
+		display: flex;
+		flex-wrap: wrap;
+		gap: 0.6rem 1rem;
+		border: 0;
+		padding: 0;
+	}
+	.feed-categories legend {
+		width: 100%;
+		font-weight: 700;
+		margin-bottom: 0.45rem;
+	}
+	.feed-categories legend span {
+		font-weight: 400;
+		color: var(--color-text-muted);
+	}
+	.feed-entry {
+		display: grid;
+		grid-template-columns: auto 1fr;
+		gap: 0.8rem;
+		align-items: start;
+		padding: 0.9rem;
+		border: 1px solid var(--color-border);
+		border-radius: 0.7rem;
+		cursor: pointer;
+	}
+	.feed-entry > span {
+		display: grid;
+		gap: 0.25rem;
+		min-width: 0;
+	}
+	.feed-entry small {
+		color: var(--color-text-muted);
+	}
+	.feed-entry a {
+		width: fit-content;
+	}
+	.feed-actions {
+		display: flex;
+		flex-wrap: wrap;
+		gap: 0.75rem;
+		align-items: center;
+	}
+</style>
@@ -0,0 +1,31 @@
+import { fail } from '@sveltejs/kit';
+import type { Actions, PageServerLoad } from './$types';
+import { getAuthConfig } from '#lib/server/config.js';
+import { authenticateShare, getSharedShow, SHARE_SESSION_COOKIE } from '#lib/server/shares.js';
+
+export const load: PageServerLoad = ({ params, cookies }) => {
+	return getSharedShow(params.token, cookies.get(SHARE_SESSION_COOKIE));
+};
+
+export const actions = {
+	password: async ({ params, request, cookies, getClientAddress }) => {
+		const data = await request.formData();
+		try {
+			const session = await authenticateShare(
+				params.token,
+				String(data.get('password') || ''),
+				getClientAddress()
+			);
+			cookies.set(SHARE_SESSION_COOKIE, session.token, {
+				path: `/freigabe/${params.token}`,
+				httpOnly: true,
+				sameSite: 'strict',
+				secure: getAuthConfig().secureCookies,
+				expires: session.expires
+			});
+			return { success: true };
+		} catch {
+			return fail(401, { error: 'Passwort falsch oder Freigabe nicht mehr verfügbar.' });
+		}
+	}
+} satisfies Actions;
@@ -0,0 +1,141 @@
+<script lang="ts">
+	import { page } from '$app/state';
+	import { formatDuration } from '#lib/format.js';
+	import type { PageProps } from './$types';
+
+	let { data, form }: PageProps = $props();
+
+	function berlinDate(value: string | null) {
+		if (!value) return 'Termin nicht angegeben';
+		return new Intl.DateTimeFormat('de-DE', {
+			timeZone: 'Europe/Berlin',
+			dateStyle: 'full',
+			timeStyle: 'short'
+		}).format(new Date(value));
+	}
+</script>
+
+<svelte:head><title>Sendungsfreigabe | Sendewerk</title></svelte:head>
+
+<main class="share-page">
+	{#if data.status === 'unavailable'}
+		<section class="quiet-panel share-gate">
+			<p class="eyebrow">Lesefreigabe</p>
+			<h1>Nicht verfügbar</h1>
+			<p>Dieser Link ist ungültig, abgelaufen oder wurde widerrufen.</p>
+		</section>
+	{:else if data.status === 'password'}
+		<section class="quiet-panel share-gate">
+			<p class="eyebrow">Geschützte Lesefreigabe</p>
+			<h1>Passwort erforderlich</h1>
+			{#if form?.error}<div class="form-message error" role="alert">{form.error}</div>{/if}
+			<form method="POST" action="?/password" class="compact-form">
+				<label
+					>Passwort<input
+						name="password"
+						type="password"
+						required
+						autocomplete="current-password"
+					/></label
+				>
+				<button class="primary-button" type="submit">Sendung öffnen</button>
+			</form>
+		</section>
+	{:else}
+		<header class="share-heading">
+			<p class="eyebrow">
+				{data.share.isCompleted ? 'Abgeschlossene Sendung' : 'Aktuelle Sendungsplanung'} · Nur lesen
+			</p>
+			<h1>{data.share.title}</h1>
+			<p>{berlinDate(data.share.startsAtUtc)} Uhr</p>
+		</header>
+		<div class="shared-rundown">
+			{#each data.share.sections as section (section)}
+				<section class="quiet-panel shared-section">
+					<header>
+						<div>
+							{#if section.category}<small
+									style={`--tax-color: ${section.categoryColor ?? '#67dde8'}`}
+									>{section.category}</small
+								>{/if}
+							<h2>{section.name}</h2>
+						</div>
+						{#if section.explicitDurationSeconds !== null}<span
+								>{formatDuration(section.explicitDurationSeconds)}</span
+							>{/if}
+					</header>
+					{#each section.usages as usage (usage)}
+						<article class="shared-usage">
+							<div class="shared-usage-heading">
+								<div>
+									<small
+										>{usage.status === 'done'
+											? 'Gesendet'
+											: usage.status === 'skipped'
+												? 'Übersprungen'
+												: 'Offen'}</small
+									>
+									<h3>{usage.title}</h3>
+								</div>
+								<span>{formatDuration(usage.actualDurationSeconds || usage.durationSeconds)}</span>
+							</div>
+							{#if usage.media}<img
+									src={`${page.url.pathname}/media/${usage.media.id}`}
+									alt={usage.media.alt_text}
+								/>{/if}
+							{#if 'introHtml' in usage && usage.introHtml}<div class="shared-copy">
+									<strong>Einleitung</strong>
+									<!-- HTML is produced exclusively by the server-side allowlist sanitizer. -->
+									<!-- eslint-disable-next-line svelte/no-at-html-tags -->
+									<div>{@html usage.introHtml}</div>
+								</div>{/if}
+							{#if 'moderationHtml' in usage && usage.moderationHtml}<div class="shared-copy">
+									<strong>Moderation</strong>
+									<!-- HTML is produced exclusively by the server-side allowlist sanitizer. -->
+									<!-- eslint-disable-next-line svelte/no-at-html-tags -->
+									<div>{@html usage.moderationHtml}</div>
+								</div>{/if}
+							{#if 'interactionHtml' in usage && usage.interactionHtml}<div class="shared-copy">
+									<strong>Interaktion</strong>
+									<!-- HTML is produced exclusively by the server-side allowlist sanitizer. -->
+									<!-- eslint-disable-next-line svelte/no-at-html-tags -->
+									<div>{@html usage.interactionHtml}</div>
+								</div>{/if}
+							{#if 'transitionHtml' in usage && usage.transitionHtml}<div class="shared-copy">
+									<strong>Überleitung</strong>
+									<!-- HTML is produced exclusively by the server-side allowlist sanitizer. -->
+									<!-- eslint-disable-next-line svelte/no-at-html-tags -->
+									<div>{@html usage.transitionHtml}</div>
+								</div>{/if}
+							{#if 'researchHtml' in usage && usage.researchHtml}<details>
+									<summary>Recherche</summary>
+									<!-- HTML is produced exclusively by the server-side allowlist sanitizer. -->
+									<!-- eslint-disable-next-line svelte/no-at-html-tags -->
+									<div class="shared-copy">{@html usage.researchHtml}</div>
+								</details>{/if}
+							{#if 'sources' in usage && usage.sources?.length}<details>
+									<summary>Quellen</summary>
+									<ul>
+										{#each usage.sources ?? [] as source (source)}<li>
+												<!-- External source URLs are validated and stored server-side. -->
+												<!-- eslint-disable-next-line svelte/no-navigation-without-resolve -->
+												<a href={source.url} rel="noreferrer">{source.label || source.url}</a>
+											</li>{/each}
+									</ul>
+								</details>{/if}
+							{#if 'tools' in usage && usage.tools?.length}<details>
+									<summary>Werkzeuge</summary>
+									<ul>
+										{#each usage.tools ?? [] as tool (tool)}<li>
+												<strong>{tool.name}</strong>{#if tool.note}
+													· {tool.note}{/if}
+											</li>{/each}
+									</ul>
+								</details>{/if}
+						</article>
+					{/each}
+				</section>
+			{/each}
+		</div>
+	{/if}
+</main>
@@ -0,0 +1,18 @@
+import { error } from '@sveltejs/kit';
+import type { RequestHandler } from './$types';
+import { getSharedMedia, SHARE_SESSION_COOKIE } from '#lib/server/shares.js';
+
+export const GET: RequestHandler = async ({ params, cookies }) => {
+	const media = await getSharedMedia(params.token, cookies.get(SHARE_SESSION_COOKIE), params.id);
+	if (!media) error(404, 'Bild nicht gefunden');
+	return new Response(media.data, {
+		headers: {
+			'Content-Type': media.mimeType,
+			'Content-Length': String(media.byteSize),
+			'Cache-Control': 'private, no-store',
+			'Content-Security-Policy': "default-src 'none'; sandbox",
+			'Cross-Origin-Resource-Policy': 'same-origin',
+			'X-Content-Type-Options': 'nosniff'
+		}
+	});
+};
@@ -75,6 +75,7 @@ function pieceInput(data: FormData): PieceInput {
 		summary: text(data, 'summary'),
 		formatId: text(data, 'formatId') || null,
 		status: text(data, 'status') as EditablePieceStatus,
+		preparationEffort: (text(data, 'preparationEffort') || null) as PieceInput['preparationEffort'],
 		durationSeconds: durationInSeconds(data),
 		intro: text(data, 'intro'),
 		researchText: text(data, 'researchText'),
@@ -347,6 +347,13 @@
 								bind:value={durationMinutes}
 							/></label
 						>
+						<label
+							>Vorbereitungsaufwand<select name="preparationEffort" bind:value={draft.preparationEffort}
+								><option value={null}>Nicht angegeben</option><option value="low">Gering</option><option
+									value="medium">Mittel</option
+								><option value="high">Hoch</option></select
+							></label
+						>
 						<label
 							>Format<select name="formatId" bind:value={draft.formatId}
 								><option value={null}>Ohne Format</option
@@ -542,7 +549,7 @@
 							bind:value={draft.presentationText}
 						/>
 						<div class="presentation-mode-picker" role="group" aria-label="Darstellung">
-							{#each [['text', 'Text'], ['link', 'Linkvorschau'], ['video', 'Video']] as mode (mode[0])}<label
+							{#each [['text', 'Text'], ['image', 'Nur Bild'], ['link', 'Linkvorschau'], ['video', 'Video']] as mode (mode[0])}<label
 									><input
 										type="radio"
 										name="presentationMode"
@@ -1,7 +1,8 @@
 import { randomUUID } from 'node:crypto';
 import { error, fail } from '@sveltejs/kit';
 import type { Actions, PageServerLoad } from './$types';
-import { requireUser } from '#lib/server/auth.js';
+import { requireBarkeeper, requireUser } from '#lib/server/auth.js';
+import { finalizeShow, getCompletionSummary } from '#lib/server/completion.js';
 import {
 	completeCurrent,
 	clearPresentationChannel,
@@ -24,6 +25,8 @@ import {
 	startOrResumeLive
 } from '#lib/server/live.js';
 import { listShows } from '#lib/server/shows.js';
+import { createShare, deleteShare, listShares, updateShare } from '#lib/server/shares.js';
+import { berlinLocalToUtc } from '#lib/server/time.js';

 function text(data: FormData, name: string) {
 	return String(data.get(name) || '');
@@ -70,11 +73,19 @@ function attempt(intent: string, operation: () => unknown) {
 }

 export const load: PageServerLoad = ({ locals, url }) => {
-	requireUser(locals.user);
+	const actor = requireUser(locals.user);
 	const showId = url.searchParams.get('show') || listShows()[0]?.id;
 	if (!showId) error(404, 'Keine Sendung vorhanden');
 	try {
-		return { live: getLiveView(showId), commandId: randomUUID() };
+		const live = getLiveView(showId);
+		return {
+			live,
+			canManageShares: actor.role === 'barkeeper',
+			shares: actor.role === 'barkeeper' ? listShares(actor, showId) : [],
+			commandId: randomUUID(),
+			completion:
+				live.endedAtUtc && live.show.status !== 'completed' ? getCompletionSummary(showId) : null
+		};
 	} catch (cause) {
 		if (cause instanceof Error && cause.message === 'NOT_FOUND')
 			error(404, 'Sendung nicht gefunden');
@@ -83,6 +94,45 @@ export const load: PageServerLoad = ({ locals, url }) => {
 };

 export const actions = {
+	createShare: async ({ locals, request }) => {
+		const actor = requireBarkeeper(locals.user);
+		const data = await request.formData();
+		try {
+			const share = await createShare(actor, {
+				showId: text(data, 'showId'), scope: text(data, 'scope'), password: text(data, 'password'),
+				expiresAtUtc: berlinLocalToUtc(text(data, 'expiresAt'), 'INVALID_EXPIRY')
+			});
+			return { intent: 'createShare', success: 'Leselink angelegt.', shareUrl: `/freigabe/${share.token}` };
+		} catch (cause) {
+			const problem = actionError(cause);
+			return fail(problem.status, { intent: 'createShare', ...problem });
+		}
+	},
+	updateShare: async ({ locals, request }) => {
+		const actor = requireBarkeeper(locals.user);
+		const data = await request.formData();
+		try {
+			await updateShare(actor, text(data, 'shareId'), {
+				scope: text(data, 'scope'), passwordMode: text(data, 'passwordMode'), password: text(data, 'password'),
+				expiresAtUtc: berlinLocalToUtc(text(data, 'expiresAt'), 'INVALID_EXPIRY')
+			}, text(data, 'showId'));
+			return { intent: 'updateShare', success: 'Freigabe aktualisiert.' };
+		} catch (cause) {
+			const problem = actionError(cause);
+			return fail(problem.status, { intent: 'updateShare', ...problem });
+		}
+	},
+	deleteShare: async ({ locals, request }) => {
+		const actor = requireBarkeeper(locals.user);
+		const data = await request.formData();
+		try {
+			deleteShare(actor, text(data, 'shareId'), text(data, 'showId'));
+			return { intent: 'deleteShare', success: 'Freigabe gelöscht.' };
+		} catch (cause) {
+			const problem = actionError(cause);
+			return fail(problem.status, { intent: 'deleteShare', ...problem });
+		}
+	},
 	start: async ({ locals, request }) => {
 		requireUser(locals.user);
 		const data = await request.formData();
@@ -142,6 +192,20 @@ export const actions = {
 			endLive(text(data, 'showId'), text(data, 'commandId'), Number(data.get('revision')))
 		);
 	},
+	finalize: async ({ locals, request }) => {
+		const actor = requireUser(locals.user);
+		const data = await request.formData();
+		return attempt('finalize', () =>
+			finalizeShow({
+				showId: text(data, 'showId'),
+				commandId: text(data, 'commandId'),
+				expectedShowRevision: Number(data.get('showRevision')),
+				expectedLiveRevision: Number(data.get('revision')),
+				archivePieceIds: data.getAll('archivePieceIds').map(String),
+				actor
+			})
+		);
+	},
 	resumeEnded: async ({ locals, request }) => {
 		requireUser(locals.user);
 		const data = await request.formData();
@@ -4,6 +4,7 @@
 	import { onMount, tick, untrack } from 'svelte';
 	import AppIcon from '#lib/components/AppIcon.svelte';
 	import ThemeToggle from '#lib/components/ThemeToggle.svelte';
+	import ShareManagement from '#lib/components/ShareManagement.svelte';
 	import { formatClock, formatDuration } from '#lib/format.js';
 	import type { PageProps } from './$types';

@@ -30,6 +31,7 @@
 	let railCloseButton = $state<HTMLButtonElement>();
 	let liveMenuTrigger = $state<HTMLButtonElement>();
 	let liveMenuPopover = $state<HTMLElement>();
+	let completionDialog = $state<HTMLDialogElement>();
 	let scrollPositions: Record<string, number> = {};
 	let outputWindow: Window | null = null;
 	let allUsages = $derived(data.live.sections.flatMap((section) => section.usages));
@@ -48,6 +50,9 @@
 	let currentSection = $derived(
 		data.live.sections.find((section) => section.id === data.live.current?.sectionId) ?? null
 	);
+	let viewedSection = $derived(
+		data.live.sections.find((section) => section.id === viewedUsage?.sectionId) ?? null
+	);
 	let presentedUsage = $derived(
 		allUsages.find((usage) => usage.id === data.live.presentationUsageId) ?? null
 	);
@@ -100,6 +105,16 @@
 			data.live.sectionTimer.sectionId === data.live.current.sectionId
 		)
 	);
+
+	async function copyTwitchTags() {
+		if (!viewedSection?.twitchTags.length) return;
+		try {
+			await navigator.clipboard.writeText(viewedSection.twitchTags.join(', '));
+			popupMessage = 'Twitch-Tags kopiert.';
+		} catch {
+			popupMessage = 'Kopieren wurde vom Browser blockiert.';
+		}
+	}
 	let runningOffsetSeconds = $derived(
 		data.live.totalTimer.runningSinceUtc ? Math.max(0, Math.floor((now - loadedAt) / 1000)) : 0
 	);
@@ -144,6 +159,10 @@
 		});
 	});

+	$effect(() => {
+		if (!data.completion && completionDialog?.open) completionDialog.close();
+	});
+
 	onMount(() => {
 		const key = `sendewerk-live-${data.live.show.id}`;
 		try {
@@ -572,6 +591,7 @@
 			</section>
 			<section>
 				<strong>Ausgabekanal</strong>
+				{#if data.canManageShares}<ShareManagement shows={[{ ...data.live.show, startsAtUtc: null }]} shares={data.shares} fixedShowId={data.live.show.id} {form} />{/if}
 				<form method="POST" action={liveAction('createOutput')} use:enhance={enhanceOutput}>
 					<input type="hidden" name="showId" value={data.live.show.id} />
 					<button class="secondary-button" type="submit">Ausgabe verbinden und öffnen</button>
@@ -611,34 +631,48 @@
 						>
 					</form>
 				{:else if data.live.endedAtUtc}
-					<form method="POST" action={liveAction('resumeEnded')} use:enhance={enhanceCommand}>
-						<input type="hidden" name="showId" value={data.live.show.id} />
-						<input type="hidden" name="revision" value={data.live.liveRevision} />
-						<input type="hidden" name="commandId" value={data.commandId} />
-						<button class="secondary-button" type="submit"
-							><AppIcon name="play" /> Lauf fortsetzen</button
+					{#if data.live.show.status === 'completed'}
+						<p class="quiet-copy">Diese Sendung ist historisch abgeschlossen und unveränderlich.</p>
+						<a class="secondary-button" href={resolve('/sendungen/[id]', { id: data.live.show.id })}
+							>Historische Sendung öffnen</a
 						>
-					</form>
-					<form
-						method="POST"
-						action={liveAction('startNewRun')}
-						use:enhance={enhanceCommand}
-						onsubmit={(event) => {
-							if (
-								!confirm(
-									'Neuen Durchlauf starten? Fortschritt und Zeitmessungen werden zurückgesetzt.'
+					{:else}
+						<form method="POST" action={liveAction('resumeEnded')} use:enhance={enhanceCommand}>
+							<input type="hidden" name="showId" value={data.live.show.id} />
+							<input type="hidden" name="revision" value={data.live.liveRevision} />
+							<input type="hidden" name="commandId" value={data.commandId} />
+							<button class="secondary-button" type="submit"
+								><AppIcon name="play" /> Lauf fortsetzen</button
+							>
+						</form>
+						<form
+							method="POST"
+							action={liveAction('startNewRun')}
+							use:enhance={enhanceCommand}
+							onsubmit={(event) => {
+								if (
+									!confirm(
+										'Neuen Durchlauf starten? Fortschritt und Zeitmessungen werden zurückgesetzt.'
+									)
 								)
-							)
-								event.preventDefault();
-						}}
-					>
-						<input type="hidden" name="showId" value={data.live.show.id} />
-						<input type="hidden" name="revision" value={data.live.liveRevision} />
-						<input type="hidden" name="commandId" value={data.commandId} />
-						<button class="text-button" type="submit"
-							><AppIcon name="arrow-rotate-left" /> Neuer Durchlauf</button
+									event.preventDefault();
+							}}
 						>
-					</form>
+							<input type="hidden" name="showId" value={data.live.show.id} />
+							<input type="hidden" name="revision" value={data.live.liveRevision} />
+							<input type="hidden" name="commandId" value={data.commandId} />
+							<button class="text-button" type="submit"
+								><AppIcon name="arrow-rotate-left" /> Neuer Durchlauf</button
+							>
+						</form>
+						<button
+							class="primary-button"
+							type="button"
+							onclick={() => completionDialog?.showModal()}
+						>
+							<AppIcon name="box-archive" /> Sendung abschließen
+						</button>
+					{/if}
 				{:else}
 					<form
 						method="POST"
@@ -723,6 +757,49 @@
 		{#if popupMessage}<div class="live-message form-message" role="status">{popupMessage}</div>{/if}
 	</div>

+	<dialog bind:this={completionDialog} class="completion-dialog">
+		<form method="POST" action={liveAction('finalize')} use:enhance={enhanceCommand}>
+			<header>
+				<p class="eyebrow">Unveränderliche Historie</p>
+				<h2>Sendung abschließen</h2>
+			</header>
+			<p>
+				Der aktuelle Ablauf wird dauerhaft eingefroren. Übersprungene Pieces zählen nicht als
+				gesendet.
+			</p>
+			{#if data.completion}
+				<div class="completion-counts">
+					<span><strong>{data.completion.doneCount}</strong> gesendet</span><span
+						><strong>{data.completion.skippedCount}</strong> übersprungen</span
+					><span><strong>{data.completion.openCount}</strong> offen</span>
+				</div>
+				<fieldset>
+					<legend>Originale bewusst in den Fundus-Archivbereich legen</legend>
+					{#each data.completion.candidates as candidate (candidate.pieceId)}<label
+							class="check-row"
+							><input type="checkbox" name="archivePieceIds" value={candidate.pieceId} /><span
+								><strong>{candidate.title}</strong>{#if candidate.usageCount > 1}<small
+										>{candidate.usageCount} gesendete Verwendungen</small
+									>{/if}</span
+							></label
+						>{/each}
+					{#if !data.completion.candidates.length}<p class="quiet-copy">
+							Keine archivierbaren Originale vorhanden.
+						</p>{/if}
+				</fieldset>
+			{/if}
+			<input type="hidden" name="showId" value={data.live.show.id} />
+			<input type="hidden" name="revision" value={data.live.liveRevision} />
+			<input type="hidden" name="showRevision" value={data.live.show.revision} />
+			<input type="hidden" name="commandId" value={data.commandId} />
+			<footer>
+				<button class="text-button" type="button" onclick={() => completionDialog?.close()}
+					>Abbrechen</button
+				><button class="primary-button" type="submit">Historischen Stand abschließen</button>
+			</footer>
+		</form>
+	</dialog>
+
 	<div class="live-workspace">
 		{#if viewedUsage}<article
 				class="live-current"
@@ -732,12 +809,14 @@
 			>
 				<div class="live-current-scroll" bind:this={pieceScroller} onscroll={persistSettings}>
 					<div class="live-piece-heading">
-						<span class="live-piece-position">Piece {viewedPosition}/{data.live.totalCount}</span>
 						<h1 id="current-title">{viewedUsage.title}</h1>
 						{#if showTimes}<strong class="live-piece-time">
 								{formatClock(viewedActualSeconds)} / {formatClock(viewedUsage.durationSeconds)}
 							</strong>{/if}
 					</div>
+					{#if viewedSection?.twitchTags.length}<button class="text-button live-twitch-tags" type="button" onclick={copyTwitchTags}>
+						<AppIcon name="copy" /> {viewedSection.twitchTags.join(' · ')}
+					</button>{/if}

 					{#if viewedUsage.introHtml}<section class="live-script-section live-intro">
 							<span>Einleitung</span>
@@ -3,37 +3,8 @@ import type { Actions, PageServerLoad } from './$types';
 import { berlinDateKey, berlinMonthKey, normalizeMonthKey, shiftMonth } from '#lib/calendar.js';
 import { getShowOverviewView, requireUser, setShowOverviewView } from '#lib/server/auth.js';
 import { createShow, listShows, listShowTemplates } from '#lib/server/shows.js';
-
-function berlinLocalToUtc(value: string): string | null {
-	if (!value) return null;
-	const match = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2})$/.exec(value);
-	if (!match) throw new Error('INVALID_TIMESTAMP');
-	const parts = match.slice(1).map(Number);
-	const localMilliseconds = Date.UTC(parts[0], parts[1] - 1, parts[2], parts[3], parts[4]);
-	let candidate = localMilliseconds;
-	for (let attempt = 0; attempt < 2; attempt += 1) {
-		const formatted = new Intl.DateTimeFormat('en-CA', {
-			timeZone: 'Europe/Berlin',
-			year: 'numeric',
-			month: '2-digit',
-			day: '2-digit',
-			hour: '2-digit',
-			minute: '2-digit',
-			hourCycle: 'h23'
-		}).formatToParts(new Date(candidate));
-		const read = (type: Intl.DateTimeFormatPartTypes) =>
-			Number(formatted.find((part) => part.type === type)?.value);
-		const represented = Date.UTC(
-			read('year'),
-			read('month') - 1,
-			read('day'),
-			read('hour'),
-			read('minute')
-		);
-		candidate += localMilliseconds - represented;
-	}
-	return new Date(candidate).toISOString();
-}
+import { listPieces } from '#lib/server/content.js';
+import { berlinLocalToUtc } from '#lib/server/time.js';

 export const load: PageServerLoad = ({ locals, url }) => {
 	const user = requireUser(locals.user);
@@ -41,7 +12,8 @@ export const load: PageServerLoad = ({ locals, url }) => {
 	const todayMonth = berlinMonthKey(today);
 	const selectedMonth = normalizeMonthKey(url.searchParams.get('month'), todayMonth);
 	return {
-		shows: listShows(),
+		shows: listShows(['draft', 'ready', 'live']),
+		preparationPieces: listPieces({ statuses: ['preparing'] }),
 		templates: listShowTemplates(),
 		view: getShowOverviewView(user.id),
 		selectedMonth,
@@ -125,6 +125,16 @@
 		</form>
 	</details>

+	{#if data.preparationPieces.length}<section class="show-library preparation-overview" aria-labelledby="preparation-title">
+			<header><h2 id="preparation-title">Noch vorzubereiten</h2><span>{data.preparationPieces.length}</span></header>
+			<div class="preparation-list">
+				{#each data.preparationPieces as piece (piece.id)}<a href={resolve('/fundus/[id]', { id: piece.id })}>
+						<span><strong>{piece.title}</strong>{#if piece.summary}<small>{piece.summary}</small>{/if}</span>
+						{#if piece.preparationEffort}<b class={`effort ${piece.preparationEffort}`}>{piece.preparationEffort === 'low' ? 'Gering' : piece.preparationEffort === 'medium' ? 'Mittel' : 'Hoch'}</b>{/if}
+					</a>{/each}
+			</div>
+		</section>{/if}
+
 	<section class="show-library" aria-labelledby="show-library-title">
 		<header>
 			<h2 id="show-library-title">{data.view === 'list' ? 'Geplante Sendungen' : 'Kalender'}</h2>
@@ -1,13 +1,17 @@
 import { randomUUID } from 'node:crypto';
-import { error, fail } from '@sveltejs/kit';
+import { error, fail, redirect } from '@sveltejs/kit';
 import type { Actions, PageServerLoad } from './$types';
-import { requireUser } from '#lib/server/auth.js';
+import { requireBarkeeper, requireUser } from '#lib/server/auth.js';
+import { getHistoricalActualDurations } from '#lib/server/completion.js';
 import { getTaxonomy, listPieces, listPieceTemplates } from '#lib/server/content.js';
+import { createShare, deleteShare, listShares, updateShare } from '#lib/server/shares.js';
+import { berlinLocalToUtc } from '#lib/server/time.js';
 import {
 	addPieceUsage,
 	addShowSection,
 	createAndAddPieceUsage,
 	duplicatePieceUsage,
+	duplicateCompletedShow,
 	getShow,
 	getPieceUsageContexts,
 	movePieceUsage,
@@ -35,32 +39,6 @@ function pieceDurationInSeconds(data: FormData) {
 	return Math.round(Number(data.get('durationMinutes')) * 60);
 }

-function berlinLocalToUtc(value: string): string | null {
-	if (!value) return null;
-	const match = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2})$/.exec(value);
-	if (!match) throw new Error('INVALID_TIMESTAMP');
-	const parts = match.slice(1).map(Number);
-	const localMilliseconds = Date.UTC(parts[0], parts[1] - 1, parts[2], parts[3], parts[4]);
-	let candidate = localMilliseconds;
-	for (let attempt = 0; attempt < 2; attempt += 1) {
-		const formatted = new Intl.DateTimeFormat('en-CA', {
-			timeZone: 'Europe/Berlin',
-			year: 'numeric',
-			month: '2-digit',
-			day: '2-digit',
-			hour: '2-digit',
-			minute: '2-digit',
-			hourCycle: 'h23'
-		}).formatToParts(new Date(candidate));
-		const read = (type: Intl.DateTimeFormatPartTypes) =>
-			Number(formatted.find((part) => part.type === type)?.value);
-		candidate +=
-			localMilliseconds -
-			Date.UTC(read('year'), read('month') - 1, read('day'), read('hour'), read('minute'));
-	}
-	return new Date(candidate).toISOString();
-}
-
 function berlinInput(value: string | null) {
 	if (!value) return '';
 	const parts = new Intl.DateTimeFormat('en-CA', {
@@ -104,6 +82,12 @@ function actionError(cause: unknown) {
 		};
 	if (code === 'INVALID_DURATION')
 		return { status: 400, error: 'Piece-Dauern müssen zwischen 0 und 1.440 Minuten liegen.' };
+	if (code === 'INVALID_PASSWORD')
+		return { status: 400, error: 'Ein Freigabepasswort benötigt mindestens 12 Zeichen.' };
+	if (code === 'INVALID_EXPIRY')
+		return { status: 400, error: 'Der Ablaufzeitpunkt muss in der Zukunft liegen.' };
+	if (code === 'INVALID_SCOPE' || code === 'INVALID_PASSWORD_MODE')
+		return { status: 400, error: 'Die Einstellungen der Freigabe sind ungültig.' };
 	if (code.startsWith('INVALID_'))
 		return { status: 400, error: 'Mindestens ein Feld ist ungültig oder zu lang.' };
 	return { status: 500, error: 'Die Änderung konnte nicht gespeichert werden.' };
@@ -118,9 +102,26 @@ function attempt(intent: string, operation: () => unknown) {
 }

 export const load: PageServerLoad = ({ locals, params, url }) => {
-	requireUser(locals.user);
+	const actor = requireUser(locals.user);
 	const show = getShow(params.id);
 	if (!show) error(404, 'Sendung nicht gefunden');
+	const shares = actor.role === 'barkeeper' ? listShares(actor, show.id) : [];
+	if (show.status === 'completed') {
+		return {
+			show,
+			shares,
+			canManageShares: actor.role === 'barkeeper',
+			historical: true,
+			actualDurations: getHistoricalActualDurations(show.id),
+			duplicateCommandId: randomUUID(),
+			startsAtLocal: berlinInput(show.startsAtUtc),
+			pieces: [],
+			taxonomy: getTaxonomy(),
+			pieceTemplates: [],
+			createCommandId: randomUUID(),
+			filters: { query: '', categoryId: '', includeUsed: false, includePlanned: false }
+		};
+	}
 	const pieces = listPieces({
 		statuses: ['ready'],
 		query: url.searchParams.get('q') ?? '',
@@ -132,6 +133,11 @@ export const load: PageServerLoad = ({ locals, params, url }) => {
 	);
 	return {
 		show,
+		shares,
+		canManageShares: actor.role === 'barkeeper',
+		historical: false,
+		actualDurations: {} as Record<string, number>,
+		duplicateCommandId: randomUUID(),
 		startsAtLocal: berlinInput(show.startsAtUtc),
 		pieces: pieces.map((piece) => ({ ...piece, ...usageContexts[piece.id] })),
 		taxonomy: getTaxonomy(),
@@ -147,6 +153,66 @@ export const load: PageServerLoad = ({ locals, params, url }) => {
 };

 export const actions = {
+	createShare: async ({ locals, params, request }) => {
+		const actor = requireBarkeeper(locals.user);
+		const data = await request.formData();
+		try {
+			const share = await createShare(actor, {
+				showId: params.id,
+				scope: text(data, 'scope'),
+				password: text(data, 'password'),
+				expiresAtUtc: berlinLocalToUtc(text(data, 'expiresAt'), 'INVALID_EXPIRY')
+			});
+			return {
+				intent: 'createShare',
+				success: 'Leselink angelegt. Der Link wird nur jetzt vollständig angezeigt.',
+				shareUrl: `/freigabe/${share.token}`
+			};
+		} catch (cause) {
+			return fail(actionError(cause).status, { intent: 'createShare', ...actionError(cause) });
+		}
+	},
+	updateShare: async ({ locals, params, request }) => {
+		const actor = requireBarkeeper(locals.user);
+		const data = await request.formData();
+		try {
+			await updateShare(
+				actor,
+				text(data, 'shareId'),
+				{
+					scope: text(data, 'scope'),
+					passwordMode: text(data, 'passwordMode'),
+					password: text(data, 'password'),
+					expiresAtUtc: berlinLocalToUtc(text(data, 'expiresAt'), 'INVALID_EXPIRY')
+				},
+				params.id
+			);
+			return { intent: 'updateShare', success: 'Freigabe aktualisiert.' };
+		} catch (cause) {
+			return fail(actionError(cause).status, { intent: 'updateShare', ...actionError(cause) });
+		}
+	},
+	deleteShare: async ({ locals, params, request }) => {
+		const actor = requireBarkeeper(locals.user);
+		const data = await request.formData();
+		try {
+			deleteShare(actor, text(data, 'shareId'), params.id);
+			return { intent: 'deleteShare', success: 'Freigabe gelöscht.' };
+		} catch (cause) {
+			return fail(actionError(cause).status, { intent: 'deleteShare', ...actionError(cause) });
+		}
+	},
+	duplicateShow: async ({ locals, params, request }) => {
+		requireUser(locals.user);
+		const data = await request.formData();
+		try {
+			const duplicate = duplicateCompletedShow(params.id, text(data, 'commandId'));
+			redirect(303, `/sendungen/${duplicate.id}`);
+		} catch (cause) {
+			if (cause && typeof cause === 'object' && 'status' in cause) throw cause;
+			return fail(actionError(cause).status, { intent: 'duplicateShow', ...actionError(cause) });
+		}
+	},
 	saveMetadata: async ({ locals, params, request }) => {
 		requireUser(locals.user);
 		const data = await request.formData();
@@ -167,7 +233,8 @@ export const actions = {
 			addShowSection(params.id, Number(data.get('revision')), {
 				name: text(data, 'name'),
 				categoryId: text(data, 'categoryId') || null,
-				explicitDurationSeconds: nullableDuration(data)
+				explicitDurationSeconds: nullableDuration(data),
+				twitchTags: text(data, 'twitchTags').split(/[\n,]/)
 			})
 		);
 	},
@@ -178,7 +245,8 @@ export const actions = {
 			updateShowSection(params.id, text(data, 'sectionId'), Number(data.get('revision')), {
 				name: text(data, 'name'),
 				categoryId: text(data, 'categoryId') || null,
-				explicitDurationSeconds: nullableDuration(data)
+				explicitDurationSeconds: nullableDuration(data),
+				twitchTags: text(data, 'twitchTags').split(/[\n,]/)
 			})
 		);
 	},
@@ -8,7 +8,16 @@ import {
 	type TaxonomyKind
 } from '#lib/server/content.js';
 import { getMailConfig } from '#lib/server/config.js';
+import { createShare, deleteShare, listShares, updateShare } from '#lib/server/shares.js';
+import { listShows } from '#lib/server/shows.js';
+import { berlinLocalToUtc } from '#lib/server/time.js';
 import { createTool, listTools, updateTool, type ToolInput } from '#lib/server/tools.js';
+import { deleteFeedSource, fetchFeed, listFeedSources, saveFeedSource } from '#lib/server/feeds.js';
+import {
+	createTechnicalAccess,
+	listTechnicalAccesses,
+	revokeTechnicalAccess
+} from '#lib/server/technical-access.js';
 import {
 	inviteUser,
 	isRole,
@@ -28,6 +37,10 @@ export const load: PageServerLoad = ({ locals }) => {
 		users: listUsers(),
 		invitations: listOpenInvitations(),
 		tools: listTools(true),
+		shows: listShows(),
+		shares: listShares(locals.user!),
+		feeds: listFeedSources(),
+		technicalAccesses: listTechnicalAccesses(),
 		mailTransport: getMailConfig().transport
 	};
 };
@@ -50,6 +63,12 @@ function actionError(cause: unknown): string {
 	if (code === 'INVALID_TOOL_FORMAT')
 		return 'Mindestens ein gewähltes Format existiert nicht mehr.';
 	if (code === 'INVALID_TOOL') return 'Bitte die Werkzeugdaten prüfen.';
+	if (code === 'INVALID_PASSWORD') return 'Ein Freigabepasswort benötigt mindestens 12 Zeichen.';
+	if (code === 'INVALID_EXPIRY') return 'Der Ablaufzeitpunkt muss in der Zukunft liegen.';
+	if (code === 'INVALID_SCOPE') return 'Der Informationsumfang ist ungültig.';
+	if (code === 'INVALID_PASSWORD_MODE') return 'Die Passwortoption ist ungültig.';
+	if (code === 'INVALID_FEED') return 'Name, URL und Abrufintervall bitte prüfen.';
+	if (code === 'INVALID_ACCESS') return 'Name und Berechtigung bitte prüfen.';
 	return 'Die Aktion konnte nicht ausgeführt werden.';
 }

@@ -65,6 +84,50 @@ function toolInput(data: FormData): ToolInput {
 }

 export const actions = {
+	createShare: async ({ locals, request }) => {
+		const actor = requireBarkeeper(locals.user);
+		const data = await request.formData();
+		try {
+			const share = await createShare(actor, {
+				showId: String(data.get('showId') || ''),
+				scope: String(data.get('scope') || ''),
+				password: String(data.get('password') || ''),
+				expiresAtUtc: berlinLocalToUtc(String(data.get('expiresAt') || ''), 'INVALID_EXPIRY')
+			});
+			return {
+				intent: 'createShare',
+				success: 'Leselink angelegt. Der Link wird nur jetzt vollständig angezeigt.',
+				shareUrl: `/freigabe/${share.token}`
+			};
+		} catch (cause) {
+			return fail(400, { intent: 'createShare', error: actionError(cause) });
+		}
+	},
+	updateShare: async ({ locals, request }) => {
+		const actor = requireBarkeeper(locals.user);
+		const data = await request.formData();
+		try {
+			await updateShare(actor, String(data.get('shareId') || ''), {
+				scope: String(data.get('scope') || ''),
+				passwordMode: String(data.get('passwordMode') || ''),
+				password: String(data.get('password') || ''),
+				expiresAtUtc: berlinLocalToUtc(String(data.get('expiresAt') || ''), 'INVALID_EXPIRY')
+			});
+			return { intent: 'updateShare', success: 'Freigabe aktualisiert.' };
+		} catch (cause) {
+			return fail(400, { intent: 'updateShare', error: actionError(cause) });
+		}
+	},
+	deleteShare: async ({ locals, request }) => {
+		const actor = requireBarkeeper(locals.user);
+		const data = await request.formData();
+		try {
+			deleteShare(actor, String(data.get('shareId') || ''));
+			return { intent: 'deleteShare', success: 'Freigabe gelöscht.' };
+		} catch (cause) {
+			return fail(400, { intent: 'deleteShare', error: actionError(cause) });
+		}
+	},
 	invite: async ({ locals, request }) => {
 		const actor = requireBarkeeper(locals.user);
 		const data = await request.formData();
@@ -196,5 +259,78 @@ export const actions = {
 		} catch (cause) {
 			return fail(400, { intent: 'tool', error: actionError(cause) });
 		}
+	},
+	saveFeed: async ({ locals, request }) => {
+		requireBarkeeper(locals.user);
+		const data = await request.formData();
+		try {
+			saveFeedSource(String(data.get('feedId') || '') || null, {
+				name: String(data.get('name') || ''),
+				url: String(data.get('url') || ''),
+				isEnabled: data.get('isEnabled') === '1',
+				refreshIntervalMinutes: Number(data.get('refreshIntervalMinutes')),
+				defaultCategoryId: String(data.get('defaultCategoryId') || '') || null
+			});
+			return { intent: 'feed', success: 'Feed gespeichert.' };
+		} catch (cause) {
+			return fail(400, { intent: 'feed', error: actionError(cause) });
+		}
+	},
+	deleteFeed: async ({ locals, request }) => {
+		requireBarkeeper(locals.user);
+		const data = await request.formData();
+		try {
+			deleteFeedSource(String(data.get('feedId') || ''));
+			return { intent: 'feed', success: 'Feed entfernt.' };
+		} catch (cause) {
+			return fail(400, { intent: 'feed', error: actionError(cause) });
+		}
+	},
+	fetchFeed: async ({ locals, request }) => {
+		requireBarkeeper(locals.user);
+		const data = await request.formData();
+		try {
+			const result = await fetchFeed(String(data.get('feedId') || ''));
+			return {
+				intent: 'feed',
+				success: result.unchanged
+					? 'Feed ist unverändert.'
+					: `${result.inserted} neue Beiträge abgerufen.`
+			};
+		} catch {
+			return fail(400, {
+				intent: 'feed',
+				error: 'Feed konnte nicht sicher abgerufen oder gelesen werden.'
+			});
+		}
+	},
+	createTechnicalAccess: async ({ locals, request }) => {
+		const actor = requireBarkeeper(locals.user);
+		const data = await request.formData();
+		try {
+			const created = createTechnicalAccess(
+				actor,
+				String(data.get('name') || ''),
+				String(data.get('permissions') || '')
+			);
+			return {
+				intent: 'technicalAccess',
+				success:
+					'Technischer Zugang angelegt. Token jetzt sicher hinterlegen; es wird nicht erneut angezeigt.',
+				technicalToken: created.token
+			};
+		} catch (cause) {
+			return fail(400, { intent: 'technicalAccess', error: actionError(cause) });
+		}
+	},
+	revokeTechnicalAccess: async ({ locals, request }) => {
+		const actor = requireBarkeeper(locals.user);
+		const data = await request.formData();
+		try {
+			revokeTechnicalAccess(actor, String(data.get('accessId') || ''));
+			return { intent: 'technicalAccess', success: 'Technischer Zugang widerrufen.' };
+		} catch (cause) {
+			return fail(400, { intent: 'technicalAccess', error: actionError(cause) });
+		}
 	}
 } satisfies Actions;
@@ -1,6 +1,8 @@
 <script lang="ts">
+	import { resolve } from '$app/paths';
 	import AppIcon from '#lib/components/AppIcon.svelte';
 	import IconPicker from '#lib/components/IconPicker.svelte';
+	import ShareManagement from '#lib/components/ShareManagement.svelte';
 	import ToolEditorDialog from '#lib/components/ToolEditorDialog.svelte';
 	import type { PageProps } from './$types';
 	let { data, form }: PageProps = $props();
@@ -18,8 +20,189 @@
 		<h1>Verwaltung</h1>
 		<p class="page-intro">Konten, Werkzeuge und bestehende Taxonomie verwalten.</p>
 	</header>
-	{#if form?.error}<div class="form-message error" role="alert">{form.error}</div>{/if}
-	{#if form?.success}<div class="form-message success" role="status">{form.success}</div>{/if}
+	{#if form?.error && !form.intent?.toLowerCase().includes('share')}<div
+			class="form-message error"
+			role="alert"
+		>
+			{form.error}
+		</div>{/if}
+	{#if form?.success && !form.intent?.toLowerCase().includes('share')}<div
+			class="form-message success"
+			role="status"
+		>
+			{form.success}
+		</div>{/if}
+	<ShareManagement shows={data.shows} shares={data.shares} {form} />
+	<section class="quiet-panel integration-panel">
+		<div class="panel-heading">
+			<div>
+				<p class="eyebrow">Import</p>
+				<h2>RSS-Feeds</h2>
+			</div>
+			<span>{data.feeds.length} eingerichtet</span>
+		</div>
+		<p>
+			Aktive Feeds werden im gewählten Intervall abgerufen. Beiträge landen zuerst separat im
+			Eingang.
+		</p>
+		<form class="integration-form" method="POST" action="?/saveFeed">
+			<label>Name<input name="name" required maxlength="120" /></label>
+			<label
+				>Feed-URL<input
+					name="url"
+					type="url"
+					required
+					maxlength="2000"
+					placeholder="https://example.org/feed.xml"
+				/></label
+			>
+			<label
+				>Intervall in Minuten<input
+					name="refreshIntervalMinutes"
+					type="number"
+					min="15"
+					max="10080"
+					value="60"
+					required
+				/></label
+			>
+			<label
+				>Standardkategorie<select name="defaultCategoryId"
+					><option value="">Keine</option
+					>{#each data.taxonomy.categories as category (category.id)}<option value={category.id}
+							>{category.name}</option
+						>{/each}</select
+				></label
+			>
+			<label class="check-row"
+				><input type="checkbox" name="isEnabled" value="1" checked /> Automatisch abrufen</label
+			>
+			<button class="primary-button" type="submit">Feed anlegen</button>
+		</form>
+		<div class="integration-list">
+			{#each data.feeds as feed (feed.id)}
+				<details>
+					<summary
+						><span
+							><strong>{feed.name}</strong><small
+								>{feed.lastError
+									? `Fehler: ${feed.lastError}`
+									: feed.lastFetchedAtUtc
+										? `Zuletzt: ${new Date(feed.lastFetchedAtUtc).toLocaleString('de-DE')}`
+										: 'Noch nicht abgerufen'}</small
+							></span
+						><AppIcon name="pen" /></summary
+					>
+					<form class="integration-form" method="POST" action="?/saveFeed">
+						<input type="hidden" name="feedId" value={feed.id} />
+						<label>Name<input name="name" required maxlength="120" value={feed.name} /></label>
+						<label
+							>Feed-URL<input
+								name="url"
+								type="url"
+								required
+								maxlength="2000"
+								value={feed.url}
+							/></label
+						>
+						<label
+							>Intervall in Minuten<input
+								name="refreshIntervalMinutes"
+								type="number"
+								min="15"
+								max="10080"
+								value={feed.refreshIntervalMinutes}
+								required
+							/></label
+						>
+						<label
+							>Standardkategorie<select name="defaultCategoryId"
+								><option value="">Keine</option
+								>{#each data.taxonomy.categories as category (category.id)}<option
+										value={category.id}
+										selected={feed.defaultCategoryId === category.id}>{category.name}</option
+									>{/each}</select
+							></label
+						>
+						<label class="check-row"
+							><input type="checkbox" name="isEnabled" value="1" checked={feed.isEnabled} /> Automatisch
+							abrufen</label
+						>
+						<button class="secondary-button" type="submit">Speichern</button>
+					</form>
+					<div class="row-actions">
+						<form method="POST" action="?/fetchFeed">
+							<input type="hidden" name="feedId" value={feed.id} /><button
+								class="text-button"
+								type="submit">Jetzt abrufen</button
+							>
+						</form>
+						<form
+							method="POST"
+							action="?/deleteFeed"
+							onsubmit={(event) =>
+								!confirm('Feed und seinen Importeingang löschen?') && event.preventDefault()}
+						>
+							<input type="hidden" name="feedId" value={feed.id} /><button
+								class="text-button danger-text"
+								type="submit">Feed löschen</button
+							>
+						</form>
+					</div>
+				</details>
+			{/each}
+		</div>
+	</section>
+
+	<section class="quiet-panel integration-panel">
+		<div class="panel-heading">
+			<div>
+				<p class="eyebrow">Externe Assistenz</p>
+				<h2>Technische Zugänge</h2>
+			</div>
+			<a href={resolve('/api/v1/openapi.json')} target="_blank">OpenAPI</a>
+		</div>
+		<p>
+			Tokens gelten ausschließlich für die API. Schreibende Aufrufe werden protokolliert und müssen
+			idempotent sein.
+		</p>
+		{#if form?.technicalToken}<div class="token-reveal" role="status">
+				<strong>Token, einmalig sichtbar</strong><code>{form.technicalToken}</code>
+			</div>{/if}
+		<form class="integration-form" method="POST" action="?/createTechnicalAccess">
+			<label
+				>Name<input name="name" required maxlength="120" placeholder="Redaktionsassistenz" /></label
+			>
+			<label
+				>Berechtigung<select name="permissions"
+					><option value="read">Nur lesen</option><option value="read_write"
+						>Lesen und schreiben</option
+					></select
+				></label
+			>
+			<button class="primary-button" type="submit">Zugang anlegen</button>
+		</form>
+		<div class="integration-list">
+			{#each data.technicalAccesses as access (access.id)}
+				<div class="access-row">
+					<span
+						><strong>{access.name}</strong><small
+							>{access.permissions === 'read' ? 'Nur lesen' : 'Lesen und schreiben'} · {access.revokedAtUtc
+								? 'Widerrufen'
+								: access.lastUsedAtUtc
+									? `Zuletzt genutzt ${new Date(access.lastUsedAtUtc).toLocaleString('de-DE')}`
+									: 'Noch nicht genutzt'}</small
+						></span
+					>{#if !access.revokedAtUtc}<form method="POST" action="?/revokeTechnicalAccess">
+							<input type="hidden" name="accessId" value={access.id} /><button
+								class="secondary-button"
+								type="submit">Widerrufen</button
+							>
+						</form>{/if}
+				</div>
+			{/each}
+		</div>
+	</section>

 	<section class="quiet-panel account-panel">
 		<div class="panel-heading">
@@ -260,3 +443,67 @@
 		</section>
 	</div>
 </div>
+
+<style>
+	.integration-panel {
+		display: grid;
+		gap: 1rem;
+		margin-block: 1.5rem;
+	}
+	.integration-form {
+		display: grid;
+		grid-template-columns: repeat(auto-fit, minmax(12rem, 1fr));
+		gap: 0.8rem;
+		align-items: end;
+	}
+	.integration-form label:not(.check-row) {
+		display: grid;
+		gap: 0.35rem;
+	}
+	.check-row {
+		display: flex;
+		gap: 0.5rem;
+		align-items: center;
+		min-height: 2.6rem;
+	}
+	.integration-list {
+		display: grid;
+		gap: 0.5rem;
+	}
+	.integration-list details,
+	.access-row {
+		border-top: 1px solid var(--color-border);
+		padding-top: 0.8rem;
+	}
+	.integration-list summary,
+	.access-row {
+		display: flex;
+		justify-content: space-between;
+		gap: 1rem;
+		align-items: center;
+	}
+	.integration-list summary > span,
+	.access-row > span {
+		display: grid;
+		gap: 0.2rem;
+	}
+	.integration-list small {
+		color: var(--color-text-muted);
+	}
+	.row-actions {
+		display: flex;
+		gap: 1rem;
+		margin-top: 0.75rem;
+	}
+	.token-reveal {
+		display: grid;
+		gap: 0.4rem;
+		padding: 0.8rem;
+		border: 2px solid var(--color-accent);
+		border-radius: 0.7rem;
+		overflow-wrap: anywhere;
+	}
+	.token-reveal code {
+		user-select: all;
+	}
+</style>
@@ -1,6 +1,6 @@
 import { expect, test, type Locator, type Page } from '@playwright/test';
 import Database from 'better-sqlite3';
-import { readFileSync, readdirSync } from 'node:fs';
+import { mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from 'node:fs';
 import path from 'node:path';

 const adminEmail = 'barkeeper@example.test';
@@ -85,7 +85,8 @@ function addSentHistoryFixture(pieceId: string) {
 	database.pragma('foreign_keys = ON');
 	const insertShow = database.prepare(
 		`INSERT INTO shows (id, title, starts_at_utc, twitch_title, announcement_text, status,
-		 revision, created_at_utc, updated_at_utc) VALUES (?, ?, ?, '', '', 'completed', 1, ?, ?)`
+		 revision, created_at_utc, updated_at_utc, completed_at_utc)
+		 VALUES (?, ?, ?, '', '', 'completed', 1, ?, ?, ?)`
 	);
 	const insertSection = database.prepare(
 		`INSERT INTO show_sections (id, show_id, name, category_id, position,
@@ -104,9 +105,24 @@ function addSentHistoryFixture(pieceId: string) {
 		] as const) {
 			const showId = `e2e-history-${suffix}`;
 			const sectionId = `e2e-history-section-${suffix}`;
-			insertShow.run(showId, title, date, date, date);
+			insertShow.run(showId, title, date, date, date, date);
 			insertSection.run(sectionId, showId);
-			insertUsage.run(`e2e-history-usage-${suffix}`, sectionId, pieceId);
+			const usageId = `e2e-history-usage-${suffix}`;
+			insertUsage.run(usageId, sectionId, pieceId);
+			database
+				.prepare(
+					`INSERT INTO show_finalizations
+					 (show_id, command_id, source_revision, finalized_at_utc) VALUES (?, ?, 1, ?)`
+				)
+				.run(showId, `fixture-${suffix}`, date);
+			database
+				.prepare(
+					`INSERT INTO piece_usage_history
+					 (usage_id, show_id, original_piece_id, show_title_snapshot,
+					 usage_title_snapshot, used_at_utc, actual_duration_seconds)
+					 VALUES (?, ?, ?, ?, 'Historische Verwendung', ?, 300)`
+				)
+				.run(usageId, showId, pieceId, title, date);
 		}
 	})();
 	database.close();
@@ -117,10 +133,120 @@ function removeSentHistoryFixture() {
 	if (!dataDirectory) return;
 	const database = new Database(path.join(dataDirectory, 'e2e.sqlite'));
 	database.pragma('foreign_keys = ON');
+	database.prepare("DELETE FROM piece_usage_history WHERE show_id LIKE 'e2e-history-%'").run();
 	database.prepare("DELETE FROM shows WHERE id LIKE 'e2e-history-%'").run();
 	database.close();
 }

+function addCompletionFixture() {
+	const dataDirectory = process.env.SENDEWERK_E2E_DATA_DIR;
+	if (!dataDirectory) throw new Error('E2E-Datenverzeichnis ist nicht konfiguriert.');
+	const database = new Database(path.join(dataDirectory, 'e2e.sqlite'));
+	database.pragma('foreign_keys = ON');
+	const now = '2026-10-25T19:00:00.000Z';
+	const png = Buffer.from(
+		'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk+A8AAQUBAScY42YAAAAASUVORK5CYII=',
+		'base64'
+	);
+	mkdirSync(path.join(dataDirectory, 'uploads'), { recursive: true });
+	writeFileSync(path.join(dataDirectory, 'uploads', 'e2e-share.png'), png);
+	database.transaction(() => {
+		database
+			.prepare(
+				`INSERT INTO shows (id, title, starts_at_utc, twitch_title, announcement_text, status,
+				 revision, created_at_utc, updated_at_utc)
+				 VALUES ('e2e-completion', 'E2E Abschluss', ?, '', '', 'live', 1, ?, ?)`
+			)
+			.run(now, now, now);
+		database
+			.prepare(
+				`INSERT INTO show_sections (id, show_id, name, category_id, position,
+				 explicit_duration_seconds, is_reserve_bank) VALUES
+				 ('e2e-completion-section', 'e2e-completion', 'Finaler Ablauf', NULL, 0, NULL, 0),
+				 ('e2e-completion-reserve', 'e2e-completion', 'Reservebank', NULL, 1, NULL, 1)`
+			)
+			.run();
+		const insertUsage = database.prepare(
+			`INSERT INTO piece_usages (id, show_section_id, original_piece_id, position, status,
+			 duration_seconds, title_snapshot, intro_snapshot, research_snapshot, moderation_snapshot,
+			 interaction_snapshot, transition_snapshot, presentation_snapshot, own_notes, is_reserve)
+			 VALUES (?, 'e2e-completion-section', ?, ?, ?, 300, ?, ?, ?, ?, ?, ?, '', ?, 0)`
+		);
+		insertUsage.run(
+			'e2e-completion-done',
+			'piece-console',
+			0,
+			'done',
+			'Gesendeter Abschlussbeitrag',
+			'FREIGABE_EINLEITUNG',
+			'PRIVATE_FREIGABE_RECHERCHE',
+			'FREIGABE_MODERATION',
+			'FREIGABE_INTERAKTION',
+			'FREIGABE_UEBERLEITUNG',
+			'PRIVATE_FREIGABE_NOTIZ'
+		);
+		insertUsage.run(
+			'e2e-completion-skipped',
+			'piece-effects',
+			1,
+			'skipped',
+			'Übersprungener Abschlussbeitrag',
+			'',
+			'PRIVATE_SKIPPED_RESEARCH',
+			'',
+			'',
+			'',
+			''
+		);
+		database
+			.prepare(
+				`INSERT INTO show_live_states
+				 (show_id, revision, started_at_utc, ended_at_utc, presentation_revision, updated_at_utc)
+				 VALUES ('e2e-completion', 0, ?, ?, 0, ?)`
+			)
+			.run('2026-10-25T18:00:00.000Z', now, now);
+		database
+			.prepare(
+				`INSERT INTO piece_media
+				 (id, piece_id, storage_name, original_name, mime_type, byte_size, alt_text, position, created_at_utc)
+				 VALUES ('e2e-share-media', 'piece-console', 'e2e-share.png', 'intern.png',
+				 'image/png', ?, 'Freigegebenes Abschlussbild', 77, ?)`
+			)
+			.run(png.byteLength, now);
+		database
+			.prepare(
+				`INSERT INTO usage_media_snapshots
+				 (id, usage_id, original_media_id, alt_text, position, is_presentation)
+				 VALUES ('e2e-share-snapshot', 'e2e-completion-done', 'e2e-share-media',
+				 'Freigegebenes Abschlussbild', 0, 1)`
+			)
+			.run();
+	})();
+	database.close();
+}
+
+function removeCompletionFixture() {
+	const dataDirectory = process.env.SENDEWERK_E2E_DATA_DIR;
+	if (!dataDirectory) return;
+	const database = new Database(path.join(dataDirectory, 'e2e.sqlite'));
+	database.pragma('foreign_keys = ON');
+	database.transaction(() => {
+		database
+			.prepare(
+				`DELETE FROM show_share_sessions WHERE share_id IN (
+				 SELECT id FROM show_shares WHERE show_id = 'e2e-completion'
+				 )`
+			)
+			.run();
+		database.prepare("DELETE FROM show_shares WHERE show_id = 'e2e-completion'").run();
+		database.prepare("DELETE FROM piece_usage_history WHERE show_id = 'e2e-completion'").run();
+		database.prepare("DELETE FROM shows WHERE id = 'e2e-completion'").run();
+		database.prepare("DELETE FROM piece_media WHERE id = 'e2e-share-media'").run();
+	})();
+	database.close();
+	rmSync(path.join(dataDirectory, 'uploads', 'e2e-share.png'), { force: true });
+}
+
 function addPresentationFixture() {
 	const dataDirectory = process.env.SENDEWERK_E2E_DATA_DIR;
 	if (!dataDirectory) throw new Error('E2E-Datenverzeichnis ist nicht konfiguriert.');
@@ -204,10 +330,10 @@ function addCalendarFixture() {
 		`INSERT INTO shows (id, title, starts_at_utc, twitch_title, announcement_text, status,
 		 revision, created_at_utc, updated_at_utc) VALUES (?, ?, ?, '', '', 'draft', 1, ?, ?)`
 	);
-	const now = '2026-10-24T10:00:00.000Z';
+	const now = '2026-10-25T10:00:00.000Z';
 	database.transaction(() => {
-		insert.run('e2e-calendar-late', 'Kalender Spättermin', '2026-10-24T18:00:00.000Z', now, now);
-		insert.run('e2e-calendar-early', 'Kalender Frühtermin', '2026-10-24T08:00:00.000Z', now, now);
+		insert.run('e2e-calendar-late', 'Kalender Spättermin', '2026-10-25T18:00:00.000Z', now, now);
+		insert.run('e2e-calendar-early', 'Kalender Frühtermin', '2026-10-25T09:00:00.000Z', now, now);
 		insert.run(
 			'e2e-calendar-next',
 			'Kalender Novembertermin',
@@ -1532,6 +1658,163 @@ test('live control persists state and exposes only explicit presentation data',
 	await expectNoHorizontalOverflow(page);
 });

+test('completion, archive and protected guest sharing work end to end', async ({
+	page,
+	browser
+}, testInfo) => {
+	addCompletionFixture();
+	try {
+		await page.goto('/sendungen/e2e-completion');
+		await page.getByRole('button', { name: 'Lesefreigaben' }).click();
+		const planningShares = page.locator('.share-management');
+		await expect(planningShares.getByText('Aktualisiert sich bis zum Abschluss')).toBeVisible();
+		await planningShares.getByLabel('Informationsumfang').selectOption('moderation');
+		await planningShares.getByRole('button', { name: 'Leselink anlegen' }).click();
+		const planningSharePath = await planningShares.locator('.share-result a').getAttribute('href');
+		expect(planningSharePath).toMatch(/^\/freigabe\//);
+		await page.screenshot({
+			path: testInfo.outputPath('share-editor-desktop.png'),
+			fullPage: true
+		});
+		await page.setViewportSize({ width: 390, height: 844 });
+		await expectNoHorizontalOverflow(page);
+		await page.screenshot({ path: testInfo.outputPath('share-editor-mobile.png'), fullPage: true });
+		await page.setViewportSize({ width: 1280, height: 900 });
+		const planningGuest = await browser.newContext();
+		const planningGuestPage = await planningGuest.newPage();
+		await planningGuestPage.goto(planningSharePath!);
+		await expect(planningGuestPage.getByText('Aktuelle Sendungsplanung · Nur lesen')).toBeVisible();
+		await expect(planningGuestPage.getByText('Gesendeter Abschlussbeitrag')).toBeVisible();
+		await expect(planningGuestPage.getByText('FREIGABE_MODERATION')).toBeVisible();
+		const guestThemePreference = await planningGuestPage
+			.locator('html')
+			.getAttribute('data-theme-preference');
+		await planningGuestPage.getByRole('button', { name: /Darstellung:/ }).click();
+		await expect(planningGuestPage.locator('html')).not.toHaveAttribute(
+			'data-theme-preference',
+			guestThemePreference!
+		);
+
+		const planningShareRow = planningShares.locator('.share-row').first();
+		await planningShareRow.locator('summary').getByText('Ablauf und Moderation').click();
+		await planningShareRow.getByLabel('Informationsumfang').selectOption('research');
+		await planningShareRow.locator('select[name="passwordMode"]').selectOption('replace');
+		await planningShareRow.locator('input[name="password"]').fill('Planung-Freigabe-Passwort');
+		await planningShareRow.getByRole('button', { name: 'Freigabe speichern' }).click();
+		await planningGuestPage.reload();
+		await expect(
+			planningGuestPage.getByRole('heading', { name: 'Passwort erforderlich' })
+		).toBeVisible();
+
+		page.once('dialog', (dialog) => dialog.accept());
+		await planningShares
+			.locator('.share-row')
+			.first()
+			.locator('summary')
+			.getByText('Vollständig mit Recherche')
+			.click();
+		await planningShares.getByRole('button', { name: 'Freigabe löschen' }).click();
+		await planningGuestPage.reload();
+		await expect(planningGuestPage.getByRole('heading', { name: 'Nicht verfügbar' })).toBeVisible();
+		await planningGuest.close();
+
+		await page.goto('/live?show=e2e-completion');
+		await page.getByRole('button', { name: 'Menü', exact: true }).click();
+		await page.getByRole('button', { name: 'Sendung abschließen' }).click();
+		const completion = page.locator('.completion-dialog');
+		await expect(completion).toBeVisible();
+		await expect(completion).toContainText('1 gesendet');
+		await expect(completion).toContainText('1 übersprungen');
+		await expect(completion.getByText('Die kleine Konsole mit dem großen Dreh')).toBeVisible();
+		await expect(completion.getByText('Warum praktische Effekte wieder auffallen')).toHaveCount(0);
+		await completion.getByRole('button', { name: 'Historischen Stand abschließen' }).click();
+		await expect(completion).toBeHidden();
+
+		await page.goto('/archiv');
+		await expect(page.getByRole('link', { name: 'E2E Abschluss' })).toBeVisible();
+		await page.getByRole('link', { name: 'E2E Abschluss' }).click();
+		await expect(page.getByText('Unveränderliche Sendungshistorie')).toBeVisible();
+		await expect(page.getByText('Gesendeter Abschlussbeitrag')).toBeVisible();
+		await expect(page.getByText('Übersprungener Abschlussbeitrag')).toBeVisible();
+		await expect(page.getByRole('button', { name: 'Sendungsdaten speichern' })).toHaveCount(0);
+
+		await page.goto('/verwaltung');
+		await page.getByRole('button', { name: 'Lesefreigaben' }).click();
+		const shareManagement = page.locator('.share-management');
+		await shareManagement.getByLabel('Sendung').selectOption('e2e-completion');
+		await shareManagement.getByLabel('Informationsumfang').selectOption('moderation');
+		await shareManagement.getByLabel('Optionales Passwort').fill('E2E-Freigabe-Passwort');
+		await shareManagement.getByRole('button', { name: 'Leselink anlegen' }).click();
+		const shareLink = page.locator('.share-result a');
+		await expect(shareLink).toBeVisible();
+		const sharePath = await shareLink.getAttribute('href');
+		expect(sharePath).toMatch(/^\/freigabe\//);
+		await page.screenshot({ path: testInfo.outputPath('share-admin-desktop.png'), fullPage: true });
+
+		const guest = await browser.newContext();
+		const guestPage = await guest.newPage();
+		await guestPage.goto(sharePath!);
+		await expect(guestPage.getByRole('heading', { name: 'Passwort erforderlich' })).toBeVisible();
+		const passwordHtml = await guestPage.content();
+		expect(passwordHtml).not.toContain('password_hash');
+		expect(passwordHtml).not.toContain('e2e-completion');
+		await guestPage.getByLabel('Passwort').fill('falsch');
+		await guestPage.getByRole('button', { name: 'Sendung öffnen' }).click();
+		await expect(guestPage.getByRole('alert')).toContainText('Passwort falsch');
+		await guestPage.getByLabel('Passwort').fill('E2E-Freigabe-Passwort');
+		await guestPage.getByRole('button', { name: 'Sendung öffnen' }).click();
+		await expect(guestPage.getByRole('heading', { name: 'E2E Abschluss' })).toBeVisible();
+		await expect(guestPage.getByText('FREIGABE_MODERATION')).toBeVisible();
+		await expect(guestPage.getByText('PRIVATE_FREIGABE_RECHERCHE')).toHaveCount(0);
+		await expect(guestPage.getByText('PRIVATE_FREIGABE_NOTIZ')).toHaveCount(0);
+		await expect(guestPage.getByAltText('Freigegebenes Abschlussbild')).toBeVisible();
+		await guestPage.setViewportSize({ width: 390, height: 844 });
+		await expectNoHorizontalOverflow(guestPage);
+		await guestPage.screenshot({ path: testInfo.outputPath('share-mobile.png'), fullPage: true });
+
+		const imagePath = await guestPage
+			.getByAltText('Freigegebenes Abschlussbild')
+			.getAttribute('src');
+		const sharedImage = await guest.request.get(imagePath!);
+		expect(sharedImage.status()).toBe(200);
+		expect(sharedImage.headers()['content-security-policy']).toBe("default-src 'none'; sandbox");
+		expect((await guest.request.get(`${sharePath}/media/foreign-id`)).status()).toBe(404);
+		const guestWrite = await guest.request.post('/sendungen/e2e-completion?/saveMetadata', {
+			maxRedirects: 0,
+			form: { title: 'Verboten', revision: '2', status: 'draft' }
+		});
+		expect(guestWrite.status()).toBe(403);
+
+		await page.goto('/verwaltung');
+		const showCard = page.locator('.share-show-card').filter({ hasText: 'E2E Abschluss' });
+		await expect(showCard.getByText('Abgeschlossen')).toBeVisible();
+		const shareRow = showCard.locator('.share-row').first();
+		await shareRow.locator('summary').getByText('Ablauf und Moderation').click();
+		await shareRow.getByLabel('Informationsumfang').selectOption('rundown');
+		await shareRow.locator('select[name="passwordMode"]').selectOption('remove');
+		await shareRow.getByRole('button', { name: 'Freigabe speichern' }).click();
+		await guestPage.reload();
+		await expect(guestPage.getByRole('heading', { name: 'E2E Abschluss' })).toBeVisible();
+		await expect(guestPage.getByText('FREIGABE_MODERATION')).toHaveCount(0);
+
+		page.once('dialog', (dialog) => dialog.accept());
+		const updatedCard = page.locator('.share-show-card').filter({ hasText: 'E2E Abschluss' });
+		await updatedCard
+			.locator('.share-row')
+			.first()
+			.locator('summary')
+			.getByText('Nur Ablauf')
+			.click();
+		await updatedCard.getByRole('button', { name: 'Freigabe löschen' }).click();
+		await guestPage.reload();
+		await expect(guestPage.getByRole('heading', { name: 'Nicht verfügbar' })).toBeVisible();
+		expect((await guest.request.get(imagePath!)).status()).toBe(404);
+		await guest.close();
+	} finally {
+		removeCompletionFixture();
+	}
+});
+
 test('pieces autosave safely, detect conflicts and protect uploaded images', async ({
 	page,
 	browser
Author	SHA1	Message	Date
hnzio	6d96900d81	Release 0.7.0	2026-10-25 18:40:01 +01:00
hnzio	d586fbd8ce	Release 0.6.1	2026-10-25 18:18:23 +01:00
hnzio	b80dded55d	Release 0.6.0	2026-10-25 09:45:31 +01:00